+
+ +
+
+
+
+
+ +
+
+ 
+ 
+ 
+ 
+
Run your *raw* PyTorch training script on any kind of device + + +
+
+ The Real First Universal Charset Detector
+
+ 
+
+
+ 
+
+
+ Featured Packages
+
+ 
+ In other language (unofficial port - by the community)
+
+ 
+ >>>>> 👉 Try Me Online Now, Then Adopt Me 👈 <<<<< +
+ +This project offers you an alternative to **Universal Charset Encoding Detector**, also known as **Chardet**. + +| Feature | [Chardet](https://github.com/chardet/chardet) | Charset Normalizer | [cChardet](https://github.com/PyYoshi/cChardet) | +|--------------------------------------------------|:---------------------------------------------:|:--------------------------------------------------------------------------------------------------:|:-----------------------------------------------:| +| `Fast` | ❌ | ✅ | ✅ | +| `Universal**` | ❌ | ✅ | ❌ | +| `Reliable` **without** distinguishable standards | ❌ | ✅ | ✅ | +| `Reliable` **with** distinguishable standards | ✅ | ✅ | ✅ | +| `License` | LGPL-2.1
+
+
+
+ increases the precision n bits, executes , and then
+ restores the precision.
+
+ extraprec(n)(f) returns a decorated version of the function f
+ that increases the working precision by n bits before execution,
+ and restores the parent precision afterwards. With
+ normalize_output=True, it rounds the return value to the parent
+ precision.
+ """
+ return PrecisionManager(ctx, lambda p: p + n, None, normalize_output)
+
+ def extradps(ctx, n, normalize_output=False):
+ """
+ This function is analogous to extraprec (see documentation)
+ but changes the decimal precision instead of the number of bits.
+ """
+ return PrecisionManager(ctx, None, lambda d: d + n, normalize_output)
+
+ def workprec(ctx, n, normalize_output=False):
+ """
+ The block
+
+ with workprec(n):
+
+
+ sets the precision to n bits, executes , and then restores
+ the precision.
+
+ workprec(n)(f) returns a decorated version of the function f
+ that sets the precision to n bits before execution,
+ and restores the precision afterwards. With normalize_output=True,
+ it rounds the return value to the parent precision.
+ """
+ return PrecisionManager(ctx, lambda p: n, None, normalize_output)
+
+ def workdps(ctx, n, normalize_output=False):
+ """
+ This function is analogous to workprec (see documentation)
+ but changes the decimal precision instead of the number of bits.
+ """
+ return PrecisionManager(ctx, None, lambda d: n, normalize_output)
+
+ def autoprec(ctx, f, maxprec=None, catch=(), verbose=False):
+ r"""
+ Return a wrapped copy of *f* that repeatedly evaluates *f*
+ with increasing precision until the result converges to the
+ full precision used at the point of the call.
+
+ This heuristically protects against rounding errors, at the cost of
+ roughly a 2x slowdown compared to manually setting the optimal
+ precision. This method can, however, easily be fooled if the results
+ from *f* depend "discontinuously" on the precision, for instance
+ if catastrophic cancellation can occur. Therefore, :func:`~mpmath.autoprec`
+ should be used judiciously.
+
+ **Examples**
+
+ Many functions are sensitive to perturbations of the input arguments.
+ If the arguments are decimal numbers, they may have to be converted
+ to binary at a much higher precision. If the amount of required
+ extra precision is unknown, :func:`~mpmath.autoprec` is convenient::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15
+ >>> mp.pretty = True
+ >>> besselj(5, 125 * 10**28) # Exact input
+ -8.03284785591801e-17
+ >>> besselj(5, '1.25e30') # Bad
+ 7.12954868316652e-16
+ >>> autoprec(besselj)(5, '1.25e30') # Good
+ -8.03284785591801e-17
+
+ The following fails to converge because `\sin(\pi) = 0` whereas all
+ finite-precision approximations of `\pi` give nonzero values::
+
+ >>> autoprec(sin)(pi) # doctest: +IGNORE_EXCEPTION_DETAIL
+ Traceback (most recent call last):
+ ...
+ NoConvergence: autoprec: prec increased to 2910 without convergence
+
+ As the following example shows, :func:`~mpmath.autoprec` can protect against
+ cancellation, but is fooled by too severe cancellation::
+
+ >>> x = 1e-10
+ >>> exp(x)-1; expm1(x); autoprec(lambda t: exp(t)-1)(x)
+ 1.00000008274037e-10
+ 1.00000000005e-10
+ 1.00000000005e-10
+ >>> x = 1e-50
+ >>> exp(x)-1; expm1(x); autoprec(lambda t: exp(t)-1)(x)
+ 0.0
+ 1.0e-50
+ 0.0
+
+ With *catch*, an exception or list of exceptions to intercept
+ may be specified. The raised exception is interpreted
+ as signaling insufficient precision. This permits, for example,
+ evaluating a function where a too low precision results in a
+ division by zero::
+
+ >>> f = lambda x: 1/(exp(x)-1)
+ >>> f(1e-30)
+ Traceback (most recent call last):
+ ...
+ ZeroDivisionError
+ >>> autoprec(f, catch=ZeroDivisionError)(1e-30)
+ 1.0e+30
+
+
+ """
+ def f_autoprec_wrapped(*args, **kwargs):
+ prec = ctx.prec
+ if maxprec is None:
+ maxprec2 = ctx._default_hyper_maxprec(prec)
+ else:
+ maxprec2 = maxprec
+ try:
+ ctx.prec = prec + 10
+ try:
+ v1 = f(*args, **kwargs)
+ except catch:
+ v1 = ctx.nan
+ prec2 = prec + 20
+ while 1:
+ ctx.prec = prec2
+ try:
+ v2 = f(*args, **kwargs)
+ except catch:
+ v2 = ctx.nan
+ if v1 == v2:
+ break
+ err = ctx.mag(v2-v1) - ctx.mag(v2)
+ if err < (-prec):
+ break
+ if verbose:
+ print("autoprec: target=%s, prec=%s, accuracy=%s" \
+ % (prec, prec2, -err))
+ v1 = v2
+ if prec2 >= maxprec2:
+ raise ctx.NoConvergence(\
+ "autoprec: prec increased to %i without convergence"\
+ % prec2)
+ prec2 += int(prec2*2)
+ prec2 = min(prec2, maxprec2)
+ finally:
+ ctx.prec = prec
+ return +v2
+ return f_autoprec_wrapped
+
+ def nstr(ctx, x, n=6, **kwargs):
+ """
+ Convert an ``mpf`` or ``mpc`` to a decimal string literal with *n*
+ significant digits. The small default value for *n* is chosen to
+ make this function useful for printing collections of numbers
+ (lists, matrices, etc).
+
+ If *x* is a list or tuple, :func:`~mpmath.nstr` is applied recursively
+ to each element. For unrecognized classes, :func:`~mpmath.nstr`
+ simply returns ``str(x)``.
+
+ The companion function :func:`~mpmath.nprint` prints the result
+ instead of returning it.
+
+ The keyword arguments *strip_zeros*, *min_fixed*, *max_fixed*
+ and *show_zero_exponent* are forwarded to :func:`~mpmath.libmp.to_str`.
+
+ The number will be printed in fixed-point format if the position
+ of the leading digit is strictly between min_fixed
+ (default = min(-dps/3,-5)) and max_fixed (default = dps).
+
+ To force fixed-point format always, set min_fixed = -inf,
+ max_fixed = +inf. To force floating-point format, set
+ min_fixed >= max_fixed.
+
+ >>> from mpmath import *
+ >>> nstr([+pi, ldexp(1,-500)])
+ '[3.14159, 3.05494e-151]'
+ >>> nprint([+pi, ldexp(1,-500)])
+ [3.14159, 3.05494e-151]
+ >>> nstr(mpf("5e-10"), 5)
+ '5.0e-10'
+ >>> nstr(mpf("5e-10"), 5, strip_zeros=False)
+ '5.0000e-10'
+ >>> nstr(mpf("5e-10"), 5, strip_zeros=False, min_fixed=-11)
+ '0.00000000050000'
+ >>> nstr(mpf(0), 5, show_zero_exponent=True)
+ '0.0e+0'
+
+ """
+ if isinstance(x, list):
+ return "[%s]" % (", ".join(ctx.nstr(c, n, **kwargs) for c in x))
+ if isinstance(x, tuple):
+ return "(%s)" % (", ".join(ctx.nstr(c, n, **kwargs) for c in x))
+ if hasattr(x, '_mpf_'):
+ return to_str(x._mpf_, n, **kwargs)
+ if hasattr(x, '_mpc_'):
+ return "(" + mpc_to_str(x._mpc_, n, **kwargs) + ")"
+ if isinstance(x, basestring):
+ return repr(x)
+ if isinstance(x, ctx.matrix):
+ return x.__nstr__(n, **kwargs)
+ return str(x)
+
+ def _convert_fallback(ctx, x, strings):
+ if strings and isinstance(x, basestring):
+ if 'j' in x.lower():
+ x = x.lower().replace(' ', '')
+ match = get_complex.match(x)
+ re = match.group('re')
+ if not re:
+ re = 0
+ im = match.group('im').rstrip('j')
+ return ctx.mpc(ctx.convert(re), ctx.convert(im))
+ if hasattr(x, "_mpi_"):
+ a, b = x._mpi_
+ if a == b:
+ return ctx.make_mpf(a)
+ else:
+ raise ValueError("can only create mpf from zero-width interval")
+ raise TypeError("cannot create mpf from " + repr(x))
+
+ def mpmathify(ctx, *args, **kwargs):
+ return ctx.convert(*args, **kwargs)
+
+ def _parse_prec(ctx, kwargs):
+ if kwargs:
+ if kwargs.get('exact'):
+ return 0, 'f'
+ prec, rounding = ctx._prec_rounding
+ if 'rounding' in kwargs:
+ rounding = kwargs['rounding']
+ if 'prec' in kwargs:
+ prec = kwargs['prec']
+ if prec == ctx.inf:
+ return 0, 'f'
+ else:
+ prec = int(prec)
+ elif 'dps' in kwargs:
+ dps = kwargs['dps']
+ if dps == ctx.inf:
+ return 0, 'f'
+ prec = dps_to_prec(dps)
+ return prec, rounding
+ return ctx._prec_rounding
+
+ _exact_overflow_msg = "the exact result does not fit in memory"
+
+ _hypsum_msg = """hypsum() failed to converge to the requested %i bits of accuracy
+using a working precision of %i bits. Try with a higher maxprec,
+maxterms, or set zeroprec."""
+
+ def hypsum(ctx, p, q, flags, coeffs, z, accurate_small=True, **kwargs):
+ if hasattr(z, "_mpf_"):
+ key = p, q, flags, 'R'
+ v = z._mpf_
+ elif hasattr(z, "_mpc_"):
+ key = p, q, flags, 'C'
+ v = z._mpc_
+ if key not in ctx.hyp_summators:
+ ctx.hyp_summators[key] = libmp.make_hyp_summator(key)[1]
+ summator = ctx.hyp_summators[key]
+ prec = ctx.prec
+ maxprec = kwargs.get('maxprec', ctx._default_hyper_maxprec(prec))
+ extraprec = 50
+ epsshift = 25
+ # Jumps in magnitude occur when parameters are close to negative
+ # integers. We must ensure that these terms are included in
+ # the sum and added accurately
+ magnitude_check = {}
+ max_total_jump = 0
+ for i, c in enumerate(coeffs):
+ if flags[i] == 'Z':
+ if i >= p and c <= 0:
+ ok = False
+ for ii, cc in enumerate(coeffs[:p]):
+ # Note: c <= cc or c < cc, depending on convention
+ if flags[ii] == 'Z' and cc <= 0 and c <= cc:
+ ok = True
+ if not ok:
+ raise ZeroDivisionError("pole in hypergeometric series")
+ continue
+ n, d = ctx.nint_distance(c)
+ n = -int(n)
+ d = -d
+ if i >= p and n >= 0 and d > 4:
+ if n in magnitude_check:
+ magnitude_check[n] += d
+ else:
+ magnitude_check[n] = d
+ extraprec = max(extraprec, d - prec + 60)
+ max_total_jump += abs(d)
+ while 1:
+ if extraprec > maxprec:
+ raise ValueError(ctx._hypsum_msg % (prec, prec+extraprec))
+ wp = prec + extraprec
+ if magnitude_check:
+ mag_dict = dict((n,None) for n in magnitude_check)
+ else:
+ mag_dict = {}
+ zv, have_complex, magnitude = summator(coeffs, v, prec, wp, \
+ epsshift, mag_dict, **kwargs)
+ cancel = -magnitude
+ jumps_resolved = True
+ if extraprec < max_total_jump:
+ for n in mag_dict.values():
+ if (n is None) or (n < prec):
+ jumps_resolved = False
+ break
+ accurate = (cancel < extraprec-25-5 or not accurate_small)
+ if jumps_resolved:
+ if accurate:
+ break
+ # zero?
+ zeroprec = kwargs.get('zeroprec')
+ if zeroprec is not None:
+ if cancel > zeroprec:
+ if have_complex:
+ return ctx.mpc(0)
+ else:
+ return ctx.zero
+
+ # Some near-singularities were not included, so increase
+ # precision and repeat until they are
+ extraprec *= 2
+ # Possible workaround for bad roundoff in fixed-point arithmetic
+ epsshift += 5
+ extraprec += 5
+
+ if type(zv) is tuple:
+ if have_complex:
+ return ctx.make_mpc(zv)
+ else:
+ return ctx.make_mpf(zv)
+ else:
+ return zv
+
+ def ldexp(ctx, x, n):
+ r"""
+ Computes `x 2^n` efficiently. No rounding is performed.
+ The argument `x` must be a real floating-point number (or
+ possible to convert into one) and `n` must be a Python ``int``.
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = False
+ >>> ldexp(1, 10)
+ mpf('1024.0')
+ >>> ldexp(1, -3)
+ mpf('0.125')
+
+ """
+ x = ctx.convert(x)
+ return ctx.make_mpf(libmp.mpf_shift(x._mpf_, n))
+
+ def frexp(ctx, x):
+ r"""
+ Given a real number `x`, returns `(y, n)` with `y \in [0.5, 1)`,
+ `n` a Python integer, and such that `x = y 2^n`. No rounding is
+ performed.
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = False
+ >>> frexp(7.5)
+ (mpf('0.9375'), 3)
+
+ """
+ x = ctx.convert(x)
+ y, n = libmp.mpf_frexp(x._mpf_)
+ return ctx.make_mpf(y), n
+
+ def fneg(ctx, x, **kwargs):
+ """
+ Negates the number *x*, giving a floating-point result, optionally
+ using a custom precision and rounding mode.
+
+ See the documentation of :func:`~mpmath.fadd` for a detailed description
+ of how to specify precision and rounding.
+
+ **Examples**
+
+ An mpmath number is returned::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = False
+ >>> fneg(2.5)
+ mpf('-2.5')
+ >>> fneg(-5+2j)
+ mpc(real='5.0', imag='-2.0')
+
+ Precise control over rounding is possible::
+
+ >>> x = fadd(2, 1e-100, exact=True)
+ >>> fneg(x)
+ mpf('-2.0')
+ >>> fneg(x, rounding='f')
+ mpf('-2.0000000000000004')
+
+ Negating with and without roundoff::
+
+ >>> n = 200000000000000000000001
+ >>> print(int(-mpf(n)))
+ -200000000000000016777216
+ >>> print(int(fneg(n)))
+ -200000000000000016777216
+ >>> print(int(fneg(n, prec=log(n,2)+1)))
+ -200000000000000000000001
+ >>> print(int(fneg(n, dps=log(n,10)+1)))
+ -200000000000000000000001
+ >>> print(int(fneg(n, prec=inf)))
+ -200000000000000000000001
+ >>> print(int(fneg(n, dps=inf)))
+ -200000000000000000000001
+ >>> print(int(fneg(n, exact=True)))
+ -200000000000000000000001
+
+ """
+ prec, rounding = ctx._parse_prec(kwargs)
+ x = ctx.convert(x)
+ if hasattr(x, '_mpf_'):
+ return ctx.make_mpf(mpf_neg(x._mpf_, prec, rounding))
+ if hasattr(x, '_mpc_'):
+ return ctx.make_mpc(mpc_neg(x._mpc_, prec, rounding))
+ raise ValueError("Arguments need to be mpf or mpc compatible numbers")
+
+ def fadd(ctx, x, y, **kwargs):
+ """
+ Adds the numbers *x* and *y*, giving a floating-point result,
+ optionally using a custom precision and rounding mode.
+
+ The default precision is the working precision of the context.
+ You can specify a custom precision in bits by passing the *prec* keyword
+ argument, or by providing an equivalent decimal precision with the *dps*
+ keyword argument. If the precision is set to ``+inf``, or if the flag
+ *exact=True* is passed, an exact addition with no rounding is performed.
+
+ When the precision is finite, the optional *rounding* keyword argument
+ specifies the direction of rounding. Valid options are ``'n'`` for
+ nearest (default), ``'f'`` for floor, ``'c'`` for ceiling, ``'d'``
+ for down, ``'u'`` for up.
+
+ **Examples**
+
+ Using :func:`~mpmath.fadd` with precision and rounding control::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = False
+ >>> fadd(2, 1e-20)
+ mpf('2.0')
+ >>> fadd(2, 1e-20, rounding='u')
+ mpf('2.0000000000000004')
+ >>> nprint(fadd(2, 1e-20, prec=100), 25)
+ 2.00000000000000000001
+ >>> nprint(fadd(2, 1e-20, dps=15), 25)
+ 2.0
+ >>> nprint(fadd(2, 1e-20, dps=25), 25)
+ 2.00000000000000000001
+ >>> nprint(fadd(2, 1e-20, exact=True), 25)
+ 2.00000000000000000001
+
+ Exact addition avoids cancellation errors, enforcing familiar laws
+ of numbers such as `x+y-x = y`, which don't hold in floating-point
+ arithmetic with finite precision::
+
+ >>> x, y = mpf(2), mpf('1e-1000')
+ >>> print(x + y - x)
+ 0.0
+ >>> print(fadd(x, y, prec=inf) - x)
+ 1.0e-1000
+ >>> print(fadd(x, y, exact=True) - x)
+ 1.0e-1000
+
+ Exact addition can be inefficient and may be impossible to perform
+ with large magnitude differences::
+
+ >>> fadd(1, '1e-100000000000000000000', prec=inf)
+ Traceback (most recent call last):
+ ...
+ OverflowError: the exact result does not fit in memory
+
+ """
+ prec, rounding = ctx._parse_prec(kwargs)
+ x = ctx.convert(x)
+ y = ctx.convert(y)
+ try:
+ if hasattr(x, '_mpf_'):
+ if hasattr(y, '_mpf_'):
+ return ctx.make_mpf(mpf_add(x._mpf_, y._mpf_, prec, rounding))
+ if hasattr(y, '_mpc_'):
+ return ctx.make_mpc(mpc_add_mpf(y._mpc_, x._mpf_, prec, rounding))
+ if hasattr(x, '_mpc_'):
+ if hasattr(y, '_mpf_'):
+ return ctx.make_mpc(mpc_add_mpf(x._mpc_, y._mpf_, prec, rounding))
+ if hasattr(y, '_mpc_'):
+ return ctx.make_mpc(mpc_add(x._mpc_, y._mpc_, prec, rounding))
+ except (ValueError, OverflowError):
+ raise OverflowError(ctx._exact_overflow_msg)
+ raise ValueError("Arguments need to be mpf or mpc compatible numbers")
+
+ def fsub(ctx, x, y, **kwargs):
+ """
+ Subtracts the numbers *x* and *y*, giving a floating-point result,
+ optionally using a custom precision and rounding mode.
+
+ See the documentation of :func:`~mpmath.fadd` for a detailed description
+ of how to specify precision and rounding.
+
+ **Examples**
+
+ Using :func:`~mpmath.fsub` with precision and rounding control::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = False
+ >>> fsub(2, 1e-20)
+ mpf('2.0')
+ >>> fsub(2, 1e-20, rounding='d')
+ mpf('1.9999999999999998')
+ >>> nprint(fsub(2, 1e-20, prec=100), 25)
+ 1.99999999999999999999
+ >>> nprint(fsub(2, 1e-20, dps=15), 25)
+ 2.0
+ >>> nprint(fsub(2, 1e-20, dps=25), 25)
+ 1.99999999999999999999
+ >>> nprint(fsub(2, 1e-20, exact=True), 25)
+ 1.99999999999999999999
+
+ Exact subtraction avoids cancellation errors, enforcing familiar laws
+ of numbers such as `x-y+y = x`, which don't hold in floating-point
+ arithmetic with finite precision::
+
+ >>> x, y = mpf(2), mpf('1e1000')
+ >>> print(x - y + y)
+ 0.0
+ >>> print(fsub(x, y, prec=inf) + y)
+ 2.0
+ >>> print(fsub(x, y, exact=True) + y)
+ 2.0
+
+ Exact addition can be inefficient and may be impossible to perform
+ with large magnitude differences::
+
+ >>> fsub(1, '1e-100000000000000000000', prec=inf)
+ Traceback (most recent call last):
+ ...
+ OverflowError: the exact result does not fit in memory
+
+ """
+ prec, rounding = ctx._parse_prec(kwargs)
+ x = ctx.convert(x)
+ y = ctx.convert(y)
+ try:
+ if hasattr(x, '_mpf_'):
+ if hasattr(y, '_mpf_'):
+ return ctx.make_mpf(mpf_sub(x._mpf_, y._mpf_, prec, rounding))
+ if hasattr(y, '_mpc_'):
+ return ctx.make_mpc(mpc_sub((x._mpf_, fzero), y._mpc_, prec, rounding))
+ if hasattr(x, '_mpc_'):
+ if hasattr(y, '_mpf_'):
+ return ctx.make_mpc(mpc_sub_mpf(x._mpc_, y._mpf_, prec, rounding))
+ if hasattr(y, '_mpc_'):
+ return ctx.make_mpc(mpc_sub(x._mpc_, y._mpc_, prec, rounding))
+ except (ValueError, OverflowError):
+ raise OverflowError(ctx._exact_overflow_msg)
+ raise ValueError("Arguments need to be mpf or mpc compatible numbers")
+
+ def fmul(ctx, x, y, **kwargs):
+ """
+ Multiplies the numbers *x* and *y*, giving a floating-point result,
+ optionally using a custom precision and rounding mode.
+
+ See the documentation of :func:`~mpmath.fadd` for a detailed description
+ of how to specify precision and rounding.
+
+ **Examples**
+
+ The result is an mpmath number::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = False
+ >>> fmul(2, 5.0)
+ mpf('10.0')
+ >>> fmul(0.5j, 0.5)
+ mpc(real='0.0', imag='0.25')
+
+ Avoiding roundoff::
+
+ >>> x, y = 10**10+1, 10**15+1
+ >>> print(x*y)
+ 10000000001000010000000001
+ >>> print(mpf(x) * mpf(y))
+ 1.0000000001e+25
+ >>> print(int(mpf(x) * mpf(y)))
+ 10000000001000011026399232
+ >>> print(int(fmul(x, y)))
+ 10000000001000011026399232
+ >>> print(int(fmul(x, y, dps=25)))
+ 10000000001000010000000001
+ >>> print(int(fmul(x, y, exact=True)))
+ 10000000001000010000000001
+
+ Exact multiplication with complex numbers can be inefficient and may
+ be impossible to perform with large magnitude differences between
+ real and imaginary parts::
+
+ >>> x = 1+2j
+ >>> y = mpc(2, '1e-100000000000000000000')
+ >>> fmul(x, y)
+ mpc(real='2.0', imag='4.0')
+ >>> fmul(x, y, rounding='u')
+ mpc(real='2.0', imag='4.0000000000000009')
+ >>> fmul(x, y, exact=True)
+ Traceback (most recent call last):
+ ...
+ OverflowError: the exact result does not fit in memory
+
+ """
+ prec, rounding = ctx._parse_prec(kwargs)
+ x = ctx.convert(x)
+ y = ctx.convert(y)
+ try:
+ if hasattr(x, '_mpf_'):
+ if hasattr(y, '_mpf_'):
+ return ctx.make_mpf(mpf_mul(x._mpf_, y._mpf_, prec, rounding))
+ if hasattr(y, '_mpc_'):
+ return ctx.make_mpc(mpc_mul_mpf(y._mpc_, x._mpf_, prec, rounding))
+ if hasattr(x, '_mpc_'):
+ if hasattr(y, '_mpf_'):
+ return ctx.make_mpc(mpc_mul_mpf(x._mpc_, y._mpf_, prec, rounding))
+ if hasattr(y, '_mpc_'):
+ return ctx.make_mpc(mpc_mul(x._mpc_, y._mpc_, prec, rounding))
+ except (ValueError, OverflowError):
+ raise OverflowError(ctx._exact_overflow_msg)
+ raise ValueError("Arguments need to be mpf or mpc compatible numbers")
+
+ def fdiv(ctx, x, y, **kwargs):
+ """
+ Divides the numbers *x* and *y*, giving a floating-point result,
+ optionally using a custom precision and rounding mode.
+
+ See the documentation of :func:`~mpmath.fadd` for a detailed description
+ of how to specify precision and rounding.
+
+ **Examples**
+
+ The result is an mpmath number::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = False
+ >>> fdiv(3, 2)
+ mpf('1.5')
+ >>> fdiv(2, 3)
+ mpf('0.66666666666666663')
+ >>> fdiv(2+4j, 0.5)
+ mpc(real='4.0', imag='8.0')
+
+ The rounding direction and precision can be controlled::
+
+ >>> fdiv(2, 3, dps=3) # Should be accurate to at least 3 digits
+ mpf('0.6666259765625')
+ >>> fdiv(2, 3, rounding='d')
+ mpf('0.66666666666666663')
+ >>> fdiv(2, 3, prec=60)
+ mpf('0.66666666666666667')
+ >>> fdiv(2, 3, rounding='u')
+ mpf('0.66666666666666674')
+
+ Checking the error of a division by performing it at higher precision::
+
+ >>> fdiv(2, 3) - fdiv(2, 3, prec=100)
+ mpf('-3.7007434154172148e-17')
+
+ Unlike :func:`~mpmath.fadd`, :func:`~mpmath.fmul`, etc., exact division is not
+ allowed since the quotient of two floating-point numbers generally
+ does not have an exact floating-point representation. (In the
+ future this might be changed to allow the case where the division
+ is actually exact.)
+
+ >>> fdiv(2, 3, exact=True)
+ Traceback (most recent call last):
+ ...
+ ValueError: division is not an exact operation
+
+ """
+ prec, rounding = ctx._parse_prec(kwargs)
+ if not prec:
+ raise ValueError("division is not an exact operation")
+ x = ctx.convert(x)
+ y = ctx.convert(y)
+ if hasattr(x, '_mpf_'):
+ if hasattr(y, '_mpf_'):
+ return ctx.make_mpf(mpf_div(x._mpf_, y._mpf_, prec, rounding))
+ if hasattr(y, '_mpc_'):
+ return ctx.make_mpc(mpc_div((x._mpf_, fzero), y._mpc_, prec, rounding))
+ if hasattr(x, '_mpc_'):
+ if hasattr(y, '_mpf_'):
+ return ctx.make_mpc(mpc_div_mpf(x._mpc_, y._mpf_, prec, rounding))
+ if hasattr(y, '_mpc_'):
+ return ctx.make_mpc(mpc_div(x._mpc_, y._mpc_, prec, rounding))
+ raise ValueError("Arguments need to be mpf or mpc compatible numbers")
+
+ def nint_distance(ctx, x):
+ r"""
+ Return `(n,d)` where `n` is the nearest integer to `x` and `d` is
+ an estimate of `\log_2(|x-n|)`. If `d < 0`, `-d` gives the precision
+ (measured in bits) lost to cancellation when computing `x-n`.
+
+ >>> from mpmath import *
+ >>> n, d = nint_distance(5)
+ >>> print(n); print(d)
+ 5
+ -inf
+ >>> n, d = nint_distance(mpf(5))
+ >>> print(n); print(d)
+ 5
+ -inf
+ >>> n, d = nint_distance(mpf(5.00000001))
+ >>> print(n); print(d)
+ 5
+ -26
+ >>> n, d = nint_distance(mpf(4.99999999))
+ >>> print(n); print(d)
+ 5
+ -26
+ >>> n, d = nint_distance(mpc(5,10))
+ >>> print(n); print(d)
+ 5
+ 4
+ >>> n, d = nint_distance(mpc(5,0.000001))
+ >>> print(n); print(d)
+ 5
+ -19
+
+ """
+ typx = type(x)
+ if typx in int_types:
+ return int(x), ctx.ninf
+ elif typx is rational.mpq:
+ p, q = x._mpq_
+ n, r = divmod(p, q)
+ if 2*r >= q:
+ n += 1
+ elif not r:
+ return n, ctx.ninf
+ # log(p/q-n) = log((p-nq)/q) = log(p-nq) - log(q)
+ d = bitcount(abs(p-n*q)) - bitcount(q)
+ return n, d
+ if hasattr(x, "_mpf_"):
+ re = x._mpf_
+ im_dist = ctx.ninf
+ elif hasattr(x, "_mpc_"):
+ re, im = x._mpc_
+ isign, iman, iexp, ibc = im
+ if iman:
+ im_dist = iexp + ibc
+ elif im == fzero:
+ im_dist = ctx.ninf
+ else:
+ raise ValueError("requires a finite number")
+ else:
+ x = ctx.convert(x)
+ if hasattr(x, "_mpf_") or hasattr(x, "_mpc_"):
+ return ctx.nint_distance(x)
+ else:
+ raise TypeError("requires an mpf/mpc")
+ sign, man, exp, bc = re
+ mag = exp+bc
+ # |x| < 0.5
+ if mag < 0:
+ n = 0
+ re_dist = mag
+ elif man:
+ # exact integer
+ if exp >= 0:
+ n = man << exp
+ re_dist = ctx.ninf
+ # exact half-integer
+ elif exp == -1:
+ n = (man>>1)+1
+ re_dist = 0
+ else:
+ d = (-exp-1)
+ t = man >> d
+ if t & 1:
+ t += 1
+ man = (t<>1 # int(t)>>1
+ re_dist = exp+bitcount(man)
+ if sign:
+ n = -n
+ elif re == fzero:
+ re_dist = ctx.ninf
+ n = 0
+ else:
+ raise ValueError("requires a finite number")
+ return n, max(re_dist, im_dist)
+
+ def fprod(ctx, factors):
+ r"""
+ Calculates a product containing a finite number of factors (for
+ infinite products, see :func:`~mpmath.nprod`). The factors will be
+ converted to mpmath numbers.
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = False
+ >>> fprod([1, 2, 0.5, 7])
+ mpf('7.0')
+
+ """
+ orig = ctx.prec
+ try:
+ v = ctx.one
+ for p in factors:
+ v *= p
+ finally:
+ ctx.prec = orig
+ return +v
+
+ def rand(ctx):
+ """
+ Returns an ``mpf`` with value chosen randomly from `[0, 1)`.
+ The number of randomly generated bits in the mantissa is equal
+ to the working precision.
+ """
+ return ctx.make_mpf(mpf_rand(ctx._prec))
+
+ def fraction(ctx, p, q):
+ """
+ Given Python integers `(p, q)`, returns a lazy ``mpf`` representing
+ the fraction `p/q`. The value is updated with the precision.
+
+ >>> from mpmath import *
+ >>> mp.dps = 15
+ >>> a = fraction(1,100)
+ >>> b = mpf(1)/100
+ >>> print(a); print(b)
+ 0.01
+ 0.01
+ >>> mp.dps = 30
+ >>> print(a); print(b) # a will be accurate
+ 0.01
+ 0.0100000000000000002081668171172
+ >>> mp.dps = 15
+ """
+ return ctx.constant(lambda prec, rnd: from_rational(p, q, prec, rnd),
+ '%s/%s' % (p, q))
+
+ def absmin(ctx, x):
+ return abs(ctx.convert(x))
+
+ def absmax(ctx, x):
+ return abs(ctx.convert(x))
+
+ def _as_points(ctx, x):
+ # XXX: remove this?
+ if hasattr(x, '_mpi_'):
+ a, b = x._mpi_
+ return [ctx.make_mpf(a), ctx.make_mpf(b)]
+ return x
+
+ '''
+ def _zetasum(ctx, s, a, b):
+ """
+ Computes sum of k^(-s) for k = a, a+1, ..., b with a, b both small
+ integers.
+ """
+ a = int(a)
+ b = int(b)
+ s = ctx.convert(s)
+ prec, rounding = ctx._prec_rounding
+ if hasattr(s, '_mpf_'):
+ v = ctx.make_mpf(libmp.mpf_zetasum(s._mpf_, a, b, prec))
+ elif hasattr(s, '_mpc_'):
+ v = ctx.make_mpc(libmp.mpc_zetasum(s._mpc_, a, b, prec))
+ return v
+ '''
+
+ def _zetasum_fast(ctx, s, a, n, derivatives=[0], reflect=False):
+ if not (ctx.isint(a) and hasattr(s, "_mpc_")):
+ raise NotImplementedError
+ a = int(a)
+ prec = ctx._prec
+ xs, ys = libmp.mpc_zetasum(s._mpc_, a, n, derivatives, reflect, prec)
+ xs = [ctx.make_mpc(x) for x in xs]
+ ys = [ctx.make_mpc(y) for y in ys]
+ return xs, ys
+
+class PrecisionManager:
+ def __init__(self, ctx, precfun, dpsfun, normalize_output=False):
+ self.ctx = ctx
+ self.precfun = precfun
+ self.dpsfun = dpsfun
+ self.normalize_output = normalize_output
+ def __call__(self, f):
+ @functools.wraps(f)
+ def g(*args, **kwargs):
+ orig = self.ctx.prec
+ try:
+ if self.precfun:
+ self.ctx.prec = self.precfun(self.ctx.prec)
+ else:
+ self.ctx.dps = self.dpsfun(self.ctx.dps)
+ if self.normalize_output:
+ v = f(*args, **kwargs)
+ if type(v) is tuple:
+ return tuple([+a for a in v])
+ return +v
+ else:
+ return f(*args, **kwargs)
+ finally:
+ self.ctx.prec = orig
+ return g
+ def __enter__(self):
+ self.origp = self.ctx.prec
+ if self.precfun:
+ self.ctx.prec = self.precfun(self.ctx.prec)
+ else:
+ self.ctx.dps = self.dpsfun(self.ctx.dps)
+ def __exit__(self, exc_type, exc_val, exc_tb):
+ self.ctx.prec = self.origp
+ return False
+
+
+if __name__ == '__main__':
+ import doctest
+ doctest.testmod()
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/mpmath/ctx_mp_python.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/mpmath/ctx_mp_python.py
new file mode 100644
index 0000000000000000000000000000000000000000..cfbd72fb8300bf840069c38529b7b41418d26eeb
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/mpmath/ctx_mp_python.py
@@ -0,0 +1,1149 @@
+#from ctx_base import StandardBaseContext
+
+from .libmp.backend import basestring, exec_
+
+from .libmp import (MPZ, MPZ_ZERO, MPZ_ONE, int_types, repr_dps,
+ round_floor, round_ceiling, dps_to_prec, round_nearest, prec_to_dps,
+ ComplexResult, to_pickable, from_pickable, normalize,
+ from_int, from_float, from_npfloat, from_Decimal, from_str, to_int, to_float, to_str,
+ from_rational, from_man_exp,
+ fone, fzero, finf, fninf, fnan,
+ mpf_abs, mpf_pos, mpf_neg, mpf_add, mpf_sub, mpf_mul, mpf_mul_int,
+ mpf_div, mpf_rdiv_int, mpf_pow_int, mpf_mod,
+ mpf_eq, mpf_cmp, mpf_lt, mpf_gt, mpf_le, mpf_ge,
+ mpf_hash, mpf_rand,
+ mpf_sum,
+ bitcount, to_fixed,
+ mpc_to_str,
+ mpc_to_complex, mpc_hash, mpc_pos, mpc_is_nonzero, mpc_neg, mpc_conjugate,
+ mpc_abs, mpc_add, mpc_add_mpf, mpc_sub, mpc_sub_mpf, mpc_mul, mpc_mul_mpf,
+ mpc_mul_int, mpc_div, mpc_div_mpf, mpc_pow, mpc_pow_mpf, mpc_pow_int,
+ mpc_mpf_div,
+ mpf_pow,
+ mpf_pi, mpf_degree, mpf_e, mpf_phi, mpf_ln2, mpf_ln10,
+ mpf_euler, mpf_catalan, mpf_apery, mpf_khinchin,
+ mpf_glaisher, mpf_twinprime, mpf_mertens,
+ int_types)
+
+from . import rational
+from . import function_docs
+
+new = object.__new__
+
+class mpnumeric(object):
+ """Base class for mpf and mpc."""
+ __slots__ = []
+ def __new__(cls, val):
+ raise NotImplementedError
+
+class _mpf(mpnumeric):
+ """
+ An mpf instance holds a real-valued floating-point number. mpf:s
+ work analogously to Python floats, but support arbitrary-precision
+ arithmetic.
+ """
+ __slots__ = ['_mpf_']
+
+ def __new__(cls, val=fzero, **kwargs):
+ """A new mpf can be created from a Python float, an int, a
+ or a decimal string representing a number in floating-point
+ format."""
+ prec, rounding = cls.context._prec_rounding
+ if kwargs:
+ prec = kwargs.get('prec', prec)
+ if 'dps' in kwargs:
+ prec = dps_to_prec(kwargs['dps'])
+ rounding = kwargs.get('rounding', rounding)
+ if type(val) is cls:
+ sign, man, exp, bc = val._mpf_
+ if (not man) and exp:
+ return val
+ v = new(cls)
+ v._mpf_ = normalize(sign, man, exp, bc, prec, rounding)
+ return v
+ elif type(val) is tuple:
+ if len(val) == 2:
+ v = new(cls)
+ v._mpf_ = from_man_exp(val[0], val[1], prec, rounding)
+ return v
+ if len(val) == 4:
+ if val not in (finf, fninf, fnan):
+ sign, man, exp, bc = val
+ val = normalize(sign, MPZ(man), exp, bc, prec, rounding)
+ v = new(cls)
+ v._mpf_ = val
+ return v
+ raise ValueError
+ else:
+ v = new(cls)
+ v._mpf_ = mpf_pos(cls.mpf_convert_arg(val, prec, rounding), prec, rounding)
+ return v
+
+ @classmethod
+ def mpf_convert_arg(cls, x, prec, rounding):
+ if isinstance(x, int_types): return from_int(x)
+ if isinstance(x, float): return from_float(x)
+ if isinstance(x, basestring): return from_str(x, prec, rounding)
+ if isinstance(x, cls.context.constant): return x.func(prec, rounding)
+ if hasattr(x, '_mpf_'): return x._mpf_
+ if hasattr(x, '_mpmath_'):
+ t = cls.context.convert(x._mpmath_(prec, rounding))
+ if hasattr(t, '_mpf_'):
+ return t._mpf_
+ if hasattr(x, '_mpi_'):
+ a, b = x._mpi_
+ if a == b:
+ return a
+ raise ValueError("can only create mpf from zero-width interval")
+ raise TypeError("cannot create mpf from " + repr(x))
+
+ @classmethod
+ def mpf_convert_rhs(cls, x):
+ if isinstance(x, int_types): return from_int(x)
+ if isinstance(x, float): return from_float(x)
+ if isinstance(x, complex_types): return cls.context.mpc(x)
+ if isinstance(x, rational.mpq):
+ p, q = x._mpq_
+ return from_rational(p, q, cls.context.prec)
+ if hasattr(x, '_mpf_'): return x._mpf_
+ if hasattr(x, '_mpmath_'):
+ t = cls.context.convert(x._mpmath_(*cls.context._prec_rounding))
+ if hasattr(t, '_mpf_'):
+ return t._mpf_
+ return t
+ return NotImplemented
+
+ @classmethod
+ def mpf_convert_lhs(cls, x):
+ x = cls.mpf_convert_rhs(x)
+ if type(x) is tuple:
+ return cls.context.make_mpf(x)
+ return x
+
+ man_exp = property(lambda self: self._mpf_[1:3])
+ man = property(lambda self: self._mpf_[1])
+ exp = property(lambda self: self._mpf_[2])
+ bc = property(lambda self: self._mpf_[3])
+
+ real = property(lambda self: self)
+ imag = property(lambda self: self.context.zero)
+
+ conjugate = lambda self: self
+
+ def __getstate__(self): return to_pickable(self._mpf_)
+ def __setstate__(self, val): self._mpf_ = from_pickable(val)
+
+ def __repr__(s):
+ if s.context.pretty:
+ return str(s)
+ return "mpf('%s')" % to_str(s._mpf_, s.context._repr_digits)
+
+ def __str__(s): return to_str(s._mpf_, s.context._str_digits)
+ def __hash__(s): return mpf_hash(s._mpf_)
+ def __int__(s): return int(to_int(s._mpf_))
+ def __long__(s): return long(to_int(s._mpf_))
+ def __float__(s): return to_float(s._mpf_, rnd=s.context._prec_rounding[1])
+ def __complex__(s): return complex(float(s))
+ def __nonzero__(s): return s._mpf_ != fzero
+
+ __bool__ = __nonzero__
+
+ def __abs__(s):
+ cls, new, (prec, rounding) = s._ctxdata
+ v = new(cls)
+ v._mpf_ = mpf_abs(s._mpf_, prec, rounding)
+ return v
+
+ def __pos__(s):
+ cls, new, (prec, rounding) = s._ctxdata
+ v = new(cls)
+ v._mpf_ = mpf_pos(s._mpf_, prec, rounding)
+ return v
+
+ def __neg__(s):
+ cls, new, (prec, rounding) = s._ctxdata
+ v = new(cls)
+ v._mpf_ = mpf_neg(s._mpf_, prec, rounding)
+ return v
+
+ def _cmp(s, t, func):
+ if hasattr(t, '_mpf_'):
+ t = t._mpf_
+ else:
+ t = s.mpf_convert_rhs(t)
+ if t is NotImplemented:
+ return t
+ return func(s._mpf_, t)
+
+ def __cmp__(s, t): return s._cmp(t, mpf_cmp)
+ def __lt__(s, t): return s._cmp(t, mpf_lt)
+ def __gt__(s, t): return s._cmp(t, mpf_gt)
+ def __le__(s, t): return s._cmp(t, mpf_le)
+ def __ge__(s, t): return s._cmp(t, mpf_ge)
+
+ def __ne__(s, t):
+ v = s.__eq__(t)
+ if v is NotImplemented:
+ return v
+ return not v
+
+ def __rsub__(s, t):
+ cls, new, (prec, rounding) = s._ctxdata
+ if type(t) in int_types:
+ v = new(cls)
+ v._mpf_ = mpf_sub(from_int(t), s._mpf_, prec, rounding)
+ return v
+ t = s.mpf_convert_lhs(t)
+ if t is NotImplemented:
+ return t
+ return t - s
+
+ def __rdiv__(s, t):
+ cls, new, (prec, rounding) = s._ctxdata
+ if isinstance(t, int_types):
+ v = new(cls)
+ v._mpf_ = mpf_rdiv_int(t, s._mpf_, prec, rounding)
+ return v
+ t = s.mpf_convert_lhs(t)
+ if t is NotImplemented:
+ return t
+ return t / s
+
+ def __rpow__(s, t):
+ t = s.mpf_convert_lhs(t)
+ if t is NotImplemented:
+ return t
+ return t ** s
+
+ def __rmod__(s, t):
+ t = s.mpf_convert_lhs(t)
+ if t is NotImplemented:
+ return t
+ return t % s
+
+ def sqrt(s):
+ return s.context.sqrt(s)
+
+ def ae(s, t, rel_eps=None, abs_eps=None):
+ return s.context.almosteq(s, t, rel_eps, abs_eps)
+
+ def to_fixed(self, prec):
+ return to_fixed(self._mpf_, prec)
+
+ def __round__(self, *args):
+ return round(float(self), *args)
+
+mpf_binary_op = """
+def %NAME%(self, other):
+ mpf, new, (prec, rounding) = self._ctxdata
+ sval = self._mpf_
+ if hasattr(other, '_mpf_'):
+ tval = other._mpf_
+ %WITH_MPF%
+ ttype = type(other)
+ if ttype in int_types:
+ %WITH_INT%
+ elif ttype is float:
+ tval = from_float(other)
+ %WITH_MPF%
+ elif hasattr(other, '_mpc_'):
+ tval = other._mpc_
+ mpc = type(other)
+ %WITH_MPC%
+ elif ttype is complex:
+ tval = from_float(other.real), from_float(other.imag)
+ mpc = self.context.mpc
+ %WITH_MPC%
+ if isinstance(other, mpnumeric):
+ return NotImplemented
+ try:
+ other = mpf.context.convert(other, strings=False)
+ except TypeError:
+ return NotImplemented
+ return self.%NAME%(other)
+"""
+
+return_mpf = "; obj = new(mpf); obj._mpf_ = val; return obj"
+return_mpc = "; obj = new(mpc); obj._mpc_ = val; return obj"
+
+mpf_pow_same = """
+ try:
+ val = mpf_pow(sval, tval, prec, rounding) %s
+ except ComplexResult:
+ if mpf.context.trap_complex:
+ raise
+ mpc = mpf.context.mpc
+ val = mpc_pow((sval, fzero), (tval, fzero), prec, rounding) %s
+""" % (return_mpf, return_mpc)
+
+def binary_op(name, with_mpf='', with_int='', with_mpc=''):
+ code = mpf_binary_op
+ code = code.replace("%WITH_INT%", with_int)
+ code = code.replace("%WITH_MPC%", with_mpc)
+ code = code.replace("%WITH_MPF%", with_mpf)
+ code = code.replace("%NAME%", name)
+ np = {}
+ exec_(code, globals(), np)
+ return np[name]
+
+_mpf.__eq__ = binary_op('__eq__',
+ 'return mpf_eq(sval, tval)',
+ 'return mpf_eq(sval, from_int(other))',
+ 'return (tval[1] == fzero) and mpf_eq(tval[0], sval)')
+
+_mpf.__add__ = binary_op('__add__',
+ 'val = mpf_add(sval, tval, prec, rounding)' + return_mpf,
+ 'val = mpf_add(sval, from_int(other), prec, rounding)' + return_mpf,
+ 'val = mpc_add_mpf(tval, sval, prec, rounding)' + return_mpc)
+
+_mpf.__sub__ = binary_op('__sub__',
+ 'val = mpf_sub(sval, tval, prec, rounding)' + return_mpf,
+ 'val = mpf_sub(sval, from_int(other), prec, rounding)' + return_mpf,
+ 'val = mpc_sub((sval, fzero), tval, prec, rounding)' + return_mpc)
+
+_mpf.__mul__ = binary_op('__mul__',
+ 'val = mpf_mul(sval, tval, prec, rounding)' + return_mpf,
+ 'val = mpf_mul_int(sval, other, prec, rounding)' + return_mpf,
+ 'val = mpc_mul_mpf(tval, sval, prec, rounding)' + return_mpc)
+
+_mpf.__div__ = binary_op('__div__',
+ 'val = mpf_div(sval, tval, prec, rounding)' + return_mpf,
+ 'val = mpf_div(sval, from_int(other), prec, rounding)' + return_mpf,
+ 'val = mpc_mpf_div(sval, tval, prec, rounding)' + return_mpc)
+
+_mpf.__mod__ = binary_op('__mod__',
+ 'val = mpf_mod(sval, tval, prec, rounding)' + return_mpf,
+ 'val = mpf_mod(sval, from_int(other), prec, rounding)' + return_mpf,
+ 'raise NotImplementedError("complex modulo")')
+
+_mpf.__pow__ = binary_op('__pow__',
+ mpf_pow_same,
+ 'val = mpf_pow_int(sval, other, prec, rounding)' + return_mpf,
+ 'val = mpc_pow((sval, fzero), tval, prec, rounding)' + return_mpc)
+
+_mpf.__radd__ = _mpf.__add__
+_mpf.__rmul__ = _mpf.__mul__
+_mpf.__truediv__ = _mpf.__div__
+_mpf.__rtruediv__ = _mpf.__rdiv__
+
+
+class _constant(_mpf):
+ """Represents a mathematical constant with dynamic precision.
+ When printed or used in an arithmetic operation, a constant
+ is converted to a regular mpf at the working precision. A
+ regular mpf can also be obtained using the operation +x."""
+
+ def __new__(cls, func, name, docname=''):
+ a = object.__new__(cls)
+ a.name = name
+ a.func = func
+ a.__doc__ = getattr(function_docs, docname, '')
+ return a
+
+ def __call__(self, prec=None, dps=None, rounding=None):
+ prec2, rounding2 = self.context._prec_rounding
+ if not prec: prec = prec2
+ if not rounding: rounding = rounding2
+ if dps: prec = dps_to_prec(dps)
+ return self.context.make_mpf(self.func(prec, rounding))
+
+ @property
+ def _mpf_(self):
+ prec, rounding = self.context._prec_rounding
+ return self.func(prec, rounding)
+
+ def __repr__(self):
+ return "<%s: %s~>" % (self.name, self.context.nstr(self(dps=15)))
+
+
+class _mpc(mpnumeric):
+ """
+ An mpc represents a complex number using a pair of mpf:s (one
+ for the real part and another for the imaginary part.) The mpc
+ class behaves fairly similarly to Python's complex type.
+ """
+
+ __slots__ = ['_mpc_']
+
+ def __new__(cls, real=0, imag=0):
+ s = object.__new__(cls)
+ if isinstance(real, complex_types):
+ real, imag = real.real, real.imag
+ elif hasattr(real, '_mpc_'):
+ s._mpc_ = real._mpc_
+ return s
+ real = cls.context.mpf(real)
+ imag = cls.context.mpf(imag)
+ s._mpc_ = (real._mpf_, imag._mpf_)
+ return s
+
+ real = property(lambda self: self.context.make_mpf(self._mpc_[0]))
+ imag = property(lambda self: self.context.make_mpf(self._mpc_[1]))
+
+ def __getstate__(self):
+ return to_pickable(self._mpc_[0]), to_pickable(self._mpc_[1])
+
+ def __setstate__(self, val):
+ self._mpc_ = from_pickable(val[0]), from_pickable(val[1])
+
+ def __repr__(s):
+ if s.context.pretty:
+ return str(s)
+ r = repr(s.real)[4:-1]
+ i = repr(s.imag)[4:-1]
+ return "%s(real=%s, imag=%s)" % (type(s).__name__, r, i)
+
+ def __str__(s):
+ return "(%s)" % mpc_to_str(s._mpc_, s.context._str_digits)
+
+ def __complex__(s):
+ return mpc_to_complex(s._mpc_, rnd=s.context._prec_rounding[1])
+
+ def __pos__(s):
+ cls, new, (prec, rounding) = s._ctxdata
+ v = new(cls)
+ v._mpc_ = mpc_pos(s._mpc_, prec, rounding)
+ return v
+
+ def __abs__(s):
+ prec, rounding = s.context._prec_rounding
+ v = new(s.context.mpf)
+ v._mpf_ = mpc_abs(s._mpc_, prec, rounding)
+ return v
+
+ def __neg__(s):
+ cls, new, (prec, rounding) = s._ctxdata
+ v = new(cls)
+ v._mpc_ = mpc_neg(s._mpc_, prec, rounding)
+ return v
+
+ def conjugate(s):
+ cls, new, (prec, rounding) = s._ctxdata
+ v = new(cls)
+ v._mpc_ = mpc_conjugate(s._mpc_, prec, rounding)
+ return v
+
+ def __nonzero__(s):
+ return mpc_is_nonzero(s._mpc_)
+
+ __bool__ = __nonzero__
+
+ def __hash__(s):
+ return mpc_hash(s._mpc_)
+
+ @classmethod
+ def mpc_convert_lhs(cls, x):
+ try:
+ y = cls.context.convert(x)
+ return y
+ except TypeError:
+ return NotImplemented
+
+ def __eq__(s, t):
+ if not hasattr(t, '_mpc_'):
+ if isinstance(t, str):
+ return False
+ t = s.mpc_convert_lhs(t)
+ if t is NotImplemented:
+ return t
+ return s.real == t.real and s.imag == t.imag
+
+ def __ne__(s, t):
+ b = s.__eq__(t)
+ if b is NotImplemented:
+ return b
+ return not b
+
+ def _compare(*args):
+ raise TypeError("no ordering relation is defined for complex numbers")
+
+ __gt__ = _compare
+ __le__ = _compare
+ __gt__ = _compare
+ __ge__ = _compare
+
+ def __add__(s, t):
+ cls, new, (prec, rounding) = s._ctxdata
+ if not hasattr(t, '_mpc_'):
+ t = s.mpc_convert_lhs(t)
+ if t is NotImplemented:
+ return t
+ if hasattr(t, '_mpf_'):
+ v = new(cls)
+ v._mpc_ = mpc_add_mpf(s._mpc_, t._mpf_, prec, rounding)
+ return v
+ v = new(cls)
+ v._mpc_ = mpc_add(s._mpc_, t._mpc_, prec, rounding)
+ return v
+
+ def __sub__(s, t):
+ cls, new, (prec, rounding) = s._ctxdata
+ if not hasattr(t, '_mpc_'):
+ t = s.mpc_convert_lhs(t)
+ if t is NotImplemented:
+ return t
+ if hasattr(t, '_mpf_'):
+ v = new(cls)
+ v._mpc_ = mpc_sub_mpf(s._mpc_, t._mpf_, prec, rounding)
+ return v
+ v = new(cls)
+ v._mpc_ = mpc_sub(s._mpc_, t._mpc_, prec, rounding)
+ return v
+
+ def __mul__(s, t):
+ cls, new, (prec, rounding) = s._ctxdata
+ if not hasattr(t, '_mpc_'):
+ if isinstance(t, int_types):
+ v = new(cls)
+ v._mpc_ = mpc_mul_int(s._mpc_, t, prec, rounding)
+ return v
+ t = s.mpc_convert_lhs(t)
+ if t is NotImplemented:
+ return t
+ if hasattr(t, '_mpf_'):
+ v = new(cls)
+ v._mpc_ = mpc_mul_mpf(s._mpc_, t._mpf_, prec, rounding)
+ return v
+ t = s.mpc_convert_lhs(t)
+ v = new(cls)
+ v._mpc_ = mpc_mul(s._mpc_, t._mpc_, prec, rounding)
+ return v
+
+ def __div__(s, t):
+ cls, new, (prec, rounding) = s._ctxdata
+ if not hasattr(t, '_mpc_'):
+ t = s.mpc_convert_lhs(t)
+ if t is NotImplemented:
+ return t
+ if hasattr(t, '_mpf_'):
+ v = new(cls)
+ v._mpc_ = mpc_div_mpf(s._mpc_, t._mpf_, prec, rounding)
+ return v
+ v = new(cls)
+ v._mpc_ = mpc_div(s._mpc_, t._mpc_, prec, rounding)
+ return v
+
+ def __pow__(s, t):
+ cls, new, (prec, rounding) = s._ctxdata
+ if isinstance(t, int_types):
+ v = new(cls)
+ v._mpc_ = mpc_pow_int(s._mpc_, t, prec, rounding)
+ return v
+ t = s.mpc_convert_lhs(t)
+ if t is NotImplemented:
+ return t
+ v = new(cls)
+ if hasattr(t, '_mpf_'):
+ v._mpc_ = mpc_pow_mpf(s._mpc_, t._mpf_, prec, rounding)
+ else:
+ v._mpc_ = mpc_pow(s._mpc_, t._mpc_, prec, rounding)
+ return v
+
+ __radd__ = __add__
+
+ def __rsub__(s, t):
+ t = s.mpc_convert_lhs(t)
+ if t is NotImplemented:
+ return t
+ return t - s
+
+ def __rmul__(s, t):
+ cls, new, (prec, rounding) = s._ctxdata
+ if isinstance(t, int_types):
+ v = new(cls)
+ v._mpc_ = mpc_mul_int(s._mpc_, t, prec, rounding)
+ return v
+ t = s.mpc_convert_lhs(t)
+ if t is NotImplemented:
+ return t
+ return t * s
+
+ def __rdiv__(s, t):
+ t = s.mpc_convert_lhs(t)
+ if t is NotImplemented:
+ return t
+ return t / s
+
+ def __rpow__(s, t):
+ t = s.mpc_convert_lhs(t)
+ if t is NotImplemented:
+ return t
+ return t ** s
+
+ __truediv__ = __div__
+ __rtruediv__ = __rdiv__
+
+ def ae(s, t, rel_eps=None, abs_eps=None):
+ return s.context.almosteq(s, t, rel_eps, abs_eps)
+
+
+complex_types = (complex, _mpc)
+
+
+class PythonMPContext(object):
+
+ def __init__(ctx):
+ ctx._prec_rounding = [53, round_nearest]
+ ctx.mpf = type('mpf', (_mpf,), {})
+ ctx.mpc = type('mpc', (_mpc,), {})
+ ctx.mpf._ctxdata = [ctx.mpf, new, ctx._prec_rounding]
+ ctx.mpc._ctxdata = [ctx.mpc, new, ctx._prec_rounding]
+ ctx.mpf.context = ctx
+ ctx.mpc.context = ctx
+ ctx.constant = type('constant', (_constant,), {})
+ ctx.constant._ctxdata = [ctx.mpf, new, ctx._prec_rounding]
+ ctx.constant.context = ctx
+
+ def make_mpf(ctx, v):
+ a = new(ctx.mpf)
+ a._mpf_ = v
+ return a
+
+ def make_mpc(ctx, v):
+ a = new(ctx.mpc)
+ a._mpc_ = v
+ return a
+
+ def default(ctx):
+ ctx._prec = ctx._prec_rounding[0] = 53
+ ctx._dps = 15
+ ctx.trap_complex = False
+
+ def _set_prec(ctx, n):
+ ctx._prec = ctx._prec_rounding[0] = max(1, int(n))
+ ctx._dps = prec_to_dps(n)
+
+ def _set_dps(ctx, n):
+ ctx._prec = ctx._prec_rounding[0] = dps_to_prec(n)
+ ctx._dps = max(1, int(n))
+
+ prec = property(lambda ctx: ctx._prec, _set_prec)
+ dps = property(lambda ctx: ctx._dps, _set_dps)
+
+ def convert(ctx, x, strings=True):
+ """
+ Converts *x* to an ``mpf`` or ``mpc``. If *x* is of type ``mpf``,
+ ``mpc``, ``int``, ``float``, ``complex``, the conversion
+ will be performed losslessly.
+
+ If *x* is a string, the result will be rounded to the present
+ working precision. Strings representing fractions or complex
+ numbers are permitted.
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = False
+ >>> mpmathify(3.5)
+ mpf('3.5')
+ >>> mpmathify('2.1')
+ mpf('2.1000000000000001')
+ >>> mpmathify('3/4')
+ mpf('0.75')
+ >>> mpmathify('2+3j')
+ mpc(real='2.0', imag='3.0')
+
+ """
+ if type(x) in ctx.types: return x
+ if isinstance(x, int_types): return ctx.make_mpf(from_int(x))
+ if isinstance(x, float): return ctx.make_mpf(from_float(x))
+ if isinstance(x, complex):
+ return ctx.make_mpc((from_float(x.real), from_float(x.imag)))
+ if type(x).__module__ == 'numpy': return ctx.npconvert(x)
+ if isinstance(x, numbers.Rational): # e.g. Fraction
+ try: x = rational.mpq(int(x.numerator), int(x.denominator))
+ except: pass
+ prec, rounding = ctx._prec_rounding
+ if isinstance(x, rational.mpq):
+ p, q = x._mpq_
+ return ctx.make_mpf(from_rational(p, q, prec))
+ if strings and isinstance(x, basestring):
+ try:
+ _mpf_ = from_str(x, prec, rounding)
+ return ctx.make_mpf(_mpf_)
+ except ValueError:
+ pass
+ if hasattr(x, '_mpf_'): return ctx.make_mpf(x._mpf_)
+ if hasattr(x, '_mpc_'): return ctx.make_mpc(x._mpc_)
+ if hasattr(x, '_mpmath_'):
+ return ctx.convert(x._mpmath_(prec, rounding))
+ if type(x).__module__ == 'decimal':
+ try: return ctx.make_mpf(from_Decimal(x, prec, rounding))
+ except: pass
+ return ctx._convert_fallback(x, strings)
+
+ def npconvert(ctx, x):
+ """
+ Converts *x* to an ``mpf`` or ``mpc``. *x* should be a numpy
+ scalar.
+ """
+ import numpy as np
+ if isinstance(x, np.integer): return ctx.make_mpf(from_int(int(x)))
+ if isinstance(x, np.floating): return ctx.make_mpf(from_npfloat(x))
+ if isinstance(x, np.complexfloating):
+ return ctx.make_mpc((from_npfloat(x.real), from_npfloat(x.imag)))
+ raise TypeError("cannot create mpf from " + repr(x))
+
+ def isnan(ctx, x):
+ """
+ Return *True* if *x* is a NaN (not-a-number), or for a complex
+ number, whether either the real or complex part is NaN;
+ otherwise return *False*::
+
+ >>> from mpmath import *
+ >>> isnan(3.14)
+ False
+ >>> isnan(nan)
+ True
+ >>> isnan(mpc(3.14,2.72))
+ False
+ >>> isnan(mpc(3.14,nan))
+ True
+
+ """
+ if hasattr(x, "_mpf_"):
+ return x._mpf_ == fnan
+ if hasattr(x, "_mpc_"):
+ return fnan in x._mpc_
+ if isinstance(x, int_types) or isinstance(x, rational.mpq):
+ return False
+ x = ctx.convert(x)
+ if hasattr(x, '_mpf_') or hasattr(x, '_mpc_'):
+ return ctx.isnan(x)
+ raise TypeError("isnan() needs a number as input")
+
+ def isinf(ctx, x):
+ """
+ Return *True* if the absolute value of *x* is infinite;
+ otherwise return *False*::
+
+ >>> from mpmath import *
+ >>> isinf(inf)
+ True
+ >>> isinf(-inf)
+ True
+ >>> isinf(3)
+ False
+ >>> isinf(3+4j)
+ False
+ >>> isinf(mpc(3,inf))
+ True
+ >>> isinf(mpc(inf,3))
+ True
+
+ """
+ if hasattr(x, "_mpf_"):
+ return x._mpf_ in (finf, fninf)
+ if hasattr(x, "_mpc_"):
+ re, im = x._mpc_
+ return re in (finf, fninf) or im in (finf, fninf)
+ if isinstance(x, int_types) or isinstance(x, rational.mpq):
+ return False
+ x = ctx.convert(x)
+ if hasattr(x, '_mpf_') or hasattr(x, '_mpc_'):
+ return ctx.isinf(x)
+ raise TypeError("isinf() needs a number as input")
+
+ def isnormal(ctx, x):
+ """
+ Determine whether *x* is "normal" in the sense of floating-point
+ representation; that is, return *False* if *x* is zero, an
+ infinity or NaN; otherwise return *True*. By extension, a
+ complex number *x* is considered "normal" if its magnitude is
+ normal::
+
+ >>> from mpmath import *
+ >>> isnormal(3)
+ True
+ >>> isnormal(0)
+ False
+ >>> isnormal(inf); isnormal(-inf); isnormal(nan)
+ False
+ False
+ False
+ >>> isnormal(0+0j)
+ False
+ >>> isnormal(0+3j)
+ True
+ >>> isnormal(mpc(2,nan))
+ False
+ """
+ if hasattr(x, "_mpf_"):
+ return bool(x._mpf_[1])
+ if hasattr(x, "_mpc_"):
+ re, im = x._mpc_
+ re_normal = bool(re[1])
+ im_normal = bool(im[1])
+ if re == fzero: return im_normal
+ if im == fzero: return re_normal
+ return re_normal and im_normal
+ if isinstance(x, int_types) or isinstance(x, rational.mpq):
+ return bool(x)
+ x = ctx.convert(x)
+ if hasattr(x, '_mpf_') or hasattr(x, '_mpc_'):
+ return ctx.isnormal(x)
+ raise TypeError("isnormal() needs a number as input")
+
+ def isint(ctx, x, gaussian=False):
+ """
+ Return *True* if *x* is integer-valued; otherwise return
+ *False*::
+
+ >>> from mpmath import *
+ >>> isint(3)
+ True
+ >>> isint(mpf(3))
+ True
+ >>> isint(3.2)
+ False
+ >>> isint(inf)
+ False
+
+ Optionally, Gaussian integers can be checked for::
+
+ >>> isint(3+0j)
+ True
+ >>> isint(3+2j)
+ False
+ >>> isint(3+2j, gaussian=True)
+ True
+
+ """
+ if isinstance(x, int_types):
+ return True
+ if hasattr(x, "_mpf_"):
+ sign, man, exp, bc = xval = x._mpf_
+ return bool((man and exp >= 0) or xval == fzero)
+ if hasattr(x, "_mpc_"):
+ re, im = x._mpc_
+ rsign, rman, rexp, rbc = re
+ isign, iman, iexp, ibc = im
+ re_isint = (rman and rexp >= 0) or re == fzero
+ if gaussian:
+ im_isint = (iman and iexp >= 0) or im == fzero
+ return re_isint and im_isint
+ return re_isint and im == fzero
+ if isinstance(x, rational.mpq):
+ p, q = x._mpq_
+ return p % q == 0
+ x = ctx.convert(x)
+ if hasattr(x, '_mpf_') or hasattr(x, '_mpc_'):
+ return ctx.isint(x, gaussian)
+ raise TypeError("isint() needs a number as input")
+
+ def fsum(ctx, terms, absolute=False, squared=False):
+ """
+ Calculates a sum containing a finite number of terms (for infinite
+ series, see :func:`~mpmath.nsum`). The terms will be converted to
+ mpmath numbers. For len(terms) > 2, this function is generally
+ faster and produces more accurate results than the builtin
+ Python function :func:`sum`.
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = False
+ >>> fsum([1, 2, 0.5, 7])
+ mpf('10.5')
+
+ With squared=True each term is squared, and with absolute=True
+ the absolute value of each term is used.
+ """
+ prec, rnd = ctx._prec_rounding
+ real = []
+ imag = []
+ for term in terms:
+ reval = imval = 0
+ if hasattr(term, "_mpf_"):
+ reval = term._mpf_
+ elif hasattr(term, "_mpc_"):
+ reval, imval = term._mpc_
+ else:
+ term = ctx.convert(term)
+ if hasattr(term, "_mpf_"):
+ reval = term._mpf_
+ elif hasattr(term, "_mpc_"):
+ reval, imval = term._mpc_
+ else:
+ raise NotImplementedError
+ if imval:
+ if squared:
+ if absolute:
+ real.append(mpf_mul(reval,reval))
+ real.append(mpf_mul(imval,imval))
+ else:
+ reval, imval = mpc_pow_int((reval,imval),2,prec+10)
+ real.append(reval)
+ imag.append(imval)
+ elif absolute:
+ real.append(mpc_abs((reval,imval), prec))
+ else:
+ real.append(reval)
+ imag.append(imval)
+ else:
+ if squared:
+ reval = mpf_mul(reval, reval)
+ elif absolute:
+ reval = mpf_abs(reval)
+ real.append(reval)
+ s = mpf_sum(real, prec, rnd, absolute)
+ if imag:
+ s = ctx.make_mpc((s, mpf_sum(imag, prec, rnd)))
+ else:
+ s = ctx.make_mpf(s)
+ return s
+
+ def fdot(ctx, A, B=None, conjugate=False):
+ r"""
+ Computes the dot product of the iterables `A` and `B`,
+
+ .. math ::
+
+ \sum_{k=0} A_k B_k.
+
+ Alternatively, :func:`~mpmath.fdot` accepts a single iterable of pairs.
+ In other words, ``fdot(A,B)`` and ``fdot(zip(A,B))`` are equivalent.
+ The elements are automatically converted to mpmath numbers.
+
+ With ``conjugate=True``, the elements in the second vector
+ will be conjugated:
+
+ .. math ::
+
+ \sum_{k=0} A_k \overline{B_k}
+
+ **Examples**
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = False
+ >>> A = [2, 1.5, 3]
+ >>> B = [1, -1, 2]
+ >>> fdot(A, B)
+ mpf('6.5')
+ >>> list(zip(A, B))
+ [(2, 1), (1.5, -1), (3, 2)]
+ >>> fdot(_)
+ mpf('6.5')
+ >>> A = [2, 1.5, 3j]
+ >>> B = [1+j, 3, -1-j]
+ >>> fdot(A, B)
+ mpc(real='9.5', imag='-1.0')
+ >>> fdot(A, B, conjugate=True)
+ mpc(real='3.5', imag='-5.0')
+
+ """
+ if B is not None:
+ A = zip(A, B)
+ prec, rnd = ctx._prec_rounding
+ real = []
+ imag = []
+ hasattr_ = hasattr
+ types = (ctx.mpf, ctx.mpc)
+ for a, b in A:
+ if type(a) not in types: a = ctx.convert(a)
+ if type(b) not in types: b = ctx.convert(b)
+ a_real = hasattr_(a, "_mpf_")
+ b_real = hasattr_(b, "_mpf_")
+ if a_real and b_real:
+ real.append(mpf_mul(a._mpf_, b._mpf_))
+ continue
+ a_complex = hasattr_(a, "_mpc_")
+ b_complex = hasattr_(b, "_mpc_")
+ if a_real and b_complex:
+ aval = a._mpf_
+ bre, bim = b._mpc_
+ if conjugate:
+ bim = mpf_neg(bim)
+ real.append(mpf_mul(aval, bre))
+ imag.append(mpf_mul(aval, bim))
+ elif b_real and a_complex:
+ are, aim = a._mpc_
+ bval = b._mpf_
+ real.append(mpf_mul(are, bval))
+ imag.append(mpf_mul(aim, bval))
+ elif a_complex and b_complex:
+ #re, im = mpc_mul(a._mpc_, b._mpc_, prec+20)
+ are, aim = a._mpc_
+ bre, bim = b._mpc_
+ if conjugate:
+ bim = mpf_neg(bim)
+ real.append(mpf_mul(are, bre))
+ real.append(mpf_neg(mpf_mul(aim, bim)))
+ imag.append(mpf_mul(are, bim))
+ imag.append(mpf_mul(aim, bre))
+ else:
+ raise NotImplementedError
+ s = mpf_sum(real, prec, rnd)
+ if imag:
+ s = ctx.make_mpc((s, mpf_sum(imag, prec, rnd)))
+ else:
+ s = ctx.make_mpf(s)
+ return s
+
+ def _wrap_libmp_function(ctx, mpf_f, mpc_f=None, mpi_f=None, doc=""):
+ """
+ Given a low-level mpf_ function, and optionally similar functions
+ for mpc_ and mpi_, defines the function as a context method.
+
+ It is assumed that the return type is the same as that of
+ the input; the exception is that propagation from mpf to mpc is possible
+ by raising ComplexResult.
+
+ """
+ def f(x, **kwargs):
+ if type(x) not in ctx.types:
+ x = ctx.convert(x)
+ prec, rounding = ctx._prec_rounding
+ if kwargs:
+ prec = kwargs.get('prec', prec)
+ if 'dps' in kwargs:
+ prec = dps_to_prec(kwargs['dps'])
+ rounding = kwargs.get('rounding', rounding)
+ if hasattr(x, '_mpf_'):
+ try:
+ return ctx.make_mpf(mpf_f(x._mpf_, prec, rounding))
+ except ComplexResult:
+ # Handle propagation to complex
+ if ctx.trap_complex:
+ raise
+ return ctx.make_mpc(mpc_f((x._mpf_, fzero), prec, rounding))
+ elif hasattr(x, '_mpc_'):
+ return ctx.make_mpc(mpc_f(x._mpc_, prec, rounding))
+ raise NotImplementedError("%s of a %s" % (name, type(x)))
+ name = mpf_f.__name__[4:]
+ f.__doc__ = function_docs.__dict__.get(name, "Computes the %s of x" % doc)
+ return f
+
+ # Called by SpecialFunctions.__init__()
+ @classmethod
+ def _wrap_specfun(cls, name, f, wrap):
+ if wrap:
+ def f_wrapped(ctx, *args, **kwargs):
+ convert = ctx.convert
+ args = [convert(a) for a in args]
+ prec = ctx.prec
+ try:
+ ctx.prec += 10
+ retval = f(ctx, *args, **kwargs)
+ finally:
+ ctx.prec = prec
+ return +retval
+ else:
+ f_wrapped = f
+ f_wrapped.__doc__ = function_docs.__dict__.get(name, f.__doc__)
+ setattr(cls, name, f_wrapped)
+
+ def _convert_param(ctx, x):
+ if hasattr(x, "_mpc_"):
+ v, im = x._mpc_
+ if im != fzero:
+ return x, 'C'
+ elif hasattr(x, "_mpf_"):
+ v = x._mpf_
+ else:
+ if type(x) in int_types:
+ return int(x), 'Z'
+ p = None
+ if isinstance(x, tuple):
+ p, q = x
+ elif hasattr(x, '_mpq_'):
+ p, q = x._mpq_
+ elif isinstance(x, basestring) and '/' in x:
+ p, q = x.split('/')
+ p = int(p)
+ q = int(q)
+ if p is not None:
+ if not p % q:
+ return p // q, 'Z'
+ return ctx.mpq(p,q), 'Q'
+ x = ctx.convert(x)
+ if hasattr(x, "_mpc_"):
+ v, im = x._mpc_
+ if im != fzero:
+ return x, 'C'
+ elif hasattr(x, "_mpf_"):
+ v = x._mpf_
+ else:
+ return x, 'U'
+ sign, man, exp, bc = v
+ if man:
+ if exp >= -4:
+ if sign:
+ man = -man
+ if exp >= 0:
+ return int(man) << exp, 'Z'
+ if exp >= -4:
+ p, q = int(man), (1<<(-exp))
+ return ctx.mpq(p,q), 'Q'
+ x = ctx.make_mpf(v)
+ return x, 'R'
+ elif not exp:
+ return 0, 'Z'
+ else:
+ return x, 'U'
+
+ def _mpf_mag(ctx, x):
+ sign, man, exp, bc = x
+ if man:
+ return exp+bc
+ if x == fzero:
+ return ctx.ninf
+ if x == finf or x == fninf:
+ return ctx.inf
+ return ctx.nan
+
+ def mag(ctx, x):
+ """
+ Quick logarithmic magnitude estimate of a number. Returns an
+ integer or infinity `m` such that `|x| <= 2^m`. It is not
+ guaranteed that `m` is an optimal bound, but it will never
+ be too large by more than 2 (and probably not more than 1).
+
+ **Examples**
+
+ >>> from mpmath import *
+ >>> mp.pretty = True
+ >>> mag(10), mag(10.0), mag(mpf(10)), int(ceil(log(10,2)))
+ (4, 4, 4, 4)
+ >>> mag(10j), mag(10+10j)
+ (4, 5)
+ >>> mag(0.01), int(ceil(log(0.01,2)))
+ (-6, -6)
+ >>> mag(0), mag(inf), mag(-inf), mag(nan)
+ (-inf, +inf, +inf, nan)
+
+ """
+ if hasattr(x, "_mpf_"):
+ return ctx._mpf_mag(x._mpf_)
+ elif hasattr(x, "_mpc_"):
+ r, i = x._mpc_
+ if r == fzero:
+ return ctx._mpf_mag(i)
+ if i == fzero:
+ return ctx._mpf_mag(r)
+ return 1+max(ctx._mpf_mag(r), ctx._mpf_mag(i))
+ elif isinstance(x, int_types):
+ if x:
+ return bitcount(abs(x))
+ return ctx.ninf
+ elif isinstance(x, rational.mpq):
+ p, q = x._mpq_
+ if p:
+ return 1 + bitcount(abs(p)) - bitcount(q)
+ return ctx.ninf
+ else:
+ x = ctx.convert(x)
+ if hasattr(x, "_mpf_") or hasattr(x, "_mpc_"):
+ return ctx.mag(x)
+ else:
+ raise TypeError("requires an mpf/mpc")
+
+
+# Register with "numbers" ABC
+# We do not subclass, hence we do not use the @abstractmethod checks. While
+# this is less invasive it may turn out that we do not actually support
+# parts of the expected interfaces. See
+# http://docs.python.org/2/library/numbers.html for list of abstract
+# methods.
+try:
+ import numbers
+ numbers.Complex.register(_mpc)
+ numbers.Real.register(_mpf)
+except ImportError:
+ pass
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/mpmath/function_docs.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/mpmath/function_docs.py
new file mode 100644
index 0000000000000000000000000000000000000000..73c071dc30a25c0ea1366e06a407a20206bd18a2
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/mpmath/function_docs.py
@@ -0,0 +1,10201 @@
+"""
+Extended docstrings for functions.py
+"""
+
+
+pi = r"""
+`\pi`, roughly equal to 3.141592654, represents the area of the unit
+circle, the half-period of trigonometric functions, and many other
+things in mathematics.
+
+Mpmath can evaluate `\pi` to arbitrary precision::
+
+ >>> from mpmath import *
+ >>> mp.dps = 50; mp.pretty = True
+ >>> +pi
+ 3.1415926535897932384626433832795028841971693993751
+
+This shows digits 99991-100000 of `\pi` (the last digit is actually
+a 4 when the decimal expansion is truncated, but here the nearest
+rounding is used)::
+
+ >>> mp.dps = 100000
+ >>> str(pi)[-10:]
+ '5549362465'
+
+**Possible issues**
+
+:data:`pi` always rounds to the nearest floating-point
+number when used. This means that exact mathematical identities
+involving `\pi` will generally not be preserved in floating-point
+arithmetic. In particular, multiples of :data:`pi` (except for
+the trivial case ``0*pi``) are *not* the exact roots of
+:func:`~mpmath.sin`, but differ roughly by the current epsilon::
+
+ >>> mp.dps = 15
+ >>> sin(pi)
+ 1.22464679914735e-16
+
+One solution is to use the :func:`~mpmath.sinpi` function instead::
+
+ >>> sinpi(1)
+ 0.0
+
+See the documentation of trigonometric functions for additional
+details.
+
+**References**
+
+* [BorweinBorwein]_
+
+"""
+
+degree = r"""
+Represents one degree of angle, `1^{\circ} = \pi/180`, or
+about 0.01745329. This constant may be evaluated to arbitrary
+precision::
+
+ >>> from mpmath import *
+ >>> mp.dps = 50; mp.pretty = True
+ >>> +degree
+ 0.017453292519943295769236907684886127134428718885417
+
+The :data:`degree` object is convenient for conversion
+to radians::
+
+ >>> sin(30 * degree)
+ 0.5
+ >>> asin(0.5) / degree
+ 30.0
+"""
+
+e = r"""
+The transcendental number `e` = 2.718281828... is the base of the
+natural logarithm (:func:`~mpmath.ln`) and of the exponential function
+(:func:`~mpmath.exp`).
+
+Mpmath can be evaluate `e` to arbitrary precision::
+
+ >>> from mpmath import *
+ >>> mp.dps = 50; mp.pretty = True
+ >>> +e
+ 2.7182818284590452353602874713526624977572470937
+
+This shows digits 99991-100000 of `e` (the last digit is actually
+a 5 when the decimal expansion is truncated, but here the nearest
+rounding is used)::
+
+ >>> mp.dps = 100000
+ >>> str(e)[-10:]
+ '2100427166'
+
+**Possible issues**
+
+:data:`e` always rounds to the nearest floating-point number
+when used, and mathematical identities involving `e` may not
+hold in floating-point arithmetic. For example, ``ln(e)``
+might not evaluate exactly to 1.
+
+In particular, don't use ``e**x`` to compute the exponential
+function. Use ``exp(x)`` instead; this is both faster and more
+accurate.
+"""
+
+phi = r"""
+Represents the golden ratio `\phi = (1+\sqrt 5)/2`,
+approximately equal to 1.6180339887. To high precision,
+its value is::
+
+ >>> from mpmath import *
+ >>> mp.dps = 50; mp.pretty = True
+ >>> +phi
+ 1.6180339887498948482045868343656381177203091798058
+
+Formulas for the golden ratio include the following::
+
+ >>> (1+sqrt(5))/2
+ 1.6180339887498948482045868343656381177203091798058
+ >>> findroot(lambda x: x**2-x-1, 1)
+ 1.6180339887498948482045868343656381177203091798058
+ >>> limit(lambda n: fib(n+1)/fib(n), inf)
+ 1.6180339887498948482045868343656381177203091798058
+"""
+
+euler = r"""
+Euler's constant or the Euler-Mascheroni constant `\gamma`
+= 0.57721566... is a number of central importance to
+number theory and special functions. It is defined as the limit
+
+.. math ::
+
+ \gamma = \lim_{n\to\infty} H_n - \log n
+
+where `H_n = 1 + \frac{1}{2} + \ldots + \frac{1}{n}` is a harmonic
+number (see :func:`~mpmath.harmonic`).
+
+Evaluation of `\gamma` is supported at arbitrary precision::
+
+ >>> from mpmath import *
+ >>> mp.dps = 50; mp.pretty = True
+ >>> +euler
+ 0.57721566490153286060651209008240243104215933593992
+
+We can also compute `\gamma` directly from the definition,
+although this is less efficient::
+
+ >>> limit(lambda n: harmonic(n)-log(n), inf)
+ 0.57721566490153286060651209008240243104215933593992
+
+This shows digits 9991-10000 of `\gamma` (the last digit is actually
+a 5 when the decimal expansion is truncated, but here the nearest
+rounding is used)::
+
+ >>> mp.dps = 10000
+ >>> str(euler)[-10:]
+ '4679858166'
+
+Integrals, series, and representations for `\gamma` in terms of
+special functions include the following (there are many others)::
+
+ >>> mp.dps = 25
+ >>> -quad(lambda x: exp(-x)*log(x), [0,inf])
+ 0.5772156649015328606065121
+ >>> quad(lambda x,y: (x-1)/(1-x*y)/log(x*y), [0,1], [0,1])
+ 0.5772156649015328606065121
+ >>> nsum(lambda k: 1/k-log(1+1/k), [1,inf])
+ 0.5772156649015328606065121
+ >>> nsum(lambda k: (-1)**k*zeta(k)/k, [2,inf])
+ 0.5772156649015328606065121
+ >>> -diff(gamma, 1)
+ 0.5772156649015328606065121
+ >>> limit(lambda x: 1/x-gamma(x), 0)
+ 0.5772156649015328606065121
+ >>> limit(lambda x: zeta(x)-1/(x-1), 1)
+ 0.5772156649015328606065121
+ >>> (log(2*pi*nprod(lambda n:
+ ... exp(-2+2/n)*(1+2/n)**n, [1,inf]))-3)/2
+ 0.5772156649015328606065121
+
+For generalizations of the identities `\gamma = -\Gamma'(1)`
+and `\gamma = \lim_{x\to1} \zeta(x)-1/(x-1)`, see
+:func:`~mpmath.psi` and :func:`~mpmath.stieltjes` respectively.
+
+**References**
+
+* [BorweinBailey]_
+
+"""
+
+catalan = r"""
+Catalan's constant `K` = 0.91596559... is given by the infinite
+series
+
+.. math ::
+
+ K = \sum_{k=0}^{\infty} \frac{(-1)^k}{(2k+1)^2}.
+
+Mpmath can evaluate it to arbitrary precision::
+
+ >>> from mpmath import *
+ >>> mp.dps = 50; mp.pretty = True
+ >>> +catalan
+ 0.91596559417721901505460351493238411077414937428167
+
+One can also compute `K` directly from the definition, although
+this is significantly less efficient::
+
+ >>> nsum(lambda k: (-1)**k/(2*k+1)**2, [0, inf])
+ 0.91596559417721901505460351493238411077414937428167
+
+This shows digits 9991-10000 of `K` (the last digit is actually
+a 3 when the decimal expansion is truncated, but here the nearest
+rounding is used)::
+
+ >>> mp.dps = 10000
+ >>> str(catalan)[-10:]
+ '9537871504'
+
+Catalan's constant has numerous integral representations::
+
+ >>> mp.dps = 50
+ >>> quad(lambda x: -log(x)/(1+x**2), [0, 1])
+ 0.91596559417721901505460351493238411077414937428167
+ >>> quad(lambda x: atan(x)/x, [0, 1])
+ 0.91596559417721901505460351493238411077414937428167
+ >>> quad(lambda x: ellipk(x**2)/2, [0, 1])
+ 0.91596559417721901505460351493238411077414937428167
+ >>> quad(lambda x,y: 1/(1+(x*y)**2), [0, 1], [0, 1])
+ 0.91596559417721901505460351493238411077414937428167
+
+As well as series representations::
+
+ >>> pi*log(sqrt(3)+2)/8 + 3*nsum(lambda n:
+ ... (fac(n)/(2*n+1))**2/fac(2*n), [0, inf])/8
+ 0.91596559417721901505460351493238411077414937428167
+ >>> 1-nsum(lambda n: n*zeta(2*n+1)/16**n, [1,inf])
+ 0.91596559417721901505460351493238411077414937428167
+"""
+
+khinchin = r"""
+Khinchin's constant `K` = 2.68542... is a number that
+appears in the theory of continued fractions. Mpmath can evaluate
+it to arbitrary precision::
+
+ >>> from mpmath import *
+ >>> mp.dps = 50; mp.pretty = True
+ >>> +khinchin
+ 2.6854520010653064453097148354817956938203822939945
+
+An integral representation is::
+
+ >>> I = quad(lambda x: log((1-x**2)/sincpi(x))/x/(1+x), [0, 1])
+ >>> 2*exp(1/log(2)*I)
+ 2.6854520010653064453097148354817956938203822939945
+
+The computation of ``khinchin`` is based on an efficient
+implementation of the following series::
+
+ >>> f = lambda n: (zeta(2*n)-1)/n*sum((-1)**(k+1)/mpf(k)
+ ... for k in range(1,2*int(n)))
+ >>> exp(nsum(f, [1,inf])/log(2))
+ 2.6854520010653064453097148354817956938203822939945
+"""
+
+glaisher = r"""
+Glaisher's constant `A`, also known as the Glaisher-Kinkelin
+constant, is a number approximately equal to 1.282427129 that
+sometimes appears in formulas related to gamma and zeta functions.
+It is also related to the Barnes G-function (see :func:`~mpmath.barnesg`).
+
+The constant is defined as `A = \exp(1/12-\zeta'(-1))` where
+`\zeta'(s)` denotes the derivative of the Riemann zeta function
+(see :func:`~mpmath.zeta`).
+
+Mpmath can evaluate Glaisher's constant to arbitrary precision:
+
+ >>> from mpmath import *
+ >>> mp.dps = 50; mp.pretty = True
+ >>> +glaisher
+ 1.282427129100622636875342568869791727767688927325
+
+We can verify that the value computed by :data:`glaisher` is
+correct using mpmath's facilities for numerical
+differentiation and arbitrary evaluation of the zeta function:
+
+ >>> exp(mpf(1)/12 - diff(zeta, -1))
+ 1.282427129100622636875342568869791727767688927325
+
+Here is an example of an integral that can be evaluated in
+terms of Glaisher's constant:
+
+ >>> mp.dps = 15
+ >>> quad(lambda x: log(gamma(x)), [1, 1.5])
+ -0.0428537406502909
+ >>> -0.5 - 7*log(2)/24 + log(pi)/4 + 3*log(glaisher)/2
+ -0.042853740650291
+
+Mpmath computes Glaisher's constant by applying Euler-Maclaurin
+summation to a slowly convergent series. The implementation is
+reasonably efficient up to about 10,000 digits. See the source
+code for additional details.
+
+References:
+http://mathworld.wolfram.com/Glaisher-KinkelinConstant.html
+"""
+
+apery = r"""
+Represents Apery's constant, which is the irrational number
+approximately equal to 1.2020569 given by
+
+.. math ::
+
+ \zeta(3) = \sum_{k=1}^\infty\frac{1}{k^3}.
+
+The calculation is based on an efficient hypergeometric
+series. To 50 decimal places, the value is given by::
+
+ >>> from mpmath import *
+ >>> mp.dps = 50; mp.pretty = True
+ >>> +apery
+ 1.2020569031595942853997381615114499907649862923405
+
+Other ways to evaluate Apery's constant using mpmath
+include::
+
+ >>> zeta(3)
+ 1.2020569031595942853997381615114499907649862923405
+ >>> -psi(2,1)/2
+ 1.2020569031595942853997381615114499907649862923405
+ >>> 8*nsum(lambda k: 1/(2*k+1)**3, [0,inf])/7
+ 1.2020569031595942853997381615114499907649862923405
+ >>> f = lambda k: 2/k**3/(exp(2*pi*k)-1)
+ >>> 7*pi**3/180 - nsum(f, [1,inf])
+ 1.2020569031595942853997381615114499907649862923405
+
+This shows digits 9991-10000 of Apery's constant::
+
+ >>> mp.dps = 10000
+ >>> str(apery)[-10:]
+ '3189504235'
+"""
+
+mertens = r"""
+Represents the Mertens or Meissel-Mertens constant, which is the
+prime number analog of Euler's constant:
+
+.. math ::
+
+ B_1 = \lim_{N\to\infty}
+ \left(\sum_{p_k \le N} \frac{1}{p_k} - \log \log N \right)
+
+Here `p_k` denotes the `k`-th prime number. Other names for this
+constant include the Hadamard-de la Vallee-Poussin constant or
+the prime reciprocal constant.
+
+The following gives the Mertens constant to 50 digits::
+
+ >>> from mpmath import *
+ >>> mp.dps = 50; mp.pretty = True
+ >>> +mertens
+ 0.2614972128476427837554268386086958590515666482612
+
+References:
+http://mathworld.wolfram.com/MertensConstant.html
+"""
+
+twinprime = r"""
+Represents the twin prime constant, which is the factor `C_2`
+featuring in the Hardy-Littlewood conjecture for the growth of the
+twin prime counting function,
+
+.. math ::
+
+ \pi_2(n) \sim 2 C_2 \frac{n}{\log^2 n}.
+
+It is given by the product over primes
+
+.. math ::
+
+ C_2 = \prod_{p\ge3} \frac{p(p-2)}{(p-1)^2} \approx 0.66016
+
+Computing `C_2` to 50 digits::
+
+ >>> from mpmath import *
+ >>> mp.dps = 50; mp.pretty = True
+ >>> +twinprime
+ 0.66016181584686957392781211001455577843262336028473
+
+References:
+http://mathworld.wolfram.com/TwinPrimesConstant.html
+"""
+
+ln = r"""
+Computes the natural logarithm of `x`, `\ln x`.
+See :func:`~mpmath.log` for additional documentation."""
+
+sqrt = r"""
+``sqrt(x)`` gives the principal square root of `x`, `\sqrt x`.
+For positive real numbers, the principal root is simply the
+positive square root. For arbitrary complex numbers, the principal
+square root is defined to satisfy `\sqrt x = \exp(\log(x)/2)`.
+The function thus has a branch cut along the negative half real axis.
+
+For all mpmath numbers ``x``, calling ``sqrt(x)`` is equivalent to
+performing ``x**0.5``.
+
+**Examples**
+
+Basic examples and limits::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> sqrt(10)
+ 3.16227766016838
+ >>> sqrt(100)
+ 10.0
+ >>> sqrt(-4)
+ (0.0 + 2.0j)
+ >>> sqrt(1+1j)
+ (1.09868411346781 + 0.455089860562227j)
+ >>> sqrt(inf)
+ +inf
+
+Square root evaluation is fast at huge precision::
+
+ >>> mp.dps = 50000
+ >>> a = sqrt(3)
+ >>> str(a)[-10:]
+ '9329332815'
+
+:func:`mpmath.iv.sqrt` supports interval arguments::
+
+ >>> iv.dps = 15; iv.pretty = True
+ >>> iv.sqrt([16,100])
+ [4.0, 10.0]
+ >>> iv.sqrt(2)
+ [1.4142135623730949234, 1.4142135623730951455]
+ >>> iv.sqrt(2) ** 2
+ [1.9999999999999995559, 2.0000000000000004441]
+
+"""
+
+cbrt = r"""
+``cbrt(x)`` computes the cube root of `x`, `x^{1/3}`. This
+function is faster and more accurate than raising to a floating-point
+fraction::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = False
+ >>> 125**(mpf(1)/3)
+ mpf('4.9999999999999991')
+ >>> cbrt(125)
+ mpf('5.0')
+
+Every nonzero complex number has three cube roots. This function
+returns the cube root defined by `\exp(\log(x)/3)` where the
+principal branch of the natural logarithm is used. Note that this
+does not give a real cube root for negative real numbers::
+
+ >>> mp.pretty = True
+ >>> cbrt(-1)
+ (0.5 + 0.866025403784439j)
+"""
+
+exp = r"""
+Computes the exponential function,
+
+.. math ::
+
+ \exp(x) = e^x = \sum_{k=0}^{\infty} \frac{x^k}{k!}.
+
+For complex numbers, the exponential function also satisfies
+
+.. math ::
+
+ \exp(x+yi) = e^x (\cos y + i \sin y).
+
+**Basic examples**
+
+Some values of the exponential function::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> exp(0)
+ 1.0
+ >>> exp(1)
+ 2.718281828459045235360287
+ >>> exp(-1)
+ 0.3678794411714423215955238
+ >>> exp(inf)
+ +inf
+ >>> exp(-inf)
+ 0.0
+
+Arguments can be arbitrarily large::
+
+ >>> exp(10000)
+ 8.806818225662921587261496e+4342
+ >>> exp(-10000)
+ 1.135483865314736098540939e-4343
+
+Evaluation is supported for interval arguments via
+:func:`mpmath.iv.exp`::
+
+ >>> iv.dps = 25; iv.pretty = True
+ >>> iv.exp([-inf,0])
+ [0.0, 1.0]
+ >>> iv.exp([0,1])
+ [1.0, 2.71828182845904523536028749558]
+
+The exponential function can be evaluated efficiently to arbitrary
+precision::
+
+ >>> mp.dps = 10000
+ >>> exp(pi) #doctest: +ELLIPSIS
+ 23.140692632779269005729...8984304016040616
+
+**Functional properties**
+
+Numerical verification of Euler's identity for the complex
+exponential function::
+
+ >>> mp.dps = 15
+ >>> exp(j*pi)+1
+ (0.0 + 1.22464679914735e-16j)
+ >>> chop(exp(j*pi)+1)
+ 0.0
+
+This recovers the coefficients (reciprocal factorials) in the
+Maclaurin series expansion of exp::
+
+ >>> nprint(taylor(exp, 0, 5))
+ [1.0, 1.0, 0.5, 0.166667, 0.0416667, 0.00833333]
+
+The exponential function is its own derivative and antiderivative::
+
+ >>> exp(pi)
+ 23.1406926327793
+ >>> diff(exp, pi)
+ 23.1406926327793
+ >>> quad(exp, [-inf, pi])
+ 23.1406926327793
+
+The exponential function can be evaluated using various methods,
+including direct summation of the series, limits, and solving
+the defining differential equation::
+
+ >>> nsum(lambda k: pi**k/fac(k), [0,inf])
+ 23.1406926327793
+ >>> limit(lambda k: (1+pi/k)**k, inf)
+ 23.1406926327793
+ >>> odefun(lambda t, x: x, 0, 1)(pi)
+ 23.1406926327793
+"""
+
+cosh = r"""
+Computes the hyperbolic cosine of `x`,
+`\cosh(x) = (e^x + e^{-x})/2`. Values and limits include::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> cosh(0)
+ 1.0
+ >>> cosh(1)
+ 1.543080634815243778477906
+ >>> cosh(-inf), cosh(+inf)
+ (+inf, +inf)
+
+The hyperbolic cosine is an even, convex function with
+a global minimum at `x = 0`, having a Maclaurin series
+that starts::
+
+ >>> nprint(chop(taylor(cosh, 0, 5)))
+ [1.0, 0.0, 0.5, 0.0, 0.0416667, 0.0]
+
+Generalized to complex numbers, the hyperbolic cosine is
+equivalent to a cosine with the argument rotated
+in the imaginary direction, or `\cosh x = \cos ix`::
+
+ >>> cosh(2+3j)
+ (-3.724545504915322565473971 + 0.5118225699873846088344638j)
+ >>> cos(3-2j)
+ (-3.724545504915322565473971 + 0.5118225699873846088344638j)
+"""
+
+sinh = r"""
+Computes the hyperbolic sine of `x`,
+`\sinh(x) = (e^x - e^{-x})/2`. Values and limits include::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> sinh(0)
+ 0.0
+ >>> sinh(1)
+ 1.175201193643801456882382
+ >>> sinh(-inf), sinh(+inf)
+ (-inf, +inf)
+
+The hyperbolic sine is an odd function, with a Maclaurin
+series that starts::
+
+ >>> nprint(chop(taylor(sinh, 0, 5)))
+ [0.0, 1.0, 0.0, 0.166667, 0.0, 0.00833333]
+
+Generalized to complex numbers, the hyperbolic sine is
+essentially a sine with a rotation `i` applied to
+the argument; more precisely, `\sinh x = -i \sin ix`::
+
+ >>> sinh(2+3j)
+ (-3.590564589985779952012565 + 0.5309210862485198052670401j)
+ >>> j*sin(3-2j)
+ (-3.590564589985779952012565 + 0.5309210862485198052670401j)
+"""
+
+tanh = r"""
+Computes the hyperbolic tangent of `x`,
+`\tanh(x) = \sinh(x)/\cosh(x)`. Values and limits include::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> tanh(0)
+ 0.0
+ >>> tanh(1)
+ 0.7615941559557648881194583
+ >>> tanh(-inf), tanh(inf)
+ (-1.0, 1.0)
+
+The hyperbolic tangent is an odd, sigmoidal function, similar
+to the inverse tangent and error function. Its Maclaurin
+series is::
+
+ >>> nprint(chop(taylor(tanh, 0, 5)))
+ [0.0, 1.0, 0.0, -0.333333, 0.0, 0.133333]
+
+Generalized to complex numbers, the hyperbolic tangent is
+essentially a tangent with a rotation `i` applied to
+the argument; more precisely, `\tanh x = -i \tan ix`::
+
+ >>> tanh(2+3j)
+ (0.9653858790221331242784803 - 0.009884375038322493720314034j)
+ >>> j*tan(3-2j)
+ (0.9653858790221331242784803 - 0.009884375038322493720314034j)
+"""
+
+cos = r"""
+Computes the cosine of `x`, `\cos(x)`.
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> cos(pi/3)
+ 0.5
+ >>> cos(100000001)
+ -0.9802850113244713353133243
+ >>> cos(2+3j)
+ (-4.189625690968807230132555 - 9.109227893755336597979197j)
+ >>> cos(inf)
+ nan
+ >>> nprint(chop(taylor(cos, 0, 6)))
+ [1.0, 0.0, -0.5, 0.0, 0.0416667, 0.0, -0.00138889]
+
+Intervals are supported via :func:`mpmath.iv.cos`::
+
+ >>> iv.dps = 25; iv.pretty = True
+ >>> iv.cos([0,1])
+ [0.540302305868139717400936602301, 1.0]
+ >>> iv.cos([0,2])
+ [-0.41614683654714238699756823214, 1.0]
+"""
+
+sin = r"""
+Computes the sine of `x`, `\sin(x)`.
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> sin(pi/3)
+ 0.8660254037844386467637232
+ >>> sin(100000001)
+ 0.1975887055794968911438743
+ >>> sin(2+3j)
+ (9.1544991469114295734673 - 4.168906959966564350754813j)
+ >>> sin(inf)
+ nan
+ >>> nprint(chop(taylor(sin, 0, 6)))
+ [0.0, 1.0, 0.0, -0.166667, 0.0, 0.00833333, 0.0]
+
+Intervals are supported via :func:`mpmath.iv.sin`::
+
+ >>> iv.dps = 25; iv.pretty = True
+ >>> iv.sin([0,1])
+ [0.0, 0.841470984807896506652502331201]
+ >>> iv.sin([0,2])
+ [0.0, 1.0]
+"""
+
+tan = r"""
+Computes the tangent of `x`, `\tan(x) = \frac{\sin(x)}{\cos(x)}`.
+The tangent function is singular at `x = (n+1/2)\pi`, but
+``tan(x)`` always returns a finite result since `(n+1/2)\pi`
+cannot be represented exactly using floating-point arithmetic.
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> tan(pi/3)
+ 1.732050807568877293527446
+ >>> tan(100000001)
+ -0.2015625081449864533091058
+ >>> tan(2+3j)
+ (-0.003764025641504248292751221 + 1.003238627353609801446359j)
+ >>> tan(inf)
+ nan
+ >>> nprint(chop(taylor(tan, 0, 6)))
+ [0.0, 1.0, 0.0, 0.333333, 0.0, 0.133333, 0.0]
+
+Intervals are supported via :func:`mpmath.iv.tan`::
+
+ >>> iv.dps = 25; iv.pretty = True
+ >>> iv.tan([0,1])
+ [0.0, 1.55740772465490223050697482944]
+ >>> iv.tan([0,2]) # Interval includes a singularity
+ [-inf, +inf]
+"""
+
+sec = r"""
+Computes the secant of `x`, `\mathrm{sec}(x) = \frac{1}{\cos(x)}`.
+The secant function is singular at `x = (n+1/2)\pi`, but
+``sec(x)`` always returns a finite result since `(n+1/2)\pi`
+cannot be represented exactly using floating-point arithmetic.
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> sec(pi/3)
+ 2.0
+ >>> sec(10000001)
+ -1.184723164360392819100265
+ >>> sec(2+3j)
+ (-0.04167496441114427004834991 + 0.0906111371962375965296612j)
+ >>> sec(inf)
+ nan
+ >>> nprint(chop(taylor(sec, 0, 6)))
+ [1.0, 0.0, 0.5, 0.0, 0.208333, 0.0, 0.0847222]
+
+Intervals are supported via :func:`mpmath.iv.sec`::
+
+ >>> iv.dps = 25; iv.pretty = True
+ >>> iv.sec([0,1])
+ [1.0, 1.85081571768092561791175326276]
+ >>> iv.sec([0,2]) # Interval includes a singularity
+ [-inf, +inf]
+"""
+
+csc = r"""
+Computes the cosecant of `x`, `\mathrm{csc}(x) = \frac{1}{\sin(x)}`.
+This cosecant function is singular at `x = n \pi`, but with the
+exception of the point `x = 0`, ``csc(x)`` returns a finite result
+since `n \pi` cannot be represented exactly using floating-point
+arithmetic.
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> csc(pi/3)
+ 1.154700538379251529018298
+ >>> csc(10000001)
+ -1.864910497503629858938891
+ >>> csc(2+3j)
+ (0.09047320975320743980579048 + 0.04120098628857412646300981j)
+ >>> csc(inf)
+ nan
+
+Intervals are supported via :func:`mpmath.iv.csc`::
+
+ >>> iv.dps = 25; iv.pretty = True
+ >>> iv.csc([0,1]) # Interval includes a singularity
+ [1.18839510577812121626159943988, +inf]
+ >>> iv.csc([0,2])
+ [1.0, +inf]
+"""
+
+cot = r"""
+Computes the cotangent of `x`,
+`\mathrm{cot}(x) = \frac{1}{\tan(x)} = \frac{\cos(x)}{\sin(x)}`.
+This cotangent function is singular at `x = n \pi`, but with the
+exception of the point `x = 0`, ``cot(x)`` returns a finite result
+since `n \pi` cannot be represented exactly using floating-point
+arithmetic.
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> cot(pi/3)
+ 0.5773502691896257645091488
+ >>> cot(10000001)
+ 1.574131876209625656003562
+ >>> cot(2+3j)
+ (-0.003739710376336956660117409 - 0.9967577965693583104609688j)
+ >>> cot(inf)
+ nan
+
+Intervals are supported via :func:`mpmath.iv.cot`::
+
+ >>> iv.dps = 25; iv.pretty = True
+ >>> iv.cot([0,1]) # Interval includes a singularity
+ [0.642092615934330703006419974862, +inf]
+ >>> iv.cot([1,2])
+ [-inf, +inf]
+"""
+
+acos = r"""
+Computes the inverse cosine or arccosine of `x`, `\cos^{-1}(x)`.
+Since `-1 \le \cos(x) \le 1` for real `x`, the inverse
+cosine is real-valued only for `-1 \le x \le 1`. On this interval,
+:func:`~mpmath.acos` is defined to be a monotonically decreasing
+function assuming values between `+\pi` and `0`.
+
+Basic values are::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> acos(-1)
+ 3.141592653589793238462643
+ >>> acos(0)
+ 1.570796326794896619231322
+ >>> acos(1)
+ 0.0
+ >>> nprint(chop(taylor(acos, 0, 6)))
+ [1.5708, -1.0, 0.0, -0.166667, 0.0, -0.075, 0.0]
+
+:func:`~mpmath.acos` is defined so as to be a proper inverse function of
+`\cos(\theta)` for `0 \le \theta < \pi`.
+We have `\cos(\cos^{-1}(x)) = x` for all `x`, but
+`\cos^{-1}(\cos(x)) = x` only for `0 \le \Re[x] < \pi`::
+
+ >>> for x in [1, 10, -1, 2+3j, 10+3j]:
+ ... print("%s %s" % (cos(acos(x)), acos(cos(x))))
+ ...
+ 1.0 1.0
+ (10.0 + 0.0j) 2.566370614359172953850574
+ -1.0 1.0
+ (2.0 + 3.0j) (2.0 + 3.0j)
+ (10.0 + 3.0j) (2.566370614359172953850574 - 3.0j)
+
+The inverse cosine has two branch points: `x = \pm 1`. :func:`~mpmath.acos`
+places the branch cuts along the line segments `(-\infty, -1)` and
+`(+1, +\infty)`. In general,
+
+.. math ::
+
+ \cos^{-1}(x) = \frac{\pi}{2} + i \log\left(ix + \sqrt{1-x^2} \right)
+
+where the principal-branch log and square root are implied.
+"""
+
+asin = r"""
+Computes the inverse sine or arcsine of `x`, `\sin^{-1}(x)`.
+Since `-1 \le \sin(x) \le 1` for real `x`, the inverse
+sine is real-valued only for `-1 \le x \le 1`.
+On this interval, it is defined to be a monotonically increasing
+function assuming values between `-\pi/2` and `\pi/2`.
+
+Basic values are::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> asin(-1)
+ -1.570796326794896619231322
+ >>> asin(0)
+ 0.0
+ >>> asin(1)
+ 1.570796326794896619231322
+ >>> nprint(chop(taylor(asin, 0, 6)))
+ [0.0, 1.0, 0.0, 0.166667, 0.0, 0.075, 0.0]
+
+:func:`~mpmath.asin` is defined so as to be a proper inverse function of
+`\sin(\theta)` for `-\pi/2 < \theta < \pi/2`.
+We have `\sin(\sin^{-1}(x)) = x` for all `x`, but
+`\sin^{-1}(\sin(x)) = x` only for `-\pi/2 < \Re[x] < \pi/2`::
+
+ >>> for x in [1, 10, -1, 1+3j, -2+3j]:
+ ... print("%s %s" % (chop(sin(asin(x))), asin(sin(x))))
+ ...
+ 1.0 1.0
+ 10.0 -0.5752220392306202846120698
+ -1.0 -1.0
+ (1.0 + 3.0j) (1.0 + 3.0j)
+ (-2.0 + 3.0j) (-1.141592653589793238462643 - 3.0j)
+
+The inverse sine has two branch points: `x = \pm 1`. :func:`~mpmath.asin`
+places the branch cuts along the line segments `(-\infty, -1)` and
+`(+1, +\infty)`. In general,
+
+.. math ::
+
+ \sin^{-1}(x) = -i \log\left(ix + \sqrt{1-x^2} \right)
+
+where the principal-branch log and square root are implied.
+"""
+
+atan = r"""
+Computes the inverse tangent or arctangent of `x`, `\tan^{-1}(x)`.
+This is a real-valued function for all real `x`, with range
+`(-\pi/2, \pi/2)`.
+
+Basic values are::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> atan(-inf)
+ -1.570796326794896619231322
+ >>> atan(-1)
+ -0.7853981633974483096156609
+ >>> atan(0)
+ 0.0
+ >>> atan(1)
+ 0.7853981633974483096156609
+ >>> atan(inf)
+ 1.570796326794896619231322
+ >>> nprint(chop(taylor(atan, 0, 6)))
+ [0.0, 1.0, 0.0, -0.333333, 0.0, 0.2, 0.0]
+
+The inverse tangent is often used to compute angles. However,
+the atan2 function is often better for this as it preserves sign
+(see :func:`~mpmath.atan2`).
+
+:func:`~mpmath.atan` is defined so as to be a proper inverse function of
+`\tan(\theta)` for `-\pi/2 < \theta < \pi/2`.
+We have `\tan(\tan^{-1}(x)) = x` for all `x`, but
+`\tan^{-1}(\tan(x)) = x` only for `-\pi/2 < \Re[x] < \pi/2`::
+
+ >>> mp.dps = 25
+ >>> for x in [1, 10, -1, 1+3j, -2+3j]:
+ ... print("%s %s" % (tan(atan(x)), atan(tan(x))))
+ ...
+ 1.0 1.0
+ 10.0 0.5752220392306202846120698
+ -1.0 -1.0
+ (1.0 + 3.0j) (1.000000000000000000000001 + 3.0j)
+ (-2.0 + 3.0j) (1.141592653589793238462644 + 3.0j)
+
+The inverse tangent has two branch points: `x = \pm i`. :func:`~mpmath.atan`
+places the branch cuts along the line segments `(-i \infty, -i)` and
+`(+i, +i \infty)`. In general,
+
+.. math ::
+
+ \tan^{-1}(x) = \frac{i}{2}\left(\log(1-ix)-\log(1+ix)\right)
+
+where the principal-branch log is implied.
+"""
+
+acot = r"""Computes the inverse cotangent of `x`,
+`\mathrm{cot}^{-1}(x) = \tan^{-1}(1/x)`."""
+
+asec = r"""Computes the inverse secant of `x`,
+`\mathrm{sec}^{-1}(x) = \cos^{-1}(1/x)`."""
+
+acsc = r"""Computes the inverse cosecant of `x`,
+`\mathrm{csc}^{-1}(x) = \sin^{-1}(1/x)`."""
+
+coth = r"""Computes the hyperbolic cotangent of `x`,
+`\mathrm{coth}(x) = \frac{\cosh(x)}{\sinh(x)}`.
+"""
+
+sech = r"""Computes the hyperbolic secant of `x`,
+`\mathrm{sech}(x) = \frac{1}{\cosh(x)}`.
+"""
+
+csch = r"""Computes the hyperbolic cosecant of `x`,
+`\mathrm{csch}(x) = \frac{1}{\sinh(x)}`.
+"""
+
+acosh = r"""Computes the inverse hyperbolic cosine of `x`,
+`\mathrm{cosh}^{-1}(x) = \log(x+\sqrt{x+1}\sqrt{x-1})`.
+"""
+
+asinh = r"""Computes the inverse hyperbolic sine of `x`,
+`\mathrm{sinh}^{-1}(x) = \log(x+\sqrt{1+x^2})`.
+"""
+
+atanh = r"""Computes the inverse hyperbolic tangent of `x`,
+`\mathrm{tanh}^{-1}(x) = \frac{1}{2}\left(\log(1+x)-\log(1-x)\right)`.
+"""
+
+acoth = r"""Computes the inverse hyperbolic cotangent of `x`,
+`\mathrm{coth}^{-1}(x) = \tanh^{-1}(1/x)`."""
+
+asech = r"""Computes the inverse hyperbolic secant of `x`,
+`\mathrm{sech}^{-1}(x) = \cosh^{-1}(1/x)`."""
+
+acsch = r"""Computes the inverse hyperbolic cosecant of `x`,
+`\mathrm{csch}^{-1}(x) = \sinh^{-1}(1/x)`."""
+
+
+
+sinpi = r"""
+Computes `\sin(\pi x)`, more accurately than the expression
+``sin(pi*x)``::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> sinpi(10**10), sin(pi*(10**10))
+ (0.0, -2.23936276195592e-6)
+ >>> sinpi(10**10+0.5), sin(pi*(10**10+0.5))
+ (1.0, 0.999999999998721)
+"""
+
+cospi = r"""
+Computes `\cos(\pi x)`, more accurately than the expression
+``cos(pi*x)``::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> cospi(10**10), cos(pi*(10**10))
+ (1.0, 0.999999999997493)
+ >>> cospi(10**10+0.5), cos(pi*(10**10+0.5))
+ (0.0, 1.59960492420134e-6)
+"""
+
+sinc = r"""
+``sinc(x)`` computes the unnormalized sinc function, defined as
+
+.. math ::
+
+ \mathrm{sinc}(x) = \begin{cases}
+ \sin(x)/x, & \mbox{if } x \ne 0 \\
+ 1, & \mbox{if } x = 0.
+ \end{cases}
+
+See :func:`~mpmath.sincpi` for the normalized sinc function.
+
+Simple values and limits include::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> sinc(0)
+ 1.0
+ >>> sinc(1)
+ 0.841470984807897
+ >>> sinc(inf)
+ 0.0
+
+The integral of the sinc function is the sine integral Si::
+
+ >>> quad(sinc, [0, 1])
+ 0.946083070367183
+ >>> si(1)
+ 0.946083070367183
+"""
+
+sincpi = r"""
+``sincpi(x)`` computes the normalized sinc function, defined as
+
+.. math ::
+
+ \mathrm{sinc}_{\pi}(x) = \begin{cases}
+ \sin(\pi x)/(\pi x), & \mbox{if } x \ne 0 \\
+ 1, & \mbox{if } x = 0.
+ \end{cases}
+
+Equivalently, we have
+`\mathrm{sinc}_{\pi}(x) = \mathrm{sinc}(\pi x)`.
+
+The normalization entails that the function integrates
+to unity over the entire real line::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> quadosc(sincpi, [-inf, inf], period=2.0)
+ 1.0
+
+Like, :func:`~mpmath.sinpi`, :func:`~mpmath.sincpi` is evaluated accurately
+at its roots::
+
+ >>> sincpi(10)
+ 0.0
+"""
+
+expj = r"""
+Convenience function for computing `e^{ix}`::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> expj(0)
+ (1.0 + 0.0j)
+ >>> expj(-1)
+ (0.5403023058681397174009366 - 0.8414709848078965066525023j)
+ >>> expj(j)
+ (0.3678794411714423215955238 + 0.0j)
+ >>> expj(1+j)
+ (0.1987661103464129406288032 + 0.3095598756531121984439128j)
+"""
+
+expjpi = r"""
+Convenience function for computing `e^{i \pi x}`.
+Evaluation is accurate near zeros (see also :func:`~mpmath.cospi`,
+:func:`~mpmath.sinpi`)::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> expjpi(0)
+ (1.0 + 0.0j)
+ >>> expjpi(1)
+ (-1.0 + 0.0j)
+ >>> expjpi(0.5)
+ (0.0 + 1.0j)
+ >>> expjpi(-1)
+ (-1.0 + 0.0j)
+ >>> expjpi(j)
+ (0.04321391826377224977441774 + 0.0j)
+ >>> expjpi(1+j)
+ (-0.04321391826377224977441774 + 0.0j)
+"""
+
+floor = r"""
+Computes the floor of `x`, `\lfloor x \rfloor`, defined as
+the largest integer less than or equal to `x`::
+
+ >>> from mpmath import *
+ >>> mp.pretty = False
+ >>> floor(3.5)
+ mpf('3.0')
+
+.. note ::
+
+ :func:`~mpmath.floor`, :func:`~mpmath.ceil` and :func:`~mpmath.nint` return a
+ floating-point number, not a Python ``int``. If `\lfloor x \rfloor` is
+ too large to be represented exactly at the present working precision,
+ the result will be rounded, not necessarily in the direction
+ implied by the mathematical definition of the function.
+
+To avoid rounding, use *prec=0*::
+
+ >>> mp.dps = 15
+ >>> print(int(floor(10**30+1)))
+ 1000000000000000019884624838656
+ >>> print(int(floor(10**30+1, prec=0)))
+ 1000000000000000000000000000001
+
+The floor function is defined for complex numbers and
+acts on the real and imaginary parts separately::
+
+ >>> floor(3.25+4.75j)
+ mpc(real='3.0', imag='4.0')
+"""
+
+ceil = r"""
+Computes the ceiling of `x`, `\lceil x \rceil`, defined as
+the smallest integer greater than or equal to `x`::
+
+ >>> from mpmath import *
+ >>> mp.pretty = False
+ >>> ceil(3.5)
+ mpf('4.0')
+
+The ceiling function is defined for complex numbers and
+acts on the real and imaginary parts separately::
+
+ >>> ceil(3.25+4.75j)
+ mpc(real='4.0', imag='5.0')
+
+See notes about rounding for :func:`~mpmath.floor`.
+"""
+
+nint = r"""
+Evaluates the nearest integer function, `\mathrm{nint}(x)`.
+This gives the nearest integer to `x`; on a tie, it
+gives the nearest even integer::
+
+ >>> from mpmath import *
+ >>> mp.pretty = False
+ >>> nint(3.2)
+ mpf('3.0')
+ >>> nint(3.8)
+ mpf('4.0')
+ >>> nint(3.5)
+ mpf('4.0')
+ >>> nint(4.5)
+ mpf('4.0')
+
+The nearest integer function is defined for complex numbers and
+acts on the real and imaginary parts separately::
+
+ >>> nint(3.25+4.75j)
+ mpc(real='3.0', imag='5.0')
+
+See notes about rounding for :func:`~mpmath.floor`.
+"""
+
+frac = r"""
+Gives the fractional part of `x`, defined as
+`\mathrm{frac}(x) = x - \lfloor x \rfloor` (see :func:`~mpmath.floor`).
+In effect, this computes `x` modulo 1, or `x+n` where
+`n \in \mathbb{Z}` is such that `x+n \in [0,1)`::
+
+ >>> from mpmath import *
+ >>> mp.pretty = False
+ >>> frac(1.25)
+ mpf('0.25')
+ >>> frac(3)
+ mpf('0.0')
+ >>> frac(-1.25)
+ mpf('0.75')
+
+For a complex number, the fractional part function applies to
+the real and imaginary parts separately::
+
+ >>> frac(2.25+3.75j)
+ mpc(real='0.25', imag='0.75')
+
+Plotted, the fractional part function gives a sawtooth
+wave. The Fourier series coefficients have a simple
+form::
+
+ >>> mp.dps = 15
+ >>> nprint(fourier(lambda x: frac(x)-0.5, [0,1], 4))
+ ([0.0, 0.0, 0.0, 0.0, 0.0], [0.0, -0.31831, -0.159155, -0.106103, -0.0795775])
+ >>> nprint([-1/(pi*k) for k in range(1,5)])
+ [-0.31831, -0.159155, -0.106103, -0.0795775]
+
+.. note::
+
+ The fractional part is sometimes defined as a symmetric
+ function, i.e. returning `-\mathrm{frac}(-x)` if `x < 0`.
+ This convention is used, for instance, by Mathematica's
+ ``FractionalPart``.
+
+"""
+
+sign = r"""
+Returns the sign of `x`, defined as `\mathrm{sign}(x) = x / |x|`
+(with the special case `\mathrm{sign}(0) = 0`)::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = False
+ >>> sign(10)
+ mpf('1.0')
+ >>> sign(-10)
+ mpf('-1.0')
+ >>> sign(0)
+ mpf('0.0')
+
+Note that the sign function is also defined for complex numbers,
+for which it gives the projection onto the unit circle::
+
+ >>> mp.dps = 15; mp.pretty = True
+ >>> sign(1+j)
+ (0.707106781186547 + 0.707106781186547j)
+
+"""
+
+arg = r"""
+Computes the complex argument (phase) of `x`, defined as the
+signed angle between the positive real axis and `x` in the
+complex plane::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> arg(3)
+ 0.0
+ >>> arg(3+3j)
+ 0.785398163397448
+ >>> arg(3j)
+ 1.5707963267949
+ >>> arg(-3)
+ 3.14159265358979
+ >>> arg(-3j)
+ -1.5707963267949
+
+The angle is defined to satisfy `-\pi < \arg(x) \le \pi` and
+with the sign convention that a nonnegative imaginary part
+results in a nonnegative argument.
+
+The value returned by :func:`~mpmath.arg` is an ``mpf`` instance.
+"""
+
+fabs = r"""
+Returns the absolute value of `x`, `|x|`. Unlike :func:`abs`,
+:func:`~mpmath.fabs` converts non-mpmath numbers (such as ``int``)
+into mpmath numbers::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = False
+ >>> fabs(3)
+ mpf('3.0')
+ >>> fabs(-3)
+ mpf('3.0')
+ >>> fabs(3+4j)
+ mpf('5.0')
+"""
+
+re = r"""
+Returns the real part of `x`, `\Re(x)`. :func:`~mpmath.re`
+converts a non-mpmath number to an mpmath number::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = False
+ >>> re(3)
+ mpf('3.0')
+ >>> re(-1+4j)
+ mpf('-1.0')
+"""
+
+im = r"""
+Returns the imaginary part of `x`, `\Im(x)`. :func:`~mpmath.im`
+converts a non-mpmath number to an mpmath number::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = False
+ >>> im(3)
+ mpf('0.0')
+ >>> im(-1+4j)
+ mpf('4.0')
+"""
+
+conj = r"""
+Returns the complex conjugate of `x`, `\overline{x}`. Unlike
+``x.conjugate()``, :func:`~mpmath.im` converts `x` to a mpmath number::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = False
+ >>> conj(3)
+ mpf('3.0')
+ >>> conj(-1+4j)
+ mpc(real='-1.0', imag='-4.0')
+"""
+
+polar = r"""
+Returns the polar representation of the complex number `z`
+as a pair `(r, \phi)` such that `z = r e^{i \phi}`::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> polar(-2)
+ (2.0, 3.14159265358979)
+ >>> polar(3-4j)
+ (5.0, -0.927295218001612)
+"""
+
+rect = r"""
+Returns the complex number represented by polar
+coordinates `(r, \phi)`::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> chop(rect(2, pi))
+ -2.0
+ >>> rect(sqrt(2), -pi/4)
+ (1.0 - 1.0j)
+"""
+
+expm1 = r"""
+Computes `e^x - 1`, accurately for small `x`.
+
+Unlike the expression ``exp(x) - 1``, ``expm1(x)`` does not suffer from
+potentially catastrophic cancellation::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> exp(1e-10)-1; print(expm1(1e-10))
+ 1.00000008274037e-10
+ 1.00000000005e-10
+ >>> exp(1e-20)-1; print(expm1(1e-20))
+ 0.0
+ 1.0e-20
+ >>> 1/(exp(1e-20)-1)
+ Traceback (most recent call last):
+ ...
+ ZeroDivisionError
+ >>> 1/expm1(1e-20)
+ 1.0e+20
+
+Evaluation works for extremely tiny values::
+
+ >>> expm1(0)
+ 0.0
+ >>> expm1('1e-10000000')
+ 1.0e-10000000
+
+"""
+
+log1p = r"""
+Computes `\log(1+x)`, accurately for small `x`.
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> log(1+1e-10); print(mp.log1p(1e-10))
+ 1.00000008269037e-10
+ 9.9999999995e-11
+ >>> mp.log1p(1e-100j)
+ (5.0e-201 + 1.0e-100j)
+ >>> mp.log1p(0)
+ 0.0
+
+"""
+
+
+powm1 = r"""
+Computes `x^y - 1`, accurately when `x^y` is very close to 1.
+
+This avoids potentially catastrophic cancellation::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> power(0.99999995, 1e-10) - 1
+ 0.0
+ >>> powm1(0.99999995, 1e-10)
+ -5.00000012791934e-18
+
+Powers exactly equal to 1, and only those powers, yield 0 exactly::
+
+ >>> powm1(-j, 4)
+ (0.0 + 0.0j)
+ >>> powm1(3, 0)
+ 0.0
+ >>> powm1(fadd(-1, 1e-100, exact=True), 4)
+ -4.0e-100
+
+Evaluation works for extremely tiny `y`::
+
+ >>> powm1(2, '1e-100000')
+ 6.93147180559945e-100001
+ >>> powm1(j, '1e-1000')
+ (-1.23370055013617e-2000 + 1.5707963267949e-1000j)
+
+"""
+
+root = r"""
+``root(z, n, k=0)`` computes an `n`-th root of `z`, i.e. returns a number
+`r` that (up to possible approximation error) satisfies `r^n = z`.
+(``nthroot`` is available as an alias for ``root``.)
+
+Every complex number `z \ne 0` has `n` distinct `n`-th roots, which are
+equidistant points on a circle with radius `|z|^{1/n}`, centered around the
+origin. A specific root may be selected using the optional index
+`k`. The roots are indexed counterclockwise, starting with `k = 0` for the root
+closest to the positive real half-axis.
+
+The `k = 0` root is the so-called principal `n`-th root, often denoted by
+`\sqrt[n]{z}` or `z^{1/n}`, and also given by `\exp(\log(z) / n)`. If `z` is
+a positive real number, the principal root is just the unique positive
+`n`-th root of `z`. Under some circumstances, non-principal real roots exist:
+for positive real `z`, `n` even, there is a negative root given by `k = n/2`;
+for negative real `z`, `n` odd, there is a negative root given by `k = (n-1)/2`.
+
+To obtain all roots with a simple expression, use
+``[root(z,n,k) for k in range(n)]``.
+
+An important special case, ``root(1, n, k)`` returns the `k`-th `n`-th root of
+unity, `\zeta_k = e^{2 \pi i k / n}`. Alternatively, :func:`~mpmath.unitroots`
+provides a slightly more convenient way to obtain the roots of unity,
+including the option to compute only the primitive roots of unity.
+
+Both `k` and `n` should be integers; `k` outside of ``range(n)`` will be
+reduced modulo `n`. If `n` is negative, `x^{-1/n} = 1/x^{1/n}` (or
+the equivalent reciprocal for a non-principal root with `k \ne 0`) is computed.
+
+:func:`~mpmath.root` is implemented to use Newton's method for small
+`n`. At high precision, this makes `x^{1/n}` not much more
+expensive than the regular exponentiation, `x^n`. For very large
+`n`, :func:`~mpmath.nthroot` falls back to use the exponential function.
+
+**Examples**
+
+:func:`~mpmath.nthroot`/:func:`~mpmath.root` is faster and more accurate than raising to a
+floating-point fraction::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = False
+ >>> 16807 ** (mpf(1)/5)
+ mpf('7.0000000000000009')
+ >>> root(16807, 5)
+ mpf('7.0')
+ >>> nthroot(16807, 5) # Alias
+ mpf('7.0')
+
+A high-precision root::
+
+ >>> mp.dps = 50; mp.pretty = True
+ >>> nthroot(10, 5)
+ 1.584893192461113485202101373391507013269442133825
+ >>> nthroot(10, 5) ** 5
+ 10.0
+
+Computing principal and non-principal square and cube roots::
+
+ >>> mp.dps = 15
+ >>> root(10, 2)
+ 3.16227766016838
+ >>> root(10, 2, 1)
+ -3.16227766016838
+ >>> root(-10, 3)
+ (1.07721734501594 + 1.86579517236206j)
+ >>> root(-10, 3, 1)
+ -2.15443469003188
+ >>> root(-10, 3, 2)
+ (1.07721734501594 - 1.86579517236206j)
+
+All the 7th roots of a complex number::
+
+ >>> for r in [root(3+4j, 7, k) for k in range(7)]:
+ ... print("%s %s" % (r, r**7))
+ ...
+ (1.24747270589553 + 0.166227124177353j) (3.0 + 4.0j)
+ (0.647824911301003 + 1.07895435170559j) (3.0 + 4.0j)
+ (-0.439648254723098 + 1.17920694574172j) (3.0 + 4.0j)
+ (-1.19605731775069 + 0.391492658196305j) (3.0 + 4.0j)
+ (-1.05181082538903 - 0.691023585965793j) (3.0 + 4.0j)
+ (-0.115529328478668 - 1.25318497558335j) (3.0 + 4.0j)
+ (0.907748109144957 - 0.871672518271819j) (3.0 + 4.0j)
+
+Cube roots of unity::
+
+ >>> for k in range(3): print(root(1, 3, k))
+ ...
+ 1.0
+ (-0.5 + 0.866025403784439j)
+ (-0.5 - 0.866025403784439j)
+
+Some exact high order roots::
+
+ >>> root(75**210, 105)
+ 5625.0
+ >>> root(1, 128, 96)
+ (0.0 - 1.0j)
+ >>> root(4**128, 128, 96)
+ (0.0 - 4.0j)
+
+"""
+
+unitroots = r"""
+``unitroots(n)`` returns `\zeta_0, \zeta_1, \ldots, \zeta_{n-1}`,
+all the distinct `n`-th roots of unity, as a list. If the option
+*primitive=True* is passed, only the primitive roots are returned.
+
+Every `n`-th root of unity satisfies `(\zeta_k)^n = 1`. There are `n` distinct
+roots for each `n` (`\zeta_k` and `\zeta_j` are the same when
+`k = j \pmod n`), which form a regular polygon with vertices on the unit
+circle. They are ordered counterclockwise with increasing `k`, starting
+with `\zeta_0 = 1`.
+
+**Examples**
+
+The roots of unity up to `n = 4`::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> nprint(unitroots(1))
+ [1.0]
+ >>> nprint(unitroots(2))
+ [1.0, -1.0]
+ >>> nprint(unitroots(3))
+ [1.0, (-0.5 + 0.866025j), (-0.5 - 0.866025j)]
+ >>> nprint(unitroots(4))
+ [1.0, (0.0 + 1.0j), -1.0, (0.0 - 1.0j)]
+
+Roots of unity form a geometric series that sums to 0::
+
+ >>> mp.dps = 50
+ >>> chop(fsum(unitroots(25)))
+ 0.0
+
+Primitive roots up to `n = 4`::
+
+ >>> mp.dps = 15
+ >>> nprint(unitroots(1, primitive=True))
+ [1.0]
+ >>> nprint(unitroots(2, primitive=True))
+ [-1.0]
+ >>> nprint(unitroots(3, primitive=True))
+ [(-0.5 + 0.866025j), (-0.5 - 0.866025j)]
+ >>> nprint(unitroots(4, primitive=True))
+ [(0.0 + 1.0j), (0.0 - 1.0j)]
+
+There are only four primitive 12th roots::
+
+ >>> nprint(unitroots(12, primitive=True))
+ [(0.866025 + 0.5j), (-0.866025 + 0.5j), (-0.866025 - 0.5j), (0.866025 - 0.5j)]
+
+The `n`-th roots of unity form a group, the cyclic group of order `n`.
+Any primitive root `r` is a generator for this group, meaning that
+`r^0, r^1, \ldots, r^{n-1}` gives the whole set of unit roots (in
+some permuted order)::
+
+ >>> for r in unitroots(6): print(r)
+ ...
+ 1.0
+ (0.5 + 0.866025403784439j)
+ (-0.5 + 0.866025403784439j)
+ -1.0
+ (-0.5 - 0.866025403784439j)
+ (0.5 - 0.866025403784439j)
+ >>> r = unitroots(6, primitive=True)[1]
+ >>> for k in range(6): print(chop(r**k))
+ ...
+ 1.0
+ (0.5 - 0.866025403784439j)
+ (-0.5 - 0.866025403784439j)
+ -1.0
+ (-0.5 + 0.866025403784438j)
+ (0.5 + 0.866025403784438j)
+
+The number of primitive roots equals the Euler totient function `\phi(n)`::
+
+ >>> [len(unitroots(n, primitive=True)) for n in range(1,20)]
+ [1, 1, 2, 2, 4, 2, 6, 4, 6, 4, 10, 4, 12, 6, 8, 8, 16, 6, 18]
+
+"""
+
+
+log = r"""
+Computes the base-`b` logarithm of `x`, `\log_b(x)`. If `b` is
+unspecified, :func:`~mpmath.log` computes the natural (base `e`) logarithm
+and is equivalent to :func:`~mpmath.ln`. In general, the base `b` logarithm
+is defined in terms of the natural logarithm as
+`\log_b(x) = \ln(x)/\ln(b)`.
+
+By convention, we take `\log(0) = -\infty`.
+
+The natural logarithm is real if `x > 0` and complex if `x < 0` or if
+`x` is complex. The principal branch of the complex logarithm is
+used, meaning that `\Im(\ln(x)) = -\pi < \arg(x) \le \pi`.
+
+**Examples**
+
+Some basic values and limits::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> log(1)
+ 0.0
+ >>> log(2)
+ 0.693147180559945
+ >>> log(1000,10)
+ 3.0
+ >>> log(4, 16)
+ 0.5
+ >>> log(j)
+ (0.0 + 1.5707963267949j)
+ >>> log(-1)
+ (0.0 + 3.14159265358979j)
+ >>> log(0)
+ -inf
+ >>> log(inf)
+ +inf
+
+The natural logarithm is the antiderivative of `1/x`::
+
+ >>> quad(lambda x: 1/x, [1, 5])
+ 1.6094379124341
+ >>> log(5)
+ 1.6094379124341
+ >>> diff(log, 10)
+ 0.1
+
+The Taylor series expansion of the natural logarithm around
+`x = 1` has coefficients `(-1)^{n+1}/n`::
+
+ >>> nprint(taylor(log, 1, 7))
+ [0.0, 1.0, -0.5, 0.333333, -0.25, 0.2, -0.166667, 0.142857]
+
+:func:`~mpmath.log` supports arbitrary precision evaluation::
+
+ >>> mp.dps = 50
+ >>> log(pi)
+ 1.1447298858494001741434273513530587116472948129153
+ >>> log(pi, pi**3)
+ 0.33333333333333333333333333333333333333333333333333
+ >>> mp.dps = 25
+ >>> log(3+4j)
+ (1.609437912434100374600759 + 0.9272952180016122324285125j)
+"""
+
+log10 = r"""
+Computes the base-10 logarithm of `x`, `\log_{10}(x)`. ``log10(x)``
+is equivalent to ``log(x, 10)``.
+"""
+
+fmod = r"""
+Converts `x` and `y` to mpmath numbers and returns `x \mod y`.
+For mpmath numbers, this is equivalent to ``x % y``.
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> fmod(100, pi)
+ 2.61062773871641
+
+You can use :func:`~mpmath.fmod` to compute fractional parts of numbers::
+
+ >>> fmod(10.25, 1)
+ 0.25
+
+"""
+
+radians = r"""
+Converts the degree angle `x` to radians::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> radians(60)
+ 1.0471975511966
+"""
+
+degrees = r"""
+Converts the radian angle `x` to a degree angle::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> degrees(pi/3)
+ 60.0
+"""
+
+atan2 = r"""
+Computes the two-argument arctangent, `\mathrm{atan2}(y, x)`,
+giving the signed angle between the positive `x`-axis and the
+point `(x, y)` in the 2D plane. This function is defined for
+real `x` and `y` only.
+
+The two-argument arctangent essentially computes
+`\mathrm{atan}(y/x)`, but accounts for the signs of both
+`x` and `y` to give the angle for the correct quadrant. The
+following examples illustrate the difference::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> atan2(1,1), atan(1/1.)
+ (0.785398163397448, 0.785398163397448)
+ >>> atan2(1,-1), atan(1/-1.)
+ (2.35619449019234, -0.785398163397448)
+ >>> atan2(-1,1), atan(-1/1.)
+ (-0.785398163397448, -0.785398163397448)
+ >>> atan2(-1,-1), atan(-1/-1.)
+ (-2.35619449019234, 0.785398163397448)
+
+The angle convention is the same as that used for the complex
+argument; see :func:`~mpmath.arg`.
+"""
+
+fibonacci = r"""
+``fibonacci(n)`` computes the `n`-th Fibonacci number, `F(n)`. The
+Fibonacci numbers are defined by the recurrence `F(n) = F(n-1) + F(n-2)`
+with the initial values `F(0) = 0`, `F(1) = 1`. :func:`~mpmath.fibonacci`
+extends this definition to arbitrary real and complex arguments
+using the formula
+
+.. math ::
+
+ F(z) = \frac{\phi^z - \cos(\pi z) \phi^{-z}}{\sqrt 5}
+
+where `\phi` is the golden ratio. :func:`~mpmath.fibonacci` also uses this
+continuous formula to compute `F(n)` for extremely large `n`, where
+calculating the exact integer would be wasteful.
+
+For convenience, :func:`~mpmath.fib` is available as an alias for
+:func:`~mpmath.fibonacci`.
+
+**Basic examples**
+
+Some small Fibonacci numbers are::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> for i in range(10):
+ ... print(fibonacci(i))
+ ...
+ 0.0
+ 1.0
+ 1.0
+ 2.0
+ 3.0
+ 5.0
+ 8.0
+ 13.0
+ 21.0
+ 34.0
+ >>> fibonacci(50)
+ 12586269025.0
+
+The recurrence for `F(n)` extends backwards to negative `n`::
+
+ >>> for i in range(10):
+ ... print(fibonacci(-i))
+ ...
+ 0.0
+ 1.0
+ -1.0
+ 2.0
+ -3.0
+ 5.0
+ -8.0
+ 13.0
+ -21.0
+ 34.0
+
+Large Fibonacci numbers will be computed approximately unless
+the precision is set high enough::
+
+ >>> fib(200)
+ 2.8057117299251e+41
+ >>> mp.dps = 45
+ >>> fib(200)
+ 280571172992510140037611932413038677189525.0
+
+:func:`~mpmath.fibonacci` can compute approximate Fibonacci numbers
+of stupendous size::
+
+ >>> mp.dps = 15
+ >>> fibonacci(10**25)
+ 3.49052338550226e+2089876402499787337692720
+
+**Real and complex arguments**
+
+The extended Fibonacci function is an analytic function. The
+property `F(z) = F(z-1) + F(z-2)` holds for arbitrary `z`::
+
+ >>> mp.dps = 15
+ >>> fib(pi)
+ 2.1170270579161
+ >>> fib(pi-1) + fib(pi-2)
+ 2.1170270579161
+ >>> fib(3+4j)
+ (-5248.51130728372 - 14195.962288353j)
+ >>> fib(2+4j) + fib(1+4j)
+ (-5248.51130728372 - 14195.962288353j)
+
+The Fibonacci function has infinitely many roots on the
+negative half-real axis. The first root is at 0, the second is
+close to -0.18, and then there are infinitely many roots that
+asymptotically approach `-n+1/2`::
+
+ >>> findroot(fib, -0.2)
+ -0.183802359692956
+ >>> findroot(fib, -2)
+ -1.57077646820395
+ >>> findroot(fib, -17)
+ -16.4999999596115
+ >>> findroot(fib, -24)
+ -23.5000000000479
+
+**Mathematical relationships**
+
+For large `n`, `F(n+1)/F(n)` approaches the golden ratio::
+
+ >>> mp.dps = 50
+ >>> fibonacci(101)/fibonacci(100)
+ 1.6180339887498948482045868343656381177203127439638
+ >>> +phi
+ 1.6180339887498948482045868343656381177203091798058
+
+The sum of reciprocal Fibonacci numbers converges to an irrational
+number for which no closed form expression is known::
+
+ >>> mp.dps = 15
+ >>> nsum(lambda n: 1/fib(n), [1, inf])
+ 3.35988566624318
+
+Amazingly, however, the sum of odd-index reciprocal Fibonacci
+numbers can be expressed in terms of a Jacobi theta function::
+
+ >>> nsum(lambda n: 1/fib(2*n+1), [0, inf])
+ 1.82451515740692
+ >>> sqrt(5)*jtheta(2,0,(3-sqrt(5))/2)**2/4
+ 1.82451515740692
+
+Some related sums can be done in closed form::
+
+ >>> nsum(lambda k: 1/(1+fib(2*k+1)), [0, inf])
+ 1.11803398874989
+ >>> phi - 0.5
+ 1.11803398874989
+ >>> f = lambda k:(-1)**(k+1) / sum(fib(n)**2 for n in range(1,int(k+1)))
+ >>> nsum(f, [1, inf])
+ 0.618033988749895
+ >>> phi-1
+ 0.618033988749895
+
+**References**
+
+1. http://mathworld.wolfram.com/FibonacciNumber.html
+"""
+
+altzeta = r"""
+Gives the Dirichlet eta function, `\eta(s)`, also known as the
+alternating zeta function. This function is defined in analogy
+with the Riemann zeta function as providing the sum of the
+alternating series
+
+.. math ::
+
+ \eta(s) = \sum_{k=0}^{\infty} \frac{(-1)^k}{k^s}
+ = 1-\frac{1}{2^s}+\frac{1}{3^s}-\frac{1}{4^s}+\ldots
+
+The eta function, unlike the Riemann zeta function, is an entire
+function, having a finite value for all complex `s`. The special case
+`\eta(1) = \log(2)` gives the value of the alternating harmonic series.
+
+The alternating zeta function may expressed using the Riemann zeta function
+as `\eta(s) = (1 - 2^{1-s}) \zeta(s)`. It can also be expressed
+in terms of the Hurwitz zeta function, for example using
+:func:`~mpmath.dirichlet` (see documentation for that function).
+
+**Examples**
+
+Some special values are::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> altzeta(1)
+ 0.693147180559945
+ >>> altzeta(0)
+ 0.5
+ >>> altzeta(-1)
+ 0.25
+ >>> altzeta(-2)
+ 0.0
+
+An example of a sum that can be computed more accurately and
+efficiently via :func:`~mpmath.altzeta` than via numerical summation::
+
+ >>> sum(-(-1)**n / mpf(n)**2.5 for n in range(1, 100))
+ 0.867204951503984
+ >>> altzeta(2.5)
+ 0.867199889012184
+
+At positive even integers, the Dirichlet eta function
+evaluates to a rational multiple of a power of `\pi`::
+
+ >>> altzeta(2)
+ 0.822467033424113
+ >>> pi**2/12
+ 0.822467033424113
+
+Like the Riemann zeta function, `\eta(s)`, approaches 1
+as `s` approaches positive infinity, although it does
+so from below rather than from above::
+
+ >>> altzeta(30)
+ 0.999999999068682
+ >>> altzeta(inf)
+ 1.0
+ >>> mp.pretty = False
+ >>> altzeta(1000, rounding='d')
+ mpf('0.99999999999999989')
+ >>> altzeta(1000, rounding='u')
+ mpf('1.0')
+
+**References**
+
+1. http://mathworld.wolfram.com/DirichletEtaFunction.html
+
+2. http://en.wikipedia.org/wiki/Dirichlet_eta_function
+"""
+
+factorial = r"""
+Computes the factorial, `x!`. For integers `n \ge 0`, we have
+`n! = 1 \cdot 2 \cdots (n-1) \cdot n` and more generally the factorial
+is defined for real or complex `x` by `x! = \Gamma(x+1)`.
+
+**Examples**
+
+Basic values and limits::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> for k in range(6):
+ ... print("%s %s" % (k, fac(k)))
+ ...
+ 0 1.0
+ 1 1.0
+ 2 2.0
+ 3 6.0
+ 4 24.0
+ 5 120.0
+ >>> fac(inf)
+ +inf
+ >>> fac(0.5), sqrt(pi)/2
+ (0.886226925452758, 0.886226925452758)
+
+For large positive `x`, `x!` can be approximated by
+Stirling's formula::
+
+ >>> x = 10**10
+ >>> fac(x)
+ 2.32579620567308e+95657055186
+ >>> sqrt(2*pi*x)*(x/e)**x
+ 2.32579597597705e+95657055186
+
+:func:`~mpmath.fac` supports evaluation for astronomically large values::
+
+ >>> fac(10**30)
+ 6.22311232304258e+29565705518096748172348871081098
+
+Reciprocal factorials appear in the Taylor series of the
+exponential function (among many other contexts)::
+
+ >>> nsum(lambda k: 1/fac(k), [0, inf]), exp(1)
+ (2.71828182845905, 2.71828182845905)
+ >>> nsum(lambda k: pi**k/fac(k), [0, inf]), exp(pi)
+ (23.1406926327793, 23.1406926327793)
+
+"""
+
+gamma = r"""
+Computes the gamma function, `\Gamma(x)`. The gamma function is a
+shifted version of the ordinary factorial, satisfying
+`\Gamma(n) = (n-1)!` for integers `n > 0`. More generally, it
+is defined by
+
+.. math ::
+
+ \Gamma(x) = \int_0^{\infty} t^{x-1} e^{-t}\, dt
+
+for any real or complex `x` with `\Re(x) > 0` and for `\Re(x) < 0`
+by analytic continuation.
+
+**Examples**
+
+Basic values and limits::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> for k in range(1, 6):
+ ... print("%s %s" % (k, gamma(k)))
+ ...
+ 1 1.0
+ 2 1.0
+ 3 2.0
+ 4 6.0
+ 5 24.0
+ >>> gamma(inf)
+ +inf
+ >>> gamma(0)
+ Traceback (most recent call last):
+ ...
+ ValueError: gamma function pole
+
+The gamma function of a half-integer is a rational multiple of
+`\sqrt{\pi}`::
+
+ >>> gamma(0.5), sqrt(pi)
+ (1.77245385090552, 1.77245385090552)
+ >>> gamma(1.5), sqrt(pi)/2
+ (0.886226925452758, 0.886226925452758)
+
+We can check the integral definition::
+
+ >>> gamma(3.5)
+ 3.32335097044784
+ >>> quad(lambda t: t**2.5*exp(-t), [0,inf])
+ 3.32335097044784
+
+:func:`~mpmath.gamma` supports arbitrary-precision evaluation and
+complex arguments::
+
+ >>> mp.dps = 50
+ >>> gamma(sqrt(3))
+ 0.91510229697308632046045539308226554038315280564184
+ >>> mp.dps = 25
+ >>> gamma(2j)
+ (0.009902440080927490985955066 - 0.07595200133501806872408048j)
+
+Arguments can also be large. Note that the gamma function grows
+very quickly::
+
+ >>> mp.dps = 15
+ >>> gamma(10**20)
+ 1.9328495143101e+1956570551809674817225
+
+**References**
+
+* [Spouge]_
+
+"""
+
+psi = r"""
+Gives the polygamma function of order `m` of `z`, `\psi^{(m)}(z)`.
+Special cases are known as the *digamma function* (`\psi^{(0)}(z)`),
+the *trigamma function* (`\psi^{(1)}(z)`), etc. The polygamma
+functions are defined as the logarithmic derivatives of the gamma
+function:
+
+.. math ::
+
+ \psi^{(m)}(z) = \left(\frac{d}{dz}\right)^{m+1} \log \Gamma(z)
+
+In particular, `\psi^{(0)}(z) = \Gamma'(z)/\Gamma(z)`. In the
+present implementation of :func:`~mpmath.psi`, the order `m` must be a
+nonnegative integer, while the argument `z` may be an arbitrary
+complex number (with exception for the polygamma function's poles
+at `z = 0, -1, -2, \ldots`).
+
+**Examples**
+
+For various rational arguments, the polygamma function reduces to
+a combination of standard mathematical constants::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> psi(0, 1), -euler
+ (-0.5772156649015328606065121, -0.5772156649015328606065121)
+ >>> psi(1, '1/4'), pi**2+8*catalan
+ (17.19732915450711073927132, 17.19732915450711073927132)
+ >>> psi(2, '1/2'), -14*apery
+ (-16.82879664423431999559633, -16.82879664423431999559633)
+
+The polygamma functions are derivatives of each other::
+
+ >>> diff(lambda x: psi(3, x), pi), psi(4, pi)
+ (-0.1105749312578862734526952, -0.1105749312578862734526952)
+ >>> quad(lambda x: psi(4, x), [2, 3]), psi(3,3)-psi(3,2)
+ (-0.375, -0.375)
+
+The digamma function diverges logarithmically as `z \to \infty`,
+while higher orders tend to zero::
+
+ >>> psi(0,inf), psi(1,inf), psi(2,inf)
+ (+inf, 0.0, 0.0)
+
+Evaluation for a complex argument::
+
+ >>> psi(2, -1-2j)
+ (0.03902435405364952654838445 + 0.1574325240413029954685366j)
+
+Evaluation is supported for large orders `m` and/or large
+arguments `z`::
+
+ >>> psi(3, 10**100)
+ 2.0e-300
+ >>> psi(250, 10**30+10**20*j)
+ (-1.293142504363642687204865e-7010 + 3.232856260909107391513108e-7018j)
+
+**Application to infinite series**
+
+Any infinite series where the summand is a rational function of
+the index `k` can be evaluated in closed form in terms of polygamma
+functions of the roots and poles of the summand::
+
+ >>> a = sqrt(2)
+ >>> b = sqrt(3)
+ >>> nsum(lambda k: 1/((k+a)**2*(k+b)), [0, inf])
+ 0.4049668927517857061917531
+ >>> (psi(0,a)-psi(0,b)-a*psi(1,a)+b*psi(1,a))/(a-b)**2
+ 0.4049668927517857061917531
+
+This follows from the series representation (`m > 0`)
+
+.. math ::
+
+ \psi^{(m)}(z) = (-1)^{m+1} m! \sum_{k=0}^{\infty}
+ \frac{1}{(z+k)^{m+1}}.
+
+Since the roots of a polynomial may be complex, it is sometimes
+necessary to use the complex polygamma function to evaluate
+an entirely real-valued sum::
+
+ >>> nsum(lambda k: 1/(k**2-2*k+3), [0, inf])
+ 1.694361433907061256154665
+ >>> nprint(polyroots([1,-2,3]))
+ [(1.0 - 1.41421j), (1.0 + 1.41421j)]
+ >>> r1 = 1-sqrt(2)*j
+ >>> r2 = r1.conjugate()
+ >>> (psi(0,-r2)-psi(0,-r1))/(r1-r2)
+ (1.694361433907061256154665 + 0.0j)
+
+"""
+
+digamma = r"""
+Shortcut for ``psi(0,z)``.
+"""
+
+harmonic = r"""
+If `n` is an integer, ``harmonic(n)`` gives a floating-point
+approximation of the `n`-th harmonic number `H(n)`, defined as
+
+.. math ::
+
+ H(n) = 1 + \frac{1}{2} + \frac{1}{3} + \ldots + \frac{1}{n}
+
+The first few harmonic numbers are::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> for n in range(8):
+ ... print("%s %s" % (n, harmonic(n)))
+ ...
+ 0 0.0
+ 1 1.0
+ 2 1.5
+ 3 1.83333333333333
+ 4 2.08333333333333
+ 5 2.28333333333333
+ 6 2.45
+ 7 2.59285714285714
+
+The infinite harmonic series `1 + 1/2 + 1/3 + \ldots` diverges::
+
+ >>> harmonic(inf)
+ +inf
+
+:func:`~mpmath.harmonic` is evaluated using the digamma function rather
+than by summing the harmonic series term by term. It can therefore
+be computed quickly for arbitrarily large `n`, and even for
+nonintegral arguments::
+
+ >>> harmonic(10**100)
+ 230.835724964306
+ >>> harmonic(0.5)
+ 0.613705638880109
+ >>> harmonic(3+4j)
+ (2.24757548223494 + 0.850502209186044j)
+
+:func:`~mpmath.harmonic` supports arbitrary precision evaluation::
+
+ >>> mp.dps = 50
+ >>> harmonic(11)
+ 3.0198773448773448773448773448773448773448773448773
+ >>> harmonic(pi)
+ 1.8727388590273302654363491032336134987519132374152
+
+The harmonic series diverges, but at a glacial pace. It is possible
+to calculate the exact number of terms required before the sum
+exceeds a given amount, say 100::
+
+ >>> mp.dps = 50
+ >>> v = 10**findroot(lambda x: harmonic(10**x) - 100, 10)
+ >>> v
+ 15092688622113788323693563264538101449859496.864101
+ >>> v = int(ceil(v))
+ >>> print(v)
+ 15092688622113788323693563264538101449859497
+ >>> harmonic(v-1)
+ 99.999999999999999999999999999999999999999999942747
+ >>> harmonic(v)
+ 100.000000000000000000000000000000000000000000009
+
+"""
+
+bernoulli = r"""
+Computes the nth Bernoulli number, `B_n`, for any integer `n \ge 0`.
+
+The Bernoulli numbers are rational numbers, but this function
+returns a floating-point approximation. To obtain an exact
+fraction, use :func:`~mpmath.bernfrac` instead.
+
+**Examples**
+
+Numerical values of the first few Bernoulli numbers::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> for n in range(15):
+ ... print("%s %s" % (n, bernoulli(n)))
+ ...
+ 0 1.0
+ 1 -0.5
+ 2 0.166666666666667
+ 3 0.0
+ 4 -0.0333333333333333
+ 5 0.0
+ 6 0.0238095238095238
+ 7 0.0
+ 8 -0.0333333333333333
+ 9 0.0
+ 10 0.0757575757575758
+ 11 0.0
+ 12 -0.253113553113553
+ 13 0.0
+ 14 1.16666666666667
+
+Bernoulli numbers can be approximated with arbitrary precision::
+
+ >>> mp.dps = 50
+ >>> bernoulli(100)
+ -2.8382249570693706959264156336481764738284680928013e+78
+
+Arbitrarily large `n` are supported::
+
+ >>> mp.dps = 15
+ >>> bernoulli(10**20 + 2)
+ 3.09136296657021e+1876752564973863312327
+
+The Bernoulli numbers are related to the Riemann zeta function
+at integer arguments::
+
+ >>> -bernoulli(8) * (2*pi)**8 / (2*fac(8))
+ 1.00407735619794
+ >>> zeta(8)
+ 1.00407735619794
+
+**Algorithm**
+
+For small `n` (`n < 3000`) :func:`~mpmath.bernoulli` uses a recurrence
+formula due to Ramanujan. All results in this range are cached,
+so sequential computation of small Bernoulli numbers is
+guaranteed to be fast.
+
+For larger `n`, `B_n` is evaluated in terms of the Riemann zeta
+function.
+"""
+
+stieltjes = r"""
+For a nonnegative integer `n`, ``stieltjes(n)`` computes the
+`n`-th Stieltjes constant `\gamma_n`, defined as the
+`n`-th coefficient in the Laurent series expansion of the
+Riemann zeta function around the pole at `s = 1`. That is,
+we have:
+
+.. math ::
+
+ \zeta(s) = \frac{1}{s-1} \sum_{n=0}^{\infty}
+ \frac{(-1)^n}{n!} \gamma_n (s-1)^n
+
+More generally, ``stieltjes(n, a)`` gives the corresponding
+coefficient `\gamma_n(a)` for the Hurwitz zeta function
+`\zeta(s,a)` (with `\gamma_n = \gamma_n(1)`).
+
+**Examples**
+
+The zeroth Stieltjes constant is just Euler's constant `\gamma`::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> stieltjes(0)
+ 0.577215664901533
+
+Some more values are::
+
+ >>> stieltjes(1)
+ -0.0728158454836767
+ >>> stieltjes(10)
+ 0.000205332814909065
+ >>> stieltjes(30)
+ 0.00355772885557316
+ >>> stieltjes(1000)
+ -1.57095384420474e+486
+ >>> stieltjes(2000)
+ 2.680424678918e+1109
+ >>> stieltjes(1, 2.5)
+ -0.23747539175716
+
+An alternative way to compute `\gamma_1`::
+
+ >>> diff(extradps(15)(lambda x: 1/(x-1) - zeta(x)), 1)
+ -0.0728158454836767
+
+:func:`~mpmath.stieltjes` supports arbitrary precision evaluation::
+
+ >>> mp.dps = 50
+ >>> stieltjes(2)
+ -0.0096903631928723184845303860352125293590658061013408
+
+**Algorithm**
+
+:func:`~mpmath.stieltjes` numerically evaluates the integral in
+the following representation due to Ainsworth, Howell and
+Coffey [1], [2]:
+
+.. math ::
+
+ \gamma_n(a) = \frac{\log^n a}{2a} - \frac{\log^{n+1}(a)}{n+1} +
+ \frac{2}{a} \Re \int_0^{\infty}
+ \frac{(x/a-i)\log^n(a-ix)}{(1+x^2/a^2)(e^{2\pi x}-1)} dx.
+
+For some reference values with `a = 1`, see e.g. [4].
+
+**References**
+
+1. O. R. Ainsworth & L. W. Howell, "An integral representation of
+ the generalized Euler-Mascheroni constants", NASA Technical
+ Paper 2456 (1985),
+ http://ntrs.nasa.gov/archive/nasa/casi.ntrs.nasa.gov/19850014994_1985014994.pdf
+
+2. M. W. Coffey, "The Stieltjes constants, their relation to the
+ `\eta_j` coefficients, and representation of the Hurwitz
+ zeta function", arXiv:0706.0343v1 http://arxiv.org/abs/0706.0343
+
+3. http://mathworld.wolfram.com/StieltjesConstants.html
+
+4. http://pi.lacim.uqam.ca/piDATA/stieltjesgamma.txt
+
+"""
+
+gammaprod = r"""
+Given iterables `a` and `b`, ``gammaprod(a, b)`` computes the
+product / quotient of gamma functions:
+
+.. math ::
+
+ \frac{\Gamma(a_0) \Gamma(a_1) \cdots \Gamma(a_p)}
+ {\Gamma(b_0) \Gamma(b_1) \cdots \Gamma(b_q)}
+
+Unlike direct calls to :func:`~mpmath.gamma`, :func:`~mpmath.gammaprod` considers
+the entire product as a limit and evaluates this limit properly if
+any of the numerator or denominator arguments are nonpositive
+integers such that poles of the gamma function are encountered.
+That is, :func:`~mpmath.gammaprod` evaluates
+
+.. math ::
+
+ \lim_{\epsilon \to 0}
+ \frac{\Gamma(a_0+\epsilon) \Gamma(a_1+\epsilon) \cdots
+ \Gamma(a_p+\epsilon)}
+ {\Gamma(b_0+\epsilon) \Gamma(b_1+\epsilon) \cdots
+ \Gamma(b_q+\epsilon)}
+
+In particular:
+
+* If there are equally many poles in the numerator and the
+ denominator, the limit is a rational number times the remaining,
+ regular part of the product.
+
+* If there are more poles in the numerator, :func:`~mpmath.gammaprod`
+ returns ``+inf``.
+
+* If there are more poles in the denominator, :func:`~mpmath.gammaprod`
+ returns 0.
+
+**Examples**
+
+The reciprocal gamma function `1/\Gamma(x)` evaluated at `x = 0`::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15
+ >>> gammaprod([], [0])
+ 0.0
+
+A limit::
+
+ >>> gammaprod([-4], [-3])
+ -0.25
+ >>> limit(lambda x: gamma(x-1)/gamma(x), -3, direction=1)
+ -0.25
+ >>> limit(lambda x: gamma(x-1)/gamma(x), -3, direction=-1)
+ -0.25
+
+"""
+
+beta = r"""
+Computes the beta function,
+`B(x,y) = \Gamma(x) \Gamma(y) / \Gamma(x+y)`.
+The beta function is also commonly defined by the integral
+representation
+
+.. math ::
+
+ B(x,y) = \int_0^1 t^{x-1} (1-t)^{y-1} \, dt
+
+**Examples**
+
+For integer and half-integer arguments where all three gamma
+functions are finite, the beta function becomes either rational
+number or a rational multiple of `\pi`::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> beta(5, 2)
+ 0.0333333333333333
+ >>> beta(1.5, 2)
+ 0.266666666666667
+ >>> 16*beta(2.5, 1.5)
+ 3.14159265358979
+
+Where appropriate, :func:`~mpmath.beta` evaluates limits. A pole
+of the beta function is taken to result in ``+inf``::
+
+ >>> beta(-0.5, 0.5)
+ 0.0
+ >>> beta(-3, 3)
+ -0.333333333333333
+ >>> beta(-2, 3)
+ +inf
+ >>> beta(inf, 1)
+ 0.0
+ >>> beta(inf, 0)
+ nan
+
+:func:`~mpmath.beta` supports complex numbers and arbitrary precision
+evaluation::
+
+ >>> beta(1, 2+j)
+ (0.4 - 0.2j)
+ >>> mp.dps = 25
+ >>> beta(j,0.5)
+ (1.079424249270925780135675 - 1.410032405664160838288752j)
+ >>> mp.dps = 50
+ >>> beta(pi, e)
+ 0.037890298781212201348153837138927165984170287886464
+
+Various integrals can be computed by means of the
+beta function::
+
+ >>> mp.dps = 15
+ >>> quad(lambda t: t**2.5*(1-t)**2, [0, 1])
+ 0.0230880230880231
+ >>> beta(3.5, 3)
+ 0.0230880230880231
+ >>> quad(lambda t: sin(t)**4 * sqrt(cos(t)), [0, pi/2])
+ 0.319504062596158
+ >>> beta(2.5, 0.75)/2
+ 0.319504062596158
+
+"""
+
+betainc = r"""
+``betainc(a, b, x1=0, x2=1, regularized=False)`` gives the generalized
+incomplete beta function,
+
+.. math ::
+
+ I_{x_1}^{x_2}(a,b) = \int_{x_1}^{x_2} t^{a-1} (1-t)^{b-1} dt.
+
+When `x_1 = 0, x_2 = 1`, this reduces to the ordinary (complete)
+beta function `B(a,b)`; see :func:`~mpmath.beta`.
+
+With the keyword argument ``regularized=True``, :func:`~mpmath.betainc`
+computes the regularized incomplete beta function
+`I_{x_1}^{x_2}(a,b) / B(a,b)`. This is the cumulative distribution of the
+beta distribution with parameters `a`, `b`.
+
+.. note :
+
+ Implementations of the incomplete beta function in some other
+ software uses a different argument order. For example, Mathematica uses the
+ reversed argument order ``Beta[x1,x2,a,b]``. For the equivalent of SciPy's
+ three-argument incomplete beta integral (implicitly with `x1 = 0`), use
+ ``betainc(a,b,0,x2,regularized=True)``.
+
+**Examples**
+
+Verifying that :func:`~mpmath.betainc` computes the integral in the
+definition::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> x,y,a,b = 3, 4, 0, 6
+ >>> betainc(x, y, a, b)
+ -4010.4
+ >>> quad(lambda t: t**(x-1) * (1-t)**(y-1), [a, b])
+ -4010.4
+
+The arguments may be arbitrary complex numbers::
+
+ >>> betainc(0.75, 1-4j, 0, 2+3j)
+ (0.2241657956955709603655887 + 0.3619619242700451992411724j)
+
+With regularization::
+
+ >>> betainc(1, 2, 0, 0.25, regularized=True)
+ 0.4375
+ >>> betainc(pi, e, 0, 1, regularized=True) # Complete
+ 1.0
+
+The beta integral satisfies some simple argument transformation
+symmetries::
+
+ >>> mp.dps = 15
+ >>> betainc(2,3,4,5), -betainc(2,3,5,4), betainc(3,2,1-5,1-4)
+ (56.0833333333333, 56.0833333333333, 56.0833333333333)
+
+The beta integral can often be evaluated analytically. For integer and
+rational arguments, the incomplete beta function typically reduces to a
+simple algebraic-logarithmic expression::
+
+ >>> mp.dps = 25
+ >>> identify(chop(betainc(0, 0, 3, 4)))
+ '-(log((9/8)))'
+ >>> identify(betainc(2, 3, 4, 5))
+ '(673/12)'
+ >>> identify(betainc(1.5, 1, 1, 2))
+ '((-12+sqrt(1152))/18)'
+
+"""
+
+binomial = r"""
+Computes the binomial coefficient
+
+.. math ::
+
+ {n \choose k} = \frac{n!}{k!(n-k)!}.
+
+The binomial coefficient gives the number of ways that `k` items
+can be chosen from a set of `n` items. More generally, the binomial
+coefficient is a well-defined function of arbitrary real or
+complex `n` and `k`, via the gamma function.
+
+**Examples**
+
+Generate Pascal's triangle::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> for n in range(5):
+ ... nprint([binomial(n,k) for k in range(n+1)])
+ ...
+ [1.0]
+ [1.0, 1.0]
+ [1.0, 2.0, 1.0]
+ [1.0, 3.0, 3.0, 1.0]
+ [1.0, 4.0, 6.0, 4.0, 1.0]
+
+There is 1 way to select 0 items from the empty set, and 0 ways to
+select 1 item from the empty set::
+
+ >>> binomial(0, 0)
+ 1.0
+ >>> binomial(0, 1)
+ 0.0
+
+:func:`~mpmath.binomial` supports large arguments::
+
+ >>> binomial(10**20, 10**20-5)
+ 8.33333333333333e+97
+ >>> binomial(10**20, 10**10)
+ 2.60784095465201e+104342944813
+
+Nonintegral binomial coefficients find use in series
+expansions::
+
+ >>> nprint(taylor(lambda x: (1+x)**0.25, 0, 4))
+ [1.0, 0.25, -0.09375, 0.0546875, -0.0375977]
+ >>> nprint([binomial(0.25, k) for k in range(5)])
+ [1.0, 0.25, -0.09375, 0.0546875, -0.0375977]
+
+An integral representation::
+
+ >>> n, k = 5, 3
+ >>> f = lambda t: exp(-j*k*t)*(1+exp(j*t))**n
+ >>> chop(quad(f, [-pi,pi])/(2*pi))
+ 10.0
+ >>> binomial(n,k)
+ 10.0
+
+"""
+
+rf = r"""
+Computes the rising factorial or Pochhammer symbol,
+
+.. math ::
+
+ x^{(n)} = x (x+1) \cdots (x+n-1) = \frac{\Gamma(x+n)}{\Gamma(x)}
+
+where the rightmost expression is valid for nonintegral `n`.
+
+**Examples**
+
+For integral `n`, the rising factorial is a polynomial::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> for n in range(5):
+ ... nprint(taylor(lambda x: rf(x,n), 0, n))
+ ...
+ [1.0]
+ [0.0, 1.0]
+ [0.0, 1.0, 1.0]
+ [0.0, 2.0, 3.0, 1.0]
+ [0.0, 6.0, 11.0, 6.0, 1.0]
+
+Evaluation is supported for arbitrary arguments::
+
+ >>> rf(2+3j, 5.5)
+ (-7202.03920483347 - 3777.58810701527j)
+"""
+
+ff = r"""
+Computes the falling factorial,
+
+.. math ::
+
+ (x)_n = x (x-1) \cdots (x-n+1) = \frac{\Gamma(x+1)}{\Gamma(x-n+1)}
+
+where the rightmost expression is valid for nonintegral `n`.
+
+**Examples**
+
+For integral `n`, the falling factorial is a polynomial::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> for n in range(5):
+ ... nprint(taylor(lambda x: ff(x,n), 0, n))
+ ...
+ [1.0]
+ [0.0, 1.0]
+ [0.0, -1.0, 1.0]
+ [0.0, 2.0, -3.0, 1.0]
+ [0.0, -6.0, 11.0, -6.0, 1.0]
+
+Evaluation is supported for arbitrary arguments::
+
+ >>> ff(2+3j, 5.5)
+ (-720.41085888203 + 316.101124983878j)
+"""
+
+fac2 = r"""
+Computes the double factorial `x!!`, defined for integers
+`x > 0` by
+
+.. math ::
+
+ x!! = \begin{cases}
+ 1 \cdot 3 \cdots (x-2) \cdot x & x \;\mathrm{odd} \\
+ 2 \cdot 4 \cdots (x-2) \cdot x & x \;\mathrm{even}
+ \end{cases}
+
+and more generally by [1]
+
+.. math ::
+
+ x!! = 2^{x/2} \left(\frac{\pi}{2}\right)^{(\cos(\pi x)-1)/4}
+ \Gamma\left(\frac{x}{2}+1\right).
+
+**Examples**
+
+The integer sequence of double factorials begins::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> nprint([fac2(n) for n in range(10)])
+ [1.0, 1.0, 2.0, 3.0, 8.0, 15.0, 48.0, 105.0, 384.0, 945.0]
+
+For large `x`, double factorials follow a Stirling-like asymptotic
+approximation::
+
+ >>> x = mpf(10000)
+ >>> fac2(x)
+ 5.97272691416282e+17830
+ >>> sqrt(pi)*x**((x+1)/2)*exp(-x/2)
+ 5.97262736954392e+17830
+
+The recurrence formula `x!! = x (x-2)!!` can be reversed to
+define the double factorial of negative odd integers (but
+not negative even integers)::
+
+ >>> fac2(-1), fac2(-3), fac2(-5), fac2(-7)
+ (1.0, -1.0, 0.333333333333333, -0.0666666666666667)
+ >>> fac2(-2)
+ Traceback (most recent call last):
+ ...
+ ValueError: gamma function pole
+
+With the exception of the poles at negative even integers,
+:func:`~mpmath.fac2` supports evaluation for arbitrary complex arguments.
+The recurrence formula is valid generally::
+
+ >>> fac2(pi+2j)
+ (-1.3697207890154e-12 + 3.93665300979176e-12j)
+ >>> (pi+2j)*fac2(pi-2+2j)
+ (-1.3697207890154e-12 + 3.93665300979176e-12j)
+
+Double factorials should not be confused with nested factorials,
+which are immensely larger::
+
+ >>> fac(fac(20))
+ 5.13805976125208e+43675043585825292774
+ >>> fac2(20)
+ 3715891200.0
+
+Double factorials appear, among other things, in series expansions
+of Gaussian functions and the error function. Infinite series
+include::
+
+ >>> nsum(lambda k: 1/fac2(k), [0, inf])
+ 3.05940740534258
+ >>> sqrt(e)*(1+sqrt(pi/2)*erf(sqrt(2)/2))
+ 3.05940740534258
+ >>> nsum(lambda k: 2**k/fac2(2*k-1), [1, inf])
+ 4.06015693855741
+ >>> e * erf(1) * sqrt(pi)
+ 4.06015693855741
+
+A beautiful Ramanujan sum::
+
+ >>> nsum(lambda k: (-1)**k*(fac2(2*k-1)/fac2(2*k))**3, [0,inf])
+ 0.90917279454693
+ >>> (gamma('9/8')/gamma('5/4')/gamma('7/8'))**2
+ 0.90917279454693
+
+**References**
+
+1. http://functions.wolfram.com/GammaBetaErf/Factorial2/27/01/0002/
+
+2. http://mathworld.wolfram.com/DoubleFactorial.html
+
+"""
+
+hyper = r"""
+Evaluates the generalized hypergeometric function
+
+.. math ::
+
+ \,_pF_q(a_1,\ldots,a_p; b_1,\ldots,b_q; z) =
+ \sum_{n=0}^\infty \frac{(a_1)_n (a_2)_n \ldots (a_p)_n}
+ {(b_1)_n(b_2)_n\ldots(b_q)_n} \frac{z^n}{n!}
+
+where `(x)_n` denotes the rising factorial (see :func:`~mpmath.rf`).
+
+The parameters lists ``a_s`` and ``b_s`` may contain integers,
+real numbers, complex numbers, as well as exact fractions given in
+the form of tuples `(p, q)`. :func:`~mpmath.hyper` is optimized to handle
+integers and fractions more efficiently than arbitrary
+floating-point parameters (since rational parameters are by
+far the most common).
+
+**Examples**
+
+Verifying that :func:`~mpmath.hyper` gives the sum in the definition, by
+comparison with :func:`~mpmath.nsum`::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> a,b,c,d = 2,3,4,5
+ >>> x = 0.25
+ >>> hyper([a,b],[c,d],x)
+ 1.078903941164934876086237
+ >>> fn = lambda n: rf(a,n)*rf(b,n)/rf(c,n)/rf(d,n)*x**n/fac(n)
+ >>> nsum(fn, [0, inf])
+ 1.078903941164934876086237
+
+The parameters can be any combination of integers, fractions,
+floats and complex numbers::
+
+ >>> a, b, c, d, e = 1, (-1,2), pi, 3+4j, (2,3)
+ >>> x = 0.2j
+ >>> hyper([a,b],[c,d,e],x)
+ (0.9923571616434024810831887 - 0.005753848733883879742993122j)
+ >>> b, e = -0.5, mpf(2)/3
+ >>> fn = lambda n: rf(a,n)*rf(b,n)/rf(c,n)/rf(d,n)/rf(e,n)*x**n/fac(n)
+ >>> nsum(fn, [0, inf])
+ (0.9923571616434024810831887 - 0.005753848733883879742993122j)
+
+The `\,_0F_0` and `\,_1F_0` series are just elementary functions::
+
+ >>> a, z = sqrt(2), +pi
+ >>> hyper([],[],z)
+ 23.14069263277926900572909
+ >>> exp(z)
+ 23.14069263277926900572909
+ >>> hyper([a],[],z)
+ (-0.09069132879922920160334114 + 0.3283224323946162083579656j)
+ >>> (1-z)**(-a)
+ (-0.09069132879922920160334114 + 0.3283224323946162083579656j)
+
+If any `a_k` coefficient is a nonpositive integer, the series terminates
+into a finite polynomial::
+
+ >>> hyper([1,1,1,-3],[2,5],1)
+ 0.7904761904761904761904762
+ >>> identify(_)
+ '(83/105)'
+
+If any `b_k` is a nonpositive integer, the function is undefined (unless the
+series terminates before the division by zero occurs)::
+
+ >>> hyper([1,1,1,-3],[-2,5],1)
+ Traceback (most recent call last):
+ ...
+ ZeroDivisionError: pole in hypergeometric series
+ >>> hyper([1,1,1,-1],[-2,5],1)
+ 1.1
+
+Except for polynomial cases, the radius of convergence `R` of the hypergeometric
+series is either `R = \infty` (if `p \le q`), `R = 1` (if `p = q+1`), or
+`R = 0` (if `p > q+1`).
+
+The analytic continuations of the functions with `p = q+1`, i.e. `\,_2F_1`,
+`\,_3F_2`, `\,_4F_3`, etc, are all implemented and therefore these functions
+can be evaluated for `|z| \ge 1`. The shortcuts :func:`~mpmath.hyp2f1`, :func:`~mpmath.hyp3f2`
+are available to handle the most common cases (see their documentation),
+but functions of higher degree are also supported via :func:`~mpmath.hyper`::
+
+ >>> hyper([1,2,3,4], [5,6,7], 1) # 4F3 at finite-valued branch point
+ 1.141783505526870731311423
+ >>> hyper([4,5,6,7], [1,2,3], 1) # 4F3 at pole
+ +inf
+ >>> hyper([1,2,3,4,5], [6,7,8,9], 10) # 5F4
+ (1.543998916527972259717257 - 0.5876309929580408028816365j)
+ >>> hyper([1,2,3,4,5,6], [7,8,9,10,11], 1j) # 6F5
+ (0.9996565821853579063502466 + 0.0129721075905630604445669j)
+
+Near `z = 1` with noninteger parameters::
+
+ >>> hyper(['1/3',1,'3/2',2], ['1/5','11/6','41/8'], 1)
+ 2.219433352235586121250027
+ >>> hyper(['1/3',1,'3/2',2], ['1/5','11/6','5/4'], 1)
+ +inf
+ >>> eps1 = extradps(6)(lambda: 1 - mpf('1e-6'))()
+ >>> hyper(['1/3',1,'3/2',2], ['1/5','11/6','5/4'], eps1)
+ 2923978034.412973409330956
+
+Please note that, as currently implemented, evaluation of `\,_pF_{p-1}`
+with `p \ge 3` may be slow or inaccurate when `|z-1|` is small,
+for some parameter values.
+
+Evaluation may be aborted if convergence appears to be too slow.
+The optional ``maxterms`` (limiting the number of series terms) and ``maxprec``
+(limiting the internal precision) keyword arguments can be used
+to control evaluation::
+
+ >>> hyper([1,2,3], [4,5,6], 10000) # doctest: +IGNORE_EXCEPTION_DETAIL
+ Traceback (most recent call last):
+ ...
+ NoConvergence: Hypergeometric series converges too slowly. Try increasing maxterms.
+ >>> hyper([1,2,3], [4,5,6], 10000, maxterms=10**6)
+ 7.622806053177969474396918e+4310
+
+Additional options include ``force_series`` (which forces direct use of
+a hypergeometric series even if another evaluation method might work better)
+and ``asymp_tol`` which controls the target tolerance for using
+asymptotic series.
+
+When `p > q+1`, ``hyper`` computes the (iterated) Borel sum of the divergent
+series. For `\,_2F_0` the Borel sum has an analytic solution and can be
+computed efficiently (see :func:`~mpmath.hyp2f0`). For higher degrees, the functions
+is evaluated first by attempting to sum it directly as an asymptotic
+series (this only works for tiny `|z|`), and then by evaluating the Borel
+regularized sum using numerical integration. Except for
+special parameter combinations, this can be extremely slow.
+
+ >>> hyper([1,1], [], 0.5) # regularization of 2F0
+ (1.340965419580146562086448 + 0.8503366631752726568782447j)
+ >>> hyper([1,1,1,1], [1], 0.5) # regularization of 4F1
+ (1.108287213689475145830699 + 0.5327107430640678181200491j)
+
+With the following magnitude of argument, the asymptotic series for `\,_3F_1`
+gives only a few digits. Using Borel summation, ``hyper`` can produce
+a value with full accuracy::
+
+ >>> mp.dps = 15
+ >>> hyper([2,0.5,4], [5.25], '0.08', force_series=True) # doctest: +IGNORE_EXCEPTION_DETAIL
+ Traceback (most recent call last):
+ ...
+ NoConvergence: Hypergeometric series converges too slowly. Try increasing maxterms.
+ >>> hyper([2,0.5,4], [5.25], '0.08', asymp_tol=1e-4)
+ 1.0725535790737
+ >>> hyper([2,0.5,4], [5.25], '0.08')
+ (1.07269542893559 + 5.54668863216891e-5j)
+ >>> hyper([2,0.5,4], [5.25], '-0.08', asymp_tol=1e-4)
+ 0.946344925484879
+ >>> hyper([2,0.5,4], [5.25], '-0.08')
+ 0.946312503737771
+ >>> mp.dps = 25
+ >>> hyper([2,0.5,4], [5.25], '-0.08')
+ 0.9463125037377662296700858
+
+Note that with the positive `z` value, there is a complex part in the
+correct result, which falls below the tolerance of the asymptotic series.
+
+By default, a parameter that appears in both ``a_s`` and ``b_s`` will be removed
+unless it is a nonpositive integer. This generally speeds up evaluation
+by producing a hypergeometric function of lower order.
+This optimization can be disabled by passing ``eliminate=False``.
+
+ >>> hyper([1,2,3], [4,5,3], 10000)
+ 1.268943190440206905892212e+4321
+ >>> hyper([1,2,3], [4,5,3], 10000, eliminate=False) # doctest: +IGNORE_EXCEPTION_DETAIL
+ Traceback (most recent call last):
+ ...
+ NoConvergence: Hypergeometric series converges too slowly. Try increasing maxterms.
+ >>> hyper([1,2,3], [4,5,3], 10000, eliminate=False, maxterms=10**6)
+ 1.268943190440206905892212e+4321
+
+If a nonpositive integer `-n` appears in both ``a_s`` and ``b_s``, this parameter
+cannot be unambiguously removed since it creates a term 0 / 0.
+In this case the hypergeometric series is understood to terminate before
+the division by zero occurs. This convention is consistent with Mathematica.
+An alternative convention of eliminating the parameters can be toggled
+with ``eliminate_all=True``:
+
+ >>> hyper([2,-1], [-1], 3)
+ 7.0
+ >>> hyper([2,-1], [-1], 3, eliminate_all=True)
+ 0.25
+ >>> hyper([2], [], 3)
+ 0.25
+
+"""
+
+hypercomb = r"""
+Computes a weighted combination of hypergeometric functions
+
+.. math ::
+
+ \sum_{r=1}^N \left[ \prod_{k=1}^{l_r} {w_{r,k}}^{c_{r,k}}
+ \frac{\prod_{k=1}^{m_r} \Gamma(\alpha_{r,k})}{\prod_{k=1}^{n_r}
+ \Gamma(\beta_{r,k})}
+ \,_{p_r}F_{q_r}(a_{r,1},\ldots,a_{r,p}; b_{r,1},
+ \ldots, b_{r,q}; z_r)\right].
+
+Typically the parameters are linear combinations of a small set of base
+parameters; :func:`~mpmath.hypercomb` permits computing a correct value in
+the case that some of the `\alpha`, `\beta`, `b` turn out to be
+nonpositive integers, or if division by zero occurs for some `w^c`,
+assuming that there are opposing singularities that cancel out.
+The limit is computed by evaluating the function with the base
+parameters perturbed, at a higher working precision.
+
+The first argument should be a function that takes the perturbable
+base parameters ``params`` as input and returns `N` tuples
+``(w, c, alpha, beta, a, b, z)``, where the coefficients ``w``, ``c``,
+gamma factors ``alpha``, ``beta``, and hypergeometric coefficients
+``a``, ``b`` each should be lists of numbers, and ``z`` should be a single
+number.
+
+**Examples**
+
+The following evaluates
+
+.. math ::
+
+ (a-1) \frac{\Gamma(a-3)}{\Gamma(a-4)} \,_1F_1(a,a-1,z) = e^z(a-4)(a+z-1)
+
+with `a=1, z=3`. There is a zero factor, two gamma function poles, and
+the 1F1 function is singular; all singularities cancel out to give a finite
+value::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> hypercomb(lambda a: [([a-1],[1],[a-3],[a-4],[a],[a-1],3)], [1])
+ -180.769832308689
+ >>> -9*exp(3)
+ -180.769832308689
+
+"""
+
+hyp0f1 = r"""
+Gives the hypergeometric function `\,_0F_1`, sometimes known as the
+confluent limit function, defined as
+
+.. math ::
+
+ \,_0F_1(a,z) = \sum_{k=0}^{\infty} \frac{1}{(a)_k} \frac{z^k}{k!}.
+
+This function satisfies the differential equation `z f''(z) + a f'(z) = f(z)`,
+and is related to the Bessel function of the first kind (see :func:`~mpmath.besselj`).
+
+``hyp0f1(a,z)`` is equivalent to ``hyper([],[a],z)``; see documentation for
+:func:`~mpmath.hyper` for more information.
+
+**Examples**
+
+Evaluation for arbitrary arguments::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> hyp0f1(2, 0.25)
+ 1.130318207984970054415392
+ >>> hyp0f1((1,2), 1234567)
+ 6.27287187546220705604627e+964
+ >>> hyp0f1(3+4j, 1000000j)
+ (3.905169561300910030267132e+606 + 3.807708544441684513934213e+606j)
+
+Evaluation is supported for arbitrarily large values of `z`,
+using asymptotic expansions::
+
+ >>> hyp0f1(1, 10**50)
+ 2.131705322874965310390701e+8685889638065036553022565
+ >>> hyp0f1(1, -10**50)
+ 1.115945364792025420300208e-13
+
+Verifying the differential equation::
+
+ >>> a = 2.5
+ >>> f = lambda z: hyp0f1(a,z)
+ >>> for z in [0, 10, 3+4j]:
+ ... chop(z*diff(f,z,2) + a*diff(f,z) - f(z))
+ ...
+ 0.0
+ 0.0
+ 0.0
+
+"""
+
+hyp1f1 = r"""
+Gives the confluent hypergeometric function of the first kind,
+
+.. math ::
+
+ \,_1F_1(a,b,z) = \sum_{k=0}^{\infty} \frac{(a)_k}{(b)_k} \frac{z^k}{k!},
+
+also known as Kummer's function and sometimes denoted by `M(a,b,z)`. This
+function gives one solution to the confluent (Kummer's) differential equation
+
+.. math ::
+
+ z f''(z) + (b-z) f'(z) - af(z) = 0.
+
+A second solution is given by the `U` function; see :func:`~mpmath.hyperu`.
+Solutions are also given in an alternate form by the Whittaker
+functions (:func:`~mpmath.whitm`, :func:`~mpmath.whitw`).
+
+``hyp1f1(a,b,z)`` is equivalent
+to ``hyper([a],[b],z)``; see documentation for :func:`~mpmath.hyper` for more
+information.
+
+**Examples**
+
+Evaluation for real and complex values of the argument `z`, with
+fixed parameters `a = 2, b = -1/3`::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> hyp1f1(2, (-1,3), 3.25)
+ -2815.956856924817275640248
+ >>> hyp1f1(2, (-1,3), -3.25)
+ -1.145036502407444445553107
+ >>> hyp1f1(2, (-1,3), 1000)
+ -8.021799872770764149793693e+441
+ >>> hyp1f1(2, (-1,3), -1000)
+ 0.000003131987633006813594535331
+ >>> hyp1f1(2, (-1,3), 100+100j)
+ (-3.189190365227034385898282e+48 - 1.106169926814270418999315e+49j)
+
+Parameters may be complex::
+
+ >>> hyp1f1(2+3j, -1+j, 10j)
+ (261.8977905181045142673351 + 160.8930312845682213562172j)
+
+Arbitrarily large values of `z` are supported::
+
+ >>> hyp1f1(3, 4, 10**20)
+ 3.890569218254486878220752e+43429448190325182745
+ >>> hyp1f1(3, 4, -10**20)
+ 6.0e-60
+ >>> hyp1f1(3, 4, 10**20*j)
+ (-1.935753855797342532571597e-20 - 2.291911213325184901239155e-20j)
+
+Verifying the differential equation::
+
+ >>> a, b = 1.5, 2
+ >>> f = lambda z: hyp1f1(a,b,z)
+ >>> for z in [0, -10, 3, 3+4j]:
+ ... chop(z*diff(f,z,2) + (b-z)*diff(f,z) - a*f(z))
+ ...
+ 0.0
+ 0.0
+ 0.0
+ 0.0
+
+An integral representation::
+
+ >>> a, b = 1.5, 3
+ >>> z = 1.5
+ >>> hyp1f1(a,b,z)
+ 2.269381460919952778587441
+ >>> g = lambda t: exp(z*t)*t**(a-1)*(1-t)**(b-a-1)
+ >>> gammaprod([b],[a,b-a])*quad(g, [0,1])
+ 2.269381460919952778587441
+
+
+"""
+
+hyp1f2 = r"""
+Gives the hypergeometric function `\,_1F_2(a_1,a_2;b_1,b_2; z)`.
+The call ``hyp1f2(a1,b1,b2,z)`` is equivalent to
+``hyper([a1],[b1,b2],z)``.
+
+Evaluation works for complex and arbitrarily large arguments::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> a, b, c = 1.5, (-1,3), 2.25
+ >>> hyp1f2(a, b, c, 10**20)
+ -1.159388148811981535941434e+8685889639
+ >>> hyp1f2(a, b, c, -10**20)
+ -12.60262607892655945795907
+ >>> hyp1f2(a, b, c, 10**20*j)
+ (4.237220401382240876065501e+6141851464 - 2.950930337531768015892987e+6141851464j)
+ >>> hyp1f2(2+3j, -2j, 0.5j, 10-20j)
+ (135881.9905586966432662004 - 86681.95885418079535738828j)
+
+"""
+
+hyp2f2 = r"""
+Gives the hypergeometric function `\,_2F_2(a_1,a_2;b_1,b_2; z)`.
+The call ``hyp2f2(a1,a2,b1,b2,z)`` is equivalent to
+``hyper([a1,a2],[b1,b2],z)``.
+
+Evaluation works for complex and arbitrarily large arguments::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> a, b, c, d = 1.5, (-1,3), 2.25, 4
+ >>> hyp2f2(a, b, c, d, 10**20)
+ -5.275758229007902299823821e+43429448190325182663
+ >>> hyp2f2(a, b, c, d, -10**20)
+ 2561445.079983207701073448
+ >>> hyp2f2(a, b, c, d, 10**20*j)
+ (2218276.509664121194836667 - 1280722.539991603850462856j)
+ >>> hyp2f2(2+3j, -2j, 0.5j, 4j, 10-20j)
+ (80500.68321405666957342788 - 20346.82752982813540993502j)
+
+"""
+
+hyp2f3 = r"""
+Gives the hypergeometric function `\,_2F_3(a_1,a_2;b_1,b_2,b_3; z)`.
+The call ``hyp2f3(a1,a2,b1,b2,b3,z)`` is equivalent to
+``hyper([a1,a2],[b1,b2,b3],z)``.
+
+Evaluation works for arbitrarily large arguments::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> a1,a2,b1,b2,b3 = 1.5, (-1,3), 2.25, 4, (1,5)
+ >>> hyp2f3(a1,a2,b1,b2,b3,10**20)
+ -4.169178177065714963568963e+8685889590
+ >>> hyp2f3(a1,a2,b1,b2,b3,-10**20)
+ 7064472.587757755088178629
+ >>> hyp2f3(a1,a2,b1,b2,b3,10**20*j)
+ (-5.163368465314934589818543e+6141851415 + 1.783578125755972803440364e+6141851416j)
+ >>> hyp2f3(2+3j, -2j, 0.5j, 4j, -1-j, 10-20j)
+ (-2280.938956687033150740228 + 13620.97336609573659199632j)
+ >>> hyp2f3(2+3j, -2j, 0.5j, 4j, -1-j, 10000000-20000000j)
+ (4.849835186175096516193e+3504 - 3.365981529122220091353633e+3504j)
+
+"""
+
+hyp2f1 = r"""
+Gives the Gauss hypergeometric function `\,_2F_1` (often simply referred to as
+*the* hypergeometric function), defined for `|z| < 1` as
+
+.. math ::
+
+ \,_2F_1(a,b,c,z) = \sum_{k=0}^{\infty}
+ \frac{(a)_k (b)_k}{(c)_k} \frac{z^k}{k!}.
+
+and for `|z| \ge 1` by analytic continuation, with a branch cut on `(1, \infty)`
+when necessary.
+
+Special cases of this function include many of the orthogonal polynomials as
+well as the incomplete beta function and other functions. Properties of the
+Gauss hypergeometric function are documented comprehensively in many references,
+for example Abramowitz & Stegun, section 15.
+
+The implementation supports the analytic continuation as well as evaluation
+close to the unit circle where `|z| \approx 1`. The syntax ``hyp2f1(a,b,c,z)``
+is equivalent to ``hyper([a,b],[c],z)``.
+
+**Examples**
+
+Evaluation with `z` inside, outside and on the unit circle, for
+fixed parameters::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> hyp2f1(2, (1,2), 4, 0.75)
+ 1.303703703703703703703704
+ >>> hyp2f1(2, (1,2), 4, -1.75)
+ 0.7431290566046919177853916
+ >>> hyp2f1(2, (1,2), 4, 1.75)
+ (1.418075801749271137026239 - 1.114976146679907015775102j)
+ >>> hyp2f1(2, (1,2), 4, 1)
+ 1.6
+ >>> hyp2f1(2, (1,2), 4, -1)
+ 0.8235498012182875315037882
+ >>> hyp2f1(2, (1,2), 4, j)
+ (0.9144026291433065674259078 + 0.2050415770437884900574923j)
+ >>> hyp2f1(2, (1,2), 4, 2+j)
+ (0.9274013540258103029011549 + 0.7455257875808100868984496j)
+ >>> hyp2f1(2, (1,2), 4, 0.25j)
+ (0.9931169055799728251931672 + 0.06154836525312066938147793j)
+
+Evaluation with complex parameter values::
+
+ >>> hyp2f1(1+j, 0.75, 10j, 1+5j)
+ (0.8834833319713479923389638 + 0.7053886880648105068343509j)
+
+Evaluation with `z = 1`::
+
+ >>> hyp2f1(-2.5, 3.5, 1.5, 1)
+ 0.0
+ >>> hyp2f1(-2.5, 3, 4, 1)
+ 0.06926406926406926406926407
+ >>> hyp2f1(2, 3, 4, 1)
+ +inf
+
+Evaluation for huge arguments::
+
+ >>> hyp2f1((-1,3), 1.75, 4, '1e100')
+ (7.883714220959876246415651e+32 + 1.365499358305579597618785e+33j)
+ >>> hyp2f1((-1,3), 1.75, 4, '1e1000000')
+ (7.883714220959876246415651e+333332 + 1.365499358305579597618785e+333333j)
+ >>> hyp2f1((-1,3), 1.75, 4, '1e1000000j')
+ (1.365499358305579597618785e+333333 - 7.883714220959876246415651e+333332j)
+
+An integral representation::
+
+ >>> a,b,c,z = -0.5, 1, 2.5, 0.25
+ >>> g = lambda t: t**(b-1) * (1-t)**(c-b-1) * (1-t*z)**(-a)
+ >>> gammaprod([c],[b,c-b]) * quad(g, [0,1])
+ 0.9480458814362824478852618
+ >>> hyp2f1(a,b,c,z)
+ 0.9480458814362824478852618
+
+Verifying the hypergeometric differential equation::
+
+ >>> f = lambda z: hyp2f1(a,b,c,z)
+ >>> chop(z*(1-z)*diff(f,z,2) + (c-(a+b+1)*z)*diff(f,z) - a*b*f(z))
+ 0.0
+
+"""
+
+hyp3f2 = r"""
+Gives the generalized hypergeometric function `\,_3F_2`, defined for `|z| < 1`
+as
+
+.. math ::
+
+ \,_3F_2(a_1,a_2,a_3,b_1,b_2,z) = \sum_{k=0}^{\infty}
+ \frac{(a_1)_k (a_2)_k (a_3)_k}{(b_1)_k (b_2)_k} \frac{z^k}{k!}.
+
+and for `|z| \ge 1` by analytic continuation. The analytic structure of this
+function is similar to that of `\,_2F_1`, generally with a singularity at
+`z = 1` and a branch cut on `(1, \infty)`.
+
+Evaluation is supported inside, on, and outside
+the circle of convergence `|z| = 1`::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> hyp3f2(1,2,3,4,5,0.25)
+ 1.083533123380934241548707
+ >>> hyp3f2(1,2+2j,3,4,5,-10+10j)
+ (0.1574651066006004632914361 - 0.03194209021885226400892963j)
+ >>> hyp3f2(1,2,3,4,5,-10)
+ 0.3071141169208772603266489
+ >>> hyp3f2(1,2,3,4,5,10)
+ (-0.4857045320523947050581423 - 0.5988311440454888436888028j)
+ >>> hyp3f2(0.25,1,1,2,1.5,1)
+ 1.157370995096772047567631
+ >>> (8-pi-2*ln2)/3
+ 1.157370995096772047567631
+ >>> hyp3f2(1+j,0.5j,2,1,-2j,-1)
+ (1.74518490615029486475959 + 0.1454701525056682297614029j)
+ >>> hyp3f2(1+j,0.5j,2,1,-2j,sqrt(j))
+ (0.9829816481834277511138055 - 0.4059040020276937085081127j)
+ >>> hyp3f2(-3,2,1,-5,4,1)
+ 1.41
+ >>> hyp3f2(-3,2,1,-5,4,2)
+ 2.12
+
+Evaluation very close to the unit circle::
+
+ >>> hyp3f2(1,2,3,4,5,'1.0001')
+ (1.564877796743282766872279 - 3.76821518787438186031973e-11j)
+ >>> hyp3f2(1,2,3,4,5,'1+0.0001j')
+ (1.564747153061671573212831 + 0.0001305757570366084557648482j)
+ >>> hyp3f2(1,2,3,4,5,'0.9999')
+ 1.564616644881686134983664
+ >>> hyp3f2(1,2,3,4,5,'-0.9999')
+ 0.7823896253461678060196207
+
+.. note ::
+
+ Evaluation for `|z-1|` small can currently be inaccurate or slow
+ for some parameter combinations.
+
+For various parameter combinations, `\,_3F_2` admits representation in terms
+of hypergeometric functions of lower degree, or in terms of
+simpler functions::
+
+ >>> for a, b, z in [(1,2,-1), (2,0.5,1)]:
+ ... hyp2f1(a,b,a+b+0.5,z)**2
+ ... hyp3f2(2*a,a+b,2*b,a+b+0.5,2*a+2*b,z)
+ ...
+ 0.4246104461966439006086308
+ 0.4246104461966439006086308
+ 7.111111111111111111111111
+ 7.111111111111111111111111
+
+ >>> z = 2+3j
+ >>> hyp3f2(0.5,1,1.5,2,2,z)
+ (0.7621440939243342419729144 + 0.4249117735058037649915723j)
+ >>> 4*(pi-2*ellipe(z))/(pi*z)
+ (0.7621440939243342419729144 + 0.4249117735058037649915723j)
+
+"""
+
+hyperu = r"""
+Gives the Tricomi confluent hypergeometric function `U`, also known as
+the Kummer or confluent hypergeometric function of the second kind. This
+function gives a second linearly independent solution to the confluent
+hypergeometric differential equation (the first is provided by `\,_1F_1` --
+see :func:`~mpmath.hyp1f1`).
+
+**Examples**
+
+Evaluation for arbitrary complex arguments::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> hyperu(2,3,4)
+ 0.0625
+ >>> hyperu(0.25, 5, 1000)
+ 0.1779949416140579573763523
+ >>> hyperu(0.25, 5, -1000)
+ (0.1256256609322773150118907 - 0.1256256609322773150118907j)
+
+The `U` function may be singular at `z = 0`::
+
+ >>> hyperu(1.5, 2, 0)
+ +inf
+ >>> hyperu(1.5, -2, 0)
+ 0.1719434921288400112603671
+
+Verifying the differential equation::
+
+ >>> a, b = 1.5, 2
+ >>> f = lambda z: hyperu(a,b,z)
+ >>> for z in [-10, 3, 3+4j]:
+ ... chop(z*diff(f,z,2) + (b-z)*diff(f,z) - a*f(z))
+ ...
+ 0.0
+ 0.0
+ 0.0
+
+An integral representation::
+
+ >>> a,b,z = 2, 3.5, 4.25
+ >>> hyperu(a,b,z)
+ 0.06674960718150520648014567
+ >>> quad(lambda t: exp(-z*t)*t**(a-1)*(1+t)**(b-a-1),[0,inf]) / gamma(a)
+ 0.06674960718150520648014567
+
+
+[1] http://people.math.sfu.ca/~cbm/aands/page_504.htm
+"""
+
+hyp2f0 = r"""
+Gives the hypergeometric function `\,_2F_0`, defined formally by the
+series
+
+.. math ::
+
+ \,_2F_0(a,b;;z) = \sum_{n=0}^{\infty} (a)_n (b)_n \frac{z^n}{n!}.
+
+This series usually does not converge. For small enough `z`, it can be viewed
+as an asymptotic series that may be summed directly with an appropriate
+truncation. When this is not the case, :func:`~mpmath.hyp2f0` gives a regularized sum,
+or equivalently, it uses a representation in terms of the
+hypergeometric U function [1]. The series also converges when either `a` or `b`
+is a nonpositive integer, as it then terminates into a polynomial
+after `-a` or `-b` terms.
+
+**Examples**
+
+Evaluation is supported for arbitrary complex arguments::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> hyp2f0((2,3), 1.25, -100)
+ 0.07095851870980052763312791
+ >>> hyp2f0((2,3), 1.25, 100)
+ (-0.03254379032170590665041131 + 0.07269254613282301012735797j)
+ >>> hyp2f0(-0.75, 1-j, 4j)
+ (-0.3579987031082732264862155 - 3.052951783922142735255881j)
+
+Even with real arguments, the regularized value of 2F0 is often complex-valued,
+but the imaginary part decreases exponentially as `z \to 0`. In the following
+example, the first call uses complex evaluation while the second has a small
+enough `z` to evaluate using the direct series and thus the returned value
+is strictly real (this should be taken to indicate that the imaginary
+part is less than ``eps``)::
+
+ >>> mp.dps = 15
+ >>> hyp2f0(1.5, 0.5, 0.05)
+ (1.04166637647907 + 8.34584913683906e-8j)
+ >>> hyp2f0(1.5, 0.5, 0.0005)
+ 1.00037535207621
+
+The imaginary part can be retrieved by increasing the working precision::
+
+ >>> mp.dps = 80
+ >>> nprint(hyp2f0(1.5, 0.5, 0.009).imag)
+ 1.23828e-46
+
+In the polynomial case (the series terminating), 2F0 can evaluate exactly::
+
+ >>> mp.dps = 15
+ >>> hyp2f0(-6,-6,2)
+ 291793.0
+ >>> identify(hyp2f0(-2,1,0.25))
+ '(5/8)'
+
+The coefficients of the polynomials can be recovered using Taylor expansion::
+
+ >>> nprint(taylor(lambda x: hyp2f0(-3,0.5,x), 0, 10))
+ [1.0, -1.5, 2.25, -1.875, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
+ >>> nprint(taylor(lambda x: hyp2f0(-4,0.5,x), 0, 10))
+ [1.0, -2.0, 4.5, -7.5, 6.5625, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
+
+
+[1] http://people.math.sfu.ca/~cbm/aands/page_504.htm
+"""
+
+
+gammainc = r"""
+``gammainc(z, a=0, b=inf)`` computes the (generalized) incomplete
+gamma function with integration limits `[a, b]`:
+
+.. math ::
+
+ \Gamma(z,a,b) = \int_a^b t^{z-1} e^{-t} \, dt
+
+The generalized incomplete gamma function reduces to the
+following special cases when one or both endpoints are fixed:
+
+* `\Gamma(z,0,\infty)` is the standard ("complete")
+ gamma function, `\Gamma(z)` (available directly
+ as the mpmath function :func:`~mpmath.gamma`)
+* `\Gamma(z,a,\infty)` is the "upper" incomplete gamma
+ function, `\Gamma(z,a)`
+* `\Gamma(z,0,b)` is the "lower" incomplete gamma
+ function, `\gamma(z,b)`.
+
+Of course, we have
+`\Gamma(z,0,x) + \Gamma(z,x,\infty) = \Gamma(z)`
+for all `z` and `x`.
+
+Note however that some authors reverse the order of the
+arguments when defining the lower and upper incomplete
+gamma function, so one should be careful to get the correct
+definition.
+
+If also given the keyword argument ``regularized=True``,
+:func:`~mpmath.gammainc` computes the "regularized" incomplete gamma
+function
+
+.. math ::
+
+ P(z,a,b) = \frac{\Gamma(z,a,b)}{\Gamma(z)}.
+
+**Examples**
+
+We can compare with numerical quadrature to verify that
+:func:`~mpmath.gammainc` computes the integral in the definition::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> gammainc(2+3j, 4, 10)
+ (0.00977212668627705160602312 - 0.0770637306312989892451977j)
+ >>> quad(lambda t: t**(2+3j-1) * exp(-t), [4, 10])
+ (0.00977212668627705160602312 - 0.0770637306312989892451977j)
+
+Argument symmetries follow directly from the integral definition::
+
+ >>> gammainc(3, 4, 5) + gammainc(3, 5, 4)
+ 0.0
+ >>> gammainc(3,0,2) + gammainc(3,2,4); gammainc(3,0,4)
+ 1.523793388892911312363331
+ 1.523793388892911312363331
+ >>> findroot(lambda z: gammainc(2,z,3), 1)
+ 3.0
+
+Evaluation for arbitrarily large arguments::
+
+ >>> gammainc(10, 100)
+ 4.083660630910611272288592e-26
+ >>> gammainc(10, 10000000000000000)
+ 5.290402449901174752972486e-4342944819032375
+ >>> gammainc(3+4j, 1000000+1000000j)
+ (-1.257913707524362408877881e-434284 + 2.556691003883483531962095e-434284j)
+
+Evaluation of a generalized incomplete gamma function automatically chooses
+the representation that gives a more accurate result, depending on which
+parameter is larger::
+
+ >>> gammainc(10000000, 3) - gammainc(10000000, 2) # Bad
+ 0.0
+ >>> gammainc(10000000, 2, 3) # Good
+ 1.755146243738946045873491e+4771204
+ >>> gammainc(2, 0, 100000001) - gammainc(2, 0, 100000000) # Bad
+ 0.0
+ >>> gammainc(2, 100000000, 100000001) # Good
+ 4.078258353474186729184421e-43429441
+
+The incomplete gamma functions satisfy simple recurrence
+relations::
+
+ >>> mp.dps = 25
+ >>> z, a = mpf(3.5), mpf(2)
+ >>> gammainc(z+1, a); z*gammainc(z,a) + a**z*exp(-a)
+ 10.60130296933533459267329
+ 10.60130296933533459267329
+ >>> gammainc(z+1,0,a); z*gammainc(z,0,a) - a**z*exp(-a)
+ 1.030425427232114336470932
+ 1.030425427232114336470932
+
+Evaluation at integers and poles::
+
+ >>> gammainc(-3, -4, -5)
+ (-0.2214577048967798566234192 + 0.0j)
+ >>> gammainc(-3, 0, 5)
+ +inf
+
+If `z` is an integer, the recurrence reduces the incomplete gamma
+function to `P(a) \exp(-a) + Q(b) \exp(-b)` where `P` and
+`Q` are polynomials::
+
+ >>> gammainc(1, 2); exp(-2)
+ 0.1353352832366126918939995
+ 0.1353352832366126918939995
+ >>> mp.dps = 50
+ >>> identify(gammainc(6, 1, 2), ['exp(-1)', 'exp(-2)'])
+ '(326*exp(-1) + (-872)*exp(-2))'
+
+The incomplete gamma functions reduce to functions such as
+the exponential integral Ei and the error function for special
+arguments::
+
+ >>> mp.dps = 25
+ >>> gammainc(0, 4); -ei(-4)
+ 0.00377935240984890647887486
+ 0.00377935240984890647887486
+ >>> gammainc(0.5, 0, 2); sqrt(pi)*erf(sqrt(2))
+ 1.691806732945198336509541
+ 1.691806732945198336509541
+
+"""
+
+erf = r"""
+Computes the error function, `\mathrm{erf}(x)`. The error
+function is the normalized antiderivative of the Gaussian function
+`\exp(-t^2)`. More precisely,
+
+.. math::
+
+ \mathrm{erf}(x) = \frac{2}{\sqrt \pi} \int_0^x \exp(-t^2) \,dt
+
+**Basic examples**
+
+Simple values and limits include::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> erf(0)
+ 0.0
+ >>> erf(1)
+ 0.842700792949715
+ >>> erf(-1)
+ -0.842700792949715
+ >>> erf(inf)
+ 1.0
+ >>> erf(-inf)
+ -1.0
+
+For large real `x`, `\mathrm{erf}(x)` approaches 1 very
+rapidly::
+
+ >>> erf(3)
+ 0.999977909503001
+ >>> erf(5)
+ 0.999999999998463
+
+The error function is an odd function::
+
+ >>> nprint(chop(taylor(erf, 0, 5)))
+ [0.0, 1.12838, 0.0, -0.376126, 0.0, 0.112838]
+
+:func:`~mpmath.erf` implements arbitrary-precision evaluation and
+supports complex numbers::
+
+ >>> mp.dps = 50
+ >>> erf(0.5)
+ 0.52049987781304653768274665389196452873645157575796
+ >>> mp.dps = 25
+ >>> erf(1+j)
+ (1.316151281697947644880271 + 0.1904534692378346862841089j)
+
+Evaluation is supported for large arguments::
+
+ >>> mp.dps = 25
+ >>> erf('1e1000')
+ 1.0
+ >>> erf('-1e1000')
+ -1.0
+ >>> erf('1e-1000')
+ 1.128379167095512573896159e-1000
+ >>> erf('1e7j')
+ (0.0 + 8.593897639029319267398803e+43429448190317j)
+ >>> erf('1e7+1e7j')
+ (0.9999999858172446172631323 + 3.728805278735270407053139e-8j)
+
+**Related functions**
+
+See also :func:`~mpmath.erfc`, which is more accurate for large `x`,
+and :func:`~mpmath.erfi` which gives the antiderivative of
+`\exp(t^2)`.
+
+The Fresnel integrals :func:`~mpmath.fresnels` and :func:`~mpmath.fresnelc`
+are also related to the error function.
+"""
+
+erfc = r"""
+Computes the complementary error function,
+`\mathrm{erfc}(x) = 1-\mathrm{erf}(x)`.
+This function avoids cancellation that occurs when naively
+computing the complementary error function as ``1-erf(x)``::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> 1 - erf(10)
+ 0.0
+ >>> erfc(10)
+ 2.08848758376254e-45
+
+:func:`~mpmath.erfc` works accurately even for ludicrously large
+arguments::
+
+ >>> erfc(10**10)
+ 4.3504398860243e-43429448190325182776
+
+Complex arguments are supported::
+
+ >>> erfc(500+50j)
+ (1.19739830969552e-107492 + 1.46072418957528e-107491j)
+
+"""
+
+
+erfi = r"""
+Computes the imaginary error function, `\mathrm{erfi}(x)`.
+The imaginary error function is defined in analogy with the
+error function, but with a positive sign in the integrand:
+
+.. math ::
+
+ \mathrm{erfi}(x) = \frac{2}{\sqrt \pi} \int_0^x \exp(t^2) \,dt
+
+Whereas the error function rapidly converges to 1 as `x` grows,
+the imaginary error function rapidly diverges to infinity.
+The functions are related as
+`\mathrm{erfi}(x) = -i\,\mathrm{erf}(ix)` for all complex
+numbers `x`.
+
+**Examples**
+
+Basic values and limits::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> erfi(0)
+ 0.0
+ >>> erfi(1)
+ 1.65042575879754
+ >>> erfi(-1)
+ -1.65042575879754
+ >>> erfi(inf)
+ +inf
+ >>> erfi(-inf)
+ -inf
+
+Note the symmetry between erf and erfi::
+
+ >>> erfi(3j)
+ (0.0 + 0.999977909503001j)
+ >>> erf(3)
+ 0.999977909503001
+ >>> erf(1+2j)
+ (-0.536643565778565 - 5.04914370344703j)
+ >>> erfi(2+1j)
+ (-5.04914370344703 - 0.536643565778565j)
+
+Large arguments are supported::
+
+ >>> erfi(1000)
+ 1.71130938718796e+434291
+ >>> erfi(10**10)
+ 7.3167287567024e+43429448190325182754
+ >>> erfi(-10**10)
+ -7.3167287567024e+43429448190325182754
+ >>> erfi(1000-500j)
+ (2.49895233563961e+325717 + 2.6846779342253e+325717j)
+ >>> erfi(100000j)
+ (0.0 + 1.0j)
+ >>> erfi(-100000j)
+ (0.0 - 1.0j)
+
+
+"""
+
+erfinv = r"""
+Computes the inverse error function, satisfying
+
+.. math ::
+
+ \mathrm{erf}(\mathrm{erfinv}(x)) =
+ \mathrm{erfinv}(\mathrm{erf}(x)) = x.
+
+This function is defined only for `-1 \le x \le 1`.
+
+**Examples**
+
+Special values include::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> erfinv(0)
+ 0.0
+ >>> erfinv(1)
+ +inf
+ >>> erfinv(-1)
+ -inf
+
+The domain is limited to the standard interval::
+
+ >>> erfinv(2)
+ Traceback (most recent call last):
+ ...
+ ValueError: erfinv(x) is defined only for -1 <= x <= 1
+
+It is simple to check that :func:`~mpmath.erfinv` computes inverse values of
+:func:`~mpmath.erf` as promised::
+
+ >>> erf(erfinv(0.75))
+ 0.75
+ >>> erf(erfinv(-0.995))
+ -0.995
+
+:func:`~mpmath.erfinv` supports arbitrary-precision evaluation::
+
+ >>> mp.dps = 50
+ >>> x = erf(2)
+ >>> x
+ 0.99532226501895273416206925636725292861089179704006
+ >>> erfinv(x)
+ 2.0
+
+A definite integral involving the inverse error function::
+
+ >>> mp.dps = 15
+ >>> quad(erfinv, [0, 1])
+ 0.564189583547756
+ >>> 1/sqrt(pi)
+ 0.564189583547756
+
+The inverse error function can be used to generate random numbers
+with a Gaussian distribution (although this is a relatively
+inefficient algorithm)::
+
+ >>> nprint([erfinv(2*rand()-1) for n in range(6)]) # doctest: +SKIP
+ [-0.586747, 1.10233, -0.376796, 0.926037, -0.708142, -0.732012]
+
+"""
+
+npdf = r"""
+``npdf(x, mu=0, sigma=1)`` evaluates the probability density
+function of a normal distribution with mean value `\mu`
+and variance `\sigma^2`.
+
+Elementary properties of the probability distribution can
+be verified using numerical integration::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> quad(npdf, [-inf, inf])
+ 1.0
+ >>> quad(lambda x: npdf(x, 3), [3, inf])
+ 0.5
+ >>> quad(lambda x: npdf(x, 3, 2), [3, inf])
+ 0.5
+
+See also :func:`~mpmath.ncdf`, which gives the cumulative
+distribution.
+"""
+
+ncdf = r"""
+``ncdf(x, mu=0, sigma=1)`` evaluates the cumulative distribution
+function of a normal distribution with mean value `\mu`
+and variance `\sigma^2`.
+
+See also :func:`~mpmath.npdf`, which gives the probability density.
+
+Elementary properties include::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> ncdf(pi, mu=pi)
+ 0.5
+ >>> ncdf(-inf)
+ 0.0
+ >>> ncdf(+inf)
+ 1.0
+
+The cumulative distribution is the integral of the density
+function having identical mu and sigma::
+
+ >>> mp.dps = 15
+ >>> diff(ncdf, 2)
+ 0.053990966513188
+ >>> npdf(2)
+ 0.053990966513188
+ >>> diff(lambda x: ncdf(x, 1, 0.5), 0)
+ 0.107981933026376
+ >>> npdf(0, 1, 0.5)
+ 0.107981933026376
+"""
+
+expint = r"""
+:func:`~mpmath.expint(n,z)` gives the generalized exponential integral
+or En-function,
+
+.. math ::
+
+ \mathrm{E}_n(z) = \int_1^{\infty} \frac{e^{-zt}}{t^n} dt,
+
+where `n` and `z` may both be complex numbers. The case with `n = 1` is
+also given by :func:`~mpmath.e1`.
+
+**Examples**
+
+Evaluation at real and complex arguments::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> expint(1, 6.25)
+ 0.0002704758872637179088496194
+ >>> expint(-3, 2+3j)
+ (0.00299658467335472929656159 + 0.06100816202125885450319632j)
+ >>> expint(2+3j, 4-5j)
+ (0.001803529474663565056945248 - 0.002235061547756185403349091j)
+
+At negative integer values of `n`, `E_n(z)` reduces to a
+rational-exponential function::
+
+ >>> f = lambda n, z: fac(n)*sum(z**k/fac(k-1) for k in range(1,n+2))/\
+ ... exp(z)/z**(n+2)
+ >>> n = 3
+ >>> z = 1/pi
+ >>> expint(-n,z)
+ 584.2604820613019908668219
+ >>> f(n,z)
+ 584.2604820613019908668219
+ >>> n = 5
+ >>> expint(-n,z)
+ 115366.5762594725451811138
+ >>> f(n,z)
+ 115366.5762594725451811138
+"""
+
+e1 = r"""
+Computes the exponential integral `\mathrm{E}_1(z)`, given by
+
+.. math ::
+
+ \mathrm{E}_1(z) = \int_z^{\infty} \frac{e^{-t}}{t} dt.
+
+This is equivalent to :func:`~mpmath.expint` with `n = 1`.
+
+**Examples**
+
+Two ways to evaluate this function::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> e1(6.25)
+ 0.0002704758872637179088496194
+ >>> expint(1,6.25)
+ 0.0002704758872637179088496194
+
+The E1-function is essentially the same as the Ei-function (:func:`~mpmath.ei`)
+with negated argument, except for an imaginary branch cut term::
+
+ >>> e1(2.5)
+ 0.02491491787026973549562801
+ >>> -ei(-2.5)
+ 0.02491491787026973549562801
+ >>> e1(-2.5)
+ (-7.073765894578600711923552 - 3.141592653589793238462643j)
+ >>> -ei(2.5)
+ -7.073765894578600711923552
+
+"""
+
+ei = r"""
+Computes the exponential integral or Ei-function, `\mathrm{Ei}(x)`.
+The exponential integral is defined as
+
+.. math ::
+
+ \mathrm{Ei}(x) = \int_{-\infty\,}^x \frac{e^t}{t} \, dt.
+
+When the integration range includes `t = 0`, the exponential
+integral is interpreted as providing the Cauchy principal value.
+
+For real `x`, the Ei-function behaves roughly like
+`\mathrm{Ei}(x) \approx \exp(x) + \log(|x|)`.
+
+The Ei-function is related to the more general family of exponential
+integral functions denoted by `E_n`, which are available as :func:`~mpmath.expint`.
+
+**Basic examples**
+
+Some basic values and limits are::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> ei(0)
+ -inf
+ >>> ei(1)
+ 1.89511781635594
+ >>> ei(inf)
+ +inf
+ >>> ei(-inf)
+ 0.0
+
+For `x < 0`, the defining integral can be evaluated
+numerically as a reference::
+
+ >>> ei(-4)
+ -0.00377935240984891
+ >>> quad(lambda t: exp(t)/t, [-inf, -4])
+ -0.00377935240984891
+
+:func:`~mpmath.ei` supports complex arguments and arbitrary
+precision evaluation::
+
+ >>> mp.dps = 50
+ >>> ei(pi)
+ 10.928374389331410348638445906907535171566338835056
+ >>> mp.dps = 25
+ >>> ei(3+4j)
+ (-4.154091651642689822535359 + 4.294418620024357476985535j)
+
+**Related functions**
+
+The exponential integral is closely related to the logarithmic
+integral. See :func:`~mpmath.li` for additional information.
+
+The exponential integral is related to the hyperbolic
+and trigonometric integrals (see :func:`~mpmath.chi`, :func:`~mpmath.shi`,
+:func:`~mpmath.ci`, :func:`~mpmath.si`) similarly to how the ordinary
+exponential function is related to the hyperbolic and
+trigonometric functions::
+
+ >>> mp.dps = 15
+ >>> ei(3)
+ 9.93383257062542
+ >>> chi(3) + shi(3)
+ 9.93383257062542
+ >>> chop(ci(3j) - j*si(3j) - pi*j/2)
+ 9.93383257062542
+
+Beware that logarithmic corrections, as in the last example
+above, are required to obtain the correct branch in general.
+For details, see [1].
+
+The exponential integral is also a special case of the
+hypergeometric function `\,_2F_2`::
+
+ >>> z = 0.6
+ >>> z*hyper([1,1],[2,2],z) + (ln(z)-ln(1/z))/2 + euler
+ 0.769881289937359
+ >>> ei(z)
+ 0.769881289937359
+
+**References**
+
+1. Relations between Ei and other functions:
+ http://functions.wolfram.com/GammaBetaErf/ExpIntegralEi/27/01/
+
+2. Abramowitz & Stegun, section 5:
+ http://people.math.sfu.ca/~cbm/aands/page_228.htm
+
+3. Asymptotic expansion for Ei:
+ http://mathworld.wolfram.com/En-Function.html
+"""
+
+li = r"""
+Computes the logarithmic integral or li-function
+`\mathrm{li}(x)`, defined by
+
+.. math ::
+
+ \mathrm{li}(x) = \int_0^x \frac{1}{\log t} \, dt
+
+The logarithmic integral has a singularity at `x = 1`.
+
+Alternatively, ``li(x, offset=True)`` computes the offset
+logarithmic integral (used in number theory)
+
+.. math ::
+
+ \mathrm{Li}(x) = \int_2^x \frac{1}{\log t} \, dt.
+
+These two functions are related via the simple identity
+`\mathrm{Li}(x) = \mathrm{li}(x) - \mathrm{li}(2)`.
+
+The logarithmic integral should also not be confused with
+the polylogarithm (also denoted by Li), which is implemented
+as :func:`~mpmath.polylog`.
+
+**Examples**
+
+Some basic values and limits::
+
+ >>> from mpmath import *
+ >>> mp.dps = 30; mp.pretty = True
+ >>> li(0)
+ 0.0
+ >>> li(1)
+ -inf
+ >>> li(1)
+ -inf
+ >>> li(2)
+ 1.04516378011749278484458888919
+ >>> findroot(li, 2)
+ 1.45136923488338105028396848589
+ >>> li(inf)
+ +inf
+ >>> li(2, offset=True)
+ 0.0
+ >>> li(1, offset=True)
+ -inf
+ >>> li(0, offset=True)
+ -1.04516378011749278484458888919
+ >>> li(10, offset=True)
+ 5.12043572466980515267839286347
+
+The logarithmic integral can be evaluated for arbitrary
+complex arguments::
+
+ >>> mp.dps = 20
+ >>> li(3+4j)
+ (3.1343755504645775265 + 2.6769247817778742392j)
+
+The logarithmic integral is related to the exponential integral::
+
+ >>> ei(log(3))
+ 2.1635885946671919729
+ >>> li(3)
+ 2.1635885946671919729
+
+The logarithmic integral grows like `O(x/\log(x))`::
+
+ >>> mp.dps = 15
+ >>> x = 10**100
+ >>> x/log(x)
+ 4.34294481903252e+97
+ >>> li(x)
+ 4.3619719871407e+97
+
+The prime number theorem states that the number of primes less
+than `x` is asymptotic to `\mathrm{Li}(x)` (equivalently
+`\mathrm{li}(x)`). For example, it is known that there are
+exactly 1,925,320,391,606,803,968,923 prime numbers less than
+`10^{23}` [1]. The logarithmic integral provides a very
+accurate estimate::
+
+ >>> li(10**23, offset=True)
+ 1.92532039161405e+21
+
+A definite integral is::
+
+ >>> quad(li, [0, 1])
+ -0.693147180559945
+ >>> -ln(2)
+ -0.693147180559945
+
+**References**
+
+1. http://mathworld.wolfram.com/PrimeCountingFunction.html
+
+2. http://mathworld.wolfram.com/LogarithmicIntegral.html
+
+"""
+
+ci = r"""
+Computes the cosine integral,
+
+.. math ::
+
+ \mathrm{Ci}(x) = -\int_x^{\infty} \frac{\cos t}{t}\,dt
+ = \gamma + \log x + \int_0^x \frac{\cos t - 1}{t}\,dt
+
+**Examples**
+
+Some values and limits::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> ci(0)
+ -inf
+ >>> ci(1)
+ 0.3374039229009681346626462
+ >>> ci(pi)
+ 0.07366791204642548599010096
+ >>> ci(inf)
+ 0.0
+ >>> ci(-inf)
+ (0.0 + 3.141592653589793238462643j)
+ >>> ci(2+3j)
+ (1.408292501520849518759125 - 2.983617742029605093121118j)
+
+The cosine integral behaves roughly like the sinc function
+(see :func:`~mpmath.sinc`) for large real `x`::
+
+ >>> ci(10**10)
+ -4.875060251748226537857298e-11
+ >>> sinc(10**10)
+ -4.875060250875106915277943e-11
+ >>> chop(limit(ci, inf))
+ 0.0
+
+It has infinitely many roots on the positive real axis::
+
+ >>> findroot(ci, 1)
+ 0.6165054856207162337971104
+ >>> findroot(ci, 2)
+ 3.384180422551186426397851
+
+Evaluation is supported for `z` anywhere in the complex plane::
+
+ >>> ci(10**6*(1+j))
+ (4.449410587611035724984376e+434287 + 9.75744874290013526417059e+434287j)
+
+We can evaluate the defining integral as a reference::
+
+ >>> mp.dps = 15
+ >>> -quadosc(lambda t: cos(t)/t, [5, inf], omega=1)
+ -0.190029749656644
+ >>> ci(5)
+ -0.190029749656644
+
+Some infinite series can be evaluated using the
+cosine integral::
+
+ >>> nsum(lambda k: (-1)**k/(fac(2*k)*(2*k)), [1,inf])
+ -0.239811742000565
+ >>> ci(1) - euler
+ -0.239811742000565
+
+"""
+
+si = r"""
+Computes the sine integral,
+
+.. math ::
+
+ \mathrm{Si}(x) = \int_0^x \frac{\sin t}{t}\,dt.
+
+The sine integral is thus the antiderivative of the sinc
+function (see :func:`~mpmath.sinc`).
+
+**Examples**
+
+Some values and limits::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> si(0)
+ 0.0
+ >>> si(1)
+ 0.9460830703671830149413533
+ >>> si(-1)
+ -0.9460830703671830149413533
+ >>> si(pi)
+ 1.851937051982466170361053
+ >>> si(inf)
+ 1.570796326794896619231322
+ >>> si(-inf)
+ -1.570796326794896619231322
+ >>> si(2+3j)
+ (4.547513889562289219853204 + 1.399196580646054789459839j)
+
+The sine integral approaches `\pi/2` for large real `x`::
+
+ >>> si(10**10)
+ 1.570796326707584656968511
+ >>> pi/2
+ 1.570796326794896619231322
+
+Evaluation is supported for `z` anywhere in the complex plane::
+
+ >>> si(10**6*(1+j))
+ (-9.75744874290013526417059e+434287 + 4.449410587611035724984376e+434287j)
+
+We can evaluate the defining integral as a reference::
+
+ >>> mp.dps = 15
+ >>> quad(sinc, [0, 5])
+ 1.54993124494467
+ >>> si(5)
+ 1.54993124494467
+
+Some infinite series can be evaluated using the
+sine integral::
+
+ >>> nsum(lambda k: (-1)**k/(fac(2*k+1)*(2*k+1)), [0,inf])
+ 0.946083070367183
+ >>> si(1)
+ 0.946083070367183
+
+"""
+
+chi = r"""
+Computes the hyperbolic cosine integral, defined
+in analogy with the cosine integral (see :func:`~mpmath.ci`) as
+
+.. math ::
+
+ \mathrm{Chi}(x) = -\int_x^{\infty} \frac{\cosh t}{t}\,dt
+ = \gamma + \log x + \int_0^x \frac{\cosh t - 1}{t}\,dt
+
+Some values and limits::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> chi(0)
+ -inf
+ >>> chi(1)
+ 0.8378669409802082408946786
+ >>> chi(inf)
+ +inf
+ >>> findroot(chi, 0.5)
+ 0.5238225713898644064509583
+ >>> chi(2+3j)
+ (-0.1683628683277204662429321 + 2.625115880451325002151688j)
+
+Evaluation is supported for `z` anywhere in the complex plane::
+
+ >>> chi(10**6*(1+j))
+ (4.449410587611035724984376e+434287 - 9.75744874290013526417059e+434287j)
+
+"""
+
+shi = r"""
+Computes the hyperbolic sine integral, defined
+in analogy with the sine integral (see :func:`~mpmath.si`) as
+
+.. math ::
+
+ \mathrm{Shi}(x) = \int_0^x \frac{\sinh t}{t}\,dt.
+
+Some values and limits::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> shi(0)
+ 0.0
+ >>> shi(1)
+ 1.057250875375728514571842
+ >>> shi(-1)
+ -1.057250875375728514571842
+ >>> shi(inf)
+ +inf
+ >>> shi(2+3j)
+ (-0.1931890762719198291678095 + 2.645432555362369624818525j)
+
+Evaluation is supported for `z` anywhere in the complex plane::
+
+ >>> shi(10**6*(1+j))
+ (4.449410587611035724984376e+434287 - 9.75744874290013526417059e+434287j)
+
+"""
+
+fresnels = r"""
+Computes the Fresnel sine integral
+
+.. math ::
+
+ S(x) = \int_0^x \sin\left(\frac{\pi t^2}{2}\right) \,dt
+
+Note that some sources define this function
+without the normalization factor `\pi/2`.
+
+**Examples**
+
+Some basic values and limits::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> fresnels(0)
+ 0.0
+ >>> fresnels(inf)
+ 0.5
+ >>> fresnels(-inf)
+ -0.5
+ >>> fresnels(1)
+ 0.4382591473903547660767567
+ >>> fresnels(1+2j)
+ (36.72546488399143842838788 + 15.58775110440458732748279j)
+
+Comparing with the definition::
+
+ >>> fresnels(3)
+ 0.4963129989673750360976123
+ >>> quad(lambda t: sin(pi*t**2/2), [0,3])
+ 0.4963129989673750360976123
+"""
+
+fresnelc = r"""
+Computes the Fresnel cosine integral
+
+.. math ::
+
+ C(x) = \int_0^x \cos\left(\frac{\pi t^2}{2}\right) \,dt
+
+Note that some sources define this function
+without the normalization factor `\pi/2`.
+
+**Examples**
+
+Some basic values and limits::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> fresnelc(0)
+ 0.0
+ >>> fresnelc(inf)
+ 0.5
+ >>> fresnelc(-inf)
+ -0.5
+ >>> fresnelc(1)
+ 0.7798934003768228294742064
+ >>> fresnelc(1+2j)
+ (16.08787137412548041729489 - 36.22568799288165021578758j)
+
+Comparing with the definition::
+
+ >>> fresnelc(3)
+ 0.6057207892976856295561611
+ >>> quad(lambda t: cos(pi*t**2/2), [0,3])
+ 0.6057207892976856295561611
+"""
+
+airyai = r"""
+Computes the Airy function `\operatorname{Ai}(z)`, which is
+the solution of the Airy differential equation `f''(z) - z f(z) = 0`
+with initial conditions
+
+.. math ::
+
+ \operatorname{Ai}(0) =
+ \frac{1}{3^{2/3}\Gamma\left(\frac{2}{3}\right)}
+
+ \operatorname{Ai}'(0) =
+ -\frac{1}{3^{1/3}\Gamma\left(\frac{1}{3}\right)}.
+
+Other common ways of defining the Ai-function include
+integrals such as
+
+.. math ::
+
+ \operatorname{Ai}(x) = \frac{1}{\pi}
+ \int_0^{\infty} \cos\left(\frac{1}{3}t^3+xt\right) dt
+ \qquad x \in \mathbb{R}
+
+ \operatorname{Ai}(z) = \frac{\sqrt{3}}{2\pi}
+ \int_0^{\infty}
+ \exp\left(-\frac{t^3}{3}-\frac{z^3}{3t^3}\right) dt.
+
+The Ai-function is an entire function with a turning point,
+behaving roughly like a slowly decaying sine wave for `z < 0` and
+like a rapidly decreasing exponential for `z > 0`.
+A second solution of the Airy differential equation
+is given by `\operatorname{Bi}(z)` (see :func:`~mpmath.airybi`).
+
+Optionally, with *derivative=alpha*, :func:`airyai` can compute the
+`\alpha`-th order fractional derivative with respect to `z`.
+For `\alpha = n = 1,2,3,\ldots` this gives the derivative
+`\operatorname{Ai}^{(n)}(z)`, and for `\alpha = -n = -1,-2,-3,\ldots`
+this gives the `n`-fold iterated integral
+
+.. math ::
+
+ f_0(z) = \operatorname{Ai}(z)
+
+ f_n(z) = \int_0^z f_{n-1}(t) dt.
+
+The Ai-function has infinitely many zeros, all located along the
+negative half of the real axis. They can be computed with
+:func:`~mpmath.airyaizero`.
+
+**Plots**
+
+.. literalinclude :: /plots/ai.py
+.. image :: /plots/ai.png
+.. literalinclude :: /plots/ai_c.py
+.. image :: /plots/ai_c.png
+
+**Basic examples**
+
+Limits and values include::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> airyai(0); 1/(power(3,'2/3')*gamma('2/3'))
+ 0.3550280538878172392600632
+ 0.3550280538878172392600632
+ >>> airyai(1)
+ 0.1352924163128814155241474
+ >>> airyai(-1)
+ 0.5355608832923521187995166
+ >>> airyai(inf); airyai(-inf)
+ 0.0
+ 0.0
+
+Evaluation is supported for large magnitudes of the argument::
+
+ >>> airyai(-100)
+ 0.1767533932395528780908311
+ >>> airyai(100)
+ 2.634482152088184489550553e-291
+ >>> airyai(50+50j)
+ (-5.31790195707456404099817e-68 - 1.163588003770709748720107e-67j)
+ >>> airyai(-50+50j)
+ (1.041242537363167632587245e+158 + 3.347525544923600321838281e+157j)
+
+Huge arguments are also fine::
+
+ >>> airyai(10**10)
+ 1.162235978298741779953693e-289529654602171
+ >>> airyai(-10**10)
+ 0.0001736206448152818510510181
+ >>> w = airyai(10**10*(1+j))
+ >>> w.real
+ 5.711508683721355528322567e-186339621747698
+ >>> w.imag
+ 1.867245506962312577848166e-186339621747697
+
+The first root of the Ai-function is::
+
+ >>> findroot(airyai, -2)
+ -2.338107410459767038489197
+ >>> airyaizero(1)
+ -2.338107410459767038489197
+
+**Properties and relations**
+
+Verifying the Airy differential equation::
+
+ >>> for z in [-3.4, 0, 2.5, 1+2j]:
+ ... chop(airyai(z,2) - z*airyai(z))
+ ...
+ 0.0
+ 0.0
+ 0.0
+ 0.0
+
+The first few terms of the Taylor series expansion around `z = 0`
+(every third term is zero)::
+
+ >>> nprint(taylor(airyai, 0, 5))
+ [0.355028, -0.258819, 0.0, 0.0591713, -0.0215683, 0.0]
+
+The Airy functions satisfy the Wronskian relation
+`\operatorname{Ai}(z) \operatorname{Bi}'(z) -
+\operatorname{Ai}'(z) \operatorname{Bi}(z) = 1/\pi`::
+
+ >>> z = -0.5
+ >>> airyai(z)*airybi(z,1) - airyai(z,1)*airybi(z)
+ 0.3183098861837906715377675
+ >>> 1/pi
+ 0.3183098861837906715377675
+
+The Airy functions can be expressed in terms of Bessel
+functions of order `\pm 1/3`. For `\Re[z] \le 0`, we have::
+
+ >>> z = -3
+ >>> airyai(z)
+ -0.3788142936776580743472439
+ >>> y = 2*power(-z,'3/2')/3
+ >>> (sqrt(-z) * (besselj('1/3',y) + besselj('-1/3',y)))/3
+ -0.3788142936776580743472439
+
+**Derivatives and integrals**
+
+Derivatives of the Ai-function (directly and using :func:`~mpmath.diff`)::
+
+ >>> airyai(-3,1); diff(airyai,-3)
+ 0.3145837692165988136507873
+ 0.3145837692165988136507873
+ >>> airyai(-3,2); diff(airyai,-3,2)
+ 1.136442881032974223041732
+ 1.136442881032974223041732
+ >>> airyai(1000,1); diff(airyai,1000)
+ -2.943133917910336090459748e-9156
+ -2.943133917910336090459748e-9156
+
+Several derivatives at `z = 0`::
+
+ >>> airyai(0,0); airyai(0,1); airyai(0,2)
+ 0.3550280538878172392600632
+ -0.2588194037928067984051836
+ 0.0
+ >>> airyai(0,3); airyai(0,4); airyai(0,5)
+ 0.3550280538878172392600632
+ -0.5176388075856135968103671
+ 0.0
+ >>> airyai(0,15); airyai(0,16); airyai(0,17)
+ 1292.30211615165475090663
+ -3188.655054727379756351861
+ 0.0
+
+The integral of the Ai-function::
+
+ >>> airyai(3,-1); quad(airyai, [0,3])
+ 0.3299203760070217725002701
+ 0.3299203760070217725002701
+ >>> airyai(-10,-1); quad(airyai, [0,-10])
+ -0.765698403134212917425148
+ -0.765698403134212917425148
+
+Integrals of high or fractional order::
+
+ >>> airyai(-2,0.5); differint(airyai,-2,0.5,0)
+ (0.0 + 0.2453596101351438273844725j)
+ (0.0 + 0.2453596101351438273844725j)
+ >>> airyai(-2,-4); differint(airyai,-2,-4,0)
+ 0.2939176441636809580339365
+ 0.2939176441636809580339365
+ >>> airyai(0,-1); airyai(0,-2); airyai(0,-3)
+ 0.0
+ 0.0
+ 0.0
+
+Integrals of the Ai-function can be evaluated at limit points::
+
+ >>> airyai(-1000000,-1); airyai(-inf,-1)
+ -0.6666843728311539978751512
+ -0.6666666666666666666666667
+ >>> airyai(10,-1); airyai(+inf,-1)
+ 0.3333333332991690159427932
+ 0.3333333333333333333333333
+ >>> airyai(+inf,-2); airyai(+inf,-3)
+ +inf
+ +inf
+ >>> airyai(-1000000,-2); airyai(-inf,-2)
+ 666666.4078472650651209742
+ +inf
+ >>> airyai(-1000000,-3); airyai(-inf,-3)
+ -333333074513.7520264995733
+ -inf
+
+**References**
+
+1. [DLMF]_ Chapter 9: Airy and Related Functions
+2. [WolframFunctions]_ section: Bessel-Type Functions
+
+"""
+
+airybi = r"""
+Computes the Airy function `\operatorname{Bi}(z)`, which is
+the solution of the Airy differential equation `f''(z) - z f(z) = 0`
+with initial conditions
+
+.. math ::
+
+ \operatorname{Bi}(0) =
+ \frac{1}{3^{1/6}\Gamma\left(\frac{2}{3}\right)}
+
+ \operatorname{Bi}'(0) =
+ \frac{3^{1/6}}{\Gamma\left(\frac{1}{3}\right)}.
+
+Like the Ai-function (see :func:`~mpmath.airyai`), the Bi-function
+is oscillatory for `z < 0`, but it grows rather than decreases
+for `z > 0`.
+
+Optionally, as for :func:`~mpmath.airyai`, derivatives, integrals
+and fractional derivatives can be computed with the *derivative*
+parameter.
+
+The Bi-function has infinitely many zeros along the negative
+half-axis, as well as complex zeros, which can all be computed
+with :func:`~mpmath.airybizero`.
+
+**Plots**
+
+.. literalinclude :: /plots/bi.py
+.. image :: /plots/bi.png
+.. literalinclude :: /plots/bi_c.py
+.. image :: /plots/bi_c.png
+
+**Basic examples**
+
+Limits and values include::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> airybi(0); 1/(power(3,'1/6')*gamma('2/3'))
+ 0.6149266274460007351509224
+ 0.6149266274460007351509224
+ >>> airybi(1)
+ 1.207423594952871259436379
+ >>> airybi(-1)
+ 0.10399738949694461188869
+ >>> airybi(inf); airybi(-inf)
+ +inf
+ 0.0
+
+Evaluation is supported for large magnitudes of the argument::
+
+ >>> airybi(-100)
+ 0.02427388768016013160566747
+ >>> airybi(100)
+ 6.041223996670201399005265e+288
+ >>> airybi(50+50j)
+ (-5.322076267321435669290334e+63 + 1.478450291165243789749427e+65j)
+ >>> airybi(-50+50j)
+ (-3.347525544923600321838281e+157 + 1.041242537363167632587245e+158j)
+
+Huge arguments::
+
+ >>> airybi(10**10)
+ 1.369385787943539818688433e+289529654602165
+ >>> airybi(-10**10)
+ 0.001775656141692932747610973
+ >>> w = airybi(10**10*(1+j))
+ >>> w.real
+ -6.559955931096196875845858e+186339621747689
+ >>> w.imag
+ -6.822462726981357180929024e+186339621747690
+
+The first real root of the Bi-function is::
+
+ >>> findroot(airybi, -1); airybizero(1)
+ -1.17371322270912792491998
+ -1.17371322270912792491998
+
+**Properties and relations**
+
+Verifying the Airy differential equation::
+
+ >>> for z in [-3.4, 0, 2.5, 1+2j]:
+ ... chop(airybi(z,2) - z*airybi(z))
+ ...
+ 0.0
+ 0.0
+ 0.0
+ 0.0
+
+The first few terms of the Taylor series expansion around `z = 0`
+(every third term is zero)::
+
+ >>> nprint(taylor(airybi, 0, 5))
+ [0.614927, 0.448288, 0.0, 0.102488, 0.0373574, 0.0]
+
+The Airy functions can be expressed in terms of Bessel
+functions of order `\pm 1/3`. For `\Re[z] \le 0`, we have::
+
+ >>> z = -3
+ >>> airybi(z)
+ -0.1982896263749265432206449
+ >>> p = 2*power(-z,'3/2')/3
+ >>> sqrt(-mpf(z)/3)*(besselj('-1/3',p) - besselj('1/3',p))
+ -0.1982896263749265432206449
+
+**Derivatives and integrals**
+
+Derivatives of the Bi-function (directly and using :func:`~mpmath.diff`)::
+
+ >>> airybi(-3,1); diff(airybi,-3)
+ -0.675611222685258537668032
+ -0.675611222685258537668032
+ >>> airybi(-3,2); diff(airybi,-3,2)
+ 0.5948688791247796296619346
+ 0.5948688791247796296619346
+ >>> airybi(1000,1); diff(airybi,1000)
+ 1.710055114624614989262335e+9156
+ 1.710055114624614989262335e+9156
+
+Several derivatives at `z = 0`::
+
+ >>> airybi(0,0); airybi(0,1); airybi(0,2)
+ 0.6149266274460007351509224
+ 0.4482883573538263579148237
+ 0.0
+ >>> airybi(0,3); airybi(0,4); airybi(0,5)
+ 0.6149266274460007351509224
+ 0.8965767147076527158296474
+ 0.0
+ >>> airybi(0,15); airybi(0,16); airybi(0,17)
+ 2238.332923903442675949357
+ 5522.912562599140729510628
+ 0.0
+
+The integral of the Bi-function::
+
+ >>> airybi(3,-1); quad(airybi, [0,3])
+ 10.06200303130620056316655
+ 10.06200303130620056316655
+ >>> airybi(-10,-1); quad(airybi, [0,-10])
+ -0.01504042480614002045135483
+ -0.01504042480614002045135483
+
+Integrals of high or fractional order::
+
+ >>> airybi(-2,0.5); differint(airybi, -2, 0.5, 0)
+ (0.0 + 0.5019859055341699223453257j)
+ (0.0 + 0.5019859055341699223453257j)
+ >>> airybi(-2,-4); differint(airybi,-2,-4,0)
+ 0.2809314599922447252139092
+ 0.2809314599922447252139092
+ >>> airybi(0,-1); airybi(0,-2); airybi(0,-3)
+ 0.0
+ 0.0
+ 0.0
+
+Integrals of the Bi-function can be evaluated at limit points::
+
+ >>> airybi(-1000000,-1); airybi(-inf,-1)
+ 0.000002191261128063434047966873
+ 0.0
+ >>> airybi(10,-1); airybi(+inf,-1)
+ 147809803.1074067161675853
+ +inf
+ >>> airybi(+inf,-2); airybi(+inf,-3)
+ +inf
+ +inf
+ >>> airybi(-1000000,-2); airybi(-inf,-2)
+ 0.4482883750599908479851085
+ 0.4482883573538263579148237
+ >>> gamma('2/3')*power(3,'2/3')/(2*pi)
+ 0.4482883573538263579148237
+ >>> airybi(-100000,-3); airybi(-inf,-3)
+ -44828.52827206932872493133
+ -inf
+ >>> airybi(-100000,-4); airybi(-inf,-4)
+ 2241411040.437759489540248
+ +inf
+
+"""
+
+airyaizero = r"""
+Gives the `k`-th zero of the Airy Ai-function,
+i.e. the `k`-th number `a_k` ordered by magnitude for which
+`\operatorname{Ai}(a_k) = 0`.
+
+Optionally, with *derivative=1*, the corresponding
+zero `a'_k` of the derivative function, i.e.
+`\operatorname{Ai}'(a'_k) = 0`, is computed.
+
+**Examples**
+
+Some values of `a_k`::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> airyaizero(1)
+ -2.338107410459767038489197
+ >>> airyaizero(2)
+ -4.087949444130970616636989
+ >>> airyaizero(3)
+ -5.520559828095551059129856
+ >>> airyaizero(1000)
+ -281.0315196125215528353364
+
+Some values of `a'_k`::
+
+ >>> airyaizero(1,1)
+ -1.018792971647471089017325
+ >>> airyaizero(2,1)
+ -3.248197582179836537875424
+ >>> airyaizero(3,1)
+ -4.820099211178735639400616
+ >>> airyaizero(1000,1)
+ -280.9378080358935070607097
+
+Verification::
+
+ >>> chop(airyai(airyaizero(1)))
+ 0.0
+ >>> chop(airyai(airyaizero(1,1),1))
+ 0.0
+
+"""
+
+airybizero = r"""
+With *complex=False*, gives the `k`-th real zero of the Airy Bi-function,
+i.e. the `k`-th number `b_k` ordered by magnitude for which
+`\operatorname{Bi}(b_k) = 0`.
+
+With *complex=True*, gives the `k`-th complex zero in the upper
+half plane `\beta_k`. Also the conjugate `\overline{\beta_k}`
+is a zero.
+
+Optionally, with *derivative=1*, the corresponding
+zero `b'_k` or `\beta'_k` of the derivative function, i.e.
+`\operatorname{Bi}'(b'_k) = 0` or `\operatorname{Bi}'(\beta'_k) = 0`,
+is computed.
+
+**Examples**
+
+Some values of `b_k`::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> airybizero(1)
+ -1.17371322270912792491998
+ >>> airybizero(2)
+ -3.271093302836352715680228
+ >>> airybizero(3)
+ -4.830737841662015932667709
+ >>> airybizero(1000)
+ -280.9378112034152401578834
+
+Some values of `b_k`::
+
+ >>> airybizero(1,1)
+ -2.294439682614123246622459
+ >>> airybizero(2,1)
+ -4.073155089071828215552369
+ >>> airybizero(3,1)
+ -5.512395729663599496259593
+ >>> airybizero(1000,1)
+ -281.0315164471118527161362
+
+Some values of `\beta_k`::
+
+ >>> airybizero(1,complex=True)
+ (0.9775448867316206859469927 + 2.141290706038744575749139j)
+ >>> airybizero(2,complex=True)
+ (1.896775013895336346627217 + 3.627291764358919410440499j)
+ >>> airybizero(3,complex=True)
+ (2.633157739354946595708019 + 4.855468179979844983174628j)
+ >>> airybizero(1000,complex=True)
+ (140.4978560578493018899793 + 243.3907724215792121244867j)
+
+Some values of `\beta'_k`::
+
+ >>> airybizero(1,1,complex=True)
+ (0.2149470745374305676088329 + 1.100600143302797880647194j)
+ >>> airybizero(2,1,complex=True)
+ (1.458168309223507392028211 + 2.912249367458445419235083j)
+ >>> airybizero(3,1,complex=True)
+ (2.273760763013482299792362 + 4.254528549217097862167015j)
+ >>> airybizero(1000,1,complex=True)
+ (140.4509972835270559730423 + 243.3096175398562811896208j)
+
+Verification::
+
+ >>> chop(airybi(airybizero(1)))
+ 0.0
+ >>> chop(airybi(airybizero(1,1),1))
+ 0.0
+ >>> u = airybizero(1,complex=True)
+ >>> chop(airybi(u))
+ 0.0
+ >>> chop(airybi(conj(u)))
+ 0.0
+
+The complex zeros (in the upper and lower half-planes respectively)
+asymptotically approach the rays `z = R \exp(\pm i \pi /3)`::
+
+ >>> arg(airybizero(1,complex=True))
+ 1.142532510286334022305364
+ >>> arg(airybizero(1000,complex=True))
+ 1.047271114786212061583917
+ >>> arg(airybizero(1000000,complex=True))
+ 1.047197624741816183341355
+ >>> pi/3
+ 1.047197551196597746154214
+
+"""
+
+
+ellipk = r"""
+Evaluates the complete elliptic integral of the first kind,
+`K(m)`, defined by
+
+.. math ::
+
+ K(m) = \int_0^{\pi/2} \frac{dt}{\sqrt{1-m \sin^2 t}} \, = \,
+ \frac{\pi}{2} \,_2F_1\left(\frac{1}{2}, \frac{1}{2}, 1, m\right).
+
+Note that the argument is the parameter `m = k^2`,
+not the modulus `k` which is sometimes used.
+
+**Plots**
+
+.. literalinclude :: /plots/ellipk.py
+.. image :: /plots/ellipk.png
+
+**Examples**
+
+Values and limits include::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> ellipk(0)
+ 1.570796326794896619231322
+ >>> ellipk(inf)
+ (0.0 + 0.0j)
+ >>> ellipk(-inf)
+ 0.0
+ >>> ellipk(1)
+ +inf
+ >>> ellipk(-1)
+ 1.31102877714605990523242
+ >>> ellipk(2)
+ (1.31102877714605990523242 - 1.31102877714605990523242j)
+
+Verifying the defining integral and hypergeometric
+representation::
+
+ >>> ellipk(0.5)
+ 1.85407467730137191843385
+ >>> quad(lambda t: (1-0.5*sin(t)**2)**-0.5, [0, pi/2])
+ 1.85407467730137191843385
+ >>> pi/2*hyp2f1(0.5,0.5,1,0.5)
+ 1.85407467730137191843385
+
+Evaluation is supported for arbitrary complex `m`::
+
+ >>> ellipk(3+4j)
+ (0.9111955638049650086562171 + 0.6313342832413452438845091j)
+
+A definite integral::
+
+ >>> quad(ellipk, [0, 1])
+ 2.0
+"""
+
+agm = r"""
+``agm(a, b)`` computes the arithmetic-geometric mean of `a` and
+`b`, defined as the limit of the following iteration:
+
+.. math ::
+
+ a_0 = a
+
+ b_0 = b
+
+ a_{n+1} = \frac{a_n+b_n}{2}
+
+ b_{n+1} = \sqrt{a_n b_n}
+
+This function can be called with a single argument, computing
+`\mathrm{agm}(a,1) = \mathrm{agm}(1,a)`.
+
+**Examples**
+
+It is a well-known theorem that the geometric mean of
+two distinct positive numbers is less than the arithmetic
+mean. It follows that the arithmetic-geometric mean lies
+between the two means::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> a = mpf(3)
+ >>> b = mpf(4)
+ >>> sqrt(a*b)
+ 3.46410161513775
+ >>> agm(a,b)
+ 3.48202767635957
+ >>> (a+b)/2
+ 3.5
+
+The arithmetic-geometric mean is scale-invariant::
+
+ >>> agm(10*e, 10*pi)
+ 29.261085515723
+ >>> 10*agm(e, pi)
+ 29.261085515723
+
+As an order-of-magnitude estimate, `\mathrm{agm}(1,x) \approx x`
+for large `x`::
+
+ >>> agm(10**10)
+ 643448704.760133
+ >>> agm(10**50)
+ 1.34814309345871e+48
+
+For tiny `x`, `\mathrm{agm}(1,x) \approx -\pi/(2 \log(x/4))`::
+
+ >>> agm('0.01')
+ 0.262166887202249
+ >>> -pi/2/log('0.0025')
+ 0.262172347753122
+
+The arithmetic-geometric mean can also be computed for complex
+numbers::
+
+ >>> agm(3, 2+j)
+ (2.51055133276184 + 0.547394054060638j)
+
+The AGM iteration converges very quickly (each step doubles
+the number of correct digits), so :func:`~mpmath.agm` supports efficient
+high-precision evaluation::
+
+ >>> mp.dps = 10000
+ >>> a = agm(1,2)
+ >>> str(a)[-10:]
+ '1679581912'
+
+**Mathematical relations**
+
+The arithmetic-geometric mean may be used to evaluate the
+following two parametric definite integrals:
+
+.. math ::
+
+ I_1 = \int_0^{\infty}
+ \frac{1}{\sqrt{(x^2+a^2)(x^2+b^2)}} \,dx
+
+ I_2 = \int_0^{\pi/2}
+ \frac{1}{\sqrt{a^2 \cos^2(x) + b^2 \sin^2(x)}} \,dx
+
+We have::
+
+ >>> mp.dps = 15
+ >>> a = 3
+ >>> b = 4
+ >>> f1 = lambda x: ((x**2+a**2)*(x**2+b**2))**-0.5
+ >>> f2 = lambda x: ((a*cos(x))**2 + (b*sin(x))**2)**-0.5
+ >>> quad(f1, [0, inf])
+ 0.451115405388492
+ >>> quad(f2, [0, pi/2])
+ 0.451115405388492
+ >>> pi/(2*agm(a,b))
+ 0.451115405388492
+
+A formula for `\Gamma(1/4)`::
+
+ >>> gamma(0.25)
+ 3.62560990822191
+ >>> sqrt(2*sqrt(2*pi**3)/agm(1,sqrt(2)))
+ 3.62560990822191
+
+**Possible issues**
+
+The branch cut chosen for complex `a` and `b` is somewhat
+arbitrary.
+
+"""
+
+gegenbauer = r"""
+Evaluates the Gegenbauer polynomial, or ultraspherical polynomial,
+
+.. math ::
+
+ C_n^{(a)}(z) = {n+2a-1 \choose n} \,_2F_1\left(-n, n+2a;
+ a+\frac{1}{2}; \frac{1}{2}(1-z)\right).
+
+When `n` is a nonnegative integer, this formula gives a polynomial
+in `z` of degree `n`, but all parameters are permitted to be
+complex numbers. With `a = 1/2`, the Gegenbauer polynomial
+reduces to a Legendre polynomial.
+
+**Examples**
+
+Evaluation for arbitrary arguments::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> gegenbauer(3, 0.5, -10)
+ -2485.0
+ >>> gegenbauer(1000, 10, 100)
+ 3.012757178975667428359374e+2322
+ >>> gegenbauer(2+3j, -0.75, -1000j)
+ (-5038991.358609026523401901 + 9414549.285447104177860806j)
+
+Evaluation at negative integer orders::
+
+ >>> gegenbauer(-4, 2, 1.75)
+ -1.0
+ >>> gegenbauer(-4, 3, 1.75)
+ 0.0
+ >>> gegenbauer(-4, 2j, 1.75)
+ 0.0
+ >>> gegenbauer(-7, 0.5, 3)
+ 8989.0
+
+The Gegenbauer polynomials solve the differential equation::
+
+ >>> n, a = 4.5, 1+2j
+ >>> f = lambda z: gegenbauer(n, a, z)
+ >>> for z in [0, 0.75, -0.5j]:
+ ... chop((1-z**2)*diff(f,z,2) - (2*a+1)*z*diff(f,z) + n*(n+2*a)*f(z))
+ ...
+ 0.0
+ 0.0
+ 0.0
+
+The Gegenbauer polynomials have generating function
+`(1-2zt+t^2)^{-a}`::
+
+ >>> a, z = 2.5, 1
+ >>> taylor(lambda t: (1-2*z*t+t**2)**(-a), 0, 3)
+ [1.0, 5.0, 15.0, 35.0]
+ >>> [gegenbauer(n,a,z) for n in range(4)]
+ [1.0, 5.0, 15.0, 35.0]
+
+The Gegenbauer polynomials are orthogonal on `[-1, 1]` with respect
+to the weight `(1-z^2)^{a-\frac{1}{2}}`::
+
+ >>> a, n, m = 2.5, 4, 5
+ >>> Cn = lambda z: gegenbauer(n, a, z, zeroprec=1000)
+ >>> Cm = lambda z: gegenbauer(m, a, z, zeroprec=1000)
+ >>> chop(quad(lambda z: Cn(z)*Cm(z)*(1-z**2)*(a-0.5), [-1, 1]))
+ 0.0
+"""
+
+laguerre = r"""
+Gives the generalized (associated) Laguerre polynomial, defined by
+
+.. math ::
+
+ L_n^a(z) = \frac{\Gamma(n+b+1)}{\Gamma(b+1) \Gamma(n+1)}
+ \,_1F_1(-n, a+1, z).
+
+With `a = 0` and `n` a nonnegative integer, this reduces to an ordinary
+Laguerre polynomial, the sequence of which begins
+`L_0(z) = 1, L_1(z) = 1-z, L_2(z) = z^2-2z+1, \ldots`.
+
+The Laguerre polynomials are orthogonal with respect to the weight
+`z^a e^{-z}` on `[0, \infty)`.
+
+**Plots**
+
+.. literalinclude :: /plots/laguerre.py
+.. image :: /plots/laguerre.png
+
+**Examples**
+
+Evaluation for arbitrary arguments::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> laguerre(5, 0, 0.25)
+ 0.03726399739583333333333333
+ >>> laguerre(1+j, 0.5, 2+3j)
+ (4.474921610704496808379097 - 11.02058050372068958069241j)
+ >>> laguerre(2, 0, 10000)
+ 49980001.0
+ >>> laguerre(2.5, 0, 10000)
+ -9.327764910194842158583189e+4328
+
+The first few Laguerre polynomials, normalized to have integer
+coefficients::
+
+ >>> for n in range(7):
+ ... chop(taylor(lambda z: fac(n)*laguerre(n, 0, z), 0, n))
+ ...
+ [1.0]
+ [1.0, -1.0]
+ [2.0, -4.0, 1.0]
+ [6.0, -18.0, 9.0, -1.0]
+ [24.0, -96.0, 72.0, -16.0, 1.0]
+ [120.0, -600.0, 600.0, -200.0, 25.0, -1.0]
+ [720.0, -4320.0, 5400.0, -2400.0, 450.0, -36.0, 1.0]
+
+Verifying orthogonality::
+
+ >>> Lm = lambda t: laguerre(m,a,t)
+ >>> Ln = lambda t: laguerre(n,a,t)
+ >>> a, n, m = 2.5, 2, 3
+ >>> chop(quad(lambda t: exp(-t)*t**a*Lm(t)*Ln(t), [0,inf]))
+ 0.0
+
+
+"""
+
+hermite = r"""
+Evaluates the Hermite polynomial `H_n(z)`, which may be defined using
+the recurrence
+
+.. math ::
+
+ H_0(z) = 1
+
+ H_1(z) = 2z
+
+ H_{n+1} = 2z H_n(z) - 2n H_{n-1}(z).
+
+The Hermite polynomials are orthogonal on `(-\infty, \infty)` with
+respect to the weight `e^{-z^2}`. More generally, allowing arbitrary complex
+values of `n`, the Hermite function `H_n(z)` is defined as
+
+.. math ::
+
+ H_n(z) = (2z)^n \,_2F_0\left(-\frac{n}{2}, \frac{1-n}{2},
+ -\frac{1}{z^2}\right)
+
+for `\Re{z} > 0`, or generally
+
+.. math ::
+
+ H_n(z) = 2^n \sqrt{\pi} \left(
+ \frac{1}{\Gamma\left(\frac{1-n}{2}\right)}
+ \,_1F_1\left(-\frac{n}{2}, \frac{1}{2}, z^2\right) -
+ \frac{2z}{\Gamma\left(-\frac{n}{2}\right)}
+ \,_1F_1\left(\frac{1-n}{2}, \frac{3}{2}, z^2\right)
+ \right).
+
+**Plots**
+
+.. literalinclude :: /plots/hermite.py
+.. image :: /plots/hermite.png
+
+**Examples**
+
+Evaluation for arbitrary arguments::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> hermite(0, 10)
+ 1.0
+ >>> hermite(1, 10); hermite(2, 10)
+ 20.0
+ 398.0
+ >>> hermite(10000, 2)
+ 4.950440066552087387515653e+19334
+ >>> hermite(3, -10**8)
+ -7999999999999998800000000.0
+ >>> hermite(-3, -10**8)
+ 1.675159751729877682920301e+4342944819032534
+ >>> hermite(2+3j, -1+2j)
+ (-0.07652130602993513389421901 - 0.1084662449961914580276007j)
+
+Coefficients of the first few Hermite polynomials are::
+
+ >>> for n in range(7):
+ ... chop(taylor(lambda z: hermite(n, z), 0, n))
+ ...
+ [1.0]
+ [0.0, 2.0]
+ [-2.0, 0.0, 4.0]
+ [0.0, -12.0, 0.0, 8.0]
+ [12.0, 0.0, -48.0, 0.0, 16.0]
+ [0.0, 120.0, 0.0, -160.0, 0.0, 32.0]
+ [-120.0, 0.0, 720.0, 0.0, -480.0, 0.0, 64.0]
+
+Values at `z = 0`::
+
+ >>> for n in range(-5, 9):
+ ... hermite(n, 0)
+ ...
+ 0.02769459142039868792653387
+ 0.08333333333333333333333333
+ 0.2215567313631895034122709
+ 0.5
+ 0.8862269254527580136490837
+ 1.0
+ 0.0
+ -2.0
+ 0.0
+ 12.0
+ 0.0
+ -120.0
+ 0.0
+ 1680.0
+
+Hermite functions satisfy the differential equation::
+
+ >>> n = 4
+ >>> f = lambda z: hermite(n, z)
+ >>> z = 1.5
+ >>> chop(diff(f,z,2) - 2*z*diff(f,z) + 2*n*f(z))
+ 0.0
+
+Verifying orthogonality::
+
+ >>> chop(quad(lambda t: hermite(2,t)*hermite(4,t)*exp(-t**2), [-inf,inf]))
+ 0.0
+
+"""
+
+jacobi = r"""
+``jacobi(n, a, b, x)`` evaluates the Jacobi polynomial
+`P_n^{(a,b)}(x)`. The Jacobi polynomials are a special
+case of the hypergeometric function `\,_2F_1` given by:
+
+.. math ::
+
+ P_n^{(a,b)}(x) = {n+a \choose n}
+ \,_2F_1\left(-n,1+a+b+n,a+1,\frac{1-x}{2}\right).
+
+Note that this definition generalizes to nonintegral values
+of `n`. When `n` is an integer, the hypergeometric series
+terminates after a finite number of terms, giving
+a polynomial in `x`.
+
+**Evaluation of Jacobi polynomials**
+
+A special evaluation is `P_n^{(a,b)}(1) = {n+a \choose n}`::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> jacobi(4, 0.5, 0.25, 1)
+ 2.4609375
+ >>> binomial(4+0.5, 4)
+ 2.4609375
+
+A Jacobi polynomial of degree `n` is equal to its
+Taylor polynomial of degree `n`. The explicit
+coefficients of Jacobi polynomials can therefore
+be recovered easily using :func:`~mpmath.taylor`::
+
+ >>> for n in range(5):
+ ... nprint(taylor(lambda x: jacobi(n,1,2,x), 0, n))
+ ...
+ [1.0]
+ [-0.5, 2.5]
+ [-0.75, -1.5, 5.25]
+ [0.5, -3.5, -3.5, 10.5]
+ [0.625, 2.5, -11.25, -7.5, 20.625]
+
+For nonintegral `n`, the Jacobi "polynomial" is no longer
+a polynomial::
+
+ >>> nprint(taylor(lambda x: jacobi(0.5,1,2,x), 0, 4))
+ [0.309983, 1.84119, -1.26933, 1.26699, -1.34808]
+
+**Orthogonality**
+
+The Jacobi polynomials are orthogonal on the interval
+`[-1, 1]` with respect to the weight function
+`w(x) = (1-x)^a (1+x)^b`. That is,
+`w(x) P_n^{(a,b)}(x) P_m^{(a,b)}(x)` integrates to
+zero if `m \ne n` and to a nonzero number if `m = n`.
+
+The orthogonality is easy to verify using numerical
+quadrature::
+
+ >>> P = jacobi
+ >>> f = lambda x: (1-x)**a * (1+x)**b * P(m,a,b,x) * P(n,a,b,x)
+ >>> a = 2
+ >>> b = 3
+ >>> m, n = 3, 4
+ >>> chop(quad(f, [-1, 1]), 1)
+ 0.0
+ >>> m, n = 4, 4
+ >>> quad(f, [-1, 1])
+ 1.9047619047619
+
+**Differential equation**
+
+The Jacobi polynomials are solutions of the differential
+equation
+
+.. math ::
+
+ (1-x^2) y'' + (b-a-(a+b+2)x) y' + n (n+a+b+1) y = 0.
+
+We can verify that :func:`~mpmath.jacobi` approximately satisfies
+this equation::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15
+ >>> a = 2.5
+ >>> b = 4
+ >>> n = 3
+ >>> y = lambda x: jacobi(n,a,b,x)
+ >>> x = pi
+ >>> A0 = n*(n+a+b+1)*y(x)
+ >>> A1 = (b-a-(a+b+2)*x)*diff(y,x)
+ >>> A2 = (1-x**2)*diff(y,x,2)
+ >>> nprint(A2 + A1 + A0, 1)
+ 4.0e-12
+
+The difference of order `10^{-12}` is as close to zero as
+it could be at 15-digit working precision, since the terms
+are large::
+
+ >>> A0, A1, A2
+ (26560.2328981879, -21503.7641037294, -5056.46879445852)
+
+"""
+
+legendre = r"""
+``legendre(n, x)`` evaluates the Legendre polynomial `P_n(x)`.
+The Legendre polynomials are given by the formula
+
+.. math ::
+
+ P_n(x) = \frac{1}{2^n n!} \frac{d^n}{dx^n} (x^2 -1)^n.
+
+Alternatively, they can be computed recursively using
+
+.. math ::
+
+ P_0(x) = 1
+
+ P_1(x) = x
+
+ (n+1) P_{n+1}(x) = (2n+1) x P_n(x) - n P_{n-1}(x).
+
+A third definition is in terms of the hypergeometric function
+`\,_2F_1`, whereby they can be generalized to arbitrary `n`:
+
+.. math ::
+
+ P_n(x) = \,_2F_1\left(-n, n+1, 1, \frac{1-x}{2}\right)
+
+**Plots**
+
+.. literalinclude :: /plots/legendre.py
+.. image :: /plots/legendre.png
+
+**Basic evaluation**
+
+The Legendre polynomials assume fixed values at the points
+`x = -1` and `x = 1`::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> nprint([legendre(n, 1) for n in range(6)])
+ [1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
+ >>> nprint([legendre(n, -1) for n in range(6)])
+ [1.0, -1.0, 1.0, -1.0, 1.0, -1.0]
+
+The coefficients of Legendre polynomials can be recovered
+using degree-`n` Taylor expansion::
+
+ >>> for n in range(5):
+ ... nprint(chop(taylor(lambda x: legendre(n, x), 0, n)))
+ ...
+ [1.0]
+ [0.0, 1.0]
+ [-0.5, 0.0, 1.5]
+ [0.0, -1.5, 0.0, 2.5]
+ [0.375, 0.0, -3.75, 0.0, 4.375]
+
+The roots of Legendre polynomials are located symmetrically
+on the interval `[-1, 1]`::
+
+ >>> for n in range(5):
+ ... nprint(polyroots(taylor(lambda x: legendre(n, x), 0, n)[::-1]))
+ ...
+ []
+ [0.0]
+ [-0.57735, 0.57735]
+ [-0.774597, 0.0, 0.774597]
+ [-0.861136, -0.339981, 0.339981, 0.861136]
+
+An example of an evaluation for arbitrary `n`::
+
+ >>> legendre(0.75, 2+4j)
+ (1.94952805264875 + 2.1071073099422j)
+
+**Orthogonality**
+
+The Legendre polynomials are orthogonal on `[-1, 1]` with respect
+to the trivial weight `w(x) = 1`. That is, `P_m(x) P_n(x)`
+integrates to zero if `m \ne n` and to `2/(2n+1)` if `m = n`::
+
+ >>> m, n = 3, 4
+ >>> quad(lambda x: legendre(m,x)*legendre(n,x), [-1, 1])
+ 0.0
+ >>> m, n = 4, 4
+ >>> quad(lambda x: legendre(m,x)*legendre(n,x), [-1, 1])
+ 0.222222222222222
+
+**Differential equation**
+
+The Legendre polynomials satisfy the differential equation
+
+.. math ::
+
+ ((1-x^2) y')' + n(n+1) y' = 0.
+
+We can verify this numerically::
+
+ >>> n = 3.6
+ >>> x = 0.73
+ >>> P = legendre
+ >>> A = diff(lambda t: (1-t**2)*diff(lambda u: P(n,u), t), x)
+ >>> B = n*(n+1)*P(n,x)
+ >>> nprint(A+B,1)
+ 9.0e-16
+
+"""
+
+
+legenp = r"""
+Calculates the (associated) Legendre function of the first kind of
+degree *n* and order *m*, `P_n^m(z)`. Taking `m = 0` gives the ordinary
+Legendre function of the first kind, `P_n(z)`. The parameters may be
+complex numbers.
+
+In terms of the Gauss hypergeometric function, the (associated) Legendre
+function is defined as
+
+.. math ::
+
+ P_n^m(z) = \frac{1}{\Gamma(1-m)} \frac{(1+z)^{m/2}}{(1-z)^{m/2}}
+ \,_2F_1\left(-n, n+1, 1-m, \frac{1-z}{2}\right).
+
+With *type=3* instead of *type=2*, the alternative
+definition
+
+.. math ::
+
+ \hat{P}_n^m(z) = \frac{1}{\Gamma(1-m)} \frac{(z+1)^{m/2}}{(z-1)^{m/2}}
+ \,_2F_1\left(-n, n+1, 1-m, \frac{1-z}{2}\right).
+
+is used. These functions correspond respectively to ``LegendreP[n,m,2,z]``
+and ``LegendreP[n,m,3,z]`` in Mathematica.
+
+The general solution of the (associated) Legendre differential equation
+
+.. math ::
+
+ (1-z^2) f''(z) - 2zf'(z) + \left(n(n+1)-\frac{m^2}{1-z^2}\right)f(z) = 0
+
+is given by `C_1 P_n^m(z) + C_2 Q_n^m(z)` for arbitrary constants
+`C_1`, `C_2`, where `Q_n^m(z)` is a Legendre function of the
+second kind as implemented by :func:`~mpmath.legenq`.
+
+**Examples**
+
+Evaluation for arbitrary parameters and arguments::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> legenp(2, 0, 10); legendre(2, 10)
+ 149.5
+ 149.5
+ >>> legenp(-2, 0.5, 2.5)
+ (1.972260393822275434196053 - 1.972260393822275434196053j)
+ >>> legenp(2+3j, 1-j, -0.5+4j)
+ (-3.335677248386698208736542 - 5.663270217461022307645625j)
+ >>> chop(legenp(3, 2, -1.5, type=2))
+ 28.125
+ >>> chop(legenp(3, 2, -1.5, type=3))
+ -28.125
+
+Verifying the associated Legendre differential equation::
+
+ >>> n, m = 2, -0.5
+ >>> C1, C2 = 1, -3
+ >>> f = lambda z: C1*legenp(n,m,z) + C2*legenq(n,m,z)
+ >>> deq = lambda z: (1-z**2)*diff(f,z,2) - 2*z*diff(f,z) + \
+ ... (n*(n+1)-m**2/(1-z**2))*f(z)
+ >>> for z in [0, 2, -1.5, 0.5+2j]:
+ ... chop(deq(mpmathify(z)))
+ ...
+ 0.0
+ 0.0
+ 0.0
+ 0.0
+"""
+
+legenq = r"""
+Calculates the (associated) Legendre function of the second kind of
+degree *n* and order *m*, `Q_n^m(z)`. Taking `m = 0` gives the ordinary
+Legendre function of the second kind, `Q_n(z)`. The parameters may be
+complex numbers.
+
+The Legendre functions of the second kind give a second set of
+solutions to the (associated) Legendre differential equation.
+(See :func:`~mpmath.legenp`.)
+Unlike the Legendre functions of the first kind, they are not
+polynomials of `z` for integer `n`, `m` but rational or logarithmic
+functions with poles at `z = \pm 1`.
+
+There are various ways to define Legendre functions of
+the second kind, giving rise to different complex structure.
+A version can be selected using the *type* keyword argument.
+The *type=2* and *type=3* functions are given respectively by
+
+.. math ::
+
+ Q_n^m(z) = \frac{\pi}{2 \sin(\pi m)}
+ \left( \cos(\pi m) P_n^m(z) -
+ \frac{\Gamma(1+m+n)}{\Gamma(1-m+n)} P_n^{-m}(z)\right)
+
+ \hat{Q}_n^m(z) = \frac{\pi}{2 \sin(\pi m)} e^{\pi i m}
+ \left( \hat{P}_n^m(z) -
+ \frac{\Gamma(1+m+n)}{\Gamma(1-m+n)} \hat{P}_n^{-m}(z)\right)
+
+where `P` and `\hat{P}` are the *type=2* and *type=3* Legendre functions
+of the first kind. The formulas above should be understood as limits
+when `m` is an integer.
+
+These functions correspond to ``LegendreQ[n,m,2,z]`` (or ``LegendreQ[n,m,z]``)
+and ``LegendreQ[n,m,3,z]`` in Mathematica. The *type=3* function
+is essentially the same as the function defined in
+Abramowitz & Stegun (eq. 8.1.3) but with `(z+1)^{m/2}(z-1)^{m/2}` instead
+of `(z^2-1)^{m/2}`, giving slightly different branches.
+
+**Examples**
+
+Evaluation for arbitrary parameters and arguments::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> legenq(2, 0, 0.5)
+ -0.8186632680417568557122028
+ >>> legenq(-1.5, -2, 2.5)
+ (0.6655964618250228714288277 + 0.3937692045497259717762649j)
+ >>> legenq(2-j, 3+4j, -6+5j)
+ (-10001.95256487468541686564 - 6011.691337610097577791134j)
+
+Different versions of the function::
+
+ >>> legenq(2, 1, 0.5)
+ 0.7298060598018049369381857
+ >>> legenq(2, 1, 1.5)
+ (-7.902916572420817192300921 + 0.1998650072605976600724502j)
+ >>> legenq(2, 1, 0.5, type=3)
+ (2.040524284763495081918338 - 0.7298060598018049369381857j)
+ >>> chop(legenq(2, 1, 1.5, type=3))
+ -0.1998650072605976600724502
+
+"""
+
+chebyt = r"""
+``chebyt(n, x)`` evaluates the Chebyshev polynomial of the first
+kind `T_n(x)`, defined by the identity
+
+.. math ::
+
+ T_n(\cos x) = \cos(n x).
+
+The Chebyshev polynomials of the first kind are a special
+case of the Jacobi polynomials, and by extension of the
+hypergeometric function `\,_2F_1`. They can thus also be
+evaluated for nonintegral `n`.
+
+**Plots**
+
+.. literalinclude :: /plots/chebyt.py
+.. image :: /plots/chebyt.png
+
+**Basic evaluation**
+
+The coefficients of the `n`-th polynomial can be recovered
+using using degree-`n` Taylor expansion::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> for n in range(5):
+ ... nprint(chop(taylor(lambda x: chebyt(n, x), 0, n)))
+ ...
+ [1.0]
+ [0.0, 1.0]
+ [-1.0, 0.0, 2.0]
+ [0.0, -3.0, 0.0, 4.0]
+ [1.0, 0.0, -8.0, 0.0, 8.0]
+
+**Orthogonality**
+
+The Chebyshev polynomials of the first kind are orthogonal
+on the interval `[-1, 1]` with respect to the weight
+function `w(x) = 1/\sqrt{1-x^2}`::
+
+ >>> f = lambda x: chebyt(m,x)*chebyt(n,x)/sqrt(1-x**2)
+ >>> m, n = 3, 4
+ >>> nprint(quad(f, [-1, 1]),1)
+ 0.0
+ >>> m, n = 4, 4
+ >>> quad(f, [-1, 1])
+ 1.57079632596448
+
+"""
+
+chebyu = r"""
+``chebyu(n, x)`` evaluates the Chebyshev polynomial of the second
+kind `U_n(x)`, defined by the identity
+
+.. math ::
+
+ U_n(\cos x) = \frac{\sin((n+1)x)}{\sin(x)}.
+
+The Chebyshev polynomials of the second kind are a special
+case of the Jacobi polynomials, and by extension of the
+hypergeometric function `\,_2F_1`. They can thus also be
+evaluated for nonintegral `n`.
+
+**Plots**
+
+.. literalinclude :: /plots/chebyu.py
+.. image :: /plots/chebyu.png
+
+**Basic evaluation**
+
+The coefficients of the `n`-th polynomial can be recovered
+using using degree-`n` Taylor expansion::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> for n in range(5):
+ ... nprint(chop(taylor(lambda x: chebyu(n, x), 0, n)))
+ ...
+ [1.0]
+ [0.0, 2.0]
+ [-1.0, 0.0, 4.0]
+ [0.0, -4.0, 0.0, 8.0]
+ [1.0, 0.0, -12.0, 0.0, 16.0]
+
+**Orthogonality**
+
+The Chebyshev polynomials of the second kind are orthogonal
+on the interval `[-1, 1]` with respect to the weight
+function `w(x) = \sqrt{1-x^2}`::
+
+ >>> f = lambda x: chebyu(m,x)*chebyu(n,x)*sqrt(1-x**2)
+ >>> m, n = 3, 4
+ >>> quad(f, [-1, 1])
+ 0.0
+ >>> m, n = 4, 4
+ >>> quad(f, [-1, 1])
+ 1.5707963267949
+"""
+
+besselj = r"""
+``besselj(n, x, derivative=0)`` gives the Bessel function of the first kind
+`J_n(x)`. Bessel functions of the first kind are defined as
+solutions of the differential equation
+
+.. math ::
+
+ x^2 y'' + x y' + (x^2 - n^2) y = 0
+
+which appears, among other things, when solving the radial
+part of Laplace's equation in cylindrical coordinates. This
+equation has two solutions for given `n`, where the
+`J_n`-function is the solution that is nonsingular at `x = 0`.
+For positive integer `n`, `J_n(x)` behaves roughly like a sine
+(odd `n`) or cosine (even `n`) multiplied by a magnitude factor
+that decays slowly as `x \to \pm\infty`.
+
+Generally, `J_n` is a special case of the hypergeometric
+function `\,_0F_1`:
+
+.. math ::
+
+ J_n(x) = \frac{x^n}{2^n \Gamma(n+1)}
+ \,_0F_1\left(n+1,-\frac{x^2}{4}\right)
+
+With *derivative* = `m \ne 0`, the `m`-th derivative
+
+.. math ::
+
+ \frac{d^m}{dx^m} J_n(x)
+
+is computed.
+
+**Plots**
+
+.. literalinclude :: /plots/besselj.py
+.. image :: /plots/besselj.png
+.. literalinclude :: /plots/besselj_c.py
+.. image :: /plots/besselj_c.png
+
+**Examples**
+
+Evaluation is supported for arbitrary arguments, and at
+arbitrary precision::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> besselj(2, 1000)
+ -0.024777229528606
+ >>> besselj(4, 0.75)
+ 0.000801070086542314
+ >>> besselj(2, 1000j)
+ (-2.48071721019185e+432 + 6.41567059811949e-437j)
+ >>> mp.dps = 25
+ >>> besselj(0.75j, 3+4j)
+ (-2.778118364828153309919653 - 1.5863603889018621585533j)
+ >>> mp.dps = 50
+ >>> besselj(1, pi)
+ 0.28461534317975275734531059968613140570981118184947
+
+Arguments may be large::
+
+ >>> mp.dps = 25
+ >>> besselj(0, 10000)
+ -0.007096160353388801477265164
+ >>> besselj(0, 10**10)
+ 0.000002175591750246891726859055
+ >>> besselj(2, 10**100)
+ 7.337048736538615712436929e-51
+ >>> besselj(2, 10**5*j)
+ (-3.540725411970948860173735e+43426 + 4.4949812409615803110051e-43433j)
+
+The Bessel functions of the first kind satisfy simple
+symmetries around `x = 0`::
+
+ >>> mp.dps = 15
+ >>> nprint([besselj(n,0) for n in range(5)])
+ [1.0, 0.0, 0.0, 0.0, 0.0]
+ >>> nprint([besselj(n,pi) for n in range(5)])
+ [-0.304242, 0.284615, 0.485434, 0.333458, 0.151425]
+ >>> nprint([besselj(n,-pi) for n in range(5)])
+ [-0.304242, -0.284615, 0.485434, -0.333458, 0.151425]
+
+Roots of Bessel functions are often used::
+
+ >>> nprint([findroot(j0, k) for k in [2, 5, 8, 11, 14]])
+ [2.40483, 5.52008, 8.65373, 11.7915, 14.9309]
+ >>> nprint([findroot(j1, k) for k in [3, 7, 10, 13, 16]])
+ [3.83171, 7.01559, 10.1735, 13.3237, 16.4706]
+
+The roots are not periodic, but the distance between successive
+roots asymptotically approaches `2 \pi`. Bessel functions of
+the first kind have the following normalization::
+
+ >>> quadosc(j0, [0, inf], period=2*pi)
+ 1.0
+ >>> quadosc(j1, [0, inf], period=2*pi)
+ 1.0
+
+For `n = 1/2` or `n = -1/2`, the Bessel function reduces to a
+trigonometric function::
+
+ >>> x = 10
+ >>> besselj(0.5, x), sqrt(2/(pi*x))*sin(x)
+ (-0.13726373575505, -0.13726373575505)
+ >>> besselj(-0.5, x), sqrt(2/(pi*x))*cos(x)
+ (-0.211708866331398, -0.211708866331398)
+
+Derivatives of any order can be computed (negative orders
+correspond to integration)::
+
+ >>> mp.dps = 25
+ >>> besselj(0, 7.5, 1)
+ -0.1352484275797055051822405
+ >>> diff(lambda x: besselj(0,x), 7.5)
+ -0.1352484275797055051822405
+ >>> besselj(0, 7.5, 10)
+ -0.1377811164763244890135677
+ >>> diff(lambda x: besselj(0,x), 7.5, 10)
+ -0.1377811164763244890135677
+ >>> besselj(0,7.5,-1) - besselj(0,3.5,-1)
+ -0.1241343240399987693521378
+ >>> quad(j0, [3.5, 7.5])
+ -0.1241343240399987693521378
+
+Differentiation with a noninteger order gives the fractional derivative
+in the sense of the Riemann-Liouville differintegral, as computed by
+:func:`~mpmath.differint`::
+
+ >>> mp.dps = 15
+ >>> besselj(1, 3.5, 0.75)
+ -0.385977722939384
+ >>> differint(lambda x: besselj(1, x), 3.5, 0.75)
+ -0.385977722939384
+
+"""
+
+besseli = r"""
+``besseli(n, x, derivative=0)`` gives the modified Bessel function of the
+first kind,
+
+.. math ::
+
+ I_n(x) = i^{-n} J_n(ix).
+
+With *derivative* = `m \ne 0`, the `m`-th derivative
+
+.. math ::
+
+ \frac{d^m}{dx^m} I_n(x)
+
+is computed.
+
+**Plots**
+
+.. literalinclude :: /plots/besseli.py
+.. image :: /plots/besseli.png
+.. literalinclude :: /plots/besseli_c.py
+.. image :: /plots/besseli_c.png
+
+**Examples**
+
+Some values of `I_n(x)`::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> besseli(0,0)
+ 1.0
+ >>> besseli(1,0)
+ 0.0
+ >>> besseli(0,1)
+ 1.266065877752008335598245
+ >>> besseli(3.5, 2+3j)
+ (-0.2904369752642538144289025 - 0.4469098397654815837307006j)
+
+Arguments may be large::
+
+ >>> besseli(2, 1000)
+ 2.480717210191852440616782e+432
+ >>> besseli(2, 10**10)
+ 4.299602851624027900335391e+4342944813
+ >>> besseli(2, 6000+10000j)
+ (-2.114650753239580827144204e+2603 + 4.385040221241629041351886e+2602j)
+
+For integers `n`, the following integral representation holds::
+
+ >>> mp.dps = 15
+ >>> n = 3
+ >>> x = 2.3
+ >>> quad(lambda t: exp(x*cos(t))*cos(n*t), [0,pi])/pi
+ 0.349223221159309
+ >>> besseli(n,x)
+ 0.349223221159309
+
+Derivatives and antiderivatives of any order can be computed::
+
+ >>> mp.dps = 25
+ >>> besseli(2, 7.5, 1)
+ 195.8229038931399062565883
+ >>> diff(lambda x: besseli(2,x), 7.5)
+ 195.8229038931399062565883
+ >>> besseli(2, 7.5, 10)
+ 153.3296508971734525525176
+ >>> diff(lambda x: besseli(2,x), 7.5, 10)
+ 153.3296508971734525525176
+ >>> besseli(2,7.5,-1) - besseli(2,3.5,-1)
+ 202.5043900051930141956876
+ >>> quad(lambda x: besseli(2,x), [3.5, 7.5])
+ 202.5043900051930141956876
+
+"""
+
+bessely = r"""
+``bessely(n, x, derivative=0)`` gives the Bessel function of the second kind,
+
+.. math ::
+
+ Y_n(x) = \frac{J_n(x) \cos(\pi n) - J_{-n}(x)}{\sin(\pi n)}.
+
+For `n` an integer, this formula should be understood as a
+limit. With *derivative* = `m \ne 0`, the `m`-th derivative
+
+.. math ::
+
+ \frac{d^m}{dx^m} Y_n(x)
+
+is computed.
+
+**Plots**
+
+.. literalinclude :: /plots/bessely.py
+.. image :: /plots/bessely.png
+.. literalinclude :: /plots/bessely_c.py
+.. image :: /plots/bessely_c.png
+
+**Examples**
+
+Some values of `Y_n(x)`::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> bessely(0,0), bessely(1,0), bessely(2,0)
+ (-inf, -inf, -inf)
+ >>> bessely(1, pi)
+ 0.3588729167767189594679827
+ >>> bessely(0.5, 3+4j)
+ (9.242861436961450520325216 - 3.085042824915332562522402j)
+
+Arguments may be large::
+
+ >>> bessely(0, 10000)
+ 0.00364780555898660588668872
+ >>> bessely(2.5, 10**50)
+ -4.8952500412050989295774e-26
+ >>> bessely(2.5, -10**50)
+ (0.0 + 4.8952500412050989295774e-26j)
+
+Derivatives and antiderivatives of any order can be computed::
+
+ >>> bessely(2, 3.5, 1)
+ 0.3842618820422660066089231
+ >>> diff(lambda x: bessely(2, x), 3.5)
+ 0.3842618820422660066089231
+ >>> bessely(0.5, 3.5, 1)
+ -0.2066598304156764337900417
+ >>> diff(lambda x: bessely(0.5, x), 3.5)
+ -0.2066598304156764337900417
+ >>> diff(lambda x: bessely(2, x), 0.5, 10)
+ -208173867409.5547350101511
+ >>> bessely(2, 0.5, 10)
+ -208173867409.5547350101511
+ >>> bessely(2, 100.5, 100)
+ 0.02668487547301372334849043
+ >>> quad(lambda x: bessely(2,x), [1,3])
+ -1.377046859093181969213262
+ >>> bessely(2,3,-1) - bessely(2,1,-1)
+ -1.377046859093181969213262
+
+"""
+
+besselk = r"""
+``besselk(n, x)`` gives the modified Bessel function of the
+second kind,
+
+.. math ::
+
+ K_n(x) = \frac{\pi}{2} \frac{I_{-n}(x)-I_{n}(x)}{\sin(\pi n)}
+
+For `n` an integer, this formula should be understood as a
+limit.
+
+**Plots**
+
+.. literalinclude :: /plots/besselk.py
+.. image :: /plots/besselk.png
+.. literalinclude :: /plots/besselk_c.py
+.. image :: /plots/besselk_c.png
+
+**Examples**
+
+Evaluation is supported for arbitrary complex arguments::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> besselk(0,1)
+ 0.4210244382407083333356274
+ >>> besselk(0, -1)
+ (0.4210244382407083333356274 - 3.97746326050642263725661j)
+ >>> besselk(3.5, 2+3j)
+ (-0.02090732889633760668464128 + 0.2464022641351420167819697j)
+ >>> besselk(2+3j, 0.5)
+ (0.9615816021726349402626083 + 0.1918250181801757416908224j)
+
+Arguments may be large::
+
+ >>> besselk(0, 100)
+ 4.656628229175902018939005e-45
+ >>> besselk(1, 10**6)
+ 4.131967049321725588398296e-434298
+ >>> besselk(1, 10**6*j)
+ (0.001140348428252385844876706 - 0.0005200017201681152909000961j)
+ >>> besselk(4.5, fmul(10**50, j, exact=True))
+ (1.561034538142413947789221e-26 + 1.243554598118700063281496e-25j)
+
+The point `x = 0` is a singularity (logarithmic if `n = 0`)::
+
+ >>> besselk(0,0)
+ +inf
+ >>> besselk(1,0)
+ +inf
+ >>> for n in range(-4, 5):
+ ... print(besselk(n, '1e-1000'))
+ ...
+ 4.8e+4001
+ 8.0e+3000
+ 2.0e+2000
+ 1.0e+1000
+ 2302.701024509704096466802
+ 1.0e+1000
+ 2.0e+2000
+ 8.0e+3000
+ 4.8e+4001
+
+"""
+
+hankel1 = r"""
+``hankel1(n,x)`` computes the Hankel function of the first kind,
+which is the complex combination of Bessel functions given by
+
+.. math ::
+
+ H_n^{(1)}(x) = J_n(x) + i Y_n(x).
+
+**Plots**
+
+.. literalinclude :: /plots/hankel1.py
+.. image :: /plots/hankel1.png
+.. literalinclude :: /plots/hankel1_c.py
+.. image :: /plots/hankel1_c.png
+
+**Examples**
+
+The Hankel function is generally complex-valued::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> hankel1(2, pi)
+ (0.4854339326315091097054957 - 0.0999007139290278787734903j)
+ >>> hankel1(3.5, pi)
+ (0.2340002029630507922628888 - 0.6419643823412927142424049j)
+"""
+
+hankel2 = r"""
+``hankel2(n,x)`` computes the Hankel function of the second kind,
+which is the complex combination of Bessel functions given by
+
+.. math ::
+
+ H_n^{(2)}(x) = J_n(x) - i Y_n(x).
+
+**Plots**
+
+.. literalinclude :: /plots/hankel2.py
+.. image :: /plots/hankel2.png
+.. literalinclude :: /plots/hankel2_c.py
+.. image :: /plots/hankel2_c.png
+
+**Examples**
+
+The Hankel function is generally complex-valued::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> hankel2(2, pi)
+ (0.4854339326315091097054957 + 0.0999007139290278787734903j)
+ >>> hankel2(3.5, pi)
+ (0.2340002029630507922628888 + 0.6419643823412927142424049j)
+"""
+
+lambertw = r"""
+The Lambert W function `W(z)` is defined as the inverse function
+of `w \exp(w)`. In other words, the value of `W(z)` is such that
+`z = W(z) \exp(W(z))` for any complex number `z`.
+
+The Lambert W function is a multivalued function with infinitely
+many branches `W_k(z)`, indexed by `k \in \mathbb{Z}`. Each branch
+gives a different solution `w` of the equation `z = w \exp(w)`.
+All branches are supported by :func:`~mpmath.lambertw`:
+
+* ``lambertw(z)`` gives the principal solution (branch 0)
+
+* ``lambertw(z, k)`` gives the solution on branch `k`
+
+The Lambert W function has two partially real branches: the
+principal branch (`k = 0`) is real for real `z > -1/e`, and the
+`k = -1` branch is real for `-1/e < z < 0`. All branches except
+`k = 0` have a logarithmic singularity at `z = 0`.
+
+The definition, implementation and choice of branches
+is based on [Corless]_.
+
+**Plots**
+
+.. literalinclude :: /plots/lambertw.py
+.. image :: /plots/lambertw.png
+.. literalinclude :: /plots/lambertw_c.py
+.. image :: /plots/lambertw_c.png
+
+**Basic examples**
+
+The Lambert W function is the inverse of `w \exp(w)`::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> w = lambertw(1)
+ >>> w
+ 0.5671432904097838729999687
+ >>> w*exp(w)
+ 1.0
+
+Any branch gives a valid inverse::
+
+ >>> w = lambertw(1, k=3)
+ >>> w
+ (-2.853581755409037807206819 + 17.11353553941214591260783j)
+ >>> w = lambertw(1, k=25)
+ >>> w
+ (-5.047020464221569709378686 + 155.4763860949415867162066j)
+ >>> chop(w*exp(w))
+ 1.0
+
+**Applications to equation-solving**
+
+The Lambert W function may be used to solve various kinds of
+equations, such as finding the value of the infinite power
+tower `z^{z^{z^{\ldots}}}`::
+
+ >>> def tower(z, n):
+ ... if n == 0:
+ ... return z
+ ... return z ** tower(z, n-1)
+ ...
+ >>> tower(mpf(0.5), 100)
+ 0.6411857445049859844862005
+ >>> -lambertw(-log(0.5))/log(0.5)
+ 0.6411857445049859844862005
+
+**Properties**
+
+The Lambert W function grows roughly like the natural logarithm
+for large arguments::
+
+ >>> lambertw(1000); log(1000)
+ 5.249602852401596227126056
+ 6.907755278982137052053974
+ >>> lambertw(10**100); log(10**100)
+ 224.8431064451185015393731
+ 230.2585092994045684017991
+
+The principal branch of the Lambert W function has a rational
+Taylor series expansion around `z = 0`::
+
+ >>> nprint(taylor(lambertw, 0, 6), 10)
+ [0.0, 1.0, -1.0, 1.5, -2.666666667, 5.208333333, -10.8]
+
+Some special values and limits are::
+
+ >>> lambertw(0)
+ 0.0
+ >>> lambertw(1)
+ 0.5671432904097838729999687
+ >>> lambertw(e)
+ 1.0
+ >>> lambertw(inf)
+ +inf
+ >>> lambertw(0, k=-1)
+ -inf
+ >>> lambertw(0, k=3)
+ -inf
+ >>> lambertw(inf, k=2)
+ (+inf + 12.56637061435917295385057j)
+ >>> lambertw(inf, k=3)
+ (+inf + 18.84955592153875943077586j)
+ >>> lambertw(-inf, k=3)
+ (+inf + 21.9911485751285526692385j)
+
+The `k = 0` and `k = -1` branches join at `z = -1/e` where
+`W(z) = -1` for both branches. Since `-1/e` can only be represented
+approximately with binary floating-point numbers, evaluating the
+Lambert W function at this point only gives `-1` approximately::
+
+ >>> lambertw(-1/e, 0)
+ -0.9999999999998371330228251
+ >>> lambertw(-1/e, -1)
+ -1.000000000000162866977175
+
+If `-1/e` happens to round in the negative direction, there might be
+a small imaginary part::
+
+ >>> mp.dps = 15
+ >>> lambertw(-1/e)
+ (-1.0 + 8.22007971483662e-9j)
+ >>> lambertw(-1/e+eps)
+ -0.999999966242188
+
+**References**
+
+1. [Corless]_
+"""
+
+barnesg = r"""
+Evaluates the Barnes G-function, which generalizes the
+superfactorial (:func:`~mpmath.superfac`) and by extension also the
+hyperfactorial (:func:`~mpmath.hyperfac`) to the complex numbers
+in an analogous way to how the gamma function generalizes
+the ordinary factorial.
+
+The Barnes G-function may be defined in terms of a Weierstrass
+product:
+
+.. math ::
+
+ G(z+1) = (2\pi)^{z/2} e^{-[z(z+1)+\gamma z^2]/2}
+ \prod_{n=1}^\infty
+ \left[\left(1+\frac{z}{n}\right)^ne^{-z+z^2/(2n)}\right]
+
+For positive integers `n`, we have have relation to superfactorials
+`G(n) = \mathrm{sf}(n-2) = 0! \cdot 1! \cdots (n-2)!`.
+
+**Examples**
+
+Some elementary values and limits of the Barnes G-function::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> barnesg(1), barnesg(2), barnesg(3)
+ (1.0, 1.0, 1.0)
+ >>> barnesg(4)
+ 2.0
+ >>> barnesg(5)
+ 12.0
+ >>> barnesg(6)
+ 288.0
+ >>> barnesg(7)
+ 34560.0
+ >>> barnesg(8)
+ 24883200.0
+ >>> barnesg(inf)
+ +inf
+ >>> barnesg(0), barnesg(-1), barnesg(-2)
+ (0.0, 0.0, 0.0)
+
+Closed-form values are known for some rational arguments::
+
+ >>> barnesg('1/2')
+ 0.603244281209446
+ >>> sqrt(exp(0.25+log(2)/12)/sqrt(pi)/glaisher**3)
+ 0.603244281209446
+ >>> barnesg('1/4')
+ 0.29375596533861
+ >>> nthroot(exp('3/8')/exp(catalan/pi)/
+ ... gamma(0.25)**3/sqrt(glaisher)**9, 4)
+ 0.29375596533861
+
+The Barnes G-function satisfies the functional equation
+`G(z+1) = \Gamma(z) G(z)`::
+
+ >>> z = pi
+ >>> barnesg(z+1)
+ 2.39292119327948
+ >>> gamma(z)*barnesg(z)
+ 2.39292119327948
+
+The asymptotic growth rate of the Barnes G-function is related to
+the Glaisher-Kinkelin constant::
+
+ >>> limit(lambda n: barnesg(n+1)/(n**(n**2/2-mpf(1)/12)*
+ ... (2*pi)**(n/2)*exp(-3*n**2/4)), inf)
+ 0.847536694177301
+ >>> exp('1/12')/glaisher
+ 0.847536694177301
+
+The Barnes G-function can be differentiated in closed form::
+
+ >>> z = 3
+ >>> diff(barnesg, z)
+ 0.264507203401607
+ >>> barnesg(z)*((z-1)*psi(0,z)-z+(log(2*pi)+1)/2)
+ 0.264507203401607
+
+Evaluation is supported for arbitrary arguments and at arbitrary
+precision::
+
+ >>> barnesg(6.5)
+ 2548.7457695685
+ >>> barnesg(-pi)
+ 0.00535976768353037
+ >>> barnesg(3+4j)
+ (-0.000676375932234244 - 4.42236140124728e-5j)
+ >>> mp.dps = 50
+ >>> barnesg(1/sqrt(2))
+ 0.81305501090451340843586085064413533788206204124732
+ >>> q = barnesg(10j)
+ >>> q.real
+ 0.000000000021852360840356557241543036724799812371995850552234
+ >>> q.imag
+ -0.00000000000070035335320062304849020654215545839053210041457588
+ >>> mp.dps = 15
+ >>> barnesg(100)
+ 3.10361006263698e+6626
+ >>> barnesg(-101)
+ 0.0
+ >>> barnesg(-10.5)
+ 5.94463017605008e+25
+ >>> barnesg(-10000.5)
+ -6.14322868174828e+167480422
+ >>> barnesg(1000j)
+ (5.21133054865546e-1173597 + 4.27461836811016e-1173597j)
+ >>> barnesg(-1000+1000j)
+ (2.43114569750291e+1026623 + 2.24851410674842e+1026623j)
+
+
+**References**
+
+1. Whittaker & Watson, *A Course of Modern Analysis*,
+ Cambridge University Press, 4th edition (1927), p.264
+2. http://en.wikipedia.org/wiki/Barnes_G-function
+3. http://mathworld.wolfram.com/BarnesG-Function.html
+
+"""
+
+superfac = r"""
+Computes the superfactorial, defined as the product of
+consecutive factorials
+
+.. math ::
+
+ \mathrm{sf}(n) = \prod_{k=1}^n k!
+
+For general complex `z`, `\mathrm{sf}(z)` is defined
+in terms of the Barnes G-function (see :func:`~mpmath.barnesg`).
+
+**Examples**
+
+The first few superfactorials are (OEIS A000178)::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> for n in range(10):
+ ... print("%s %s" % (n, superfac(n)))
+ ...
+ 0 1.0
+ 1 1.0
+ 2 2.0
+ 3 12.0
+ 4 288.0
+ 5 34560.0
+ 6 24883200.0
+ 7 125411328000.0
+ 8 5.05658474496e+15
+ 9 1.83493347225108e+21
+
+Superfactorials grow very rapidly::
+
+ >>> superfac(1000)
+ 3.24570818422368e+1177245
+ >>> superfac(10**10)
+ 2.61398543581249e+467427913956904067453
+
+Evaluation is supported for arbitrary arguments::
+
+ >>> mp.dps = 25
+ >>> superfac(pi)
+ 17.20051550121297985285333
+ >>> superfac(2+3j)
+ (-0.005915485633199789627466468 + 0.008156449464604044948738263j)
+ >>> diff(superfac, 1)
+ 0.2645072034016070205673056
+
+**References**
+
+1. http://oeis.org/A000178
+
+"""
+
+
+hyperfac = r"""
+Computes the hyperfactorial, defined for integers as the product
+
+.. math ::
+
+ H(n) = \prod_{k=1}^n k^k.
+
+
+The hyperfactorial satisfies the recurrence formula `H(z) = z^z H(z-1)`.
+It can be defined more generally in terms of the Barnes G-function (see
+:func:`~mpmath.barnesg`) and the gamma function by the formula
+
+.. math ::
+
+ H(z) = \frac{\Gamma(z+1)^z}{G(z)}.
+
+The extension to complex numbers can also be done via
+the integral representation
+
+.. math ::
+
+ H(z) = (2\pi)^{-z/2} \exp \left[
+ {z+1 \choose 2} + \int_0^z \log(t!)\,dt
+ \right].
+
+**Examples**
+
+The rapidly-growing sequence of hyperfactorials begins
+(OEIS A002109)::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> for n in range(10):
+ ... print("%s %s" % (n, hyperfac(n)))
+ ...
+ 0 1.0
+ 1 1.0
+ 2 4.0
+ 3 108.0
+ 4 27648.0
+ 5 86400000.0
+ 6 4031078400000.0
+ 7 3.3197663987712e+18
+ 8 5.56964379417266e+25
+ 9 2.15779412229419e+34
+
+Some even larger hyperfactorials are::
+
+ >>> hyperfac(1000)
+ 5.46458120882585e+1392926
+ >>> hyperfac(10**10)
+ 4.60408207642219e+489142638002418704309
+
+The hyperfactorial can be evaluated for arbitrary arguments::
+
+ >>> hyperfac(0.5)
+ 0.880449235173423
+ >>> diff(hyperfac, 1)
+ 0.581061466795327
+ >>> hyperfac(pi)
+ 205.211134637462
+ >>> hyperfac(-10+1j)
+ (3.01144471378225e+46 - 2.45285242480185e+46j)
+
+The recurrence property of the hyperfactorial holds
+generally::
+
+ >>> z = 3-4*j
+ >>> hyperfac(z)
+ (-4.49795891462086e-7 - 6.33262283196162e-7j)
+ >>> z**z * hyperfac(z-1)
+ (-4.49795891462086e-7 - 6.33262283196162e-7j)
+ >>> z = mpf(-0.6)
+ >>> chop(z**z * hyperfac(z-1))
+ 1.28170142849352
+ >>> hyperfac(z)
+ 1.28170142849352
+
+The hyperfactorial may also be computed using the integral
+definition::
+
+ >>> z = 2.5
+ >>> hyperfac(z)
+ 15.9842119922237
+ >>> (2*pi)**(-z/2)*exp(binomial(z+1,2) +
+ ... quad(lambda t: loggamma(t+1), [0, z]))
+ 15.9842119922237
+
+:func:`~mpmath.hyperfac` supports arbitrary-precision evaluation::
+
+ >>> mp.dps = 50
+ >>> hyperfac(10)
+ 215779412229418562091680268288000000000000000.0
+ >>> hyperfac(1/sqrt(2))
+ 0.89404818005227001975423476035729076375705084390942
+
+**References**
+
+1. http://oeis.org/A002109
+2. http://mathworld.wolfram.com/Hyperfactorial.html
+
+"""
+
+rgamma = r"""
+Computes the reciprocal of the gamma function, `1/\Gamma(z)`. This
+function evaluates to zero at the poles
+of the gamma function, `z = 0, -1, -2, \ldots`.
+
+**Examples**
+
+Basic examples::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> rgamma(1)
+ 1.0
+ >>> rgamma(4)
+ 0.1666666666666666666666667
+ >>> rgamma(0); rgamma(-1)
+ 0.0
+ 0.0
+ >>> rgamma(1000)
+ 2.485168143266784862783596e-2565
+ >>> rgamma(inf)
+ 0.0
+
+A definite integral that can be evaluated in terms of elementary
+integrals::
+
+ >>> quad(rgamma, [0,inf])
+ 2.807770242028519365221501
+ >>> e + quad(lambda t: exp(-t)/(pi**2+log(t)**2), [0,inf])
+ 2.807770242028519365221501
+"""
+
+loggamma = r"""
+Computes the principal branch of the log-gamma function,
+`\ln \Gamma(z)`. Unlike `\ln(\Gamma(z))`, which has infinitely many
+complex branch cuts, the principal log-gamma function only has a single
+branch cut along the negative half-axis. The principal branch
+continuously matches the asymptotic Stirling expansion
+
+.. math ::
+
+ \ln \Gamma(z) \sim \frac{\ln(2 \pi)}{2} +
+ \left(z-\frac{1}{2}\right) \ln(z) - z + O(z^{-1}).
+
+The real parts of both functions agree, but their imaginary
+parts generally differ by `2 n \pi` for some `n \in \mathbb{Z}`.
+They coincide for `z \in \mathbb{R}, z > 0`.
+
+Computationally, it is advantageous to use :func:`~mpmath.loggamma`
+instead of :func:`~mpmath.gamma` for extremely large arguments.
+
+**Examples**
+
+Comparing with `\ln(\Gamma(z))`::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> loggamma('13.2'); log(gamma('13.2'))
+ 20.49400419456603678498394
+ 20.49400419456603678498394
+ >>> loggamma(3+4j)
+ (-1.756626784603784110530604 + 4.742664438034657928194889j)
+ >>> log(gamma(3+4j))
+ (-1.756626784603784110530604 - 1.540520869144928548730397j)
+ >>> log(gamma(3+4j)) + 2*pi*j
+ (-1.756626784603784110530604 + 4.742664438034657928194889j)
+
+Note the imaginary parts for negative arguments::
+
+ >>> loggamma(-0.5); loggamma(-1.5); loggamma(-2.5)
+ (1.265512123484645396488946 - 3.141592653589793238462643j)
+ (0.8600470153764810145109327 - 6.283185307179586476925287j)
+ (-0.05624371649767405067259453 - 9.42477796076937971538793j)
+
+Some special values::
+
+ >>> loggamma(1); loggamma(2)
+ 0.0
+ 0.0
+ >>> loggamma(3); +ln2
+ 0.6931471805599453094172321
+ 0.6931471805599453094172321
+ >>> loggamma(3.5); log(15*sqrt(pi)/8)
+ 1.200973602347074224816022
+ 1.200973602347074224816022
+ >>> loggamma(inf)
+ +inf
+
+Huge arguments are permitted::
+
+ >>> loggamma('1e30')
+ 6.807755278982137052053974e+31
+ >>> loggamma('1e300')
+ 6.897755278982137052053974e+302
+ >>> loggamma('1e3000')
+ 6.906755278982137052053974e+3003
+ >>> loggamma('1e100000000000000000000')
+ 2.302585092994045684007991e+100000000000000000020
+ >>> loggamma('1e30j')
+ (-1.570796326794896619231322e+30 + 6.807755278982137052053974e+31j)
+ >>> loggamma('1e300j')
+ (-1.570796326794896619231322e+300 + 6.897755278982137052053974e+302j)
+ >>> loggamma('1e3000j')
+ (-1.570796326794896619231322e+3000 + 6.906755278982137052053974e+3003j)
+
+The log-gamma function can be integrated analytically
+on any interval of unit length::
+
+ >>> z = 0
+ >>> quad(loggamma, [z,z+1]); log(2*pi)/2
+ 0.9189385332046727417803297
+ 0.9189385332046727417803297
+ >>> z = 3+4j
+ >>> quad(loggamma, [z,z+1]); (log(z)-1)*z + log(2*pi)/2
+ (-0.9619286014994750641314421 + 5.219637303741238195688575j)
+ (-0.9619286014994750641314421 + 5.219637303741238195688575j)
+
+The derivatives of the log-gamma function are given by the
+polygamma function (:func:`~mpmath.psi`)::
+
+ >>> diff(loggamma, -4+3j); psi(0, -4+3j)
+ (1.688493531222971393607153 + 2.554898911356806978892748j)
+ (1.688493531222971393607153 + 2.554898911356806978892748j)
+ >>> diff(loggamma, -4+3j, 2); psi(1, -4+3j)
+ (-0.1539414829219882371561038 - 0.1020485197430267719746479j)
+ (-0.1539414829219882371561038 - 0.1020485197430267719746479j)
+
+The log-gamma function satisfies an additive form of the
+recurrence relation for the ordinary gamma function::
+
+ >>> z = 2+3j
+ >>> loggamma(z); loggamma(z+1) - log(z)
+ (-2.092851753092733349564189 + 2.302396543466867626153708j)
+ (-2.092851753092733349564189 + 2.302396543466867626153708j)
+
+"""
+
+siegeltheta = r"""
+Computes the Riemann-Siegel theta function,
+
+.. math ::
+
+ \theta(t) = \frac{
+ \log\Gamma\left(\frac{1+2it}{4}\right) -
+ \log\Gamma\left(\frac{1-2it}{4}\right)
+ }{2i} - \frac{\log \pi}{2} t.
+
+The Riemann-Siegel theta function is important in
+providing the phase factor for the Z-function
+(see :func:`~mpmath.siegelz`). Evaluation is supported for real and
+complex arguments::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> siegeltheta(0)
+ 0.0
+ >>> siegeltheta(inf)
+ +inf
+ >>> siegeltheta(-inf)
+ -inf
+ >>> siegeltheta(1)
+ -1.767547952812290388302216
+ >>> siegeltheta(10+0.25j)
+ (-3.068638039426838572528867 + 0.05804937947429712998395177j)
+
+Arbitrary derivatives may be computed with derivative = k
+
+ >>> siegeltheta(1234, derivative=2)
+ 0.0004051864079114053109473741
+ >>> diff(siegeltheta, 1234, n=2)
+ 0.0004051864079114053109473741
+
+
+The Riemann-Siegel theta function has odd symmetry around `t = 0`,
+two local extreme points and three real roots including 0 (located
+symmetrically)::
+
+ >>> nprint(chop(taylor(siegeltheta, 0, 5)))
+ [0.0, -2.68609, 0.0, 2.69433, 0.0, -6.40218]
+ >>> findroot(diffun(siegeltheta), 7)
+ 6.28983598883690277966509
+ >>> findroot(siegeltheta, 20)
+ 17.84559954041086081682634
+
+For large `t`, there is a famous asymptotic formula
+for `\theta(t)`, to first order given by::
+
+ >>> t = mpf(10**6)
+ >>> siegeltheta(t)
+ 5488816.353078403444882823
+ >>> -t*log(2*pi/t)/2-t/2
+ 5488816.745777464310273645
+"""
+
+grampoint = r"""
+Gives the `n`-th Gram point `g_n`, defined as the solution
+to the equation `\theta(g_n) = \pi n` where `\theta(t)`
+is the Riemann-Siegel theta function (:func:`~mpmath.siegeltheta`).
+
+The first few Gram points are::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> grampoint(0)
+ 17.84559954041086081682634
+ >>> grampoint(1)
+ 23.17028270124630927899664
+ >>> grampoint(2)
+ 27.67018221781633796093849
+ >>> grampoint(3)
+ 31.71797995476405317955149
+
+Checking the definition::
+
+ >>> siegeltheta(grampoint(3))
+ 9.42477796076937971538793
+ >>> 3*pi
+ 9.42477796076937971538793
+
+A large Gram point::
+
+ >>> grampoint(10**10)
+ 3293531632.728335454561153
+
+Gram points are useful when studying the Z-function
+(:func:`~mpmath.siegelz`). See the documentation of that function
+for additional examples.
+
+:func:`~mpmath.grampoint` can solve the defining equation for
+nonintegral `n`. There is a fixed point where `g(x) = x`::
+
+ >>> findroot(lambda x: grampoint(x) - x, 10000)
+ 9146.698193171459265866198
+
+**References**
+
+1. http://mathworld.wolfram.com/GramPoint.html
+
+"""
+
+siegelz = r"""
+Computes the Z-function, also known as the Riemann-Siegel Z function,
+
+.. math ::
+
+ Z(t) = e^{i \theta(t)} \zeta(1/2+it)
+
+where `\zeta(s)` is the Riemann zeta function (:func:`~mpmath.zeta`)
+and where `\theta(t)` denotes the Riemann-Siegel theta function
+(see :func:`~mpmath.siegeltheta`).
+
+Evaluation is supported for real and complex arguments::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> siegelz(1)
+ -0.7363054628673177346778998
+ >>> siegelz(3+4j)
+ (-0.1852895764366314976003936 - 0.2773099198055652246992479j)
+
+The first four derivatives are supported, using the
+optional *derivative* keyword argument::
+
+ >>> siegelz(1234567, derivative=3)
+ 56.89689348495089294249178
+ >>> diff(siegelz, 1234567, n=3)
+ 56.89689348495089294249178
+
+
+The Z-function has a Maclaurin expansion::
+
+ >>> nprint(chop(taylor(siegelz, 0, 4)))
+ [-1.46035, 0.0, 2.73588, 0.0, -8.39357]
+
+The Z-function `Z(t)` is equal to `\pm |\zeta(s)|` on the
+critical line `s = 1/2+it` (i.e. for real arguments `t`
+to `Z`). Its zeros coincide with those of the Riemann zeta
+function::
+
+ >>> findroot(siegelz, 14)
+ 14.13472514173469379045725
+ >>> findroot(siegelz, 20)
+ 21.02203963877155499262848
+ >>> findroot(zeta, 0.5+14j)
+ (0.5 + 14.13472514173469379045725j)
+ >>> findroot(zeta, 0.5+20j)
+ (0.5 + 21.02203963877155499262848j)
+
+Since the Z-function is real-valued on the critical line
+(and unlike `|\zeta(s)|` analytic), it is useful for
+investigating the zeros of the Riemann zeta function.
+For example, one can use a root-finding algorithm based
+on sign changes::
+
+ >>> findroot(siegelz, [100, 200], solver='bisect')
+ 176.4414342977104188888926
+
+To locate roots, Gram points `g_n` which can be computed
+by :func:`~mpmath.grampoint` are useful. If `(-1)^n Z(g_n)` is
+positive for two consecutive `n`, then `Z(t)` must have
+a zero between those points::
+
+ >>> g10 = grampoint(10)
+ >>> g11 = grampoint(11)
+ >>> (-1)**10 * siegelz(g10) > 0
+ True
+ >>> (-1)**11 * siegelz(g11) > 0
+ True
+ >>> findroot(siegelz, [g10, g11], solver='bisect')
+ 56.44624769706339480436776
+ >>> g10, g11
+ (54.67523744685325626632663, 57.54516517954725443703014)
+
+"""
+
+riemannr = r"""
+Evaluates the Riemann R function, a smooth approximation of the
+prime counting function `\pi(x)` (see :func:`~mpmath.primepi`). The Riemann
+R function gives a fast numerical approximation useful e.g. to
+roughly estimate the number of primes in a given interval.
+
+The Riemann R function is computed using the rapidly convergent Gram
+series,
+
+.. math ::
+
+ R(x) = 1 + \sum_{k=1}^{\infty}
+ \frac{\log^k x}{k k! \zeta(k+1)}.
+
+From the Gram series, one sees that the Riemann R function is a
+well-defined analytic function (except for a branch cut along
+the negative real half-axis); it can be evaluated for arbitrary
+real or complex arguments.
+
+The Riemann R function gives a very accurate approximation
+of the prime counting function. For example, it is wrong by at
+most 2 for `x < 1000`, and for `x = 10^9` differs from the exact
+value of `\pi(x)` by 79, or less than two parts in a million.
+It is about 10 times more accurate than the logarithmic integral
+estimate (see :func:`~mpmath.li`), which however is even faster to evaluate.
+It is orders of magnitude more accurate than the extremely
+fast `x/\log x` estimate.
+
+**Examples**
+
+For small arguments, the Riemann R function almost exactly
+gives the prime counting function if rounded to the nearest
+integer::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> primepi(50), riemannr(50)
+ (15, 14.9757023241462)
+ >>> max(abs(primepi(n)-int(round(riemannr(n)))) for n in range(100))
+ 1
+ >>> max(abs(primepi(n)-int(round(riemannr(n)))) for n in range(300))
+ 2
+
+The Riemann R function can be evaluated for arguments far too large
+for exact determination of `\pi(x)` to be computationally
+feasible with any presently known algorithm::
+
+ >>> riemannr(10**30)
+ 1.46923988977204e+28
+ >>> riemannr(10**100)
+ 4.3619719871407e+97
+ >>> riemannr(10**1000)
+ 4.3448325764012e+996
+
+A comparison of the Riemann R function and logarithmic integral estimates
+for `\pi(x)` using exact values of `\pi(10^n)` up to `n = 9`.
+The fractional error is shown in parentheses::
+
+ >>> exact = [4,25,168,1229,9592,78498,664579,5761455,50847534]
+ >>> for n, p in enumerate(exact):
+ ... n += 1
+ ... r, l = riemannr(10**n), li(10**n)
+ ... rerr, lerr = nstr((r-p)/p,3), nstr((l-p)/p,3)
+ ... print("%i %i %s(%s) %s(%s)" % (n, p, r, rerr, l, lerr))
+ ...
+ 1 4 4.56458314100509(0.141) 6.1655995047873(0.541)
+ 2 25 25.6616332669242(0.0265) 30.1261415840796(0.205)
+ 3 168 168.359446281167(0.00214) 177.609657990152(0.0572)
+ 4 1229 1226.93121834343(-0.00168) 1246.13721589939(0.0139)
+ 5 9592 9587.43173884197(-0.000476) 9629.8090010508(0.00394)
+ 6 78498 78527.3994291277(0.000375) 78627.5491594622(0.00165)
+ 7 664579 664667.447564748(0.000133) 664918.405048569(0.000511)
+ 8 5761455 5761551.86732017(1.68e-5) 5762209.37544803(0.000131)
+ 9 50847534 50847455.4277214(-1.55e-6) 50849234.9570018(3.35e-5)
+
+The derivative of the Riemann R function gives the approximate
+probability for a number of magnitude `x` to be prime::
+
+ >>> diff(riemannr, 1000)
+ 0.141903028110784
+ >>> mpf(primepi(1050) - primepi(950)) / 100
+ 0.15
+
+Evaluation is supported for arbitrary arguments and at arbitrary
+precision::
+
+ >>> mp.dps = 30
+ >>> riemannr(7.5)
+ 3.72934743264966261918857135136
+ >>> riemannr(-4+2j)
+ (-0.551002208155486427591793957644 + 2.16966398138119450043195899746j)
+
+"""
+
+primepi = r"""
+Evaluates the prime counting function, `\pi(x)`, which gives
+the number of primes less than or equal to `x`. The argument
+`x` may be fractional.
+
+The prime counting function is very expensive to evaluate
+precisely for large `x`, and the present implementation is
+not optimized in any way. For numerical approximation of the
+prime counting function, it is better to use :func:`~mpmath.primepi2`
+or :func:`~mpmath.riemannr`.
+
+Some values of the prime counting function::
+
+ >>> from mpmath import *
+ >>> [primepi(k) for k in range(20)]
+ [0, 0, 1, 2, 2, 3, 3, 4, 4, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 8]
+ >>> primepi(3.5)
+ 2
+ >>> primepi(100000)
+ 9592
+
+"""
+
+primepi2 = r"""
+Returns an interval (as an ``mpi`` instance) providing bounds
+for the value of the prime counting function `\pi(x)`. For small
+`x`, :func:`~mpmath.primepi2` returns an exact interval based on
+the output of :func:`~mpmath.primepi`. For `x > 2656`, a loose interval
+based on Schoenfeld's inequality
+
+.. math ::
+
+ |\pi(x) - \mathrm{li}(x)| < \frac{\sqrt x \log x}{8 \pi}
+
+is returned. This estimate is rigorous assuming the truth of
+the Riemann hypothesis, and can be computed very quickly.
+
+**Examples**
+
+Exact values of the prime counting function for small `x`::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> iv.dps = 15; iv.pretty = True
+ >>> primepi2(10)
+ [4.0, 4.0]
+ >>> primepi2(100)
+ [25.0, 25.0]
+ >>> primepi2(1000)
+ [168.0, 168.0]
+
+Loose intervals are generated for moderately large `x`:
+
+ >>> primepi2(10000), primepi(10000)
+ ([1209.0, 1283.0], 1229)
+ >>> primepi2(50000), primepi(50000)
+ ([5070.0, 5263.0], 5133)
+
+As `x` increases, the absolute error gets worse while the relative
+error improves. The exact value of `\pi(10^{23})` is
+1925320391606803968923, and :func:`~mpmath.primepi2` gives 9 significant
+digits::
+
+ >>> p = primepi2(10**23)
+ >>> p
+ [1.9253203909477020467e+21, 1.925320392280406229e+21]
+ >>> mpf(p.delta) / mpf(p.a)
+ 6.9219865355293e-10
+
+A more precise, nonrigorous estimate for `\pi(x)` can be
+obtained using the Riemann R function (:func:`~mpmath.riemannr`).
+For large enough `x`, the value returned by :func:`~mpmath.primepi2`
+essentially amounts to a small perturbation of the value returned by
+:func:`~mpmath.riemannr`::
+
+ >>> primepi2(10**100)
+ [4.3619719871407024816e+97, 4.3619719871407032404e+97]
+ >>> riemannr(10**100)
+ 4.3619719871407e+97
+"""
+
+primezeta = r"""
+Computes the prime zeta function, which is defined
+in analogy with the Riemann zeta function (:func:`~mpmath.zeta`)
+as
+
+.. math ::
+
+ P(s) = \sum_p \frac{1}{p^s}
+
+where the sum is taken over all prime numbers `p`. Although
+this sum only converges for `\mathrm{Re}(s) > 1`, the
+function is defined by analytic continuation in the
+half-plane `\mathrm{Re}(s) > 0`.
+
+**Examples**
+
+Arbitrary-precision evaluation for real and complex arguments is
+supported::
+
+ >>> from mpmath import *
+ >>> mp.dps = 30; mp.pretty = True
+ >>> primezeta(2)
+ 0.452247420041065498506543364832
+ >>> primezeta(pi)
+ 0.15483752698840284272036497397
+ >>> mp.dps = 50
+ >>> primezeta(3)
+ 0.17476263929944353642311331466570670097541212192615
+ >>> mp.dps = 20
+ >>> primezeta(3+4j)
+ (-0.12085382601645763295 - 0.013370403397787023602j)
+
+The prime zeta function has a logarithmic pole at `s = 1`,
+with residue equal to the difference of the Mertens and
+Euler constants::
+
+ >>> primezeta(1)
+ +inf
+ >>> extradps(25)(lambda x: primezeta(1+x)+log(x))(+eps)
+ -0.31571845205389007685
+ >>> mertens-euler
+ -0.31571845205389007685
+
+The analytic continuation to `0 < \mathrm{Re}(s) \le 1`
+is implemented. In this strip the function exhibits
+very complex behavior; on the unit interval, it has poles at
+`1/n` for every squarefree integer `n`::
+
+ >>> primezeta(0.5) # Pole at s = 1/2
+ (-inf + 3.1415926535897932385j)
+ >>> primezeta(0.25)
+ (-1.0416106801757269036 + 0.52359877559829887308j)
+ >>> primezeta(0.5+10j)
+ (0.54892423556409790529 + 0.45626803423487934264j)
+
+Although evaluation works in principle for any `\mathrm{Re}(s) > 0`,
+it should be noted that the evaluation time increases exponentially
+as `s` approaches the imaginary axis.
+
+For large `\mathrm{Re}(s)`, `P(s)` is asymptotic to `2^{-s}`::
+
+ >>> primezeta(inf)
+ 0.0
+ >>> primezeta(10), mpf(2)**-10
+ (0.00099360357443698021786, 0.0009765625)
+ >>> primezeta(1000)
+ 9.3326361850321887899e-302
+ >>> primezeta(1000+1000j)
+ (-3.8565440833654995949e-302 - 8.4985390447553234305e-302j)
+
+**References**
+
+Carl-Erik Froberg, "On the prime zeta function",
+BIT 8 (1968), pp. 187-202.
+
+"""
+
+bernpoly = r"""
+Evaluates the Bernoulli polynomial `B_n(z)`.
+
+The first few Bernoulli polynomials are::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> for n in range(6):
+ ... nprint(chop(taylor(lambda x: bernpoly(n,x), 0, n)))
+ ...
+ [1.0]
+ [-0.5, 1.0]
+ [0.166667, -1.0, 1.0]
+ [0.0, 0.5, -1.5, 1.0]
+ [-0.0333333, 0.0, 1.0, -2.0, 1.0]
+ [0.0, -0.166667, 0.0, 1.66667, -2.5, 1.0]
+
+At `z = 0`, the Bernoulli polynomial evaluates to a
+Bernoulli number (see :func:`~mpmath.bernoulli`)::
+
+ >>> bernpoly(12, 0), bernoulli(12)
+ (-0.253113553113553, -0.253113553113553)
+ >>> bernpoly(13, 0), bernoulli(13)
+ (0.0, 0.0)
+
+Evaluation is accurate for large `n` and small `z`::
+
+ >>> mp.dps = 25
+ >>> bernpoly(100, 0.5)
+ 2.838224957069370695926416e+78
+ >>> bernpoly(1000, 10.5)
+ 5.318704469415522036482914e+1769
+
+"""
+
+polylog = r"""
+Computes the polylogarithm, defined by the sum
+
+.. math ::
+
+ \mathrm{Li}_s(z) = \sum_{k=1}^{\infty} \frac{z^k}{k^s}.
+
+This series is convergent only for `|z| < 1`, so elsewhere
+the analytic continuation is implied.
+
+The polylogarithm should not be confused with the logarithmic
+integral (also denoted by Li or li), which is implemented
+as :func:`~mpmath.li`.
+
+**Examples**
+
+The polylogarithm satisfies a huge number of functional identities.
+A sample of polylogarithm evaluations is shown below::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> polylog(1,0.5), log(2)
+ (0.693147180559945, 0.693147180559945)
+ >>> polylog(2,0.5), (pi**2-6*log(2)**2)/12
+ (0.582240526465012, 0.582240526465012)
+ >>> polylog(2,-phi), -log(phi)**2-pi**2/10
+ (-1.21852526068613, -1.21852526068613)
+ >>> polylog(3,0.5), 7*zeta(3)/8-pi**2*log(2)/12+log(2)**3/6
+ (0.53721319360804, 0.53721319360804)
+
+:func:`~mpmath.polylog` can evaluate the analytic continuation of the
+polylogarithm when `s` is an integer::
+
+ >>> polylog(2, 10)
+ (0.536301287357863 - 7.23378441241546j)
+ >>> polylog(2, -10)
+ -4.1982778868581
+ >>> polylog(2, 10j)
+ (-3.05968879432873 + 3.71678149306807j)
+ >>> polylog(-2, 10)
+ -0.150891632373114
+ >>> polylog(-2, -10)
+ 0.067618332081142
+ >>> polylog(-2, 10j)
+ (0.0384353698579347 + 0.0912451798066779j)
+
+Some more examples, with arguments on the unit circle (note that
+the series definition cannot be used for computation here)::
+
+ >>> polylog(2,j)
+ (-0.205616758356028 + 0.915965594177219j)
+ >>> j*catalan-pi**2/48
+ (-0.205616758356028 + 0.915965594177219j)
+ >>> polylog(3,exp(2*pi*j/3))
+ (-0.534247512515375 + 0.765587078525922j)
+ >>> -4*zeta(3)/9 + 2*j*pi**3/81
+ (-0.534247512515375 + 0.765587078525921j)
+
+Polylogarithms of different order are related by integration
+and differentiation::
+
+ >>> s, z = 3, 0.5
+ >>> polylog(s+1, z)
+ 0.517479061673899
+ >>> quad(lambda t: polylog(s,t)/t, [0, z])
+ 0.517479061673899
+ >>> z*diff(lambda t: polylog(s+2,t), z)
+ 0.517479061673899
+
+Taylor series expansions around `z = 0` are::
+
+ >>> for n in range(-3, 4):
+ ... nprint(taylor(lambda x: polylog(n,x), 0, 5))
+ ...
+ [0.0, 1.0, 8.0, 27.0, 64.0, 125.0]
+ [0.0, 1.0, 4.0, 9.0, 16.0, 25.0]
+ [0.0, 1.0, 2.0, 3.0, 4.0, 5.0]
+ [0.0, 1.0, 1.0, 1.0, 1.0, 1.0]
+ [0.0, 1.0, 0.5, 0.333333, 0.25, 0.2]
+ [0.0, 1.0, 0.25, 0.111111, 0.0625, 0.04]
+ [0.0, 1.0, 0.125, 0.037037, 0.015625, 0.008]
+
+The series defining the polylogarithm is simultaneously
+a Taylor series and an L-series. For certain values of `z`, the
+polylogarithm reduces to a pure zeta function::
+
+ >>> polylog(pi, 1), zeta(pi)
+ (1.17624173838258, 1.17624173838258)
+ >>> polylog(pi, -1), -altzeta(pi)
+ (-0.909670702980385, -0.909670702980385)
+
+Evaluation for arbitrary, nonintegral `s` is supported
+for `z` within the unit circle:
+
+ >>> polylog(3+4j, 0.25)
+ (0.24258605789446 - 0.00222938275488344j)
+ >>> nsum(lambda k: 0.25**k / k**(3+4j), [1,inf])
+ (0.24258605789446 - 0.00222938275488344j)
+
+It is also supported outside of the unit circle::
+
+ >>> polylog(1+j, 20+40j)
+ (-7.1421172179728 - 3.92726697721369j)
+ >>> polylog(1+j, 200+400j)
+ (-5.41934747194626 - 9.94037752563927j)
+
+**References**
+
+1. Richard Crandall, "Note on fast polylogarithm computation"
+ http://www.reed.edu/physics/faculty/crandall/papers/Polylog.pdf
+2. http://en.wikipedia.org/wiki/Polylogarithm
+3. http://mathworld.wolfram.com/Polylogarithm.html
+
+"""
+
+bell = r"""
+For `n` a nonnegative integer, ``bell(n,x)`` evaluates the Bell
+polynomial `B_n(x)`, the first few of which are
+
+.. math ::
+
+ B_0(x) = 1
+
+ B_1(x) = x
+
+ B_2(x) = x^2+x
+
+ B_3(x) = x^3+3x^2+x
+
+If `x = 1` or :func:`~mpmath.bell` is called with only one argument, it
+gives the `n`-th Bell number `B_n`, which is the number of
+partitions of a set with `n` elements. By setting the precision to
+at least `\log_{10} B_n` digits, :func:`~mpmath.bell` provides fast
+calculation of exact Bell numbers.
+
+In general, :func:`~mpmath.bell` computes
+
+.. math ::
+
+ B_n(x) = e^{-x} \left(\mathrm{sinc}(\pi n) + E_n(x)\right)
+
+where `E_n(x)` is the generalized exponential function implemented
+by :func:`~mpmath.polyexp`. This is an extension of Dobinski's formula [1],
+where the modification is the sinc term ensuring that `B_n(x)` is
+continuous in `n`; :func:`~mpmath.bell` can thus be evaluated,
+differentiated, etc for arbitrary complex arguments.
+
+**Examples**
+
+Simple evaluations::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> bell(0, 2.5)
+ 1.0
+ >>> bell(1, 2.5)
+ 2.5
+ >>> bell(2, 2.5)
+ 8.75
+
+Evaluation for arbitrary complex arguments::
+
+ >>> bell(5.75+1j, 2-3j)
+ (-10767.71345136587098445143 - 15449.55065599872579097221j)
+
+The first few Bell polynomials::
+
+ >>> for k in range(7):
+ ... nprint(taylor(lambda x: bell(k,x), 0, k))
+ ...
+ [1.0]
+ [0.0, 1.0]
+ [0.0, 1.0, 1.0]
+ [0.0, 1.0, 3.0, 1.0]
+ [0.0, 1.0, 7.0, 6.0, 1.0]
+ [0.0, 1.0, 15.0, 25.0, 10.0, 1.0]
+ [0.0, 1.0, 31.0, 90.0, 65.0, 15.0, 1.0]
+
+The first few Bell numbers and complementary Bell numbers::
+
+ >>> [int(bell(k)) for k in range(10)]
+ [1, 1, 2, 5, 15, 52, 203, 877, 4140, 21147]
+ >>> [int(bell(k,-1)) for k in range(10)]
+ [1, -1, 0, 1, 1, -2, -9, -9, 50, 267]
+
+Large Bell numbers::
+
+ >>> mp.dps = 50
+ >>> bell(50)
+ 185724268771078270438257767181908917499221852770.0
+ >>> bell(50,-1)
+ -29113173035759403920216141265491160286912.0
+
+Some even larger values::
+
+ >>> mp.dps = 25
+ >>> bell(1000,-1)
+ -1.237132026969293954162816e+1869
+ >>> bell(1000)
+ 2.989901335682408421480422e+1927
+ >>> bell(1000,2)
+ 6.591553486811969380442171e+1987
+ >>> bell(1000,100.5)
+ 9.101014101401543575679639e+2529
+
+A determinant identity satisfied by Bell numbers::
+
+ >>> mp.dps = 15
+ >>> N = 8
+ >>> det([[bell(k+j) for j in range(N)] for k in range(N)])
+ 125411328000.0
+ >>> superfac(N-1)
+ 125411328000.0
+
+**References**
+
+1. http://mathworld.wolfram.com/DobinskisFormula.html
+
+"""
+
+polyexp = r"""
+Evaluates the polyexponential function, defined for arbitrary
+complex `s`, `z` by the series
+
+.. math ::
+
+ E_s(z) = \sum_{k=1}^{\infty} \frac{k^s}{k!} z^k.
+
+`E_s(z)` is constructed from the exponential function analogously
+to how the polylogarithm is constructed from the ordinary
+logarithm; as a function of `s` (with `z` fixed), `E_s` is an L-series
+It is an entire function of both `s` and `z`.
+
+The polyexponential function provides a generalization of the
+Bell polynomials `B_n(x)` (see :func:`~mpmath.bell`) to noninteger orders `n`.
+In terms of the Bell polynomials,
+
+.. math ::
+
+ E_s(z) = e^z B_s(z) - \mathrm{sinc}(\pi s).
+
+Note that `B_n(x)` and `e^{-x} E_n(x)` are identical if `n`
+is a nonzero integer, but not otherwise. In particular, they differ
+at `n = 0`.
+
+**Examples**
+
+Evaluating a series::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> nsum(lambda k: sqrt(k)/fac(k), [1,inf])
+ 2.101755547733791780315904
+ >>> polyexp(0.5,1)
+ 2.101755547733791780315904
+
+Evaluation for arbitrary arguments::
+
+ >>> polyexp(-3-4j, 2.5+2j)
+ (2.351660261190434618268706 + 1.202966666673054671364215j)
+
+Evaluation is accurate for tiny function values::
+
+ >>> polyexp(4, -100)
+ 3.499471750566824369520223e-36
+
+If `n` is a nonpositive integer, `E_n` reduces to a special
+instance of the hypergeometric function `\,_pF_q`::
+
+ >>> n = 3
+ >>> x = pi
+ >>> polyexp(-n,x)
+ 4.042192318847986561771779
+ >>> x*hyper([1]*(n+1), [2]*(n+1), x)
+ 4.042192318847986561771779
+
+"""
+
+cyclotomic = r"""
+Evaluates the cyclotomic polynomial `\Phi_n(x)`, defined by
+
+.. math ::
+
+ \Phi_n(x) = \prod_{\zeta} (x - \zeta)
+
+where `\zeta` ranges over all primitive `n`-th roots of unity
+(see :func:`~mpmath.unitroots`). An equivalent representation, used
+for computation, is
+
+.. math ::
+
+ \Phi_n(x) = \prod_{d\mid n}(x^d-1)^{\mu(n/d)} = \Phi_n(x)
+
+where `\mu(m)` denotes the Moebius function. The cyclotomic
+polynomials are integer polynomials, the first of which can be
+written explicitly as
+
+.. math ::
+
+ \Phi_0(x) = 1
+
+ \Phi_1(x) = x - 1
+
+ \Phi_2(x) = x + 1
+
+ \Phi_3(x) = x^3 + x^2 + 1
+
+ \Phi_4(x) = x^2 + 1
+
+ \Phi_5(x) = x^4 + x^3 + x^2 + x + 1
+
+ \Phi_6(x) = x^2 - x + 1
+
+**Examples**
+
+The coefficients of low-order cyclotomic polynomials can be recovered
+using Taylor expansion::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> for n in range(9):
+ ... p = chop(taylor(lambda x: cyclotomic(n,x), 0, 10))
+ ... print("%s %s" % (n, nstr(p[:10+1-p[::-1].index(1)])))
+ ...
+ 0 [1.0]
+ 1 [-1.0, 1.0]
+ 2 [1.0, 1.0]
+ 3 [1.0, 1.0, 1.0]
+ 4 [1.0, 0.0, 1.0]
+ 5 [1.0, 1.0, 1.0, 1.0, 1.0]
+ 6 [1.0, -1.0, 1.0]
+ 7 [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
+ 8 [1.0, 0.0, 0.0, 0.0, 1.0]
+
+The definition as a product over primitive roots may be checked
+by computing the product explicitly (for a real argument, this
+method will generally introduce numerical noise in the imaginary
+part)::
+
+ >>> mp.dps = 25
+ >>> z = 3+4j
+ >>> cyclotomic(10, z)
+ (-419.0 - 360.0j)
+ >>> fprod(z-r for r in unitroots(10, primitive=True))
+ (-419.0 - 360.0j)
+ >>> z = 3
+ >>> cyclotomic(10, z)
+ 61.0
+ >>> fprod(z-r for r in unitroots(10, primitive=True))
+ (61.0 - 3.146045605088568607055454e-25j)
+
+Up to permutation, the roots of a given cyclotomic polynomial
+can be checked to agree with the list of primitive roots::
+
+ >>> p = taylor(lambda x: cyclotomic(6,x), 0, 6)[:3]
+ >>> for r in polyroots(p[::-1]):
+ ... print(r)
+ ...
+ (0.5 - 0.8660254037844386467637232j)
+ (0.5 + 0.8660254037844386467637232j)
+ >>>
+ >>> for r in unitroots(6, primitive=True):
+ ... print(r)
+ ...
+ (0.5 + 0.8660254037844386467637232j)
+ (0.5 - 0.8660254037844386467637232j)
+
+"""
+
+meijerg = r"""
+Evaluates the Meijer G-function, defined as
+
+.. math ::
+
+ G^{m,n}_{p,q} \left( \left. \begin{matrix}
+ a_1, \dots, a_n ; a_{n+1} \dots a_p \\
+ b_1, \dots, b_m ; b_{m+1} \dots b_q
+ \end{matrix}\; \right| \; z ; r \right) =
+ \frac{1}{2 \pi i} \int_L
+ \frac{\prod_{j=1}^m \Gamma(b_j+s) \prod_{j=1}^n\Gamma(1-a_j-s)}
+ {\prod_{j=n+1}^{p}\Gamma(a_j+s) \prod_{j=m+1}^q \Gamma(1-b_j-s)}
+ z^{-s/r} ds
+
+for an appropriate choice of the contour `L` (see references).
+
+There are `p` elements `a_j`.
+The argument *a_s* should be a pair of lists, the first containing the
+`n` elements `a_1, \ldots, a_n` and the second containing
+the `p-n` elements `a_{n+1}, \ldots a_p`.
+
+There are `q` elements `b_j`.
+The argument *b_s* should be a pair of lists, the first containing the
+`m` elements `b_1, \ldots, b_m` and the second containing
+the `q-m` elements `b_{m+1}, \ldots b_q`.
+
+The implicit tuple `(m, n, p, q)` constitutes the order or degree of the
+Meijer G-function, and is determined by the lengths of the coefficient
+vectors. Confusingly, the indices in this tuple appear in a different order
+from the coefficients, but this notation is standard. The many examples
+given below should hopefully clear up any potential confusion.
+
+**Algorithm**
+
+The Meijer G-function is evaluated as a combination of hypergeometric series.
+There are two versions of the function, which can be selected with
+the optional *series* argument.
+
+*series=1* uses a sum of `m` `\,_pF_{q-1}` functions of `z`
+
+*series=2* uses a sum of `n` `\,_qF_{p-1}` functions of `1/z`
+
+The default series is chosen based on the degree and `|z|` in order
+to be consistent with Mathematica's. This definition of the Meijer G-function
+has a discontinuity at `|z| = 1` for some orders, which can
+be avoided by explicitly specifying a series.
+
+Keyword arguments are forwarded to :func:`~mpmath.hypercomb`.
+
+**Examples**
+
+Many standard functions are special cases of the Meijer G-function
+(possibly rescaled and/or with branch cut corrections). We define
+some test parameters::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> a = mpf(0.75)
+ >>> b = mpf(1.5)
+ >>> z = mpf(2.25)
+
+The exponential function:
+`e^z = G^{1,0}_{0,1} \left( \left. \begin{matrix} - \\ 0 \end{matrix} \;
+\right| \; -z \right)`
+
+ >>> meijerg([[],[]], [[0],[]], -z)
+ 9.487735836358525720550369
+ >>> exp(z)
+ 9.487735836358525720550369
+
+The natural logarithm:
+`\log(1+z) = G^{1,2}_{2,2} \left( \left. \begin{matrix} 1, 1 \\ 1, 0
+\end{matrix} \; \right| \; -z \right)`
+
+ >>> meijerg([[1,1],[]], [[1],[0]], z)
+ 1.178654996341646117219023
+ >>> log(1+z)
+ 1.178654996341646117219023
+
+A rational function:
+`\frac{z}{z+1} = G^{1,2}_{2,2} \left( \left. \begin{matrix} 1, 1 \\ 1, 1
+\end{matrix} \; \right| \; z \right)`
+
+ >>> meijerg([[1,1],[]], [[1],[1]], z)
+ 0.6923076923076923076923077
+ >>> z/(z+1)
+ 0.6923076923076923076923077
+
+The sine and cosine functions:
+
+`\frac{1}{\sqrt \pi} \sin(2 \sqrt z) = G^{1,0}_{0,2} \left( \left. \begin{matrix}
+- \\ \frac{1}{2}, 0 \end{matrix} \; \right| \; z \right)`
+
+`\frac{1}{\sqrt \pi} \cos(2 \sqrt z) = G^{1,0}_{0,2} \left( \left. \begin{matrix}
+- \\ 0, \frac{1}{2} \end{matrix} \; \right| \; z \right)`
+
+ >>> meijerg([[],[]], [[0.5],[0]], (z/2)**2)
+ 0.4389807929218676682296453
+ >>> sin(z)/sqrt(pi)
+ 0.4389807929218676682296453
+ >>> meijerg([[],[]], [[0],[0.5]], (z/2)**2)
+ -0.3544090145996275423331762
+ >>> cos(z)/sqrt(pi)
+ -0.3544090145996275423331762
+
+Bessel functions:
+
+`J_a(2 \sqrt z) = G^{1,0}_{0,2} \left( \left.
+\begin{matrix} - \\ \frac{a}{2}, -\frac{a}{2}
+\end{matrix} \; \right| \; z \right)`
+
+`Y_a(2 \sqrt z) = G^{2,0}_{1,3} \left( \left.
+\begin{matrix} \frac{-a-1}{2} \\ \frac{a}{2}, -\frac{a}{2}, \frac{-a-1}{2}
+\end{matrix} \; \right| \; z \right)`
+
+`(-z)^{a/2} z^{-a/2} I_a(2 \sqrt z) = G^{1,0}_{0,2} \left( \left.
+\begin{matrix} - \\ \frac{a}{2}, -\frac{a}{2}
+\end{matrix} \; \right| \; -z \right)`
+
+`2 K_a(2 \sqrt z) = G^{2,0}_{0,2} \left( \left.
+\begin{matrix} - \\ \frac{a}{2}, -\frac{a}{2}
+\end{matrix} \; \right| \; z \right)`
+
+As the example with the Bessel *I* function shows, a branch
+factor is required for some arguments when inverting the square root.
+
+ >>> meijerg([[],[]], [[a/2],[-a/2]], (z/2)**2)
+ 0.5059425789597154858527264
+ >>> besselj(a,z)
+ 0.5059425789597154858527264
+ >>> meijerg([[],[(-a-1)/2]], [[a/2,-a/2],[(-a-1)/2]], (z/2)**2)
+ 0.1853868950066556941442559
+ >>> bessely(a, z)
+ 0.1853868950066556941442559
+ >>> meijerg([[],[]], [[a/2],[-a/2]], -(z/2)**2)
+ (0.8685913322427653875717476 + 2.096964974460199200551738j)
+ >>> (-z)**(a/2) / z**(a/2) * besseli(a, z)
+ (0.8685913322427653875717476 + 2.096964974460199200551738j)
+ >>> 0.5*meijerg([[],[]], [[a/2,-a/2],[]], (z/2)**2)
+ 0.09334163695597828403796071
+ >>> besselk(a,z)
+ 0.09334163695597828403796071
+
+Error functions:
+
+`\sqrt{\pi} z^{2(a-1)} \mathrm{erfc}(z) = G^{2,0}_{1,2} \left( \left.
+\begin{matrix} a \\ a-1, a-\frac{1}{2}
+\end{matrix} \; \right| \; z, \frac{1}{2} \right)`
+
+ >>> meijerg([[],[a]], [[a-1,a-0.5],[]], z, 0.5)
+ 0.00172839843123091957468712
+ >>> sqrt(pi) * z**(2*a-2) * erfc(z)
+ 0.00172839843123091957468712
+
+A Meijer G-function of higher degree, (1,1,2,3):
+
+ >>> meijerg([[a],[b]], [[a],[b,a-1]], z)
+ 1.55984467443050210115617
+ >>> sin((b-a)*pi)/pi*(exp(z)-1)*z**(a-1)
+ 1.55984467443050210115617
+
+A Meijer G-function of still higher degree, (4,1,2,4), that can
+be expanded as a messy combination of exponential integrals:
+
+ >>> meijerg([[a],[2*b-a]], [[b,a,b-0.5,-1-a+2*b],[]], z)
+ 0.3323667133658557271898061
+ >>> chop(4**(a-b+1)*sqrt(pi)*gamma(2*b-2*a)*z**a*\
+ ... expint(2*b-2*a, -2*sqrt(-z))*expint(2*b-2*a, 2*sqrt(-z)))
+ 0.3323667133658557271898061
+
+In the following case, different series give different values::
+
+ >>> chop(meijerg([[1],[0.25]],[[3],[0.5]],-2))
+ -0.06417628097442437076207337
+ >>> meijerg([[1],[0.25]],[[3],[0.5]],-2,series=1)
+ 0.1428699426155117511873047
+ >>> chop(meijerg([[1],[0.25]],[[3],[0.5]],-2,series=2))
+ -0.06417628097442437076207337
+
+**References**
+
+1. http://en.wikipedia.org/wiki/Meijer_G-function
+
+2. http://mathworld.wolfram.com/MeijerG-Function.html
+
+3. http://functions.wolfram.com/HypergeometricFunctions/MeijerG/
+
+4. http://functions.wolfram.com/HypergeometricFunctions/MeijerG1/
+
+"""
+
+clsin = r"""
+Computes the Clausen sine function, defined formally by the series
+
+.. math ::
+
+ \mathrm{Cl}_s(z) = \sum_{k=1}^{\infty} \frac{\sin(kz)}{k^s}.
+
+The special case `\mathrm{Cl}_2(z)` (i.e. ``clsin(2,z)``) is the classical
+"Clausen function". More generally, the Clausen function is defined for
+complex `s` and `z`, even when the series does not converge. The
+Clausen function is related to the polylogarithm (:func:`~mpmath.polylog`) as
+
+.. math ::
+
+ \mathrm{Cl}_s(z) = \frac{1}{2i}\left(\mathrm{Li}_s\left(e^{iz}\right) -
+ \mathrm{Li}_s\left(e^{-iz}\right)\right)
+
+ = \mathrm{Im}\left[\mathrm{Li}_s(e^{iz})\right] \quad (s, z \in \mathbb{R}),
+
+and this representation can be taken to provide the analytic continuation of the
+series. The complementary function :func:`~mpmath.clcos` gives the corresponding
+cosine sum.
+
+**Examples**
+
+Evaluation for arbitrarily chosen `s` and `z`::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> s, z = 3, 4
+ >>> clsin(s, z); nsum(lambda k: sin(z*k)/k**s, [1,inf])
+ -0.6533010136329338746275795
+ -0.6533010136329338746275795
+
+Using `z + \pi` instead of `z` gives an alternating series::
+
+ >>> clsin(s, z+pi)
+ 0.8860032351260589402871624
+ >>> nsum(lambda k: (-1)**k*sin(z*k)/k**s, [1,inf])
+ 0.8860032351260589402871624
+
+With `s = 1`, the sum can be expressed in closed form
+using elementary functions::
+
+ >>> z = 1 + sqrt(3)
+ >>> clsin(1, z)
+ 0.2047709230104579724675985
+ >>> chop((log(1-exp(-j*z)) - log(1-exp(j*z)))/(2*j))
+ 0.2047709230104579724675985
+ >>> nsum(lambda k: sin(k*z)/k, [1,inf])
+ 0.2047709230104579724675985
+
+The classical Clausen function `\mathrm{Cl}_2(\theta)` gives the
+value of the integral `\int_0^{\theta} -\ln(2\sin(x/2)) dx` for
+`0 < \theta < 2 \pi`::
+
+ >>> cl2 = lambda t: clsin(2, t)
+ >>> cl2(3.5)
+ -0.2465045302347694216534255
+ >>> -quad(lambda x: ln(2*sin(0.5*x)), [0, 3.5])
+ -0.2465045302347694216534255
+
+This function is symmetric about `\theta = \pi` with zeros and extreme
+points::
+
+ >>> cl2(0); cl2(pi/3); chop(cl2(pi)); cl2(5*pi/3); chop(cl2(2*pi))
+ 0.0
+ 1.014941606409653625021203
+ 0.0
+ -1.014941606409653625021203
+ 0.0
+
+Catalan's constant is a special value::
+
+ >>> cl2(pi/2)
+ 0.9159655941772190150546035
+ >>> +catalan
+ 0.9159655941772190150546035
+
+The Clausen sine function can be expressed in closed form when
+`s` is an odd integer (becoming zero when `s` < 0)::
+
+ >>> z = 1 + sqrt(2)
+ >>> clsin(1, z); (pi-z)/2
+ 0.3636895456083490948304773
+ 0.3636895456083490948304773
+ >>> clsin(3, z); pi**2/6*z - pi*z**2/4 + z**3/12
+ 0.5661751584451144991707161
+ 0.5661751584451144991707161
+ >>> clsin(-1, z)
+ 0.0
+ >>> clsin(-3, z)
+ 0.0
+
+It can also be expressed in closed form for even integer `s \le 0`,
+providing a finite sum for series such as
+`\sin(z) + \sin(2z) + \sin(3z) + \ldots`::
+
+ >>> z = 1 + sqrt(2)
+ >>> clsin(0, z)
+ 0.1903105029507513881275865
+ >>> cot(z/2)/2
+ 0.1903105029507513881275865
+ >>> clsin(-2, z)
+ -0.1089406163841548817581392
+ >>> -cot(z/2)*csc(z/2)**2/4
+ -0.1089406163841548817581392
+
+Call with ``pi=True`` to multiply `z` by `\pi` exactly::
+
+ >>> clsin(3, 3*pi)
+ -8.892316224968072424732898e-26
+ >>> clsin(3, 3, pi=True)
+ 0.0
+
+Evaluation for complex `s`, `z` in a nonconvergent case::
+
+ >>> s, z = -1-j, 1+2j
+ >>> clsin(s, z)
+ (-0.593079480117379002516034 + 0.9038644233367868273362446j)
+ >>> extraprec(20)(nsum)(lambda k: sin(k*z)/k**s, [1,inf])
+ (-0.593079480117379002516034 + 0.9038644233367868273362446j)
+
+"""
+
+clcos = r"""
+Computes the Clausen cosine function, defined formally by the series
+
+.. math ::
+
+ \mathrm{\widetilde{Cl}}_s(z) = \sum_{k=1}^{\infty} \frac{\cos(kz)}{k^s}.
+
+This function is complementary to the Clausen sine function
+:func:`~mpmath.clsin`. In terms of the polylogarithm,
+
+.. math ::
+
+ \mathrm{\widetilde{Cl}}_s(z) =
+ \frac{1}{2}\left(\mathrm{Li}_s\left(e^{iz}\right) +
+ \mathrm{Li}_s\left(e^{-iz}\right)\right)
+
+ = \mathrm{Re}\left[\mathrm{Li}_s(e^{iz})\right] \quad (s, z \in \mathbb{R}).
+
+**Examples**
+
+Evaluation for arbitrarily chosen `s` and `z`::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> s, z = 3, 4
+ >>> clcos(s, z); nsum(lambda k: cos(z*k)/k**s, [1,inf])
+ -0.6518926267198991308332759
+ -0.6518926267198991308332759
+
+Using `z + \pi` instead of `z` gives an alternating series::
+
+ >>> s, z = 3, 0.5
+ >>> clcos(s, z+pi)
+ -0.8155530586502260817855618
+ >>> nsum(lambda k: (-1)**k*cos(z*k)/k**s, [1,inf])
+ -0.8155530586502260817855618
+
+With `s = 1`, the sum can be expressed in closed form
+using elementary functions::
+
+ >>> z = 1 + sqrt(3)
+ >>> clcos(1, z)
+ -0.6720334373369714849797918
+ >>> chop(-0.5*(log(1-exp(j*z))+log(1-exp(-j*z))))
+ -0.6720334373369714849797918
+ >>> -log(abs(2*sin(0.5*z))) # Equivalent to above when z is real
+ -0.6720334373369714849797918
+ >>> nsum(lambda k: cos(k*z)/k, [1,inf])
+ -0.6720334373369714849797918
+
+It can also be expressed in closed form when `s` is an even integer.
+For example,
+
+ >>> clcos(2,z)
+ -0.7805359025135583118863007
+ >>> pi**2/6 - pi*z/2 + z**2/4
+ -0.7805359025135583118863007
+
+The case `s = 0` gives the renormalized sum of
+`\cos(z) + \cos(2z) + \cos(3z) + \ldots` (which happens to be the same for
+any value of `z`)::
+
+ >>> clcos(0, z)
+ -0.5
+ >>> nsum(lambda k: cos(k*z), [1,inf])
+ -0.5
+
+Also the sums
+
+.. math ::
+
+ \cos(z) + 2\cos(2z) + 3\cos(3z) + \ldots
+
+and
+
+.. math ::
+
+ \cos(z) + 2^n \cos(2z) + 3^n \cos(3z) + \ldots
+
+for higher integer powers `n = -s` can be done in closed form. They are zero
+when `n` is positive and even (`s` negative and even)::
+
+ >>> clcos(-1, z); 1/(2*cos(z)-2)
+ -0.2607829375240542480694126
+ -0.2607829375240542480694126
+ >>> clcos(-3, z); (2+cos(z))*csc(z/2)**4/8
+ 0.1472635054979944390848006
+ 0.1472635054979944390848006
+ >>> clcos(-2, z); clcos(-4, z); clcos(-6, z)
+ 0.0
+ 0.0
+ 0.0
+
+With `z = \pi`, the series reduces to that of the Riemann zeta function
+(more generally, if `z = p \pi/q`, it is a finite sum over Hurwitz zeta
+function values)::
+
+ >>> clcos(2.5, 0); zeta(2.5)
+ 1.34148725725091717975677
+ 1.34148725725091717975677
+ >>> clcos(2.5, pi); -altzeta(2.5)
+ -0.8671998890121841381913472
+ -0.8671998890121841381913472
+
+Call with ``pi=True`` to multiply `z` by `\pi` exactly::
+
+ >>> clcos(-3, 2*pi)
+ 2.997921055881167659267063e+102
+ >>> clcos(-3, 2, pi=True)
+ 0.008333333333333333333333333
+
+Evaluation for complex `s`, `z` in a nonconvergent case::
+
+ >>> s, z = -1-j, 1+2j
+ >>> clcos(s, z)
+ (0.9407430121562251476136807 + 0.715826296033590204557054j)
+ >>> extraprec(20)(nsum)(lambda k: cos(k*z)/k**s, [1,inf])
+ (0.9407430121562251476136807 + 0.715826296033590204557054j)
+
+"""
+
+whitm = r"""
+Evaluates the Whittaker function `M(k,m,z)`, which gives a solution
+to the Whittaker differential equation
+
+.. math ::
+
+ \frac{d^2f}{dz^2} + \left(-\frac{1}{4}+\frac{k}{z}+
+ \frac{(\frac{1}{4}-m^2)}{z^2}\right) f = 0.
+
+A second solution is given by :func:`~mpmath.whitw`.
+
+The Whittaker functions are defined in Abramowitz & Stegun, section 13.1.
+They are alternate forms of the confluent hypergeometric functions
+`\,_1F_1` and `U`:
+
+.. math ::
+
+ M(k,m,z) = e^{-\frac{1}{2}z} z^{\frac{1}{2}+m}
+ \,_1F_1(\tfrac{1}{2}+m-k, 1+2m, z)
+
+ W(k,m,z) = e^{-\frac{1}{2}z} z^{\frac{1}{2}+m}
+ U(\tfrac{1}{2}+m-k, 1+2m, z).
+
+**Examples**
+
+Evaluation for arbitrary real and complex arguments is supported::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> whitm(1, 1, 1)
+ 0.7302596799460411820509668
+ >>> whitm(1, 1, -1)
+ (0.0 - 1.417977827655098025684246j)
+ >>> whitm(j, j/2, 2+3j)
+ (3.245477713363581112736478 - 0.822879187542699127327782j)
+ >>> whitm(2, 3, 100000)
+ 4.303985255686378497193063e+21707
+
+Evaluation at zero::
+
+ >>> whitm(1,-1,0); whitm(1,-0.5,0); whitm(1,0,0)
+ +inf
+ nan
+ 0.0
+
+We can verify that :func:`~mpmath.whitm` numerically satisfies the
+differential equation for arbitrarily chosen values::
+
+ >>> k = mpf(0.25)
+ >>> m = mpf(1.5)
+ >>> f = lambda z: whitm(k,m,z)
+ >>> for z in [-1, 2.5, 3, 1+2j]:
+ ... chop(diff(f,z,2) + (-0.25 + k/z + (0.25-m**2)/z**2)*f(z))
+ ...
+ 0.0
+ 0.0
+ 0.0
+ 0.0
+
+An integral involving both :func:`~mpmath.whitm` and :func:`~mpmath.whitw`,
+verifying evaluation along the real axis::
+
+ >>> quad(lambda x: exp(-x)*whitm(3,2,x)*whitw(1,-2,x), [0,inf])
+ 3.438869842576800225207341
+ >>> 128/(21*sqrt(pi))
+ 3.438869842576800225207341
+
+"""
+
+whitw = r"""
+Evaluates the Whittaker function `W(k,m,z)`, which gives a second
+solution to the Whittaker differential equation. (See :func:`~mpmath.whitm`.)
+
+**Examples**
+
+Evaluation for arbitrary real and complex arguments is supported::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> whitw(1, 1, 1)
+ 1.19532063107581155661012
+ >>> whitw(1, 1, -1)
+ (-0.9424875979222187313924639 - 0.2607738054097702293308689j)
+ >>> whitw(j, j/2, 2+3j)
+ (0.1782899315111033879430369 - 0.01609578360403649340169406j)
+ >>> whitw(2, 3, 100000)
+ 1.887705114889527446891274e-21705
+ >>> whitw(-1, -1, 100)
+ 1.905250692824046162462058e-24
+
+Evaluation at zero::
+
+ >>> for m in [-1, -0.5, 0, 0.5, 1]:
+ ... whitw(1, m, 0)
+ ...
+ +inf
+ nan
+ 0.0
+ nan
+ +inf
+
+We can verify that :func:`~mpmath.whitw` numerically satisfies the
+differential equation for arbitrarily chosen values::
+
+ >>> k = mpf(0.25)
+ >>> m = mpf(1.5)
+ >>> f = lambda z: whitw(k,m,z)
+ >>> for z in [-1, 2.5, 3, 1+2j]:
+ ... chop(diff(f,z,2) + (-0.25 + k/z + (0.25-m**2)/z**2)*f(z))
+ ...
+ 0.0
+ 0.0
+ 0.0
+ 0.0
+
+"""
+
+ber = r"""
+Computes the Kelvin function ber, which for real arguments gives the real part
+of the Bessel J function of a rotated argument
+
+.. math ::
+
+ J_n\left(x e^{3\pi i/4}\right) = \mathrm{ber}_n(x) + i \mathrm{bei}_n(x).
+
+The imaginary part is given by :func:`~mpmath.bei`.
+
+**Plots**
+
+.. literalinclude :: /plots/ber.py
+.. image :: /plots/ber.png
+
+**Examples**
+
+Verifying the defining relation::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> n, x = 2, 3.5
+ >>> ber(n,x)
+ 1.442338852571888752631129
+ >>> bei(n,x)
+ -0.948359035324558320217678
+ >>> besselj(n, x*root(1,8,3))
+ (1.442338852571888752631129 - 0.948359035324558320217678j)
+
+The ber and bei functions are also defined by analytic continuation
+for complex arguments::
+
+ >>> ber(1+j, 2+3j)
+ (4.675445984756614424069563 - 15.84901771719130765656316j)
+ >>> bei(1+j, 2+3j)
+ (15.83886679193707699364398 + 4.684053288183046528703611j)
+
+"""
+
+bei = r"""
+Computes the Kelvin function bei, which for real arguments gives the
+imaginary part of the Bessel J function of a rotated argument.
+See :func:`~mpmath.ber`.
+"""
+
+ker = r"""
+Computes the Kelvin function ker, which for real arguments gives the real part
+of the (rescaled) Bessel K function of a rotated argument
+
+.. math ::
+
+ e^{-\pi i/2} K_n\left(x e^{3\pi i/4}\right) = \mathrm{ker}_n(x) + i \mathrm{kei}_n(x).
+
+The imaginary part is given by :func:`~mpmath.kei`.
+
+**Plots**
+
+.. literalinclude :: /plots/ker.py
+.. image :: /plots/ker.png
+
+**Examples**
+
+Verifying the defining relation::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> n, x = 2, 4.5
+ >>> ker(n,x)
+ 0.02542895201906369640249801
+ >>> kei(n,x)
+ -0.02074960467222823237055351
+ >>> exp(-n*pi*j/2) * besselk(n, x*root(1,8,1))
+ (0.02542895201906369640249801 - 0.02074960467222823237055351j)
+
+The ker and kei functions are also defined by analytic continuation
+for complex arguments::
+
+ >>> ker(1+j, 3+4j)
+ (1.586084268115490421090533 - 2.939717517906339193598719j)
+ >>> kei(1+j, 3+4j)
+ (-2.940403256319453402690132 - 1.585621643835618941044855j)
+
+"""
+
+kei = r"""
+Computes the Kelvin function kei, which for real arguments gives the
+imaginary part of the (rescaled) Bessel K function of a rotated argument.
+See :func:`~mpmath.ker`.
+"""
+
+struveh = r"""
+Gives the Struve function
+
+.. math ::
+
+ \,\mathbf{H}_n(z) =
+ \sum_{k=0}^\infty \frac{(-1)^k}{\Gamma(k+\frac{3}{2})
+ \Gamma(k+n+\frac{3}{2})} {\left({\frac{z}{2}}\right)}^{2k+n+1}
+
+which is a solution to the Struve differential equation
+
+.. math ::
+
+ z^2 f''(z) + z f'(z) + (z^2-n^2) f(z) = \frac{2 z^{n+1}}{\pi (2n-1)!!}.
+
+**Examples**
+
+Evaluation for arbitrary real and complex arguments::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> struveh(0, 3.5)
+ 0.3608207733778295024977797
+ >>> struveh(-1, 10)
+ -0.255212719726956768034732
+ >>> struveh(1, -100.5)
+ 0.5819566816797362287502246
+ >>> struveh(2.5, 10000000000000)
+ 3153915652525200060.308937
+ >>> struveh(2.5, -10000000000000)
+ (0.0 - 3153915652525200060.308937j)
+ >>> struveh(1+j, 1000000+4000000j)
+ (-3.066421087689197632388731e+1737173 - 1.596619701076529803290973e+1737173j)
+
+A Struve function of half-integer order is elementary; for example:
+
+ >>> z = 3
+ >>> struveh(0.5, 3)
+ 0.9167076867564138178671595
+ >>> sqrt(2/(pi*z))*(1-cos(z))
+ 0.9167076867564138178671595
+
+Numerically verifying the differential equation::
+
+ >>> z = mpf(4.5)
+ >>> n = 3
+ >>> f = lambda z: struveh(n,z)
+ >>> lhs = z**2*diff(f,z,2) + z*diff(f,z) + (z**2-n**2)*f(z)
+ >>> rhs = 2*z**(n+1)/fac2(2*n-1)/pi
+ >>> lhs
+ 17.40359302709875496632744
+ >>> rhs
+ 17.40359302709875496632744
+
+"""
+
+struvel = r"""
+Gives the modified Struve function
+
+.. math ::
+
+ \,\mathbf{L}_n(z) = -i e^{-n\pi i/2} \mathbf{H}_n(i z)
+
+which solves to the modified Struve differential equation
+
+.. math ::
+
+ z^2 f''(z) + z f'(z) - (z^2+n^2) f(z) = \frac{2 z^{n+1}}{\pi (2n-1)!!}.
+
+**Examples**
+
+Evaluation for arbitrary real and complex arguments::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> struvel(0, 3.5)
+ 7.180846515103737996249972
+ >>> struvel(-1, 10)
+ 2670.994904980850550721511
+ >>> struvel(1, -100.5)
+ 1.757089288053346261497686e+42
+ >>> struvel(2.5, 10000000000000)
+ 4.160893281017115450519948e+4342944819025
+ >>> struvel(2.5, -10000000000000)
+ (0.0 - 4.160893281017115450519948e+4342944819025j)
+ >>> struvel(1+j, 700j)
+ (-0.1721150049480079451246076 + 0.1240770953126831093464055j)
+ >>> struvel(1+j, 1000000+4000000j)
+ (-2.973341637511505389128708e+434290 - 5.164633059729968297147448e+434290j)
+
+Numerically verifying the differential equation::
+
+ >>> z = mpf(3.5)
+ >>> n = 3
+ >>> f = lambda z: struvel(n,z)
+ >>> lhs = z**2*diff(f,z,2) + z*diff(f,z) - (z**2+n**2)*f(z)
+ >>> rhs = 2*z**(n+1)/fac2(2*n-1)/pi
+ >>> lhs
+ 6.368850306060678353018165
+ >>> rhs
+ 6.368850306060678353018165
+"""
+
+appellf1 = r"""
+Gives the Appell F1 hypergeometric function of two variables,
+
+.. math ::
+
+ F_1(a,b_1,b_2,c,x,y) = \sum_{m=0}^{\infty} \sum_{n=0}^{\infty}
+ \frac{(a)_{m+n} (b_1)_m (b_2)_n}{(c)_{m+n}}
+ \frac{x^m y^n}{m! n!}.
+
+This series is only generally convergent when `|x| < 1` and `|y| < 1`,
+although :func:`~mpmath.appellf1` can evaluate an analytic continuation
+with respecto to either variable, and sometimes both.
+
+**Examples**
+
+Evaluation is supported for real and complex parameters::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> appellf1(1,0,0.5,1,0.5,0.25)
+ 1.154700538379251529018298
+ >>> appellf1(1,1+j,0.5,1,0.5,0.5j)
+ (1.138403860350148085179415 + 1.510544741058517621110615j)
+
+For some integer parameters, the F1 series reduces to a polynomial::
+
+ >>> appellf1(2,-4,-3,1,2,5)
+ -816.0
+ >>> appellf1(-5,1,2,1,4,5)
+ -20528.0
+
+The analytic continuation with respect to either `x` or `y`,
+and sometimes with respect to both, can be evaluated::
+
+ >>> appellf1(2,3,4,5,100,0.5)
+ (0.0006231042714165329279738662 + 0.0000005769149277148425774499857j)
+ >>> appellf1('1.1', '0.3', '0.2+2j', '0.4', '0.2', 1.5+3j)
+ (-0.1782604566893954897128702 + 0.002472407104546216117161499j)
+ >>> appellf1(1,2,3,4,10,12)
+ -0.07122993830066776374929313
+
+For certain arguments, F1 reduces to an ordinary hypergeometric function::
+
+ >>> appellf1(1,2,3,5,0.5,0.25)
+ 1.547902270302684019335555
+ >>> 4*hyp2f1(1,2,5,'1/3')/3
+ 1.547902270302684019335555
+ >>> appellf1(1,2,3,4,0,1.5)
+ (-1.717202506168937502740238 - 2.792526803190927323077905j)
+ >>> hyp2f1(1,3,4,1.5)
+ (-1.717202506168937502740238 - 2.792526803190927323077905j)
+
+The F1 function satisfies a system of partial differential equations::
+
+ >>> a,b1,b2,c,x,y = map(mpf, [1,0.5,0.25,1.125,0.25,-0.25])
+ >>> F = lambda x,y: appellf1(a,b1,b2,c,x,y)
+ >>> chop(x*(1-x)*diff(F,(x,y),(2,0)) +
+ ... y*(1-x)*diff(F,(x,y),(1,1)) +
+ ... (c-(a+b1+1)*x)*diff(F,(x,y),(1,0)) -
+ ... b1*y*diff(F,(x,y),(0,1)) -
+ ... a*b1*F(x,y))
+ 0.0
+ >>>
+ >>> chop(y*(1-y)*diff(F,(x,y),(0,2)) +
+ ... x*(1-y)*diff(F,(x,y),(1,1)) +
+ ... (c-(a+b2+1)*y)*diff(F,(x,y),(0,1)) -
+ ... b2*x*diff(F,(x,y),(1,0)) -
+ ... a*b2*F(x,y))
+ 0.0
+
+The Appell F1 function allows for closed-form evaluation of various
+integrals, such as any integral of the form
+`\int x^r (x+a)^p (x+b)^q dx`::
+
+ >>> def integral(a,b,p,q,r,x1,x2):
+ ... a,b,p,q,r,x1,x2 = map(mpmathify, [a,b,p,q,r,x1,x2])
+ ... f = lambda x: x**r * (x+a)**p * (x+b)**q
+ ... def F(x):
+ ... v = x**(r+1)/(r+1) * (a+x)**p * (b+x)**q
+ ... v *= (1+x/a)**(-p)
+ ... v *= (1+x/b)**(-q)
+ ... v *= appellf1(r+1,-p,-q,2+r,-x/a,-x/b)
+ ... return v
+ ... print("Num. quad: %s" % quad(f, [x1,x2]))
+ ... print("Appell F1: %s" % (F(x2)-F(x1)))
+ ...
+ >>> integral('1/5','4/3','-2','3','1/2',0,1)
+ Num. quad: 9.073335358785776206576981
+ Appell F1: 9.073335358785776206576981
+ >>> integral('3/2','4/3','-2','3','1/2',0,1)
+ Num. quad: 1.092829171999626454344678
+ Appell F1: 1.092829171999626454344678
+ >>> integral('3/2','4/3','-2','3','1/2',12,25)
+ Num. quad: 1106.323225040235116498927
+ Appell F1: 1106.323225040235116498927
+
+Also incomplete elliptic integrals fall into this category [1]::
+
+ >>> def E(z, m):
+ ... if (pi/2).ae(z):
+ ... return ellipe(m)
+ ... return 2*round(re(z)/pi)*ellipe(m) + mpf(-1)**round(re(z)/pi)*\
+ ... sin(z)*appellf1(0.5,0.5,-0.5,1.5,sin(z)**2,m*sin(z)**2)
+ ...
+ >>> z, m = 1, 0.5
+ >>> E(z,m); quad(lambda t: sqrt(1-m*sin(t)**2), [0,pi/4,3*pi/4,z])
+ 0.9273298836244400669659042
+ 0.9273298836244400669659042
+ >>> z, m = 3, 2
+ >>> E(z,m); quad(lambda t: sqrt(1-m*sin(t)**2), [0,pi/4,3*pi/4,z])
+ (1.057495752337234229715836 + 1.198140234735592207439922j)
+ (1.057495752337234229715836 + 1.198140234735592207439922j)
+
+**References**
+
+1. [WolframFunctions]_ http://functions.wolfram.com/EllipticIntegrals/EllipticE2/26/01/
+2. [SrivastavaKarlsson]_
+3. [CabralRosetti]_
+4. [Vidunas]_
+5. [Slater]_
+
+"""
+
+angerj = r"""
+Gives the Anger function
+
+.. math ::
+
+ \mathbf{J}_{\nu}(z) = \frac{1}{\pi}
+ \int_0^{\pi} \cos(\nu t - z \sin t) dt
+
+which is an entire function of both the parameter `\nu` and
+the argument `z`. It solves the inhomogeneous Bessel differential
+equation
+
+.. math ::
+
+ f''(z) + \frac{1}{z}f'(z) + \left(1-\frac{\nu^2}{z^2}\right) f(z)
+ = \frac{(z-\nu)}{\pi z^2} \sin(\pi \nu).
+
+**Examples**
+
+Evaluation for real and complex parameter and argument::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> angerj(2,3)
+ 0.4860912605858910769078311
+ >>> angerj(-3+4j, 2+5j)
+ (-5033.358320403384472395612 + 585.8011892476145118551756j)
+ >>> angerj(3.25, 1e6j)
+ (4.630743639715893346570743e+434290 - 1.117960409887505906848456e+434291j)
+ >>> angerj(-1.5, 1e6)
+ 0.0002795719747073879393087011
+
+The Anger function coincides with the Bessel J-function when `\nu`
+is an integer::
+
+ >>> angerj(1,3); besselj(1,3)
+ 0.3390589585259364589255146
+ 0.3390589585259364589255146
+ >>> angerj(1.5,3); besselj(1.5,3)
+ 0.4088969848691080859328847
+ 0.4777182150870917715515015
+
+Verifying the differential equation::
+
+ >>> v,z = mpf(2.25), 0.75
+ >>> f = lambda z: angerj(v,z)
+ >>> diff(f,z,2) + diff(f,z)/z + (1-(v/z)**2)*f(z)
+ -0.6002108774380707130367995
+ >>> (z-v)/(pi*z**2) * sinpi(v)
+ -0.6002108774380707130367995
+
+Verifying the integral representation::
+
+ >>> angerj(v,z)
+ 0.1145380759919333180900501
+ >>> quad(lambda t: cos(v*t-z*sin(t))/pi, [0,pi])
+ 0.1145380759919333180900501
+
+**References**
+
+1. [DLMF]_ section 11.10: Anger-Weber Functions
+"""
+
+webere = r"""
+Gives the Weber function
+
+.. math ::
+
+ \mathbf{E}_{\nu}(z) = \frac{1}{\pi}
+ \int_0^{\pi} \sin(\nu t - z \sin t) dt
+
+which is an entire function of both the parameter `\nu` and
+the argument `z`. It solves the inhomogeneous Bessel differential
+equation
+
+.. math ::
+
+ f''(z) + \frac{1}{z}f'(z) + \left(1-\frac{\nu^2}{z^2}\right) f(z)
+ = -\frac{1}{\pi z^2} (z+\nu+(z-\nu)\cos(\pi \nu)).
+
+**Examples**
+
+Evaluation for real and complex parameter and argument::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> webere(2,3)
+ -0.1057668973099018425662646
+ >>> webere(-3+4j, 2+5j)
+ (-585.8081418209852019290498 - 5033.314488899926921597203j)
+ >>> webere(3.25, 1e6j)
+ (-1.117960409887505906848456e+434291 - 4.630743639715893346570743e+434290j)
+ >>> webere(3.25, 1e6)
+ -0.00002812518265894315604914453
+
+Up to addition of a rational function of `z`, the Weber function coincides
+with the Struve H-function when `\nu` is an integer::
+
+ >>> webere(1,3); 2/pi-struveh(1,3)
+ -0.3834897968188690177372881
+ -0.3834897968188690177372881
+ >>> webere(5,3); 26/(35*pi)-struveh(5,3)
+ 0.2009680659308154011878075
+ 0.2009680659308154011878075
+
+Verifying the differential equation::
+
+ >>> v,z = mpf(2.25), 0.75
+ >>> f = lambda z: webere(v,z)
+ >>> diff(f,z,2) + diff(f,z)/z + (1-(v/z)**2)*f(z)
+ -1.097441848875479535164627
+ >>> -(z+v+(z-v)*cospi(v))/(pi*z**2)
+ -1.097441848875479535164627
+
+Verifying the integral representation::
+
+ >>> webere(v,z)
+ 0.1486507351534283744485421
+ >>> quad(lambda t: sin(v*t-z*sin(t))/pi, [0,pi])
+ 0.1486507351534283744485421
+
+**References**
+
+1. [DLMF]_ section 11.10: Anger-Weber Functions
+"""
+
+lommels1 = r"""
+Gives the Lommel function `s_{\mu,\nu}` or `s^{(1)}_{\mu,\nu}`
+
+.. math ::
+
+ s_{\mu,\nu}(z) = \frac{z^{\mu+1}}{(\mu-\nu+1)(\mu+\nu+1)}
+ \,_1F_2\left(1; \frac{\mu-\nu+3}{2}, \frac{\mu+\nu+3}{2};
+ -\frac{z^2}{4} \right)
+
+which solves the inhomogeneous Bessel equation
+
+.. math ::
+
+ z^2 f''(z) + z f'(z) + (z^2-\nu^2) f(z) = z^{\mu+1}.
+
+A second solution is given by :func:`~mpmath.lommels2`.
+
+**Plots**
+
+.. literalinclude :: /plots/lommels1.py
+.. image :: /plots/lommels1.png
+
+**Examples**
+
+An integral representation::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> u,v,z = 0.25, 0.125, mpf(0.75)
+ >>> lommels1(u,v,z)
+ 0.4276243877565150372999126
+ >>> (bessely(v,z)*quad(lambda t: t**u*besselj(v,t), [0,z]) - \
+ ... besselj(v,z)*quad(lambda t: t**u*bessely(v,t), [0,z]))*(pi/2)
+ 0.4276243877565150372999126
+
+A special value::
+
+ >>> lommels1(v,v,z)
+ 0.5461221367746048054932553
+ >>> gamma(v+0.5)*sqrt(pi)*power(2,v-1)*struveh(v,z)
+ 0.5461221367746048054932553
+
+Verifying the differential equation::
+
+ >>> f = lambda z: lommels1(u,v,z)
+ >>> z**2*diff(f,z,2) + z*diff(f,z) + (z**2-v**2)*f(z)
+ 0.6979536443265746992059141
+ >>> z**(u+1)
+ 0.6979536443265746992059141
+
+**References**
+
+1. [GradshteynRyzhik]_
+2. [Weisstein]_ http://mathworld.wolfram.com/LommelFunction.html
+"""
+
+lommels2 = r"""
+Gives the second Lommel function `S_{\mu,\nu}` or `s^{(2)}_{\mu,\nu}`
+
+.. math ::
+
+ S_{\mu,\nu}(z) = s_{\mu,\nu}(z) + 2^{\mu-1}
+ \Gamma\left(\tfrac{1}{2}(\mu-\nu+1)\right)
+ \Gamma\left(\tfrac{1}{2}(\mu+\nu+1)\right) \times
+
+ \left[\sin(\tfrac{1}{2}(\mu-\nu)\pi) J_{\nu}(z) -
+ \cos(\tfrac{1}{2}(\mu-\nu)\pi) Y_{\nu}(z)
+ \right]
+
+which solves the same differential equation as
+:func:`~mpmath.lommels1`.
+
+**Plots**
+
+.. literalinclude :: /plots/lommels2.py
+.. image :: /plots/lommels2.png
+
+**Examples**
+
+For large `|z|`, `S_{\mu,\nu} \sim z^{\mu-1}`::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> lommels2(10,2,30000)
+ 1.968299831601008419949804e+40
+ >>> power(30000,9)
+ 1.9683e+40
+
+A special value::
+
+ >>> u,v,z = 0.5, 0.125, mpf(0.75)
+ >>> lommels2(v,v,z)
+ 0.9589683199624672099969765
+ >>> (struveh(v,z)-bessely(v,z))*power(2,v-1)*sqrt(pi)*gamma(v+0.5)
+ 0.9589683199624672099969765
+
+Verifying the differential equation::
+
+ >>> f = lambda z: lommels2(u,v,z)
+ >>> z**2*diff(f,z,2) + z*diff(f,z) + (z**2-v**2)*f(z)
+ 0.6495190528383289850727924
+ >>> z**(u+1)
+ 0.6495190528383289850727924
+
+**References**
+
+1. [GradshteynRyzhik]_
+2. [Weisstein]_ http://mathworld.wolfram.com/LommelFunction.html
+"""
+
+appellf2 = r"""
+Gives the Appell F2 hypergeometric function of two variables
+
+.. math ::
+
+ F_2(a,b_1,b_2,c_1,c_2,x,y) = \sum_{m=0}^{\infty} \sum_{n=0}^{\infty}
+ \frac{(a)_{m+n} (b_1)_m (b_2)_n}{(c_1)_m (c_2)_n}
+ \frac{x^m y^n}{m! n!}.
+
+The series is generally absolutely convergent for `|x| + |y| < 1`.
+
+**Examples**
+
+Evaluation for real and complex arguments::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> appellf2(1,2,3,4,5,0.25,0.125)
+ 1.257417193533135344785602
+ >>> appellf2(1,-3,-4,2,3,2,3)
+ -42.8
+ >>> appellf2(0.5,0.25,-0.25,2,3,0.25j,0.25)
+ (0.9880539519421899867041719 + 0.01497616165031102661476978j)
+ >>> chop(appellf2(1,1+j,1-j,3j,-3j,0.25,0.25))
+ 1.201311219287411337955192
+ >>> appellf2(1,1,1,4,6,0.125,16)
+ (-0.09455532250274744282125152 - 0.7647282253046207836769297j)
+
+A transformation formula::
+
+ >>> a,b1,b2,c1,c2,x,y = map(mpf, [1,2,0.5,0.25,1.625,-0.125,0.125])
+ >>> appellf2(a,b1,b2,c1,c2,x,y)
+ 0.2299211717841180783309688
+ >>> (1-x)**(-a)*appellf2(a,c1-b1,b2,c1,c2,x/(x-1),y/(1-x))
+ 0.2299211717841180783309688
+
+A system of partial differential equations satisfied by F2::
+
+ >>> a,b1,b2,c1,c2,x,y = map(mpf, [1,0.5,0.25,1.125,1.5,0.0625,-0.0625])
+ >>> F = lambda x,y: appellf2(a,b1,b2,c1,c2,x,y)
+ >>> chop(x*(1-x)*diff(F,(x,y),(2,0)) -
+ ... x*y*diff(F,(x,y),(1,1)) +
+ ... (c1-(a+b1+1)*x)*diff(F,(x,y),(1,0)) -
+ ... b1*y*diff(F,(x,y),(0,1)) -
+ ... a*b1*F(x,y))
+ 0.0
+ >>> chop(y*(1-y)*diff(F,(x,y),(0,2)) -
+ ... x*y*diff(F,(x,y),(1,1)) +
+ ... (c2-(a+b2+1)*y)*diff(F,(x,y),(0,1)) -
+ ... b2*x*diff(F,(x,y),(1,0)) -
+ ... a*b2*F(x,y))
+ 0.0
+
+**References**
+
+See references for :func:`~mpmath.appellf1`.
+"""
+
+appellf3 = r"""
+Gives the Appell F3 hypergeometric function of two variables
+
+.. math ::
+
+ F_3(a_1,a_2,b_1,b_2,c,x,y) = \sum_{m=0}^{\infty} \sum_{n=0}^{\infty}
+ \frac{(a_1)_m (a_2)_n (b_1)_m (b_2)_n}{(c)_{m+n}}
+ \frac{x^m y^n}{m! n!}.
+
+The series is generally absolutely convergent for `|x| < 1, |y| < 1`.
+
+**Examples**
+
+Evaluation for various parameters and variables::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> appellf3(1,2,3,4,5,0.5,0.25)
+ 2.221557778107438938158705
+ >>> appellf3(1,2,3,4,5,6,0); hyp2f1(1,3,5,6)
+ (-0.5189554589089861284537389 - 0.1454441043328607980769742j)
+ (-0.5189554589089861284537389 - 0.1454441043328607980769742j)
+ >>> appellf3(1,-2,-3,1,1,4,6)
+ -17.4
+ >>> appellf3(1,2,-3,1,1,4,6)
+ (17.7876136773677356641825 + 19.54768762233649126154534j)
+ >>> appellf3(1,2,-3,1,1,6,4)
+ (85.02054175067929402953645 + 148.4402528821177305173599j)
+ >>> chop(appellf3(1+j,2,1-j,2,3,0.25,0.25))
+ 1.719992169545200286696007
+
+Many transformations and evaluations for special combinations
+of the parameters are possible, e.g.:
+
+ >>> a,b,c,x,y = map(mpf, [0.5,0.25,0.125,0.125,-0.125])
+ >>> appellf3(a,c-a,b,c-b,c,x,y)
+ 1.093432340896087107444363
+ >>> (1-y)**(a+b-c)*hyp2f1(a,b,c,x+y-x*y)
+ 1.093432340896087107444363
+ >>> x**2*appellf3(1,1,1,1,3,x,-x)
+ 0.01568646277445385390945083
+ >>> polylog(2,x**2)
+ 0.01568646277445385390945083
+ >>> a1,a2,b1,b2,c,x = map(mpf, [0.5,0.25,0.125,0.5,4.25,0.125])
+ >>> appellf3(a1,a2,b1,b2,c,x,1)
+ 1.03947361709111140096947
+ >>> gammaprod([c,c-a2-b2],[c-a2,c-b2])*hyp3f2(a1,b1,c-a2-b2,c-a2,c-b2,x)
+ 1.03947361709111140096947
+
+The Appell F3 function satisfies a pair of partial
+differential equations::
+
+ >>> a1,a2,b1,b2,c,x,y = map(mpf, [0.5,0.25,0.125,0.5,0.625,0.0625,-0.0625])
+ >>> F = lambda x,y: appellf3(a1,a2,b1,b2,c,x,y)
+ >>> chop(x*(1-x)*diff(F,(x,y),(2,0)) +
+ ... y*diff(F,(x,y),(1,1)) +
+ ... (c-(a1+b1+1)*x)*diff(F,(x,y),(1,0)) -
+ ... a1*b1*F(x,y))
+ 0.0
+ >>> chop(y*(1-y)*diff(F,(x,y),(0,2)) +
+ ... x*diff(F,(x,y),(1,1)) +
+ ... (c-(a2+b2+1)*y)*diff(F,(x,y),(0,1)) -
+ ... a2*b2*F(x,y))
+ 0.0
+
+**References**
+
+See references for :func:`~mpmath.appellf1`.
+"""
+
+appellf4 = r"""
+Gives the Appell F4 hypergeometric function of two variables
+
+.. math ::
+
+ F_4(a,b,c_1,c_2,x,y) = \sum_{m=0}^{\infty} \sum_{n=0}^{\infty}
+ \frac{(a)_{m+n} (b)_{m+n}}{(c_1)_m (c_2)_n}
+ \frac{x^m y^n}{m! n!}.
+
+The series is generally absolutely convergent for
+`\sqrt{|x|} + \sqrt{|y|} < 1`.
+
+**Examples**
+
+Evaluation for various parameters and arguments::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> appellf4(1,1,2,2,0.25,0.125)
+ 1.286182069079718313546608
+ >>> appellf4(-2,-3,4,5,4,5)
+ 34.8
+ >>> appellf4(5,4,2,3,0.25j,-0.125j)
+ (-0.2585967215437846642163352 + 2.436102233553582711818743j)
+
+Reduction to `\,_2F_1` in a special case::
+
+ >>> a,b,c,x,y = map(mpf, [0.5,0.25,0.125,0.125,-0.125])
+ >>> appellf4(a,b,c,a+b-c+1,x*(1-y),y*(1-x))
+ 1.129143488466850868248364
+ >>> hyp2f1(a,b,c,x)*hyp2f1(a,b,a+b-c+1,y)
+ 1.129143488466850868248364
+
+A system of partial differential equations satisfied by F4::
+
+ >>> a,b,c1,c2,x,y = map(mpf, [1,0.5,0.25,1.125,0.0625,-0.0625])
+ >>> F = lambda x,y: appellf4(a,b,c1,c2,x,y)
+ >>> chop(x*(1-x)*diff(F,(x,y),(2,0)) -
+ ... y**2*diff(F,(x,y),(0,2)) -
+ ... 2*x*y*diff(F,(x,y),(1,1)) +
+ ... (c1-(a+b+1)*x)*diff(F,(x,y),(1,0)) -
+ ... ((a+b+1)*y)*diff(F,(x,y),(0,1)) -
+ ... a*b*F(x,y))
+ 0.0
+ >>> chop(y*(1-y)*diff(F,(x,y),(0,2)) -
+ ... x**2*diff(F,(x,y),(2,0)) -
+ ... 2*x*y*diff(F,(x,y),(1,1)) +
+ ... (c2-(a+b+1)*y)*diff(F,(x,y),(0,1)) -
+ ... ((a+b+1)*x)*diff(F,(x,y),(1,0)) -
+ ... a*b*F(x,y))
+ 0.0
+
+**References**
+
+See references for :func:`~mpmath.appellf1`.
+"""
+
+zeta = r"""
+Computes the Riemann zeta function
+
+.. math ::
+
+ \zeta(s) = 1+\frac{1}{2^s}+\frac{1}{3^s}+\frac{1}{4^s}+\ldots
+
+or, with `a \ne 1`, the more general Hurwitz zeta function
+
+.. math ::
+
+ \zeta(s,a) = \sum_{k=0}^\infty \frac{1}{(a+k)^s}.
+
+Optionally, ``zeta(s, a, n)`` computes the `n`-th derivative with
+respect to `s`,
+
+.. math ::
+
+ \zeta^{(n)}(s,a) = (-1)^n \sum_{k=0}^\infty \frac{\log^n(a+k)}{(a+k)^s}.
+
+Although these series only converge for `\Re(s) > 1`, the Riemann and Hurwitz
+zeta functions are defined through analytic continuation for arbitrary
+complex `s \ne 1` (`s = 1` is a pole).
+
+The implementation uses three algorithms: the Borwein algorithm for
+the Riemann zeta function when `s` is close to the real line;
+the Riemann-Siegel formula for the Riemann zeta function when `s` is
+large imaginary, and Euler-Maclaurin summation in all other cases.
+The reflection formula for `\Re(s) < 0` is implemented in some cases.
+The algorithm can be chosen with ``method = 'borwein'``,
+``method='riemann-siegel'`` or ``method = 'euler-maclaurin'``.
+
+The parameter `a` is usually a rational number `a = p/q`, and may be specified
+as such by passing an integer tuple `(p, q)`. Evaluation is supported for
+arbitrary complex `a`, but may be slow and/or inaccurate when `\Re(s) < 0` for
+nonrational `a` or when computing derivatives.
+
+**Examples**
+
+Some values of the Riemann zeta function::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> zeta(2); pi**2 / 6
+ 1.644934066848226436472415
+ 1.644934066848226436472415
+ >>> zeta(0)
+ -0.5
+ >>> zeta(-1)
+ -0.08333333333333333333333333
+ >>> zeta(-2)
+ 0.0
+
+For large positive `s`, `\zeta(s)` rapidly approaches 1::
+
+ >>> zeta(50)
+ 1.000000000000000888178421
+ >>> zeta(100)
+ 1.0
+ >>> zeta(inf)
+ 1.0
+ >>> 1-sum((zeta(k)-1)/k for k in range(2,85)); +euler
+ 0.5772156649015328606065121
+ 0.5772156649015328606065121
+ >>> nsum(lambda k: zeta(k)-1, [2, inf])
+ 1.0
+
+Evaluation is supported for complex `s` and `a`:
+
+ >>> zeta(-3+4j)
+ (-0.03373057338827757067584698 + 0.2774499251557093745297677j)
+ >>> zeta(2+3j, -1+j)
+ (389.6841230140842816370741 + 295.2674610150305334025962j)
+
+The Riemann zeta function has so-called nontrivial zeros on
+the critical line `s = 1/2 + it`::
+
+ >>> findroot(zeta, 0.5+14j); zetazero(1)
+ (0.5 + 14.13472514173469379045725j)
+ (0.5 + 14.13472514173469379045725j)
+ >>> findroot(zeta, 0.5+21j); zetazero(2)
+ (0.5 + 21.02203963877155499262848j)
+ (0.5 + 21.02203963877155499262848j)
+ >>> findroot(zeta, 0.5+25j); zetazero(3)
+ (0.5 + 25.01085758014568876321379j)
+ (0.5 + 25.01085758014568876321379j)
+ >>> chop(zeta(zetazero(10)))
+ 0.0
+
+Evaluation on and near the critical line is supported for large
+heights `t` by means of the Riemann-Siegel formula (currently
+for `a = 1`, `n \le 4`)::
+
+ >>> zeta(0.5+100000j)
+ (1.073032014857753132114076 + 5.780848544363503984261041j)
+ >>> zeta(0.75+1000000j)
+ (0.9535316058375145020351559 + 0.9525945894834273060175651j)
+ >>> zeta(0.5+10000000j)
+ (11.45804061057709254500227 - 8.643437226836021723818215j)
+ >>> zeta(0.5+100000000j, derivative=1)
+ (51.12433106710194942681869 + 43.87221167872304520599418j)
+ >>> zeta(0.5+100000000j, derivative=2)
+ (-444.2760822795430400549229 - 896.3789978119185981665403j)
+ >>> zeta(0.5+100000000j, derivative=3)
+ (3230.72682687670422215339 + 14374.36950073615897616781j)
+ >>> zeta(0.5+100000000j, derivative=4)
+ (-11967.35573095046402130602 - 218945.7817789262839266148j)
+ >>> zeta(1+10000000j) # off the line
+ (2.859846483332530337008882 + 0.491808047480981808903986j)
+ >>> zeta(1+10000000j, derivative=1)
+ (-4.333835494679647915673205 - 0.08405337962602933636096103j)
+ >>> zeta(1+10000000j, derivative=4)
+ (453.2764822702057701894278 - 581.963625832768189140995j)
+
+For investigation of the zeta function zeros, the Riemann-Siegel
+Z-function is often more convenient than working with the Riemann
+zeta function directly (see :func:`~mpmath.siegelz`).
+
+Some values of the Hurwitz zeta function::
+
+ >>> zeta(2, 3); -5./4 + pi**2/6
+ 0.3949340668482264364724152
+ 0.3949340668482264364724152
+ >>> zeta(2, (3,4)); pi**2 - 8*catalan
+ 2.541879647671606498397663
+ 2.541879647671606498397663
+
+For positive integer values of `s`, the Hurwitz zeta function is
+equivalent to a polygamma function (except for a normalizing factor)::
+
+ >>> zeta(4, (1,5)); psi(3, '1/5')/6
+ 625.5408324774542966919938
+ 625.5408324774542966919938
+
+Evaluation of derivatives::
+
+ >>> zeta(0, 3+4j, 1); loggamma(3+4j) - ln(2*pi)/2
+ (-2.675565317808456852310934 + 4.742664438034657928194889j)
+ (-2.675565317808456852310934 + 4.742664438034657928194889j)
+ >>> zeta(2, 1, 20)
+ 2432902008176640000.000242
+ >>> zeta(3+4j, 5.5+2j, 4)
+ (-0.140075548947797130681075 - 0.3109263360275413251313634j)
+ >>> zeta(0.5+100000j, 1, 4)
+ (-10407.16081931495861539236 + 13777.78669862804508537384j)
+ >>> zeta(-100+0.5j, (1,3), derivative=4)
+ (4.007180821099823942702249e+79 + 4.916117957092593868321778e+78j)
+
+Generating a Taylor series at `s = 2` using derivatives::
+
+ >>> for k in range(11): print("%s * (s-2)^%i" % (zeta(2,1,k)/fac(k), k))
+ ...
+ 1.644934066848226436472415 * (s-2)^0
+ -0.9375482543158437537025741 * (s-2)^1
+ 0.9946401171494505117104293 * (s-2)^2
+ -1.000024300473840810940657 * (s-2)^3
+ 1.000061933072352565457512 * (s-2)^4
+ -1.000006869443931806408941 * (s-2)^5
+ 1.000000173233769531820592 * (s-2)^6
+ -0.9999999569989868493432399 * (s-2)^7
+ 0.9999999937218844508684206 * (s-2)^8
+ -0.9999999996355013916608284 * (s-2)^9
+ 1.000000000004610645020747 * (s-2)^10
+
+Evaluation at zero and for negative integer `s`::
+
+ >>> zeta(0, 10)
+ -9.5
+ >>> zeta(-2, (2,3)); mpf(1)/81
+ 0.01234567901234567901234568
+ 0.01234567901234567901234568
+ >>> zeta(-3+4j, (5,4))
+ (0.2899236037682695182085988 + 0.06561206166091757973112783j)
+ >>> zeta(-3.25, 1/pi)
+ -0.0005117269627574430494396877
+ >>> zeta(-3.5, pi, 1)
+ 11.156360390440003294709
+ >>> zeta(-100.5, (8,3))
+ -4.68162300487989766727122e+77
+ >>> zeta(-10.5, (-8,3))
+ (-0.01521913704446246609237979 + 29907.72510874248161608216j)
+ >>> zeta(-1000.5, (-8,3))
+ (1.031911949062334538202567e+1770 + 1.519555750556794218804724e+426j)
+ >>> zeta(-1+j, 3+4j)
+ (-16.32988355630802510888631 - 22.17706465801374033261383j)
+ >>> zeta(-1+j, 3+4j, 2)
+ (32.48985276392056641594055 - 51.11604466157397267043655j)
+ >>> diff(lambda s: zeta(s, 3+4j), -1+j, 2)
+ (32.48985276392056641594055 - 51.11604466157397267043655j)
+
+**References**
+
+1. http://mathworld.wolfram.com/RiemannZetaFunction.html
+
+2. http://mathworld.wolfram.com/HurwitzZetaFunction.html
+
+3. [BorweinZeta]_
+
+"""
+
+dirichlet = r"""
+Evaluates the Dirichlet L-function
+
+.. math ::
+
+ L(s,\chi) = \sum_{k=1}^\infty \frac{\chi(k)}{k^s}.
+
+where `\chi` is a periodic sequence of length `q` which should be supplied
+in the form of a list `[\chi(0), \chi(1), \ldots, \chi(q-1)]`.
+Strictly, `\chi` should be a Dirichlet character, but any periodic
+sequence will work.
+
+For example, ``dirichlet(s, [1])`` gives the ordinary
+Riemann zeta function and ``dirichlet(s, [-1,1])`` gives
+the alternating zeta function (Dirichlet eta function).
+
+Also the derivative with respect to `s` (currently only a first
+derivative) can be evaluated.
+
+**Examples**
+
+The ordinary Riemann zeta function::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> dirichlet(3, [1]); zeta(3)
+ 1.202056903159594285399738
+ 1.202056903159594285399738
+ >>> dirichlet(1, [1])
+ +inf
+
+The alternating zeta function::
+
+ >>> dirichlet(1, [-1,1]); ln(2)
+ 0.6931471805599453094172321
+ 0.6931471805599453094172321
+
+The following defines the Dirichlet beta function
+`\beta(s) = \sum_{k=0}^\infty \frac{(-1)^k}{(2k+1)^s}` and verifies
+several values of this function::
+
+ >>> B = lambda s, d=0: dirichlet(s, [0, 1, 0, -1], d)
+ >>> B(0); 1./2
+ 0.5
+ 0.5
+ >>> B(1); pi/4
+ 0.7853981633974483096156609
+ 0.7853981633974483096156609
+ >>> B(2); +catalan
+ 0.9159655941772190150546035
+ 0.9159655941772190150546035
+ >>> B(2,1); diff(B, 2)
+ 0.08158073611659279510291217
+ 0.08158073611659279510291217
+ >>> B(-1,1); 2*catalan/pi
+ 0.5831218080616375602767689
+ 0.5831218080616375602767689
+ >>> B(0,1); log(gamma(0.25)**2/(2*pi*sqrt(2)))
+ 0.3915943927068367764719453
+ 0.3915943927068367764719454
+ >>> B(1,1); 0.25*pi*(euler+2*ln2+3*ln(pi)-4*ln(gamma(0.25)))
+ 0.1929013167969124293631898
+ 0.1929013167969124293631898
+
+A custom L-series of period 3::
+
+ >>> dirichlet(2, [2,0,1])
+ 0.7059715047839078092146831
+ >>> 2*nsum(lambda k: (3*k)**-2, [1,inf]) + \
+ ... nsum(lambda k: (3*k+2)**-2, [0,inf])
+ 0.7059715047839078092146831
+
+"""
+
+coulombf = r"""
+Calculates the regular Coulomb wave function
+
+.. math ::
+
+ F_l(\eta,z) = C_l(\eta) z^{l+1} e^{-iz} \,_1F_1(l+1-i\eta, 2l+2, 2iz)
+
+where the normalization constant `C_l(\eta)` is as calculated by
+:func:`~mpmath.coulombc`. This function solves the differential equation
+
+.. math ::
+
+ f''(z) + \left(1-\frac{2\eta}{z}-\frac{l(l+1)}{z^2}\right) f(z) = 0.
+
+A second linearly independent solution is given by the irregular
+Coulomb wave function `G_l(\eta,z)` (see :func:`~mpmath.coulombg`)
+and thus the general solution is
+`f(z) = C_1 F_l(\eta,z) + C_2 G_l(\eta,z)` for arbitrary
+constants `C_1`, `C_2`.
+Physically, the Coulomb wave functions give the radial solution
+to the Schrodinger equation for a point particle in a `1/z` potential; `z` is
+then the radius and `l`, `\eta` are quantum numbers.
+
+The Coulomb wave functions with real parameters are defined
+in Abramowitz & Stegun, section 14. However, all parameters are permitted
+to be complex in this implementation (see references).
+
+**Plots**
+
+.. literalinclude :: /plots/coulombf.py
+.. image :: /plots/coulombf.png
+.. literalinclude :: /plots/coulombf_c.py
+.. image :: /plots/coulombf_c.png
+
+**Examples**
+
+Evaluation is supported for arbitrary magnitudes of `z`::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> coulombf(2, 1.5, 3.5)
+ 0.4080998961088761187426445
+ >>> coulombf(-2, 1.5, 3.5)
+ 0.7103040849492536747533465
+ >>> coulombf(2, 1.5, '1e-10')
+ 4.143324917492256448770769e-33
+ >>> coulombf(2, 1.5, 1000)
+ 0.4482623140325567050716179
+ >>> coulombf(2, 1.5, 10**10)
+ -0.066804196437694360046619
+
+Verifying the differential equation::
+
+ >>> l, eta, z = 2, 3, mpf(2.75)
+ >>> A, B = 1, 2
+ >>> f = lambda z: A*coulombf(l,eta,z) + B*coulombg(l,eta,z)
+ >>> chop(diff(f,z,2) + (1-2*eta/z - l*(l+1)/z**2)*f(z))
+ 0.0
+
+A Wronskian relation satisfied by the Coulomb wave functions::
+
+ >>> l = 2
+ >>> eta = 1.5
+ >>> F = lambda z: coulombf(l,eta,z)
+ >>> G = lambda z: coulombg(l,eta,z)
+ >>> for z in [3.5, -1, 2+3j]:
+ ... chop(diff(F,z)*G(z) - F(z)*diff(G,z))
+ ...
+ 1.0
+ 1.0
+ 1.0
+
+Another Wronskian relation::
+
+ >>> F = coulombf
+ >>> G = coulombg
+ >>> for z in [3.5, -1, 2+3j]:
+ ... chop(F(l-1,eta,z)*G(l,eta,z)-F(l,eta,z)*G(l-1,eta,z) - l/sqrt(l**2+eta**2))
+ ...
+ 0.0
+ 0.0
+ 0.0
+
+An integral identity connecting the regular and irregular wave functions::
+
+ >>> l, eta, z = 4+j, 2-j, 5+2j
+ >>> coulombf(l,eta,z) + j*coulombg(l,eta,z)
+ (0.7997977752284033239714479 + 0.9294486669502295512503127j)
+ >>> g = lambda t: exp(-t)*t**(l-j*eta)*(t+2*j*z)**(l+j*eta)
+ >>> j*exp(-j*z)*z**(-l)/fac(2*l+1)/coulombc(l,eta)*quad(g, [0,inf])
+ (0.7997977752284033239714479 + 0.9294486669502295512503127j)
+
+Some test case with complex parameters, taken from Michel [2]::
+
+ >>> mp.dps = 15
+ >>> coulombf(1+0.1j, 50+50j, 100.156)
+ (-1.02107292320897e+15 - 2.83675545731519e+15j)
+ >>> coulombg(1+0.1j, 50+50j, 100.156)
+ (2.83675545731519e+15 - 1.02107292320897e+15j)
+ >>> coulombf(1e-5j, 10+1e-5j, 0.1+1e-6j)
+ (4.30566371247811e-14 - 9.03347835361657e-19j)
+ >>> coulombg(1e-5j, 10+1e-5j, 0.1+1e-6j)
+ (778709182061.134 + 18418936.2660553j)
+
+The following reproduces a table in Abramowitz & Stegun, at twice
+the precision::
+
+ >>> mp.dps = 10
+ >>> eta = 2; z = 5
+ >>> for l in [5, 4, 3, 2, 1, 0]:
+ ... print("%s %s %s" % (l, coulombf(l,eta,z),
+ ... diff(lambda z: coulombf(l,eta,z), z)))
+ ...
+ 5 0.09079533488 0.1042553261
+ 4 0.2148205331 0.2029591779
+ 3 0.4313159311 0.320534053
+ 2 0.7212774133 0.3952408216
+ 1 0.9935056752 0.3708676452
+ 0 1.143337392 0.2937960375
+
+**References**
+
+1. I.J. Thompson & A.R. Barnett, "Coulomb and Bessel Functions of Complex
+ Arguments and Order", J. Comp. Phys., vol 64, no. 2, June 1986.
+
+2. N. Michel, "Precise Coulomb wave functions for a wide range of
+ complex `l`, `\eta` and `z`", http://arxiv.org/abs/physics/0702051v1
+
+"""
+
+coulombg = r"""
+Calculates the irregular Coulomb wave function
+
+.. math ::
+
+ G_l(\eta,z) = \frac{F_l(\eta,z) \cos(\chi) - F_{-l-1}(\eta,z)}{\sin(\chi)}
+
+where `\chi = \sigma_l - \sigma_{-l-1} - (l+1/2) \pi`
+and `\sigma_l(\eta) = (\ln \Gamma(1+l+i\eta)-\ln \Gamma(1+l-i\eta))/(2i)`.
+
+See :func:`~mpmath.coulombf` for additional information.
+
+**Plots**
+
+.. literalinclude :: /plots/coulombg.py
+.. image :: /plots/coulombg.png
+.. literalinclude :: /plots/coulombg_c.py
+.. image :: /plots/coulombg_c.png
+
+**Examples**
+
+Evaluation is supported for arbitrary magnitudes of `z`::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> coulombg(-2, 1.5, 3.5)
+ 1.380011900612186346255524
+ >>> coulombg(2, 1.5, 3.5)
+ 1.919153700722748795245926
+ >>> coulombg(-2, 1.5, '1e-10')
+ 201126715824.7329115106793
+ >>> coulombg(-2, 1.5, 1000)
+ 0.1802071520691149410425512
+ >>> coulombg(-2, 1.5, 10**10)
+ 0.652103020061678070929794
+
+The following reproduces a table in Abramowitz & Stegun,
+at twice the precision::
+
+ >>> mp.dps = 10
+ >>> eta = 2; z = 5
+ >>> for l in [1, 2, 3, 4, 5]:
+ ... print("%s %s %s" % (l, coulombg(l,eta,z),
+ ... -diff(lambda z: coulombg(l,eta,z), z)))
+ ...
+ 1 1.08148276 0.6028279961
+ 2 1.496877075 0.5661803178
+ 3 2.048694714 0.7959909551
+ 4 3.09408669 1.731802374
+ 5 5.629840456 4.549343289
+
+Evaluation close to the singularity at `z = 0`::
+
+ >>> mp.dps = 15
+ >>> coulombg(0,10,1)
+ 3088184933.67358
+ >>> coulombg(0,10,'1e-10')
+ 5554866000719.8
+ >>> coulombg(0,10,'1e-100')
+ 5554866221524.1
+
+Evaluation with a half-integer value for `l`::
+
+ >>> coulombg(1.5, 1, 10)
+ 0.852320038297334
+"""
+
+coulombc = r"""
+Gives the normalizing Gamow constant for Coulomb wave functions,
+
+.. math ::
+
+ C_l(\eta) = 2^l \exp\left(-\pi \eta/2 + [\ln \Gamma(1+l+i\eta) +
+ \ln \Gamma(1+l-i\eta)]/2 - \ln \Gamma(2l+2)\right),
+
+where the log gamma function with continuous imaginary part
+away from the negative half axis (see :func:`~mpmath.loggamma`) is implied.
+
+This function is used internally for the calculation of
+Coulomb wave functions, and automatically cached to make multiple
+evaluations with fixed `l`, `\eta` fast.
+"""
+
+ellipfun = r"""
+Computes any of the Jacobi elliptic functions, defined
+in terms of Jacobi theta functions as
+
+.. math ::
+
+ \mathrm{sn}(u,m) = \frac{\vartheta_3(0,q)}{\vartheta_2(0,q)}
+ \frac{\vartheta_1(t,q)}{\vartheta_4(t,q)}
+
+ \mathrm{cn}(u,m) = \frac{\vartheta_4(0,q)}{\vartheta_2(0,q)}
+ \frac{\vartheta_2(t,q)}{\vartheta_4(t,q)}
+
+ \mathrm{dn}(u,m) = \frac{\vartheta_4(0,q)}{\vartheta_3(0,q)}
+ \frac{\vartheta_3(t,q)}{\vartheta_4(t,q)},
+
+or more generally computes a ratio of two such functions. Here
+`t = u/\vartheta_3(0,q)^2`, and `q = q(m)` denotes the nome (see
+:func:`~mpmath.nome`). Optionally, you can specify the nome directly
+instead of `m` by passing ``q=``, or you can directly
+specify the elliptic parameter `k` with ``k=``.
+
+The first argument should be a two-character string specifying the
+function using any combination of ``'s'``, ``'c'``, ``'d'``, ``'n'``. These
+letters respectively denote the basic functions
+`\mathrm{sn}(u,m)`, `\mathrm{cn}(u,m)`, `\mathrm{dn}(u,m)`, and `1`.
+The identifier specifies the ratio of two such functions.
+For example, ``'ns'`` identifies the function
+
+.. math ::
+
+ \mathrm{ns}(u,m) = \frac{1}{\mathrm{sn}(u,m)}
+
+and ``'cd'`` identifies the function
+
+.. math ::
+
+ \mathrm{cd}(u,m) = \frac{\mathrm{cn}(u,m)}{\mathrm{dn}(u,m)}.
+
+If called with only the first argument, a function object
+evaluating the chosen function for given arguments is returned.
+
+**Examples**
+
+Basic evaluation::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> ellipfun('cd', 3.5, 0.5)
+ -0.9891101840595543931308394
+ >>> ellipfun('cd', 3.5, q=0.25)
+ 0.07111979240214668158441418
+
+The sn-function is doubly periodic in the complex plane with periods
+`4 K(m)` and `2 i K(1-m)` (see :func:`~mpmath.ellipk`)::
+
+ >>> sn = ellipfun('sn')
+ >>> sn(2, 0.25)
+ 0.9628981775982774425751399
+ >>> sn(2+4*ellipk(0.25), 0.25)
+ 0.9628981775982774425751399
+ >>> chop(sn(2+2*j*ellipk(1-0.25), 0.25))
+ 0.9628981775982774425751399
+
+The cn-function is doubly periodic with periods `4 K(m)` and `2 K(m) + 2 i K(1-m)`::
+
+ >>> cn = ellipfun('cn')
+ >>> cn(2, 0.25)
+ -0.2698649654510865792581416
+ >>> cn(2+4*ellipk(0.25), 0.25)
+ -0.2698649654510865792581416
+ >>> chop(cn(2+2*ellipk(0.25)+2*j*ellipk(1-0.25), 0.25))
+ -0.2698649654510865792581416
+
+The dn-function is doubly periodic with periods `2 K(m)` and `4 i K(1-m)`::
+
+ >>> dn = ellipfun('dn')
+ >>> dn(2, 0.25)
+ 0.8764740583123262286931578
+ >>> dn(2+2*ellipk(0.25), 0.25)
+ 0.8764740583123262286931578
+ >>> chop(dn(2+4*j*ellipk(1-0.25), 0.25))
+ 0.8764740583123262286931578
+
+"""
+
+
+jtheta = r"""
+Computes the Jacobi theta function `\vartheta_n(z, q)`, where
+`n = 1, 2, 3, 4`, defined by the infinite series:
+
+.. math ::
+
+ \vartheta_1(z,q) = 2 q^{1/4} \sum_{n=0}^{\infty}
+ (-1)^n q^{n^2+n\,} \sin((2n+1)z)
+
+ \vartheta_2(z,q) = 2 q^{1/4} \sum_{n=0}^{\infty}
+ q^{n^{2\,} + n} \cos((2n+1)z)
+
+ \vartheta_3(z,q) = 1 + 2 \sum_{n=1}^{\infty}
+ q^{n^2\,} \cos(2 n z)
+
+ \vartheta_4(z,q) = 1 + 2 \sum_{n=1}^{\infty}
+ (-q)^{n^2\,} \cos(2 n z)
+
+The theta functions are functions of two variables:
+
+* `z` is the *argument*, an arbitrary real or complex number
+
+* `q` is the *nome*, which must be a real or complex number
+ in the unit disk (i.e. `|q| < 1`). For `|q| \ll 1`, the
+ series converge very quickly, so the Jacobi theta functions
+ can efficiently be evaluated to high precision.
+
+The compact notations `\vartheta_n(q) = \vartheta_n(0,q)`
+and `\vartheta_n = \vartheta_n(0,q)` are also frequently
+encountered. Finally, Jacobi theta functions are frequently
+considered as functions of the half-period ratio `\tau`
+and then usually denoted by `\vartheta_n(z|\tau)`.
+
+Optionally, ``jtheta(n, z, q, derivative=d)`` with `d > 0` computes
+a `d`-th derivative with respect to `z`.
+
+**Examples and basic properties**
+
+Considered as functions of `z`, the Jacobi theta functions may be
+viewed as generalizations of the ordinary trigonometric functions
+cos and sin. They are periodic functions::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> jtheta(1, 0.25, '0.2')
+ 0.2945120798627300045053104
+ >>> jtheta(1, 0.25 + 2*pi, '0.2')
+ 0.2945120798627300045053104
+
+Indeed, the series defining the theta functions are essentially
+trigonometric Fourier series. The coefficients can be retrieved
+using :func:`~mpmath.fourier`::
+
+ >>> mp.dps = 10
+ >>> nprint(fourier(lambda x: jtheta(2, x, 0.5), [-pi, pi], 4))
+ ([0.0, 1.68179, 0.0, 0.420448, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0])
+
+The Jacobi theta functions are also so-called quasiperiodic
+functions of `z` and `\tau`, meaning that for fixed `\tau`,
+`\vartheta_n(z, q)` and `\vartheta_n(z+\pi \tau, q)` are the same
+except for an exponential factor::
+
+ >>> mp.dps = 25
+ >>> tau = 3*j/10
+ >>> q = exp(pi*j*tau)
+ >>> z = 10
+ >>> jtheta(4, z+tau*pi, q)
+ (-0.682420280786034687520568 + 1.526683999721399103332021j)
+ >>> -exp(-2*j*z)/q * jtheta(4, z, q)
+ (-0.682420280786034687520568 + 1.526683999721399103332021j)
+
+The Jacobi theta functions satisfy a huge number of other
+functional equations, such as the following identity (valid for
+any `q`)::
+
+ >>> q = mpf(3)/10
+ >>> jtheta(3,0,q)**4
+ 6.823744089352763305137427
+ >>> jtheta(2,0,q)**4 + jtheta(4,0,q)**4
+ 6.823744089352763305137427
+
+Extensive listings of identities satisfied by the Jacobi theta
+functions can be found in standard reference works.
+
+The Jacobi theta functions are related to the gamma function
+for special arguments::
+
+ >>> jtheta(3, 0, exp(-pi))
+ 1.086434811213308014575316
+ >>> pi**(1/4.) / gamma(3/4.)
+ 1.086434811213308014575316
+
+:func:`~mpmath.jtheta` supports arbitrary precision evaluation and complex
+arguments::
+
+ >>> mp.dps = 50
+ >>> jtheta(4, sqrt(2), 0.5)
+ 2.0549510717571539127004115835148878097035750653737
+ >>> mp.dps = 25
+ >>> jtheta(4, 1+2j, (1+j)/5)
+ (7.180331760146805926356634 - 1.634292858119162417301683j)
+
+Evaluation of derivatives::
+
+ >>> mp.dps = 25
+ >>> jtheta(1, 7, 0.25, 1); diff(lambda z: jtheta(1, z, 0.25), 7)
+ 1.209857192844475388637236
+ 1.209857192844475388637236
+ >>> jtheta(1, 7, 0.25, 2); diff(lambda z: jtheta(1, z, 0.25), 7, 2)
+ -0.2598718791650217206533052
+ -0.2598718791650217206533052
+ >>> jtheta(2, 7, 0.25, 1); diff(lambda z: jtheta(2, z, 0.25), 7)
+ -1.150231437070259644461474
+ -1.150231437070259644461474
+ >>> jtheta(2, 7, 0.25, 2); diff(lambda z: jtheta(2, z, 0.25), 7, 2)
+ -0.6226636990043777445898114
+ -0.6226636990043777445898114
+ >>> jtheta(3, 7, 0.25, 1); diff(lambda z: jtheta(3, z, 0.25), 7)
+ -0.9990312046096634316587882
+ -0.9990312046096634316587882
+ >>> jtheta(3, 7, 0.25, 2); diff(lambda z: jtheta(3, z, 0.25), 7, 2)
+ -0.1530388693066334936151174
+ -0.1530388693066334936151174
+ >>> jtheta(4, 7, 0.25, 1); diff(lambda z: jtheta(4, z, 0.25), 7)
+ 0.9820995967262793943571139
+ 0.9820995967262793943571139
+ >>> jtheta(4, 7, 0.25, 2); diff(lambda z: jtheta(4, z, 0.25), 7, 2)
+ 0.3936902850291437081667755
+ 0.3936902850291437081667755
+
+**Possible issues**
+
+For `|q| \ge 1` or `\Im(\tau) \le 0`, :func:`~mpmath.jtheta` raises
+``ValueError``. This exception is also raised for `|q|` extremely
+close to 1 (or equivalently `\tau` very close to 0), since the
+series would converge too slowly::
+
+ >>> jtheta(1, 10, 0.99999999 * exp(0.5*j))
+ Traceback (most recent call last):
+ ...
+ ValueError: abs(q) > THETA_Q_LIM = 1.000000
+
+"""
+
+eulernum = r"""
+Gives the `n`-th Euler number, defined as the `n`-th derivative of
+`\mathrm{sech}(t) = 1/\cosh(t)` evaluated at `t = 0`. Equivalently, the
+Euler numbers give the coefficients of the Taylor series
+
+.. math ::
+
+ \mathrm{sech}(t) = \sum_{n=0}^{\infty} \frac{E_n}{n!} t^n.
+
+The Euler numbers are closely related to Bernoulli numbers
+and Bernoulli polynomials. They can also be evaluated in terms of
+Euler polynomials (see :func:`~mpmath.eulerpoly`) as `E_n = 2^n E_n(1/2)`.
+
+**Examples**
+
+Computing the first few Euler numbers and verifying that they
+agree with the Taylor series::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> [eulernum(n) for n in range(11)]
+ [1.0, 0.0, -1.0, 0.0, 5.0, 0.0, -61.0, 0.0, 1385.0, 0.0, -50521.0]
+ >>> chop(diffs(sech, 0, 10))
+ [1.0, 0.0, -1.0, 0.0, 5.0, 0.0, -61.0, 0.0, 1385.0, 0.0, -50521.0]
+
+Euler numbers grow very rapidly. :func:`~mpmath.eulernum` efficiently
+computes numerical approximations for large indices::
+
+ >>> eulernum(50)
+ -6.053285248188621896314384e+54
+ >>> eulernum(1000)
+ 3.887561841253070615257336e+2371
+ >>> eulernum(10**20)
+ 4.346791453661149089338186e+1936958564106659551331
+
+Comparing with an asymptotic formula for the Euler numbers::
+
+ >>> n = 10**5
+ >>> (-1)**(n//2) * 8 * sqrt(n/(2*pi)) * (2*n/(pi*e))**n
+ 3.69919063017432362805663e+436961
+ >>> eulernum(n)
+ 3.699193712834466537941283e+436961
+
+Pass ``exact=True`` to obtain exact values of Euler numbers as integers::
+
+ >>> print(eulernum(50, exact=True))
+ -6053285248188621896314383785111649088103498225146815121
+ >>> print(eulernum(200, exact=True) % 10**10)
+ 1925859625
+ >>> eulernum(1001, exact=True)
+ 0
+"""
+
+eulerpoly = r"""
+Evaluates the Euler polynomial `E_n(z)`, defined by the generating function
+representation
+
+.. math ::
+
+ \frac{2e^{zt}}{e^t+1} = \sum_{n=0}^\infty E_n(z) \frac{t^n}{n!}.
+
+The Euler polynomials may also be represented in terms of
+Bernoulli polynomials (see :func:`~mpmath.bernpoly`) using various formulas, for
+example
+
+.. math ::
+
+ E_n(z) = \frac{2}{n+1} \left(
+ B_n(z)-2^{n+1}B_n\left(\frac{z}{2}\right)
+ \right).
+
+Special values include the Euler numbers `E_n = 2^n E_n(1/2)` (see
+:func:`~mpmath.eulernum`).
+
+**Examples**
+
+Computing the coefficients of the first few Euler polynomials::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> for n in range(6):
+ ... chop(taylor(lambda z: eulerpoly(n,z), 0, n))
+ ...
+ [1.0]
+ [-0.5, 1.0]
+ [0.0, -1.0, 1.0]
+ [0.25, 0.0, -1.5, 1.0]
+ [0.0, 1.0, 0.0, -2.0, 1.0]
+ [-0.5, 0.0, 2.5, 0.0, -2.5, 1.0]
+
+Evaluation for arbitrary `z`::
+
+ >>> eulerpoly(2,3)
+ 6.0
+ >>> eulerpoly(5,4)
+ 423.5
+ >>> eulerpoly(35, 11111111112)
+ 3.994957561486776072734601e+351
+ >>> eulerpoly(4, 10+20j)
+ (-47990.0 - 235980.0j)
+ >>> eulerpoly(2, '-3.5e-5')
+ 0.000035001225
+ >>> eulerpoly(3, 0.5)
+ 0.0
+ >>> eulerpoly(55, -10**80)
+ -1.0e+4400
+ >>> eulerpoly(5, -inf)
+ -inf
+ >>> eulerpoly(6, -inf)
+ +inf
+
+Computing Euler numbers::
+
+ >>> 2**26 * eulerpoly(26,0.5)
+ -4087072509293123892361.0
+ >>> eulernum(26)
+ -4087072509293123892361.0
+
+Evaluation is accurate for large `n` and small `z`::
+
+ >>> eulerpoly(100, 0.5)
+ 2.29047999988194114177943e+108
+ >>> eulerpoly(1000, 10.5)
+ 3.628120031122876847764566e+2070
+ >>> eulerpoly(10000, 10.5)
+ 1.149364285543783412210773e+30688
+"""
+
+spherharm = r"""
+Evaluates the spherical harmonic `Y_l^m(\theta,\phi)`,
+
+.. math ::
+
+ Y_l^m(\theta,\phi) = \sqrt{\frac{2l+1}{4\pi}\frac{(l-m)!}{(l+m)!}}
+ P_l^m(\cos \theta) e^{i m \phi}
+
+where `P_l^m` is an associated Legendre function (see :func:`~mpmath.legenp`).
+
+Here `\theta \in [0, \pi]` denotes the polar coordinate (ranging
+from the north pole to the south pole) and `\phi \in [0, 2 \pi]` denotes the
+azimuthal coordinate on a sphere. Care should be used since many different
+conventions for spherical coordinate variables are used.
+
+Usually spherical harmonics are considered for `l \in \mathbb{N}`,
+`m \in \mathbb{Z}`, `|m| \le l`. More generally, `l,m,\theta,\phi`
+are permitted to be complex numbers.
+
+.. note ::
+
+ :func:`~mpmath.spherharm` returns a complex number, even if the value is
+ purely real.
+
+**Plots**
+
+.. literalinclude :: /plots/spherharm40.py
+
+`Y_{4,0}`:
+
+.. image :: /plots/spherharm40.png
+
+`Y_{4,1}`:
+
+.. image :: /plots/spherharm41.png
+
+`Y_{4,2}`:
+
+.. image :: /plots/spherharm42.png
+
+`Y_{4,3}`:
+
+.. image :: /plots/spherharm43.png
+
+`Y_{4,4}`:
+
+.. image :: /plots/spherharm44.png
+
+**Examples**
+
+Some low-order spherical harmonics with reference values::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> theta = pi/4
+ >>> phi = pi/3
+ >>> spherharm(0,0,theta,phi); 0.5*sqrt(1/pi)*expj(0)
+ (0.2820947917738781434740397 + 0.0j)
+ (0.2820947917738781434740397 + 0.0j)
+ >>> spherharm(1,-1,theta,phi); 0.5*sqrt(3/(2*pi))*expj(-phi)*sin(theta)
+ (0.1221506279757299803965962 - 0.2115710938304086076055298j)
+ (0.1221506279757299803965962 - 0.2115710938304086076055298j)
+ >>> spherharm(1,0,theta,phi); 0.5*sqrt(3/pi)*cos(theta)*expj(0)
+ (0.3454941494713354792652446 + 0.0j)
+ (0.3454941494713354792652446 + 0.0j)
+ >>> spherharm(1,1,theta,phi); -0.5*sqrt(3/(2*pi))*expj(phi)*sin(theta)
+ (-0.1221506279757299803965962 - 0.2115710938304086076055298j)
+ (-0.1221506279757299803965962 - 0.2115710938304086076055298j)
+
+With the normalization convention used, the spherical harmonics are orthonormal
+on the unit sphere::
+
+ >>> sphere = [0,pi], [0,2*pi]
+ >>> dS = lambda t,p: fp.sin(t) # differential element
+ >>> Y1 = lambda t,p: fp.spherharm(l1,m1,t,p)
+ >>> Y2 = lambda t,p: fp.conj(fp.spherharm(l2,m2,t,p))
+ >>> l1 = l2 = 3; m1 = m2 = 2
+ >>> fp.chop(fp.quad(lambda t,p: Y1(t,p)*Y2(t,p)*dS(t,p), *sphere))
+ 1.0000000000000007
+ >>> m2 = 1 # m1 != m2
+ >>> print(fp.chop(fp.quad(lambda t,p: Y1(t,p)*Y2(t,p)*dS(t,p), *sphere)))
+ 0.0
+
+Evaluation is accurate for large orders::
+
+ >>> spherharm(1000,750,0.5,0.25)
+ (3.776445785304252879026585e-102 - 5.82441278771834794493484e-102j)
+
+Evaluation works with complex parameter values::
+
+ >>> spherharm(1+j, 2j, 2+3j, -0.5j)
+ (64.44922331113759992154992 + 1981.693919841408089681743j)
+"""
+
+scorergi = r"""
+Evaluates the Scorer function
+
+.. math ::
+
+ \operatorname{Gi}(z) =
+ \operatorname{Ai}(z) \int_0^z \operatorname{Bi}(t) dt +
+ \operatorname{Bi}(z) \int_z^{\infty} \operatorname{Ai}(t) dt
+
+which gives a particular solution to the inhomogeneous Airy
+differential equation `f''(z) - z f(z) = 1/\pi`. Another
+particular solution is given by the Scorer Hi-function
+(:func:`~mpmath.scorerhi`). The two functions are related as
+`\operatorname{Gi}(z) + \operatorname{Hi}(z) = \operatorname{Bi}(z)`.
+
+**Plots**
+
+.. literalinclude :: /plots/gi.py
+.. image :: /plots/gi.png
+.. literalinclude :: /plots/gi_c.py
+.. image :: /plots/gi_c.png
+
+**Examples**
+
+Some values and limits::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> scorergi(0); 1/(power(3,'7/6')*gamma('2/3'))
+ 0.2049755424820002450503075
+ 0.2049755424820002450503075
+ >>> diff(scorergi, 0); 1/(power(3,'5/6')*gamma('1/3'))
+ 0.1494294524512754526382746
+ 0.1494294524512754526382746
+ >>> scorergi(+inf); scorergi(-inf)
+ 0.0
+ 0.0
+ >>> scorergi(1)
+ 0.2352184398104379375986902
+ >>> scorergi(-1)
+ -0.1166722172960152826494198
+
+Evaluation for large arguments::
+
+ >>> scorergi(10)
+ 0.03189600510067958798062034
+ >>> scorergi(100)
+ 0.003183105228162961476590531
+ >>> scorergi(1000000)
+ 0.0000003183098861837906721743873
+ >>> 1/(pi*1000000)
+ 0.0000003183098861837906715377675
+ >>> scorergi(-1000)
+ -0.08358288400262780392338014
+ >>> scorergi(-100000)
+ 0.02886866118619660226809581
+ >>> scorergi(50+10j)
+ (0.0061214102799778578790984 - 0.001224335676457532180747917j)
+ >>> scorergi(-50-10j)
+ (5.236047850352252236372551e+29 - 3.08254224233701381482228e+29j)
+ >>> scorergi(100000j)
+ (-8.806659285336231052679025e+6474077 + 8.684731303500835514850962e+6474077j)
+
+Verifying the connection between Gi and Hi::
+
+ >>> z = 0.25
+ >>> scorergi(z) + scorerhi(z)
+ 0.7287469039362150078694543
+ >>> airybi(z)
+ 0.7287469039362150078694543
+
+Verifying the differential equation::
+
+ >>> for z in [-3.4, 0, 2.5, 1+2j]:
+ ... chop(diff(scorergi,z,2) - z*scorergi(z))
+ ...
+ -0.3183098861837906715377675
+ -0.3183098861837906715377675
+ -0.3183098861837906715377675
+ -0.3183098861837906715377675
+
+Verifying the integral representation::
+
+ >>> z = 0.5
+ >>> scorergi(z)
+ 0.2447210432765581976910539
+ >>> Ai,Bi = airyai,airybi
+ >>> Bi(z)*(Ai(inf,-1)-Ai(z,-1)) + Ai(z)*(Bi(z,-1)-Bi(0,-1))
+ 0.2447210432765581976910539
+
+**References**
+
+1. [DLMF]_ section 9.12: Scorer Functions
+
+"""
+
+scorerhi = r"""
+Evaluates the second Scorer function
+
+.. math ::
+
+ \operatorname{Hi}(z) =
+ \operatorname{Bi}(z) \int_{-\infty}^z \operatorname{Ai}(t) dt -
+ \operatorname{Ai}(z) \int_{-\infty}^z \operatorname{Bi}(t) dt
+
+which gives a particular solution to the inhomogeneous Airy
+differential equation `f''(z) - z f(z) = 1/\pi`. See also
+:func:`~mpmath.scorergi`.
+
+**Plots**
+
+.. literalinclude :: /plots/hi.py
+.. image :: /plots/hi.png
+.. literalinclude :: /plots/hi_c.py
+.. image :: /plots/hi_c.png
+
+**Examples**
+
+Some values and limits::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> scorerhi(0); 2/(power(3,'7/6')*gamma('2/3'))
+ 0.4099510849640004901006149
+ 0.4099510849640004901006149
+ >>> diff(scorerhi,0); 2/(power(3,'5/6')*gamma('1/3'))
+ 0.2988589049025509052765491
+ 0.2988589049025509052765491
+ >>> scorerhi(+inf); scorerhi(-inf)
+ +inf
+ 0.0
+ >>> scorerhi(1)
+ 0.9722051551424333218376886
+ >>> scorerhi(-1)
+ 0.2206696067929598945381098
+
+Evaluation for large arguments::
+
+ >>> scorerhi(10)
+ 455641153.5163291358991077
+ >>> scorerhi(100)
+ 6.041223996670201399005265e+288
+ >>> scorerhi(1000000)
+ 7.138269638197858094311122e+289529652
+ >>> scorerhi(-10)
+ 0.0317685352825022727415011
+ >>> scorerhi(-100)
+ 0.003183092495767499864680483
+ >>> scorerhi(100j)
+ (-6.366197716545672122983857e-9 + 0.003183098861710582761688475j)
+ >>> scorerhi(50+50j)
+ (-5.322076267321435669290334e+63 + 1.478450291165243789749427e+65j)
+ >>> scorerhi(-1000-1000j)
+ (0.0001591549432510502796565538 - 0.000159154943091895334973109j)
+
+Verifying the differential equation::
+
+ >>> for z in [-3.4, 0, 2, 1+2j]:
+ ... chop(diff(scorerhi,z,2) - z*scorerhi(z))
+ ...
+ 0.3183098861837906715377675
+ 0.3183098861837906715377675
+ 0.3183098861837906715377675
+ 0.3183098861837906715377675
+
+Verifying the integral representation::
+
+ >>> z = 0.5
+ >>> scorerhi(z)
+ 0.6095559998265972956089949
+ >>> Ai,Bi = airyai,airybi
+ >>> Bi(z)*(Ai(z,-1)-Ai(-inf,-1)) - Ai(z)*(Bi(z,-1)-Bi(-inf,-1))
+ 0.6095559998265972956089949
+
+"""
+
+
+stirling1 = r"""
+Gives the Stirling number of the first kind `s(n,k)`, defined by
+
+.. math ::
+
+ x(x-1)(x-2)\cdots(x-n+1) = \sum_{k=0}^n s(n,k) x^k.
+
+The value is computed using an integer recurrence. The implementation
+is not optimized for approximating large values quickly.
+
+**Examples**
+
+Comparing with the generating function::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> taylor(lambda x: ff(x, 5), 0, 5)
+ [0.0, 24.0, -50.0, 35.0, -10.0, 1.0]
+ >>> [stirling1(5, k) for k in range(6)]
+ [0.0, 24.0, -50.0, 35.0, -10.0, 1.0]
+
+Recurrence relation::
+
+ >>> n, k = 5, 3
+ >>> stirling1(n+1,k) + n*stirling1(n,k) - stirling1(n,k-1)
+ 0.0
+
+The matrices of Stirling numbers of first and second kind are inverses
+of each other::
+
+ >>> A = matrix(5, 5); B = matrix(5, 5)
+ >>> for n in range(5):
+ ... for k in range(5):
+ ... A[n,k] = stirling1(n,k)
+ ... B[n,k] = stirling2(n,k)
+ ...
+ >>> A * B
+ [1.0 0.0 0.0 0.0 0.0]
+ [0.0 1.0 0.0 0.0 0.0]
+ [0.0 0.0 1.0 0.0 0.0]
+ [0.0 0.0 0.0 1.0 0.0]
+ [0.0 0.0 0.0 0.0 1.0]
+
+Pass ``exact=True`` to obtain exact values of Stirling numbers as integers::
+
+ >>> stirling1(42, 5)
+ -2.864498971768501633736628e+50
+ >>> print(stirling1(42, 5, exact=True))
+ -286449897176850163373662803014001546235808317440000
+
+"""
+
+stirling2 = r"""
+Gives the Stirling number of the second kind `S(n,k)`, defined by
+
+.. math ::
+
+ x^n = \sum_{k=0}^n S(n,k) x(x-1)(x-2)\cdots(x-k+1)
+
+The value is computed using integer arithmetic to evaluate a power sum.
+The implementation is not optimized for approximating large values quickly.
+
+**Examples**
+
+Comparing with the generating function::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> taylor(lambda x: sum(stirling2(5,k) * ff(x,k) for k in range(6)), 0, 5)
+ [0.0, 0.0, 0.0, 0.0, 0.0, 1.0]
+
+Recurrence relation::
+
+ >>> n, k = 5, 3
+ >>> stirling2(n+1,k) - k*stirling2(n,k) - stirling2(n,k-1)
+ 0.0
+
+Pass ``exact=True`` to obtain exact values of Stirling numbers as integers::
+
+ >>> stirling2(52, 10)
+ 2.641822121003543906807485e+45
+ >>> print(stirling2(52, 10, exact=True))
+ 2641822121003543906807485307053638921722527655
+
+
+"""
+
+squarew = r"""
+Computes the square wave function using the definition:
+
+.. math::
+ x(t) = A(-1)^{\left\lfloor{2t / P}\right\rfloor}
+
+where `P` is the period of the wave and `A` is the amplitude.
+
+**Examples**
+
+Square wave with period = 2, amplitude = 1 ::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> squarew(0,1,2)
+ 1.0
+ >>> squarew(0.5,1,2)
+ 1.0
+ >>> squarew(1,1,2)
+ -1.0
+ >>> squarew(1.5,1,2)
+ -1.0
+ >>> squarew(2,1,2)
+ 1.0
+"""
+
+trianglew = r"""
+Computes the triangle wave function using the definition:
+
+.. math::
+ x(t) = 2A\left(\frac{1}{2}-\left|1-2 \operatorname{frac}\left(\frac{x}{P}+\frac{1}{4}\right)\right|\right)
+
+where :math:`\operatorname{frac}\left(\frac{t}{T}\right) = \frac{t}{T}-\left\lfloor{\frac{t}{T}}\right\rfloor`
+, `P` is the period of the wave, and `A` is the amplitude.
+
+**Examples**
+
+Triangle wave with period = 2, amplitude = 1 ::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> trianglew(0,1,2)
+ 0.0
+ >>> trianglew(0.25,1,2)
+ 0.5
+ >>> trianglew(0.5,1,2)
+ 1.0
+ >>> trianglew(1,1,2)
+ 0.0
+ >>> trianglew(1.5,1,2)
+ -1.0
+ >>> trianglew(2,1,2)
+ 0.0
+"""
+
+sawtoothw = r"""
+Computes the sawtooth wave function using the definition:
+
+.. math::
+ x(t) = A\operatorname{frac}\left(\frac{t}{T}\right)
+
+where :math:`\operatorname{frac}\left(\frac{t}{T}\right) = \frac{t}{T}-\left\lfloor{\frac{t}{T}}\right\rfloor`,
+`P` is the period of the wave, and `A` is the amplitude.
+
+**Examples**
+
+Sawtooth wave with period = 2, amplitude = 1 ::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> sawtoothw(0,1,2)
+ 0.0
+ >>> sawtoothw(0.5,1,2)
+ 0.25
+ >>> sawtoothw(1,1,2)
+ 0.5
+ >>> sawtoothw(1.5,1,2)
+ 0.75
+ >>> sawtoothw(2,1,2)
+ 0.0
+"""
+
+unit_triangle = r"""
+Computes the unit triangle using the definition:
+
+.. math::
+ x(t) = A(-\left| t \right| + 1)
+
+where `A` is the amplitude.
+
+**Examples**
+
+Unit triangle with amplitude = 1 ::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> unit_triangle(-1,1)
+ 0.0
+ >>> unit_triangle(-0.5,1)
+ 0.5
+ >>> unit_triangle(0,1)
+ 1.0
+ >>> unit_triangle(0.5,1)
+ 0.5
+ >>> unit_triangle(1,1)
+ 0.0
+"""
+
+sigmoid = r"""
+Computes the sigmoid function using the definition:
+
+.. math::
+ x(t) = \frac{A}{1 + e^{-t}}
+
+where `A` is the amplitude.
+
+**Examples**
+
+Sigmoid function with amplitude = 1 ::
+
+ >>> from mpmath import *
+ >>> mp.dps = 25; mp.pretty = True
+ >>> sigmoid(-1,1)
+ 0.2689414213699951207488408
+ >>> sigmoid(-0.5,1)
+ 0.3775406687981454353610994
+ >>> sigmoid(0,1)
+ 0.5
+ >>> sigmoid(0.5,1)
+ 0.6224593312018545646389006
+ >>> sigmoid(1,1)
+ 0.7310585786300048792511592
+
+"""
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/mpmath/identification.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/mpmath/identification.py
new file mode 100644
index 0000000000000000000000000000000000000000..226f62d3fe9cacedbd9ba2b1e66ff0ad017fa604
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/mpmath/identification.py
@@ -0,0 +1,844 @@
+"""
+Implements the PSLQ algorithm for integer relation detection,
+and derivative algorithms for constant recognition.
+"""
+
+from .libmp.backend import xrange
+from .libmp import int_types, sqrt_fixed
+
+# round to nearest integer (can be done more elegantly...)
+def round_fixed(x, prec):
+ return ((x + (1<<(prec-1))) >> prec) << prec
+
+class IdentificationMethods(object):
+ pass
+
+
+def pslq(ctx, x, tol=None, maxcoeff=1000, maxsteps=100, verbose=False):
+ r"""
+ Given a vector of real numbers `x = [x_0, x_1, ..., x_n]`, ``pslq(x)``
+ uses the PSLQ algorithm to find a list of integers
+ `[c_0, c_1, ..., c_n]` such that
+
+ .. math ::
+
+ |c_1 x_1 + c_2 x_2 + ... + c_n x_n| < \mathrm{tol}
+
+ and such that `\max |c_k| < \mathrm{maxcoeff}`. If no such vector
+ exists, :func:`~mpmath.pslq` returns ``None``. The tolerance defaults to
+ 3/4 of the working precision.
+
+ **Examples**
+
+ Find rational approximations for `\pi`::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> pslq([-1, pi], tol=0.01)
+ [22, 7]
+ >>> pslq([-1, pi], tol=0.001)
+ [355, 113]
+ >>> mpf(22)/7; mpf(355)/113; +pi
+ 3.14285714285714
+ 3.14159292035398
+ 3.14159265358979
+
+ Pi is not a rational number with denominator less than 1000::
+
+ >>> pslq([-1, pi])
+ >>>
+
+ To within the standard precision, it can however be approximated
+ by at least one rational number with denominator less than `10^{12}`::
+
+ >>> p, q = pslq([-1, pi], maxcoeff=10**12)
+ >>> print(p); print(q)
+ 238410049439
+ 75888275702
+ >>> mpf(p)/q
+ 3.14159265358979
+
+ The PSLQ algorithm can be applied to long vectors. For example,
+ we can investigate the rational (in)dependence of integer square
+ roots::
+
+ >>> mp.dps = 30
+ >>> pslq([sqrt(n) for n in range(2, 5+1)])
+ >>>
+ >>> pslq([sqrt(n) for n in range(2, 6+1)])
+ >>>
+ >>> pslq([sqrt(n) for n in range(2, 8+1)])
+ [2, 0, 0, 0, 0, 0, -1]
+
+ **Machin formulas**
+
+ A famous formula for `\pi` is Machin's,
+
+ .. math ::
+
+ \frac{\pi}{4} = 4 \operatorname{acot} 5 - \operatorname{acot} 239
+
+ There are actually infinitely many formulas of this type. Two
+ others are
+
+ .. math ::
+
+ \frac{\pi}{4} = \operatorname{acot} 1
+
+ \frac{\pi}{4} = 12 \operatorname{acot} 49 + 32 \operatorname{acot} 57
+ + 5 \operatorname{acot} 239 + 12 \operatorname{acot} 110443
+
+ We can easily verify the formulas using the PSLQ algorithm::
+
+ >>> mp.dps = 30
+ >>> pslq([pi/4, acot(1)])
+ [1, -1]
+ >>> pslq([pi/4, acot(5), acot(239)])
+ [1, -4, 1]
+ >>> pslq([pi/4, acot(49), acot(57), acot(239), acot(110443)])
+ [1, -12, -32, 5, -12]
+
+ We could try to generate a custom Machin-like formula by running
+ the PSLQ algorithm with a few inverse cotangent values, for example
+ acot(2), acot(3) ... acot(10). Unfortunately, there is a linear
+ dependence among these values, resulting in only that dependence
+ being detected, with a zero coefficient for `\pi`::
+
+ >>> pslq([pi] + [acot(n) for n in range(2,11)])
+ [0, 1, -1, 0, 0, 0, -1, 0, 0, 0]
+
+ We get better luck by removing linearly dependent terms::
+
+ >>> pslq([pi] + [acot(n) for n in range(2,11) if n not in (3, 5)])
+ [1, -8, 0, 0, 4, 0, 0, 0]
+
+ In other words, we found the following formula::
+
+ >>> 8*acot(2) - 4*acot(7)
+ 3.14159265358979323846264338328
+ >>> +pi
+ 3.14159265358979323846264338328
+
+ **Algorithm**
+
+ This is a fairly direct translation to Python of the pseudocode given by
+ David Bailey, "The PSLQ Integer Relation Algorithm":
+ http://www.cecm.sfu.ca/organics/papers/bailey/paper/html/node3.html
+
+ The present implementation uses fixed-point instead of floating-point
+ arithmetic, since this is significantly (about 7x) faster.
+ """
+
+ n = len(x)
+ if n < 2:
+ raise ValueError("n cannot be less than 2")
+
+ # At too low precision, the algorithm becomes meaningless
+ prec = ctx.prec
+ if prec < 53:
+ raise ValueError("prec cannot be less than 53")
+
+ if verbose and prec // max(2,n) < 5:
+ print("Warning: precision for PSLQ may be too low")
+
+ target = int(prec * 0.75)
+
+ if tol is None:
+ tol = ctx.mpf(2)**(-target)
+ else:
+ tol = ctx.convert(tol)
+
+ extra = 60
+ prec += extra
+
+ if verbose:
+ print("PSLQ using prec %i and tol %s" % (prec, ctx.nstr(tol)))
+
+ tol = ctx.to_fixed(tol, prec)
+ assert tol
+
+ # Convert to fixed-point numbers. The dummy None is added so we can
+ # use 1-based indexing. (This just allows us to be consistent with
+ # Bailey's indexing. The algorithm is 100 lines long, so debugging
+ # a single wrong index can be painful.)
+ x = [None] + [ctx.to_fixed(ctx.mpf(xk), prec) for xk in x]
+
+ # Sanity check on magnitudes
+ minx = min(abs(xx) for xx in x[1:])
+ if not minx:
+ raise ValueError("PSLQ requires a vector of nonzero numbers")
+ if minx < tol//100:
+ if verbose:
+ print("STOPPING: (one number is too small)")
+ return None
+
+ g = sqrt_fixed((4<> prec)
+ s[k] = sqrt_fixed(t, prec)
+ t = s[1]
+ y = x[:]
+ for k in xrange(1, n+1):
+ y[k] = (x[k] << prec) // t
+ s[k] = (s[k] << prec) // t
+ # step 3
+ for i in xrange(1, n+1):
+ for j in xrange(i+1, n):
+ H[i,j] = 0
+ if i <= n-1:
+ if s[i]:
+ H[i,i] = (s[i+1] << prec) // s[i]
+ else:
+ H[i,i] = 0
+ for j in range(1, i):
+ sjj1 = s[j]*s[j+1]
+ if sjj1:
+ H[i,j] = ((-y[i]*y[j])<> prec)
+ for k in xrange(1, j+1):
+ H[i,k] = H[i,k] - (t*H[j,k] >> prec)
+ for k in xrange(1, n+1):
+ A[i,k] = A[i,k] - (t*A[j,k] >> prec)
+ B[k,j] = B[k,j] + (t*B[k,i] >> prec)
+ # Main algorithm
+ for REP in range(maxsteps):
+ # Step 1
+ m = -1
+ szmax = -1
+ for i in range(1, n):
+ h = H[i,i]
+ sz = (g**i * abs(h)) >> (prec*(i-1))
+ if sz > szmax:
+ m = i
+ szmax = sz
+ # Step 2
+ y[m], y[m+1] = y[m+1], y[m]
+ for i in xrange(1,n+1): H[m,i], H[m+1,i] = H[m+1,i], H[m,i]
+ for i in xrange(1,n+1): A[m,i], A[m+1,i] = A[m+1,i], A[m,i]
+ for i in xrange(1,n+1): B[i,m], B[i,m+1] = B[i,m+1], B[i,m]
+ # Step 3
+ if m <= n - 2:
+ t0 = sqrt_fixed((H[m,m]**2 + H[m,m+1]**2)>>prec, prec)
+ # A zero element probably indicates that the precision has
+ # been exhausted. XXX: this could be spurious, due to
+ # using fixed-point arithmetic
+ if not t0:
+ break
+ t1 = (H[m,m] << prec) // t0
+ t2 = (H[m,m+1] << prec) // t0
+ for i in xrange(m, n+1):
+ t3 = H[i,m]
+ t4 = H[i,m+1]
+ H[i,m] = (t1*t3+t2*t4) >> prec
+ H[i,m+1] = (-t2*t3+t1*t4) >> prec
+ # Step 4
+ for i in xrange(m+1, n+1):
+ for j in xrange(min(i-1, m+1), 0, -1):
+ try:
+ t = round_fixed((H[i,j] << prec)//H[j,j], prec)
+ # Precision probably exhausted
+ except ZeroDivisionError:
+ break
+ y[j] = y[j] + ((t*y[i]) >> prec)
+ for k in xrange(1, j+1):
+ H[i,k] = H[i,k] - (t*H[j,k] >> prec)
+ for k in xrange(1, n+1):
+ A[i,k] = A[i,k] - (t*A[j,k] >> prec)
+ B[k,j] = B[k,j] + (t*B[k,i] >> prec)
+ # Until a relation is found, the error typically decreases
+ # slowly (e.g. a factor 1-10) with each step TODO: we could
+ # compare err from two successive iterations. If there is a
+ # large drop (several orders of magnitude), that indicates a
+ # "high quality" relation was detected. Reporting this to
+ # the user somehow might be useful.
+ best_err = maxcoeff<> prec) for j in \
+ range(1,n+1)]
+ if max(abs(v) for v in vec) < maxcoeff:
+ if verbose:
+ print("FOUND relation at iter %i/%i, error: %s" % \
+ (REP, maxsteps, ctx.nstr(err / ctx.mpf(2)**prec, 1)))
+ return vec
+ best_err = min(err, best_err)
+ # Calculate a lower bound for the norm. We could do this
+ # more exactly (using the Euclidean norm) but there is probably
+ # no practical benefit.
+ recnorm = max(abs(h) for h in H.values())
+ if recnorm:
+ norm = ((1 << (2*prec)) // recnorm) >> prec
+ norm //= 100
+ else:
+ norm = ctx.inf
+ if verbose:
+ print("%i/%i: Error: %8s Norm: %s" % \
+ (REP, maxsteps, ctx.nstr(best_err / ctx.mpf(2)**prec, 1), norm))
+ if norm >= maxcoeff:
+ break
+ if verbose:
+ print("CANCELLING after step %i/%i." % (REP, maxsteps))
+ print("Could not find an integer relation. Norm bound: %s" % norm)
+ return None
+
+def findpoly(ctx, x, n=1, **kwargs):
+ r"""
+ ``findpoly(x, n)`` returns the coefficients of an integer
+ polynomial `P` of degree at most `n` such that `P(x) \approx 0`.
+ If no polynomial having `x` as a root can be found,
+ :func:`~mpmath.findpoly` returns ``None``.
+
+ :func:`~mpmath.findpoly` works by successively calling :func:`~mpmath.pslq` with
+ the vectors `[1, x]`, `[1, x, x^2]`, `[1, x, x^2, x^3]`, ...,
+ `[1, x, x^2, .., x^n]` as input. Keyword arguments given to
+ :func:`~mpmath.findpoly` are forwarded verbatim to :func:`~mpmath.pslq`. In
+ particular, you can specify a tolerance for `P(x)` with ``tol``
+ and a maximum permitted coefficient size with ``maxcoeff``.
+
+ For large values of `n`, it is recommended to run :func:`~mpmath.findpoly`
+ at high precision; preferably 50 digits or more.
+
+ **Examples**
+
+ By default (degree `n = 1`), :func:`~mpmath.findpoly` simply finds a linear
+ polynomial with a rational root::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> findpoly(0.7)
+ [-10, 7]
+
+ The generated coefficient list is valid input to ``polyval`` and
+ ``polyroots``::
+
+ >>> nprint(polyval(findpoly(phi, 2), phi), 1)
+ -2.0e-16
+ >>> for r in polyroots(findpoly(phi, 2)):
+ ... print(r)
+ ...
+ -0.618033988749895
+ 1.61803398874989
+
+ Numbers of the form `m + n \sqrt p` for integers `(m, n, p)` are
+ solutions to quadratic equations. As we find here, `1+\sqrt 2`
+ is a root of the polynomial `x^2 - 2x - 1`::
+
+ >>> findpoly(1+sqrt(2), 2)
+ [1, -2, -1]
+ >>> findroot(lambda x: x**2 - 2*x - 1, 1)
+ 2.4142135623731
+
+ Despite only containing square roots, the following number results
+ in a polynomial of degree 4::
+
+ >>> findpoly(sqrt(2)+sqrt(3), 4)
+ [1, 0, -10, 0, 1]
+
+ In fact, `x^4 - 10x^2 + 1` is the *minimal polynomial* of
+ `r = \sqrt 2 + \sqrt 3`, meaning that a rational polynomial of
+ lower degree having `r` as a root does not exist. Given sufficient
+ precision, :func:`~mpmath.findpoly` will usually find the correct
+ minimal polynomial of a given algebraic number.
+
+ **Non-algebraic numbers**
+
+ If :func:`~mpmath.findpoly` fails to find a polynomial with given
+ coefficient size and tolerance constraints, that means no such
+ polynomial exists.
+
+ We can verify that `\pi` is not an algebraic number of degree 3 with
+ coefficients less than 1000::
+
+ >>> mp.dps = 15
+ >>> findpoly(pi, 3)
+ >>>
+
+ It is always possible to find an algebraic approximation of a number
+ using one (or several) of the following methods:
+
+ 1. Increasing the permitted degree
+ 2. Allowing larger coefficients
+ 3. Reducing the tolerance
+
+ One example of each method is shown below::
+
+ >>> mp.dps = 15
+ >>> findpoly(pi, 4)
+ [95, -545, 863, -183, -298]
+ >>> findpoly(pi, 3, maxcoeff=10000)
+ [836, -1734, -2658, -457]
+ >>> findpoly(pi, 3, tol=1e-7)
+ [-4, 22, -29, -2]
+
+ It is unknown whether Euler's constant is transcendental (or even
+ irrational). We can use :func:`~mpmath.findpoly` to check that if is
+ an algebraic number, its minimal polynomial must have degree
+ at least 7 and a coefficient of magnitude at least 1000000::
+
+ >>> mp.dps = 200
+ >>> findpoly(euler, 6, maxcoeff=10**6, tol=1e-100, maxsteps=1000)
+ >>>
+
+ Note that the high precision and strict tolerance is necessary
+ for such high-degree runs, since otherwise unwanted low-accuracy
+ approximations will be detected. It may also be necessary to set
+ maxsteps high to prevent a premature exit (before the coefficient
+ bound has been reached). Running with ``verbose=True`` to get an
+ idea what is happening can be useful.
+ """
+ x = ctx.mpf(x)
+ if n < 1:
+ raise ValueError("n cannot be less than 1")
+ if x == 0:
+ return [1, 0]
+ xs = [ctx.mpf(1)]
+ for i in range(1,n+1):
+ xs.append(x**i)
+ a = ctx.pslq(xs, **kwargs)
+ if a is not None:
+ return a[::-1]
+
+def fracgcd(p, q):
+ x, y = p, q
+ while y:
+ x, y = y, x % y
+ if x != 1:
+ p //= x
+ q //= x
+ if q == 1:
+ return p
+ return p, q
+
+def pslqstring(r, constants):
+ q = r[0]
+ r = r[1:]
+ s = []
+ for i in range(len(r)):
+ p = r[i]
+ if p:
+ z = fracgcd(-p,q)
+ cs = constants[i][1]
+ if cs == '1':
+ cs = ''
+ else:
+ cs = '*' + cs
+ if isinstance(z, int_types):
+ if z > 0: term = str(z) + cs
+ else: term = ("(%s)" % z) + cs
+ else:
+ term = ("(%s/%s)" % z) + cs
+ s.append(term)
+ s = ' + '.join(s)
+ if '+' in s or '*' in s:
+ s = '(' + s + ')'
+ return s or '0'
+
+def prodstring(r, constants):
+ q = r[0]
+ r = r[1:]
+ num = []
+ den = []
+ for i in range(len(r)):
+ p = r[i]
+ if p:
+ z = fracgcd(-p,q)
+ cs = constants[i][1]
+ if isinstance(z, int_types):
+ if abs(z) == 1: t = cs
+ else: t = '%s**%s' % (cs, abs(z))
+ ([num,den][z<0]).append(t)
+ else:
+ t = '%s**(%s/%s)' % (cs, abs(z[0]), z[1])
+ ([num,den][z[0]<0]).append(t)
+ num = '*'.join(num)
+ den = '*'.join(den)
+ if num and den: return "(%s)/(%s)" % (num, den)
+ if num: return num
+ if den: return "1/(%s)" % den
+
+def quadraticstring(ctx,t,a,b,c):
+ if c < 0:
+ a,b,c = -a,-b,-c
+ u1 = (-b+ctx.sqrt(b**2-4*a*c))/(2*c)
+ u2 = (-b-ctx.sqrt(b**2-4*a*c))/(2*c)
+ if abs(u1-t) < abs(u2-t):
+ if b: s = '((%s+sqrt(%s))/%s)' % (-b,b**2-4*a*c,2*c)
+ else: s = '(sqrt(%s)/%s)' % (-4*a*c,2*c)
+ else:
+ if b: s = '((%s-sqrt(%s))/%s)' % (-b,b**2-4*a*c,2*c)
+ else: s = '(-sqrt(%s)/%s)' % (-4*a*c,2*c)
+ return s
+
+# Transformation y = f(x,c), with inverse function x = f(y,c)
+# The third entry indicates whether the transformation is
+# redundant when c = 1
+transforms = [
+ (lambda ctx,x,c: x*c, '$y/$c', 0),
+ (lambda ctx,x,c: x/c, '$c*$y', 1),
+ (lambda ctx,x,c: c/x, '$c/$y', 0),
+ (lambda ctx,x,c: (x*c)**2, 'sqrt($y)/$c', 0),
+ (lambda ctx,x,c: (x/c)**2, '$c*sqrt($y)', 1),
+ (lambda ctx,x,c: (c/x)**2, '$c/sqrt($y)', 0),
+ (lambda ctx,x,c: c*x**2, 'sqrt($y)/sqrt($c)', 1),
+ (lambda ctx,x,c: x**2/c, 'sqrt($c)*sqrt($y)', 1),
+ (lambda ctx,x,c: c/x**2, 'sqrt($c)/sqrt($y)', 1),
+ (lambda ctx,x,c: ctx.sqrt(x*c), '$y**2/$c', 0),
+ (lambda ctx,x,c: ctx.sqrt(x/c), '$c*$y**2', 1),
+ (lambda ctx,x,c: ctx.sqrt(c/x), '$c/$y**2', 0),
+ (lambda ctx,x,c: c*ctx.sqrt(x), '$y**2/$c**2', 1),
+ (lambda ctx,x,c: ctx.sqrt(x)/c, '$c**2*$y**2', 1),
+ (lambda ctx,x,c: c/ctx.sqrt(x), '$c**2/$y**2', 1),
+ (lambda ctx,x,c: ctx.exp(x*c), 'log($y)/$c', 0),
+ (lambda ctx,x,c: ctx.exp(x/c), '$c*log($y)', 1),
+ (lambda ctx,x,c: ctx.exp(c/x), '$c/log($y)', 0),
+ (lambda ctx,x,c: c*ctx.exp(x), 'log($y/$c)', 1),
+ (lambda ctx,x,c: ctx.exp(x)/c, 'log($c*$y)', 1),
+ (lambda ctx,x,c: c/ctx.exp(x), 'log($c/$y)', 0),
+ (lambda ctx,x,c: ctx.ln(x*c), 'exp($y)/$c', 0),
+ (lambda ctx,x,c: ctx.ln(x/c), '$c*exp($y)', 1),
+ (lambda ctx,x,c: ctx.ln(c/x), '$c/exp($y)', 0),
+ (lambda ctx,x,c: c*ctx.ln(x), 'exp($y/$c)', 1),
+ (lambda ctx,x,c: ctx.ln(x)/c, 'exp($c*$y)', 1),
+ (lambda ctx,x,c: c/ctx.ln(x), 'exp($c/$y)', 0),
+]
+
+def identify(ctx, x, constants=[], tol=None, maxcoeff=1000, full=False,
+ verbose=False):
+ r"""
+ Given a real number `x`, ``identify(x)`` attempts to find an exact
+ formula for `x`. This formula is returned as a string. If no match
+ is found, ``None`` is returned. With ``full=True``, a list of
+ matching formulas is returned.
+
+ As a simple example, :func:`~mpmath.identify` will find an algebraic
+ formula for the golden ratio::
+
+ >>> from mpmath import *
+ >>> mp.dps = 15; mp.pretty = True
+ >>> identify(phi)
+ '((1+sqrt(5))/2)'
+
+ :func:`~mpmath.identify` can identify simple algebraic numbers and simple
+ combinations of given base constants, as well as certain basic
+ transformations thereof. More specifically, :func:`~mpmath.identify`
+ looks for the following:
+
+ 1. Fractions
+ 2. Quadratic algebraic numbers
+ 3. Rational linear combinations of the base constants
+ 4. Any of the above after first transforming `x` into `f(x)` where
+ `f(x)` is `1/x`, `\sqrt x`, `x^2`, `\log x` or `\exp x`, either
+ directly or with `x` or `f(x)` multiplied or divided by one of
+ the base constants
+ 5. Products of fractional powers of the base constants and
+ small integers
+
+ Base constants can be given as a list of strings representing mpmath
+ expressions (:func:`~mpmath.identify` will ``eval`` the strings to numerical
+ values and use the original strings for the output), or as a dict of
+ formula:value pairs.
+
+ In order not to produce spurious results, :func:`~mpmath.identify` should
+ be used with high precision; preferably 50 digits or more.
+
+ **Examples**
+
+ Simple identifications can be performed safely at standard
+ precision. Here the default recognition of rational, algebraic,
+ and exp/log of algebraic numbers is demonstrated::
+
+ >>> mp.dps = 15
+ >>> identify(0.22222222222222222)
+ '(2/9)'
+ >>> identify(1.9662210973805663)
+ 'sqrt(((24+sqrt(48))/8))'
+ >>> identify(4.1132503787829275)
+ 'exp((sqrt(8)/2))'
+ >>> identify(0.881373587019543)
+ 'log(((2+sqrt(8))/2))'
+
+ By default, :func:`~mpmath.identify` does not recognize `\pi`. At standard
+ precision it finds a not too useful approximation. At slightly
+ increased precision, this approximation is no longer accurate
+ enough and :func:`~mpmath.identify` more correctly returns ``None``::
+
+ >>> identify(pi)
+ '(2**(176/117)*3**(20/117)*5**(35/39))/(7**(92/117))'
+ >>> mp.dps = 30
+ >>> identify(pi)
+ >>>
+
+ Numbers such as `\pi`, and simple combinations of user-defined
+ constants, can be identified if they are provided explicitly::
+
+ >>> identify(3*pi-2*e, ['pi', 'e'])
+ '(3*pi + (-2)*e)'
+
+ Here is an example using a dict of constants. Note that the
+ constants need not be "atomic"; :func:`~mpmath.identify` can just
+ as well express the given number in terms of expressions
+ given by formulas::
+
+ >>> identify(pi+e, {'a':pi+2, 'b':2*e})
+ '((-2) + 1*a + (1/2)*b)'
+
+ Next, we attempt some identifications with a set of base constants.
+ It is necessary to increase the precision a bit.
+
+ >>> mp.dps = 50
+ >>> base = ['sqrt(2)','pi','log(2)']
+ >>> identify(0.25, base)
+ '(1/4)'
+ >>> identify(3*pi + 2*sqrt(2) + 5*log(2)/7, base)
+ '(2*sqrt(2) + 3*pi + (5/7)*log(2))'
+ >>> identify(exp(pi+2), base)
+ 'exp((2 + 1*pi))'
+ >>> identify(1/(3+sqrt(2)), base)
+ '((3/7) + (-1/7)*sqrt(2))'
+ >>> identify(sqrt(2)/(3*pi+4), base)
+ 'sqrt(2)/(4 + 3*pi)'
+ >>> identify(5**(mpf(1)/3)*pi*log(2)**2, base)
+ '5**(1/3)*pi*log(2)**2'
+
+ An example of an erroneous solution being found when too low
+ precision is used::
+
+ >>> mp.dps = 15
+ >>> identify(1/(3*pi-4*e+sqrt(8)), ['pi', 'e', 'sqrt(2)'])
+ '((11/25) + (-158/75)*pi + (76/75)*e + (44/15)*sqrt(2))'
+ >>> mp.dps = 50
+ >>> identify(1/(3*pi-4*e+sqrt(8)), ['pi', 'e', 'sqrt(2)'])
+ '1/(3*pi + (-4)*e + 2*sqrt(2))'
+
+ **Finding approximate solutions**
+
+ The tolerance ``tol`` defaults to 3/4 of the working precision.
+ Lowering the tolerance is useful for finding approximate matches.
+ We can for example try to generate approximations for pi::
+
+ >>> mp.dps = 15
+ >>> identify(pi, tol=1e-2)
+ '(22/7)'
+ >>> identify(pi, tol=1e-3)
+ '(355/113)'
+ >>> identify(pi, tol=1e-10)
+ '(5**(339/269))/(2**(64/269)*3**(13/269)*7**(92/269))'
+
+ With ``full=True``, and by supplying a few base constants,
+ ``identify`` can generate almost endless lists of approximations
+ for any number (the output below has been truncated to show only
+ the first few)::
+
+ >>> for p in identify(pi, ['e', 'catalan'], tol=1e-5, full=True):
+ ... print(p)
+ ... # doctest: +ELLIPSIS
+ e/log((6 + (-4/3)*e))
+ (3**3*5*e*catalan**2)/(2*7**2)
+ sqrt(((-13) + 1*e + 22*catalan))
+ log(((-6) + 24*e + 4*catalan)/e)
+ exp(catalan*((-1/5) + (8/15)*e))
+ catalan*(6 + (-6)*e + 15*catalan)
+ sqrt((5 + 26*e + (-3)*catalan))/e
+ e*sqrt(((-27) + 2*e + 25*catalan))
+ log(((-1) + (-11)*e + 59*catalan))
+ ((3/20) + (21/20)*e + (3/20)*catalan)
+ ...
+
+ The numerical values are roughly as close to `\pi` as permitted by the
+ specified tolerance:
+
+ >>> e/log(6-4*e/3)
+ 3.14157719846001
+ >>> 135*e*catalan**2/98
+ 3.14166950419369
+ >>> sqrt(e-13+22*catalan)
+ 3.14158000062992
+ >>> log(24*e-6+4*catalan)-1
+ 3.14158791577159
+
+ **Symbolic processing**
+
+ The output formula can be evaluated as a Python expression.
+ Note however that if fractions (like '2/3') are present in
+ the formula, Python's :func:`~mpmath.eval()` may erroneously perform
+ integer division. Note also that the output is not necessarily
+ in the algebraically simplest form::
+
+ >>> identify(sqrt(2))
+ '(sqrt(8)/2)'
+
+ As a solution to both problems, consider using SymPy's
+ :func:`~mpmath.sympify` to convert the formula into a symbolic expression.
+ SymPy can be used to pretty-print or further simplify the formula
+ symbolically::
+
+ >>> from sympy import sympify # doctest: +SKIP
+ >>> sympify(identify(sqrt(2))) # doctest: +SKIP
+ 2**(1/2)
+
+ Sometimes :func:`~mpmath.identify` can simplify an expression further than
+ a symbolic algorithm::
+
+ >>> from sympy import simplify # doctest: +SKIP
+ >>> x = sympify('-1/(-3/2+(1/2)*5**(1/2))*(3/2-1/2*5**(1/2))**(1/2)') # doctest: +SKIP
+ >>> x # doctest: +SKIP
+ (3/2 - 5**(1/2)/2)**(-1/2)
+ >>> x = simplify(x) # doctest: +SKIP
+ >>> x # doctest: +SKIP
+ 2/(6 - 2*5**(1/2))**(1/2)
+ >>> mp.dps = 30 # doctest: +SKIP
+ >>> x = sympify(identify(x.evalf(30))) # doctest: +SKIP
+ >>> x # doctest: +SKIP
+ 1/2 + 5**(1/2)/2
+
+ (In fact, this functionality is available directly in SymPy as the
+ function :func:`~mpmath.nsimplify`, which is essentially a wrapper for
+ :func:`~mpmath.identify`.)
+
+ **Miscellaneous issues and limitations**
+
+ The input `x` must be a real number. All base constants must be
+ positive real numbers and must not be rationals or rational linear
+ combinations of each other.
+
+ The worst-case computation time grows quickly with the number of
+ base constants. Already with 3 or 4 base constants,
+ :func:`~mpmath.identify` may require several seconds to finish. To search
+ for relations among a large number of constants, you should
+ consider using :func:`~mpmath.pslq` directly.
+
+ The extended transformations are applied to x, not the constants
+ separately. As a result, ``identify`` will for example be able to
+ recognize ``exp(2*pi+3)`` with ``pi`` given as a base constant, but
+ not ``2*exp(pi)+3``. It will be able to recognize the latter if
+ ``exp(pi)`` is given explicitly as a base constant.
+
+ """
+
+ solutions = []
+
+ def addsolution(s):
+ if verbose: print("Found: ", s)
+ solutions.append(s)
+
+ x = ctx.mpf(x)
+
+ # Further along, x will be assumed positive
+ if x == 0:
+ if full: return ['0']
+ else: return '0'
+ if x < 0:
+ sol = ctx.identify(-x, constants, tol, maxcoeff, full, verbose)
+ if sol is None:
+ return sol
+ if full:
+ return ["-(%s)"%s for s in sol]
+ else:
+ return "-(%s)" % sol
+
+ if tol:
+ tol = ctx.mpf(tol)
+ else:
+ tol = ctx.eps**0.7
+ M = maxcoeff
+
+ if constants:
+ if isinstance(constants, dict):
+ constants = [(ctx.mpf(v), name) for (name, v) in sorted(constants.items())]
+ else:
+ namespace = dict((name, getattr(ctx,name)) for name in dir(ctx))
+ constants = [(eval(p, namespace), p) for p in constants]
+ else:
+ constants = []
+
+ # We always want to find at least rational terms
+ if 1 not in [value for (name, value) in constants]:
+ constants = [(ctx.mpf(1), '1')] + constants
+
+ # PSLQ with simple algebraic and functional transformations
+ for ft, ftn, red in transforms:
+ for c, cn in constants:
+ if red and cn == '1':
+ continue
+ t = ft(ctx,x,c)
+ # Prevent exponential transforms from wreaking havoc
+ if abs(t) > M**2 or abs(t) < tol:
+ continue
+ # Linear combination of base constants
+ r = ctx.pslq([t] + [a[0] for a in constants], tol, M)
+ s = None
+ if r is not None and max(abs(uw) for uw in r) <= M and r[0]:
+ s = pslqstring(r, constants)
+ # Quadratic algebraic numbers
+ else:
+ q = ctx.pslq([ctx.one, t, t**2], tol, M)
+ if q is not None and len(q) == 3 and q[2]:
+ aa, bb, cc = q
+ if max(abs(aa),abs(bb),abs(cc)) <= M:
+ s = quadraticstring(ctx,t,aa,bb,cc)
+ if s:
+ if cn == '1' and ('/$c' in ftn):
+ s = ftn.replace('$y', s).replace('/$c', '')
+ else:
+ s = ftn.replace('$y', s).replace('$c', cn)
+ addsolution(s)
+ if not full: return solutions[0]
+
+ if verbose:
+ print(".")
+
+ # Check for a direct multiplicative formula
+ if x != 1:
+ # Allow fractional powers of fractions
+ ilogs = [2,3,5,7]
+ # Watch out for existing fractional powers of fractions
+ logs = []
+ for a, s in constants:
+ if not sum(bool(ctx.findpoly(ctx.ln(a)/ctx.ln(i),1)) for i in ilogs):
+ logs.append((ctx.ln(a), s))
+ logs = [(ctx.ln(i),str(i)) for i in ilogs] + logs
+ r = ctx.pslq([ctx.ln(x)] + [a[0] for a in logs], tol, M)
+ if r is not None and max(abs(uw) for uw in r) <= M and r[0]:
+ addsolution(prodstring(r, logs))
+ if not full: return solutions[0]
+
+ if full:
+ return sorted(solutions, key=len)
+ else:
+ return None
+
+IdentificationMethods.pslq = pslq
+IdentificationMethods.findpoly = findpoly
+IdentificationMethods.identify = identify
+
+
+if __name__ == '__main__':
+ import doctest
+ doctest.testmod()
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/mpmath/math2.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/mpmath/math2.py
new file mode 100644
index 0000000000000000000000000000000000000000..302e25f509c18b2c76a2b62611f2765db84ab13e
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/mpmath/math2.py
@@ -0,0 +1,672 @@
+"""
+This module complements the math and cmath builtin modules by providing
+fast machine precision versions of some additional functions (gamma, ...)
+and wrapping math/cmath functions so that they can be called with either
+real or complex arguments.
+"""
+
+import operator
+import math
+import cmath
+
+# Irrational (?) constants
+pi = 3.1415926535897932385
+e = 2.7182818284590452354
+sqrt2 = 1.4142135623730950488
+sqrt5 = 2.2360679774997896964
+phi = 1.6180339887498948482
+ln2 = 0.69314718055994530942
+ln10 = 2.302585092994045684
+euler = 0.57721566490153286061
+catalan = 0.91596559417721901505
+khinchin = 2.6854520010653064453
+apery = 1.2020569031595942854
+
+logpi = 1.1447298858494001741
+
+def _mathfun_real(f_real, f_complex):
+ def f(x, **kwargs):
+ if type(x) is float:
+ return f_real(x)
+ if type(x) is complex:
+ return f_complex(x)
+ try:
+ x = float(x)
+ return f_real(x)
+ except (TypeError, ValueError):
+ x = complex(x)
+ return f_complex(x)
+ f.__name__ = f_real.__name__
+ return f
+
+def _mathfun(f_real, f_complex):
+ def f(x, **kwargs):
+ if type(x) is complex:
+ return f_complex(x)
+ try:
+ return f_real(float(x))
+ except (TypeError, ValueError):
+ return f_complex(complex(x))
+ f.__name__ = f_real.__name__
+ return f
+
+def _mathfun_n(f_real, f_complex):
+ def f(*args, **kwargs):
+ try:
+ return f_real(*(float(x) for x in args))
+ except (TypeError, ValueError):
+ return f_complex(*(complex(x) for x in args))
+ f.__name__ = f_real.__name__
+ return f
+
+# Workaround for non-raising log and sqrt in Python 2.5 and 2.4
+# on Unix system
+try:
+ math.log(-2.0)
+ def math_log(x):
+ if x <= 0.0:
+ raise ValueError("math domain error")
+ return math.log(x)
+ def math_sqrt(x):
+ if x < 0.0:
+ raise ValueError("math domain error")
+ return math.sqrt(x)
+except (ValueError, TypeError):
+ math_log = math.log
+ math_sqrt = math.sqrt
+
+pow = _mathfun_n(operator.pow, lambda x, y: complex(x)**y)
+log = _mathfun_n(math_log, cmath.log)
+sqrt = _mathfun(math_sqrt, cmath.sqrt)
+exp = _mathfun_real(math.exp, cmath.exp)
+
+cos = _mathfun_real(math.cos, cmath.cos)
+sin = _mathfun_real(math.sin, cmath.sin)
+tan = _mathfun_real(math.tan, cmath.tan)
+
+acos = _mathfun(math.acos, cmath.acos)
+asin = _mathfun(math.asin, cmath.asin)
+atan = _mathfun_real(math.atan, cmath.atan)
+
+cosh = _mathfun_real(math.cosh, cmath.cosh)
+sinh = _mathfun_real(math.sinh, cmath.sinh)
+tanh = _mathfun_real(math.tanh, cmath.tanh)
+
+floor = _mathfun_real(math.floor,
+ lambda z: complex(math.floor(z.real), math.floor(z.imag)))
+ceil = _mathfun_real(math.ceil,
+ lambda z: complex(math.ceil(z.real), math.ceil(z.imag)))
+
+
+cos_sin = _mathfun_real(lambda x: (math.cos(x), math.sin(x)),
+ lambda z: (cmath.cos(z), cmath.sin(z)))
+
+cbrt = _mathfun(lambda x: x**(1./3), lambda z: z**(1./3))
+
+def nthroot(x, n):
+ r = 1./n
+ try:
+ return float(x) ** r
+ except (ValueError, TypeError):
+ return complex(x) ** r
+
+def _sinpi_real(x):
+ if x < 0:
+ return -_sinpi_real(-x)
+ n, r = divmod(x, 0.5)
+ r *= pi
+ n %= 4
+ if n == 0: return math.sin(r)
+ if n == 1: return math.cos(r)
+ if n == 2: return -math.sin(r)
+ if n == 3: return -math.cos(r)
+
+def _cospi_real(x):
+ if x < 0:
+ x = -x
+ n, r = divmod(x, 0.5)
+ r *= pi
+ n %= 4
+ if n == 0: return math.cos(r)
+ if n == 1: return -math.sin(r)
+ if n == 2: return -math.cos(r)
+ if n == 3: return math.sin(r)
+
+def _sinpi_complex(z):
+ if z.real < 0:
+ return -_sinpi_complex(-z)
+ n, r = divmod(z.real, 0.5)
+ z = pi*complex(r, z.imag)
+ n %= 4
+ if n == 0: return cmath.sin(z)
+ if n == 1: return cmath.cos(z)
+ if n == 2: return -cmath.sin(z)
+ if n == 3: return -cmath.cos(z)
+
+def _cospi_complex(z):
+ if z.real < 0:
+ z = -z
+ n, r = divmod(z.real, 0.5)
+ z = pi*complex(r, z.imag)
+ n %= 4
+ if n == 0: return cmath.cos(z)
+ if n == 1: return -cmath.sin(z)
+ if n == 2: return -cmath.cos(z)
+ if n == 3: return cmath.sin(z)
+
+cospi = _mathfun_real(_cospi_real, _cospi_complex)
+sinpi = _mathfun_real(_sinpi_real, _sinpi_complex)
+
+def tanpi(x):
+ try:
+ return sinpi(x) / cospi(x)
+ except OverflowError:
+ if complex(x).imag > 10:
+ return 1j
+ if complex(x).imag < 10:
+ return -1j
+ raise
+
+def cotpi(x):
+ try:
+ return cospi(x) / sinpi(x)
+ except OverflowError:
+ if complex(x).imag > 10:
+ return -1j
+ if complex(x).imag < 10:
+ return 1j
+ raise
+
+INF = 1e300*1e300
+NINF = -INF
+NAN = INF-INF
+EPS = 2.2204460492503131e-16
+
+_exact_gamma = (INF, 1.0, 1.0, 2.0, 6.0, 24.0, 120.0, 720.0, 5040.0, 40320.0,
+ 362880.0, 3628800.0, 39916800.0, 479001600.0, 6227020800.0, 87178291200.0,
+ 1307674368000.0, 20922789888000.0, 355687428096000.0, 6402373705728000.0,
+ 121645100408832000.0, 2432902008176640000.0)
+
+_max_exact_gamma = len(_exact_gamma)-1
+
+# Lanczos coefficients used by the GNU Scientific Library
+_lanczos_g = 7
+_lanczos_p = (0.99999999999980993, 676.5203681218851, -1259.1392167224028,
+ 771.32342877765313, -176.61502916214059, 12.507343278686905,
+ -0.13857109526572012, 9.9843695780195716e-6, 1.5056327351493116e-7)
+
+def _gamma_real(x):
+ _intx = int(x)
+ if _intx == x:
+ if _intx <= 0:
+ #return (-1)**_intx * INF
+ raise ZeroDivisionError("gamma function pole")
+ if _intx <= _max_exact_gamma:
+ return _exact_gamma[_intx]
+ if x < 0.5:
+ # TODO: sinpi
+ return pi / (_sinpi_real(x)*_gamma_real(1-x))
+ else:
+ x -= 1.0
+ r = _lanczos_p[0]
+ for i in range(1, _lanczos_g+2):
+ r += _lanczos_p[i]/(x+i)
+ t = x + _lanczos_g + 0.5
+ return 2.506628274631000502417 * t**(x+0.5) * math.exp(-t) * r
+
+def _gamma_complex(x):
+ if not x.imag:
+ return complex(_gamma_real(x.real))
+ if x.real < 0.5:
+ # TODO: sinpi
+ return pi / (_sinpi_complex(x)*_gamma_complex(1-x))
+ else:
+ x -= 1.0
+ r = _lanczos_p[0]
+ for i in range(1, _lanczos_g+2):
+ r += _lanczos_p[i]/(x+i)
+ t = x + _lanczos_g + 0.5
+ return 2.506628274631000502417 * t**(x+0.5) * cmath.exp(-t) * r
+
+gamma = _mathfun_real(_gamma_real, _gamma_complex)
+
+def rgamma(x):
+ try:
+ return 1./gamma(x)
+ except ZeroDivisionError:
+ return x*0.0
+
+def factorial(x):
+ return gamma(x+1.0)
+
+def arg(x):
+ if type(x) is float:
+ return math.atan2(0.0,x)
+ return math.atan2(x.imag,x.real)
+
+# XXX: broken for negatives
+def loggamma(x):
+ if type(x) not in (float, complex):
+ try:
+ x = float(x)
+ except (ValueError, TypeError):
+ x = complex(x)
+ try:
+ xreal = x.real
+ ximag = x.imag
+ except AttributeError: # py2.5
+ xreal = x
+ ximag = 0.0
+ # Reflection formula
+ # http://functions.wolfram.com/GammaBetaErf/LogGamma/16/01/01/0003/
+ if xreal < 0.0:
+ if abs(x) < 0.5:
+ v = log(gamma(x))
+ if ximag == 0:
+ v = v.conjugate()
+ return v
+ z = 1-x
+ try:
+ re = z.real
+ im = z.imag
+ except AttributeError: # py2.5
+ re = z
+ im = 0.0
+ refloor = floor(re)
+ if im == 0.0:
+ imsign = 0
+ elif im < 0.0:
+ imsign = -1
+ else:
+ imsign = 1
+ return (-pi*1j)*abs(refloor)*(1-abs(imsign)) + logpi - \
+ log(sinpi(z-refloor)) - loggamma(z) + 1j*pi*refloor*imsign
+ if x == 1.0 or x == 2.0:
+ return x*0
+ p = 0.
+ while abs(x) < 11:
+ p -= log(x)
+ x += 1.0
+ s = 0.918938533204672742 + (x-0.5)*log(x) - x
+ r = 1./x
+ r2 = r*r
+ s += 0.083333333333333333333*r; r *= r2
+ s += -0.0027777777777777777778*r; r *= r2
+ s += 0.00079365079365079365079*r; r *= r2
+ s += -0.0005952380952380952381*r; r *= r2
+ s += 0.00084175084175084175084*r; r *= r2
+ s += -0.0019175269175269175269*r; r *= r2
+ s += 0.0064102564102564102564*r; r *= r2
+ s += -0.02955065359477124183*r
+ return s + p
+
+_psi_coeff = [
+0.083333333333333333333,
+-0.0083333333333333333333,
+0.003968253968253968254,
+-0.0041666666666666666667,
+0.0075757575757575757576,
+-0.021092796092796092796,
+0.083333333333333333333,
+-0.44325980392156862745,
+3.0539543302701197438,
+-26.456212121212121212]
+
+def _digamma_real(x):
+ _intx = int(x)
+ if _intx == x:
+ if _intx <= 0:
+ raise ZeroDivisionError("polygamma pole")
+ if x < 0.5:
+ x = 1.0-x
+ s = pi*cotpi(x)
+ else:
+ s = 0.0
+ while x < 10.0:
+ s -= 1.0/x
+ x += 1.0
+ x2 = x**-2
+ t = x2
+ for c in _psi_coeff:
+ s -= c*t
+ if t < 1e-20:
+ break
+ t *= x2
+ return s + math_log(x) - 0.5/x
+
+def _digamma_complex(x):
+ if not x.imag:
+ return complex(_digamma_real(x.real))
+ if x.real < 0.5:
+ x = 1.0-x
+ s = pi*cotpi(x)
+ else:
+ s = 0.0
+ while abs(x) < 10.0:
+ s -= 1.0/x
+ x += 1.0
+ x2 = x**-2
+ t = x2
+ for c in _psi_coeff:
+ s -= c*t
+ if abs(t) < 1e-20:
+ break
+ t *= x2
+ return s + cmath.log(x) - 0.5/x
+
+digamma = _mathfun_real(_digamma_real, _digamma_complex)
+
+# TODO: could implement complex erf and erfc here. Need
+# to find an accurate method (avoiding cancellation)
+# for approx. 1 < abs(x) < 9.
+
+_erfc_coeff_P = [
+ 1.0000000161203922312,
+ 2.1275306946297962644,
+ 2.2280433377390253297,
+ 1.4695509105618423961,
+ 0.66275911699770787537,
+ 0.20924776504163751585,
+ 0.045459713768411264339,
+ 0.0063065951710717791934,
+ 0.00044560259661560421715][::-1]
+
+_erfc_coeff_Q = [
+ 1.0000000000000000000,
+ 3.2559100272784894318,
+ 4.9019435608903239131,
+ 4.4971472894498014205,
+ 2.7845640601891186528,
+ 1.2146026030046904138,
+ 0.37647108453729465912,
+ 0.080970149639040548613,
+ 0.011178148899483545902,
+ 0.00078981003831980423513][::-1]
+
+def _polyval(coeffs, x):
+ p = coeffs[0]
+ for c in coeffs[1:]:
+ p = c + x*p
+ return p
+
+def _erf_taylor(x):
+ # Taylor series assuming 0 <= x <= 1
+ x2 = x*x
+ s = t = x
+ n = 1
+ while abs(t) > 1e-17:
+ t *= x2/n
+ s -= t/(n+n+1)
+ n += 1
+ t *= x2/n
+ s += t/(n+n+1)
+ n += 1
+ return 1.1283791670955125739*s
+
+def _erfc_mid(x):
+ # Rational approximation assuming 0 <= x <= 9
+ return exp(-x*x)*_polyval(_erfc_coeff_P,x)/_polyval(_erfc_coeff_Q,x)
+
+def _erfc_asymp(x):
+ # Asymptotic expansion assuming x >= 9
+ x2 = x*x
+ v = exp(-x2)/x*0.56418958354775628695
+ r = t = 0.5 / x2
+ s = 1.0
+ for n in range(1,22,4):
+ s -= t
+ t *= r * (n+2)
+ s += t
+ t *= r * (n+4)
+ if abs(t) < 1e-17:
+ break
+ return s * v
+
+def erf(x):
+ """
+ erf of a real number.
+ """
+ x = float(x)
+ if x != x:
+ return x
+ if x < 0.0:
+ return -erf(-x)
+ if x >= 1.0:
+ if x >= 6.0:
+ return 1.0
+ return 1.0 - _erfc_mid(x)
+ return _erf_taylor(x)
+
+def erfc(x):
+ """
+ erfc of a real number.
+ """
+ x = float(x)
+ if x != x:
+ return x
+ if x < 0.0:
+ if x < -6.0:
+ return 2.0
+ return 2.0-erfc(-x)
+ if x > 9.0:
+ return _erfc_asymp(x)
+ if x >= 1.0:
+ return _erfc_mid(x)
+ return 1.0 - _erf_taylor(x)
+
+gauss42 = [\
+(0.99839961899006235, 0.0041059986046490839),
+(-0.99839961899006235, 0.0041059986046490839),
+(0.9915772883408609, 0.009536220301748501),
+(-0.9915772883408609,0.009536220301748501),
+(0.97934250806374812, 0.014922443697357493),
+(-0.97934250806374812, 0.014922443697357493),
+(0.96175936533820439,0.020227869569052644),
+(-0.96175936533820439, 0.020227869569052644),
+(0.93892355735498811, 0.025422959526113047),
+(-0.93892355735498811,0.025422959526113047),
+(0.91095972490412735, 0.030479240699603467),
+(-0.91095972490412735, 0.030479240699603467),
+(0.87802056981217269,0.03536907109759211),
+(-0.87802056981217269, 0.03536907109759211),
+(0.8402859832618168, 0.040065735180692258),
+(-0.8402859832618168,0.040065735180692258),
+(0.7979620532554873, 0.044543577771965874),
+(-0.7979620532554873, 0.044543577771965874),
+(0.75127993568948048,0.048778140792803244),
+(-0.75127993568948048, 0.048778140792803244),
+(0.70049459055617114, 0.052746295699174064),
+(-0.70049459055617114,0.052746295699174064),
+(0.64588338886924779, 0.056426369358018376),
+(-0.64588338886924779, 0.056426369358018376),
+(0.58774459748510932, 0.059798262227586649),
+(-0.58774459748510932, 0.059798262227586649),
+(0.5263957499311922, 0.062843558045002565),
+(-0.5263957499311922, 0.062843558045002565),
+(0.46217191207042191, 0.065545624364908975),
+(-0.46217191207042191, 0.065545624364908975),
+(0.39542385204297503, 0.067889703376521934),
+(-0.39542385204297503, 0.067889703376521934),
+(0.32651612446541151, 0.069862992492594159),
+(-0.32651612446541151, 0.069862992492594159),
+(0.25582507934287907, 0.071454714265170971),
+(-0.25582507934287907, 0.071454714265170971),
+(0.18373680656485453, 0.072656175243804091),
+(-0.18373680656485453, 0.072656175243804091),
+(0.11064502720851986, 0.073460813453467527),
+(-0.11064502720851986, 0.073460813453467527),
+(0.036948943165351772, 0.073864234232172879),
+(-0.036948943165351772, 0.073864234232172879)]
+
+EI_ASYMP_CONVERGENCE_RADIUS = 40.0
+
+def ei_asymp(z, _e1=False):
+ r = 1./z
+ s = t = 1.0
+ k = 1
+ while 1:
+ t *= k*r
+ s += t
+ if abs(t) < 1e-16:
+ break
+ k += 1
+ v = s*exp(z)/z
+ if _e1:
+ if type(z) is complex:
+ zreal = z.real
+ zimag = z.imag
+ else:
+ zreal = z
+ zimag = 0.0
+ if zimag == 0.0 and zreal > 0.0:
+ v += pi*1j
+ else:
+ if type(z) is complex:
+ if z.imag > 0:
+ v += pi*1j
+ if z.imag < 0:
+ v -= pi*1j
+ return v
+
+def ei_taylor(z, _e1=False):
+ s = t = z
+ k = 2
+ while 1:
+ t = t*z/k
+ term = t/k
+ if abs(term) < 1e-17:
+ break
+ s += term
+ k += 1
+ s += euler
+ if _e1:
+ s += log(-z)
+ else:
+ if type(z) is float or z.imag == 0.0:
+ s += math_log(abs(z))
+ else:
+ s += cmath.log(z)
+ return s
+
+def ei(z, _e1=False):
+ typez = type(z)
+ if typez not in (float, complex):
+ try:
+ z = float(z)
+ typez = float
+ except (TypeError, ValueError):
+ z = complex(z)
+ typez = complex
+ if not z:
+ return -INF
+ absz = abs(z)
+ if absz > EI_ASYMP_CONVERGENCE_RADIUS:
+ return ei_asymp(z, _e1)
+ elif absz <= 2.0 or (typez is float and z > 0.0):
+ return ei_taylor(z, _e1)
+ # Integrate, starting from whichever is smaller of a Taylor
+ # series value or an asymptotic series value
+ if typez is complex and z.real > 0.0:
+ zref = z / absz
+ ref = ei_taylor(zref, _e1)
+ else:
+ zref = EI_ASYMP_CONVERGENCE_RADIUS * z / absz
+ ref = ei_asymp(zref, _e1)
+ C = (zref-z)*0.5
+ D = (zref+z)*0.5
+ s = 0.0
+ if type(z) is complex:
+ _exp = cmath.exp
+ else:
+ _exp = math.exp
+ for x,w in gauss42:
+ t = C*x+D
+ s += w*_exp(t)/t
+ ref -= C*s
+ return ref
+
+def e1(z):
+ # hack to get consistent signs if the imaginary part if 0
+ # and signed
+ typez = type(z)
+ if type(z) not in (float, complex):
+ try:
+ z = float(z)
+ typez = float
+ except (TypeError, ValueError):
+ z = complex(z)
+ typez = complex
+ if typez is complex and not z.imag:
+ z = complex(z.real, 0.0)
+ # end hack
+ return -ei(-z, _e1=True)
+
+_zeta_int = [\
+-0.5,
+0.0,
+1.6449340668482264365,1.2020569031595942854,1.0823232337111381915,
+1.0369277551433699263,1.0173430619844491397,1.0083492773819228268,
+1.0040773561979443394,1.0020083928260822144,1.0009945751278180853,
+1.0004941886041194646,1.0002460865533080483,1.0001227133475784891,
+1.0000612481350587048,1.0000305882363070205,1.0000152822594086519,
+1.0000076371976378998,1.0000038172932649998,1.0000019082127165539,
+1.0000009539620338728,1.0000004769329867878,1.0000002384505027277,
+1.0000001192199259653,1.0000000596081890513,1.0000000298035035147,
+1.0000000149015548284]
+
+_zeta_P = [-3.50000000087575873, -0.701274355654678147,
+-0.0672313458590012612, -0.00398731457954257841,
+-0.000160948723019303141, -4.67633010038383371e-6,
+-1.02078104417700585e-7, -1.68030037095896287e-9,
+-1.85231868742346722e-11][::-1]
+
+_zeta_Q = [1.00000000000000000, -0.936552848762465319,
+-0.0588835413263763741, -0.00441498861482948666,
+-0.000143416758067432622, -5.10691659585090782e-6,
+-9.58813053268913799e-8, -1.72963791443181972e-9,
+-1.83527919681474132e-11][::-1]
+
+_zeta_1 = [3.03768838606128127e-10, -1.21924525236601262e-8,
+2.01201845887608893e-7, -1.53917240683468381e-6,
+-5.09890411005967954e-7, 0.000122464707271619326,
+-0.000905721539353130232, -0.00239315326074843037,
+0.084239750013159168, 0.418938517907442414, 0.500000001921884009]
+
+_zeta_0 = [-3.46092485016748794e-10, -6.42610089468292485e-9,
+1.76409071536679773e-7, -1.47141263991560698e-6, -6.38880222546167613e-7,
+0.000122641099800668209, -0.000905894913516772796, -0.00239303348507992713,
+0.0842396947501199816, 0.418938533204660256, 0.500000000000000052]
+
+def zeta(s):
+ """
+ Riemann zeta function, real argument
+ """
+ if not isinstance(s, (float, int)):
+ try:
+ s = float(s)
+ except (ValueError, TypeError):
+ try:
+ s = complex(s)
+ if not s.imag:
+ return complex(zeta(s.real))
+ except (ValueError, TypeError):
+ pass
+ raise NotImplementedError
+ if s == 1:
+ raise ValueError("zeta(1) pole")
+ if s >= 27:
+ return 1.0 + 2.0**(-s) + 3.0**(-s)
+ n = int(s)
+ if n == s:
+ if n >= 0:
+ return _zeta_int[n]
+ if not (n % 2):
+ return 0.0
+ if s <= 0.0:
+ return 2.**s*pi**(s-1)*_sinpi_real(0.5*s)*_gamma_real(1-s)*zeta(1-s)
+ if s <= 2.0:
+ if s <= 1.0:
+ return _polyval(_zeta_0,s)/(s-1)
+ return _polyval(_zeta_1,s)/(s-1)
+ z = _polyval(_zeta_P,s) / _polyval(_zeta_Q,s)
+ return 1.0 + 2.0**(-s) + 3.0**(-s) + 4.0**(-s)*z
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/mpmath/rational.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/mpmath/rational.py
new file mode 100644
index 0000000000000000000000000000000000000000..58745205319ac3548ad5feb49371d2d154b2d3c8
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/mpmath/rational.py
@@ -0,0 +1,240 @@
+import operator
+import sys
+from .libmp import int_types, mpf_hash, bitcount, from_man_exp, HASH_MODULUS
+
+new = object.__new__
+
+def create_reduced(p, q, _cache={}):
+ key = p, q
+ if key in _cache:
+ return _cache[key]
+ x, y = p, q
+ while y:
+ x, y = y, x % y
+ if x != 1:
+ p //= x
+ q //= x
+ v = new(mpq)
+ v._mpq_ = p, q
+ # Speedup integers, half-integers and other small fractions
+ if q <= 4 and abs(key[0]) < 100:
+ _cache[key] = v
+ return v
+
+class mpq(object):
+ """
+ Exact rational type, currently only intended for internal use.
+ """
+
+ __slots__ = ["_mpq_"]
+
+ def __new__(cls, p, q=1):
+ if type(p) is tuple:
+ p, q = p
+ elif hasattr(p, '_mpq_'):
+ p, q = p._mpq_
+ return create_reduced(p, q)
+
+ def __repr__(s):
+ return "mpq(%s,%s)" % s._mpq_
+
+ def __str__(s):
+ return "(%s/%s)" % s._mpq_
+
+ def __int__(s):
+ a, b = s._mpq_
+ return a // b
+
+ def __nonzero__(s):
+ return bool(s._mpq_[0])
+
+ __bool__ = __nonzero__
+
+ def __hash__(s):
+ a, b = s._mpq_
+ if sys.version_info >= (3, 2):
+ inverse = pow(b, HASH_MODULUS-2, HASH_MODULUS)
+ if not inverse:
+ h = sys.hash_info.inf
+ else:
+ h = (abs(a) * inverse) % HASH_MODULUS
+ if a < 0: h = -h
+ if h == -1: h = -2
+ return h
+ else:
+ if b == 1:
+ return hash(a)
+ # Power of two: mpf compatible hash
+ if not (b & (b-1)):
+ return mpf_hash(from_man_exp(a, 1-bitcount(b)))
+ return hash((a,b))
+
+ def __eq__(s, t):
+ ttype = type(t)
+ if ttype is mpq:
+ return s._mpq_ == t._mpq_
+ if ttype in int_types:
+ a, b = s._mpq_
+ if b != 1:
+ return False
+ return a == t
+ return NotImplemented
+
+ def __ne__(s, t):
+ ttype = type(t)
+ if ttype is mpq:
+ return s._mpq_ != t._mpq_
+ if ttype in int_types:
+ a, b = s._mpq_
+ if b != 1:
+ return True
+ return a != t
+ return NotImplemented
+
+ def _cmp(s, t, op):
+ ttype = type(t)
+ if ttype in int_types:
+ a, b = s._mpq_
+ return op(a, t*b)
+ if ttype is mpq:
+ a, b = s._mpq_
+ c, d = t._mpq_
+ return op(a*d, b*c)
+ return NotImplementedError
+
+ def __lt__(s, t): return s._cmp(t, operator.lt)
+ def __le__(s, t): return s._cmp(t, operator.le)
+ def __gt__(s, t): return s._cmp(t, operator.gt)
+ def __ge__(s, t): return s._cmp(t, operator.ge)
+
+ def __abs__(s):
+ a, b = s._mpq_
+ if a >= 0:
+ return s
+ v = new(mpq)
+ v._mpq_ = -a, b
+ return v
+
+ def __neg__(s):
+ a, b = s._mpq_
+ v = new(mpq)
+ v._mpq_ = -a, b
+ return v
+
+ def __pos__(s):
+ return s
+
+ def __add__(s, t):
+ ttype = type(t)
+ if ttype is mpq:
+ a, b = s._mpq_
+ c, d = t._mpq_
+ return create_reduced(a*d+b*c, b*d)
+ if ttype in int_types:
+ a, b = s._mpq_
+ v = new(mpq)
+ v._mpq_ = a+b*t, b
+ return v
+ return NotImplemented
+
+ __radd__ = __add__
+
+ def __sub__(s, t):
+ ttype = type(t)
+ if ttype is mpq:
+ a, b = s._mpq_
+ c, d = t._mpq_
+ return create_reduced(a*d-b*c, b*d)
+ if ttype in int_types:
+ a, b = s._mpq_
+ v = new(mpq)
+ v._mpq_ = a-b*t, b
+ return v
+ return NotImplemented
+
+ def __rsub__(s, t):
+ ttype = type(t)
+ if ttype is mpq:
+ a, b = s._mpq_
+ c, d = t._mpq_
+ return create_reduced(b*c-a*d, b*d)
+ if ttype in int_types:
+ a, b = s._mpq_
+ v = new(mpq)
+ v._mpq_ = b*t-a, b
+ return v
+ return NotImplemented
+
+ def __mul__(s, t):
+ ttype = type(t)
+ if ttype is mpq:
+ a, b = s._mpq_
+ c, d = t._mpq_
+ return create_reduced(a*c, b*d)
+ if ttype in int_types:
+ a, b = s._mpq_
+ return create_reduced(a*t, b)
+ return NotImplemented
+
+ __rmul__ = __mul__
+
+ def __div__(s, t):
+ ttype = type(t)
+ if ttype is mpq:
+ a, b = s._mpq_
+ c, d = t._mpq_
+ return create_reduced(a*d, b*c)
+ if ttype in int_types:
+ a, b = s._mpq_
+ return create_reduced(a, b*t)
+ return NotImplemented
+
+ def __rdiv__(s, t):
+ ttype = type(t)
+ if ttype is mpq:
+ a, b = s._mpq_
+ c, d = t._mpq_
+ return create_reduced(b*c, a*d)
+ if ttype in int_types:
+ a, b = s._mpq_
+ return create_reduced(b*t, a)
+ return NotImplemented
+
+ def __pow__(s, t):
+ ttype = type(t)
+ if ttype in int_types:
+ a, b = s._mpq_
+ if t:
+ if t < 0:
+ a, b, t = b, a, -t
+ v = new(mpq)
+ v._mpq_ = a**t, b**t
+ return v
+ raise ZeroDivisionError
+ return NotImplemented
+
+
+mpq_1 = mpq((1,1))
+mpq_0 = mpq((0,1))
+mpq_1_2 = mpq((1,2))
+mpq_3_2 = mpq((3,2))
+mpq_1_4 = mpq((1,4))
+mpq_1_16 = mpq((1,16))
+mpq_3_16 = mpq((3,16))
+mpq_5_2 = mpq((5,2))
+mpq_3_4 = mpq((3,4))
+mpq_7_4 = mpq((7,4))
+mpq_5_4 = mpq((5,4))
+
+
+# Register with "numbers" ABC
+# We do not subclass, hence we do not use the @abstractmethod checks. While
+# this is less invasive it may turn out that we do not actually support
+# parts of the expected interfaces. See
+# http://docs.python.org/2/library/numbers.html for list of abstract
+# methods.
+try:
+ import numbers
+ numbers.Rational.register(mpq)
+except ImportError:
+ pass
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/mpmath/usertools.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/mpmath/usertools.py
new file mode 100644
index 0000000000000000000000000000000000000000..8028a4c46f1c635a6857f1f2de48ac6675d3c6d3
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/mpmath/usertools.py
@@ -0,0 +1,93 @@
+
+def monitor(f, input='print', output='print'):
+ """
+ Returns a wrapped copy of *f* that monitors evaluation by calling
+ *input* with every input (*args*, *kwargs*) passed to *f* and
+ *output* with every value returned from *f*. The default action
+ (specify using the special string value ``'print'``) is to print
+ inputs and outputs to stdout, along with the total evaluation
+ count::
+
+ >>> from mpmath import *
+ >>> mp.dps = 5; mp.pretty = False
+ >>> diff(monitor(exp), 1) # diff will eval f(x-h) and f(x+h)
+ in 0 (mpf('0.99999999906867742538452148'),) {}
+ out 0 mpf('2.7182818259274480055282064')
+ in 1 (mpf('1.0000000009313225746154785'),) {}
+ out 1 mpf('2.7182818309906424675501024')
+ mpf('2.7182808')
+
+ To disable either the input or the output handler, you may
+ pass *None* as argument.
+
+ Custom input and output handlers may be used e.g. to store
+ results for later analysis::
+
+ >>> mp.dps = 15
+ >>> input = []
+ >>> output = []
+ >>> findroot(monitor(sin, input.append, output.append), 3.0)
+ mpf('3.1415926535897932')
+ >>> len(input) # Count number of evaluations
+ 9
+ >>> print(input[3]); print(output[3])
+ ((mpf('3.1415076583334066'),), {})
+ 8.49952562843408e-5
+ >>> print(input[4]); print(output[4])
+ ((mpf('3.1415928201669122'),), {})
+ -1.66577118985331e-7
+
+ """
+ if not input:
+ input = lambda v: None
+ elif input == 'print':
+ incount = [0]
+ def input(value):
+ args, kwargs = value
+ print("in %s %r %r" % (incount[0], args, kwargs))
+ incount[0] += 1
+ if not output:
+ output = lambda v: None
+ elif output == 'print':
+ outcount = [0]
+ def output(value):
+ print("out %s %r" % (outcount[0], value))
+ outcount[0] += 1
+ def f_monitored(*args, **kwargs):
+ input((args, kwargs))
+ v = f(*args, **kwargs)
+ output(v)
+ return v
+ return f_monitored
+
+def timing(f, *args, **kwargs):
+ """
+ Returns time elapsed for evaluating ``f()``. Optionally arguments
+ may be passed to time the execution of ``f(*args, **kwargs)``.
+
+ If the first call is very quick, ``f`` is called
+ repeatedly and the best time is returned.
+ """
+ once = kwargs.get('once')
+ if 'once' in kwargs:
+ del kwargs['once']
+ if args or kwargs:
+ if len(args) == 1 and not kwargs:
+ arg = args[0]
+ g = lambda: f(arg)
+ else:
+ g = lambda: f(*args, **kwargs)
+ else:
+ g = f
+ from timeit import default_timer as clock
+ t1=clock(); v=g(); t2=clock(); t=t2-t1
+ if t > 0.05 or once:
+ return t
+ for i in range(3):
+ t1=clock();
+ # Evaluate multiple times because the timer function
+ # has a significant overhead
+ g();g();g();g();g();g();g();g();g();g()
+ t2=clock()
+ t=min(t,(t2-t1)/10)
+ return t
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/mpmath/visualization.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/mpmath/visualization.py
new file mode 100644
index 0000000000000000000000000000000000000000..17e12e97bead4f2977b59361a4de7672f0e9b75f
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/mpmath/visualization.py
@@ -0,0 +1,313 @@
+"""
+Plotting (requires matplotlib)
+"""
+
+from colorsys import hsv_to_rgb, hls_to_rgb
+from .libmp import NoConvergence
+from .libmp.backend import xrange
+
+class VisualizationMethods(object):
+ plot_ignore = (ValueError, ArithmeticError, ZeroDivisionError, NoConvergence)
+
+def plot(ctx, f, xlim=[-5,5], ylim=None, points=200, file=None, dpi=None,
+ singularities=[], axes=None):
+ r"""
+ Shows a simple 2D plot of a function `f(x)` or list of functions
+ `[f_0(x), f_1(x), \ldots, f_n(x)]` over a given interval
+ specified by *xlim*. Some examples::
+
+ plot(lambda x: exp(x)*li(x), [1, 4])
+ plot([cos, sin], [-4, 4])
+ plot([fresnels, fresnelc], [-4, 4])
+ plot([sqrt, cbrt], [-4, 4])
+ plot(lambda t: zeta(0.5+t*j), [-20, 20])
+ plot([floor, ceil, abs, sign], [-5, 5])
+
+ Points where the function raises a numerical exception or
+ returns an infinite value are removed from the graph.
+ Singularities can also be excluded explicitly
+ as follows (useful for removing erroneous vertical lines)::
+
+ plot(cot, ylim=[-5, 5]) # bad
+ plot(cot, ylim=[-5, 5], singularities=[-pi, 0, pi]) # good
+
+ For parts where the function assumes complex values, the
+ real part is plotted with dashes and the imaginary part
+ is plotted with dots.
+
+ .. note :: This function requires matplotlib (pylab).
+ """
+ if file:
+ axes = None
+ fig = None
+ if not axes:
+ import pylab
+ fig = pylab.figure()
+ axes = fig.add_subplot(111)
+ if not isinstance(f, (tuple, list)):
+ f = [f]
+ a, b = xlim
+ colors = ['b', 'r', 'g', 'm', 'k']
+ for n, func in enumerate(f):
+ x = ctx.arange(a, b, (b-a)/float(points))
+ segments = []
+ segment = []
+ in_complex = False
+ for i in xrange(len(x)):
+ try:
+ if i != 0:
+ for sing in singularities:
+ if x[i-1] <= sing and x[i] >= sing:
+ raise ValueError
+ v = func(x[i])
+ if ctx.isnan(v) or abs(v) > 1e300:
+ raise ValueError
+ if hasattr(v, "imag") and v.imag:
+ re = float(v.real)
+ im = float(v.imag)
+ if not in_complex:
+ in_complex = True
+ segments.append(segment)
+ segment = []
+ segment.append((float(x[i]), re, im))
+ else:
+ if in_complex:
+ in_complex = False
+ segments.append(segment)
+ segment = []
+ if hasattr(v, "real"):
+ v = v.real
+ segment.append((float(x[i]), v))
+ except ctx.plot_ignore:
+ if segment:
+ segments.append(segment)
+ segment = []
+ if segment:
+ segments.append(segment)
+ for segment in segments:
+ x = [s[0] for s in segment]
+ y = [s[1] for s in segment]
+ if not x:
+ continue
+ c = colors[n % len(colors)]
+ if len(segment[0]) == 3:
+ z = [s[2] for s in segment]
+ axes.plot(x, y, '--'+c, linewidth=3)
+ axes.plot(x, z, ':'+c, linewidth=3)
+ else:
+ axes.plot(x, y, c, linewidth=3)
+ axes.set_xlim([float(_) for _ in xlim])
+ if ylim:
+ axes.set_ylim([float(_) for _ in ylim])
+ axes.set_xlabel('x')
+ axes.set_ylabel('f(x)')
+ axes.grid(True)
+ if fig:
+ if file:
+ pylab.savefig(file, dpi=dpi)
+ else:
+ pylab.show()
+
+def default_color_function(ctx, z):
+ if ctx.isinf(z):
+ return (1.0, 1.0, 1.0)
+ if ctx.isnan(z):
+ return (0.5, 0.5, 0.5)
+ pi = 3.1415926535898
+ a = (float(ctx.arg(z)) + ctx.pi) / (2*ctx.pi)
+ a = (a + 0.5) % 1.0
+ b = 1.0 - float(1/(1.0+abs(z)**0.3))
+ return hls_to_rgb(a, b, 0.8)
+
+blue_orange_colors = [
+ (-1.0, (0.0, 0.0, 0.0)),
+ (-0.95, (0.1, 0.2, 0.5)), # dark blue
+ (-0.5, (0.0, 0.5, 1.0)), # blueish
+ (-0.05, (0.4, 0.8, 0.8)), # cyanish
+ ( 0.0, (1.0, 1.0, 1.0)),
+ ( 0.05, (1.0, 0.9, 0.3)), # yellowish
+ ( 0.5, (0.9, 0.5, 0.0)), # orangeish
+ ( 0.95, (0.7, 0.1, 0.0)), # redish
+ ( 1.0, (0.0, 0.0, 0.0)),
+ ( 2.0, (0.0, 0.0, 0.0)),
+]
+
+def phase_color_function(ctx, z):
+ if ctx.isinf(z):
+ return (1.0, 1.0, 1.0)
+ if ctx.isnan(z):
+ return (0.5, 0.5, 0.5)
+ pi = 3.1415926535898
+ w = float(ctx.arg(z)) / pi
+ w = max(min(w, 1.0), -1.0)
+ for i in range(1,len(blue_orange_colors)):
+ if blue_orange_colors[i][0] > w:
+ a, (ra, ga, ba) = blue_orange_colors[i-1]
+ b, (rb, gb, bb) = blue_orange_colors[i]
+ s = (w-a) / (b-a)
+ return ra+(rb-ra)*s, ga+(gb-ga)*s, ba+(bb-ba)*s
+
+def cplot(ctx, f, re=[-5,5], im=[-5,5], points=2000, color=None,
+ verbose=False, file=None, dpi=None, axes=None):
+ """
+ Plots the given complex-valued function *f* over a rectangular part
+ of the complex plane specified by the pairs of intervals *re* and *im*.
+ For example::
+
+ cplot(lambda z: z, [-2, 2], [-10, 10])
+ cplot(exp)
+ cplot(zeta, [0, 1], [0, 50])
+
+ By default, the complex argument (phase) is shown as color (hue) and
+ the magnitude is show as brightness. You can also supply a
+ custom color function (*color*). This function should take a
+ complex number as input and return an RGB 3-tuple containing
+ floats in the range 0.0-1.0.
+
+ Alternatively, you can select a builtin color function by passing
+ a string as *color*:
+
+ * "default" - default color scheme
+ * "phase" - a color scheme that only renders the phase of the function,
+ with white for positive reals, black for negative reals, gold in the
+ upper half plane, and blue in the lower half plane.
+
+ To obtain a sharp image, the number of points may need to be
+ increased to 100,000 or thereabout. Since evaluating the
+ function that many times is likely to be slow, the 'verbose'
+ option is useful to display progress.
+
+ .. note :: This function requires matplotlib (pylab).
+ """
+ if color is None or color == "default":
+ color = ctx.default_color_function
+ if color == "phase":
+ color = ctx.phase_color_function
+ import pylab
+ if file:
+ axes = None
+ fig = None
+ if not axes:
+ fig = pylab.figure()
+ axes = fig.add_subplot(111)
+ rea, reb = re
+ ima, imb = im
+ dre = reb - rea
+ dim = imb - ima
+ M = int(ctx.sqrt(points*dre/dim)+1)
+ N = int(ctx.sqrt(points*dim/dre)+1)
+ x = pylab.linspace(rea, reb, M)
+ y = pylab.linspace(ima, imb, N)
+ # Note: we have to be careful to get the right rotation.
+ # Test with these plots:
+ # cplot(lambda z: z if z.real < 0 else 0)
+ # cplot(lambda z: z if z.imag < 0 else 0)
+ w = pylab.zeros((N, M, 3))
+ for n in xrange(N):
+ for m in xrange(M):
+ z = ctx.mpc(x[m], y[n])
+ try:
+ v = color(f(z))
+ except ctx.plot_ignore:
+ v = (0.5, 0.5, 0.5)
+ w[n,m] = v
+ if verbose:
+ print(str(n) + ' of ' + str(N))
+ rea, reb, ima, imb = [float(_) for _ in [rea, reb, ima, imb]]
+ axes.imshow(w, extent=(rea, reb, ima, imb), origin='lower')
+ axes.set_xlabel('Re(z)')
+ axes.set_ylabel('Im(z)')
+ if fig:
+ if file:
+ pylab.savefig(file, dpi=dpi)
+ else:
+ pylab.show()
+
+def splot(ctx, f, u=[-5,5], v=[-5,5], points=100, keep_aspect=True, \
+ wireframe=False, file=None, dpi=None, axes=None):
+ """
+ Plots the surface defined by `f`.
+
+ If `f` returns a single component, then this plots the surface
+ defined by `z = f(x,y)` over the rectangular domain with
+ `x = u` and `y = v`.
+
+ If `f` returns three components, then this plots the parametric
+ surface `x, y, z = f(u,v)` over the pairs of intervals `u` and `v`.
+
+ For example, to plot a simple function::
+
+ >>> from mpmath import *
+ >>> f = lambda x, y: sin(x+y)*cos(y)
+ >>> splot(f, [-pi,pi], [-pi,pi]) # doctest: +SKIP
+
+ Plotting a donut::
+
+ >>> r, R = 1, 2.5
+ >>> f = lambda u, v: [r*cos(u), (R+r*sin(u))*cos(v), (R+r*sin(u))*sin(v)]
+ >>> splot(f, [0, 2*pi], [0, 2*pi]) # doctest: +SKIP
+
+ .. note :: This function requires matplotlib (pylab) 0.98.5.3 or higher.
+ """
+ import pylab
+ import mpl_toolkits.mplot3d as mplot3d
+ if file:
+ axes = None
+ fig = None
+ if not axes:
+ fig = pylab.figure()
+ axes = mplot3d.axes3d.Axes3D(fig)
+ ua, ub = u
+ va, vb = v
+ du = ub - ua
+ dv = vb - va
+ if not isinstance(points, (list, tuple)):
+ points = [points, points]
+ M, N = points
+ u = pylab.linspace(ua, ub, M)
+ v = pylab.linspace(va, vb, N)
+ x, y, z = [pylab.zeros((M, N)) for i in xrange(3)]
+ xab, yab, zab = [[0, 0] for i in xrange(3)]
+ for n in xrange(N):
+ for m in xrange(M):
+ fdata = f(ctx.convert(u[m]), ctx.convert(v[n]))
+ try:
+ x[m,n], y[m,n], z[m,n] = fdata
+ except TypeError:
+ x[m,n], y[m,n], z[m,n] = u[m], v[n], fdata
+ for c, cab in [(x[m,n], xab), (y[m,n], yab), (z[m,n], zab)]:
+ if c < cab[0]:
+ cab[0] = c
+ if c > cab[1]:
+ cab[1] = c
+ if wireframe:
+ axes.plot_wireframe(x, y, z, rstride=4, cstride=4)
+ else:
+ axes.plot_surface(x, y, z, rstride=4, cstride=4)
+ axes.set_xlabel('x')
+ axes.set_ylabel('y')
+ axes.set_zlabel('z')
+ if keep_aspect:
+ dx, dy, dz = [cab[1] - cab[0] for cab in [xab, yab, zab]]
+ maxd = max(dx, dy, dz)
+ if dx < maxd:
+ delta = maxd - dx
+ axes.set_xlim3d(xab[0] - delta / 2.0, xab[1] + delta / 2.0)
+ if dy < maxd:
+ delta = maxd - dy
+ axes.set_ylim3d(yab[0] - delta / 2.0, yab[1] + delta / 2.0)
+ if dz < maxd:
+ delta = maxd - dz
+ axes.set_zlim3d(zab[0] - delta / 2.0, zab[1] + delta / 2.0)
+ if fig:
+ if file:
+ pylab.savefig(file, dpi=dpi)
+ else:
+ pylab.show()
+
+
+VisualizationMethods.plot = plot
+VisualizationMethods.default_color_function = default_color_function
+VisualizationMethods.phase_color_function = phase_color_function
+VisualizationMethods.cplot = cplot
+VisualizationMethods.splot = splot
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/__info__.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/__info__.py
new file mode 100644
index 0000000000000000000000000000000000000000..ecb75d49504fab7a43ef9bb21cf637dd7a7cd5ef
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/__info__.py
@@ -0,0 +1,221 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2024 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD. The full license text is available at:
+# - https://github.com/uqfoundation/multiprocess/blob/master/LICENSE
+'''
+-----------------------------------------------------------------
+multiprocess: better multiprocessing and multithreading in Python
+-----------------------------------------------------------------
+
+About Multiprocess
+==================
+
+``multiprocess`` is a fork of ``multiprocessing``. ``multiprocess`` extends ``multiprocessing`` to provide enhanced serialization, using `dill`. ``multiprocess`` leverages ``multiprocessing`` to support the spawning of processes using the API of the Python standard library's ``threading`` module. ``multiprocessing`` has been distributed as part of the standard library since Python 2.6.
+
+``multiprocess`` is part of ``pathos``, a Python framework for heterogeneous computing.
+``multiprocess`` is in active development, so any user feedback, bug reports, comments,
+or suggestions are highly appreciated. A list of issues is located at https://github.com/uqfoundation/multiprocess/issues, with a legacy list maintained at https://uqfoundation.github.io/project/pathos/query.
+
+
+Major Features
+==============
+
+``multiprocess`` enables:
+
+ - objects to be transferred between processes using pipes or multi-producer/multi-consumer queues
+ - objects to be shared between processes using a server process or (for simple data) shared memory
+
+``multiprocess`` provides:
+
+ - equivalents of all the synchronization primitives in ``threading``
+ - a ``Pool`` class to facilitate submitting tasks to worker processes
+ - enhanced serialization, using ``dill``
+
+
+Current Release
+===============
+
+The latest released version of ``multiprocess`` is available from:
+
+ https://pypi.org/project/multiprocess
+
+``multiprocess`` is distributed under a 3-clause BSD license, and is a fork of ``multiprocessing``.
+
+
+Development Version
+===================
+
+You can get the latest development version with all the shiny new features at:
+
+ https://github.com/uqfoundation
+
+If you have a new contribution, please submit a pull request.
+
+
+Installation
+============
+
+``multiprocess`` can be installed with ``pip``::
+
+ $ pip install multiprocess
+
+For Python 2, a C compiler is required to build the included extension module from source. Python 3 and binary installs do not require a C compiler.
+
+
+Requirements
+============
+
+``multiprocess`` requires:
+
+ - ``python`` (or ``pypy``), **>=3.8**
+ - ``setuptools``, **>=42**
+ - ``dill``, **>=0.3.8**
+
+
+Basic Usage
+===========
+
+The ``multiprocess.Process`` class follows the API of ``threading.Thread``.
+For example ::
+
+ from multiprocess import Process, Queue
+
+ def f(q):
+ q.put('hello world')
+
+ if __name__ == '__main__':
+ q = Queue()
+ p = Process(target=f, args=[q])
+ p.start()
+ print (q.get())
+ p.join()
+
+Synchronization primitives like locks, semaphores and conditions are
+available, for example ::
+
+ >>> from multiprocess import Condition
+ >>> c = Condition()
+ >>> print (c)
+ ), 0>
+ >>> c.acquire()
+ True
+ >>> print (c)
+ ), 0>
+
+One can also use a manager to create shared objects either in shared
+memory or in a server process, for example ::
+
+ >>> from multiprocess import Manager
+ >>> manager = Manager()
+ >>> l = manager.list(range(10))
+ >>> l.reverse()
+ >>> print (l)
+ [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
+ >>> print (repr(l))
+
+
+Tasks can be offloaded to a pool of worker processes in various ways,
+for example ::
+
+ >>> from multiprocess import Pool
+ >>> def f(x): return x*x
+ ...
+ >>> p = Pool(4)
+ >>> result = p.map_async(f, range(10))
+ >>> print (result.get(timeout=1))
+ [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
+
+When ``dill`` is installed, serialization is extended to most objects,
+for example ::
+
+ >>> from multiprocess import Pool
+ >>> p = Pool(4)
+ >>> print (p.map(lambda x: (lambda y:y**2)(x) + x, xrange(10)))
+ [0, 2, 6, 12, 20, 30, 42, 56, 72, 90]
+
+
+More Information
+================
+
+Probably the best way to get started is to look at the documentation at
+http://multiprocess.rtfd.io. Also see ``multiprocess.tests`` for scripts that
+demonstrate how ``multiprocess`` can be used to leverge multiple processes
+to execute Python in parallel. You can run the test suite with
+``python -m multiprocess.tests``. As ``multiprocess`` conforms to the
+``multiprocessing`` interface, the examples and documentation found at
+http://docs.python.org/library/multiprocessing.html also apply to
+``multiprocess`` if one will ``import multiprocessing as multiprocess``.
+See https://github.com/uqfoundation/multiprocess/tree/master/py3.12/examples
+for a set of examples that demonstrate some basic use cases and benchmarking
+for running Python code in parallel. Please feel free to submit a ticket on
+github, or ask a question on stackoverflow (**@Mike McKerns**). If you would
+like to share how you use ``multiprocess`` in your work, please send an email
+(to **mmckerns at uqfoundation dot org**).
+
+
+Citation
+========
+
+If you use ``multiprocess`` to do research that leads to publication, we ask that you
+acknowledge use of ``multiprocess`` by citing the following in your publication::
+
+ M.M. McKerns, L. Strand, T. Sullivan, A. Fang, M.A.G. Aivazis,
+ "Building a framework for predictive science", Proceedings of
+ the 10th Python in Science Conference, 2011;
+ http://arxiv.org/pdf/1202.1056
+
+ Michael McKerns and Michael Aivazis,
+ "pathos: a framework for heterogeneous computing", 2010- ;
+ https://uqfoundation.github.io/project/pathos
+
+Please see https://uqfoundation.github.io/project/pathos or
+http://arxiv.org/pdf/1202.1056 for further information.
+
+'''
+
+__all__ = []
+__version__ = '0.70.16'
+__author__ = 'Mike McKerns'
+
+__license__ = '''
+Copyright (c) 2008-2016 California Institute of Technology.
+Copyright (c) 2016-2024 The Uncertainty Quantification Foundation.
+All rights reserved.
+
+This software forks the python package "multiprocessing". Licence and
+copyright information for multiprocessing can be found in "COPYING".
+
+This software is available subject to the conditions and terms laid
+out below. By downloading and using this software you are agreeing
+to the following conditions.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+ - Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ - Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ - Neither the names of the copyright holders nor the names of any of
+ the contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+'''
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/__init__.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..8ff0f1ac4d92706328b55fc8be649bc107092bbc
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/__init__.py
@@ -0,0 +1,66 @@
+#
+# Package analogous to 'threading.py' but using processes
+#
+# multiprocessing/__init__.py
+#
+# This package is intended to duplicate the functionality (and much of
+# the API) of threading.py but uses processes instead of threads. A
+# subpackage 'multiprocessing.dummy' has the same API but is a simple
+# wrapper for 'threading'.
+#
+# Original: Copyright (c) 2006-2008, R Oudkerk
+# Original: Licensed to PSF under a Contributor Agreement.
+# Forked by Mike McKerns, to support enhanced serialization.
+
+# author, version, license, and long description
+try: # the package is installed
+ from .__info__ import __version__, __author__, __doc__, __license__
+except: # pragma: no cover
+ import os
+ import sys
+ root = os.path.dirname(os.path.dirname(os.path.abspath(os.path.dirname(__file__))))
+ sys.path.append(root)
+ # get distribution meta info
+ from version import (__version__, __author__,
+ get_license_text, get_readme_as_rst)
+ __license__ = get_license_text(os.path.join(root, 'LICENSE'))
+ __license__ = "\n%s" % __license__
+ __doc__ = get_readme_as_rst(os.path.join(root, 'README.md'))
+ del os, sys, root, get_license_text, get_readme_as_rst
+
+
+import sys
+from . import context
+
+#
+# Copy stuff from default context
+#
+
+__all__ = [x for x in dir(context._default_context) if not x.startswith('_')]
+globals().update((name, getattr(context._default_context, name)) for name in __all__)
+
+#
+# XXX These should not really be documented or public.
+#
+
+SUBDEBUG = 5
+SUBWARNING = 25
+
+#
+# Alias for main module -- will be reset by bootstrapping child processes
+#
+
+if '__main__' in sys.modules:
+ sys.modules['__mp_main__'] = sys.modules['__main__']
+
+
+def license():
+ """print license"""
+ print (__license__)
+ return
+
+def citation():
+ """print citation"""
+ print (__doc__[-491:-118])
+ return
+
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/connection.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/connection.py
new file mode 100644
index 0000000000000000000000000000000000000000..99ebfe19e239900da8584249a434be11618f6269
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/connection.py
@@ -0,0 +1,1181 @@
+#
+# A higher level module for using sockets (or Windows named pipes)
+#
+# multiprocessing/connection.py
+#
+# Copyright (c) 2006-2008, R Oudkerk
+# Licensed to PSF under a Contributor Agreement.
+#
+
+__all__ = [ 'Client', 'Listener', 'Pipe', 'wait' ]
+
+import errno
+import io
+import os
+import sys
+import socket
+import struct
+import time
+import tempfile
+import itertools
+
+try:
+ import _multiprocess as _multiprocessing
+except ImportError:
+ import _multiprocessing
+
+from . import util
+
+from . import AuthenticationError, BufferTooShort
+from .context import reduction
+_ForkingPickler = reduction.ForkingPickler
+
+try:
+ import _winapi
+ from _winapi import WAIT_OBJECT_0, WAIT_ABANDONED_0, WAIT_TIMEOUT, INFINITE
+except ImportError:
+ if sys.platform == 'win32':
+ raise
+ _winapi = None
+
+#
+#
+#
+
+BUFSIZE = 8192
+# A very generous timeout when it comes to local connections...
+CONNECTION_TIMEOUT = 20.
+
+_mmap_counter = itertools.count()
+
+default_family = 'AF_INET'
+families = ['AF_INET']
+
+if hasattr(socket, 'AF_UNIX'):
+ default_family = 'AF_UNIX'
+ families += ['AF_UNIX']
+
+if sys.platform == 'win32':
+ default_family = 'AF_PIPE'
+ families += ['AF_PIPE']
+
+
+def _init_timeout(timeout=CONNECTION_TIMEOUT):
+ return getattr(time,'monotonic',time.time)() + timeout
+
+def _check_timeout(t):
+ return getattr(time,'monotonic',time.time)() > t
+
+#
+#
+#
+
+def arbitrary_address(family):
+ '''
+ Return an arbitrary free address for the given family
+ '''
+ if family == 'AF_INET':
+ return ('localhost', 0)
+ elif family == 'AF_UNIX':
+ return tempfile.mktemp(prefix='listener-', dir=util.get_temp_dir())
+ elif family == 'AF_PIPE':
+ return tempfile.mktemp(prefix=r'\\.\pipe\pyc-%d-%d-' %
+ (os.getpid(), next(_mmap_counter)), dir="")
+ else:
+ raise ValueError('unrecognized family')
+
+def _validate_family(family):
+ '''
+ Checks if the family is valid for the current environment.
+ '''
+ if sys.platform != 'win32' and family == 'AF_PIPE':
+ raise ValueError('Family %s is not recognized.' % family)
+
+ if sys.platform == 'win32' and family == 'AF_UNIX':
+ # double check
+ if not hasattr(socket, family):
+ raise ValueError('Family %s is not recognized.' % family)
+
+def address_type(address):
+ '''
+ Return the types of the address
+
+ This can be 'AF_INET', 'AF_UNIX', or 'AF_PIPE'
+ '''
+ if type(address) == tuple:
+ return 'AF_INET'
+ elif type(address) is str and address.startswith('\\\\'):
+ return 'AF_PIPE'
+ elif type(address) is str or util.is_abstract_socket_namespace(address):
+ return 'AF_UNIX'
+ else:
+ raise ValueError('address type of %r unrecognized' % address)
+
+#
+# Connection classes
+#
+
+class _ConnectionBase:
+ _handle = None
+
+ def __init__(self, handle, readable=True, writable=True):
+ handle = handle.__index__()
+ if handle < 0:
+ raise ValueError("invalid handle")
+ if not readable and not writable:
+ raise ValueError(
+ "at least one of `readable` and `writable` must be True")
+ self._handle = handle
+ self._readable = readable
+ self._writable = writable
+
+ # XXX should we use util.Finalize instead of a __del__?
+
+ def __del__(self):
+ if self._handle is not None:
+ self._close()
+
+ def _check_closed(self):
+ if self._handle is None:
+ raise OSError("handle is closed")
+
+ def _check_readable(self):
+ if not self._readable:
+ raise OSError("connection is write-only")
+
+ def _check_writable(self):
+ if not self._writable:
+ raise OSError("connection is read-only")
+
+ def _bad_message_length(self):
+ if self._writable:
+ self._readable = False
+ else:
+ self.close()
+ raise OSError("bad message length")
+
+ @property
+ def closed(self):
+ """True if the connection is closed"""
+ return self._handle is None
+
+ @property
+ def readable(self):
+ """True if the connection is readable"""
+ return self._readable
+
+ @property
+ def writable(self):
+ """True if the connection is writable"""
+ return self._writable
+
+ def fileno(self):
+ """File descriptor or handle of the connection"""
+ self._check_closed()
+ return self._handle
+
+ def close(self):
+ """Close the connection"""
+ if self._handle is not None:
+ try:
+ self._close()
+ finally:
+ self._handle = None
+
+ def send_bytes(self, buf, offset=0, size=None):
+ """Send the bytes data from a bytes-like object"""
+ self._check_closed()
+ self._check_writable()
+ m = memoryview(buf)
+ if m.itemsize > 1:
+ m = m.cast('B')
+ n = m.nbytes
+ if offset < 0:
+ raise ValueError("offset is negative")
+ if n < offset:
+ raise ValueError("buffer length < offset")
+ if size is None:
+ size = n - offset
+ elif size < 0:
+ raise ValueError("size is negative")
+ elif offset + size > n:
+ raise ValueError("buffer length < offset + size")
+ self._send_bytes(m[offset:offset + size])
+
+ def send(self, obj):
+ """Send a (picklable) object"""
+ self._check_closed()
+ self._check_writable()
+ self._send_bytes(_ForkingPickler.dumps(obj))
+
+ def recv_bytes(self, maxlength=None):
+ """
+ Receive bytes data as a bytes object.
+ """
+ self._check_closed()
+ self._check_readable()
+ if maxlength is not None and maxlength < 0:
+ raise ValueError("negative maxlength")
+ buf = self._recv_bytes(maxlength)
+ if buf is None:
+ self._bad_message_length()
+ return buf.getvalue()
+
+ def recv_bytes_into(self, buf, offset=0):
+ """
+ Receive bytes data into a writeable bytes-like object.
+ Return the number of bytes read.
+ """
+ self._check_closed()
+ self._check_readable()
+ with memoryview(buf) as m:
+ # Get bytesize of arbitrary buffer
+ itemsize = m.itemsize
+ bytesize = itemsize * len(m)
+ if offset < 0:
+ raise ValueError("negative offset")
+ elif offset > bytesize:
+ raise ValueError("offset too large")
+ result = self._recv_bytes()
+ size = result.tell()
+ if bytesize < offset + size:
+ raise BufferTooShort(result.getvalue())
+ # Message can fit in dest
+ result.seek(0)
+ result.readinto(m[offset // itemsize :
+ (offset + size) // itemsize])
+ return size
+
+ def recv(self):
+ """Receive a (picklable) object"""
+ self._check_closed()
+ self._check_readable()
+ buf = self._recv_bytes()
+ return _ForkingPickler.loads(buf.getbuffer())
+
+ def poll(self, timeout=0.0):
+ """Whether there is any input available to be read"""
+ self._check_closed()
+ self._check_readable()
+ return self._poll(timeout)
+
+ def __enter__(self):
+ return self
+
+ def __exit__(self, exc_type, exc_value, exc_tb):
+ self.close()
+
+
+if _winapi:
+
+ class PipeConnection(_ConnectionBase):
+ """
+ Connection class based on a Windows named pipe.
+ Overlapped I/O is used, so the handles must have been created
+ with FILE_FLAG_OVERLAPPED.
+ """
+ _got_empty_message = False
+ _send_ov = None
+
+ def _close(self, _CloseHandle=_winapi.CloseHandle):
+ ov = self._send_ov
+ if ov is not None:
+ # Interrupt WaitForMultipleObjects() in _send_bytes()
+ ov.cancel()
+ _CloseHandle(self._handle)
+
+ def _send_bytes(self, buf):
+ if self._send_ov is not None:
+ # A connection should only be used by a single thread
+ raise ValueError("concurrent send_bytes() calls "
+ "are not supported")
+ ov, err = _winapi.WriteFile(self._handle, buf, overlapped=True)
+ self._send_ov = ov
+ try:
+ if err == _winapi.ERROR_IO_PENDING:
+ waitres = _winapi.WaitForMultipleObjects(
+ [ov.event], False, INFINITE)
+ assert waitres == WAIT_OBJECT_0
+ except:
+ ov.cancel()
+ raise
+ finally:
+ self._send_ov = None
+ nwritten, err = ov.GetOverlappedResult(True)
+ if err == _winapi.ERROR_OPERATION_ABORTED:
+ # close() was called by another thread while
+ # WaitForMultipleObjects() was waiting for the overlapped
+ # operation.
+ raise OSError(errno.EPIPE, "handle is closed")
+ assert err == 0
+ assert nwritten == len(buf)
+
+ def _recv_bytes(self, maxsize=None):
+ if self._got_empty_message:
+ self._got_empty_message = False
+ return io.BytesIO()
+ else:
+ bsize = 128 if maxsize is None else min(maxsize, 128)
+ try:
+ ov, err = _winapi.ReadFile(self._handle, bsize,
+ overlapped=True)
+ try:
+ if err == _winapi.ERROR_IO_PENDING:
+ waitres = _winapi.WaitForMultipleObjects(
+ [ov.event], False, INFINITE)
+ assert waitres == WAIT_OBJECT_0
+ except:
+ ov.cancel()
+ raise
+ finally:
+ nread, err = ov.GetOverlappedResult(True)
+ if err == 0:
+ f = io.BytesIO()
+ f.write(ov.getbuffer())
+ return f
+ elif err == _winapi.ERROR_MORE_DATA:
+ return self._get_more_data(ov, maxsize)
+ except OSError as e:
+ if e.winerror == _winapi.ERROR_BROKEN_PIPE:
+ raise EOFError
+ else:
+ raise
+ raise RuntimeError("shouldn't get here; expected KeyboardInterrupt")
+
+ def _poll(self, timeout):
+ if (self._got_empty_message or
+ _winapi.PeekNamedPipe(self._handle)[0] != 0):
+ return True
+ return bool(wait([self], timeout))
+
+ def _get_more_data(self, ov, maxsize):
+ buf = ov.getbuffer()
+ f = io.BytesIO()
+ f.write(buf)
+ left = _winapi.PeekNamedPipe(self._handle)[1]
+ assert left > 0
+ if maxsize is not None and len(buf) + left > maxsize:
+ self._bad_message_length()
+ ov, err = _winapi.ReadFile(self._handle, left, overlapped=True)
+ rbytes, err = ov.GetOverlappedResult(True)
+ assert err == 0
+ assert rbytes == left
+ f.write(ov.getbuffer())
+ return f
+
+
+class Connection(_ConnectionBase):
+ """
+ Connection class based on an arbitrary file descriptor (Unix only), or
+ a socket handle (Windows).
+ """
+
+ if _winapi:
+ def _close(self, _close=_multiprocessing.closesocket):
+ _close(self._handle)
+ _write = _multiprocessing.send
+ _read = _multiprocessing.recv
+ else:
+ def _close(self, _close=os.close):
+ _close(self._handle)
+ _write = os.write
+ _read = os.read
+
+ def _send(self, buf, write=_write):
+ remaining = len(buf)
+ while True:
+ n = write(self._handle, buf)
+ remaining -= n
+ if remaining == 0:
+ break
+ buf = buf[n:]
+
+ def _recv(self, size, read=_read):
+ buf = io.BytesIO()
+ handle = self._handle
+ remaining = size
+ while remaining > 0:
+ chunk = read(handle, remaining)
+ n = len(chunk)
+ if n == 0:
+ if remaining == size:
+ raise EOFError
+ else:
+ raise OSError("got end of file during message")
+ buf.write(chunk)
+ remaining -= n
+ return buf
+
+ def _send_bytes(self, buf):
+ n = len(buf)
+ if n > 0x7fffffff:
+ pre_header = struct.pack("!i", -1)
+ header = struct.pack("!Q", n)
+ self._send(pre_header)
+ self._send(header)
+ self._send(buf)
+ else:
+ # For wire compatibility with 3.7 and lower
+ header = struct.pack("!i", n)
+ if n > 16384:
+ # The payload is large so Nagle's algorithm won't be triggered
+ # and we'd better avoid the cost of concatenation.
+ self._send(header)
+ self._send(buf)
+ else:
+ # Issue #20540: concatenate before sending, to avoid delays due
+ # to Nagle's algorithm on a TCP socket.
+ # Also note we want to avoid sending a 0-length buffer separately,
+ # to avoid "broken pipe" errors if the other end closed the pipe.
+ self._send(header + buf)
+
+ def _recv_bytes(self, maxsize=None):
+ buf = self._recv(4)
+ size, = struct.unpack("!i", buf.getvalue())
+ if size == -1:
+ buf = self._recv(8)
+ size, = struct.unpack("!Q", buf.getvalue())
+ if maxsize is not None and size > maxsize:
+ return None
+ return self._recv(size)
+
+ def _poll(self, timeout):
+ r = wait([self], timeout)
+ return bool(r)
+
+
+#
+# Public functions
+#
+
+class Listener(object):
+ '''
+ Returns a listener object.
+
+ This is a wrapper for a bound socket which is 'listening' for
+ connections, or for a Windows named pipe.
+ '''
+ def __init__(self, address=None, family=None, backlog=1, authkey=None):
+ family = family or (address and address_type(address)) \
+ or default_family
+ address = address or arbitrary_address(family)
+
+ _validate_family(family)
+ if family == 'AF_PIPE':
+ self._listener = PipeListener(address, backlog)
+ else:
+ self._listener = SocketListener(address, family, backlog)
+
+ if authkey is not None and not isinstance(authkey, bytes):
+ raise TypeError('authkey should be a byte string')
+
+ self._authkey = authkey
+
+ def accept(self):
+ '''
+ Accept a connection on the bound socket or named pipe of `self`.
+
+ Returns a `Connection` object.
+ '''
+ if self._listener is None:
+ raise OSError('listener is closed')
+ c = self._listener.accept()
+ if self._authkey:
+ deliver_challenge(c, self._authkey)
+ answer_challenge(c, self._authkey)
+ return c
+
+ def close(self):
+ '''
+ Close the bound socket or named pipe of `self`.
+ '''
+ listener = self._listener
+ if listener is not None:
+ self._listener = None
+ listener.close()
+
+ @property
+ def address(self):
+ return self._listener._address
+
+ @property
+ def last_accepted(self):
+ return self._listener._last_accepted
+
+ def __enter__(self):
+ return self
+
+ def __exit__(self, exc_type, exc_value, exc_tb):
+ self.close()
+
+
+def Client(address, family=None, authkey=None):
+ '''
+ Returns a connection to the address of a `Listener`
+ '''
+ family = family or address_type(address)
+ _validate_family(family)
+ if family == 'AF_PIPE':
+ c = PipeClient(address)
+ else:
+ c = SocketClient(address)
+
+ if authkey is not None and not isinstance(authkey, bytes):
+ raise TypeError('authkey should be a byte string')
+
+ if authkey is not None:
+ answer_challenge(c, authkey)
+ deliver_challenge(c, authkey)
+
+ return c
+
+
+if sys.platform != 'win32':
+
+ def Pipe(duplex=True):
+ '''
+ Returns pair of connection objects at either end of a pipe
+ '''
+ if duplex:
+ s1, s2 = socket.socketpair()
+ s1.setblocking(True)
+ s2.setblocking(True)
+ c1 = Connection(s1.detach())
+ c2 = Connection(s2.detach())
+ else:
+ fd1, fd2 = os.pipe()
+ c1 = Connection(fd1, writable=False)
+ c2 = Connection(fd2, readable=False)
+
+ return c1, c2
+
+else:
+
+ def Pipe(duplex=True):
+ '''
+ Returns pair of connection objects at either end of a pipe
+ '''
+ address = arbitrary_address('AF_PIPE')
+ if duplex:
+ openmode = _winapi.PIPE_ACCESS_DUPLEX
+ access = _winapi.GENERIC_READ | _winapi.GENERIC_WRITE
+ obsize, ibsize = BUFSIZE, BUFSIZE
+ else:
+ openmode = _winapi.PIPE_ACCESS_INBOUND
+ access = _winapi.GENERIC_WRITE
+ obsize, ibsize = 0, BUFSIZE
+
+ h1 = _winapi.CreateNamedPipe(
+ address, openmode | _winapi.FILE_FLAG_OVERLAPPED |
+ _winapi.FILE_FLAG_FIRST_PIPE_INSTANCE,
+ _winapi.PIPE_TYPE_MESSAGE | _winapi.PIPE_READMODE_MESSAGE |
+ _winapi.PIPE_WAIT,
+ 1, obsize, ibsize, _winapi.NMPWAIT_WAIT_FOREVER,
+ # default security descriptor: the handle cannot be inherited
+ _winapi.NULL
+ )
+ h2 = _winapi.CreateFile(
+ address, access, 0, _winapi.NULL, _winapi.OPEN_EXISTING,
+ _winapi.FILE_FLAG_OVERLAPPED, _winapi.NULL
+ )
+ _winapi.SetNamedPipeHandleState(
+ h2, _winapi.PIPE_READMODE_MESSAGE, None, None
+ )
+
+ overlapped = _winapi.ConnectNamedPipe(h1, overlapped=True)
+ _, err = overlapped.GetOverlappedResult(True)
+ assert err == 0
+
+ c1 = PipeConnection(h1, writable=duplex)
+ c2 = PipeConnection(h2, readable=duplex)
+
+ return c1, c2
+
+#
+# Definitions for connections based on sockets
+#
+
+class SocketListener(object):
+ '''
+ Representation of a socket which is bound to an address and listening
+ '''
+ def __init__(self, address, family, backlog=1):
+ self._socket = socket.socket(getattr(socket, family))
+ try:
+ # SO_REUSEADDR has different semantics on Windows (issue #2550).
+ if os.name == 'posix':
+ self._socket.setsockopt(socket.SOL_SOCKET,
+ socket.SO_REUSEADDR, 1)
+ self._socket.setblocking(True)
+ self._socket.bind(address)
+ self._socket.listen(backlog)
+ self._address = self._socket.getsockname()
+ except OSError:
+ self._socket.close()
+ raise
+ self._family = family
+ self._last_accepted = None
+
+ if family == 'AF_UNIX' and not util.is_abstract_socket_namespace(address):
+ # Linux abstract socket namespaces do not need to be explicitly unlinked
+ self._unlink = util.Finalize(
+ self, os.unlink, args=(address,), exitpriority=0
+ )
+ else:
+ self._unlink = None
+
+ def accept(self):
+ s, self._last_accepted = self._socket.accept()
+ s.setblocking(True)
+ return Connection(s.detach())
+
+ def close(self):
+ try:
+ self._socket.close()
+ finally:
+ unlink = self._unlink
+ if unlink is not None:
+ self._unlink = None
+ unlink()
+
+
+def SocketClient(address):
+ '''
+ Return a connection object connected to the socket given by `address`
+ '''
+ family = address_type(address)
+ with socket.socket( getattr(socket, family) ) as s:
+ s.setblocking(True)
+ s.connect(address)
+ return Connection(s.detach())
+
+#
+# Definitions for connections based on named pipes
+#
+
+if sys.platform == 'win32':
+
+ class PipeListener(object):
+ '''
+ Representation of a named pipe
+ '''
+ def __init__(self, address, backlog=None):
+ self._address = address
+ self._handle_queue = [self._new_handle(first=True)]
+
+ self._last_accepted = None
+ util.sub_debug('listener created with address=%r', self._address)
+ self.close = util.Finalize(
+ self, PipeListener._finalize_pipe_listener,
+ args=(self._handle_queue, self._address), exitpriority=0
+ )
+
+ def _new_handle(self, first=False):
+ flags = _winapi.PIPE_ACCESS_DUPLEX | _winapi.FILE_FLAG_OVERLAPPED
+ if first:
+ flags |= _winapi.FILE_FLAG_FIRST_PIPE_INSTANCE
+ return _winapi.CreateNamedPipe(
+ self._address, flags,
+ _winapi.PIPE_TYPE_MESSAGE | _winapi.PIPE_READMODE_MESSAGE |
+ _winapi.PIPE_WAIT,
+ _winapi.PIPE_UNLIMITED_INSTANCES, BUFSIZE, BUFSIZE,
+ _winapi.NMPWAIT_WAIT_FOREVER, _winapi.NULL
+ )
+
+ def accept(self):
+ self._handle_queue.append(self._new_handle())
+ handle = self._handle_queue.pop(0)
+ try:
+ ov = _winapi.ConnectNamedPipe(handle, overlapped=True)
+ except OSError as e:
+ if e.winerror != _winapi.ERROR_NO_DATA:
+ raise
+ # ERROR_NO_DATA can occur if a client has already connected,
+ # written data and then disconnected -- see Issue 14725.
+ else:
+ try:
+ res = _winapi.WaitForMultipleObjects(
+ [ov.event], False, INFINITE)
+ except:
+ ov.cancel()
+ _winapi.CloseHandle(handle)
+ raise
+ finally:
+ _, err = ov.GetOverlappedResult(True)
+ assert err == 0
+ return PipeConnection(handle)
+
+ @staticmethod
+ def _finalize_pipe_listener(queue, address):
+ util.sub_debug('closing listener with address=%r', address)
+ for handle in queue:
+ _winapi.CloseHandle(handle)
+
+ def PipeClient(address):
+ '''
+ Return a connection object connected to the pipe given by `address`
+ '''
+ t = _init_timeout()
+ while 1:
+ try:
+ _winapi.WaitNamedPipe(address, 1000)
+ h = _winapi.CreateFile(
+ address, _winapi.GENERIC_READ | _winapi.GENERIC_WRITE,
+ 0, _winapi.NULL, _winapi.OPEN_EXISTING,
+ _winapi.FILE_FLAG_OVERLAPPED, _winapi.NULL
+ )
+ except OSError as e:
+ if e.winerror not in (_winapi.ERROR_SEM_TIMEOUT,
+ _winapi.ERROR_PIPE_BUSY) or _check_timeout(t):
+ raise
+ else:
+ break
+ else:
+ raise
+
+ _winapi.SetNamedPipeHandleState(
+ h, _winapi.PIPE_READMODE_MESSAGE, None, None
+ )
+ return PipeConnection(h)
+
+#
+# Authentication stuff
+#
+
+MESSAGE_LENGTH = 40 # MUST be > 20
+MESSAGE_MAXLEN = 256 # default is None
+
+_CHALLENGE = b'#CHALLENGE#'
+_WELCOME = b'#WELCOME#'
+_FAILURE = b'#FAILURE#'
+
+# multiprocessing.connection Authentication Handshake Protocol Description
+# (as documented for reference after reading the existing code)
+# =============================================================================
+#
+# On Windows: native pipes with "overlapped IO" are used to send the bytes,
+# instead of the length prefix SIZE scheme described below. (ie: the OS deals
+# with message sizes for us)
+#
+# Protocol error behaviors:
+#
+# On POSIX, any failure to receive the length prefix into SIZE, for SIZE greater
+# than the requested maxsize to receive, or receiving fewer than SIZE bytes
+# results in the connection being closed and auth to fail.
+#
+# On Windows, receiving too few bytes is never a low level _recv_bytes read
+# error, receiving too many will trigger an error only if receive maxsize
+# value was larger than 128 OR the if the data arrived in smaller pieces.
+#
+# Serving side Client side
+# ------------------------------ ---------------------------------------
+# 0. Open a connection on the pipe.
+# 1. Accept connection.
+# 2. Random 20+ bytes -> MESSAGE
+# Modern servers always send
+# more than 20 bytes and include
+# a {digest} prefix on it with
+# their preferred HMAC digest.
+# Legacy ones send ==20 bytes.
+# 3. send 4 byte length (net order)
+# prefix followed by:
+# b'#CHALLENGE#' + MESSAGE
+# 4. Receive 4 bytes, parse as network byte
+# order integer. If it is -1, receive an
+# additional 8 bytes, parse that as network
+# byte order. The result is the length of
+# the data that follows -> SIZE.
+# 5. Receive min(SIZE, 256) bytes -> M1
+# 6. Assert that M1 starts with:
+# b'#CHALLENGE#'
+# 7. Strip that prefix from M1 into -> M2
+# 7.1. Parse M2: if it is exactly 20 bytes in
+# length this indicates a legacy server
+# supporting only HMAC-MD5. Otherwise the
+# 7.2. preferred digest is looked up from an
+# expected "{digest}" prefix on M2. No prefix
+# or unsupported digest? <- AuthenticationError
+# 7.3. Put divined algorithm name in -> D_NAME
+# 8. Compute HMAC-D_NAME of AUTHKEY, M2 -> C_DIGEST
+# 9. Send 4 byte length prefix (net order)
+# followed by C_DIGEST bytes.
+# 10. Receive 4 or 4+8 byte length
+# prefix (#4 dance) -> SIZE.
+# 11. Receive min(SIZE, 256) -> C_D.
+# 11.1. Parse C_D: legacy servers
+# accept it as is, "md5" -> D_NAME
+# 11.2. modern servers check the length
+# of C_D, IF it is 16 bytes?
+# 11.2.1. "md5" -> D_NAME
+# and skip to step 12.
+# 11.3. longer? expect and parse a "{digest}"
+# prefix into -> D_NAME.
+# Strip the prefix and store remaining
+# bytes in -> C_D.
+# 11.4. Don't like D_NAME? <- AuthenticationError
+# 12. Compute HMAC-D_NAME of AUTHKEY,
+# MESSAGE into -> M_DIGEST.
+# 13. Compare M_DIGEST == C_D:
+# 14a: Match? Send length prefix &
+# b'#WELCOME#'
+# <- RETURN
+# 14b: Mismatch? Send len prefix &
+# b'#FAILURE#'
+# <- CLOSE & AuthenticationError
+# 15. Receive 4 or 4+8 byte length prefix (net
+# order) again as in #4 into -> SIZE.
+# 16. Receive min(SIZE, 256) bytes -> M3.
+# 17. Compare M3 == b'#WELCOME#':
+# 17a. Match? <- RETURN
+# 17b. Mismatch? <- CLOSE & AuthenticationError
+#
+# If this RETURNed, the connection remains open: it has been authenticated.
+#
+# Length prefixes are used consistently. Even on the legacy protocol, this
+# was good fortune and allowed us to evolve the protocol by using the length
+# of the opening challenge or length of the returned digest as a signal as
+# to which protocol the other end supports.
+
+_ALLOWED_DIGESTS = frozenset(
+ {b'md5', b'sha256', b'sha384', b'sha3_256', b'sha3_384'})
+_MAX_DIGEST_LEN = max(len(_) for _ in _ALLOWED_DIGESTS)
+
+# Old hmac-md5 only server versions from Python <=3.11 sent a message of this
+# length. It happens to not match the length of any supported digest so we can
+# use a message of this length to indicate that we should work in backwards
+# compatible md5-only mode without a {digest_name} prefix on our response.
+_MD5ONLY_MESSAGE_LENGTH = 20
+_MD5_DIGEST_LEN = 16
+_LEGACY_LENGTHS = (_MD5ONLY_MESSAGE_LENGTH, _MD5_DIGEST_LEN)
+
+
+def _get_digest_name_and_payload(message: bytes) -> (str, bytes):
+ """Returns a digest name and the payload for a response hash.
+
+ If a legacy protocol is detected based on the message length
+ or contents the digest name returned will be empty to indicate
+ legacy mode where MD5 and no digest prefix should be sent.
+ """
+ # modern message format: b"{digest}payload" longer than 20 bytes
+ # legacy message format: 16 or 20 byte b"payload"
+ if len(message) in _LEGACY_LENGTHS:
+ # Either this was a legacy server challenge, or we're processing
+ # a reply from a legacy client that sent an unprefixed 16-byte
+ # HMAC-MD5 response. All messages using the modern protocol will
+ # be longer than either of these lengths.
+ return '', message
+ if (message.startswith(b'{') and
+ (curly := message.find(b'}', 1, _MAX_DIGEST_LEN+2)) > 0):
+ digest = message[1:curly]
+ if digest in _ALLOWED_DIGESTS:
+ payload = message[curly+1:]
+ return digest.decode('ascii'), payload
+ raise AuthenticationError(
+ 'unsupported message length, missing digest prefix, '
+ f'or unsupported digest: {message=}')
+
+
+def _create_response(authkey, message):
+ """Create a MAC based on authkey and message
+
+ The MAC algorithm defaults to HMAC-MD5, unless MD5 is not available or
+ the message has a '{digest_name}' prefix. For legacy HMAC-MD5, the response
+ is the raw MAC, otherwise the response is prefixed with '{digest_name}',
+ e.g. b'{sha256}abcdefg...'
+
+ Note: The MAC protects the entire message including the digest_name prefix.
+ """
+ import hmac
+ digest_name = _get_digest_name_and_payload(message)[0]
+ # The MAC protects the entire message: digest header and payload.
+ if not digest_name:
+ # Legacy server without a {digest} prefix on message.
+ # Generate a legacy non-prefixed HMAC-MD5 reply.
+ try:
+ return hmac.new(authkey, message, 'md5').digest()
+ except ValueError:
+ # HMAC-MD5 is not available (FIPS mode?), fall back to
+ # HMAC-SHA2-256 modern protocol. The legacy server probably
+ # doesn't support it and will reject us anyways. :shrug:
+ digest_name = 'sha256'
+ # Modern protocol, indicate the digest used in the reply.
+ response = hmac.new(authkey, message, digest_name).digest()
+ return b'{%s}%s' % (digest_name.encode('ascii'), response)
+
+
+def _verify_challenge(authkey, message, response):
+ """Verify MAC challenge
+
+ If our message did not include a digest_name prefix, the client is allowed
+ to select a stronger digest_name from _ALLOWED_DIGESTS.
+
+ In case our message is prefixed, a client cannot downgrade to a weaker
+ algorithm, because the MAC is calculated over the entire message
+ including the '{digest_name}' prefix.
+ """
+ import hmac
+ response_digest, response_mac = _get_digest_name_and_payload(response)
+ response_digest = response_digest or 'md5'
+ try:
+ expected = hmac.new(authkey, message, response_digest).digest()
+ except ValueError:
+ raise AuthenticationError(f'{response_digest=} unsupported')
+ if len(expected) != len(response_mac):
+ raise AuthenticationError(
+ f'expected {response_digest!r} of length {len(expected)} '
+ f'got {len(response_mac)}')
+ if not hmac.compare_digest(expected, response_mac):
+ raise AuthenticationError('digest received was wrong')
+
+
+def deliver_challenge(connection, authkey: bytes, digest_name='sha256'):
+ if not isinstance(authkey, bytes):
+ raise ValueError(
+ "Authkey must be bytes, not {0!s}".format(type(authkey)))
+ assert MESSAGE_LENGTH > _MD5ONLY_MESSAGE_LENGTH, "protocol constraint"
+ message = os.urandom(MESSAGE_LENGTH)
+ message = b'{%s}%s' % (digest_name.encode('ascii'), message)
+ # Even when sending a challenge to a legacy client that does not support
+ # digest prefixes, they'll take the entire thing as a challenge and
+ # respond to it with a raw HMAC-MD5.
+ connection.send_bytes(_CHALLENGE + message)
+ response = connection.recv_bytes(MESSAGE_MAXLEN) # reject large message
+ try:
+ _verify_challenge(authkey, message, response)
+ except AuthenticationError:
+ connection.send_bytes(_FAILURE)
+ raise
+ else:
+ connection.send_bytes(_WELCOME)
+
+
+def answer_challenge(connection, authkey: bytes):
+ if not isinstance(authkey, bytes):
+ raise ValueError(
+ "Authkey must be bytes, not {0!s}".format(type(authkey)))
+ message = connection.recv_bytes(MESSAGE_MAXLEN) # reject large message
+ if not message.startswith(_CHALLENGE):
+ raise AuthenticationError(
+ f'Protocol error, expected challenge: {message=}')
+ message = message[len(_CHALLENGE):]
+ if len(message) < _MD5ONLY_MESSAGE_LENGTH:
+ raise AuthenticationError('challenge too short: {len(message)} bytes')
+ digest = _create_response(authkey, message)
+ connection.send_bytes(digest)
+ response = connection.recv_bytes(MESSAGE_MAXLEN) # reject large message
+ if response != _WELCOME:
+ raise AuthenticationError('digest sent was rejected')
+
+#
+# Support for using xmlrpclib for serialization
+#
+
+class ConnectionWrapper(object):
+ def __init__(self, conn, dumps, loads):
+ self._conn = conn
+ self._dumps = dumps
+ self._loads = loads
+ for attr in ('fileno', 'close', 'poll', 'recv_bytes', 'send_bytes'):
+ obj = getattr(conn, attr)
+ setattr(self, attr, obj)
+ def send(self, obj):
+ s = self._dumps(obj)
+ self._conn.send_bytes(s)
+ def recv(self):
+ s = self._conn.recv_bytes()
+ return self._loads(s)
+
+def _xml_dumps(obj):
+ return xmlrpclib.dumps((obj,), None, None, None, 1).encode('utf-8')
+
+def _xml_loads(s):
+ (obj,), method = xmlrpclib.loads(s.decode('utf-8'))
+ return obj
+
+class XmlListener(Listener):
+ def accept(self):
+ global xmlrpclib
+ import xmlrpc.client as xmlrpclib
+ obj = Listener.accept(self)
+ return ConnectionWrapper(obj, _xml_dumps, _xml_loads)
+
+def XmlClient(*args, **kwds):
+ global xmlrpclib
+ import xmlrpc.client as xmlrpclib
+ return ConnectionWrapper(Client(*args, **kwds), _xml_dumps, _xml_loads)
+
+#
+# Wait
+#
+
+if sys.platform == 'win32':
+
+ def _exhaustive_wait(handles, timeout):
+ # Return ALL handles which are currently signalled. (Only
+ # returning the first signalled might create starvation issues.)
+ L = list(handles)
+ ready = []
+ while L:
+ res = _winapi.WaitForMultipleObjects(L, False, timeout)
+ if res == WAIT_TIMEOUT:
+ break
+ elif WAIT_OBJECT_0 <= res < WAIT_OBJECT_0 + len(L):
+ res -= WAIT_OBJECT_0
+ elif WAIT_ABANDONED_0 <= res < WAIT_ABANDONED_0 + len(L):
+ res -= WAIT_ABANDONED_0
+ else:
+ raise RuntimeError('Should not get here')
+ ready.append(L[res])
+ L = L[res+1:]
+ timeout = 0
+ return ready
+
+ _ready_errors = {_winapi.ERROR_BROKEN_PIPE, _winapi.ERROR_NETNAME_DELETED}
+
+ def wait(object_list, timeout=None):
+ '''
+ Wait till an object in object_list is ready/readable.
+
+ Returns list of those objects in object_list which are ready/readable.
+ '''
+ if timeout is None:
+ timeout = INFINITE
+ elif timeout < 0:
+ timeout = 0
+ else:
+ timeout = int(timeout * 1000 + 0.5)
+
+ object_list = list(object_list)
+ waithandle_to_obj = {}
+ ov_list = []
+ ready_objects = set()
+ ready_handles = set()
+
+ try:
+ for o in object_list:
+ try:
+ fileno = getattr(o, 'fileno')
+ except AttributeError:
+ waithandle_to_obj[o.__index__()] = o
+ else:
+ # start an overlapped read of length zero
+ try:
+ ov, err = _winapi.ReadFile(fileno(), 0, True)
+ except OSError as e:
+ ov, err = None, e.winerror
+ if err not in _ready_errors:
+ raise
+ if err == _winapi.ERROR_IO_PENDING:
+ ov_list.append(ov)
+ waithandle_to_obj[ov.event] = o
+ else:
+ # If o.fileno() is an overlapped pipe handle and
+ # err == 0 then there is a zero length message
+ # in the pipe, but it HAS NOT been consumed...
+ if ov and sys.getwindowsversion()[:2] >= (6, 2):
+ # ... except on Windows 8 and later, where
+ # the message HAS been consumed.
+ try:
+ _, err = ov.GetOverlappedResult(False)
+ except OSError as e:
+ err = e.winerror
+ if not err and hasattr(o, '_got_empty_message'):
+ o._got_empty_message = True
+ ready_objects.add(o)
+ timeout = 0
+
+ ready_handles = _exhaustive_wait(waithandle_to_obj.keys(), timeout)
+ finally:
+ # request that overlapped reads stop
+ for ov in ov_list:
+ ov.cancel()
+
+ # wait for all overlapped reads to stop
+ for ov in ov_list:
+ try:
+ _, err = ov.GetOverlappedResult(True)
+ except OSError as e:
+ err = e.winerror
+ if err not in _ready_errors:
+ raise
+ if err != _winapi.ERROR_OPERATION_ABORTED:
+ o = waithandle_to_obj[ov.event]
+ ready_objects.add(o)
+ if err == 0:
+ # If o.fileno() is an overlapped pipe handle then
+ # a zero length message HAS been consumed.
+ if hasattr(o, '_got_empty_message'):
+ o._got_empty_message = True
+
+ ready_objects.update(waithandle_to_obj[h] for h in ready_handles)
+ return [o for o in object_list if o in ready_objects]
+
+else:
+
+ import selectors
+
+ # poll/select have the advantage of not requiring any extra file
+ # descriptor, contrarily to epoll/kqueue (also, they require a single
+ # syscall).
+ if hasattr(selectors, 'PollSelector'):
+ _WaitSelector = selectors.PollSelector
+ else:
+ _WaitSelector = selectors.SelectSelector
+
+ def wait(object_list, timeout=None):
+ '''
+ Wait till an object in object_list is ready/readable.
+
+ Returns list of those objects in object_list which are ready/readable.
+ '''
+ with _WaitSelector() as selector:
+ for obj in object_list:
+ selector.register(obj, selectors.EVENT_READ)
+
+ if timeout is not None:
+ deadline = getattr(time,'monotonic',time.time)() + timeout
+
+ while True:
+ ready = selector.select(timeout)
+ if ready:
+ return [key.fileobj for (key, events) in ready]
+ else:
+ if timeout is not None:
+ timeout = deadline - getattr(time,'monotonic',time.time)()
+ if timeout < 0:
+ return ready
+
+#
+# Make connection and socket objects shareable if possible
+#
+
+if sys.platform == 'win32':
+ def reduce_connection(conn):
+ handle = conn.fileno()
+ with socket.fromfd(handle, socket.AF_INET, socket.SOCK_STREAM) as s:
+ from . import resource_sharer
+ ds = resource_sharer.DupSocket(s)
+ return rebuild_connection, (ds, conn.readable, conn.writable)
+ def rebuild_connection(ds, readable, writable):
+ sock = ds.detach()
+ return Connection(sock.detach(), readable, writable)
+ reduction.register(Connection, reduce_connection)
+
+ def reduce_pipe_connection(conn):
+ access = ((_winapi.FILE_GENERIC_READ if conn.readable else 0) |
+ (_winapi.FILE_GENERIC_WRITE if conn.writable else 0))
+ dh = reduction.DupHandle(conn.fileno(), access)
+ return rebuild_pipe_connection, (dh, conn.readable, conn.writable)
+ def rebuild_pipe_connection(dh, readable, writable):
+ handle = dh.detach()
+ return PipeConnection(handle, readable, writable)
+ reduction.register(PipeConnection, reduce_pipe_connection)
+
+else:
+ def reduce_connection(conn):
+ df = reduction.DupFd(conn.fileno())
+ return rebuild_connection, (df, conn.readable, conn.writable)
+ def rebuild_connection(df, readable, writable):
+ fd = df.detach()
+ return Connection(fd, readable, writable)
+ reduction.register(Connection, reduce_connection)
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/context.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/context.py
new file mode 100644
index 0000000000000000000000000000000000000000..7cf3da6a661f1a4440f7a596449cad248c1a68d5
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/context.py
@@ -0,0 +1,377 @@
+import os
+import sys
+import threading
+
+from . import process
+from . import reduction
+
+__all__ = ()
+
+#
+# Exceptions
+#
+
+class ProcessError(Exception):
+ pass
+
+class BufferTooShort(ProcessError):
+ pass
+
+class TimeoutError(ProcessError):
+ pass
+
+class AuthenticationError(ProcessError):
+ pass
+
+#
+# Base type for contexts. Bound methods of an instance of this type are included in __all__ of __init__.py
+#
+
+class BaseContext(object):
+
+ ProcessError = ProcessError
+ BufferTooShort = BufferTooShort
+ TimeoutError = TimeoutError
+ AuthenticationError = AuthenticationError
+
+ current_process = staticmethod(process.current_process)
+ parent_process = staticmethod(process.parent_process)
+ active_children = staticmethod(process.active_children)
+
+ def cpu_count(self):
+ '''Returns the number of CPUs in the system'''
+ num = os.cpu_count()
+ if num is None:
+ raise NotImplementedError('cannot determine number of cpus')
+ else:
+ return num
+
+ def Manager(self):
+ '''Returns a manager associated with a running server process
+
+ The managers methods such as `Lock()`, `Condition()` and `Queue()`
+ can be used to create shared objects.
+ '''
+ from .managers import SyncManager
+ m = SyncManager(ctx=self.get_context())
+ m.start()
+ return m
+
+ def Pipe(self, duplex=True):
+ '''Returns two connection object connected by a pipe'''
+ from .connection import Pipe
+ return Pipe(duplex)
+
+ def Lock(self):
+ '''Returns a non-recursive lock object'''
+ from .synchronize import Lock
+ return Lock(ctx=self.get_context())
+
+ def RLock(self):
+ '''Returns a recursive lock object'''
+ from .synchronize import RLock
+ return RLock(ctx=self.get_context())
+
+ def Condition(self, lock=None):
+ '''Returns a condition object'''
+ from .synchronize import Condition
+ return Condition(lock, ctx=self.get_context())
+
+ def Semaphore(self, value=1):
+ '''Returns a semaphore object'''
+ from .synchronize import Semaphore
+ return Semaphore(value, ctx=self.get_context())
+
+ def BoundedSemaphore(self, value=1):
+ '''Returns a bounded semaphore object'''
+ from .synchronize import BoundedSemaphore
+ return BoundedSemaphore(value, ctx=self.get_context())
+
+ def Event(self):
+ '''Returns an event object'''
+ from .synchronize import Event
+ return Event(ctx=self.get_context())
+
+ def Barrier(self, parties, action=None, timeout=None):
+ '''Returns a barrier object'''
+ from .synchronize import Barrier
+ return Barrier(parties, action, timeout, ctx=self.get_context())
+
+ def Queue(self, maxsize=0):
+ '''Returns a queue object'''
+ from .queues import Queue
+ return Queue(maxsize, ctx=self.get_context())
+
+ def JoinableQueue(self, maxsize=0):
+ '''Returns a queue object'''
+ from .queues import JoinableQueue
+ return JoinableQueue(maxsize, ctx=self.get_context())
+
+ def SimpleQueue(self):
+ '''Returns a queue object'''
+ from .queues import SimpleQueue
+ return SimpleQueue(ctx=self.get_context())
+
+ def Pool(self, processes=None, initializer=None, initargs=(),
+ maxtasksperchild=None):
+ '''Returns a process pool object'''
+ from .pool import Pool
+ return Pool(processes, initializer, initargs, maxtasksperchild,
+ context=self.get_context())
+
+ def RawValue(self, typecode_or_type, *args):
+ '''Returns a shared object'''
+ from .sharedctypes import RawValue
+ return RawValue(typecode_or_type, *args)
+
+ def RawArray(self, typecode_or_type, size_or_initializer):
+ '''Returns a shared array'''
+ from .sharedctypes import RawArray
+ return RawArray(typecode_or_type, size_or_initializer)
+
+ def Value(self, typecode_or_type, *args, lock=True):
+ '''Returns a synchronized shared object'''
+ from .sharedctypes import Value
+ return Value(typecode_or_type, *args, lock=lock,
+ ctx=self.get_context())
+
+ def Array(self, typecode_or_type, size_or_initializer, *, lock=True):
+ '''Returns a synchronized shared array'''
+ from .sharedctypes import Array
+ return Array(typecode_or_type, size_or_initializer, lock=lock,
+ ctx=self.get_context())
+
+ def freeze_support(self):
+ '''Check whether this is a fake forked process in a frozen executable.
+ If so then run code specified by commandline and exit.
+ '''
+ if sys.platform == 'win32' and getattr(sys, 'frozen', False):
+ from .spawn import freeze_support
+ freeze_support()
+
+ def get_logger(self):
+ '''Return package logger -- if it does not already exist then
+ it is created.
+ '''
+ from .util import get_logger
+ return get_logger()
+
+ def log_to_stderr(self, level=None):
+ '''Turn on logging and add a handler which prints to stderr'''
+ from .util import log_to_stderr
+ return log_to_stderr(level)
+
+ def allow_connection_pickling(self):
+ '''Install support for sending connections and sockets
+ between processes
+ '''
+ # This is undocumented. In previous versions of multiprocessing
+ # its only effect was to make socket objects inheritable on Windows.
+ from . import connection
+
+ def set_executable(self, executable):
+ '''Sets the path to a python.exe or pythonw.exe binary used to run
+ child processes instead of sys.executable when using the 'spawn'
+ start method. Useful for people embedding Python.
+ '''
+ from .spawn import set_executable
+ set_executable(executable)
+
+ def set_forkserver_preload(self, module_names):
+ '''Set list of module names to try to load in forkserver process.
+ This is really just a hint.
+ '''
+ from .forkserver import set_forkserver_preload
+ set_forkserver_preload(module_names)
+
+ def get_context(self, method=None):
+ if method is None:
+ return self
+ try:
+ ctx = _concrete_contexts[method]
+ except KeyError:
+ raise ValueError('cannot find context for %r' % method) from None
+ ctx._check_available()
+ return ctx
+
+ def get_start_method(self, allow_none=False):
+ return self._name
+
+ def set_start_method(self, method, force=False):
+ raise ValueError('cannot set start method of concrete context')
+
+ @property
+ def reducer(self):
+ '''Controls how objects will be reduced to a form that can be
+ shared with other processes.'''
+ return globals().get('reduction')
+
+ @reducer.setter
+ def reducer(self, reduction):
+ globals()['reduction'] = reduction
+
+ def _check_available(self):
+ pass
+
+#
+# Type of default context -- underlying context can be set at most once
+#
+
+class Process(process.BaseProcess):
+ _start_method = None
+ @staticmethod
+ def _Popen(process_obj):
+ return _default_context.get_context().Process._Popen(process_obj)
+
+ @staticmethod
+ def _after_fork():
+ return _default_context.get_context().Process._after_fork()
+
+class DefaultContext(BaseContext):
+ Process = Process
+
+ def __init__(self, context):
+ self._default_context = context
+ self._actual_context = None
+
+ def get_context(self, method=None):
+ if method is None:
+ if self._actual_context is None:
+ self._actual_context = self._default_context
+ return self._actual_context
+ else:
+ return super().get_context(method)
+
+ def set_start_method(self, method, force=False):
+ if self._actual_context is not None and not force:
+ raise RuntimeError('context has already been set')
+ if method is None and force:
+ self._actual_context = None
+ return
+ self._actual_context = self.get_context(method)
+
+ def get_start_method(self, allow_none=False):
+ if self._actual_context is None:
+ if allow_none:
+ return None
+ self._actual_context = self._default_context
+ return self._actual_context._name
+
+ def get_all_start_methods(self):
+ """Returns a list of the supported start methods, default first."""
+ if sys.platform == 'win32':
+ return ['spawn']
+ else:
+ methods = ['spawn', 'fork'] if sys.platform == 'darwin' else ['fork', 'spawn']
+ if reduction.HAVE_SEND_HANDLE:
+ methods.append('forkserver')
+ return methods
+
+
+#
+# Context types for fixed start method
+#
+
+if sys.platform != 'win32':
+
+ class ForkProcess(process.BaseProcess):
+ _start_method = 'fork'
+ @staticmethod
+ def _Popen(process_obj):
+ from .popen_fork import Popen
+ return Popen(process_obj)
+
+ class SpawnProcess(process.BaseProcess):
+ _start_method = 'spawn'
+ @staticmethod
+ def _Popen(process_obj):
+ from .popen_spawn_posix import Popen
+ return Popen(process_obj)
+
+ @staticmethod
+ def _after_fork():
+ # process is spawned, nothing to do
+ pass
+
+ class ForkServerProcess(process.BaseProcess):
+ _start_method = 'forkserver'
+ @staticmethod
+ def _Popen(process_obj):
+ from .popen_forkserver import Popen
+ return Popen(process_obj)
+
+ class ForkContext(BaseContext):
+ _name = 'fork'
+ Process = ForkProcess
+
+ class SpawnContext(BaseContext):
+ _name = 'spawn'
+ Process = SpawnProcess
+
+ class ForkServerContext(BaseContext):
+ _name = 'forkserver'
+ Process = ForkServerProcess
+ def _check_available(self):
+ if not reduction.HAVE_SEND_HANDLE:
+ raise ValueError('forkserver start method not available')
+
+ _concrete_contexts = {
+ 'fork': ForkContext(),
+ 'spawn': SpawnContext(),
+ 'forkserver': ForkServerContext(),
+ }
+ if sys.platform == 'darwin':
+ # bpo-33725: running arbitrary code after fork() is no longer reliable
+ # on macOS since macOS 10.14 (Mojave). Use spawn by default instead.
+ _default_context = DefaultContext(_concrete_contexts['fork']) #FIXME: spawn
+ else:
+ _default_context = DefaultContext(_concrete_contexts['fork'])
+
+else:
+
+ class SpawnProcess(process.BaseProcess):
+ _start_method = 'spawn'
+ @staticmethod
+ def _Popen(process_obj):
+ from .popen_spawn_win32 import Popen
+ return Popen(process_obj)
+
+ @staticmethod
+ def _after_fork():
+ # process is spawned, nothing to do
+ pass
+
+ class SpawnContext(BaseContext):
+ _name = 'spawn'
+ Process = SpawnProcess
+
+ _concrete_contexts = {
+ 'spawn': SpawnContext(),
+ }
+ _default_context = DefaultContext(_concrete_contexts['spawn'])
+
+#
+# Force the start method
+#
+
+def _force_start_method(method):
+ _default_context._actual_context = _concrete_contexts[method]
+
+#
+# Check that the current thread is spawning a child process
+#
+
+_tls = threading.local()
+
+def get_spawning_popen():
+ return getattr(_tls, 'spawning_popen', None)
+
+def set_spawning_popen(popen):
+ _tls.spawning_popen = popen
+
+def assert_spawning(obj):
+ if get_spawning_popen() is None:
+ raise RuntimeError(
+ '%s objects should only be shared between processes'
+ ' through inheritance' % type(obj).__name__
+ )
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/forkserver.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/forkserver.py
new file mode 100644
index 0000000000000000000000000000000000000000..139c6dee9f81f37d28dea2ec84f2bd27e31cae1b
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/forkserver.py
@@ -0,0 +1,347 @@
+import errno
+import os
+import selectors
+import signal
+import socket
+import struct
+import sys
+import threading
+import warnings
+
+from . import connection
+from . import process
+from .context import reduction
+from . import resource_tracker
+from . import spawn
+from . import util
+
+__all__ = ['ensure_running', 'get_inherited_fds', 'connect_to_new_process',
+ 'set_forkserver_preload']
+
+#
+#
+#
+
+MAXFDS_TO_SEND = 256
+SIGNED_STRUCT = struct.Struct('q') # large enough for pid_t
+
+#
+# Forkserver class
+#
+
+class ForkServer(object):
+
+ def __init__(self):
+ self._forkserver_address = None
+ self._forkserver_alive_fd = None
+ self._forkserver_pid = None
+ self._inherited_fds = None
+ self._lock = threading.Lock()
+ self._preload_modules = ['__main__']
+
+ def _stop(self):
+ # Method used by unit tests to stop the server
+ with self._lock:
+ self._stop_unlocked()
+
+ def _stop_unlocked(self):
+ if self._forkserver_pid is None:
+ return
+
+ # close the "alive" file descriptor asks the server to stop
+ os.close(self._forkserver_alive_fd)
+ self._forkserver_alive_fd = None
+
+ os.waitpid(self._forkserver_pid, 0)
+ self._forkserver_pid = None
+
+ if not util.is_abstract_socket_namespace(self._forkserver_address):
+ os.unlink(self._forkserver_address)
+ self._forkserver_address = None
+
+ def set_forkserver_preload(self, modules_names):
+ '''Set list of module names to try to load in forkserver process.'''
+ if not all(type(mod) is str for mod in modules_names):
+ raise TypeError('module_names must be a list of strings')
+ self._preload_modules = modules_names
+
+ def get_inherited_fds(self):
+ '''Return list of fds inherited from parent process.
+
+ This returns None if the current process was not started by fork
+ server.
+ '''
+ return self._inherited_fds
+
+ def connect_to_new_process(self, fds):
+ '''Request forkserver to create a child process.
+
+ Returns a pair of fds (status_r, data_w). The calling process can read
+ the child process's pid and (eventually) its returncode from status_r.
+ The calling process should write to data_w the pickled preparation and
+ process data.
+ '''
+ self.ensure_running()
+ if len(fds) + 4 >= MAXFDS_TO_SEND:
+ raise ValueError('too many fds')
+ with socket.socket(socket.AF_UNIX) as client:
+ client.connect(self._forkserver_address)
+ parent_r, child_w = os.pipe()
+ child_r, parent_w = os.pipe()
+ allfds = [child_r, child_w, self._forkserver_alive_fd,
+ resource_tracker.getfd()]
+ allfds += fds
+ try:
+ reduction.sendfds(client, allfds)
+ return parent_r, parent_w
+ except:
+ os.close(parent_r)
+ os.close(parent_w)
+ raise
+ finally:
+ os.close(child_r)
+ os.close(child_w)
+
+ def ensure_running(self):
+ '''Make sure that a fork server is running.
+
+ This can be called from any process. Note that usually a child
+ process will just reuse the forkserver started by its parent, so
+ ensure_running() will do nothing.
+ '''
+ with self._lock:
+ resource_tracker.ensure_running()
+ if self._forkserver_pid is not None:
+ # forkserver was launched before, is it still running?
+ pid, status = os.waitpid(self._forkserver_pid, os.WNOHANG)
+ if not pid:
+ # still alive
+ return
+ # dead, launch it again
+ os.close(self._forkserver_alive_fd)
+ self._forkserver_address = None
+ self._forkserver_alive_fd = None
+ self._forkserver_pid = None
+
+ cmd = ('from multiprocess.forkserver import main; ' +
+ 'main(%d, %d, %r, **%r)')
+
+ if self._preload_modules:
+ desired_keys = {'main_path', 'sys_path'}
+ data = spawn.get_preparation_data('ignore')
+ data = {x: y for x, y in data.items() if x in desired_keys}
+ else:
+ data = {}
+
+ with socket.socket(socket.AF_UNIX) as listener:
+ address = connection.arbitrary_address('AF_UNIX')
+ listener.bind(address)
+ if not util.is_abstract_socket_namespace(address):
+ os.chmod(address, 0o600)
+ listener.listen()
+
+ # all client processes own the write end of the "alive" pipe;
+ # when they all terminate the read end becomes ready.
+ alive_r, alive_w = os.pipe()
+ try:
+ fds_to_pass = [listener.fileno(), alive_r]
+ cmd %= (listener.fileno(), alive_r, self._preload_modules,
+ data)
+ exe = spawn.get_executable()
+ args = [exe] + util._args_from_interpreter_flags()
+ args += ['-c', cmd]
+ pid = util.spawnv_passfds(exe, args, fds_to_pass)
+ except:
+ os.close(alive_w)
+ raise
+ finally:
+ os.close(alive_r)
+ self._forkserver_address = address
+ self._forkserver_alive_fd = alive_w
+ self._forkserver_pid = pid
+
+#
+#
+#
+
+def main(listener_fd, alive_r, preload, main_path=None, sys_path=None):
+ '''Run forkserver.'''
+ if preload:
+ if '__main__' in preload and main_path is not None:
+ process.current_process()._inheriting = True
+ try:
+ spawn.import_main_path(main_path)
+ finally:
+ del process.current_process()._inheriting
+ for modname in preload:
+ try:
+ __import__(modname)
+ except ImportError:
+ pass
+
+ util._close_stdin()
+
+ sig_r, sig_w = os.pipe()
+ os.set_blocking(sig_r, False)
+ os.set_blocking(sig_w, False)
+
+ def sigchld_handler(*_unused):
+ # Dummy signal handler, doesn't do anything
+ pass
+
+ handlers = {
+ # unblocking SIGCHLD allows the wakeup fd to notify our event loop
+ signal.SIGCHLD: sigchld_handler,
+ # protect the process from ^C
+ signal.SIGINT: signal.SIG_IGN,
+ }
+ old_handlers = {sig: signal.signal(sig, val)
+ for (sig, val) in handlers.items()}
+
+ # calling os.write() in the Python signal handler is racy
+ signal.set_wakeup_fd(sig_w)
+
+ # map child pids to client fds
+ pid_to_fd = {}
+
+ with socket.socket(socket.AF_UNIX, fileno=listener_fd) as listener, \
+ selectors.DefaultSelector() as selector:
+ _forkserver._forkserver_address = listener.getsockname()
+
+ selector.register(listener, selectors.EVENT_READ)
+ selector.register(alive_r, selectors.EVENT_READ)
+ selector.register(sig_r, selectors.EVENT_READ)
+
+ while True:
+ try:
+ while True:
+ rfds = [key.fileobj for (key, events) in selector.select()]
+ if rfds:
+ break
+
+ if alive_r in rfds:
+ # EOF because no more client processes left
+ assert os.read(alive_r, 1) == b'', "Not at EOF?"
+ raise SystemExit
+
+ if sig_r in rfds:
+ # Got SIGCHLD
+ os.read(sig_r, 65536) # exhaust
+ while True:
+ # Scan for child processes
+ try:
+ pid, sts = os.waitpid(-1, os.WNOHANG)
+ except ChildProcessError:
+ break
+ if pid == 0:
+ break
+ child_w = pid_to_fd.pop(pid, None)
+ if child_w is not None:
+ returncode = os.waitstatus_to_exitcode(sts)
+ # Send exit code to client process
+ try:
+ write_signed(child_w, returncode)
+ except BrokenPipeError:
+ # client vanished
+ pass
+ os.close(child_w)
+ else:
+ # This shouldn't happen really
+ warnings.warn('forkserver: waitpid returned '
+ 'unexpected pid %d' % pid)
+
+ if listener in rfds:
+ # Incoming fork request
+ with listener.accept()[0] as s:
+ # Receive fds from client
+ fds = reduction.recvfds(s, MAXFDS_TO_SEND + 1)
+ if len(fds) > MAXFDS_TO_SEND:
+ raise RuntimeError(
+ "Too many ({0:n}) fds to send".format(
+ len(fds)))
+ child_r, child_w, *fds = fds
+ s.close()
+ pid = os.fork()
+ if pid == 0:
+ # Child
+ code = 1
+ try:
+ listener.close()
+ selector.close()
+ unused_fds = [alive_r, child_w, sig_r, sig_w]
+ unused_fds.extend(pid_to_fd.values())
+ code = _serve_one(child_r, fds,
+ unused_fds,
+ old_handlers)
+ except Exception:
+ sys.excepthook(*sys.exc_info())
+ sys.stderr.flush()
+ finally:
+ os._exit(code)
+ else:
+ # Send pid to client process
+ try:
+ write_signed(child_w, pid)
+ except BrokenPipeError:
+ # client vanished
+ pass
+ pid_to_fd[pid] = child_w
+ os.close(child_r)
+ for fd in fds:
+ os.close(fd)
+
+ except OSError as e:
+ if e.errno != errno.ECONNABORTED:
+ raise
+
+
+def _serve_one(child_r, fds, unused_fds, handlers):
+ # close unnecessary stuff and reset signal handlers
+ signal.set_wakeup_fd(-1)
+ for sig, val in handlers.items():
+ signal.signal(sig, val)
+ for fd in unused_fds:
+ os.close(fd)
+
+ (_forkserver._forkserver_alive_fd,
+ resource_tracker._resource_tracker._fd,
+ *_forkserver._inherited_fds) = fds
+
+ # Run process object received over pipe
+ parent_sentinel = os.dup(child_r)
+ code = spawn._main(child_r, parent_sentinel)
+
+ return code
+
+
+#
+# Read and write signed numbers
+#
+
+def read_signed(fd):
+ data = b''
+ length = SIGNED_STRUCT.size
+ while len(data) < length:
+ s = os.read(fd, length - len(data))
+ if not s:
+ raise EOFError('unexpected EOF')
+ data += s
+ return SIGNED_STRUCT.unpack(data)[0]
+
+def write_signed(fd, n):
+ msg = SIGNED_STRUCT.pack(n)
+ while msg:
+ nbytes = os.write(fd, msg)
+ if nbytes == 0:
+ raise RuntimeError('should not get here')
+ msg = msg[nbytes:]
+
+#
+#
+#
+
+_forkserver = ForkServer()
+ensure_running = _forkserver.ensure_running
+get_inherited_fds = _forkserver.get_inherited_fds
+connect_to_new_process = _forkserver.connect_to_new_process
+set_forkserver_preload = _forkserver.set_forkserver_preload
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/heap.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/heap.py
new file mode 100644
index 0000000000000000000000000000000000000000..6217dfe12689b379f2dad6f1e4bc3bbf6af8f60a
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/heap.py
@@ -0,0 +1,337 @@
+#
+# Module which supports allocation of memory from an mmap
+#
+# multiprocessing/heap.py
+#
+# Copyright (c) 2006-2008, R Oudkerk
+# Licensed to PSF under a Contributor Agreement.
+#
+
+import bisect
+from collections import defaultdict
+import mmap
+import os
+import sys
+import tempfile
+import threading
+
+from .context import reduction, assert_spawning
+from . import util
+
+__all__ = ['BufferWrapper']
+
+#
+# Inheritable class which wraps an mmap, and from which blocks can be allocated
+#
+
+if sys.platform == 'win32':
+
+ import _winapi
+
+ class Arena(object):
+ """
+ A shared memory area backed by anonymous memory (Windows).
+ """
+
+ _rand = tempfile._RandomNameSequence()
+
+ def __init__(self, size):
+ self.size = size
+ for i in range(100):
+ name = 'pym-%d-%s' % (os.getpid(), next(self._rand))
+ buf = mmap.mmap(-1, size, tagname=name)
+ if _winapi.GetLastError() == 0:
+ break
+ # We have reopened a preexisting mmap.
+ buf.close()
+ else:
+ raise FileExistsError('Cannot find name for new mmap')
+ self.name = name
+ self.buffer = buf
+ self._state = (self.size, self.name)
+
+ def __getstate__(self):
+ assert_spawning(self)
+ return self._state
+
+ def __setstate__(self, state):
+ self.size, self.name = self._state = state
+ # Reopen existing mmap
+ self.buffer = mmap.mmap(-1, self.size, tagname=self.name)
+ # XXX Temporarily preventing buildbot failures while determining
+ # XXX the correct long-term fix. See issue 23060
+ #assert _winapi.GetLastError() == _winapi.ERROR_ALREADY_EXISTS
+
+else:
+
+ class Arena(object):
+ """
+ A shared memory area backed by a temporary file (POSIX).
+ """
+
+ if sys.platform == 'linux':
+ _dir_candidates = ['/dev/shm']
+ else:
+ _dir_candidates = []
+
+ def __init__(self, size, fd=-1):
+ self.size = size
+ self.fd = fd
+ if fd == -1:
+ # Arena is created anew (if fd != -1, it means we're coming
+ # from rebuild_arena() below)
+ self.fd, name = tempfile.mkstemp(
+ prefix='pym-%d-'%os.getpid(),
+ dir=self._choose_dir(size))
+ os.unlink(name)
+ util.Finalize(self, os.close, (self.fd,))
+ os.ftruncate(self.fd, size)
+ self.buffer = mmap.mmap(self.fd, self.size)
+
+ def _choose_dir(self, size):
+ # Choose a non-storage backed directory if possible,
+ # to improve performance
+ for d in self._dir_candidates:
+ st = os.statvfs(d)
+ if st.f_bavail * st.f_frsize >= size: # enough free space?
+ return d
+ return util.get_temp_dir()
+
+ def reduce_arena(a):
+ if a.fd == -1:
+ raise ValueError('Arena is unpicklable because '
+ 'forking was enabled when it was created')
+ return rebuild_arena, (a.size, reduction.DupFd(a.fd))
+
+ def rebuild_arena(size, dupfd):
+ return Arena(size, dupfd.detach())
+
+ reduction.register(Arena, reduce_arena)
+
+#
+# Class allowing allocation of chunks of memory from arenas
+#
+
+class Heap(object):
+
+ # Minimum malloc() alignment
+ _alignment = 8
+
+ _DISCARD_FREE_SPACE_LARGER_THAN = 4 * 1024 ** 2 # 4 MB
+ _DOUBLE_ARENA_SIZE_UNTIL = 4 * 1024 ** 2
+
+ def __init__(self, size=mmap.PAGESIZE):
+ self._lastpid = os.getpid()
+ self._lock = threading.Lock()
+ # Current arena allocation size
+ self._size = size
+ # A sorted list of available block sizes in arenas
+ self._lengths = []
+
+ # Free block management:
+ # - map each block size to a list of `(Arena, start, stop)` blocks
+ self._len_to_seq = {}
+ # - map `(Arena, start)` tuple to the `(Arena, start, stop)` block
+ # starting at that offset
+ self._start_to_block = {}
+ # - map `(Arena, stop)` tuple to the `(Arena, start, stop)` block
+ # ending at that offset
+ self._stop_to_block = {}
+
+ # Map arenas to their `(Arena, start, stop)` blocks in use
+ self._allocated_blocks = defaultdict(set)
+ self._arenas = []
+
+ # List of pending blocks to free - see comment in free() below
+ self._pending_free_blocks = []
+
+ # Statistics
+ self._n_mallocs = 0
+ self._n_frees = 0
+
+ @staticmethod
+ def _roundup(n, alignment):
+ # alignment must be a power of 2
+ mask = alignment - 1
+ return (n + mask) & ~mask
+
+ def _new_arena(self, size):
+ # Create a new arena with at least the given *size*
+ length = self._roundup(max(self._size, size), mmap.PAGESIZE)
+ # We carve larger and larger arenas, for efficiency, until we
+ # reach a large-ish size (roughly L3 cache-sized)
+ if self._size < self._DOUBLE_ARENA_SIZE_UNTIL:
+ self._size *= 2
+ util.info('allocating a new mmap of length %d', length)
+ arena = Arena(length)
+ self._arenas.append(arena)
+ return (arena, 0, length)
+
+ def _discard_arena(self, arena):
+ # Possibly delete the given (unused) arena
+ length = arena.size
+ # Reusing an existing arena is faster than creating a new one, so
+ # we only reclaim space if it's large enough.
+ if length < self._DISCARD_FREE_SPACE_LARGER_THAN:
+ return
+ blocks = self._allocated_blocks.pop(arena)
+ assert not blocks
+ del self._start_to_block[(arena, 0)]
+ del self._stop_to_block[(arena, length)]
+ self._arenas.remove(arena)
+ seq = self._len_to_seq[length]
+ seq.remove((arena, 0, length))
+ if not seq:
+ del self._len_to_seq[length]
+ self._lengths.remove(length)
+
+ def _malloc(self, size):
+ # returns a large enough block -- it might be much larger
+ i = bisect.bisect_left(self._lengths, size)
+ if i == len(self._lengths):
+ return self._new_arena(size)
+ else:
+ length = self._lengths[i]
+ seq = self._len_to_seq[length]
+ block = seq.pop()
+ if not seq:
+ del self._len_to_seq[length], self._lengths[i]
+
+ (arena, start, stop) = block
+ del self._start_to_block[(arena, start)]
+ del self._stop_to_block[(arena, stop)]
+ return block
+
+ def _add_free_block(self, block):
+ # make block available and try to merge with its neighbours in the arena
+ (arena, start, stop) = block
+
+ try:
+ prev_block = self._stop_to_block[(arena, start)]
+ except KeyError:
+ pass
+ else:
+ start, _ = self._absorb(prev_block)
+
+ try:
+ next_block = self._start_to_block[(arena, stop)]
+ except KeyError:
+ pass
+ else:
+ _, stop = self._absorb(next_block)
+
+ block = (arena, start, stop)
+ length = stop - start
+
+ try:
+ self._len_to_seq[length].append(block)
+ except KeyError:
+ self._len_to_seq[length] = [block]
+ bisect.insort(self._lengths, length)
+
+ self._start_to_block[(arena, start)] = block
+ self._stop_to_block[(arena, stop)] = block
+
+ def _absorb(self, block):
+ # deregister this block so it can be merged with a neighbour
+ (arena, start, stop) = block
+ del self._start_to_block[(arena, start)]
+ del self._stop_to_block[(arena, stop)]
+
+ length = stop - start
+ seq = self._len_to_seq[length]
+ seq.remove(block)
+ if not seq:
+ del self._len_to_seq[length]
+ self._lengths.remove(length)
+
+ return start, stop
+
+ def _remove_allocated_block(self, block):
+ arena, start, stop = block
+ blocks = self._allocated_blocks[arena]
+ blocks.remove((start, stop))
+ if not blocks:
+ # Arena is entirely free, discard it from this process
+ self._discard_arena(arena)
+
+ def _free_pending_blocks(self):
+ # Free all the blocks in the pending list - called with the lock held.
+ while True:
+ try:
+ block = self._pending_free_blocks.pop()
+ except IndexError:
+ break
+ self._add_free_block(block)
+ self._remove_allocated_block(block)
+
+ def free(self, block):
+ # free a block returned by malloc()
+ # Since free() can be called asynchronously by the GC, it could happen
+ # that it's called while self._lock is held: in that case,
+ # self._lock.acquire() would deadlock (issue #12352). To avoid that, a
+ # trylock is used instead, and if the lock can't be acquired
+ # immediately, the block is added to a list of blocks to be freed
+ # synchronously sometimes later from malloc() or free(), by calling
+ # _free_pending_blocks() (appending and retrieving from a list is not
+ # strictly thread-safe but under CPython it's atomic thanks to the GIL).
+ if os.getpid() != self._lastpid:
+ raise ValueError(
+ "My pid ({0:n}) is not last pid {1:n}".format(
+ os.getpid(),self._lastpid))
+ if not self._lock.acquire(False):
+ # can't acquire the lock right now, add the block to the list of
+ # pending blocks to free
+ self._pending_free_blocks.append(block)
+ else:
+ # we hold the lock
+ try:
+ self._n_frees += 1
+ self._free_pending_blocks()
+ self._add_free_block(block)
+ self._remove_allocated_block(block)
+ finally:
+ self._lock.release()
+
+ def malloc(self, size):
+ # return a block of right size (possibly rounded up)
+ if size < 0:
+ raise ValueError("Size {0:n} out of range".format(size))
+ if sys.maxsize <= size:
+ raise OverflowError("Size {0:n} too large".format(size))
+ if os.getpid() != self._lastpid:
+ self.__init__() # reinitialize after fork
+ with self._lock:
+ self._n_mallocs += 1
+ # allow pending blocks to be marked available
+ self._free_pending_blocks()
+ size = self._roundup(max(size, 1), self._alignment)
+ (arena, start, stop) = self._malloc(size)
+ real_stop = start + size
+ if real_stop < stop:
+ # if the returned block is larger than necessary, mark
+ # the remainder available
+ self._add_free_block((arena, real_stop, stop))
+ self._allocated_blocks[arena].add((start, real_stop))
+ return (arena, start, real_stop)
+
+#
+# Class wrapping a block allocated out of a Heap -- can be inherited by child process
+#
+
+class BufferWrapper(object):
+
+ _heap = Heap()
+
+ def __init__(self, size):
+ if size < 0:
+ raise ValueError("Size {0:n} out of range".format(size))
+ if sys.maxsize <= size:
+ raise OverflowError("Size {0:n} too large".format(size))
+ block = BufferWrapper._heap.malloc(size)
+ self._state = (block, size)
+ util.Finalize(self, BufferWrapper._heap.free, args=(block,))
+
+ def create_memoryview(self):
+ (arena, start, stop), size = self._state
+ return memoryview(arena.buffer)[start:start+size]
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/managers.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/managers.py
new file mode 100644
index 0000000000000000000000000000000000000000..cccf118a2722e17b2a2ead2b7ae65c9993531c50
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/managers.py
@@ -0,0 +1,1380 @@
+#
+# Module providing manager classes for dealing
+# with shared objects
+#
+# multiprocessing/managers.py
+#
+# Copyright (c) 2006-2008, R Oudkerk
+# Licensed to PSF under a Contributor Agreement.
+#
+
+__all__ = [ 'BaseManager', 'SyncManager', 'BaseProxy', 'Token' ]
+
+#
+# Imports
+#
+
+import sys
+import threading
+import signal
+import array
+import queue
+import time
+import types
+import os
+from os import getpid
+
+from traceback import format_exc
+
+from . import connection
+from .context import reduction, get_spawning_popen, ProcessError
+from . import pool
+from . import process
+from . import util
+from . import get_context
+try:
+ from . import shared_memory
+except ImportError:
+ HAS_SHMEM = False
+else:
+ HAS_SHMEM = True
+ __all__.append('SharedMemoryManager')
+
+#
+# Register some things for pickling
+#
+
+def reduce_array(a):
+ return array.array, (a.typecode, a.tobytes())
+reduction.register(array.array, reduce_array)
+
+view_types = [type(getattr({}, name)()) for name in ('items','keys','values')]
+def rebuild_as_list(obj):
+ return list, (list(obj),)
+for view_type in view_types:
+ reduction.register(view_type, rebuild_as_list)
+del view_type, view_types
+
+#
+# Type for identifying shared objects
+#
+
+class Token(object):
+ '''
+ Type to uniquely identify a shared object
+ '''
+ __slots__ = ('typeid', 'address', 'id')
+
+ def __init__(self, typeid, address, id):
+ (self.typeid, self.address, self.id) = (typeid, address, id)
+
+ def __getstate__(self):
+ return (self.typeid, self.address, self.id)
+
+ def __setstate__(self, state):
+ (self.typeid, self.address, self.id) = state
+
+ def __repr__(self):
+ return '%s(typeid=%r, address=%r, id=%r)' % \
+ (self.__class__.__name__, self.typeid, self.address, self.id)
+
+#
+# Function for communication with a manager's server process
+#
+
+def dispatch(c, id, methodname, args=(), kwds={}):
+ '''
+ Send a message to manager using connection `c` and return response
+ '''
+ c.send((id, methodname, args, kwds))
+ kind, result = c.recv()
+ if kind == '#RETURN':
+ return result
+ raise convert_to_error(kind, result)
+
+def convert_to_error(kind, result):
+ if kind == '#ERROR':
+ return result
+ elif kind in ('#TRACEBACK', '#UNSERIALIZABLE'):
+ if not isinstance(result, str):
+ raise TypeError(
+ "Result {0!r} (kind '{1}') type is {2}, not str".format(
+ result, kind, type(result)))
+ if kind == '#UNSERIALIZABLE':
+ return RemoteError('Unserializable message: %s\n' % result)
+ else:
+ return RemoteError(result)
+ else:
+ return ValueError('Unrecognized message type {!r}'.format(kind))
+
+class RemoteError(Exception):
+ def __str__(self):
+ return ('\n' + '-'*75 + '\n' + str(self.args[0]) + '-'*75)
+
+#
+# Functions for finding the method names of an object
+#
+
+def all_methods(obj):
+ '''
+ Return a list of names of methods of `obj`
+ '''
+ temp = []
+ for name in dir(obj):
+ func = getattr(obj, name)
+ if callable(func):
+ temp.append(name)
+ return temp
+
+def public_methods(obj):
+ '''
+ Return a list of names of methods of `obj` which do not start with '_'
+ '''
+ return [name for name in all_methods(obj) if name[0] != '_']
+
+#
+# Server which is run in a process controlled by a manager
+#
+
+class Server(object):
+ '''
+ Server class which runs in a process controlled by a manager object
+ '''
+ public = ['shutdown', 'create', 'accept_connection', 'get_methods',
+ 'debug_info', 'number_of_objects', 'dummy', 'incref', 'decref']
+
+ def __init__(self, registry, address, authkey, serializer):
+ if not isinstance(authkey, bytes):
+ raise TypeError(
+ "Authkey {0!r} is type {1!s}, not bytes".format(
+ authkey, type(authkey)))
+ self.registry = registry
+ self.authkey = process.AuthenticationString(authkey)
+ Listener, Client = listener_client[serializer]
+
+ # do authentication later
+ self.listener = Listener(address=address, backlog=16)
+ self.address = self.listener.address
+
+ self.id_to_obj = {'0': (None, ())}
+ self.id_to_refcount = {}
+ self.id_to_local_proxy_obj = {}
+ self.mutex = threading.Lock()
+
+ def serve_forever(self):
+ '''
+ Run the server forever
+ '''
+ self.stop_event = threading.Event()
+ process.current_process()._manager_server = self
+ try:
+ accepter = threading.Thread(target=self.accepter)
+ accepter.daemon = True
+ accepter.start()
+ try:
+ while not self.stop_event.is_set():
+ self.stop_event.wait(1)
+ except (KeyboardInterrupt, SystemExit):
+ pass
+ finally:
+ if sys.stdout != sys.__stdout__: # what about stderr?
+ util.debug('resetting stdout, stderr')
+ sys.stdout = sys.__stdout__
+ sys.stderr = sys.__stderr__
+ sys.exit(0)
+
+ def accepter(self):
+ while True:
+ try:
+ c = self.listener.accept()
+ except OSError:
+ continue
+ t = threading.Thread(target=self.handle_request, args=(c,))
+ t.daemon = True
+ t.start()
+
+ def _handle_request(self, c):
+ request = None
+ try:
+ connection.deliver_challenge(c, self.authkey)
+ connection.answer_challenge(c, self.authkey)
+ request = c.recv()
+ ignore, funcname, args, kwds = request
+ assert funcname in self.public, '%r unrecognized' % funcname
+ func = getattr(self, funcname)
+ except Exception:
+ msg = ('#TRACEBACK', format_exc())
+ else:
+ try:
+ result = func(c, *args, **kwds)
+ except Exception:
+ msg = ('#TRACEBACK', format_exc())
+ else:
+ msg = ('#RETURN', result)
+
+ try:
+ c.send(msg)
+ except Exception as e:
+ try:
+ c.send(('#TRACEBACK', format_exc()))
+ except Exception:
+ pass
+ util.info('Failure to send message: %r', msg)
+ util.info(' ... request was %r', request)
+ util.info(' ... exception was %r', e)
+
+ def handle_request(self, conn):
+ '''
+ Handle a new connection
+ '''
+ try:
+ self._handle_request(conn)
+ except SystemExit:
+ # Server.serve_client() calls sys.exit(0) on EOF
+ pass
+ finally:
+ conn.close()
+
+ def serve_client(self, conn):
+ '''
+ Handle requests from the proxies in a particular process/thread
+ '''
+ util.debug('starting server thread to service %r',
+ threading.current_thread().name)
+
+ recv = conn.recv
+ send = conn.send
+ id_to_obj = self.id_to_obj
+
+ while not self.stop_event.is_set():
+
+ try:
+ methodname = obj = None
+ request = recv()
+ ident, methodname, args, kwds = request
+ try:
+ obj, exposed, gettypeid = id_to_obj[ident]
+ except KeyError as ke:
+ try:
+ obj, exposed, gettypeid = \
+ self.id_to_local_proxy_obj[ident]
+ except KeyError:
+ raise ke
+
+ if methodname not in exposed:
+ raise AttributeError(
+ 'method %r of %r object is not in exposed=%r' %
+ (methodname, type(obj), exposed)
+ )
+
+ function = getattr(obj, methodname)
+
+ try:
+ res = function(*args, **kwds)
+ except Exception as e:
+ msg = ('#ERROR', e)
+ else:
+ typeid = gettypeid and gettypeid.get(methodname, None)
+ if typeid:
+ rident, rexposed = self.create(conn, typeid, res)
+ token = Token(typeid, self.address, rident)
+ msg = ('#PROXY', (rexposed, token))
+ else:
+ msg = ('#RETURN', res)
+
+ except AttributeError:
+ if methodname is None:
+ msg = ('#TRACEBACK', format_exc())
+ else:
+ try:
+ fallback_func = self.fallback_mapping[methodname]
+ result = fallback_func(
+ self, conn, ident, obj, *args, **kwds
+ )
+ msg = ('#RETURN', result)
+ except Exception:
+ msg = ('#TRACEBACK', format_exc())
+
+ except EOFError:
+ util.debug('got EOF -- exiting thread serving %r',
+ threading.current_thread().name)
+ sys.exit(0)
+
+ except Exception:
+ msg = ('#TRACEBACK', format_exc())
+
+ try:
+ try:
+ send(msg)
+ except Exception:
+ send(('#UNSERIALIZABLE', format_exc()))
+ except Exception as e:
+ util.info('exception in thread serving %r',
+ threading.current_thread().name)
+ util.info(' ... message was %r', msg)
+ util.info(' ... exception was %r', e)
+ conn.close()
+ sys.exit(1)
+
+ def fallback_getvalue(self, conn, ident, obj):
+ return obj
+
+ def fallback_str(self, conn, ident, obj):
+ return str(obj)
+
+ def fallback_repr(self, conn, ident, obj):
+ return repr(obj)
+
+ fallback_mapping = {
+ '__str__':fallback_str,
+ '__repr__':fallback_repr,
+ '#GETVALUE':fallback_getvalue
+ }
+
+ def dummy(self, c):
+ pass
+
+ def debug_info(self, c):
+ '''
+ Return some info --- useful to spot problems with refcounting
+ '''
+ # Perhaps include debug info about 'c'?
+ with self.mutex:
+ result = []
+ keys = list(self.id_to_refcount.keys())
+ keys.sort()
+ for ident in keys:
+ if ident != '0':
+ result.append(' %s: refcount=%s\n %s' %
+ (ident, self.id_to_refcount[ident],
+ str(self.id_to_obj[ident][0])[:75]))
+ return '\n'.join(result)
+
+ def number_of_objects(self, c):
+ '''
+ Number of shared objects
+ '''
+ # Doesn't use (len(self.id_to_obj) - 1) as we shouldn't count ident='0'
+ return len(self.id_to_refcount)
+
+ def shutdown(self, c):
+ '''
+ Shutdown this process
+ '''
+ try:
+ util.debug('manager received shutdown message')
+ c.send(('#RETURN', None))
+ except:
+ import traceback
+ traceback.print_exc()
+ finally:
+ self.stop_event.set()
+
+ def create(self, c, typeid, /, *args, **kwds):
+ '''
+ Create a new shared object and return its id
+ '''
+ with self.mutex:
+ callable, exposed, method_to_typeid, proxytype = \
+ self.registry[typeid]
+
+ if callable is None:
+ if kwds or (len(args) != 1):
+ raise ValueError(
+ "Without callable, must have one non-keyword argument")
+ obj = args[0]
+ else:
+ obj = callable(*args, **kwds)
+
+ if exposed is None:
+ exposed = public_methods(obj)
+ if method_to_typeid is not None:
+ if not isinstance(method_to_typeid, dict):
+ raise TypeError(
+ "Method_to_typeid {0!r}: type {1!s}, not dict".format(
+ method_to_typeid, type(method_to_typeid)))
+ exposed = list(exposed) + list(method_to_typeid)
+
+ ident = '%x' % id(obj) # convert to string because xmlrpclib
+ # only has 32 bit signed integers
+ util.debug('%r callable returned object with id %r', typeid, ident)
+
+ self.id_to_obj[ident] = (obj, set(exposed), method_to_typeid)
+ if ident not in self.id_to_refcount:
+ self.id_to_refcount[ident] = 0
+
+ self.incref(c, ident)
+ return ident, tuple(exposed)
+
+ def get_methods(self, c, token):
+ '''
+ Return the methods of the shared object indicated by token
+ '''
+ return tuple(self.id_to_obj[token.id][1])
+
+ def accept_connection(self, c, name):
+ '''
+ Spawn a new thread to serve this connection
+ '''
+ threading.current_thread().name = name
+ c.send(('#RETURN', None))
+ self.serve_client(c)
+
+ def incref(self, c, ident):
+ with self.mutex:
+ try:
+ self.id_to_refcount[ident] += 1
+ except KeyError as ke:
+ # If no external references exist but an internal (to the
+ # manager) still does and a new external reference is created
+ # from it, restore the manager's tracking of it from the
+ # previously stashed internal ref.
+ if ident in self.id_to_local_proxy_obj:
+ self.id_to_refcount[ident] = 1
+ self.id_to_obj[ident] = \
+ self.id_to_local_proxy_obj[ident]
+ util.debug('Server re-enabled tracking & INCREF %r', ident)
+ else:
+ raise ke
+
+ def decref(self, c, ident):
+ if ident not in self.id_to_refcount and \
+ ident in self.id_to_local_proxy_obj:
+ util.debug('Server DECREF skipping %r', ident)
+ return
+
+ with self.mutex:
+ if self.id_to_refcount[ident] <= 0:
+ raise AssertionError(
+ "Id {0!s} ({1!r}) has refcount {2:n}, not 1+".format(
+ ident, self.id_to_obj[ident],
+ self.id_to_refcount[ident]))
+ self.id_to_refcount[ident] -= 1
+ if self.id_to_refcount[ident] == 0:
+ del self.id_to_refcount[ident]
+
+ if ident not in self.id_to_refcount:
+ # Two-step process in case the object turns out to contain other
+ # proxy objects (e.g. a managed list of managed lists).
+ # Otherwise, deleting self.id_to_obj[ident] would trigger the
+ # deleting of the stored value (another managed object) which would
+ # in turn attempt to acquire the mutex that is already held here.
+ self.id_to_obj[ident] = (None, (), None) # thread-safe
+ util.debug('disposing of obj with id %r', ident)
+ with self.mutex:
+ del self.id_to_obj[ident]
+
+
+#
+# Class to represent state of a manager
+#
+
+class State(object):
+ __slots__ = ['value']
+ INITIAL = 0
+ STARTED = 1
+ SHUTDOWN = 2
+
+#
+# Mapping from serializer name to Listener and Client types
+#
+
+listener_client = { #XXX: register dill?
+ 'pickle' : (connection.Listener, connection.Client),
+ 'xmlrpclib' : (connection.XmlListener, connection.XmlClient)
+ }
+
+#
+# Definition of BaseManager
+#
+
+class BaseManager(object):
+ '''
+ Base class for managers
+ '''
+ _registry = {}
+ _Server = Server
+
+ def __init__(self, address=None, authkey=None, serializer='pickle',
+ ctx=None, *, shutdown_timeout=1.0):
+ if authkey is None:
+ authkey = process.current_process().authkey
+ self._address = address # XXX not final address if eg ('', 0)
+ self._authkey = process.AuthenticationString(authkey)
+ self._state = State()
+ self._state.value = State.INITIAL
+ self._serializer = serializer
+ self._Listener, self._Client = listener_client[serializer]
+ self._ctx = ctx or get_context()
+ self._shutdown_timeout = shutdown_timeout
+
+ def get_server(self):
+ '''
+ Return server object with serve_forever() method and address attribute
+ '''
+ if self._state.value != State.INITIAL:
+ if self._state.value == State.STARTED:
+ raise ProcessError("Already started server")
+ elif self._state.value == State.SHUTDOWN:
+ raise ProcessError("Manager has shut down")
+ else:
+ raise ProcessError(
+ "Unknown state {!r}".format(self._state.value))
+ return Server(self._registry, self._address,
+ self._authkey, self._serializer)
+
+ def connect(self):
+ '''
+ Connect manager object to the server process
+ '''
+ Listener, Client = listener_client[self._serializer]
+ conn = Client(self._address, authkey=self._authkey)
+ dispatch(conn, None, 'dummy')
+ self._state.value = State.STARTED
+
+ def start(self, initializer=None, initargs=()):
+ '''
+ Spawn a server process for this manager object
+ '''
+ if self._state.value != State.INITIAL:
+ if self._state.value == State.STARTED:
+ raise ProcessError("Already started server")
+ elif self._state.value == State.SHUTDOWN:
+ raise ProcessError("Manager has shut down")
+ else:
+ raise ProcessError(
+ "Unknown state {!r}".format(self._state.value))
+
+ if initializer is not None and not callable(initializer):
+ raise TypeError('initializer must be a callable')
+
+ # pipe over which we will retrieve address of server
+ reader, writer = connection.Pipe(duplex=False)
+
+ # spawn process which runs a server
+ self._process = self._ctx.Process(
+ target=type(self)._run_server,
+ args=(self._registry, self._address, self._authkey,
+ self._serializer, writer, initializer, initargs),
+ )
+ ident = ':'.join(str(i) for i in self._process._identity)
+ self._process.name = type(self).__name__ + '-' + ident
+ self._process.start()
+
+ # get address of server
+ writer.close()
+ self._address = reader.recv()
+ reader.close()
+
+ # register a finalizer
+ self._state.value = State.STARTED
+ self.shutdown = util.Finalize(
+ self, type(self)._finalize_manager,
+ args=(self._process, self._address, self._authkey, self._state,
+ self._Client, self._shutdown_timeout),
+ exitpriority=0
+ )
+
+ @classmethod
+ def _run_server(cls, registry, address, authkey, serializer, writer,
+ initializer=None, initargs=()):
+ '''
+ Create a server, report its address and run it
+ '''
+ # bpo-36368: protect server process from KeyboardInterrupt signals
+ signal.signal(signal.SIGINT, signal.SIG_IGN)
+
+ if initializer is not None:
+ initializer(*initargs)
+
+ # create server
+ server = cls._Server(registry, address, authkey, serializer)
+
+ # inform parent process of the server's address
+ writer.send(server.address)
+ writer.close()
+
+ # run the manager
+ util.info('manager serving at %r', server.address)
+ server.serve_forever()
+
+ def _create(self, typeid, /, *args, **kwds):
+ '''
+ Create a new shared object; return the token and exposed tuple
+ '''
+ assert self._state.value == State.STARTED, 'server not yet started'
+ conn = self._Client(self._address, authkey=self._authkey)
+ try:
+ id, exposed = dispatch(conn, None, 'create', (typeid,)+args, kwds)
+ finally:
+ conn.close()
+ return Token(typeid, self._address, id), exposed
+
+ def join(self, timeout=None):
+ '''
+ Join the manager process (if it has been spawned)
+ '''
+ if self._process is not None:
+ self._process.join(timeout)
+ if not self._process.is_alive():
+ self._process = None
+
+ def _debug_info(self):
+ '''
+ Return some info about the servers shared objects and connections
+ '''
+ conn = self._Client(self._address, authkey=self._authkey)
+ try:
+ return dispatch(conn, None, 'debug_info')
+ finally:
+ conn.close()
+
+ def _number_of_objects(self):
+ '''
+ Return the number of shared objects
+ '''
+ conn = self._Client(self._address, authkey=self._authkey)
+ try:
+ return dispatch(conn, None, 'number_of_objects')
+ finally:
+ conn.close()
+
+ def __enter__(self):
+ if self._state.value == State.INITIAL:
+ self.start()
+ if self._state.value != State.STARTED:
+ if self._state.value == State.INITIAL:
+ raise ProcessError("Unable to start server")
+ elif self._state.value == State.SHUTDOWN:
+ raise ProcessError("Manager has shut down")
+ else:
+ raise ProcessError(
+ "Unknown state {!r}".format(self._state.value))
+ return self
+
+ def __exit__(self, exc_type, exc_val, exc_tb):
+ self.shutdown()
+
+ @staticmethod
+ def _finalize_manager(process, address, authkey, state, _Client,
+ shutdown_timeout):
+ '''
+ Shutdown the manager process; will be registered as a finalizer
+ '''
+ if process.is_alive():
+ util.info('sending shutdown message to manager')
+ try:
+ conn = _Client(address, authkey=authkey)
+ try:
+ dispatch(conn, None, 'shutdown')
+ finally:
+ conn.close()
+ except Exception:
+ pass
+
+ process.join(timeout=shutdown_timeout)
+ if process.is_alive():
+ util.info('manager still alive')
+ if hasattr(process, 'terminate'):
+ util.info('trying to `terminate()` manager process')
+ process.terminate()
+ process.join(timeout=shutdown_timeout)
+ if process.is_alive():
+ util.info('manager still alive after terminate')
+ process.kill()
+ process.join()
+
+ state.value = State.SHUTDOWN
+ try:
+ del BaseProxy._address_to_local[address]
+ except KeyError:
+ pass
+
+ @property
+ def address(self):
+ return self._address
+
+ @classmethod
+ def register(cls, typeid, callable=None, proxytype=None, exposed=None,
+ method_to_typeid=None, create_method=True):
+ '''
+ Register a typeid with the manager type
+ '''
+ if '_registry' not in cls.__dict__:
+ cls._registry = cls._registry.copy()
+
+ if proxytype is None:
+ proxytype = AutoProxy
+
+ exposed = exposed or getattr(proxytype, '_exposed_', None)
+
+ method_to_typeid = method_to_typeid or \
+ getattr(proxytype, '_method_to_typeid_', None)
+
+ if method_to_typeid:
+ for key, value in list(method_to_typeid.items()): # isinstance?
+ assert type(key) is str, '%r is not a string' % key
+ assert type(value) is str, '%r is not a string' % value
+
+ cls._registry[typeid] = (
+ callable, exposed, method_to_typeid, proxytype
+ )
+
+ if create_method:
+ def temp(self, /, *args, **kwds):
+ util.debug('requesting creation of a shared %r object', typeid)
+ token, exp = self._create(typeid, *args, **kwds)
+ proxy = proxytype(
+ token, self._serializer, manager=self,
+ authkey=self._authkey, exposed=exp
+ )
+ conn = self._Client(token.address, authkey=self._authkey)
+ dispatch(conn, None, 'decref', (token.id,))
+ return proxy
+ temp.__name__ = typeid
+ setattr(cls, typeid, temp)
+
+#
+# Subclass of set which get cleared after a fork
+#
+
+class ProcessLocalSet(set):
+ def __init__(self):
+ util.register_after_fork(self, lambda obj: obj.clear())
+ def __reduce__(self):
+ return type(self), ()
+
+#
+# Definition of BaseProxy
+#
+
+class BaseProxy(object):
+ '''
+ A base for proxies of shared objects
+ '''
+ _address_to_local = {}
+ _mutex = util.ForkAwareThreadLock()
+
+ def __init__(self, token, serializer, manager=None,
+ authkey=None, exposed=None, incref=True, manager_owned=False):
+ with BaseProxy._mutex:
+ tls_idset = BaseProxy._address_to_local.get(token.address, None)
+ if tls_idset is None:
+ tls_idset = util.ForkAwareLocal(), ProcessLocalSet()
+ BaseProxy._address_to_local[token.address] = tls_idset
+
+ # self._tls is used to record the connection used by this
+ # thread to communicate with the manager at token.address
+ self._tls = tls_idset[0]
+
+ # self._idset is used to record the identities of all shared
+ # objects for which the current process owns references and
+ # which are in the manager at token.address
+ self._idset = tls_idset[1]
+
+ self._token = token
+ self._id = self._token.id
+ self._manager = manager
+ self._serializer = serializer
+ self._Client = listener_client[serializer][1]
+
+ # Should be set to True only when a proxy object is being created
+ # on the manager server; primary use case: nested proxy objects.
+ # RebuildProxy detects when a proxy is being created on the manager
+ # and sets this value appropriately.
+ self._owned_by_manager = manager_owned
+
+ if authkey is not None:
+ self._authkey = process.AuthenticationString(authkey)
+ elif self._manager is not None:
+ self._authkey = self._manager._authkey
+ else:
+ self._authkey = process.current_process().authkey
+
+ if incref:
+ self._incref()
+
+ util.register_after_fork(self, BaseProxy._after_fork)
+
+ def _connect(self):
+ util.debug('making connection to manager')
+ name = process.current_process().name
+ if threading.current_thread().name != 'MainThread':
+ name += '|' + threading.current_thread().name
+ conn = self._Client(self._token.address, authkey=self._authkey)
+ dispatch(conn, None, 'accept_connection', (name,))
+ self._tls.connection = conn
+
+ def _callmethod(self, methodname, args=(), kwds={}):
+ '''
+ Try to call a method of the referent and return a copy of the result
+ '''
+ try:
+ conn = self._tls.connection
+ except AttributeError:
+ util.debug('thread %r does not own a connection',
+ threading.current_thread().name)
+ self._connect()
+ conn = self._tls.connection
+
+ conn.send((self._id, methodname, args, kwds))
+ kind, result = conn.recv()
+
+ if kind == '#RETURN':
+ return result
+ elif kind == '#PROXY':
+ exposed, token = result
+ proxytype = self._manager._registry[token.typeid][-1]
+ token.address = self._token.address
+ proxy = proxytype(
+ token, self._serializer, manager=self._manager,
+ authkey=self._authkey, exposed=exposed
+ )
+ conn = self._Client(token.address, authkey=self._authkey)
+ dispatch(conn, None, 'decref', (token.id,))
+ return proxy
+ raise convert_to_error(kind, result)
+
+ def _getvalue(self):
+ '''
+ Get a copy of the value of the referent
+ '''
+ return self._callmethod('#GETVALUE')
+
+ def _incref(self):
+ if self._owned_by_manager:
+ util.debug('owned_by_manager skipped INCREF of %r', self._token.id)
+ return
+
+ conn = self._Client(self._token.address, authkey=self._authkey)
+ dispatch(conn, None, 'incref', (self._id,))
+ util.debug('INCREF %r', self._token.id)
+
+ self._idset.add(self._id)
+
+ state = self._manager and self._manager._state
+
+ self._close = util.Finalize(
+ self, BaseProxy._decref,
+ args=(self._token, self._authkey, state,
+ self._tls, self._idset, self._Client),
+ exitpriority=10
+ )
+
+ @staticmethod
+ def _decref(token, authkey, state, tls, idset, _Client):
+ idset.discard(token.id)
+
+ # check whether manager is still alive
+ if state is None or state.value == State.STARTED:
+ # tell manager this process no longer cares about referent
+ try:
+ util.debug('DECREF %r', token.id)
+ conn = _Client(token.address, authkey=authkey)
+ dispatch(conn, None, 'decref', (token.id,))
+ except Exception as e:
+ util.debug('... decref failed %s', e)
+
+ else:
+ util.debug('DECREF %r -- manager already shutdown', token.id)
+
+ # check whether we can close this thread's connection because
+ # the process owns no more references to objects for this manager
+ if not idset and hasattr(tls, 'connection'):
+ util.debug('thread %r has no more proxies so closing conn',
+ threading.current_thread().name)
+ tls.connection.close()
+ del tls.connection
+
+ def _after_fork(self):
+ self._manager = None
+ try:
+ self._incref()
+ except Exception as e:
+ # the proxy may just be for a manager which has shutdown
+ util.info('incref failed: %s' % e)
+
+ def __reduce__(self):
+ kwds = {}
+ if get_spawning_popen() is not None:
+ kwds['authkey'] = self._authkey
+
+ if getattr(self, '_isauto', False):
+ kwds['exposed'] = self._exposed_
+ return (RebuildProxy,
+ (AutoProxy, self._token, self._serializer, kwds))
+ else:
+ return (RebuildProxy,
+ (type(self), self._token, self._serializer, kwds))
+
+ def __deepcopy__(self, memo):
+ return self._getvalue()
+
+ def __repr__(self):
+ return '<%s object, typeid %r at %#x>' % \
+ (type(self).__name__, self._token.typeid, id(self))
+
+ def __str__(self):
+ '''
+ Return representation of the referent (or a fall-back if that fails)
+ '''
+ try:
+ return self._callmethod('__repr__')
+ except Exception:
+ return repr(self)[:-1] + "; '__str__()' failed>"
+
+#
+# Function used for unpickling
+#
+
+def RebuildProxy(func, token, serializer, kwds):
+ '''
+ Function used for unpickling proxy objects.
+ '''
+ server = getattr(process.current_process(), '_manager_server', None)
+ if server and server.address == token.address:
+ util.debug('Rebuild a proxy owned by manager, token=%r', token)
+ kwds['manager_owned'] = True
+ if token.id not in server.id_to_local_proxy_obj:
+ server.id_to_local_proxy_obj[token.id] = \
+ server.id_to_obj[token.id]
+ incref = (
+ kwds.pop('incref', True) and
+ not getattr(process.current_process(), '_inheriting', False)
+ )
+ return func(token, serializer, incref=incref, **kwds)
+
+#
+# Functions to create proxies and proxy types
+#
+
+def MakeProxyType(name, exposed, _cache={}):
+ '''
+ Return a proxy type whose methods are given by `exposed`
+ '''
+ exposed = tuple(exposed)
+ try:
+ return _cache[(name, exposed)]
+ except KeyError:
+ pass
+
+ dic = {}
+
+ for meth in exposed:
+ exec('''def %s(self, /, *args, **kwds):
+ return self._callmethod(%r, args, kwds)''' % (meth, meth), dic)
+
+ ProxyType = type(name, (BaseProxy,), dic)
+ ProxyType._exposed_ = exposed
+ _cache[(name, exposed)] = ProxyType
+ return ProxyType
+
+
+def AutoProxy(token, serializer, manager=None, authkey=None,
+ exposed=None, incref=True, manager_owned=False):
+ '''
+ Return an auto-proxy for `token`
+ '''
+ _Client = listener_client[serializer][1]
+
+ if exposed is None:
+ conn = _Client(token.address, authkey=authkey)
+ try:
+ exposed = dispatch(conn, None, 'get_methods', (token,))
+ finally:
+ conn.close()
+
+ if authkey is None and manager is not None:
+ authkey = manager._authkey
+ if authkey is None:
+ authkey = process.current_process().authkey
+
+ ProxyType = MakeProxyType('AutoProxy[%s]' % token.typeid, exposed)
+ proxy = ProxyType(token, serializer, manager=manager, authkey=authkey,
+ incref=incref, manager_owned=manager_owned)
+ proxy._isauto = True
+ return proxy
+
+#
+# Types/callables which we will register with SyncManager
+#
+
+class Namespace(object):
+ def __init__(self, /, **kwds):
+ self.__dict__.update(kwds)
+ def __repr__(self):
+ items = list(self.__dict__.items())
+ temp = []
+ for name, value in items:
+ if not name.startswith('_'):
+ temp.append('%s=%r' % (name, value))
+ temp.sort()
+ return '%s(%s)' % (self.__class__.__name__, ', '.join(temp))
+
+class Value(object):
+ def __init__(self, typecode, value, lock=True):
+ self._typecode = typecode
+ self._value = value
+ def get(self):
+ return self._value
+ def set(self, value):
+ self._value = value
+ def __repr__(self):
+ return '%s(%r, %r)'%(type(self).__name__, self._typecode, self._value)
+ value = property(get, set)
+
+def Array(typecode, sequence, lock=True):
+ return array.array(typecode, sequence)
+
+#
+# Proxy types used by SyncManager
+#
+
+class IteratorProxy(BaseProxy):
+ _exposed_ = ('__next__', 'send', 'throw', 'close')
+ def __iter__(self):
+ return self
+ def __next__(self, *args):
+ return self._callmethod('__next__', args)
+ def send(self, *args):
+ return self._callmethod('send', args)
+ def throw(self, *args):
+ return self._callmethod('throw', args)
+ def close(self, *args):
+ return self._callmethod('close', args)
+
+
+class AcquirerProxy(BaseProxy):
+ _exposed_ = ('acquire', 'release')
+ def acquire(self, blocking=True, timeout=None):
+ args = (blocking,) if timeout is None else (blocking, timeout)
+ return self._callmethod('acquire', args)
+ def release(self):
+ return self._callmethod('release')
+ def __enter__(self):
+ return self._callmethod('acquire')
+ def __exit__(self, exc_type, exc_val, exc_tb):
+ return self._callmethod('release')
+
+
+class ConditionProxy(AcquirerProxy):
+ _exposed_ = ('acquire', 'release', 'wait', 'notify', 'notify_all')
+ def wait(self, timeout=None):
+ return self._callmethod('wait', (timeout,))
+ def notify(self, n=1):
+ return self._callmethod('notify', (n,))
+ def notify_all(self):
+ return self._callmethod('notify_all')
+ def wait_for(self, predicate, timeout=None):
+ result = predicate()
+ if result:
+ return result
+ if timeout is not None:
+ endtime = getattr(time,'monotonic',time.time)() + timeout
+ else:
+ endtime = None
+ waittime = None
+ while not result:
+ if endtime is not None:
+ waittime = endtime - getattr(time,'monotonic',time.time)()
+ if waittime <= 0:
+ break
+ self.wait(waittime)
+ result = predicate()
+ return result
+
+
+class EventProxy(BaseProxy):
+ _exposed_ = ('is_set', 'set', 'clear', 'wait')
+ def is_set(self):
+ return self._callmethod('is_set')
+ def set(self):
+ return self._callmethod('set')
+ def clear(self):
+ return self._callmethod('clear')
+ def wait(self, timeout=None):
+ return self._callmethod('wait', (timeout,))
+
+
+class BarrierProxy(BaseProxy):
+ _exposed_ = ('__getattribute__', 'wait', 'abort', 'reset')
+ def wait(self, timeout=None):
+ return self._callmethod('wait', (timeout,))
+ def abort(self):
+ return self._callmethod('abort')
+ def reset(self):
+ return self._callmethod('reset')
+ @property
+ def parties(self):
+ return self._callmethod('__getattribute__', ('parties',))
+ @property
+ def n_waiting(self):
+ return self._callmethod('__getattribute__', ('n_waiting',))
+ @property
+ def broken(self):
+ return self._callmethod('__getattribute__', ('broken',))
+
+
+class NamespaceProxy(BaseProxy):
+ _exposed_ = ('__getattribute__', '__setattr__', '__delattr__')
+ def __getattr__(self, key):
+ if key[0] == '_':
+ return object.__getattribute__(self, key)
+ callmethod = object.__getattribute__(self, '_callmethod')
+ return callmethod('__getattribute__', (key,))
+ def __setattr__(self, key, value):
+ if key[0] == '_':
+ return object.__setattr__(self, key, value)
+ callmethod = object.__getattribute__(self, '_callmethod')
+ return callmethod('__setattr__', (key, value))
+ def __delattr__(self, key):
+ if key[0] == '_':
+ return object.__delattr__(self, key)
+ callmethod = object.__getattribute__(self, '_callmethod')
+ return callmethod('__delattr__', (key,))
+
+
+class ValueProxy(BaseProxy):
+ _exposed_ = ('get', 'set')
+ def get(self):
+ return self._callmethod('get')
+ def set(self, value):
+ return self._callmethod('set', (value,))
+ value = property(get, set)
+
+ __class_getitem__ = classmethod(types.GenericAlias)
+
+
+BaseListProxy = MakeProxyType('BaseListProxy', (
+ '__add__', '__contains__', '__delitem__', '__getitem__', '__len__',
+ '__mul__', '__reversed__', '__rmul__', '__setitem__',
+ 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove',
+ 'reverse', 'sort', '__imul__'
+ ))
+class ListProxy(BaseListProxy):
+ def __iadd__(self, value):
+ self._callmethod('extend', (value,))
+ return self
+ def __imul__(self, value):
+ self._callmethod('__imul__', (value,))
+ return self
+
+
+DictProxy = MakeProxyType('DictProxy', (
+ '__contains__', '__delitem__', '__getitem__', '__iter__', '__len__',
+ '__setitem__', 'clear', 'copy', 'get', 'items',
+ 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values'
+ ))
+DictProxy._method_to_typeid_ = {
+ '__iter__': 'Iterator',
+ }
+
+
+ArrayProxy = MakeProxyType('ArrayProxy', (
+ '__len__', '__getitem__', '__setitem__'
+ ))
+
+
+BasePoolProxy = MakeProxyType('PoolProxy', (
+ 'apply', 'apply_async', 'close', 'imap', 'imap_unordered', 'join',
+ 'map', 'map_async', 'starmap', 'starmap_async', 'terminate',
+ ))
+BasePoolProxy._method_to_typeid_ = {
+ 'apply_async': 'AsyncResult',
+ 'map_async': 'AsyncResult',
+ 'starmap_async': 'AsyncResult',
+ 'imap': 'Iterator',
+ 'imap_unordered': 'Iterator'
+ }
+class PoolProxy(BasePoolProxy):
+ def __enter__(self):
+ return self
+ def __exit__(self, exc_type, exc_val, exc_tb):
+ self.terminate()
+
+#
+# Definition of SyncManager
+#
+
+class SyncManager(BaseManager):
+ '''
+ Subclass of `BaseManager` which supports a number of shared object types.
+
+ The types registered are those intended for the synchronization
+ of threads, plus `dict`, `list` and `Namespace`.
+
+ The `multiprocess.Manager()` function creates started instances of
+ this class.
+ '''
+
+SyncManager.register('Queue', queue.Queue)
+SyncManager.register('JoinableQueue', queue.Queue)
+SyncManager.register('Event', threading.Event, EventProxy)
+SyncManager.register('Lock', threading.Lock, AcquirerProxy)
+SyncManager.register('RLock', threading.RLock, AcquirerProxy)
+SyncManager.register('Semaphore', threading.Semaphore, AcquirerProxy)
+SyncManager.register('BoundedSemaphore', threading.BoundedSemaphore,
+ AcquirerProxy)
+SyncManager.register('Condition', threading.Condition, ConditionProxy)
+SyncManager.register('Barrier', threading.Barrier, BarrierProxy)
+SyncManager.register('Pool', pool.Pool, PoolProxy)
+SyncManager.register('list', list, ListProxy)
+SyncManager.register('dict', dict, DictProxy)
+SyncManager.register('Value', Value, ValueProxy)
+SyncManager.register('Array', Array, ArrayProxy)
+SyncManager.register('Namespace', Namespace, NamespaceProxy)
+
+# types returned by methods of PoolProxy
+SyncManager.register('Iterator', proxytype=IteratorProxy, create_method=False)
+SyncManager.register('AsyncResult', create_method=False)
+
+#
+# Definition of SharedMemoryManager and SharedMemoryServer
+#
+
+if HAS_SHMEM:
+ class _SharedMemoryTracker:
+ "Manages one or more shared memory segments."
+
+ def __init__(self, name, segment_names=[]):
+ self.shared_memory_context_name = name
+ self.segment_names = segment_names
+
+ def register_segment(self, segment_name):
+ "Adds the supplied shared memory block name to tracker."
+ util.debug(f"Register segment {segment_name!r} in pid {getpid()}")
+ self.segment_names.append(segment_name)
+
+ def destroy_segment(self, segment_name):
+ """Calls unlink() on the shared memory block with the supplied name
+ and removes it from the list of blocks being tracked."""
+ util.debug(f"Destroy segment {segment_name!r} in pid {getpid()}")
+ self.segment_names.remove(segment_name)
+ segment = shared_memory.SharedMemory(segment_name)
+ segment.close()
+ segment.unlink()
+
+ def unlink(self):
+ "Calls destroy_segment() on all tracked shared memory blocks."
+ for segment_name in self.segment_names[:]:
+ self.destroy_segment(segment_name)
+
+ def __del__(self):
+ util.debug(f"Call {self.__class__.__name__}.__del__ in {getpid()}")
+ self.unlink()
+
+ def __getstate__(self):
+ return (self.shared_memory_context_name, self.segment_names)
+
+ def __setstate__(self, state):
+ self.__init__(*state)
+
+
+ class SharedMemoryServer(Server):
+
+ public = Server.public + \
+ ['track_segment', 'release_segment', 'list_segments']
+
+ def __init__(self, *args, **kwargs):
+ Server.__init__(self, *args, **kwargs)
+ address = self.address
+ # The address of Linux abstract namespaces can be bytes
+ if isinstance(address, bytes):
+ address = os.fsdecode(address)
+ self.shared_memory_context = \
+ _SharedMemoryTracker(f"shm_{address}_{getpid()}")
+ util.debug(f"SharedMemoryServer started by pid {getpid()}")
+
+ def create(self, c, typeid, /, *args, **kwargs):
+ """Create a new distributed-shared object (not backed by a shared
+ memory block) and return its id to be used in a Proxy Object."""
+ # Unless set up as a shared proxy, don't make shared_memory_context
+ # a standard part of kwargs. This makes things easier for supplying
+ # simple functions.
+ if hasattr(self.registry[typeid][-1], "_shared_memory_proxy"):
+ kwargs['shared_memory_context'] = self.shared_memory_context
+ return Server.create(self, c, typeid, *args, **kwargs)
+
+ def shutdown(self, c):
+ "Call unlink() on all tracked shared memory, terminate the Server."
+ self.shared_memory_context.unlink()
+ return Server.shutdown(self, c)
+
+ def track_segment(self, c, segment_name):
+ "Adds the supplied shared memory block name to Server's tracker."
+ self.shared_memory_context.register_segment(segment_name)
+
+ def release_segment(self, c, segment_name):
+ """Calls unlink() on the shared memory block with the supplied name
+ and removes it from the tracker instance inside the Server."""
+ self.shared_memory_context.destroy_segment(segment_name)
+
+ def list_segments(self, c):
+ """Returns a list of names of shared memory blocks that the Server
+ is currently tracking."""
+ return self.shared_memory_context.segment_names
+
+
+ class SharedMemoryManager(BaseManager):
+ """Like SyncManager but uses SharedMemoryServer instead of Server.
+
+ It provides methods for creating and returning SharedMemory instances
+ and for creating a list-like object (ShareableList) backed by shared
+ memory. It also provides methods that create and return Proxy Objects
+ that support synchronization across processes (i.e. multi-process-safe
+ locks and semaphores).
+ """
+
+ _Server = SharedMemoryServer
+
+ def __init__(self, *args, **kwargs):
+ if os.name == "posix":
+ # bpo-36867: Ensure the resource_tracker is running before
+ # launching the manager process, so that concurrent
+ # shared_memory manipulation both in the manager and in the
+ # current process does not create two resource_tracker
+ # processes.
+ from . import resource_tracker
+ resource_tracker.ensure_running()
+ BaseManager.__init__(self, *args, **kwargs)
+ util.debug(f"{self.__class__.__name__} created by pid {getpid()}")
+
+ def __del__(self):
+ util.debug(f"{self.__class__.__name__}.__del__ by pid {getpid()}")
+
+ def get_server(self):
+ 'Better than monkeypatching for now; merge into Server ultimately'
+ if self._state.value != State.INITIAL:
+ if self._state.value == State.STARTED:
+ raise ProcessError("Already started SharedMemoryServer")
+ elif self._state.value == State.SHUTDOWN:
+ raise ProcessError("SharedMemoryManager has shut down")
+ else:
+ raise ProcessError(
+ "Unknown state {!r}".format(self._state.value))
+ return self._Server(self._registry, self._address,
+ self._authkey, self._serializer)
+
+ def SharedMemory(self, size):
+ """Returns a new SharedMemory instance with the specified size in
+ bytes, to be tracked by the manager."""
+ with self._Client(self._address, authkey=self._authkey) as conn:
+ sms = shared_memory.SharedMemory(None, create=True, size=size)
+ try:
+ dispatch(conn, None, 'track_segment', (sms.name,))
+ except BaseException as e:
+ sms.unlink()
+ raise e
+ return sms
+
+ def ShareableList(self, sequence):
+ """Returns a new ShareableList instance populated with the values
+ from the input sequence, to be tracked by the manager."""
+ with self._Client(self._address, authkey=self._authkey) as conn:
+ sl = shared_memory.ShareableList(sequence)
+ try:
+ dispatch(conn, None, 'track_segment', (sl.shm.name,))
+ except BaseException as e:
+ sl.shm.unlink()
+ raise e
+ return sl
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/pool.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/pool.py
new file mode 100644
index 0000000000000000000000000000000000000000..4f5d88cb975cb75aa538db4d526b7e7f88e040f5
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/pool.py
@@ -0,0 +1,957 @@
+#
+# Module providing the `Pool` class for managing a process pool
+#
+# multiprocessing/pool.py
+#
+# Copyright (c) 2006-2008, R Oudkerk
+# Licensed to PSF under a Contributor Agreement.
+#
+
+__all__ = ['Pool', 'ThreadPool']
+
+#
+# Imports
+#
+
+import collections
+import itertools
+import os
+import queue
+import threading
+import time
+import traceback
+import types
+import warnings
+
+# If threading is available then ThreadPool should be provided. Therefore
+# we avoid top-level imports which are liable to fail on some systems.
+from . import util
+from . import get_context, TimeoutError
+from .connection import wait
+
+#
+# Constants representing the state of a pool
+#
+
+INIT = "INIT"
+RUN = "RUN"
+CLOSE = "CLOSE"
+TERMINATE = "TERMINATE"
+
+#
+# Miscellaneous
+#
+
+job_counter = itertools.count()
+
+def mapstar(args):
+ return list(map(*args))
+
+def starmapstar(args):
+ return list(itertools.starmap(args[0], args[1]))
+
+#
+# Hack to embed stringification of remote traceback in local traceback
+#
+
+class RemoteTraceback(Exception):
+ def __init__(self, tb):
+ self.tb = tb
+ def __str__(self):
+ return self.tb
+
+class ExceptionWithTraceback:
+ def __init__(self, exc, tb):
+ tb = traceback.format_exception(type(exc), exc, tb)
+ tb = ''.join(tb)
+ self.exc = exc
+ self.tb = '\n"""\n%s"""' % tb
+ def __reduce__(self):
+ return rebuild_exc, (self.exc, self.tb)
+
+def rebuild_exc(exc, tb):
+ exc.__cause__ = RemoteTraceback(tb)
+ return exc
+
+#
+# Code run by worker processes
+#
+
+class MaybeEncodingError(Exception):
+ """Wraps possible unpickleable errors, so they can be
+ safely sent through the socket."""
+
+ def __init__(self, exc, value):
+ self.exc = repr(exc)
+ self.value = repr(value)
+ super(MaybeEncodingError, self).__init__(self.exc, self.value)
+
+ def __str__(self):
+ return "Error sending result: '%s'. Reason: '%s'" % (self.value,
+ self.exc)
+
+ def __repr__(self):
+ return "<%s: %s>" % (self.__class__.__name__, self)
+
+
+def worker(inqueue, outqueue, initializer=None, initargs=(), maxtasks=None,
+ wrap_exception=False):
+ if (maxtasks is not None) and not (isinstance(maxtasks, int)
+ and maxtasks >= 1):
+ raise AssertionError("Maxtasks {!r} is not valid".format(maxtasks))
+ put = outqueue.put
+ get = inqueue.get
+ if hasattr(inqueue, '_writer'):
+ inqueue._writer.close()
+ outqueue._reader.close()
+
+ if initializer is not None:
+ initializer(*initargs)
+
+ completed = 0
+ while maxtasks is None or (maxtasks and completed < maxtasks):
+ try:
+ task = get()
+ except (EOFError, OSError):
+ util.debug('worker got EOFError or OSError -- exiting')
+ break
+
+ if task is None:
+ util.debug('worker got sentinel -- exiting')
+ break
+
+ job, i, func, args, kwds = task
+ try:
+ result = (True, func(*args, **kwds))
+ except Exception as e:
+ if wrap_exception and func is not _helper_reraises_exception:
+ e = ExceptionWithTraceback(e, e.__traceback__)
+ result = (False, e)
+ try:
+ put((job, i, result))
+ except Exception as e:
+ wrapped = MaybeEncodingError(e, result[1])
+ util.debug("Possible encoding error while sending result: %s" % (
+ wrapped))
+ put((job, i, (False, wrapped)))
+
+ task = job = result = func = args = kwds = None
+ completed += 1
+ util.debug('worker exiting after %d tasks' % completed)
+
+def _helper_reraises_exception(ex):
+ 'Pickle-able helper function for use by _guarded_task_generation.'
+ raise ex
+
+#
+# Class representing a process pool
+#
+
+class _PoolCache(dict):
+ """
+ Class that implements a cache for the Pool class that will notify
+ the pool management threads every time the cache is emptied. The
+ notification is done by the use of a queue that is provided when
+ instantiating the cache.
+ """
+ def __init__(self, /, *args, notifier=None, **kwds):
+ self.notifier = notifier
+ super().__init__(*args, **kwds)
+
+ def __delitem__(self, item):
+ super().__delitem__(item)
+
+ # Notify that the cache is empty. This is important because the
+ # pool keeps maintaining workers until the cache gets drained. This
+ # eliminates a race condition in which a task is finished after the
+ # the pool's _handle_workers method has enter another iteration of the
+ # loop. In this situation, the only event that can wake up the pool
+ # is the cache to be emptied (no more tasks available).
+ if not self:
+ self.notifier.put(None)
+
+class Pool(object):
+ '''
+ Class which supports an async version of applying functions to arguments.
+ '''
+ _wrap_exception = True
+
+ @staticmethod
+ def Process(ctx, *args, **kwds):
+ return ctx.Process(*args, **kwds)
+
+ def __init__(self, processes=None, initializer=None, initargs=(),
+ maxtasksperchild=None, context=None):
+ # Attributes initialized early to make sure that they exist in
+ # __del__() if __init__() raises an exception
+ self._pool = []
+ self._state = INIT
+
+ self._ctx = context or get_context()
+ self._setup_queues()
+ self._taskqueue = queue.SimpleQueue()
+ # The _change_notifier queue exist to wake up self._handle_workers()
+ # when the cache (self._cache) is empty or when there is a change in
+ # the _state variable of the thread that runs _handle_workers.
+ self._change_notifier = self._ctx.SimpleQueue()
+ self._cache = _PoolCache(notifier=self._change_notifier)
+ self._maxtasksperchild = maxtasksperchild
+ self._initializer = initializer
+ self._initargs = initargs
+
+ if processes is None:
+ processes = os.cpu_count() or 1
+ if processes < 1:
+ raise ValueError("Number of processes must be at least 1")
+ if maxtasksperchild is not None:
+ if not isinstance(maxtasksperchild, int) or maxtasksperchild <= 0:
+ raise ValueError("maxtasksperchild must be a positive int or None")
+
+ if initializer is not None and not callable(initializer):
+ raise TypeError('initializer must be a callable')
+
+ self._processes = processes
+ try:
+ self._repopulate_pool()
+ except Exception:
+ for p in self._pool:
+ if p.exitcode is None:
+ p.terminate()
+ for p in self._pool:
+ p.join()
+ raise
+
+ sentinels = self._get_sentinels()
+
+ self._worker_handler = threading.Thread(
+ target=Pool._handle_workers,
+ args=(self._cache, self._taskqueue, self._ctx, self.Process,
+ self._processes, self._pool, self._inqueue, self._outqueue,
+ self._initializer, self._initargs, self._maxtasksperchild,
+ self._wrap_exception, sentinels, self._change_notifier)
+ )
+ self._worker_handler.daemon = True
+ self._worker_handler._state = RUN
+ self._worker_handler.start()
+
+
+ self._task_handler = threading.Thread(
+ target=Pool._handle_tasks,
+ args=(self._taskqueue, self._quick_put, self._outqueue,
+ self._pool, self._cache)
+ )
+ self._task_handler.daemon = True
+ self._task_handler._state = RUN
+ self._task_handler.start()
+
+ self._result_handler = threading.Thread(
+ target=Pool._handle_results,
+ args=(self._outqueue, self._quick_get, self._cache)
+ )
+ self._result_handler.daemon = True
+ self._result_handler._state = RUN
+ self._result_handler.start()
+
+ self._terminate = util.Finalize(
+ self, self._terminate_pool,
+ args=(self._taskqueue, self._inqueue, self._outqueue, self._pool,
+ self._change_notifier, self._worker_handler, self._task_handler,
+ self._result_handler, self._cache),
+ exitpriority=15
+ )
+ self._state = RUN
+
+ # Copy globals as function locals to make sure that they are available
+ # during Python shutdown when the Pool is destroyed.
+ def __del__(self, _warn=warnings.warn, RUN=RUN):
+ if self._state == RUN:
+ _warn(f"unclosed running multiprocessing pool {self!r}",
+ ResourceWarning, source=self)
+ if getattr(self, '_change_notifier', None) is not None:
+ self._change_notifier.put(None)
+
+ def __repr__(self):
+ cls = self.__class__
+ return (f'<{cls.__module__}.{cls.__qualname__} '
+ f'state={self._state} '
+ f'pool_size={len(self._pool)}>')
+
+ def _get_sentinels(self):
+ task_queue_sentinels = [self._outqueue._reader]
+ self_notifier_sentinels = [self._change_notifier._reader]
+ return [*task_queue_sentinels, *self_notifier_sentinels]
+
+ @staticmethod
+ def _get_worker_sentinels(workers):
+ return [worker.sentinel for worker in
+ workers if hasattr(worker, "sentinel")]
+
+ @staticmethod
+ def _join_exited_workers(pool):
+ """Cleanup after any worker processes which have exited due to reaching
+ their specified lifetime. Returns True if any workers were cleaned up.
+ """
+ cleaned = False
+ for i in reversed(range(len(pool))):
+ worker = pool[i]
+ if worker.exitcode is not None:
+ # worker exited
+ util.debug('cleaning up worker %d' % i)
+ worker.join()
+ cleaned = True
+ del pool[i]
+ return cleaned
+
+ def _repopulate_pool(self):
+ return self._repopulate_pool_static(self._ctx, self.Process,
+ self._processes,
+ self._pool, self._inqueue,
+ self._outqueue, self._initializer,
+ self._initargs,
+ self._maxtasksperchild,
+ self._wrap_exception)
+
+ @staticmethod
+ def _repopulate_pool_static(ctx, Process, processes, pool, inqueue,
+ outqueue, initializer, initargs,
+ maxtasksperchild, wrap_exception):
+ """Bring the number of pool processes up to the specified number,
+ for use after reaping workers which have exited.
+ """
+ for i in range(processes - len(pool)):
+ w = Process(ctx, target=worker,
+ args=(inqueue, outqueue,
+ initializer,
+ initargs, maxtasksperchild,
+ wrap_exception))
+ w.name = w.name.replace('Process', 'PoolWorker')
+ w.daemon = True
+ w.start()
+ pool.append(w)
+ util.debug('added worker')
+
+ @staticmethod
+ def _maintain_pool(ctx, Process, processes, pool, inqueue, outqueue,
+ initializer, initargs, maxtasksperchild,
+ wrap_exception):
+ """Clean up any exited workers and start replacements for them.
+ """
+ if Pool._join_exited_workers(pool):
+ Pool._repopulate_pool_static(ctx, Process, processes, pool,
+ inqueue, outqueue, initializer,
+ initargs, maxtasksperchild,
+ wrap_exception)
+
+ def _setup_queues(self):
+ self._inqueue = self._ctx.SimpleQueue()
+ self._outqueue = self._ctx.SimpleQueue()
+ self._quick_put = self._inqueue._writer.send
+ self._quick_get = self._outqueue._reader.recv
+
+ def _check_running(self):
+ if self._state != RUN:
+ raise ValueError("Pool not running")
+
+ def apply(self, func, args=(), kwds={}):
+ '''
+ Equivalent of `func(*args, **kwds)`.
+ Pool must be running.
+ '''
+ return self.apply_async(func, args, kwds).get()
+
+ def map(self, func, iterable, chunksize=None):
+ '''
+ Apply `func` to each element in `iterable`, collecting the results
+ in a list that is returned.
+ '''
+ return self._map_async(func, iterable, mapstar, chunksize).get()
+
+ def starmap(self, func, iterable, chunksize=None):
+ '''
+ Like `map()` method but the elements of the `iterable` are expected to
+ be iterables as well and will be unpacked as arguments. Hence
+ `func` and (a, b) becomes func(a, b).
+ '''
+ return self._map_async(func, iterable, starmapstar, chunksize).get()
+
+ def starmap_async(self, func, iterable, chunksize=None, callback=None,
+ error_callback=None):
+ '''
+ Asynchronous version of `starmap()` method.
+ '''
+ return self._map_async(func, iterable, starmapstar, chunksize,
+ callback, error_callback)
+
+ def _guarded_task_generation(self, result_job, func, iterable):
+ '''Provides a generator of tasks for imap and imap_unordered with
+ appropriate handling for iterables which throw exceptions during
+ iteration.'''
+ try:
+ i = -1
+ for i, x in enumerate(iterable):
+ yield (result_job, i, func, (x,), {})
+ except Exception as e:
+ yield (result_job, i+1, _helper_reraises_exception, (e,), {})
+
+ def imap(self, func, iterable, chunksize=1):
+ '''
+ Equivalent of `map()` -- can be MUCH slower than `Pool.map()`.
+ '''
+ self._check_running()
+ if chunksize == 1:
+ result = IMapIterator(self)
+ self._taskqueue.put(
+ (
+ self._guarded_task_generation(result._job, func, iterable),
+ result._set_length
+ ))
+ return result
+ else:
+ if chunksize < 1:
+ raise ValueError(
+ "Chunksize must be 1+, not {0:n}".format(
+ chunksize))
+ task_batches = Pool._get_tasks(func, iterable, chunksize)
+ result = IMapIterator(self)
+ self._taskqueue.put(
+ (
+ self._guarded_task_generation(result._job,
+ mapstar,
+ task_batches),
+ result._set_length
+ ))
+ return (item for chunk in result for item in chunk)
+
+ def imap_unordered(self, func, iterable, chunksize=1):
+ '''
+ Like `imap()` method but ordering of results is arbitrary.
+ '''
+ self._check_running()
+ if chunksize == 1:
+ result = IMapUnorderedIterator(self)
+ self._taskqueue.put(
+ (
+ self._guarded_task_generation(result._job, func, iterable),
+ result._set_length
+ ))
+ return result
+ else:
+ if chunksize < 1:
+ raise ValueError(
+ "Chunksize must be 1+, not {0!r}".format(chunksize))
+ task_batches = Pool._get_tasks(func, iterable, chunksize)
+ result = IMapUnorderedIterator(self)
+ self._taskqueue.put(
+ (
+ self._guarded_task_generation(result._job,
+ mapstar,
+ task_batches),
+ result._set_length
+ ))
+ return (item for chunk in result for item in chunk)
+
+ def apply_async(self, func, args=(), kwds={}, callback=None,
+ error_callback=None):
+ '''
+ Asynchronous version of `apply()` method.
+ '''
+ self._check_running()
+ result = ApplyResult(self, callback, error_callback)
+ self._taskqueue.put(([(result._job, 0, func, args, kwds)], None))
+ return result
+
+ def map_async(self, func, iterable, chunksize=None, callback=None,
+ error_callback=None):
+ '''
+ Asynchronous version of `map()` method.
+ '''
+ return self._map_async(func, iterable, mapstar, chunksize, callback,
+ error_callback)
+
+ def _map_async(self, func, iterable, mapper, chunksize=None, callback=None,
+ error_callback=None):
+ '''
+ Helper function to implement map, starmap and their async counterparts.
+ '''
+ self._check_running()
+ if not hasattr(iterable, '__len__'):
+ iterable = list(iterable)
+
+ if chunksize is None:
+ chunksize, extra = divmod(len(iterable), len(self._pool) * 4)
+ if extra:
+ chunksize += 1
+ if len(iterable) == 0:
+ chunksize = 0
+
+ task_batches = Pool._get_tasks(func, iterable, chunksize)
+ result = MapResult(self, chunksize, len(iterable), callback,
+ error_callback=error_callback)
+ self._taskqueue.put(
+ (
+ self._guarded_task_generation(result._job,
+ mapper,
+ task_batches),
+ None
+ )
+ )
+ return result
+
+ @staticmethod
+ def _wait_for_updates(sentinels, change_notifier, timeout=None):
+ wait(sentinels, timeout=timeout)
+ while not change_notifier.empty():
+ change_notifier.get()
+
+ @classmethod
+ def _handle_workers(cls, cache, taskqueue, ctx, Process, processes,
+ pool, inqueue, outqueue, initializer, initargs,
+ maxtasksperchild, wrap_exception, sentinels,
+ change_notifier):
+ thread = threading.current_thread()
+
+ # Keep maintaining workers until the cache gets drained, unless the pool
+ # is terminated.
+ while thread._state == RUN or (cache and thread._state != TERMINATE):
+ cls._maintain_pool(ctx, Process, processes, pool, inqueue,
+ outqueue, initializer, initargs,
+ maxtasksperchild, wrap_exception)
+
+ current_sentinels = [*cls._get_worker_sentinels(pool), *sentinels]
+
+ cls._wait_for_updates(current_sentinels, change_notifier)
+ # send sentinel to stop workers
+ taskqueue.put(None)
+ util.debug('worker handler exiting')
+
+ @staticmethod
+ def _handle_tasks(taskqueue, put, outqueue, pool, cache):
+ thread = threading.current_thread()
+
+ for taskseq, set_length in iter(taskqueue.get, None):
+ task = None
+ try:
+ # iterating taskseq cannot fail
+ for task in taskseq:
+ if thread._state != RUN:
+ util.debug('task handler found thread._state != RUN')
+ break
+ try:
+ put(task)
+ except Exception as e:
+ job, idx = task[:2]
+ try:
+ cache[job]._set(idx, (False, e))
+ except KeyError:
+ pass
+ else:
+ if set_length:
+ util.debug('doing set_length()')
+ idx = task[1] if task else -1
+ set_length(idx + 1)
+ continue
+ break
+ finally:
+ task = taskseq = job = None
+ else:
+ util.debug('task handler got sentinel')
+
+ try:
+ # tell result handler to finish when cache is empty
+ util.debug('task handler sending sentinel to result handler')
+ outqueue.put(None)
+
+ # tell workers there is no more work
+ util.debug('task handler sending sentinel to workers')
+ for p in pool:
+ put(None)
+ except OSError:
+ util.debug('task handler got OSError when sending sentinels')
+
+ util.debug('task handler exiting')
+
+ @staticmethod
+ def _handle_results(outqueue, get, cache):
+ thread = threading.current_thread()
+
+ while 1:
+ try:
+ task = get()
+ except (OSError, EOFError):
+ util.debug('result handler got EOFError/OSError -- exiting')
+ return
+
+ if thread._state != RUN:
+ assert thread._state == TERMINATE, "Thread not in TERMINATE"
+ util.debug('result handler found thread._state=TERMINATE')
+ break
+
+ if task is None:
+ util.debug('result handler got sentinel')
+ break
+
+ job, i, obj = task
+ try:
+ cache[job]._set(i, obj)
+ except KeyError:
+ pass
+ task = job = obj = None
+
+ while cache and thread._state != TERMINATE:
+ try:
+ task = get()
+ except (OSError, EOFError):
+ util.debug('result handler got EOFError/OSError -- exiting')
+ return
+
+ if task is None:
+ util.debug('result handler ignoring extra sentinel')
+ continue
+ job, i, obj = task
+ try:
+ cache[job]._set(i, obj)
+ except KeyError:
+ pass
+ task = job = obj = None
+
+ if hasattr(outqueue, '_reader'):
+ util.debug('ensuring that outqueue is not full')
+ # If we don't make room available in outqueue then
+ # attempts to add the sentinel (None) to outqueue may
+ # block. There is guaranteed to be no more than 2 sentinels.
+ try:
+ for i in range(10):
+ if not outqueue._reader.poll():
+ break
+ get()
+ except (OSError, EOFError):
+ pass
+
+ util.debug('result handler exiting: len(cache)=%s, thread._state=%s',
+ len(cache), thread._state)
+
+ @staticmethod
+ def _get_tasks(func, it, size):
+ it = iter(it)
+ while 1:
+ x = tuple(itertools.islice(it, size))
+ if not x:
+ return
+ yield (func, x)
+
+ def __reduce__(self):
+ raise NotImplementedError(
+ 'pool objects cannot be passed between processes or pickled'
+ )
+
+ def close(self):
+ util.debug('closing pool')
+ if self._state == RUN:
+ self._state = CLOSE
+ self._worker_handler._state = CLOSE
+ self._change_notifier.put(None)
+
+ def terminate(self):
+ util.debug('terminating pool')
+ self._state = TERMINATE
+ self._terminate()
+
+ def join(self):
+ util.debug('joining pool')
+ if self._state == RUN:
+ raise ValueError("Pool is still running")
+ elif self._state not in (CLOSE, TERMINATE):
+ raise ValueError("In unknown state")
+ self._worker_handler.join()
+ self._task_handler.join()
+ self._result_handler.join()
+ for p in self._pool:
+ p.join()
+
+ @staticmethod
+ def _help_stuff_finish(inqueue, task_handler, size):
+ # task_handler may be blocked trying to put items on inqueue
+ util.debug('removing tasks from inqueue until task handler finished')
+ inqueue._rlock.acquire()
+ while task_handler.is_alive() and inqueue._reader.poll():
+ inqueue._reader.recv()
+ time.sleep(0)
+
+ @classmethod
+ def _terminate_pool(cls, taskqueue, inqueue, outqueue, pool, change_notifier,
+ worker_handler, task_handler, result_handler, cache):
+ # this is guaranteed to only be called once
+ util.debug('finalizing pool')
+
+ # Notify that the worker_handler state has been changed so the
+ # _handle_workers loop can be unblocked (and exited) in order to
+ # send the finalization sentinel all the workers.
+ worker_handler._state = TERMINATE
+ change_notifier.put(None)
+
+ task_handler._state = TERMINATE
+
+ util.debug('helping task handler/workers to finish')
+ cls._help_stuff_finish(inqueue, task_handler, len(pool))
+
+ if (not result_handler.is_alive()) and (len(cache) != 0):
+ raise AssertionError(
+ "Cannot have cache with result_handler not alive")
+
+ result_handler._state = TERMINATE
+ change_notifier.put(None)
+ outqueue.put(None) # sentinel
+
+ # We must wait for the worker handler to exit before terminating
+ # workers because we don't want workers to be restarted behind our back.
+ util.debug('joining worker handler')
+ if threading.current_thread() is not worker_handler:
+ worker_handler.join()
+
+ # Terminate workers which haven't already finished.
+ if pool and hasattr(pool[0], 'terminate'):
+ util.debug('terminating workers')
+ for p in pool:
+ if p.exitcode is None:
+ p.terminate()
+
+ util.debug('joining task handler')
+ if threading.current_thread() is not task_handler:
+ task_handler.join()
+
+ util.debug('joining result handler')
+ if threading.current_thread() is not result_handler:
+ result_handler.join()
+
+ if pool and hasattr(pool[0], 'terminate'):
+ util.debug('joining pool workers')
+ for p in pool:
+ if p.is_alive():
+ # worker has not yet exited
+ util.debug('cleaning up worker %d' % p.pid)
+ p.join()
+
+ def __enter__(self):
+ self._check_running()
+ return self
+
+ def __exit__(self, exc_type, exc_val, exc_tb):
+ self.terminate()
+
+#
+# Class whose instances are returned by `Pool.apply_async()`
+#
+
+class ApplyResult(object):
+
+ def __init__(self, pool, callback, error_callback):
+ self._pool = pool
+ self._event = threading.Event()
+ self._job = next(job_counter)
+ self._cache = pool._cache
+ self._callback = callback
+ self._error_callback = error_callback
+ self._cache[self._job] = self
+
+ def ready(self):
+ return self._event.is_set()
+
+ def successful(self):
+ if not self.ready():
+ raise ValueError("{0!r} not ready".format(self))
+ return self._success
+
+ def wait(self, timeout=None):
+ self._event.wait(timeout)
+
+ def get(self, timeout=None):
+ self.wait(timeout)
+ if not self.ready():
+ raise TimeoutError
+ if self._success:
+ return self._value
+ else:
+ raise self._value
+
+ def _set(self, i, obj):
+ self._success, self._value = obj
+ if self._callback and self._success:
+ self._callback(self._value)
+ if self._error_callback and not self._success:
+ self._error_callback(self._value)
+ self._event.set()
+ del self._cache[self._job]
+ self._pool = None
+
+ __class_getitem__ = classmethod(types.GenericAlias)
+
+AsyncResult = ApplyResult # create alias -- see #17805
+
+#
+# Class whose instances are returned by `Pool.map_async()`
+#
+
+class MapResult(ApplyResult):
+
+ def __init__(self, pool, chunksize, length, callback, error_callback):
+ ApplyResult.__init__(self, pool, callback,
+ error_callback=error_callback)
+ self._success = True
+ self._value = [None] * length
+ self._chunksize = chunksize
+ if chunksize <= 0:
+ self._number_left = 0
+ self._event.set()
+ del self._cache[self._job]
+ else:
+ self._number_left = length//chunksize + bool(length % chunksize)
+
+ def _set(self, i, success_result):
+ self._number_left -= 1
+ success, result = success_result
+ if success and self._success:
+ self._value[i*self._chunksize:(i+1)*self._chunksize] = result
+ if self._number_left == 0:
+ if self._callback:
+ self._callback(self._value)
+ del self._cache[self._job]
+ self._event.set()
+ self._pool = None
+ else:
+ if not success and self._success:
+ # only store first exception
+ self._success = False
+ self._value = result
+ if self._number_left == 0:
+ # only consider the result ready once all jobs are done
+ if self._error_callback:
+ self._error_callback(self._value)
+ del self._cache[self._job]
+ self._event.set()
+ self._pool = None
+
+#
+# Class whose instances are returned by `Pool.imap()`
+#
+
+class IMapIterator(object):
+
+ def __init__(self, pool):
+ self._pool = pool
+ self._cond = threading.Condition(threading.Lock())
+ self._job = next(job_counter)
+ self._cache = pool._cache
+ self._items = collections.deque()
+ self._index = 0
+ self._length = None
+ self._unsorted = {}
+ self._cache[self._job] = self
+
+ def __iter__(self):
+ return self
+
+ def next(self, timeout=None):
+ with self._cond:
+ try:
+ item = self._items.popleft()
+ except IndexError:
+ if self._index == self._length:
+ self._pool = None
+ raise StopIteration from None
+ self._cond.wait(timeout)
+ try:
+ item = self._items.popleft()
+ except IndexError:
+ if self._index == self._length:
+ self._pool = None
+ raise StopIteration from None
+ raise TimeoutError from None
+
+ success, value = item
+ if success:
+ return value
+ raise value
+
+ __next__ = next # XXX
+
+ def _set(self, i, obj):
+ with self._cond:
+ if self._index == i:
+ self._items.append(obj)
+ self._index += 1
+ while self._index in self._unsorted:
+ obj = self._unsorted.pop(self._index)
+ self._items.append(obj)
+ self._index += 1
+ self._cond.notify()
+ else:
+ self._unsorted[i] = obj
+
+ if self._index == self._length:
+ del self._cache[self._job]
+ self._pool = None
+
+ def _set_length(self, length):
+ with self._cond:
+ self._length = length
+ if self._index == self._length:
+ self._cond.notify()
+ del self._cache[self._job]
+ self._pool = None
+
+#
+# Class whose instances are returned by `Pool.imap_unordered()`
+#
+
+class IMapUnorderedIterator(IMapIterator):
+
+ def _set(self, i, obj):
+ with self._cond:
+ self._items.append(obj)
+ self._index += 1
+ self._cond.notify()
+ if self._index == self._length:
+ del self._cache[self._job]
+ self._pool = None
+
+#
+#
+#
+
+class ThreadPool(Pool):
+ _wrap_exception = False
+
+ @staticmethod
+ def Process(ctx, *args, **kwds):
+ from .dummy import Process
+ return Process(*args, **kwds)
+
+ def __init__(self, processes=None, initializer=None, initargs=()):
+ Pool.__init__(self, processes, initializer, initargs)
+
+ def _setup_queues(self):
+ self._inqueue = queue.SimpleQueue()
+ self._outqueue = queue.SimpleQueue()
+ self._quick_put = self._inqueue.put
+ self._quick_get = self._outqueue.get
+
+ def _get_sentinels(self):
+ return [self._change_notifier._reader]
+
+ @staticmethod
+ def _get_worker_sentinels(workers):
+ return []
+
+ @staticmethod
+ def _help_stuff_finish(inqueue, task_handler, size):
+ # drain inqueue, and put sentinels at its head to make workers finish
+ try:
+ while True:
+ inqueue.get(block=False)
+ except queue.Empty:
+ pass
+ for i in range(size):
+ inqueue.put(None)
+
+ def _wait_for_updates(self, sentinels, change_notifier, timeout):
+ time.sleep(timeout)
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/popen_fork.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/popen_fork.py
new file mode 100644
index 0000000000000000000000000000000000000000..fa7c52d589fea22aad4b2ff4ba969db442a9ec1c
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/popen_fork.py
@@ -0,0 +1,83 @@
+import os
+import signal
+
+from . import util
+
+__all__ = ['Popen']
+
+#
+# Start child process using fork
+#
+
+class Popen(object):
+ method = 'fork'
+
+ def __init__(self, process_obj):
+ util._flush_std_streams()
+ self.returncode = None
+ self.finalizer = None
+ self._launch(process_obj)
+
+ def duplicate_for_child(self, fd):
+ return fd
+
+ def poll(self, flag=os.WNOHANG):
+ if self.returncode is None:
+ try:
+ pid, sts = os.waitpid(self.pid, flag)
+ except OSError:
+ # Child process not yet created. See #1731717
+ # e.errno == errno.ECHILD == 10
+ return None
+ if pid == self.pid:
+ self.returncode = os.waitstatus_to_exitcode(sts)
+ return self.returncode
+
+ def wait(self, timeout=None):
+ if self.returncode is None:
+ if timeout is not None:
+ from multiprocess.connection import wait
+ if not wait([self.sentinel], timeout):
+ return None
+ # This shouldn't block if wait() returned successfully.
+ return self.poll(os.WNOHANG if timeout == 0.0 else 0)
+ return self.returncode
+
+ def _send_signal(self, sig):
+ if self.returncode is None:
+ try:
+ os.kill(self.pid, sig)
+ except ProcessLookupError:
+ pass
+ except OSError:
+ if self.wait(timeout=0.1) is None:
+ raise
+
+ def terminate(self):
+ self._send_signal(signal.SIGTERM)
+
+ def kill(self):
+ self._send_signal(signal.SIGKILL)
+
+ def _launch(self, process_obj):
+ code = 1
+ parent_r, child_w = os.pipe()
+ child_r, parent_w = os.pipe()
+ self.pid = os.fork()
+ if self.pid == 0:
+ try:
+ os.close(parent_r)
+ os.close(parent_w)
+ code = process_obj._bootstrap(parent_sentinel=child_r)
+ finally:
+ os._exit(code)
+ else:
+ os.close(child_w)
+ os.close(child_r)
+ self.finalizer = util.Finalize(self, util.close_fds,
+ (parent_r, parent_w,))
+ self.sentinel = parent_r
+
+ def close(self):
+ if self.finalizer is not None:
+ self.finalizer()
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/popen_forkserver.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/popen_forkserver.py
new file mode 100644
index 0000000000000000000000000000000000000000..2cea1fc7a4602172b87df391fdc831c9d40ac49a
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/popen_forkserver.py
@@ -0,0 +1,74 @@
+import io
+import os
+
+from .context import reduction, set_spawning_popen
+if not reduction.HAVE_SEND_HANDLE:
+ raise ImportError('No support for sending fds between processes')
+from . import forkserver
+from . import popen_fork
+from . import spawn
+from . import util
+
+
+__all__ = ['Popen']
+
+#
+# Wrapper for an fd used while launching a process
+#
+
+class _DupFd(object):
+ def __init__(self, ind):
+ self.ind = ind
+ def detach(self):
+ return forkserver.get_inherited_fds()[self.ind]
+
+#
+# Start child process using a server process
+#
+
+class Popen(popen_fork.Popen):
+ method = 'forkserver'
+ DupFd = _DupFd
+
+ def __init__(self, process_obj):
+ self._fds = []
+ super().__init__(process_obj)
+
+ def duplicate_for_child(self, fd):
+ self._fds.append(fd)
+ return len(self._fds) - 1
+
+ def _launch(self, process_obj):
+ prep_data = spawn.get_preparation_data(process_obj._name)
+ buf = io.BytesIO()
+ set_spawning_popen(self)
+ try:
+ reduction.dump(prep_data, buf)
+ reduction.dump(process_obj, buf)
+ finally:
+ set_spawning_popen(None)
+
+ self.sentinel, w = forkserver.connect_to_new_process(self._fds)
+ # Keep a duplicate of the data pipe's write end as a sentinel of the
+ # parent process used by the child process.
+ _parent_w = os.dup(w)
+ self.finalizer = util.Finalize(self, util.close_fds,
+ (_parent_w, self.sentinel))
+ with open(w, 'wb', closefd=True) as f:
+ f.write(buf.getbuffer())
+ self.pid = forkserver.read_signed(self.sentinel)
+
+ def poll(self, flag=os.WNOHANG):
+ if self.returncode is None:
+ from multiprocess.connection import wait
+ timeout = 0 if flag == os.WNOHANG else None
+ if not wait([self.sentinel], timeout):
+ return None
+ try:
+ self.returncode = forkserver.read_signed(self.sentinel)
+ except (OSError, EOFError):
+ # This should not happen usually, but perhaps the forkserver
+ # process itself got killed
+ self.returncode = 255
+
+ return self.returncode
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/popen_spawn_posix.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/popen_spawn_posix.py
new file mode 100644
index 0000000000000000000000000000000000000000..24b8634523e5f2c29cd8bb21022c26d22a4fb13b
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/popen_spawn_posix.py
@@ -0,0 +1,72 @@
+import io
+import os
+
+from .context import reduction, set_spawning_popen
+from . import popen_fork
+from . import spawn
+from . import util
+
+__all__ = ['Popen']
+
+
+#
+# Wrapper for an fd used while launching a process
+#
+
+class _DupFd(object):
+ def __init__(self, fd):
+ self.fd = fd
+ def detach(self):
+ return self.fd
+
+#
+# Start child process using a fresh interpreter
+#
+
+class Popen(popen_fork.Popen):
+ method = 'spawn'
+ DupFd = _DupFd
+
+ def __init__(self, process_obj):
+ self._fds = []
+ super().__init__(process_obj)
+
+ def duplicate_for_child(self, fd):
+ self._fds.append(fd)
+ return fd
+
+ def _launch(self, process_obj):
+ from . import resource_tracker
+ tracker_fd = resource_tracker.getfd()
+ self._fds.append(tracker_fd)
+ prep_data = spawn.get_preparation_data(process_obj._name)
+ fp = io.BytesIO()
+ set_spawning_popen(self)
+ try:
+ reduction.dump(prep_data, fp)
+ reduction.dump(process_obj, fp)
+ finally:
+ set_spawning_popen(None)
+
+ parent_r = child_w = child_r = parent_w = None
+ try:
+ parent_r, child_w = os.pipe()
+ child_r, parent_w = os.pipe()
+ cmd = spawn.get_command_line(tracker_fd=tracker_fd,
+ pipe_handle=child_r)
+ self._fds.extend([child_r, child_w])
+ self.pid = util.spawnv_passfds(spawn.get_executable(),
+ cmd, self._fds)
+ self.sentinel = parent_r
+ with open(parent_w, 'wb', closefd=False) as f:
+ f.write(fp.getbuffer())
+ finally:
+ fds_to_close = []
+ for fd in (parent_r, parent_w):
+ if fd is not None:
+ fds_to_close.append(fd)
+ self.finalizer = util.Finalize(self, util.close_fds, fds_to_close)
+
+ for fd in (child_r, child_w):
+ if fd is not None:
+ os.close(fd)
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/popen_spawn_win32.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/popen_spawn_win32.py
new file mode 100644
index 0000000000000000000000000000000000000000..af044305709e56cf55e3df46c9ee1c2d31efddac
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/popen_spawn_win32.py
@@ -0,0 +1,139 @@
+import os
+import msvcrt
+import signal
+import sys
+import _winapi
+
+from .context import reduction, get_spawning_popen, set_spawning_popen
+from . import spawn
+from . import util
+
+__all__ = ['Popen']
+
+#
+#
+#
+
+# Exit code used by Popen.terminate()
+TERMINATE = 0x10000
+WINEXE = (sys.platform == 'win32' and getattr(sys, 'frozen', False))
+WINSERVICE = sys.executable.lower().endswith("pythonservice.exe")
+
+
+def _path_eq(p1, p2):
+ return p1 == p2 or os.path.normcase(p1) == os.path.normcase(p2)
+
+WINENV = not _path_eq(sys.executable, sys._base_executable)
+
+
+def _close_handles(*handles):
+ for handle in handles:
+ _winapi.CloseHandle(handle)
+
+
+#
+# We define a Popen class similar to the one from subprocess, but
+# whose constructor takes a process object as its argument.
+#
+
+class Popen(object):
+ '''
+ Start a subprocess to run the code of a process object
+ '''
+ method = 'spawn'
+
+ def __init__(self, process_obj):
+ prep_data = spawn.get_preparation_data(process_obj._name)
+
+ # read end of pipe will be duplicated by the child process
+ # -- see spawn_main() in spawn.py.
+ #
+ # bpo-33929: Previously, the read end of pipe was "stolen" by the child
+ # process, but it leaked a handle if the child process had been
+ # terminated before it could steal the handle from the parent process.
+ rhandle, whandle = _winapi.CreatePipe(None, 0)
+ wfd = msvcrt.open_osfhandle(whandle, 0)
+ cmd = spawn.get_command_line(parent_pid=os.getpid(),
+ pipe_handle=rhandle)
+
+ python_exe = spawn.get_executable()
+
+ # bpo-35797: When running in a venv, we bypass the redirect
+ # executor and launch our base Python.
+ if WINENV and _path_eq(python_exe, sys.executable):
+ cmd[0] = python_exe = sys._base_executable
+ env = os.environ.copy()
+ env["__PYVENV_LAUNCHER__"] = sys.executable
+ else:
+ env = None
+
+ cmd = ' '.join('"%s"' % x for x in cmd)
+
+ with open(wfd, 'wb', closefd=True) as to_child:
+ # start process
+ try:
+ hp, ht, pid, tid = _winapi.CreateProcess(
+ python_exe, cmd,
+ None, None, False, 0, env, None, None)
+ _winapi.CloseHandle(ht)
+ except:
+ _winapi.CloseHandle(rhandle)
+ raise
+
+ # set attributes of self
+ self.pid = pid
+ self.returncode = None
+ self._handle = hp
+ self.sentinel = int(hp)
+ self.finalizer = util.Finalize(self, _close_handles,
+ (self.sentinel, int(rhandle)))
+
+ # send information to child
+ set_spawning_popen(self)
+ try:
+ reduction.dump(prep_data, to_child)
+ reduction.dump(process_obj, to_child)
+ finally:
+ set_spawning_popen(None)
+
+ def duplicate_for_child(self, handle):
+ assert self is get_spawning_popen()
+ return reduction.duplicate(handle, self.sentinel)
+
+ def wait(self, timeout=None):
+ if self.returncode is None:
+ if timeout is None:
+ msecs = _winapi.INFINITE
+ else:
+ msecs = max(0, int(timeout * 1000 + 0.5))
+
+ res = _winapi.WaitForSingleObject(int(self._handle), msecs)
+ if res == _winapi.WAIT_OBJECT_0:
+ code = _winapi.GetExitCodeProcess(self._handle)
+ if code == TERMINATE:
+ code = -signal.SIGTERM
+ self.returncode = code
+
+ return self.returncode
+
+ def poll(self):
+ return self.wait(timeout=0)
+
+ def terminate(self):
+ if self.returncode is None:
+ try:
+ _winapi.TerminateProcess(int(self._handle), TERMINATE)
+ except PermissionError:
+ # ERROR_ACCESS_DENIED (winerror 5) is received when the
+ # process already died.
+ code = _winapi.GetExitCodeProcess(int(self._handle))
+ if code == _winapi.STILL_ACTIVE:
+ raise
+ self.returncode = code
+ else:
+ self.returncode = -signal.SIGTERM
+
+ kill = terminate
+
+ def close(self):
+ self.finalizer()
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/process.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/process.py
new file mode 100644
index 0000000000000000000000000000000000000000..8c1fa1c85daf97f950b19573f05ac05a55f3cdc4
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/process.py
@@ -0,0 +1,439 @@
+#
+# Module providing the `Process` class which emulates `threading.Thread`
+#
+# multiprocessing/process.py
+#
+# Copyright (c) 2006-2008, R Oudkerk
+# Licensed to PSF under a Contributor Agreement.
+#
+
+__all__ = ['BaseProcess', 'current_process', 'active_children',
+ 'parent_process']
+
+#
+# Imports
+#
+
+import os
+import sys
+import signal
+import itertools
+import threading
+from _weakrefset import WeakSet
+
+#
+#
+#
+
+try:
+ ORIGINAL_DIR = os.path.abspath(os.getcwd())
+except OSError:
+ ORIGINAL_DIR = None
+
+#
+# Public functions
+#
+
+def current_process():
+ '''
+ Return process object representing the current process
+ '''
+ return _current_process
+
+def active_children():
+ '''
+ Return list of process objects corresponding to live child processes
+ '''
+ _cleanup()
+ return list(_children)
+
+
+def parent_process():
+ '''
+ Return process object representing the parent process
+ '''
+ return _parent_process
+
+#
+#
+#
+
+def _cleanup():
+ # check for processes which have finished
+ for p in list(_children):
+ if (child_popen := p._popen) and child_popen.poll() is not None:
+ _children.discard(p)
+
+#
+# The `Process` class
+#
+
+class BaseProcess(object):
+ '''
+ Process objects represent activity that is run in a separate process
+
+ The class is analogous to `threading.Thread`
+ '''
+ def _Popen(self):
+ raise NotImplementedError
+
+ def __init__(self, group=None, target=None, name=None, args=(), kwargs={},
+ *, daemon=None):
+ assert group is None, 'group argument must be None for now'
+ count = next(_process_counter)
+ self._identity = _current_process._identity + (count,)
+ self._config = _current_process._config.copy()
+ self._parent_pid = os.getpid()
+ self._parent_name = _current_process.name
+ self._popen = None
+ self._closed = False
+ self._target = target
+ self._args = tuple(args)
+ self._kwargs = dict(kwargs)
+ self._name = name or type(self).__name__ + '-' + \
+ ':'.join(str(i) for i in self._identity)
+ if daemon is not None:
+ self.daemon = daemon
+ _dangling.add(self)
+
+ def _check_closed(self):
+ if self._closed:
+ raise ValueError("process object is closed")
+
+ def run(self):
+ '''
+ Method to be run in sub-process; can be overridden in sub-class
+ '''
+ if self._target:
+ self._target(*self._args, **self._kwargs)
+
+ def start(self):
+ '''
+ Start child process
+ '''
+ self._check_closed()
+ assert self._popen is None, 'cannot start a process twice'
+ assert self._parent_pid == os.getpid(), \
+ 'can only start a process object created by current process'
+ assert not _current_process._config.get('daemon'), \
+ 'daemonic processes are not allowed to have children'
+ _cleanup()
+ self._popen = self._Popen(self)
+ self._sentinel = self._popen.sentinel
+ # Avoid a refcycle if the target function holds an indirect
+ # reference to the process object (see bpo-30775)
+ del self._target, self._args, self._kwargs
+ _children.add(self)
+
+ def terminate(self):
+ '''
+ Terminate process; sends SIGTERM signal or uses TerminateProcess()
+ '''
+ self._check_closed()
+ self._popen.terminate()
+
+ def kill(self):
+ '''
+ Terminate process; sends SIGKILL signal or uses TerminateProcess()
+ '''
+ self._check_closed()
+ self._popen.kill()
+
+ def join(self, timeout=None):
+ '''
+ Wait until child process terminates
+ '''
+ self._check_closed()
+ assert self._parent_pid == os.getpid(), 'can only join a child process'
+ assert self._popen is not None, 'can only join a started process'
+ res = self._popen.wait(timeout)
+ if res is not None:
+ _children.discard(self)
+
+ def is_alive(self):
+ '''
+ Return whether process is alive
+ '''
+ self._check_closed()
+ if self is _current_process:
+ return True
+ assert self._parent_pid == os.getpid(), 'can only test a child process'
+
+ if self._popen is None:
+ return False
+
+ returncode = self._popen.poll()
+ if returncode is None:
+ return True
+ else:
+ _children.discard(self)
+ return False
+
+ def close(self):
+ '''
+ Close the Process object.
+
+ This method releases resources held by the Process object. It is
+ an error to call this method if the child process is still running.
+ '''
+ if self._popen is not None:
+ if self._popen.poll() is None:
+ raise ValueError("Cannot close a process while it is still running. "
+ "You should first call join() or terminate().")
+ self._popen.close()
+ self._popen = None
+ del self._sentinel
+ _children.discard(self)
+ self._closed = True
+
+ @property
+ def name(self):
+ return self._name
+
+ @name.setter
+ def name(self, name):
+ assert isinstance(name, str), 'name must be a string'
+ self._name = name
+
+ @property
+ def daemon(self):
+ '''
+ Return whether process is a daemon
+ '''
+ return self._config.get('daemon', False)
+
+ @daemon.setter
+ def daemon(self, daemonic):
+ '''
+ Set whether process is a daemon
+ '''
+ assert self._popen is None, 'process has already started'
+ self._config['daemon'] = daemonic
+
+ @property
+ def authkey(self):
+ return self._config['authkey']
+
+ @authkey.setter
+ def authkey(self, authkey):
+ '''
+ Set authorization key of process
+ '''
+ self._config['authkey'] = AuthenticationString(authkey)
+
+ @property
+ def exitcode(self):
+ '''
+ Return exit code of process or `None` if it has yet to stop
+ '''
+ self._check_closed()
+ if self._popen is None:
+ return self._popen
+ return self._popen.poll()
+
+ @property
+ def ident(self):
+ '''
+ Return identifier (PID) of process or `None` if it has yet to start
+ '''
+ self._check_closed()
+ if self is _current_process:
+ return os.getpid()
+ else:
+ return self._popen and self._popen.pid
+
+ pid = ident
+
+ @property
+ def sentinel(self):
+ '''
+ Return a file descriptor (Unix) or handle (Windows) suitable for
+ waiting for process termination.
+ '''
+ self._check_closed()
+ try:
+ return self._sentinel
+ except AttributeError:
+ raise ValueError("process not started") from None
+
+ def __repr__(self):
+ exitcode = None
+ if self is _current_process:
+ status = 'started'
+ elif self._closed:
+ status = 'closed'
+ elif self._parent_pid != os.getpid():
+ status = 'unknown'
+ elif self._popen is None:
+ status = 'initial'
+ else:
+ exitcode = self._popen.poll()
+ if exitcode is not None:
+ status = 'stopped'
+ else:
+ status = 'started'
+
+ info = [type(self).__name__, 'name=%r' % self._name]
+ if self._popen is not None:
+ info.append('pid=%s' % self._popen.pid)
+ info.append('parent=%s' % self._parent_pid)
+ info.append(status)
+ if exitcode is not None:
+ exitcode = _exitcode_to_name.get(exitcode, exitcode)
+ info.append('exitcode=%s' % exitcode)
+ if self.daemon:
+ info.append('daemon')
+ return '<%s>' % ' '.join(info)
+
+ ##
+
+ def _bootstrap(self, parent_sentinel=None):
+ from . import util, context
+ global _current_process, _parent_process, _process_counter, _children
+
+ try:
+ if self._start_method is not None:
+ context._force_start_method(self._start_method)
+ _process_counter = itertools.count(1)
+ _children = set()
+ util._close_stdin()
+ old_process = _current_process
+ _current_process = self
+ _parent_process = _ParentProcess(
+ self._parent_name, self._parent_pid, parent_sentinel)
+ if threading._HAVE_THREAD_NATIVE_ID:
+ threading.main_thread()._set_native_id()
+ try:
+ self._after_fork()
+ finally:
+ # delay finalization of the old process object until after
+ # _run_after_forkers() is executed
+ del old_process
+ util.info('child process calling self.run()')
+ try:
+ self.run()
+ exitcode = 0
+ finally:
+ util._exit_function()
+ except SystemExit as e:
+ if e.code is None:
+ exitcode = 0
+ elif isinstance(e.code, int):
+ exitcode = e.code
+ else:
+ sys.stderr.write(str(e.code) + '\n')
+ exitcode = 1
+ except:
+ exitcode = 1
+ import traceback
+ sys.stderr.write('Process %s:\n' % self.name)
+ traceback.print_exc()
+ finally:
+ threading._shutdown()
+ util.info('process exiting with exitcode %d' % exitcode)
+ util._flush_std_streams()
+
+ return exitcode
+
+ @staticmethod
+ def _after_fork():
+ from . import util
+ util._finalizer_registry.clear()
+ util._run_after_forkers()
+
+
+#
+# We subclass bytes to avoid accidental transmission of auth keys over network
+#
+
+class AuthenticationString(bytes):
+ def __reduce__(self):
+ from .context import get_spawning_popen
+ if get_spawning_popen() is None:
+ raise TypeError(
+ 'Pickling an AuthenticationString object is '
+ 'disallowed for security reasons'
+ )
+ return AuthenticationString, (bytes(self),)
+
+
+#
+# Create object representing the parent process
+#
+
+class _ParentProcess(BaseProcess):
+
+ def __init__(self, name, pid, sentinel):
+ self._identity = ()
+ self._name = name
+ self._pid = pid
+ self._parent_pid = None
+ self._popen = None
+ self._closed = False
+ self._sentinel = sentinel
+ self._config = {}
+
+ def is_alive(self):
+ from multiprocess.connection import wait
+ return not wait([self._sentinel], timeout=0)
+
+ @property
+ def ident(self):
+ return self._pid
+
+ def join(self, timeout=None):
+ '''
+ Wait until parent process terminates
+ '''
+ from multiprocess.connection import wait
+ wait([self._sentinel], timeout=timeout)
+
+ pid = ident
+
+#
+# Create object representing the main process
+#
+
+class _MainProcess(BaseProcess):
+
+ def __init__(self):
+ self._identity = ()
+ self._name = 'MainProcess'
+ self._parent_pid = None
+ self._popen = None
+ self._closed = False
+ self._config = {'authkey': AuthenticationString(os.urandom(32)),
+ 'semprefix': '/mp'}
+ # Note that some versions of FreeBSD only allow named
+ # semaphores to have names of up to 14 characters. Therefore
+ # we choose a short prefix.
+ #
+ # On MacOSX in a sandbox it may be necessary to use a
+ # different prefix -- see #19478.
+ #
+ # Everything in self._config will be inherited by descendant
+ # processes.
+
+ def close(self):
+ pass
+
+
+_parent_process = None
+_current_process = _MainProcess()
+_process_counter = itertools.count(1)
+_children = set()
+del _MainProcess
+
+#
+# Give names to some return codes
+#
+
+_exitcode_to_name = {}
+
+for name, signum in list(signal.__dict__.items()):
+ if name[:3]=='SIG' and '_' not in name:
+ _exitcode_to_name[-signum] = f'-{name}'
+del name, signum
+
+# For debug and leak testing
+_dangling = WeakSet()
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/queues.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/queues.py
new file mode 100644
index 0000000000000000000000000000000000000000..ae51ba919c991fbf418d72b19d8fb1014785efe5
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/queues.py
@@ -0,0 +1,399 @@
+#
+# Module implementing queues
+#
+# multiprocessing/queues.py
+#
+# Copyright (c) 2006-2008, R Oudkerk
+# Licensed to PSF under a Contributor Agreement.
+#
+
+__all__ = ['Queue', 'SimpleQueue', 'JoinableQueue']
+
+import sys
+import os
+import threading
+import collections
+import time
+import types
+import weakref
+import errno
+
+from queue import Empty, Full
+
+try:
+ import _multiprocess as _multiprocessing
+except ImportError:
+ import _multiprocessing
+
+from . import connection
+from . import context
+_ForkingPickler = context.reduction.ForkingPickler
+
+from .util import debug, info, Finalize, register_after_fork, is_exiting
+
+#
+# Queue type using a pipe, buffer and thread
+#
+
+class Queue(object):
+
+ def __init__(self, maxsize=0, *, ctx):
+ if maxsize <= 0:
+ # Can raise ImportError (see issues #3770 and #23400)
+ from .synchronize import SEM_VALUE_MAX as maxsize
+ self._maxsize = maxsize
+ self._reader, self._writer = connection.Pipe(duplex=False)
+ self._rlock = ctx.Lock()
+ self._opid = os.getpid()
+ if sys.platform == 'win32':
+ self._wlock = None
+ else:
+ self._wlock = ctx.Lock()
+ self._sem = ctx.BoundedSemaphore(maxsize)
+ # For use by concurrent.futures
+ self._ignore_epipe = False
+ self._reset()
+
+ if sys.platform != 'win32':
+ register_after_fork(self, Queue._after_fork)
+
+ def __getstate__(self):
+ context.assert_spawning(self)
+ return (self._ignore_epipe, self._maxsize, self._reader, self._writer,
+ self._rlock, self._wlock, self._sem, self._opid)
+
+ def __setstate__(self, state):
+ (self._ignore_epipe, self._maxsize, self._reader, self._writer,
+ self._rlock, self._wlock, self._sem, self._opid) = state
+ self._reset()
+
+ def _after_fork(self):
+ debug('Queue._after_fork()')
+ self._reset(after_fork=True)
+
+ def _reset(self, after_fork=False):
+ if after_fork:
+ self._notempty._at_fork_reinit()
+ else:
+ self._notempty = threading.Condition(threading.Lock())
+ self._buffer = collections.deque()
+ self._thread = None
+ self._jointhread = None
+ self._joincancelled = False
+ self._closed = False
+ self._close = None
+ self._send_bytes = self._writer.send_bytes
+ self._recv_bytes = self._reader.recv_bytes
+ self._poll = self._reader.poll
+
+ def put(self, obj, block=True, timeout=None):
+ if self._closed:
+ raise ValueError(f"Queue {self!r} is closed")
+ if not self._sem.acquire(block, timeout):
+ raise Full
+
+ with self._notempty:
+ if self._thread is None:
+ self._start_thread()
+ self._buffer.append(obj)
+ self._notempty.notify()
+
+ def get(self, block=True, timeout=None):
+ if self._closed:
+ raise ValueError(f"Queue {self!r} is closed")
+ if block and timeout is None:
+ with self._rlock:
+ res = self._recv_bytes()
+ self._sem.release()
+ else:
+ if block:
+ deadline = getattr(time,'monotonic',time.time)() + timeout
+ if not self._rlock.acquire(block, timeout):
+ raise Empty
+ try:
+ if block:
+ timeout = deadline - getattr(time,'monotonic',time.time)()
+ if not self._poll(timeout):
+ raise Empty
+ elif not self._poll():
+ raise Empty
+ res = self._recv_bytes()
+ self._sem.release()
+ finally:
+ self._rlock.release()
+ # unserialize the data after having released the lock
+ return _ForkingPickler.loads(res)
+
+ def qsize(self):
+ # Raises NotImplementedError on Mac OSX because of broken sem_getvalue()
+ return self._maxsize - self._sem._semlock._get_value()
+
+ def empty(self):
+ return not self._poll()
+
+ def full(self):
+ return self._sem._semlock._is_zero()
+
+ def get_nowait(self):
+ return self.get(False)
+
+ def put_nowait(self, obj):
+ return self.put(obj, False)
+
+ def close(self):
+ self._closed = True
+ close = self._close
+ if close:
+ self._close = None
+ close()
+
+ def join_thread(self):
+ debug('Queue.join_thread()')
+ assert self._closed, "Queue {0!r} not closed".format(self)
+ if self._jointhread:
+ self._jointhread()
+
+ def cancel_join_thread(self):
+ debug('Queue.cancel_join_thread()')
+ self._joincancelled = True
+ try:
+ self._jointhread.cancel()
+ except AttributeError:
+ pass
+
+ def _terminate_broken(self):
+ # Close a Queue on error.
+
+ # gh-94777: Prevent queue writing to a pipe which is no longer read.
+ self._reader.close()
+
+ self.close()
+ self.join_thread()
+
+ def _start_thread(self):
+ debug('Queue._start_thread()')
+
+ # Start thread which transfers data from buffer to pipe
+ self._buffer.clear()
+ self._thread = threading.Thread(
+ target=Queue._feed,
+ args=(self._buffer, self._notempty, self._send_bytes,
+ self._wlock, self._reader.close, self._writer.close,
+ self._ignore_epipe, self._on_queue_feeder_error,
+ self._sem),
+ name='QueueFeederThread',
+ daemon=True,
+ )
+
+ try:
+ debug('doing self._thread.start()')
+ self._thread.start()
+ debug('... done self._thread.start()')
+ except:
+ # gh-109047: During Python finalization, creating a thread
+ # can fail with RuntimeError.
+ self._thread = None
+ raise
+
+ if not self._joincancelled:
+ self._jointhread = Finalize(
+ self._thread, Queue._finalize_join,
+ [weakref.ref(self._thread)],
+ exitpriority=-5
+ )
+
+ # Send sentinel to the thread queue object when garbage collected
+ self._close = Finalize(
+ self, Queue._finalize_close,
+ [self._buffer, self._notempty],
+ exitpriority=10
+ )
+
+ @staticmethod
+ def _finalize_join(twr):
+ debug('joining queue thread')
+ thread = twr()
+ if thread is not None:
+ thread.join()
+ debug('... queue thread joined')
+ else:
+ debug('... queue thread already dead')
+
+ @staticmethod
+ def _finalize_close(buffer, notempty):
+ debug('telling queue thread to quit')
+ with notempty:
+ buffer.append(_sentinel)
+ notempty.notify()
+
+ @staticmethod
+ def _feed(buffer, notempty, send_bytes, writelock, reader_close,
+ writer_close, ignore_epipe, onerror, queue_sem):
+ debug('starting thread to feed data to pipe')
+ nacquire = notempty.acquire
+ nrelease = notempty.release
+ nwait = notempty.wait
+ bpopleft = buffer.popleft
+ sentinel = _sentinel
+ if sys.platform != 'win32':
+ wacquire = writelock.acquire
+ wrelease = writelock.release
+ else:
+ wacquire = None
+
+ while 1:
+ try:
+ nacquire()
+ try:
+ if not buffer:
+ nwait()
+ finally:
+ nrelease()
+ try:
+ while 1:
+ obj = bpopleft()
+ if obj is sentinel:
+ debug('feeder thread got sentinel -- exiting')
+ reader_close()
+ writer_close()
+ return
+
+ # serialize the data before acquiring the lock
+ obj = _ForkingPickler.dumps(obj)
+ if wacquire is None:
+ send_bytes(obj)
+ else:
+ wacquire()
+ try:
+ send_bytes(obj)
+ finally:
+ wrelease()
+ except IndexError:
+ pass
+ except Exception as e:
+ if ignore_epipe and getattr(e, 'errno', 0) == errno.EPIPE:
+ return
+ # Since this runs in a daemon thread the resources it uses
+ # may be become unusable while the process is cleaning up.
+ # We ignore errors which happen after the process has
+ # started to cleanup.
+ if is_exiting():
+ info('error in queue thread: %s', e)
+ return
+ else:
+ # Since the object has not been sent in the queue, we need
+ # to decrease the size of the queue. The error acts as
+ # if the object had been silently removed from the queue
+ # and this step is necessary to have a properly working
+ # queue.
+ queue_sem.release()
+ onerror(e, obj)
+
+ @staticmethod
+ def _on_queue_feeder_error(e, obj):
+ """
+ Private API hook called when feeding data in the background thread
+ raises an exception. For overriding by concurrent.futures.
+ """
+ import traceback
+ traceback.print_exc()
+
+ __class_getitem__ = classmethod(types.GenericAlias)
+
+
+_sentinel = object()
+
+#
+# A queue type which also supports join() and task_done() methods
+#
+# Note that if you do not call task_done() for each finished task then
+# eventually the counter's semaphore may overflow causing Bad Things
+# to happen.
+#
+
+class JoinableQueue(Queue):
+
+ def __init__(self, maxsize=0, *, ctx):
+ Queue.__init__(self, maxsize, ctx=ctx)
+ self._unfinished_tasks = ctx.Semaphore(0)
+ self._cond = ctx.Condition()
+
+ def __getstate__(self):
+ return Queue.__getstate__(self) + (self._cond, self._unfinished_tasks)
+
+ def __setstate__(self, state):
+ Queue.__setstate__(self, state[:-2])
+ self._cond, self._unfinished_tasks = state[-2:]
+
+ def put(self, obj, block=True, timeout=None):
+ if self._closed:
+ raise ValueError(f"Queue {self!r} is closed")
+ if not self._sem.acquire(block, timeout):
+ raise Full
+
+ with self._notempty, self._cond:
+ if self._thread is None:
+ self._start_thread()
+ self._buffer.append(obj)
+ self._unfinished_tasks.release()
+ self._notempty.notify()
+
+ def task_done(self):
+ with self._cond:
+ if not self._unfinished_tasks.acquire(False):
+ raise ValueError('task_done() called too many times')
+ if self._unfinished_tasks._semlock._is_zero():
+ self._cond.notify_all()
+
+ def join(self):
+ with self._cond:
+ if not self._unfinished_tasks._semlock._is_zero():
+ self._cond.wait()
+
+#
+# Simplified Queue type -- really just a locked pipe
+#
+
+class SimpleQueue(object):
+
+ def __init__(self, *, ctx):
+ self._reader, self._writer = connection.Pipe(duplex=False)
+ self._rlock = ctx.Lock()
+ self._poll = self._reader.poll
+ if sys.platform == 'win32':
+ self._wlock = None
+ else:
+ self._wlock = ctx.Lock()
+
+ def close(self):
+ self._reader.close()
+ self._writer.close()
+
+ def empty(self):
+ return not self._poll()
+
+ def __getstate__(self):
+ context.assert_spawning(self)
+ return (self._reader, self._writer, self._rlock, self._wlock)
+
+ def __setstate__(self, state):
+ (self._reader, self._writer, self._rlock, self._wlock) = state
+ self._poll = self._reader.poll
+
+ def get(self):
+ with self._rlock:
+ res = self._reader.recv_bytes()
+ # unserialize the data after having released the lock
+ return _ForkingPickler.loads(res)
+
+ def put(self, obj):
+ # serialize the data before acquiring the lock
+ obj = _ForkingPickler.dumps(obj)
+ if self._wlock is None:
+ # writes to a message oriented win32 pipe are atomic
+ self._writer.send_bytes(obj)
+ else:
+ with self._wlock:
+ self._writer.send_bytes(obj)
+
+ __class_getitem__ = classmethod(types.GenericAlias)
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/reduction.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/reduction.py
new file mode 100644
index 0000000000000000000000000000000000000000..39b132c5e17067a215184866a25654b70b7bea1f
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/reduction.py
@@ -0,0 +1,284 @@
+#
+# Module which deals with pickling of objects.
+#
+# multiprocessing/reduction.py
+#
+# Copyright (c) 2006-2008, R Oudkerk
+# Licensed to PSF under a Contributor Agreement.
+#
+
+from abc import ABCMeta
+import copyreg
+import functools
+import io
+import os
+try:
+ import dill as pickle
+except ImportError:
+ import pickle
+import socket
+import sys
+
+from . import context
+
+__all__ = ['send_handle', 'recv_handle', 'ForkingPickler', 'register', 'dump']
+
+
+HAVE_SEND_HANDLE = (sys.platform == 'win32' or
+ (hasattr(socket, 'CMSG_LEN') and
+ hasattr(socket, 'SCM_RIGHTS') and
+ hasattr(socket.socket, 'sendmsg')))
+
+#
+# Pickler subclass
+#
+
+class ForkingPickler(pickle.Pickler):
+ '''Pickler subclass used by multiprocess.'''
+ _extra_reducers = {}
+ _copyreg_dispatch_table = copyreg.dispatch_table
+
+ def __init__(self, *args, **kwds):
+ super().__init__(*args, **kwds)
+ self.dispatch_table = self._copyreg_dispatch_table.copy()
+ self.dispatch_table.update(self._extra_reducers)
+
+ @classmethod
+ def register(cls, type, reduce):
+ '''Register a reduce function for a type.'''
+ cls._extra_reducers[type] = reduce
+
+ @classmethod
+ def dumps(cls, obj, protocol=None, *args, **kwds):
+ buf = io.BytesIO()
+ cls(buf, protocol, *args, **kwds).dump(obj)
+ return buf.getbuffer()
+
+ loads = pickle.loads
+
+register = ForkingPickler.register
+
+def dump(obj, file, protocol=None, *args, **kwds):
+ '''Replacement for pickle.dump() using ForkingPickler.'''
+ ForkingPickler(file, protocol, *args, **kwds).dump(obj)
+
+#
+# Platform specific definitions
+#
+
+if sys.platform == 'win32':
+ # Windows
+ __all__ += ['DupHandle', 'duplicate', 'steal_handle']
+ import _winapi
+
+ def duplicate(handle, target_process=None, inheritable=False,
+ *, source_process=None):
+ '''Duplicate a handle. (target_process is a handle not a pid!)'''
+ current_process = _winapi.GetCurrentProcess()
+ if source_process is None:
+ source_process = current_process
+ if target_process is None:
+ target_process = current_process
+ return _winapi.DuplicateHandle(
+ source_process, handle, target_process,
+ 0, inheritable, _winapi.DUPLICATE_SAME_ACCESS)
+
+ def steal_handle(source_pid, handle):
+ '''Steal a handle from process identified by source_pid.'''
+ source_process_handle = _winapi.OpenProcess(
+ _winapi.PROCESS_DUP_HANDLE, False, source_pid)
+ try:
+ return _winapi.DuplicateHandle(
+ source_process_handle, handle,
+ _winapi.GetCurrentProcess(), 0, False,
+ _winapi.DUPLICATE_SAME_ACCESS | _winapi.DUPLICATE_CLOSE_SOURCE)
+ finally:
+ _winapi.CloseHandle(source_process_handle)
+
+ def send_handle(conn, handle, destination_pid):
+ '''Send a handle over a local connection.'''
+ dh = DupHandle(handle, _winapi.DUPLICATE_SAME_ACCESS, destination_pid)
+ conn.send(dh)
+
+ def recv_handle(conn):
+ '''Receive a handle over a local connection.'''
+ return conn.recv().detach()
+
+ class DupHandle(object):
+ '''Picklable wrapper for a handle.'''
+ def __init__(self, handle, access, pid=None):
+ if pid is None:
+ # We just duplicate the handle in the current process and
+ # let the receiving process steal the handle.
+ pid = os.getpid()
+ proc = _winapi.OpenProcess(_winapi.PROCESS_DUP_HANDLE, False, pid)
+ try:
+ self._handle = _winapi.DuplicateHandle(
+ _winapi.GetCurrentProcess(),
+ handle, proc, access, False, 0)
+ finally:
+ _winapi.CloseHandle(proc)
+ self._access = access
+ self._pid = pid
+
+ def detach(self):
+ '''Get the handle. This should only be called once.'''
+ # retrieve handle from process which currently owns it
+ if self._pid == os.getpid():
+ # The handle has already been duplicated for this process.
+ return self._handle
+ # We must steal the handle from the process whose pid is self._pid.
+ proc = _winapi.OpenProcess(_winapi.PROCESS_DUP_HANDLE, False,
+ self._pid)
+ try:
+ return _winapi.DuplicateHandle(
+ proc, self._handle, _winapi.GetCurrentProcess(),
+ self._access, False, _winapi.DUPLICATE_CLOSE_SOURCE)
+ finally:
+ _winapi.CloseHandle(proc)
+
+else:
+ # Unix
+ __all__ += ['DupFd', 'sendfds', 'recvfds']
+ import array
+
+ # On MacOSX we should acknowledge receipt of fds -- see Issue14669
+ ACKNOWLEDGE = sys.platform == 'darwin'
+
+ def sendfds(sock, fds):
+ '''Send an array of fds over an AF_UNIX socket.'''
+ fds = array.array('i', fds)
+ msg = bytes([len(fds) % 256])
+ sock.sendmsg([msg], [(socket.SOL_SOCKET, socket.SCM_RIGHTS, fds)])
+ if ACKNOWLEDGE and sock.recv(1) != b'A':
+ raise RuntimeError('did not receive acknowledgement of fd')
+
+ def recvfds(sock, size):
+ '''Receive an array of fds over an AF_UNIX socket.'''
+ a = array.array('i')
+ bytes_size = a.itemsize * size
+ msg, ancdata, flags, addr = sock.recvmsg(1, socket.CMSG_SPACE(bytes_size))
+ if not msg and not ancdata:
+ raise EOFError
+ try:
+ if ACKNOWLEDGE:
+ sock.send(b'A')
+ if len(ancdata) != 1:
+ raise RuntimeError('received %d items of ancdata' %
+ len(ancdata))
+ cmsg_level, cmsg_type, cmsg_data = ancdata[0]
+ if (cmsg_level == socket.SOL_SOCKET and
+ cmsg_type == socket.SCM_RIGHTS):
+ if len(cmsg_data) % a.itemsize != 0:
+ raise ValueError
+ a.frombytes(cmsg_data)
+ if len(a) % 256 != msg[0]:
+ raise AssertionError(
+ "Len is {0:n} but msg[0] is {1!r}".format(
+ len(a), msg[0]))
+ return list(a)
+ except (ValueError, IndexError):
+ pass
+ raise RuntimeError('Invalid data received')
+
+ def send_handle(conn, handle, destination_pid):
+ '''Send a handle over a local connection.'''
+ with socket.fromfd(conn.fileno(), socket.AF_UNIX, socket.SOCK_STREAM) as s:
+ sendfds(s, [handle])
+
+ def recv_handle(conn):
+ '''Receive a handle over a local connection.'''
+ with socket.fromfd(conn.fileno(), socket.AF_UNIX, socket.SOCK_STREAM) as s:
+ return recvfds(s, 1)[0]
+
+ def DupFd(fd):
+ '''Return a wrapper for an fd.'''
+ popen_obj = context.get_spawning_popen()
+ if popen_obj is not None:
+ return popen_obj.DupFd(popen_obj.duplicate_for_child(fd))
+ elif HAVE_SEND_HANDLE:
+ from . import resource_sharer
+ return resource_sharer.DupFd(fd)
+ else:
+ raise ValueError('SCM_RIGHTS appears not to be available')
+
+#
+# Try making some callable types picklable
+#
+
+def _reduce_method(m):
+ if m.__self__ is None:
+ return getattr, (m.__class__, m.__func__.__name__)
+ else:
+ return getattr, (m.__self__, m.__func__.__name__)
+class _C:
+ def f(self):
+ pass
+register(type(_C().f), _reduce_method)
+
+
+def _reduce_method_descriptor(m):
+ return getattr, (m.__objclass__, m.__name__)
+register(type(list.append), _reduce_method_descriptor)
+register(type(int.__add__), _reduce_method_descriptor)
+
+
+def _reduce_partial(p):
+ return _rebuild_partial, (p.func, p.args, p.keywords or {})
+def _rebuild_partial(func, args, keywords):
+ return functools.partial(func, *args, **keywords)
+register(functools.partial, _reduce_partial)
+
+#
+# Make sockets picklable
+#
+
+if sys.platform == 'win32':
+ def _reduce_socket(s):
+ from .resource_sharer import DupSocket
+ return _rebuild_socket, (DupSocket(s),)
+ def _rebuild_socket(ds):
+ return ds.detach()
+ register(socket.socket, _reduce_socket)
+
+else:
+ def _reduce_socket(s):
+ df = DupFd(s.fileno())
+ return _rebuild_socket, (df, s.family, s.type, s.proto)
+ def _rebuild_socket(df, family, type, proto):
+ fd = df.detach()
+ return socket.socket(family, type, proto, fileno=fd)
+ register(socket.socket, _reduce_socket)
+
+
+class AbstractReducer(metaclass=ABCMeta):
+ '''Abstract base class for use in implementing a Reduction class
+ suitable for use in replacing the standard reduction mechanism
+ used in multiprocess.'''
+ ForkingPickler = ForkingPickler
+ register = register
+ dump = dump
+ send_handle = send_handle
+ recv_handle = recv_handle
+
+ if sys.platform == 'win32':
+ steal_handle = steal_handle
+ duplicate = duplicate
+ DupHandle = DupHandle
+ else:
+ sendfds = sendfds
+ recvfds = recvfds
+ DupFd = DupFd
+
+ _reduce_method = _reduce_method
+ _reduce_method_descriptor = _reduce_method_descriptor
+ _rebuild_partial = _rebuild_partial
+ _reduce_socket = _reduce_socket
+ _rebuild_socket = _rebuild_socket
+
+ def __init__(self, *args):
+ register(type(_C().f), _reduce_method)
+ register(type(list.append), _reduce_method_descriptor)
+ register(type(int.__add__), _reduce_method_descriptor)
+ register(functools.partial, _reduce_partial)
+ register(socket.socket, _reduce_socket)
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/resource_sharer.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/resource_sharer.py
new file mode 100644
index 0000000000000000000000000000000000000000..66076509a1202e7a1b4d8a481f64621a4bfbbf3e
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/resource_sharer.py
@@ -0,0 +1,154 @@
+#
+# We use a background thread for sharing fds on Unix, and for sharing sockets on
+# Windows.
+#
+# A client which wants to pickle a resource registers it with the resource
+# sharer and gets an identifier in return. The unpickling process will connect
+# to the resource sharer, sends the identifier and its pid, and then receives
+# the resource.
+#
+
+import os
+import signal
+import socket
+import sys
+import threading
+
+from . import process
+from .context import reduction
+from . import util
+
+__all__ = ['stop']
+
+
+if sys.platform == 'win32':
+ __all__ += ['DupSocket']
+
+ class DupSocket(object):
+ '''Picklable wrapper for a socket.'''
+ def __init__(self, sock):
+ new_sock = sock.dup()
+ def send(conn, pid):
+ share = new_sock.share(pid)
+ conn.send_bytes(share)
+ self._id = _resource_sharer.register(send, new_sock.close)
+
+ def detach(self):
+ '''Get the socket. This should only be called once.'''
+ with _resource_sharer.get_connection(self._id) as conn:
+ share = conn.recv_bytes()
+ return socket.fromshare(share)
+
+else:
+ __all__ += ['DupFd']
+
+ class DupFd(object):
+ '''Wrapper for fd which can be used at any time.'''
+ def __init__(self, fd):
+ new_fd = os.dup(fd)
+ def send(conn, pid):
+ reduction.send_handle(conn, new_fd, pid)
+ def close():
+ os.close(new_fd)
+ self._id = _resource_sharer.register(send, close)
+
+ def detach(self):
+ '''Get the fd. This should only be called once.'''
+ with _resource_sharer.get_connection(self._id) as conn:
+ return reduction.recv_handle(conn)
+
+
+class _ResourceSharer(object):
+ '''Manager for resources using background thread.'''
+ def __init__(self):
+ self._key = 0
+ self._cache = {}
+ self._lock = threading.Lock()
+ self._listener = None
+ self._address = None
+ self._thread = None
+ util.register_after_fork(self, _ResourceSharer._afterfork)
+
+ def register(self, send, close):
+ '''Register resource, returning an identifier.'''
+ with self._lock:
+ if self._address is None:
+ self._start()
+ self._key += 1
+ self._cache[self._key] = (send, close)
+ return (self._address, self._key)
+
+ @staticmethod
+ def get_connection(ident):
+ '''Return connection from which to receive identified resource.'''
+ from .connection import Client
+ address, key = ident
+ c = Client(address, authkey=process.current_process().authkey)
+ c.send((key, os.getpid()))
+ return c
+
+ def stop(self, timeout=None):
+ '''Stop the background thread and clear registered resources.'''
+ from .connection import Client
+ with self._lock:
+ if self._address is not None:
+ c = Client(self._address,
+ authkey=process.current_process().authkey)
+ c.send(None)
+ c.close()
+ self._thread.join(timeout)
+ if self._thread.is_alive():
+ util.sub_warning('_ResourceSharer thread did '
+ 'not stop when asked')
+ self._listener.close()
+ self._thread = None
+ self._address = None
+ self._listener = None
+ for key, (send, close) in self._cache.items():
+ close()
+ self._cache.clear()
+
+ def _afterfork(self):
+ for key, (send, close) in self._cache.items():
+ close()
+ self._cache.clear()
+ self._lock._at_fork_reinit()
+ if self._listener is not None:
+ self._listener.close()
+ self._listener = None
+ self._address = None
+ self._thread = None
+
+ def _start(self):
+ from .connection import Listener
+ assert self._listener is None, "Already have Listener"
+ util.debug('starting listener and thread for sending handles')
+ self._listener = Listener(authkey=process.current_process().authkey)
+ self._address = self._listener.address
+ t = threading.Thread(target=self._serve)
+ t.daemon = True
+ t.start()
+ self._thread = t
+
+ def _serve(self):
+ if hasattr(signal, 'pthread_sigmask'):
+ signal.pthread_sigmask(signal.SIG_BLOCK, signal.valid_signals())
+ while 1:
+ try:
+ with self._listener.accept() as conn:
+ msg = conn.recv()
+ if msg is None:
+ break
+ key, destination_pid = msg
+ send, close = self._cache.pop(key)
+ try:
+ send(conn, destination_pid)
+ finally:
+ close()
+ except:
+ if not util.is_exiting():
+ sys.excepthook(*sys.exc_info())
+
+
+_resource_sharer = _ResourceSharer()
+stop = _resource_sharer.stop
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/resource_tracker.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/resource_tracker.py
new file mode 100644
index 0000000000000000000000000000000000000000..546608fc42425991ee0225aeabebe7a5f7f26904
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/resource_tracker.py
@@ -0,0 +1,272 @@
+###############################################################################
+# Server process to keep track of unlinked resources (like shared memory
+# segments, semaphores etc.) and clean them.
+#
+# On Unix we run a server process which keeps track of unlinked
+# resources. The server ignores SIGINT and SIGTERM and reads from a
+# pipe. Every other process of the program has a copy of the writable
+# end of the pipe, so we get EOF when all other processes have exited.
+# Then the server process unlinks any remaining resource names.
+#
+# This is important because there may be system limits for such resources: for
+# instance, the system only supports a limited number of named semaphores, and
+# shared-memory segments live in the RAM. If a python process leaks such a
+# resource, this resource will not be removed till the next reboot. Without
+# this resource tracker process, "killall python" would probably leave unlinked
+# resources.
+
+import os
+import signal
+import sys
+import threading
+import warnings
+
+from . import spawn
+from . import util
+
+__all__ = ['ensure_running', 'register', 'unregister']
+
+_HAVE_SIGMASK = hasattr(signal, 'pthread_sigmask')
+_IGNORED_SIGNALS = (signal.SIGINT, signal.SIGTERM)
+
+_CLEANUP_FUNCS = {
+ 'noop': lambda: None,
+}
+
+if os.name == 'posix':
+ try:
+ import _multiprocess as _multiprocessing
+ except ImportError:
+ import _multiprocessing
+ import _posixshmem
+
+ # Use sem_unlink() to clean up named semaphores.
+ #
+ # sem_unlink() may be missing if the Python build process detected the
+ # absence of POSIX named semaphores. In that case, no named semaphores were
+ # ever opened, so no cleanup would be necessary.
+ if hasattr(_multiprocessing, 'sem_unlink'):
+ _CLEANUP_FUNCS.update({
+ 'semaphore': _multiprocessing.sem_unlink,
+ })
+ _CLEANUP_FUNCS.update({
+ 'shared_memory': _posixshmem.shm_unlink,
+ })
+
+
+class ReentrantCallError(RuntimeError):
+ pass
+
+
+class ResourceTracker(object):
+
+ def __init__(self):
+ self._lock = threading.RLock()
+ self._fd = None
+ self._pid = None
+
+ def _reentrant_call_error(self):
+ # gh-109629: this happens if an explicit call to the ResourceTracker
+ # gets interrupted by a garbage collection, invoking a finalizer (*)
+ # that itself calls back into ResourceTracker.
+ # (*) for example the SemLock finalizer
+ raise ReentrantCallError(
+ "Reentrant call into the multiprocessing resource tracker")
+
+ def _stop(self):
+ with self._lock:
+ # This should not happen (_stop() isn't called by a finalizer)
+ # but we check for it anyway.
+ if getattr(self._lock, "_recursion_count", int)() > 1:
+ return self._reentrant_call_error()
+ if self._fd is None:
+ # not running
+ return
+
+ # closing the "alive" file descriptor stops main()
+ os.close(self._fd)
+ self._fd = None
+
+ os.waitpid(self._pid, 0)
+ self._pid = None
+
+ def getfd(self):
+ self.ensure_running()
+ return self._fd
+
+ def ensure_running(self):
+ '''Make sure that resource tracker process is running.
+
+ This can be run from any process. Usually a child process will use
+ the resource created by its parent.'''
+ with self._lock:
+ if getattr(self._lock, "_recursion_count", int)() > 1:
+ # The code below is certainly not reentrant-safe, so bail out
+ return self._reentrant_call_error()
+ if self._fd is not None:
+ # resource tracker was launched before, is it still running?
+ if self._check_alive():
+ # => still alive
+ return
+ # => dead, launch it again
+ os.close(self._fd)
+
+ # Clean-up to avoid dangling processes.
+ try:
+ # _pid can be None if this process is a child from another
+ # python process, which has started the resource_tracker.
+ if self._pid is not None:
+ os.waitpid(self._pid, 0)
+ except ChildProcessError:
+ # The resource_tracker has already been terminated.
+ pass
+ self._fd = None
+ self._pid = None
+
+ warnings.warn('resource_tracker: process died unexpectedly, '
+ 'relaunching. Some resources might leak.')
+
+ fds_to_pass = []
+ try:
+ fds_to_pass.append(sys.stderr.fileno())
+ except Exception:
+ pass
+ cmd = 'from multiprocess.resource_tracker import main;main(%d)'
+ r, w = os.pipe()
+ try:
+ fds_to_pass.append(r)
+ # process will out live us, so no need to wait on pid
+ exe = spawn.get_executable()
+ args = [exe] + util._args_from_interpreter_flags()
+ args += ['-c', cmd % r]
+ # bpo-33613: Register a signal mask that will block the signals.
+ # This signal mask will be inherited by the child that is going
+ # to be spawned and will protect the child from a race condition
+ # that can make the child die before it registers signal handlers
+ # for SIGINT and SIGTERM. The mask is unregistered after spawning
+ # the child.
+ try:
+ if _HAVE_SIGMASK:
+ signal.pthread_sigmask(signal.SIG_BLOCK, _IGNORED_SIGNALS)
+ pid = util.spawnv_passfds(exe, args, fds_to_pass)
+ finally:
+ if _HAVE_SIGMASK:
+ signal.pthread_sigmask(signal.SIG_UNBLOCK, _IGNORED_SIGNALS)
+ except:
+ os.close(w)
+ raise
+ else:
+ self._fd = w
+ self._pid = pid
+ finally:
+ os.close(r)
+
+ def _check_alive(self):
+ '''Check that the pipe has not been closed by sending a probe.'''
+ try:
+ # We cannot use send here as it calls ensure_running, creating
+ # a cycle.
+ os.write(self._fd, b'PROBE:0:noop\n')
+ except OSError:
+ return False
+ else:
+ return True
+
+ def register(self, name, rtype):
+ '''Register name of resource with resource tracker.'''
+ self._send('REGISTER', name, rtype)
+
+ def unregister(self, name, rtype):
+ '''Unregister name of resource with resource tracker.'''
+ self._send('UNREGISTER', name, rtype)
+
+ def _send(self, cmd, name, rtype):
+ try:
+ self.ensure_running()
+ except ReentrantCallError:
+ # The code below might or might not work, depending on whether
+ # the resource tracker was already running and still alive.
+ # Better warn the user.
+ # (XXX is warnings.warn itself reentrant-safe? :-)
+ warnings.warn(
+ f"ResourceTracker called reentrantly for resource cleanup, "
+ f"which is unsupported. "
+ f"The {rtype} object {name!r} might leak.")
+ msg = '{0}:{1}:{2}\n'.format(cmd, name, rtype).encode('ascii')
+ if len(msg) > 512:
+ # posix guarantees that writes to a pipe of less than PIPE_BUF
+ # bytes are atomic, and that PIPE_BUF >= 512
+ raise ValueError('msg too long')
+ nbytes = os.write(self._fd, msg)
+ assert nbytes == len(msg), "nbytes {0:n} but len(msg) {1:n}".format(
+ nbytes, len(msg))
+
+
+_resource_tracker = ResourceTracker()
+ensure_running = _resource_tracker.ensure_running
+register = _resource_tracker.register
+unregister = _resource_tracker.unregister
+getfd = _resource_tracker.getfd
+
+
+def main(fd):
+ '''Run resource tracker.'''
+ # protect the process from ^C and "killall python" etc
+ signal.signal(signal.SIGINT, signal.SIG_IGN)
+ signal.signal(signal.SIGTERM, signal.SIG_IGN)
+ if _HAVE_SIGMASK:
+ signal.pthread_sigmask(signal.SIG_UNBLOCK, _IGNORED_SIGNALS)
+
+ for f in (sys.stdin, sys.stdout):
+ try:
+ f.close()
+ except Exception:
+ pass
+
+ cache = {rtype: set() for rtype in _CLEANUP_FUNCS.keys()}
+ try:
+ # keep track of registered/unregistered resources
+ with open(fd, 'rb') as f:
+ for line in f:
+ try:
+ cmd, name, rtype = line.strip().decode('ascii').split(':')
+ cleanup_func = _CLEANUP_FUNCS.get(rtype, None)
+ if cleanup_func is None:
+ raise ValueError(
+ f'Cannot register {name} for automatic cleanup: '
+ f'unknown resource type {rtype}')
+
+ if cmd == 'REGISTER':
+ cache[rtype].add(name)
+ elif cmd == 'UNREGISTER':
+ cache[rtype].remove(name)
+ elif cmd == 'PROBE':
+ pass
+ else:
+ raise RuntimeError('unrecognized command %r' % cmd)
+ except Exception:
+ try:
+ sys.excepthook(*sys.exc_info())
+ except:
+ pass
+ finally:
+ # all processes have terminated; cleanup any remaining resources
+ for rtype, rtype_cache in cache.items():
+ if rtype_cache:
+ try:
+ warnings.warn('resource_tracker: There appear to be %d '
+ 'leaked %s objects to clean up at shutdown' %
+ (len(rtype_cache), rtype))
+ except Exception:
+ pass
+ for name in rtype_cache:
+ # For some reason the process which created and registered this
+ # resource has failed to unregister it. Presumably it has
+ # died. We therefore unlink it.
+ try:
+ try:
+ _CLEANUP_FUNCS[rtype](name)
+ except Exception as e:
+ warnings.warn('resource_tracker: %r: %s' % (name, e))
+ finally:
+ pass
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/shared_memory.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/shared_memory.py
new file mode 100644
index 0000000000000000000000000000000000000000..9a1e5aa17b87a232a831b5d250b8e0c2f15f574d
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/shared_memory.py
@@ -0,0 +1,534 @@
+"""Provides shared memory for direct access across processes.
+
+The API of this package is currently provisional. Refer to the
+documentation for details.
+"""
+
+
+__all__ = [ 'SharedMemory', 'ShareableList' ]
+
+
+from functools import partial
+import mmap
+import os
+import errno
+import struct
+import secrets
+import types
+
+if os.name == "nt":
+ import _winapi
+ _USE_POSIX = False
+else:
+ import _posixshmem
+ _USE_POSIX = True
+
+from . import resource_tracker
+
+_O_CREX = os.O_CREAT | os.O_EXCL
+
+# FreeBSD (and perhaps other BSDs) limit names to 14 characters.
+_SHM_SAFE_NAME_LENGTH = 14
+
+# Shared memory block name prefix
+if _USE_POSIX:
+ _SHM_NAME_PREFIX = '/psm_'
+else:
+ _SHM_NAME_PREFIX = 'wnsm_'
+
+
+def _make_filename():
+ "Create a random filename for the shared memory object."
+ # number of random bytes to use for name
+ nbytes = (_SHM_SAFE_NAME_LENGTH - len(_SHM_NAME_PREFIX)) // 2
+ assert nbytes >= 2, '_SHM_NAME_PREFIX too long'
+ name = _SHM_NAME_PREFIX + secrets.token_hex(nbytes)
+ assert len(name) <= _SHM_SAFE_NAME_LENGTH
+ return name
+
+
+class SharedMemory:
+ """Creates a new shared memory block or attaches to an existing
+ shared memory block.
+
+ Every shared memory block is assigned a unique name. This enables
+ one process to create a shared memory block with a particular name
+ so that a different process can attach to that same shared memory
+ block using that same name.
+
+ As a resource for sharing data across processes, shared memory blocks
+ may outlive the original process that created them. When one process
+ no longer needs access to a shared memory block that might still be
+ needed by other processes, the close() method should be called.
+ When a shared memory block is no longer needed by any process, the
+ unlink() method should be called to ensure proper cleanup."""
+
+ # Defaults; enables close() and unlink() to run without errors.
+ _name = None
+ _fd = -1
+ _mmap = None
+ _buf = None
+ _flags = os.O_RDWR
+ _mode = 0o600
+ _prepend_leading_slash = True if _USE_POSIX else False
+
+ def __init__(self, name=None, create=False, size=0):
+ if not size >= 0:
+ raise ValueError("'size' must be a positive integer")
+ if create:
+ self._flags = _O_CREX | os.O_RDWR
+ if size == 0:
+ raise ValueError("'size' must be a positive number different from zero")
+ if name is None and not self._flags & os.O_EXCL:
+ raise ValueError("'name' can only be None if create=True")
+
+ if _USE_POSIX:
+
+ # POSIX Shared Memory
+
+ if name is None:
+ while True:
+ name = _make_filename()
+ try:
+ self._fd = _posixshmem.shm_open(
+ name,
+ self._flags,
+ mode=self._mode
+ )
+ except FileExistsError:
+ continue
+ self._name = name
+ break
+ else:
+ name = "/" + name if self._prepend_leading_slash else name
+ self._fd = _posixshmem.shm_open(
+ name,
+ self._flags,
+ mode=self._mode
+ )
+ self._name = name
+ try:
+ if create and size:
+ os.ftruncate(self._fd, size)
+ stats = os.fstat(self._fd)
+ size = stats.st_size
+ self._mmap = mmap.mmap(self._fd, size)
+ except OSError:
+ self.unlink()
+ raise
+
+ resource_tracker.register(self._name, "shared_memory")
+
+ else:
+
+ # Windows Named Shared Memory
+
+ if create:
+ while True:
+ temp_name = _make_filename() if name is None else name
+ # Create and reserve shared memory block with this name
+ # until it can be attached to by mmap.
+ h_map = _winapi.CreateFileMapping(
+ _winapi.INVALID_HANDLE_VALUE,
+ _winapi.NULL,
+ _winapi.PAGE_READWRITE,
+ (size >> 32) & 0xFFFFFFFF,
+ size & 0xFFFFFFFF,
+ temp_name
+ )
+ try:
+ last_error_code = _winapi.GetLastError()
+ if last_error_code == _winapi.ERROR_ALREADY_EXISTS:
+ if name is not None:
+ raise FileExistsError(
+ errno.EEXIST,
+ os.strerror(errno.EEXIST),
+ name,
+ _winapi.ERROR_ALREADY_EXISTS
+ )
+ else:
+ continue
+ self._mmap = mmap.mmap(-1, size, tagname=temp_name)
+ finally:
+ _winapi.CloseHandle(h_map)
+ self._name = temp_name
+ break
+
+ else:
+ self._name = name
+ # Dynamically determine the existing named shared memory
+ # block's size which is likely a multiple of mmap.PAGESIZE.
+ h_map = _winapi.OpenFileMapping(
+ _winapi.FILE_MAP_READ,
+ False,
+ name
+ )
+ try:
+ p_buf = _winapi.MapViewOfFile(
+ h_map,
+ _winapi.FILE_MAP_READ,
+ 0,
+ 0,
+ 0
+ )
+ finally:
+ _winapi.CloseHandle(h_map)
+ try:
+ size = _winapi.VirtualQuerySize(p_buf)
+ finally:
+ _winapi.UnmapViewOfFile(p_buf)
+ self._mmap = mmap.mmap(-1, size, tagname=name)
+
+ self._size = size
+ self._buf = memoryview(self._mmap)
+
+ def __del__(self):
+ try:
+ self.close()
+ except OSError:
+ pass
+
+ def __reduce__(self):
+ return (
+ self.__class__,
+ (
+ self.name,
+ False,
+ self.size,
+ ),
+ )
+
+ def __repr__(self):
+ return f'{self.__class__.__name__}({self.name!r}, size={self.size})'
+
+ @property
+ def buf(self):
+ "A memoryview of contents of the shared memory block."
+ return self._buf
+
+ @property
+ def name(self):
+ "Unique name that identifies the shared memory block."
+ reported_name = self._name
+ if _USE_POSIX and self._prepend_leading_slash:
+ if self._name.startswith("/"):
+ reported_name = self._name[1:]
+ return reported_name
+
+ @property
+ def size(self):
+ "Size in bytes."
+ return self._size
+
+ def close(self):
+ """Closes access to the shared memory from this instance but does
+ not destroy the shared memory block."""
+ if self._buf is not None:
+ self._buf.release()
+ self._buf = None
+ if self._mmap is not None:
+ self._mmap.close()
+ self._mmap = None
+ if _USE_POSIX and self._fd >= 0:
+ os.close(self._fd)
+ self._fd = -1
+
+ def unlink(self):
+ """Requests that the underlying shared memory block be destroyed.
+
+ In order to ensure proper cleanup of resources, unlink should be
+ called once (and only once) across all processes which have access
+ to the shared memory block."""
+ if _USE_POSIX and self._name:
+ _posixshmem.shm_unlink(self._name)
+ resource_tracker.unregister(self._name, "shared_memory")
+
+
+_encoding = "utf8"
+
+class ShareableList:
+ """Pattern for a mutable list-like object shareable via a shared
+ memory block. It differs from the built-in list type in that these
+ lists can not change their overall length (i.e. no append, insert,
+ etc.)
+
+ Because values are packed into a memoryview as bytes, the struct
+ packing format for any storable value must require no more than 8
+ characters to describe its format."""
+
+ # The shared memory area is organized as follows:
+ # - 8 bytes: number of items (N) as a 64-bit integer
+ # - (N + 1) * 8 bytes: offsets of each element from the start of the
+ # data area
+ # - K bytes: the data area storing item values (with encoding and size
+ # depending on their respective types)
+ # - N * 8 bytes: `struct` format string for each element
+ # - N bytes: index into _back_transforms_mapping for each element
+ # (for reconstructing the corresponding Python value)
+ _types_mapping = {
+ int: "q",
+ float: "d",
+ bool: "xxxxxxx?",
+ str: "%ds",
+ bytes: "%ds",
+ None.__class__: "xxxxxx?x",
+ }
+ _alignment = 8
+ _back_transforms_mapping = {
+ 0: lambda value: value, # int, float, bool
+ 1: lambda value: value.rstrip(b'\x00').decode(_encoding), # str
+ 2: lambda value: value.rstrip(b'\x00'), # bytes
+ 3: lambda _value: None, # None
+ }
+
+ @staticmethod
+ def _extract_recreation_code(value):
+ """Used in concert with _back_transforms_mapping to convert values
+ into the appropriate Python objects when retrieving them from
+ the list as well as when storing them."""
+ if not isinstance(value, (str, bytes, None.__class__)):
+ return 0
+ elif isinstance(value, str):
+ return 1
+ elif isinstance(value, bytes):
+ return 2
+ else:
+ return 3 # NoneType
+
+ def __init__(self, sequence=None, *, name=None):
+ if name is None or sequence is not None:
+ sequence = sequence or ()
+ _formats = [
+ self._types_mapping[type(item)]
+ if not isinstance(item, (str, bytes))
+ else self._types_mapping[type(item)] % (
+ self._alignment * (len(item) // self._alignment + 1),
+ )
+ for item in sequence
+ ]
+ self._list_len = len(_formats)
+ assert sum(len(fmt) <= 8 for fmt in _formats) == self._list_len
+ offset = 0
+ # The offsets of each list element into the shared memory's
+ # data area (0 meaning the start of the data area, not the start
+ # of the shared memory area).
+ self._allocated_offsets = [0]
+ for fmt in _formats:
+ offset += self._alignment if fmt[-1] != "s" else int(fmt[:-1])
+ self._allocated_offsets.append(offset)
+ _recreation_codes = [
+ self._extract_recreation_code(item) for item in sequence
+ ]
+ requested_size = struct.calcsize(
+ "q" + self._format_size_metainfo +
+ "".join(_formats) +
+ self._format_packing_metainfo +
+ self._format_back_transform_codes
+ )
+
+ self.shm = SharedMemory(name, create=True, size=requested_size)
+ else:
+ self.shm = SharedMemory(name)
+
+ if sequence is not None:
+ _enc = _encoding
+ struct.pack_into(
+ "q" + self._format_size_metainfo,
+ self.shm.buf,
+ 0,
+ self._list_len,
+ *(self._allocated_offsets)
+ )
+ struct.pack_into(
+ "".join(_formats),
+ self.shm.buf,
+ self._offset_data_start,
+ *(v.encode(_enc) if isinstance(v, str) else v for v in sequence)
+ )
+ struct.pack_into(
+ self._format_packing_metainfo,
+ self.shm.buf,
+ self._offset_packing_formats,
+ *(v.encode(_enc) for v in _formats)
+ )
+ struct.pack_into(
+ self._format_back_transform_codes,
+ self.shm.buf,
+ self._offset_back_transform_codes,
+ *(_recreation_codes)
+ )
+
+ else:
+ self._list_len = len(self) # Obtains size from offset 0 in buffer.
+ self._allocated_offsets = list(
+ struct.unpack_from(
+ self._format_size_metainfo,
+ self.shm.buf,
+ 1 * 8
+ )
+ )
+
+ def _get_packing_format(self, position):
+ "Gets the packing format for a single value stored in the list."
+ position = position if position >= 0 else position + self._list_len
+ if (position >= self._list_len) or (self._list_len < 0):
+ raise IndexError("Requested position out of range.")
+
+ v = struct.unpack_from(
+ "8s",
+ self.shm.buf,
+ self._offset_packing_formats + position * 8
+ )[0]
+ fmt = v.rstrip(b'\x00')
+ fmt_as_str = fmt.decode(_encoding)
+
+ return fmt_as_str
+
+ def _get_back_transform(self, position):
+ "Gets the back transformation function for a single value."
+
+ if (position >= self._list_len) or (self._list_len < 0):
+ raise IndexError("Requested position out of range.")
+
+ transform_code = struct.unpack_from(
+ "b",
+ self.shm.buf,
+ self._offset_back_transform_codes + position
+ )[0]
+ transform_function = self._back_transforms_mapping[transform_code]
+
+ return transform_function
+
+ def _set_packing_format_and_transform(self, position, fmt_as_str, value):
+ """Sets the packing format and back transformation code for a
+ single value in the list at the specified position."""
+
+ if (position >= self._list_len) or (self._list_len < 0):
+ raise IndexError("Requested position out of range.")
+
+ struct.pack_into(
+ "8s",
+ self.shm.buf,
+ self._offset_packing_formats + position * 8,
+ fmt_as_str.encode(_encoding)
+ )
+
+ transform_code = self._extract_recreation_code(value)
+ struct.pack_into(
+ "b",
+ self.shm.buf,
+ self._offset_back_transform_codes + position,
+ transform_code
+ )
+
+ def __getitem__(self, position):
+ position = position if position >= 0 else position + self._list_len
+ try:
+ offset = self._offset_data_start + self._allocated_offsets[position]
+ (v,) = struct.unpack_from(
+ self._get_packing_format(position),
+ self.shm.buf,
+ offset
+ )
+ except IndexError:
+ raise IndexError("index out of range")
+
+ back_transform = self._get_back_transform(position)
+ v = back_transform(v)
+
+ return v
+
+ def __setitem__(self, position, value):
+ position = position if position >= 0 else position + self._list_len
+ try:
+ item_offset = self._allocated_offsets[position]
+ offset = self._offset_data_start + item_offset
+ current_format = self._get_packing_format(position)
+ except IndexError:
+ raise IndexError("assignment index out of range")
+
+ if not isinstance(value, (str, bytes)):
+ new_format = self._types_mapping[type(value)]
+ encoded_value = value
+ else:
+ allocated_length = self._allocated_offsets[position + 1] - item_offset
+
+ encoded_value = (value.encode(_encoding)
+ if isinstance(value, str) else value)
+ if len(encoded_value) > allocated_length:
+ raise ValueError("bytes/str item exceeds available storage")
+ if current_format[-1] == "s":
+ new_format = current_format
+ else:
+ new_format = self._types_mapping[str] % (
+ allocated_length,
+ )
+
+ self._set_packing_format_and_transform(
+ position,
+ new_format,
+ value
+ )
+ struct.pack_into(new_format, self.shm.buf, offset, encoded_value)
+
+ def __reduce__(self):
+ return partial(self.__class__, name=self.shm.name), ()
+
+ def __len__(self):
+ return struct.unpack_from("q", self.shm.buf, 0)[0]
+
+ def __repr__(self):
+ return f'{self.__class__.__name__}({list(self)}, name={self.shm.name!r})'
+
+ @property
+ def format(self):
+ "The struct packing format used by all currently stored items."
+ return "".join(
+ self._get_packing_format(i) for i in range(self._list_len)
+ )
+
+ @property
+ def _format_size_metainfo(self):
+ "The struct packing format used for the items' storage offsets."
+ return "q" * (self._list_len + 1)
+
+ @property
+ def _format_packing_metainfo(self):
+ "The struct packing format used for the items' packing formats."
+ return "8s" * self._list_len
+
+ @property
+ def _format_back_transform_codes(self):
+ "The struct packing format used for the items' back transforms."
+ return "b" * self._list_len
+
+ @property
+ def _offset_data_start(self):
+ # - 8 bytes for the list length
+ # - (N + 1) * 8 bytes for the element offsets
+ return (self._list_len + 2) * 8
+
+ @property
+ def _offset_packing_formats(self):
+ return self._offset_data_start + self._allocated_offsets[-1]
+
+ @property
+ def _offset_back_transform_codes(self):
+ return self._offset_packing_formats + self._list_len * 8
+
+ def count(self, value):
+ "L.count(value) -> integer -- return number of occurrences of value."
+
+ return sum(value == entry for entry in self)
+
+ def index(self, value):
+ """L.index(value) -> integer -- return first index of value.
+ Raises ValueError if the value is not present."""
+
+ for position, entry in enumerate(self):
+ if value == entry:
+ return position
+ else:
+ raise ValueError(f"{value!r} not in this container")
+
+ __class_getitem__ = classmethod(types.GenericAlias)
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/sharedctypes.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/sharedctypes.py
new file mode 100644
index 0000000000000000000000000000000000000000..6071707027bea46dccfc4d92fb3195060faf07ce
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/sharedctypes.py
@@ -0,0 +1,240 @@
+#
+# Module which supports allocation of ctypes objects from shared memory
+#
+# multiprocessing/sharedctypes.py
+#
+# Copyright (c) 2006-2008, R Oudkerk
+# Licensed to PSF under a Contributor Agreement.
+#
+
+import ctypes
+import weakref
+
+from . import heap
+from . import get_context
+
+from .context import reduction, assert_spawning
+_ForkingPickler = reduction.ForkingPickler
+
+__all__ = ['RawValue', 'RawArray', 'Value', 'Array', 'copy', 'synchronized']
+
+#
+#
+#
+
+typecode_to_type = {
+ 'c': ctypes.c_char, 'u': ctypes.c_wchar,
+ 'b': ctypes.c_byte, 'B': ctypes.c_ubyte,
+ 'h': ctypes.c_short, 'H': ctypes.c_ushort,
+ 'i': ctypes.c_int, 'I': ctypes.c_uint,
+ 'l': ctypes.c_long, 'L': ctypes.c_ulong,
+ 'q': ctypes.c_longlong, 'Q': ctypes.c_ulonglong,
+ 'f': ctypes.c_float, 'd': ctypes.c_double
+ }
+
+#
+#
+#
+
+def _new_value(type_):
+ size = ctypes.sizeof(type_)
+ wrapper = heap.BufferWrapper(size)
+ return rebuild_ctype(type_, wrapper, None)
+
+def RawValue(typecode_or_type, *args):
+ '''
+ Returns a ctypes object allocated from shared memory
+ '''
+ type_ = typecode_to_type.get(typecode_or_type, typecode_or_type)
+ obj = _new_value(type_)
+ ctypes.memset(ctypes.addressof(obj), 0, ctypes.sizeof(obj))
+ obj.__init__(*args)
+ return obj
+
+def RawArray(typecode_or_type, size_or_initializer):
+ '''
+ Returns a ctypes array allocated from shared memory
+ '''
+ type_ = typecode_to_type.get(typecode_or_type, typecode_or_type)
+ if isinstance(size_or_initializer, int):
+ type_ = type_ * size_or_initializer
+ obj = _new_value(type_)
+ ctypes.memset(ctypes.addressof(obj), 0, ctypes.sizeof(obj))
+ return obj
+ else:
+ type_ = type_ * len(size_or_initializer)
+ result = _new_value(type_)
+ result.__init__(*size_or_initializer)
+ return result
+
+def Value(typecode_or_type, *args, lock=True, ctx=None):
+ '''
+ Return a synchronization wrapper for a Value
+ '''
+ obj = RawValue(typecode_or_type, *args)
+ if lock is False:
+ return obj
+ if lock in (True, None):
+ ctx = ctx or get_context()
+ lock = ctx.RLock()
+ if not hasattr(lock, 'acquire'):
+ raise AttributeError("%r has no method 'acquire'" % lock)
+ return synchronized(obj, lock, ctx=ctx)
+
+def Array(typecode_or_type, size_or_initializer, *, lock=True, ctx=None):
+ '''
+ Return a synchronization wrapper for a RawArray
+ '''
+ obj = RawArray(typecode_or_type, size_or_initializer)
+ if lock is False:
+ return obj
+ if lock in (True, None):
+ ctx = ctx or get_context()
+ lock = ctx.RLock()
+ if not hasattr(lock, 'acquire'):
+ raise AttributeError("%r has no method 'acquire'" % lock)
+ return synchronized(obj, lock, ctx=ctx)
+
+def copy(obj):
+ new_obj = _new_value(type(obj))
+ ctypes.pointer(new_obj)[0] = obj
+ return new_obj
+
+def synchronized(obj, lock=None, ctx=None):
+ assert not isinstance(obj, SynchronizedBase), 'object already synchronized'
+ ctx = ctx or get_context()
+
+ if isinstance(obj, ctypes._SimpleCData):
+ return Synchronized(obj, lock, ctx)
+ elif isinstance(obj, ctypes.Array):
+ if obj._type_ is ctypes.c_char:
+ return SynchronizedString(obj, lock, ctx)
+ return SynchronizedArray(obj, lock, ctx)
+ else:
+ cls = type(obj)
+ try:
+ scls = class_cache[cls]
+ except KeyError:
+ names = [field[0] for field in cls._fields_]
+ d = {name: make_property(name) for name in names}
+ classname = 'Synchronized' + cls.__name__
+ scls = class_cache[cls] = type(classname, (SynchronizedBase,), d)
+ return scls(obj, lock, ctx)
+
+#
+# Functions for pickling/unpickling
+#
+
+def reduce_ctype(obj):
+ assert_spawning(obj)
+ if isinstance(obj, ctypes.Array):
+ return rebuild_ctype, (obj._type_, obj._wrapper, obj._length_)
+ else:
+ return rebuild_ctype, (type(obj), obj._wrapper, None)
+
+def rebuild_ctype(type_, wrapper, length):
+ if length is not None:
+ type_ = type_ * length
+ _ForkingPickler.register(type_, reduce_ctype)
+ buf = wrapper.create_memoryview()
+ obj = type_.from_buffer(buf)
+ obj._wrapper = wrapper
+ return obj
+
+#
+# Function to create properties
+#
+
+def make_property(name):
+ try:
+ return prop_cache[name]
+ except KeyError:
+ d = {}
+ exec(template % ((name,)*7), d)
+ prop_cache[name] = d[name]
+ return d[name]
+
+template = '''
+def get%s(self):
+ self.acquire()
+ try:
+ return self._obj.%s
+ finally:
+ self.release()
+def set%s(self, value):
+ self.acquire()
+ try:
+ self._obj.%s = value
+ finally:
+ self.release()
+%s = property(get%s, set%s)
+'''
+
+prop_cache = {}
+class_cache = weakref.WeakKeyDictionary()
+
+#
+# Synchronized wrappers
+#
+
+class SynchronizedBase(object):
+
+ def __init__(self, obj, lock=None, ctx=None):
+ self._obj = obj
+ if lock:
+ self._lock = lock
+ else:
+ ctx = ctx or get_context(force=True)
+ self._lock = ctx.RLock()
+ self.acquire = self._lock.acquire
+ self.release = self._lock.release
+
+ def __enter__(self):
+ return self._lock.__enter__()
+
+ def __exit__(self, *args):
+ return self._lock.__exit__(*args)
+
+ def __reduce__(self):
+ assert_spawning(self)
+ return synchronized, (self._obj, self._lock)
+
+ def get_obj(self):
+ return self._obj
+
+ def get_lock(self):
+ return self._lock
+
+ def __repr__(self):
+ return '<%s wrapper for %s>' % (type(self).__name__, self._obj)
+
+
+class Synchronized(SynchronizedBase):
+ value = make_property('value')
+
+
+class SynchronizedArray(SynchronizedBase):
+
+ def __len__(self):
+ return len(self._obj)
+
+ def __getitem__(self, i):
+ with self:
+ return self._obj[i]
+
+ def __setitem__(self, i, value):
+ with self:
+ self._obj[i] = value
+
+ def __getslice__(self, start, stop):
+ with self:
+ return self._obj[start:stop]
+
+ def __setslice__(self, start, stop, values):
+ with self:
+ self._obj[start:stop] = values
+
+
+class SynchronizedString(SynchronizedArray):
+ value = make_property('value')
+ raw = make_property('raw')
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/spawn.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/spawn.py
new file mode 100644
index 0000000000000000000000000000000000000000..ba67e79b6d83665257c6ff07fbdfc3c7ef6589f7
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/spawn.py
@@ -0,0 +1,307 @@
+#
+# Code used to start processes when using the spawn or forkserver
+# start methods.
+#
+# multiprocessing/spawn.py
+#
+# Copyright (c) 2006-2008, R Oudkerk
+# Licensed to PSF under a Contributor Agreement.
+#
+
+import os
+import sys
+import runpy
+import types
+
+from . import get_start_method, set_start_method
+from . import process
+from .context import reduction
+from . import util
+
+__all__ = ['_main', 'freeze_support', 'set_executable', 'get_executable',
+ 'get_preparation_data', 'get_command_line', 'import_main_path']
+
+#
+# _python_exe is the assumed path to the python executable.
+# People embedding Python want to modify it.
+#
+
+if sys.platform != 'win32':
+ WINEXE = False
+ WINSERVICE = False
+else:
+ WINEXE = getattr(sys, 'frozen', False)
+ WINSERVICE = sys.executable and sys.executable.lower().endswith("pythonservice.exe")
+
+def set_executable(exe):
+ global _python_exe
+ if exe is None:
+ _python_exe = exe
+ elif sys.platform == 'win32':
+ _python_exe = os.fsdecode(exe)
+ else:
+ _python_exe = os.fsencode(exe)
+
+def get_executable():
+ return _python_exe
+
+if WINSERVICE:
+ set_executable(os.path.join(sys.exec_prefix, 'python.exe'))
+else:
+ set_executable(sys.executable)
+
+#
+#
+#
+
+def is_forking(argv):
+ '''
+ Return whether commandline indicates we are forking
+ '''
+ if len(argv) >= 2 and argv[1] == '--multiprocessing-fork':
+ return True
+ else:
+ return False
+
+
+def freeze_support():
+ '''
+ Run code for process object if this in not the main process
+ '''
+ if is_forking(sys.argv):
+ kwds = {}
+ for arg in sys.argv[2:]:
+ name, value = arg.split('=')
+ if value == 'None':
+ kwds[name] = None
+ else:
+ kwds[name] = int(value)
+ spawn_main(**kwds)
+ sys.exit()
+
+
+def get_command_line(**kwds):
+ '''
+ Returns prefix of command line used for spawning a child process
+ '''
+ if getattr(sys, 'frozen', False):
+ return ([sys.executable, '--multiprocessing-fork'] +
+ ['%s=%r' % item for item in kwds.items()])
+ else:
+ prog = 'from multiprocess.spawn import spawn_main; spawn_main(%s)'
+ prog %= ', '.join('%s=%r' % item for item in kwds.items())
+ opts = util._args_from_interpreter_flags()
+ exe = get_executable()
+ return [exe] + opts + ['-c', prog, '--multiprocessing-fork']
+
+
+def spawn_main(pipe_handle, parent_pid=None, tracker_fd=None):
+ '''
+ Run code specified by data received over pipe
+ '''
+ assert is_forking(sys.argv), "Not forking"
+ if sys.platform == 'win32':
+ import msvcrt
+ import _winapi
+
+ if parent_pid is not None:
+ source_process = _winapi.OpenProcess(
+ _winapi.SYNCHRONIZE | _winapi.PROCESS_DUP_HANDLE,
+ False, parent_pid)
+ else:
+ source_process = None
+ new_handle = reduction.duplicate(pipe_handle,
+ source_process=source_process)
+ fd = msvcrt.open_osfhandle(new_handle, os.O_RDONLY)
+ parent_sentinel = source_process
+ else:
+ from . import resource_tracker
+ resource_tracker._resource_tracker._fd = tracker_fd
+ fd = pipe_handle
+ parent_sentinel = os.dup(pipe_handle)
+ exitcode = _main(fd, parent_sentinel)
+ sys.exit(exitcode)
+
+
+def _main(fd, parent_sentinel):
+ with os.fdopen(fd, 'rb', closefd=True) as from_parent:
+ process.current_process()._inheriting = True
+ try:
+ preparation_data = reduction.pickle.load(from_parent)
+ prepare(preparation_data)
+ self = reduction.pickle.load(from_parent)
+ finally:
+ del process.current_process()._inheriting
+ return self._bootstrap(parent_sentinel)
+
+
+def _check_not_importing_main():
+ if getattr(process.current_process(), '_inheriting', False):
+ raise RuntimeError('''
+ An attempt has been made to start a new process before the
+ current process has finished its bootstrapping phase.
+
+ This probably means that you are not using fork to start your
+ child processes and you have forgotten to use the proper idiom
+ in the main module:
+
+ if __name__ == '__main__':
+ freeze_support()
+ ...
+
+ The "freeze_support()" line can be omitted if the program
+ is not going to be frozen to produce an executable.
+
+ To fix this issue, refer to the "Safe importing of main module"
+ section in https://docs.python.org/3/library/multiprocessing.html
+ ''')
+
+
+def get_preparation_data(name):
+ '''
+ Return info about parent needed by child to unpickle process object
+ '''
+ _check_not_importing_main()
+ d = dict(
+ log_to_stderr=util._log_to_stderr,
+ authkey=process.current_process().authkey,
+ )
+
+ if util._logger is not None:
+ d['log_level'] = util._logger.getEffectiveLevel()
+
+ sys_path=sys.path.copy()
+ try:
+ i = sys_path.index('')
+ except ValueError:
+ pass
+ else:
+ sys_path[i] = process.ORIGINAL_DIR
+
+ d.update(
+ name=name,
+ sys_path=sys_path,
+ sys_argv=sys.argv,
+ orig_dir=process.ORIGINAL_DIR,
+ dir=os.getcwd(),
+ start_method=get_start_method(),
+ )
+
+ # Figure out whether to initialise main in the subprocess as a module
+ # or through direct execution (or to leave it alone entirely)
+ main_module = sys.modules['__main__']
+ main_mod_name = getattr(main_module.__spec__, "name", None)
+ if main_mod_name is not None:
+ d['init_main_from_name'] = main_mod_name
+ elif sys.platform != 'win32' or (not WINEXE and not WINSERVICE):
+ main_path = getattr(main_module, '__file__', None)
+ if main_path is not None:
+ if (not os.path.isabs(main_path) and
+ process.ORIGINAL_DIR is not None):
+ main_path = os.path.join(process.ORIGINAL_DIR, main_path)
+ d['init_main_from_path'] = os.path.normpath(main_path)
+
+ return d
+
+#
+# Prepare current process
+#
+
+old_main_modules = []
+
+def prepare(data):
+ '''
+ Try to get current process ready to unpickle process object
+ '''
+ if 'name' in data:
+ process.current_process().name = data['name']
+
+ if 'authkey' in data:
+ process.current_process().authkey = data['authkey']
+
+ if 'log_to_stderr' in data and data['log_to_stderr']:
+ util.log_to_stderr()
+
+ if 'log_level' in data:
+ util.get_logger().setLevel(data['log_level'])
+
+ if 'sys_path' in data:
+ sys.path = data['sys_path']
+
+ if 'sys_argv' in data:
+ sys.argv = data['sys_argv']
+
+ if 'dir' in data:
+ os.chdir(data['dir'])
+
+ if 'orig_dir' in data:
+ process.ORIGINAL_DIR = data['orig_dir']
+
+ if 'start_method' in data:
+ set_start_method(data['start_method'], force=True)
+
+ if 'init_main_from_name' in data:
+ _fixup_main_from_name(data['init_main_from_name'])
+ elif 'init_main_from_path' in data:
+ _fixup_main_from_path(data['init_main_from_path'])
+
+# Multiprocessing module helpers to fix up the main module in
+# spawned subprocesses
+def _fixup_main_from_name(mod_name):
+ # __main__.py files for packages, directories, zip archives, etc, run
+ # their "main only" code unconditionally, so we don't even try to
+ # populate anything in __main__, nor do we make any changes to
+ # __main__ attributes
+ current_main = sys.modules['__main__']
+ if mod_name == "__main__" or mod_name.endswith(".__main__"):
+ return
+
+ # If this process was forked, __main__ may already be populated
+ if getattr(current_main.__spec__, "name", None) == mod_name:
+ return
+
+ # Otherwise, __main__ may contain some non-main code where we need to
+ # support unpickling it properly. We rerun it as __mp_main__ and make
+ # the normal __main__ an alias to that
+ old_main_modules.append(current_main)
+ main_module = types.ModuleType("__mp_main__")
+ main_content = runpy.run_module(mod_name,
+ run_name="__mp_main__",
+ alter_sys=True)
+ main_module.__dict__.update(main_content)
+ sys.modules['__main__'] = sys.modules['__mp_main__'] = main_module
+
+
+def _fixup_main_from_path(main_path):
+ # If this process was forked, __main__ may already be populated
+ current_main = sys.modules['__main__']
+
+ # Unfortunately, the main ipython launch script historically had no
+ # "if __name__ == '__main__'" guard, so we work around that
+ # by treating it like a __main__.py file
+ # See https://github.com/ipython/ipython/issues/4698
+ main_name = os.path.splitext(os.path.basename(main_path))[0]
+ if main_name == 'ipython':
+ return
+
+ # Otherwise, if __file__ already has the setting we expect,
+ # there's nothing more to do
+ if getattr(current_main, '__file__', None) == main_path:
+ return
+
+ # If the parent process has sent a path through rather than a module
+ # name we assume it is an executable script that may contain
+ # non-main code that needs to be executed
+ old_main_modules.append(current_main)
+ main_module = types.ModuleType("__mp_main__")
+ main_content = runpy.run_path(main_path,
+ run_name="__mp_main__")
+ main_module.__dict__.update(main_content)
+ sys.modules['__main__'] = sys.modules['__mp_main__'] = main_module
+
+
+def import_main_path(main_path):
+ '''
+ Set sys.modules['__main__'] to module at main_path
+ '''
+ _fixup_main_from_path(main_path)
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/synchronize.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/synchronize.py
new file mode 100644
index 0000000000000000000000000000000000000000..0c978d836d9a81d97f95e7f0c8fc809a4286529b
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/synchronize.py
@@ -0,0 +1,410 @@
+#
+# Module implementing synchronization primitives
+#
+# multiprocessing/synchronize.py
+#
+# Copyright (c) 2006-2008, R Oudkerk
+# Licensed to PSF under a Contributor Agreement.
+#
+
+__all__ = [
+ 'Lock', 'RLock', 'Semaphore', 'BoundedSemaphore', 'Condition', 'Event'
+ ]
+
+import threading
+import sys
+import tempfile
+try:
+ import _multiprocess as _multiprocessing
+except ImportError:
+ import _multiprocessing
+import time
+
+from . import context
+from . import process
+from . import util
+
+# Try to import the mp.synchronize module cleanly, if it fails
+# raise ImportError for platforms lacking a working sem_open implementation.
+# See issue 3770
+try:
+ from _multiprocess import SemLock, sem_unlink
+except ImportError:
+ try:
+ from _multiprocessing import SemLock, sem_unlink
+ except (ImportError):
+ raise ImportError("This platform lacks a functioning sem_open" +
+ " implementation, therefore, the required" +
+ " synchronization primitives needed will not" +
+ " function, see issue 3770.")
+
+#
+# Constants
+#
+
+RECURSIVE_MUTEX, SEMAPHORE = list(range(2))
+SEM_VALUE_MAX = _multiprocessing.SemLock.SEM_VALUE_MAX
+
+#
+# Base class for semaphores and mutexes; wraps `_multiprocessing.SemLock`
+#
+
+class SemLock(object):
+
+ _rand = tempfile._RandomNameSequence()
+
+ def __init__(self, kind, value, maxvalue, *, ctx):
+ if ctx is None:
+ ctx = context._default_context.get_context()
+ self._is_fork_ctx = ctx.get_start_method() == 'fork'
+ unlink_now = sys.platform == 'win32' or self._is_fork_ctx
+ for i in range(100):
+ try:
+ sl = self._semlock = _multiprocessing.SemLock(
+ kind, value, maxvalue, self._make_name(),
+ unlink_now)
+ except FileExistsError:
+ pass
+ else:
+ break
+ else:
+ raise FileExistsError('cannot find name for semaphore')
+
+ util.debug('created semlock with handle %s' % sl.handle)
+ self._make_methods()
+
+ if sys.platform != 'win32':
+ def _after_fork(obj):
+ obj._semlock._after_fork()
+ util.register_after_fork(self, _after_fork)
+
+ if self._semlock.name is not None:
+ # We only get here if we are on Unix with forking
+ # disabled. When the object is garbage collected or the
+ # process shuts down we unlink the semaphore name
+ from .resource_tracker import register
+ register(self._semlock.name, "semaphore")
+ util.Finalize(self, SemLock._cleanup, (self._semlock.name,),
+ exitpriority=0)
+
+ @staticmethod
+ def _cleanup(name):
+ from .resource_tracker import unregister
+ sem_unlink(name)
+ unregister(name, "semaphore")
+
+ def _make_methods(self):
+ self.acquire = self._semlock.acquire
+ self.release = self._semlock.release
+
+ def __enter__(self):
+ return self._semlock.__enter__()
+
+ def __exit__(self, *args):
+ return self._semlock.__exit__(*args)
+
+ def __getstate__(self):
+ context.assert_spawning(self)
+ sl = self._semlock
+ if sys.platform == 'win32':
+ h = context.get_spawning_popen().duplicate_for_child(sl.handle)
+ else:
+ if self._is_fork_ctx:
+ raise RuntimeError('A SemLock created in a fork context is being '
+ 'shared with a process in a spawn context. This is '
+ 'not supported. Please use the same context to create '
+ 'multiprocess objects and Process.')
+ h = sl.handle
+ return (h, sl.kind, sl.maxvalue, sl.name)
+
+ def __setstate__(self, state):
+ self._semlock = _multiprocessing.SemLock._rebuild(*state)
+ util.debug('recreated blocker with handle %r' % state[0])
+ self._make_methods()
+ # Ensure that deserialized SemLock can be serialized again (gh-108520).
+ self._is_fork_ctx = False
+
+ @staticmethod
+ def _make_name():
+ return '%s-%s' % (process.current_process()._config['semprefix'],
+ next(SemLock._rand))
+
+#
+# Semaphore
+#
+
+class Semaphore(SemLock):
+
+ def __init__(self, value=1, *, ctx):
+ SemLock.__init__(self, SEMAPHORE, value, SEM_VALUE_MAX, ctx=ctx)
+
+ def get_value(self):
+ return self._semlock._get_value()
+
+ def __repr__(self):
+ try:
+ value = self._semlock._get_value()
+ except Exception:
+ value = 'unknown'
+ return '<%s(value=%s)>' % (self.__class__.__name__, value)
+
+#
+# Bounded semaphore
+#
+
+class BoundedSemaphore(Semaphore):
+
+ def __init__(self, value=1, *, ctx):
+ SemLock.__init__(self, SEMAPHORE, value, value, ctx=ctx)
+
+ def __repr__(self):
+ try:
+ value = self._semlock._get_value()
+ except Exception:
+ value = 'unknown'
+ return '<%s(value=%s, maxvalue=%s)>' % \
+ (self.__class__.__name__, value, self._semlock.maxvalue)
+
+#
+# Non-recursive lock
+#
+
+class Lock(SemLock):
+
+ def __init__(self, *, ctx):
+ SemLock.__init__(self, SEMAPHORE, 1, 1, ctx=ctx)
+
+ def __repr__(self):
+ try:
+ if self._semlock._is_mine():
+ name = process.current_process().name
+ if threading.current_thread().name != 'MainThread':
+ name += '|' + threading.current_thread().name
+ elif self._semlock._get_value() == 1:
+ name = 'None'
+ elif self._semlock._count() > 0:
+ name = 'SomeOtherThread'
+ else:
+ name = 'SomeOtherProcess'
+ except Exception:
+ name = 'unknown'
+ return '<%s(owner=%s)>' % (self.__class__.__name__, name)
+
+#
+# Recursive lock
+#
+
+class RLock(SemLock):
+
+ def __init__(self, *, ctx):
+ SemLock.__init__(self, RECURSIVE_MUTEX, 1, 1, ctx=ctx)
+
+ def __repr__(self):
+ try:
+ if self._semlock._is_mine():
+ name = process.current_process().name
+ if threading.current_thread().name != 'MainThread':
+ name += '|' + threading.current_thread().name
+ count = self._semlock._count()
+ elif self._semlock._get_value() == 1:
+ name, count = 'None', 0
+ elif self._semlock._count() > 0:
+ name, count = 'SomeOtherThread', 'nonzero'
+ else:
+ name, count = 'SomeOtherProcess', 'nonzero'
+ except Exception:
+ name, count = 'unknown', 'unknown'
+ return '<%s(%s, %s)>' % (self.__class__.__name__, name, count)
+
+#
+# Condition variable
+#
+
+class Condition(object):
+
+ def __init__(self, lock=None, *, ctx):
+ self._lock = lock or ctx.RLock()
+ self._sleeping_count = ctx.Semaphore(0)
+ self._woken_count = ctx.Semaphore(0)
+ self._wait_semaphore = ctx.Semaphore(0)
+ self._make_methods()
+
+ def __getstate__(self):
+ context.assert_spawning(self)
+ return (self._lock, self._sleeping_count,
+ self._woken_count, self._wait_semaphore)
+
+ def __setstate__(self, state):
+ (self._lock, self._sleeping_count,
+ self._woken_count, self._wait_semaphore) = state
+ self._make_methods()
+
+ def __enter__(self):
+ return self._lock.__enter__()
+
+ def __exit__(self, *args):
+ return self._lock.__exit__(*args)
+
+ def _make_methods(self):
+ self.acquire = self._lock.acquire
+ self.release = self._lock.release
+
+ def __repr__(self):
+ try:
+ num_waiters = (self._sleeping_count._semlock._get_value() -
+ self._woken_count._semlock._get_value())
+ except Exception:
+ num_waiters = 'unknown'
+ return '<%s(%s, %s)>' % (self.__class__.__name__, self._lock, num_waiters)
+
+ def wait(self, timeout=None):
+ assert self._lock._semlock._is_mine(), \
+ 'must acquire() condition before using wait()'
+
+ # indicate that this thread is going to sleep
+ self._sleeping_count.release()
+
+ # release lock
+ count = self._lock._semlock._count()
+ for i in range(count):
+ self._lock.release()
+
+ try:
+ # wait for notification or timeout
+ return self._wait_semaphore.acquire(True, timeout)
+ finally:
+ # indicate that this thread has woken
+ self._woken_count.release()
+
+ # reacquire lock
+ for i in range(count):
+ self._lock.acquire()
+
+ def notify(self, n=1):
+ assert self._lock._semlock._is_mine(), 'lock is not owned'
+ assert not self._wait_semaphore.acquire(
+ False), ('notify: Should not have been able to acquire '
+ + '_wait_semaphore')
+
+ # to take account of timeouts since last notify*() we subtract
+ # woken_count from sleeping_count and rezero woken_count
+ while self._woken_count.acquire(False):
+ res = self._sleeping_count.acquire(False)
+ assert res, ('notify: Bug in sleeping_count.acquire'
+ + '- res should not be False')
+
+ sleepers = 0
+ while sleepers < n and self._sleeping_count.acquire(False):
+ self._wait_semaphore.release() # wake up one sleeper
+ sleepers += 1
+
+ if sleepers:
+ for i in range(sleepers):
+ self._woken_count.acquire() # wait for a sleeper to wake
+
+ # rezero wait_semaphore in case some timeouts just happened
+ while self._wait_semaphore.acquire(False):
+ pass
+
+ def notify_all(self):
+ self.notify(n=sys.maxsize)
+
+ def wait_for(self, predicate, timeout=None):
+ result = predicate()
+ if result:
+ return result
+ if timeout is not None:
+ endtime = getattr(time,'monotonic',time.time)() + timeout
+ else:
+ endtime = None
+ waittime = None
+ while not result:
+ if endtime is not None:
+ waittime = endtime - getattr(time,'monotonic',time.time)()
+ if waittime <= 0:
+ break
+ self.wait(waittime)
+ result = predicate()
+ return result
+
+#
+# Event
+#
+
+class Event(object):
+
+ def __init__(self, *, ctx):
+ self._cond = ctx.Condition(ctx.Lock())
+ self._flag = ctx.Semaphore(0)
+
+ def is_set(self):
+ with self._cond:
+ if self._flag.acquire(False):
+ self._flag.release()
+ return True
+ return False
+
+ def set(self):
+ with self._cond:
+ self._flag.acquire(False)
+ self._flag.release()
+ self._cond.notify_all()
+
+ def clear(self):
+ with self._cond:
+ self._flag.acquire(False)
+
+ def wait(self, timeout=None):
+ with self._cond:
+ if self._flag.acquire(False):
+ self._flag.release()
+ else:
+ self._cond.wait(timeout)
+
+ if self._flag.acquire(False):
+ self._flag.release()
+ return True
+ return False
+
+ def __repr__(self) -> str:
+ set_status = 'set' if self.is_set() else 'unset'
+ return f"<{type(self).__qualname__} at {id(self):#x} {set_status}>"
+#
+# Barrier
+#
+
+class Barrier(threading.Barrier):
+
+ def __init__(self, parties, action=None, timeout=None, *, ctx):
+ import struct
+ from .heap import BufferWrapper
+ wrapper = BufferWrapper(struct.calcsize('i') * 2)
+ cond = ctx.Condition()
+ self.__setstate__((parties, action, timeout, cond, wrapper))
+ self._state = 0
+ self._count = 0
+
+ def __setstate__(self, state):
+ (self._parties, self._action, self._timeout,
+ self._cond, self._wrapper) = state
+ self._array = self._wrapper.create_memoryview().cast('i')
+
+ def __getstate__(self):
+ return (self._parties, self._action, self._timeout,
+ self._cond, self._wrapper)
+
+ @property
+ def _state(self):
+ return self._array[0]
+
+ @_state.setter
+ def _state(self, value):
+ self._array[0] = value
+
+ @property
+ def _count(self):
+ return self._array[1]
+
+ @_count.setter
+ def _count(self, value):
+ self._array[1] = value
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/util.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/util.py
new file mode 100644
index 0000000000000000000000000000000000000000..d24182b579bc23ec50bfd83244ea28a27c945dd3
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/multiprocess/util.py
@@ -0,0 +1,491 @@
+#
+# Module providing various facilities to other parts of the package
+#
+# multiprocessing/util.py
+#
+# Copyright (c) 2006-2008, R Oudkerk
+# Licensed to PSF under a Contributor Agreement.
+#
+
+import os
+import itertools
+import sys
+import weakref
+import atexit
+import threading # we want threading to install it's
+ # cleanup function before multiprocessing does
+from subprocess import _args_from_interpreter_flags
+
+from . import process
+
+__all__ = [
+ 'sub_debug', 'debug', 'info', 'sub_warning', 'get_logger',
+ 'log_to_stderr', 'get_temp_dir', 'register_after_fork',
+ 'is_exiting', 'Finalize', 'ForkAwareThreadLock', 'ForkAwareLocal',
+ 'close_all_fds_except', 'SUBDEBUG', 'SUBWARNING',
+ ]
+
+#
+# Logging
+#
+
+NOTSET = 0
+SUBDEBUG = 5
+DEBUG = 10
+INFO = 20
+SUBWARNING = 25
+
+LOGGER_NAME = 'multiprocess'
+DEFAULT_LOGGING_FORMAT = '[%(levelname)s/%(processName)s] %(message)s'
+
+_logger = None
+_log_to_stderr = False
+
+def sub_debug(msg, *args):
+ if _logger:
+ _logger.log(SUBDEBUG, msg, *args)
+
+def debug(msg, *args):
+ if _logger:
+ _logger.log(DEBUG, msg, *args)
+
+def info(msg, *args):
+ if _logger:
+ _logger.log(INFO, msg, *args)
+
+def sub_warning(msg, *args):
+ if _logger:
+ _logger.log(SUBWARNING, msg, *args)
+
+def get_logger():
+ '''
+ Returns logger used by multiprocess
+ '''
+ global _logger
+ import logging
+
+ logging._acquireLock()
+ try:
+ if not _logger:
+
+ _logger = logging.getLogger(LOGGER_NAME)
+ _logger.propagate = 0
+
+ # XXX multiprocessing should cleanup before logging
+ if hasattr(atexit, 'unregister'):
+ atexit.unregister(_exit_function)
+ atexit.register(_exit_function)
+ else:
+ atexit._exithandlers.remove((_exit_function, (), {}))
+ atexit._exithandlers.append((_exit_function, (), {}))
+
+ finally:
+ logging._releaseLock()
+
+ return _logger
+
+def log_to_stderr(level=None):
+ '''
+ Turn on logging and add a handler which prints to stderr
+ '''
+ global _log_to_stderr
+ import logging
+
+ logger = get_logger()
+ formatter = logging.Formatter(DEFAULT_LOGGING_FORMAT)
+ handler = logging.StreamHandler()
+ handler.setFormatter(formatter)
+ logger.addHandler(handler)
+
+ if level:
+ logger.setLevel(level)
+ _log_to_stderr = True
+ return _logger
+
+
+# Abstract socket support
+
+def _platform_supports_abstract_sockets():
+ if sys.platform == "linux":
+ return True
+ if hasattr(sys, 'getandroidapilevel'):
+ return True
+ return False
+
+
+def is_abstract_socket_namespace(address):
+ if not address:
+ return False
+ if isinstance(address, bytes):
+ return address[0] == 0
+ elif isinstance(address, str):
+ return address[0] == "\0"
+ raise TypeError(f'address type of {address!r} unrecognized')
+
+
+abstract_sockets_supported = _platform_supports_abstract_sockets()
+
+#
+# Function returning a temp directory which will be removed on exit
+#
+
+def _remove_temp_dir(rmtree, tempdir):
+ rmtree(tempdir)
+
+ current_process = process.current_process()
+ # current_process() can be None if the finalizer is called
+ # late during Python finalization
+ if current_process is not None:
+ current_process._config['tempdir'] = None
+
+def get_temp_dir():
+ # get name of a temp directory which will be automatically cleaned up
+ tempdir = process.current_process()._config.get('tempdir')
+ if tempdir is None:
+ import shutil, tempfile
+ tempdir = tempfile.mkdtemp(prefix='pymp-')
+ info('created temp directory %s', tempdir)
+ # keep a strong reference to shutil.rmtree(), since the finalizer
+ # can be called late during Python shutdown
+ Finalize(None, _remove_temp_dir, args=(shutil.rmtree, tempdir),
+ exitpriority=-100)
+ process.current_process()._config['tempdir'] = tempdir
+ return tempdir
+
+#
+# Support for reinitialization of objects when bootstrapping a child process
+#
+
+_afterfork_registry = weakref.WeakValueDictionary()
+_afterfork_counter = itertools.count()
+
+def _run_after_forkers():
+ items = list(_afterfork_registry.items())
+ items.sort()
+ for (index, ident, func), obj in items:
+ try:
+ func(obj)
+ except Exception as e:
+ info('after forker raised exception %s', e)
+
+def register_after_fork(obj, func):
+ _afterfork_registry[(next(_afterfork_counter), id(obj), func)] = obj
+
+#
+# Finalization using weakrefs
+#
+
+_finalizer_registry = {}
+_finalizer_counter = itertools.count()
+
+
+class Finalize(object):
+ '''
+ Class which supports object finalization using weakrefs
+ '''
+ def __init__(self, obj, callback, args=(), kwargs=None, exitpriority=None):
+ if (exitpriority is not None) and not isinstance(exitpriority,int):
+ raise TypeError(
+ "Exitpriority ({0!r}) must be None or int, not {1!s}".format(
+ exitpriority, type(exitpriority)))
+
+ if obj is not None:
+ self._weakref = weakref.ref(obj, self)
+ elif exitpriority is None:
+ raise ValueError("Without object, exitpriority cannot be None")
+
+ self._callback = callback
+ self._args = args
+ self._kwargs = kwargs or {}
+ self._key = (exitpriority, next(_finalizer_counter))
+ self._pid = os.getpid()
+
+ _finalizer_registry[self._key] = self
+
+ def __call__(self, wr=None,
+ # Need to bind these locally because the globals can have
+ # been cleared at shutdown
+ _finalizer_registry=_finalizer_registry,
+ sub_debug=sub_debug, getpid=os.getpid):
+ '''
+ Run the callback unless it has already been called or cancelled
+ '''
+ try:
+ del _finalizer_registry[self._key]
+ except KeyError:
+ sub_debug('finalizer no longer registered')
+ else:
+ if self._pid != getpid():
+ sub_debug('finalizer ignored because different process')
+ res = None
+ else:
+ sub_debug('finalizer calling %s with args %s and kwargs %s',
+ self._callback, self._args, self._kwargs)
+ res = self._callback(*self._args, **self._kwargs)
+ self._weakref = self._callback = self._args = \
+ self._kwargs = self._key = None
+ return res
+
+ def cancel(self):
+ '''
+ Cancel finalization of the object
+ '''
+ try:
+ del _finalizer_registry[self._key]
+ except KeyError:
+ pass
+ else:
+ self._weakref = self._callback = self._args = \
+ self._kwargs = self._key = None
+
+ def still_active(self):
+ '''
+ Return whether this finalizer is still waiting to invoke callback
+ '''
+ return self._key in _finalizer_registry
+
+ def __repr__(self):
+ try:
+ obj = self._weakref()
+ except (AttributeError, TypeError):
+ obj = None
+
+ if obj is None:
+ return '<%s object, dead>' % self.__class__.__name__
+
+ x = '<%s object, callback=%s' % (
+ self.__class__.__name__,
+ getattr(self._callback, '__name__', self._callback))
+ if self._args:
+ x += ', args=' + str(self._args)
+ if self._kwargs:
+ x += ', kwargs=' + str(self._kwargs)
+ if self._key[0] is not None:
+ x += ', exitpriority=' + str(self._key[0])
+ return x + '>'
+
+
+def _run_finalizers(minpriority=None):
+ '''
+ Run all finalizers whose exit priority is not None and at least minpriority
+
+ Finalizers with highest priority are called first; finalizers with
+ the same priority will be called in reverse order of creation.
+ '''
+ if _finalizer_registry is None:
+ # This function may be called after this module's globals are
+ # destroyed. See the _exit_function function in this module for more
+ # notes.
+ return
+
+ if minpriority is None:
+ f = lambda p : p[0] is not None
+ else:
+ f = lambda p : p[0] is not None and p[0] >= minpriority
+
+ # Careful: _finalizer_registry may be mutated while this function
+ # is running (either by a GC run or by another thread).
+
+ # list(_finalizer_registry) should be atomic, while
+ # list(_finalizer_registry.items()) is not.
+ keys = [key for key in list(_finalizer_registry) if f(key)]
+ keys.sort(reverse=True)
+
+ for key in keys:
+ finalizer = _finalizer_registry.get(key)
+ # key may have been removed from the registry
+ if finalizer is not None:
+ sub_debug('calling %s', finalizer)
+ try:
+ finalizer()
+ except Exception:
+ import traceback
+ traceback.print_exc()
+
+ if minpriority is None:
+ _finalizer_registry.clear()
+
+#
+# Clean up on exit
+#
+
+def is_exiting():
+ '''
+ Returns true if the process is shutting down
+ '''
+ return _exiting or _exiting is None
+
+_exiting = False
+
+def _exit_function(info=info, debug=debug, _run_finalizers=_run_finalizers,
+ active_children=process.active_children,
+ current_process=process.current_process):
+ # We hold on to references to functions in the arglist due to the
+ # situation described below, where this function is called after this
+ # module's globals are destroyed.
+
+ global _exiting
+
+ if not _exiting:
+ _exiting = True
+
+ info('process shutting down')
+ debug('running all "atexit" finalizers with priority >= 0')
+ _run_finalizers(0)
+
+ if current_process() is not None:
+ # We check if the current process is None here because if
+ # it's None, any call to ``active_children()`` will raise
+ # an AttributeError (active_children winds up trying to
+ # get attributes from util._current_process). One
+ # situation where this can happen is if someone has
+ # manipulated sys.modules, causing this module to be
+ # garbage collected. The destructor for the module type
+ # then replaces all values in the module dict with None.
+ # For instance, after setuptools runs a test it replaces
+ # sys.modules with a copy created earlier. See issues
+ # #9775 and #15881. Also related: #4106, #9205, and
+ # #9207.
+
+ for p in active_children():
+ if p.daemon:
+ info('calling terminate() for daemon %s', p.name)
+ p._popen.terminate()
+
+ for p in active_children():
+ info('calling join() for process %s', p.name)
+ p.join()
+
+ debug('running the remaining "atexit" finalizers')
+ _run_finalizers()
+
+atexit.register(_exit_function)
+
+#
+# Some fork aware types
+#
+
+class ForkAwareThreadLock(object):
+ def __init__(self):
+ self._lock = threading.Lock()
+ self.acquire = self._lock.acquire
+ self.release = self._lock.release
+ register_after_fork(self, ForkAwareThreadLock._at_fork_reinit)
+
+ def _at_fork_reinit(self):
+ self._lock._at_fork_reinit()
+
+ def __enter__(self):
+ return self._lock.__enter__()
+
+ def __exit__(self, *args):
+ return self._lock.__exit__(*args)
+
+
+class ForkAwareLocal(threading.local):
+ def __init__(self):
+ register_after_fork(self, lambda obj : obj.__dict__.clear())
+ def __reduce__(self):
+ return type(self), ()
+
+#
+# Close fds except those specified
+#
+
+try:
+ MAXFD = os.sysconf("SC_OPEN_MAX")
+except Exception:
+ MAXFD = 256
+
+def close_all_fds_except(fds):
+ fds = list(fds) + [-1, MAXFD]
+ fds.sort()
+ assert fds[-1] == MAXFD, 'fd too large'
+ for i in range(len(fds) - 1):
+ os.closerange(fds[i]+1, fds[i+1])
+#
+# Close sys.stdin and replace stdin with os.devnull
+#
+
+def _close_stdin():
+ if sys.stdin is None:
+ return
+
+ try:
+ sys.stdin.close()
+ except (OSError, ValueError):
+ pass
+
+ try:
+ fd = os.open(os.devnull, os.O_RDONLY)
+ try:
+ sys.stdin = open(fd, encoding="utf-8", closefd=False)
+ except:
+ os.close(fd)
+ raise
+ except (OSError, ValueError):
+ pass
+
+#
+# Flush standard streams, if any
+#
+
+def _flush_std_streams():
+ try:
+ sys.stdout.flush()
+ except (AttributeError, ValueError):
+ pass
+ try:
+ sys.stderr.flush()
+ except (AttributeError, ValueError):
+ pass
+
+#
+# Start a program with only specified fds kept open
+#
+
+def spawnv_passfds(path, args, passfds):
+ import _posixsubprocess
+ import subprocess
+ passfds = tuple(sorted(map(int, passfds)))
+ errpipe_read, errpipe_write = os.pipe()
+ try:
+ return _posixsubprocess.fork_exec(
+ args, [path], True, passfds, None, None,
+ -1, -1, -1, -1, -1, -1, errpipe_read, errpipe_write,
+ False, False, -1, None, None, None, -1, None,
+ subprocess._USE_VFORK)
+ finally:
+ os.close(errpipe_read)
+ os.close(errpipe_write)
+
+
+def close_fds(*fds):
+ """Close each file descriptor given as an argument"""
+ for fd in fds:
+ os.close(fd)
+
+
+def _cleanup_tests():
+ """Cleanup multiprocessing resources when multiprocessing tests
+ completed."""
+
+ from test import support
+
+ # cleanup multiprocessing
+ process._cleanup()
+
+ # Stop the ForkServer process if it's running
+ from multiprocess import forkserver
+ forkserver._forkserver._stop()
+
+ # Stop the ResourceTracker process if it's running
+ from multiprocess import resource_tracker
+ resource_tracker._resource_tracker._stop()
+
+ # bpo-37421: Explicitly call _run_finalizers() to remove immediately
+ # temporary directories created by multiprocessing.util.get_temp_dir().
+ _run_finalizers()
+ support.gc_collect()
+
+ support.reap_children()
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/networkx-3.6.1.dist-info/INSTALLER b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/networkx-3.6.1.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/networkx-3.6.1.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/networkx-3.6.1.dist-info/METADATA b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/networkx-3.6.1.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..98acd814861037e65d72b4ababd2e0e8b86555ab
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/networkx-3.6.1.dist-info/METADATA
@@ -0,0 +1,177 @@
+Metadata-Version: 2.4
+Name: networkx
+Version: 3.6.1
+Summary: Python package for creating and manipulating graphs and networks
+Author-email: Aric Hagberg
+Maintainer-email: NetworkX Developers
+License-Expression: BSD-3-Clause
+Project-URL: Homepage, https://networkx.org/
+Project-URL: Bug Tracker, https://github.com/networkx/networkx/issues
+Project-URL: Documentation, https://networkx.org/documentation/stable/
+Project-URL: Source Code, https://github.com/networkx/networkx
+Keywords: Networks,Graph Theory,Mathematics,network,graph,discrete mathematics,math
+Platform: Linux
+Platform: Mac OSX
+Platform: Windows
+Platform: Unix
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: !=3.14.1,>=3.11
+Description-Content-Type: text/x-rst
+License-File: LICENSE.txt
+Provides-Extra: benchmarking
+Requires-Dist: asv; extra == "benchmarking"
+Requires-Dist: virtualenv; extra == "benchmarking"
+Provides-Extra: default
+Requires-Dist: numpy>=1.25; extra == "default"
+Requires-Dist: scipy>=1.11.2; extra == "default"
+Requires-Dist: matplotlib>=3.8; extra == "default"
+Requires-Dist: pandas>=2.0; extra == "default"
+Provides-Extra: developer
+Requires-Dist: pre-commit>=4.1; extra == "developer"
+Requires-Dist: mypy>=1.15; extra == "developer"
+Provides-Extra: doc
+Requires-Dist: sphinx>=8.0; extra == "doc"
+Requires-Dist: pydata-sphinx-theme>=0.16; extra == "doc"
+Requires-Dist: sphinx-gallery>=0.18; extra == "doc"
+Requires-Dist: numpydoc>=1.8.0; extra == "doc"
+Requires-Dist: pillow>=10; extra == "doc"
+Requires-Dist: texext>=0.6.7; extra == "doc"
+Requires-Dist: myst-nb>=1.1; extra == "doc"
+Requires-Dist: intersphinx-registry; extra == "doc"
+Provides-Extra: example
+Requires-Dist: osmnx>=2.0.0; extra == "example"
+Requires-Dist: momepy>=0.7.2; extra == "example"
+Requires-Dist: contextily>=1.6; extra == "example"
+Requires-Dist: seaborn>=0.13; extra == "example"
+Requires-Dist: cairocffi>=1.7; extra == "example"
+Requires-Dist: igraph>=0.11; extra == "example"
+Requires-Dist: scikit-learn>=1.5; extra == "example"
+Requires-Dist: iplotx>=0.9.0; extra == "example"
+Provides-Extra: extra
+Requires-Dist: lxml>=4.6; extra == "extra"
+Requires-Dist: pygraphviz>=1.14; extra == "extra"
+Requires-Dist: pydot>=3.0.1; extra == "extra"
+Requires-Dist: sympy>=1.10; extra == "extra"
+Provides-Extra: release
+Requires-Dist: build>=0.10; extra == "release"
+Requires-Dist: twine>=4.0; extra == "release"
+Requires-Dist: wheel>=0.40; extra == "release"
+Requires-Dist: changelist==0.5; extra == "release"
+Provides-Extra: test
+Requires-Dist: pytest>=7.2; extra == "test"
+Requires-Dist: pytest-cov>=4.0; extra == "test"
+Requires-Dist: pytest-xdist>=3.0; extra == "test"
+Provides-Extra: test-extras
+Requires-Dist: pytest-mpl; extra == "test-extras"
+Requires-Dist: pytest-randomly; extra == "test-extras"
+Dynamic: license-file
+
+NetworkX
+========
+
+
+.. image::
+ https://github.com/networkx/networkx/actions/workflows/test.yml/badge.svg?branch=main
+ :target: https://github.com/networkx/networkx/actions/workflows/test.yml
+
+.. image::
+ https://img.shields.io/pypi/v/networkx.svg?
+ :target: https://pypi.python.org/pypi/networkx
+
+.. image::
+ https://img.shields.io/pypi/l/networkx.svg?
+ :target: https://github.com/networkx/networkx/blob/main/LICENSE.txt
+
+.. image::
+ https://img.shields.io/pypi/pyversions/networkx.svg?
+ :target: https://pypi.python.org/pypi/networkx
+
+.. image::
+ https://img.shields.io/github/labels/networkx/networkx/good%20first%20issue?color=green&label=contribute
+ :target: https://github.com/networkx/networkx/contribute
+
+.. image::
+ https://insights.linuxfoundation.org/api/badge/health-score?project=networkx
+ :target: https://insights.linuxfoundation.org/project/networkx
+
+
+NetworkX is a Python package for the creation, manipulation,
+and study of the structure, dynamics, and functions
+of complex networks.
+
+- **Website (including documentation):** https://networkx.org
+- **Mailing list:** https://groups.google.com/forum/#!forum/networkx-discuss
+- **Source:** https://github.com/networkx/networkx
+- **Bug reports:** https://github.com/networkx/networkx/issues
+- **Report a security vulnerability:** https://tidelift.com/security
+- **Tutorial:** https://networkx.org/documentation/latest/tutorial.html
+- **GitHub Discussions:** https://github.com/networkx/networkx/discussions
+- **Discord (Scientific Python) invite link:** https://discord.com/invite/vur45CbwMz
+- **NetworkX meetings calendar (open to all):** https://scientific-python.org/calendars/networkx.ics
+
+Simple example
+--------------
+
+Find the shortest path between two nodes in an undirected graph:
+
+.. code:: pycon
+
+ >>> import networkx as nx
+ >>> G = nx.Graph()
+ >>> G.add_edge("A", "B", weight=4)
+ >>> G.add_edge("B", "D", weight=2)
+ >>> G.add_edge("A", "C", weight=3)
+ >>> G.add_edge("C", "D", weight=4)
+ >>> nx.shortest_path(G, "A", "D", weight="weight")
+ ['A', 'B', 'D']
+
+Install
+-------
+
+Install the latest released version of NetworkX:
+
+.. code:: shell
+
+ $ pip install networkx
+
+Install with all optional dependencies:
+
+.. code:: shell
+
+ $ pip install networkx[default]
+
+For additional details,
+please see the `installation guide `_.
+
+Bugs
+----
+
+Please report any bugs that you find `here `_.
+Or, even better, fork the repository on `GitHub `_
+and create a pull request (PR). We welcome all changes, big or small, and we
+will help you make the PR if you are new to `git` (just ask on the issue and/or
+see the `contributor guide `_).
+
+License
+-------
+
+Released under the `3-clause BSD license `_::
+
+ Copyright (c) 2004-2025, NetworkX Developers
+ Aric Hagberg
+ Dan Schult
+ Pieter Swart
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/networkx-3.6.1.dist-info/RECORD b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/networkx-3.6.1.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..cbe1c8435488b1d09df8ee39457814745f52fc2e
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/networkx-3.6.1.dist-info/RECORD
@@ -0,0 +1,1182 @@
+networkx-3.6.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+networkx-3.6.1.dist-info/METADATA,sha256=rKXZSpfR9w8wHQM63bY19uZr6Jc6AKukEnY37tLvMWo,6783
+networkx-3.6.1.dist-info/RECORD,,
+networkx-3.6.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+networkx-3.6.1.dist-info/entry_points.txt,sha256=H2jZaDsDJ_i9H2SwWpwuFel8BrZ9xHKuvh-DQAWW9lQ,94
+networkx-3.6.1.dist-info/licenses/LICENSE.txt,sha256=PPfDoXnYF7I7i4VoIRdp_v35N5fSB9mEuLL6JNAiCzM,1763
+networkx-3.6.1.dist-info/top_level.txt,sha256=s3Mk-7KOlu-kD39w8Xg_KXoP5Z_MVvgB-upkyuOE4Hk,9
+networkx/__init__.py,sha256=OVN8C-x44LgeJWKcb77v-WwfMV7EYqieafkoQdlAl5E,1625
+networkx/__pycache__/__init__.cpython-312.pyc,,
+networkx/__pycache__/conftest.cpython-312.pyc,,
+networkx/__pycache__/convert.cpython-312.pyc,,
+networkx/__pycache__/convert_matrix.cpython-312.pyc,,
+networkx/__pycache__/exception.cpython-312.pyc,,
+networkx/__pycache__/lazy_imports.cpython-312.pyc,,
+networkx/__pycache__/relabel.cpython-312.pyc,,
+networkx/algorithms/__init__.py,sha256=sXdgBEDG0qlsOAymWl9zyT-c_luwOQOhWuus6quro0A,6607
+networkx/algorithms/__pycache__/__init__.cpython-312.pyc,,
+networkx/algorithms/__pycache__/asteroidal.cpython-312.pyc,,
+networkx/algorithms/__pycache__/boundary.cpython-312.pyc,,
+networkx/algorithms/__pycache__/bridges.cpython-312.pyc,,
+networkx/algorithms/__pycache__/broadcasting.cpython-312.pyc,,
+networkx/algorithms/__pycache__/chains.cpython-312.pyc,,
+networkx/algorithms/__pycache__/chordal.cpython-312.pyc,,
+networkx/algorithms/__pycache__/clique.cpython-312.pyc,,
+networkx/algorithms/__pycache__/cluster.cpython-312.pyc,,
+networkx/algorithms/__pycache__/communicability_alg.cpython-312.pyc,,
+networkx/algorithms/__pycache__/core.cpython-312.pyc,,
+networkx/algorithms/__pycache__/covering.cpython-312.pyc,,
+networkx/algorithms/__pycache__/cuts.cpython-312.pyc,,
+networkx/algorithms/__pycache__/cycles.cpython-312.pyc,,
+networkx/algorithms/__pycache__/d_separation.cpython-312.pyc,,
+networkx/algorithms/__pycache__/dag.cpython-312.pyc,,
+networkx/algorithms/__pycache__/distance_measures.cpython-312.pyc,,
+networkx/algorithms/__pycache__/distance_regular.cpython-312.pyc,,
+networkx/algorithms/__pycache__/dominance.cpython-312.pyc,,
+networkx/algorithms/__pycache__/dominating.cpython-312.pyc,,
+networkx/algorithms/__pycache__/efficiency_measures.cpython-312.pyc,,
+networkx/algorithms/__pycache__/euler.cpython-312.pyc,,
+networkx/algorithms/__pycache__/graph_hashing.cpython-312.pyc,,
+networkx/algorithms/__pycache__/graphical.cpython-312.pyc,,
+networkx/algorithms/__pycache__/hierarchy.cpython-312.pyc,,
+networkx/algorithms/__pycache__/hybrid.cpython-312.pyc,,
+networkx/algorithms/__pycache__/isolate.cpython-312.pyc,,
+networkx/algorithms/__pycache__/link_prediction.cpython-312.pyc,,
+networkx/algorithms/__pycache__/lowest_common_ancestors.cpython-312.pyc,,
+networkx/algorithms/__pycache__/matching.cpython-312.pyc,,
+networkx/algorithms/__pycache__/mis.cpython-312.pyc,,
+networkx/algorithms/__pycache__/moral.cpython-312.pyc,,
+networkx/algorithms/__pycache__/node_classification.cpython-312.pyc,,
+networkx/algorithms/__pycache__/non_randomness.cpython-312.pyc,,
+networkx/algorithms/__pycache__/perfect_graph.cpython-312.pyc,,
+networkx/algorithms/__pycache__/planar_drawing.cpython-312.pyc,,
+networkx/algorithms/__pycache__/planarity.cpython-312.pyc,,
+networkx/algorithms/__pycache__/polynomials.cpython-312.pyc,,
+networkx/algorithms/__pycache__/reciprocity.cpython-312.pyc,,
+networkx/algorithms/__pycache__/regular.cpython-312.pyc,,
+networkx/algorithms/__pycache__/richclub.cpython-312.pyc,,
+networkx/algorithms/__pycache__/similarity.cpython-312.pyc,,
+networkx/algorithms/__pycache__/simple_paths.cpython-312.pyc,,
+networkx/algorithms/__pycache__/smallworld.cpython-312.pyc,,
+networkx/algorithms/__pycache__/smetric.cpython-312.pyc,,
+networkx/algorithms/__pycache__/sparsifiers.cpython-312.pyc,,
+networkx/algorithms/__pycache__/structuralholes.cpython-312.pyc,,
+networkx/algorithms/__pycache__/summarization.cpython-312.pyc,,
+networkx/algorithms/__pycache__/swap.cpython-312.pyc,,
+networkx/algorithms/__pycache__/threshold.cpython-312.pyc,,
+networkx/algorithms/__pycache__/time_dependent.cpython-312.pyc,,
+networkx/algorithms/__pycache__/tournament.cpython-312.pyc,,
+networkx/algorithms/__pycache__/triads.cpython-312.pyc,,
+networkx/algorithms/__pycache__/vitality.cpython-312.pyc,,
+networkx/algorithms/__pycache__/voronoi.cpython-312.pyc,,
+networkx/algorithms/__pycache__/walks.cpython-312.pyc,,
+networkx/algorithms/__pycache__/wiener.cpython-312.pyc,,
+networkx/algorithms/approximation/__init__.py,sha256=1W0c3YlSfVQtNI4-WiQdzMfPqmcrCar5hJQmrwcsVoI,1234
+networkx/algorithms/approximation/__pycache__/__init__.cpython-312.pyc,,
+networkx/algorithms/approximation/__pycache__/clique.cpython-312.pyc,,
+networkx/algorithms/approximation/__pycache__/clustering_coefficient.cpython-312.pyc,,
+networkx/algorithms/approximation/__pycache__/connectivity.cpython-312.pyc,,
+networkx/algorithms/approximation/__pycache__/density.cpython-312.pyc,,
+networkx/algorithms/approximation/__pycache__/distance_measures.cpython-312.pyc,,
+networkx/algorithms/approximation/__pycache__/dominating_set.cpython-312.pyc,,
+networkx/algorithms/approximation/__pycache__/kcomponents.cpython-312.pyc,,
+networkx/algorithms/approximation/__pycache__/matching.cpython-312.pyc,,
+networkx/algorithms/approximation/__pycache__/maxcut.cpython-312.pyc,,
+networkx/algorithms/approximation/__pycache__/ramsey.cpython-312.pyc,,
+networkx/algorithms/approximation/__pycache__/steinertree.cpython-312.pyc,,
+networkx/algorithms/approximation/__pycache__/traveling_salesman.cpython-312.pyc,,
+networkx/algorithms/approximation/__pycache__/treewidth.cpython-312.pyc,,
+networkx/algorithms/approximation/__pycache__/vertex_cover.cpython-312.pyc,,
+networkx/algorithms/approximation/clique.py,sha256=b4cnWMJXmmgCyjMI8A_doHZeKS_RQbGqm2L01OpT_Jg,7691
+networkx/algorithms/approximation/clustering_coefficient.py,sha256=SWpSLEhW3DJc1n2fHlSbJSGg3wdoJkN5Y4_tnntn0Ws,2164
+networkx/algorithms/approximation/connectivity.py,sha256=aVXSfUiWEG4gUL0R1u6WZ-h-wheuLP1_suO_pRFB8M4,13118
+networkx/algorithms/approximation/density.py,sha256=_JU9nIH4wneHG6PtEAF_q1oLwy5UUKk--FkTVkkMAMg,15258
+networkx/algorithms/approximation/distance_measures.py,sha256=UEkmKagNw9sj8kiUDdbAeYuzvZ31pgLMXqzliqMkG84,5805
+networkx/algorithms/approximation/dominating_set.py,sha256=5fC90w1CgYR4Xkpqact8iukKY0i57bMmyJW-A9CToUQ,4710
+networkx/algorithms/approximation/kcomponents.py,sha256=MDkoyQbk0gSAm3ZZK35VOsiLJDv7wiDsxfzH5O-ObFs,13285
+networkx/algorithms/approximation/matching.py,sha256=PFof5m9AIq9Xr5Kaa_-mYxI1IBBP7HEkjf-R9wVE3bo,1175
+networkx/algorithms/approximation/maxcut.py,sha256=eTQZqsDQAAUaufni-aDJAY2UzIcajDhRMdj-AcqVkPs,4333
+networkx/algorithms/approximation/ramsey.py,sha256=W5tX7BOQJIM_qNsBeUhCXVWMD8DFdeTycYyk08k4Sqk,1358
+networkx/algorithms/approximation/steinertree.py,sha256=2t58cQQt9OAMRWP1q0RV9QrdNzgasZtPNp6PbA0LFDU,9363
+networkx/algorithms/approximation/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/approximation/tests/__pycache__/__init__.cpython-312.pyc,,
+networkx/algorithms/approximation/tests/__pycache__/test_approx_clust_coeff.cpython-312.pyc,,
+networkx/algorithms/approximation/tests/__pycache__/test_clique.cpython-312.pyc,,
+networkx/algorithms/approximation/tests/__pycache__/test_connectivity.cpython-312.pyc,,
+networkx/algorithms/approximation/tests/__pycache__/test_density.cpython-312.pyc,,
+networkx/algorithms/approximation/tests/__pycache__/test_distance_measures.cpython-312.pyc,,
+networkx/algorithms/approximation/tests/__pycache__/test_dominating_set.cpython-312.pyc,,
+networkx/algorithms/approximation/tests/__pycache__/test_kcomponents.cpython-312.pyc,,
+networkx/algorithms/approximation/tests/__pycache__/test_matching.cpython-312.pyc,,
+networkx/algorithms/approximation/tests/__pycache__/test_maxcut.cpython-312.pyc,,
+networkx/algorithms/approximation/tests/__pycache__/test_ramsey.cpython-312.pyc,,
+networkx/algorithms/approximation/tests/__pycache__/test_steinertree.cpython-312.pyc,,
+networkx/algorithms/approximation/tests/__pycache__/test_traveling_salesman.cpython-312.pyc,,
+networkx/algorithms/approximation/tests/__pycache__/test_treewidth.cpython-312.pyc,,
+networkx/algorithms/approximation/tests/__pycache__/test_vertex_cover.cpython-312.pyc,,
+networkx/algorithms/approximation/tests/test_approx_clust_coeff.py,sha256=PGOVEKf2BcJu1vvjZrgTlBBpwM8V6t7yCANjyS9nWF0,1171
+networkx/algorithms/approximation/tests/test_clique.py,sha256=s6HQB-lK3RAu_ftpe2NvIiMu0Ol8tpAdbGvWzucNL6k,3021
+networkx/algorithms/approximation/tests/test_connectivity.py,sha256=gDG6tsgP3ux7Dgu0x7r0nso7_yknIxicV42Gq0It5pc,5952
+networkx/algorithms/approximation/tests/test_density.py,sha256=EgJsX9z2lxWJCpF5NPbYEbE0GIATazCmgj7wFYeObDM,5298
+networkx/algorithms/approximation/tests/test_distance_measures.py,sha256=axgOojplJIgXdopgkjxjAgvzGTQ1FV1oJ5NG-7ICalo,2023
+networkx/algorithms/approximation/tests/test_dominating_set.py,sha256=l4pBDY7pK7Fxw-S4tOlNcxf-j2j5GpHPJ9f4TrMs1sI,2686
+networkx/algorithms/approximation/tests/test_kcomponents.py,sha256=tTljP1FHzXrUwi-oBz5AQcibRw1NgR4N5UE0a2OrOUA,9346
+networkx/algorithms/approximation/tests/test_matching.py,sha256=nitZncaM0605kaIu1NO6_5TFV2--nohUCO46XTD_lnM,186
+networkx/algorithms/approximation/tests/test_maxcut.py,sha256=U6CDZFSLfYDII-1nX9XB7avSz10kTx88vNazJFoLQ1k,2804
+networkx/algorithms/approximation/tests/test_ramsey.py,sha256=h36Ol39csHbIoTDBxbxMgn4371iVUGZ3a2N6l7d56lI,1143
+networkx/algorithms/approximation/tests/test_steinertree.py,sha256=ifBKzrKjRzfMg2g9BKSXVYLvuEbygQPp9rXR4cK99Q8,10727
+networkx/algorithms/approximation/tests/test_traveling_salesman.py,sha256=odnyk7CgLbMGI2QuHxj3BPRX4cCfWHK5N65rj0jMLW8,32048
+networkx/algorithms/approximation/tests/test_treewidth.py,sha256=b_79ZKiW0XX24-GYaeQJ9Zaq7ZFYQT0DcDTkACII3EY,8868
+networkx/algorithms/approximation/tests/test_vertex_cover.py,sha256=FobHNhG9CAMeB_AOEprUs-7XQdPoc1YvfmXhozDZ8pM,1942
+networkx/algorithms/approximation/traveling_salesman.py,sha256=HZU6dbPo3Hiz2-Z3QHLFm5kdGBQwkXPefkVUuW-IC2A,56210
+networkx/algorithms/approximation/treewidth.py,sha256=hfLiPlheQMN7MG6CGR5w7AscKbLu3pTLNYRS13SO0Xo,8389
+networkx/algorithms/approximation/vertex_cover.py,sha256=oIi_yg5O-IisnfmrSof1P4HD-fsZpW69RpvkR_SM5Og,2803
+networkx/algorithms/assortativity/__init__.py,sha256=ov3HRRbeYB_6Qezvxp1OTl77GBpw-EWkWGUzgfT8G9c,294
+networkx/algorithms/assortativity/__pycache__/__init__.cpython-312.pyc,,
+networkx/algorithms/assortativity/__pycache__/connectivity.cpython-312.pyc,,
+networkx/algorithms/assortativity/__pycache__/correlation.cpython-312.pyc,,
+networkx/algorithms/assortativity/__pycache__/mixing.cpython-312.pyc,,
+networkx/algorithms/assortativity/__pycache__/neighbor_degree.cpython-312.pyc,,
+networkx/algorithms/assortativity/__pycache__/pairs.cpython-312.pyc,,
+networkx/algorithms/assortativity/connectivity.py,sha256=-V0C5MTqtErl86N-gyrZ487MUyiG5x1QFEZKurOpIJA,4220
+networkx/algorithms/assortativity/correlation.py,sha256=0rc4FDi-e8eQRia7gpFrTqjIy-J7V2GtSwOb4QN6WZk,8689
+networkx/algorithms/assortativity/mixing.py,sha256=RRqqkuVwo71LosJLDbeVCVBikqC7I_XZORdsonQsf9Y,7586
+networkx/algorithms/assortativity/neighbor_degree.py,sha256=UMaQWKBkOZ0ZgC8xGt5fXEz8OL1rgwYjt2zKbKEqofI,5282
+networkx/algorithms/assortativity/pairs.py,sha256=w7xnaWxDDteluHoCsqunLlcM6nlcBenO_5Nz87oOEnE,3841
+networkx/algorithms/assortativity/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/assortativity/tests/__pycache__/__init__.cpython-312.pyc,,
+networkx/algorithms/assortativity/tests/__pycache__/base_test.cpython-312.pyc,,
+networkx/algorithms/assortativity/tests/__pycache__/test_connectivity.cpython-312.pyc,,
+networkx/algorithms/assortativity/tests/__pycache__/test_correlation.cpython-312.pyc,,
+networkx/algorithms/assortativity/tests/__pycache__/test_mixing.cpython-312.pyc,,
+networkx/algorithms/assortativity/tests/__pycache__/test_neighbor_degree.cpython-312.pyc,,
+networkx/algorithms/assortativity/tests/__pycache__/test_pairs.cpython-312.pyc,,
+networkx/algorithms/assortativity/tests/base_test.py,sha256=MNeQMLA3oBUCM8TSyNbBQ_uW0nDc1GEZYdNdUwePAm4,2651
+networkx/algorithms/assortativity/tests/test_connectivity.py,sha256=Js841GQLYTLWvc6xZhnyqj-JtyrnS0ska1TFYntxyXA,4978
+networkx/algorithms/assortativity/tests/test_correlation.py,sha256=ddx-yqnVcOfx1dKVNUF695hS3Q-zCmFmCGzK64B7YSE,5068
+networkx/algorithms/assortativity/tests/test_mixing.py,sha256=1kkiMoQXslY-VnT1j00mFbRdj75A4d1b6OPTUOJVgaY,6802
+networkx/algorithms/assortativity/tests/test_neighbor_degree.py,sha256=wphbir1e-h-BAq5rjvWBi4WlgWdseyQbh_KLGQvy5Pc,3934
+networkx/algorithms/assortativity/tests/test_pairs.py,sha256=t05qP_-gfkbiR6aTLtE1owYl9otBSsuJcRkuZsa63UQ,3008
+networkx/algorithms/asteroidal.py,sha256=hIGg9zI4vylRXkrY5wHverTSOeK6dt1Gn2T_JYvGNnU,5500
+networkx/algorithms/bipartite/__init__.py,sha256=FZug-pg0FUDgAdysnKXxDpi1ly8ezxf4UxBPRklqjys,3883
+networkx/algorithms/bipartite/__pycache__/__init__.cpython-312.pyc,,
+networkx/algorithms/bipartite/__pycache__/basic.cpython-312.pyc,,
+networkx/algorithms/bipartite/__pycache__/centrality.cpython-312.pyc,,
+networkx/algorithms/bipartite/__pycache__/cluster.cpython-312.pyc,,
+networkx/algorithms/bipartite/__pycache__/covering.cpython-312.pyc,,
+networkx/algorithms/bipartite/__pycache__/edgelist.cpython-312.pyc,,
+networkx/algorithms/bipartite/__pycache__/extendability.cpython-312.pyc,,
+networkx/algorithms/bipartite/__pycache__/generators.cpython-312.pyc,,
+networkx/algorithms/bipartite/__pycache__/link_analysis.cpython-312.pyc,,
+networkx/algorithms/bipartite/__pycache__/matching.cpython-312.pyc,,
+networkx/algorithms/bipartite/__pycache__/matrix.cpython-312.pyc,,
+networkx/algorithms/bipartite/__pycache__/projection.cpython-312.pyc,,
+networkx/algorithms/bipartite/__pycache__/redundancy.cpython-312.pyc,,
+networkx/algorithms/bipartite/__pycache__/spectral.cpython-312.pyc,,
+networkx/algorithms/bipartite/basic.py,sha256=JPC2gGuPvFA6q2CuI5mqLX_9QUGxrsQ8cIwcS0e9P4U,8375
+networkx/algorithms/bipartite/centrality.py,sha256=G280bAqeyXyCmes5NpRqUv2Tc-EHWrMshJ3_f4uqV9U,9156
+networkx/algorithms/bipartite/cluster.py,sha256=8aZRmlQ3g0XtzHyF1kUBBwnzMSjtduquHDH8MxKNSEI,7346
+networkx/algorithms/bipartite/covering.py,sha256=B3ITc016Kk70NBv-1lb30emXnfjlMIQJ7M-FIPCZip0,2163
+networkx/algorithms/bipartite/edgelist.py,sha256=mmiM2Bvh9CxRKCsspbs-90GZedpt7Gj5AGzvJ-aYDSM,11409
+networkx/algorithms/bipartite/extendability.py,sha256=OrYHlS4ruQST-dlQOuleiqHFKpVVNOvrG5aDNFgfckg,3989
+networkx/algorithms/bipartite/generators.py,sha256=p0xgyuJ5hp52NYPu2ryPEKZ0MEktP5VSW2HMK2VdBCo,20408
+networkx/algorithms/bipartite/link_analysis.py,sha256=eVRRQgwzMcUPPu6ccskPk72yc_lmnF5EGqNIdXe-MxA,12772
+networkx/algorithms/bipartite/matching.py,sha256=xsT048Ok_uM0Zhpdc34qswV1zaCGOlJQnsbGTDsm5oo,21637
+networkx/algorithms/bipartite/matrix.py,sha256=rxmjBNHts4hQ-EIlHLE3vIAeGHaMz8Kg_FJ8je5zFyQ,8320
+networkx/algorithms/bipartite/projection.py,sha256=YIUlreqQQ6IPE37OXF32zNIdzEGeyR8aY-7iUENZYVA,17252
+networkx/algorithms/bipartite/redundancy.py,sha256=eGNVo0qW-3unhGhY5VTs2vbc8QmOGve70UDY3ykjhNo,3340
+networkx/algorithms/bipartite/spectral.py,sha256=fu2grV1the_e_G-e_lUdhk8Y9XFe6_p2tPmx3RKntFw,1902
+networkx/algorithms/bipartite/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/bipartite/tests/__pycache__/__init__.cpython-312.pyc,,
+networkx/algorithms/bipartite/tests/__pycache__/test_basic.cpython-312.pyc,,
+networkx/algorithms/bipartite/tests/__pycache__/test_centrality.cpython-312.pyc,,
+networkx/algorithms/bipartite/tests/__pycache__/test_cluster.cpython-312.pyc,,
+networkx/algorithms/bipartite/tests/__pycache__/test_covering.cpython-312.pyc,,
+networkx/algorithms/bipartite/tests/__pycache__/test_edgelist.cpython-312.pyc,,
+networkx/algorithms/bipartite/tests/__pycache__/test_extendability.cpython-312.pyc,,
+networkx/algorithms/bipartite/tests/__pycache__/test_generators.cpython-312.pyc,,
+networkx/algorithms/bipartite/tests/__pycache__/test_link_analysis.cpython-312.pyc,,
+networkx/algorithms/bipartite/tests/__pycache__/test_matching.cpython-312.pyc,,
+networkx/algorithms/bipartite/tests/__pycache__/test_matrix.cpython-312.pyc,,
+networkx/algorithms/bipartite/tests/__pycache__/test_project.cpython-312.pyc,,
+networkx/algorithms/bipartite/tests/__pycache__/test_redundancy.cpython-312.pyc,,
+networkx/algorithms/bipartite/tests/__pycache__/test_spectral_bipartivity.cpython-312.pyc,,
+networkx/algorithms/bipartite/tests/test_basic.py,sha256=gzbtsQqPi85BznX5REdGBBJVyr9aH4nO06c3eEI4634,4291
+networkx/algorithms/bipartite/tests/test_centrality.py,sha256=PABPbrIyoAziEEQKXsZLl2jT36N8DZpNRzEO-jeu89Y,6362
+networkx/algorithms/bipartite/tests/test_cluster.py,sha256=O0VsPVt8vcY_E1FjjLJX2xaUbhVViI5MP6_gLTbEpos,2801
+networkx/algorithms/bipartite/tests/test_covering.py,sha256=EGVxYQsyLXE5yY5N5u6D4wZq2NcZe9OwlYpEuY6DF3o,1221
+networkx/algorithms/bipartite/tests/test_edgelist.py,sha256=fK35tSekG_-9Ewr5Bhl1bRdwAy247Z9zZ4dQFFDQ9xw,8471
+networkx/algorithms/bipartite/tests/test_extendability.py,sha256=XgPmg6bWiHAF1iQ75_r2NqUxExOQNZRUeYUPzlCa5-E,7043
+networkx/algorithms/bipartite/tests/test_generators.py,sha256=BehRU6SQnWzKsAFoshrN2vpxcPByLAViofGeq38v23E,13203
+networkx/algorithms/bipartite/tests/test_link_analysis.py,sha256=vJMOtYG0vxYQCif_ztnYTUm_13gApfzFiNxChRefONg,6914
+networkx/algorithms/bipartite/tests/test_matching.py,sha256=3-2DMl3tF-g4_xNHvEuY4fZW7S5cqMTO_GUpcz1gkeQ,11973
+networkx/algorithms/bipartite/tests/test_matrix.py,sha256=TlZRVHCTKO2sqhycKFsefvdqP-Se47b_8iZwjtPpQYs,5063
+networkx/algorithms/bipartite/tests/test_project.py,sha256=WhX_yteTrXOdTZLMXpkW2A5ZFIBkw0WsnJRsNITyYtQ,15294
+networkx/algorithms/bipartite/tests/test_redundancy.py,sha256=utxcrQaTrkcEN3kqtObgKNpLZai8B5sMAqLyXatOuUo,917
+networkx/algorithms/bipartite/tests/test_spectral_bipartivity.py,sha256=1jGDgrIx3-TWOCNMSC4zxmZa7LHyMU69DXh3h12Bjag,2358
+networkx/algorithms/boundary.py,sha256=q3JtWssmn9yCB2mBdkjKZjkaxmBhkG9_dJOzmuJiQos,5339
+networkx/algorithms/bridges.py,sha256=CsxueHDOB9aFM5D8GP83u1ZKGzxF193XBpvmMReAcQk,6066
+networkx/algorithms/broadcasting.py,sha256=Amw1oRpr8pdS67aC_9wjJOQomP1IqPvqtE7c0Mf9L70,4974
+networkx/algorithms/centrality/__init__.py,sha256=Er3YoYoj76UfY4P6I0L-0fCQkO7mMU0b3NLsTT2RGWI,558
+networkx/algorithms/centrality/__pycache__/__init__.cpython-312.pyc,,
+networkx/algorithms/centrality/__pycache__/betweenness.cpython-312.pyc,,
+networkx/algorithms/centrality/__pycache__/betweenness_subset.cpython-312.pyc,,
+networkx/algorithms/centrality/__pycache__/closeness.cpython-312.pyc,,
+networkx/algorithms/centrality/__pycache__/current_flow_betweenness.cpython-312.pyc,,
+networkx/algorithms/centrality/__pycache__/current_flow_betweenness_subset.cpython-312.pyc,,
+networkx/algorithms/centrality/__pycache__/current_flow_closeness.cpython-312.pyc,,
+networkx/algorithms/centrality/__pycache__/degree_alg.cpython-312.pyc,,
+networkx/algorithms/centrality/__pycache__/dispersion.cpython-312.pyc,,
+networkx/algorithms/centrality/__pycache__/eigenvector.cpython-312.pyc,,
+networkx/algorithms/centrality/__pycache__/flow_matrix.cpython-312.pyc,,
+networkx/algorithms/centrality/__pycache__/group.cpython-312.pyc,,
+networkx/algorithms/centrality/__pycache__/harmonic.cpython-312.pyc,,
+networkx/algorithms/centrality/__pycache__/katz.cpython-312.pyc,,
+networkx/algorithms/centrality/__pycache__/laplacian.cpython-312.pyc,,
+networkx/algorithms/centrality/__pycache__/load.cpython-312.pyc,,
+networkx/algorithms/centrality/__pycache__/percolation.cpython-312.pyc,,
+networkx/algorithms/centrality/__pycache__/reaching.cpython-312.pyc,,
+networkx/algorithms/centrality/__pycache__/second_order.cpython-312.pyc,,
+networkx/algorithms/centrality/__pycache__/subgraph_alg.cpython-312.pyc,,
+networkx/algorithms/centrality/__pycache__/trophic.cpython-312.pyc,,
+networkx/algorithms/centrality/__pycache__/voterank_alg.cpython-312.pyc,,
+networkx/algorithms/centrality/betweenness.py,sha256=8829b5ep0pilM2Muqk5U0rPVQ02kwwedXaVGuQ_hY_U,22814
+networkx/algorithms/centrality/betweenness_subset.py,sha256=CUX0c96gYIORsdjOxVtif2796gOAcMitYoqEnbXDi5c,8114
+networkx/algorithms/centrality/closeness.py,sha256=ehkntG-gApT9uhWJjGaEZQ-tEQ-hdxDT7luf-uVPNAE,10281
+networkx/algorithms/centrality/current_flow_betweenness.py,sha256=kbq9XsZQvrCOdCAYvF67hRni1aqA1sT93WU2i0WfKKI,12717
+networkx/algorithms/centrality/current_flow_betweenness_subset.py,sha256=2qtLgf_3ft5qdDvHFrfYUt6zeQi42Nw7XBpSZRboJIA,8107
+networkx/algorithms/centrality/current_flow_closeness.py,sha256=IvecI8BZE4SgKayEXhKowIJw7S2fD_dN__N-f9TW-ME,3327
+networkx/algorithms/centrality/degree_alg.py,sha256=EFTA1b_GWUbmBy5R9beRQp7yh1X_NwZtk5L6is-mFGk,3894
+networkx/algorithms/centrality/dispersion.py,sha256=M12L2KiVPrC2-SyCXMF0kvxLelgcmvXJkLT_cBHoCTw,3631
+networkx/algorithms/centrality/eigenvector.py,sha256=LAxVqaT3LmuQw20__t1KrgLKPF1Cz-PkTaiSrgPC1FU,13623
+networkx/algorithms/centrality/flow_matrix.py,sha256=Y65m6VbWyYjNK0CInE_lufyEkKy9-TyPmBeXb-Gkz70,3834
+networkx/algorithms/centrality/group.py,sha256=TLlK2eWlcMX7Lvbe2wAcZrmZ9LLTvbRCz-3RbXF0Zug,27960
+networkx/algorithms/centrality/harmonic.py,sha256=OfrDikASbb0Xejjbd1kJ-lQuGT3Gv-rg3pmTtncAbho,2832
+networkx/algorithms/centrality/katz.py,sha256=uVGHAyjqndSd4y4idHjkv0mUhmKmHU5vaEfNWfiKlzc,11042
+networkx/algorithms/centrality/laplacian.py,sha256=qjyW2WnxMFo_mZqiQ4d8PVHLpXi3xNEX148Yikvk_ls,5554
+networkx/algorithms/centrality/load.py,sha256=M2EdPX4gJEYGjMBIJMFKRWGI9uYHbFOWYxsILeaJuOE,6859
+networkx/algorithms/centrality/percolation.py,sha256=YJB8iYgbpjJ3EYK8pl26iSnjgfFsK31ufytRHnUTYYE,4419
+networkx/algorithms/centrality/reaching.py,sha256=Q9rda_dqXBfVaHOi8FgZSYNHKpJ0SHfCbX_myMsIe2I,7255
+networkx/algorithms/centrality/second_order.py,sha256=4CTboP95B6gUtAtSKLfeeE4s9oq0_3hXsXczxL6c_g8,5012
+networkx/algorithms/centrality/subgraph_alg.py,sha256=YXkuyhhhZHmobNFpKDUpfeqSPyBvk97MlcJy5ESWh1s,10520
+networkx/algorithms/centrality/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/centrality/tests/__pycache__/__init__.cpython-312.pyc,,
+networkx/algorithms/centrality/tests/__pycache__/test_betweenness_centrality.cpython-312.pyc,,
+networkx/algorithms/centrality/tests/__pycache__/test_betweenness_centrality_subset.cpython-312.pyc,,
+networkx/algorithms/centrality/tests/__pycache__/test_closeness_centrality.cpython-312.pyc,,
+networkx/algorithms/centrality/tests/__pycache__/test_current_flow_betweenness_centrality.cpython-312.pyc,,
+networkx/algorithms/centrality/tests/__pycache__/test_current_flow_betweenness_centrality_subset.cpython-312.pyc,,
+networkx/algorithms/centrality/tests/__pycache__/test_current_flow_closeness.cpython-312.pyc,,
+networkx/algorithms/centrality/tests/__pycache__/test_degree_centrality.cpython-312.pyc,,
+networkx/algorithms/centrality/tests/__pycache__/test_dispersion.cpython-312.pyc,,
+networkx/algorithms/centrality/tests/__pycache__/test_eigenvector_centrality.cpython-312.pyc,,
+networkx/algorithms/centrality/tests/__pycache__/test_group.cpython-312.pyc,,
+networkx/algorithms/centrality/tests/__pycache__/test_harmonic_centrality.cpython-312.pyc,,
+networkx/algorithms/centrality/tests/__pycache__/test_katz_centrality.cpython-312.pyc,,
+networkx/algorithms/centrality/tests/__pycache__/test_laplacian_centrality.cpython-312.pyc,,
+networkx/algorithms/centrality/tests/__pycache__/test_load_centrality.cpython-312.pyc,,
+networkx/algorithms/centrality/tests/__pycache__/test_percolation_centrality.cpython-312.pyc,,
+networkx/algorithms/centrality/tests/__pycache__/test_reaching.cpython-312.pyc,,
+networkx/algorithms/centrality/tests/__pycache__/test_second_order_centrality.cpython-312.pyc,,
+networkx/algorithms/centrality/tests/__pycache__/test_subgraph.cpython-312.pyc,,
+networkx/algorithms/centrality/tests/__pycache__/test_trophic.cpython-312.pyc,,
+networkx/algorithms/centrality/tests/__pycache__/test_voterank.cpython-312.pyc,,
+networkx/algorithms/centrality/tests/test_betweenness_centrality.py,sha256=LmHNSaqExAT8kE-eOb_67Z6ckSGD_XqO56OHXhNkbFc,33669
+networkx/algorithms/centrality/tests/test_betweenness_centrality_subset.py,sha256=Y7qigLxQwFJqClJiCrKWGkcOHD467W0b6C5gBb0rFUg,13085
+networkx/algorithms/centrality/tests/test_closeness_centrality.py,sha256=-LtG4ex192Xjgy4JCTfdjdJ3Cd9Op-3XnVvG2GA3FWQ,8728
+networkx/algorithms/centrality/tests/test_current_flow_betweenness_centrality.py,sha256=1sipOadh8bsuzHZ0_7haapKU6Vrn0rbZL5HXvbsto5w,10072
+networkx/algorithms/centrality/tests/test_current_flow_betweenness_centrality_subset.py,sha256=JfRGgPuiF-vJu5fc2_pcJYREEboxcK_dmy-np39c4Aw,5839
+networkx/algorithms/centrality/tests/test_current_flow_closeness.py,sha256=vflQeoNKngrGUiRb3XNlm2X9wR4vKgMSW_sCyMUCQi8,1379
+networkx/algorithms/centrality/tests/test_degree_centrality.py,sha256=Jn_p5lThA3__ZBTDAORwo_EchjXKKkK1NwU_73HHI6M,4101
+networkx/algorithms/centrality/tests/test_dispersion.py,sha256=ROgl_5bGhcNXonNW3ylsvUcA0NCwynsQu_scic371Gw,1959
+networkx/algorithms/centrality/tests/test_eigenvector_centrality.py,sha256=AfUa7GTve0UX6QOdBF6YMipmo-gKhyCu6aT8OCSf8wc,5254
+networkx/algorithms/centrality/tests/test_group.py,sha256=833ME4tGlOGQZz8YANw4MSyeVPpjbyCdYh5X88GOprw,8685
+networkx/algorithms/centrality/tests/test_harmonic_centrality.py,sha256=wI7nStX_kIFJoZQY_i8DXXlZBOJzVnQfOP8yidX0PAU,3867
+networkx/algorithms/centrality/tests/test_katz_centrality.py,sha256=JL0bZZsJe2MQFL6urXgY82wCAwucUvhjaShYZPxpL6U,11240
+networkx/algorithms/centrality/tests/test_laplacian_centrality.py,sha256=9Nd9CfiCn2908BgRZ-cQiMQjpOFDu4Bftod1didWyCE,5898
+networkx/algorithms/centrality/tests/test_load_centrality.py,sha256=Vv3zSW89iELN-8KNbUclmkhOe1LzKdF7U_w34nYovIo,11343
+networkx/algorithms/centrality/tests/test_percolation_centrality.py,sha256=ycQ1fvEZZcWAfqL11urT7yHiEP77usJDSG25OQiDM2s,2591
+networkx/algorithms/centrality/tests/test_reaching.py,sha256=_JVeO1Ri-KybdnGCJ_yNPtJQmT_g77z0DAkU0JYFVGQ,5090
+networkx/algorithms/centrality/tests/test_second_order_centrality.py,sha256=ce0wQ4T33lu23wskzGUnBS7X4BSODlvAX1S5KxlLzOA,1999
+networkx/algorithms/centrality/tests/test_subgraph.py,sha256=vhE9Uh-_Hlk49k-ny6ORHCgqk7LWH8OHIYOEYM96uz0,3729
+networkx/algorithms/centrality/tests/test_trophic.py,sha256=mt--0AUc_8qez2SjauEHVnetC3DMwMAlLME6kgb8Lc0,8796
+networkx/algorithms/centrality/tests/test_voterank.py,sha256=tN5u7pKAnJ_4AiwhPW6EuJZz7FLIG2jYqLKcXFi2urk,1687
+networkx/algorithms/centrality/trophic.py,sha256=7mpFrpgQhwP3Ad1plpJu1WzTGR1YWrIp_SUhM0D8Zww,5328
+networkx/algorithms/centrality/voterank_alg.py,sha256=z_1eq8rSDadEO5W5BbAg1zuOJj2di4FUCkmOwiuK12I,3231
+networkx/algorithms/chains.py,sha256=PPiSq5-GsT1Lsf8fwtGwGDVf1hhv5ZLariWtfzkBbAw,6968
+networkx/algorithms/chordal.py,sha256=L-ILWdVLWE44OkWmEO_4bSo4z6Ro-_zLglfLfTrwdqQ,13411
+networkx/algorithms/clique.py,sha256=SAvORAbZrZ-IpTVuEcarETQihNes-glpNiqoZ7hEgnM,27522
+networkx/algorithms/cluster.py,sha256=sKexvbvRnjuHSAkoJ9_dzCuOWDUDQkT_KjzmkKSoAhE,24851
+networkx/algorithms/coloring/__init__.py,sha256=P1cmqrAjcaCdObkNZ1e6Hp__ZpxBAhQx0iIipOVW8jg,182
+networkx/algorithms/coloring/__pycache__/__init__.cpython-312.pyc,,
+networkx/algorithms/coloring/__pycache__/equitable_coloring.cpython-312.pyc,,
+networkx/algorithms/coloring/__pycache__/greedy_coloring.cpython-312.pyc,,
+networkx/algorithms/coloring/equitable_coloring.py,sha256=uDcza6PD9qbvwVPUX1MBZbopQdrAEKNk6DpCFkc02tU,16315
+networkx/algorithms/coloring/greedy_coloring.py,sha256=GLXbwSvitsQgmxtOsbgUt4DTkURnb2k0X-7-SNsDW9I,20043
+networkx/algorithms/coloring/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/coloring/tests/__pycache__/__init__.cpython-312.pyc,,
+networkx/algorithms/coloring/tests/__pycache__/test_coloring.cpython-312.pyc,,
+networkx/algorithms/coloring/tests/test_coloring.py,sha256=7v_d1xanjYMZCa3dq2hE2hCcyexwWBTEFV5SoLgQDv4,23697
+networkx/algorithms/communicability_alg.py,sha256=0tZvZKY-_GUUB7GsRILxabS2jEpI51Udg5ADI9ADGZw,4545
+networkx/algorithms/community/__init__.py,sha256=vfw5aY7eoL7UDk42e0JPoVzRViCzk5cQf83zbls5p90,1279
+networkx/algorithms/community/__pycache__/__init__.cpython-312.pyc,,
+networkx/algorithms/community/__pycache__/asyn_fluid.cpython-312.pyc,,
+networkx/algorithms/community/__pycache__/bipartitions.cpython-312.pyc,,
+networkx/algorithms/community/__pycache__/centrality.cpython-312.pyc,,
+networkx/algorithms/community/__pycache__/community_utils.cpython-312.pyc,,
+networkx/algorithms/community/__pycache__/divisive.cpython-312.pyc,,
+networkx/algorithms/community/__pycache__/kclique.cpython-312.pyc,,
+networkx/algorithms/community/__pycache__/label_propagation.cpython-312.pyc,,
+networkx/algorithms/community/__pycache__/leiden.cpython-312.pyc,,
+networkx/algorithms/community/__pycache__/local.cpython-312.pyc,,
+networkx/algorithms/community/__pycache__/louvain.cpython-312.pyc,,
+networkx/algorithms/community/__pycache__/lukes.cpython-312.pyc,,
+networkx/algorithms/community/__pycache__/modularity_max.cpython-312.pyc,,
+networkx/algorithms/community/__pycache__/quality.cpython-312.pyc,,
+networkx/algorithms/community/asyn_fluid.py,sha256=bsY14UgR5FKLFqhFhHKmPP4-RJsVzH6K8ogsImLnCE8,6010
+networkx/algorithms/community/bipartitions.py,sha256=jqgJyMKOCs8TwI8YM9DO8qzuVZFe4XCnYRGeVAx5P4c,12238
+networkx/algorithms/community/centrality.py,sha256=Yyv5kyf1hf_L7iQ_ZbG8_FAkP638Sc_3N4tCSoB6J1w,6635
+networkx/algorithms/community/community_utils.py,sha256=sUi-AcPYyGrYhnjI9ztt-vrSHLl28lKXxTJPfi5N0c8,908
+networkx/algorithms/community/divisive.py,sha256=yFcKfKkiI6FqEVlBVxLa1fbqI1Yeiqe_A5fpPnYvlAE,6655
+networkx/algorithms/community/kclique.py,sha256=DTr9iUT_XWv0S3Y79KQl6OXefjztNMc9SAHWhdFOxcU,2460
+networkx/algorithms/community/label_propagation.py,sha256=LhzAXSHFCPQ2kG_rPgXb06YKdppO7buApksCC4GI4w8,11878
+networkx/algorithms/community/leiden.py,sha256=dx1N_KEsy30mfJ4729rJ28qaLsnkxoqDnv3UOXV2hWQ,6964
+networkx/algorithms/community/local.py,sha256=w-LK7qlMsQ2YHbZRQP95JvqM2gHGSe4yYZi7CXNkj_M,7316
+networkx/algorithms/community/louvain.py,sha256=jscGGTF6uUnC7yGEZTcE9UFmKsLDFwlZa4ecQyVQrOU,15424
+networkx/algorithms/community/lukes.py,sha256=gzqnup95RR2UzUiPpIt8qkepzZ9dCWqHGQSVPIJDMx8,8115
+networkx/algorithms/community/modularity_max.py,sha256=Qzidmvk2QOIb-S2o4erJvLSeQWcPbLq5TVMrxw15Wc4,18093
+networkx/algorithms/community/quality.py,sha256=oEw-RZBe62janFTTs-ak62APBiF2FpQoBiHv11_4YQY,11943
+networkx/algorithms/community/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/community/tests/__pycache__/__init__.cpython-312.pyc,,
+networkx/algorithms/community/tests/__pycache__/test_asyn_fluid.cpython-312.pyc,,
+networkx/algorithms/community/tests/__pycache__/test_bipartitions.cpython-312.pyc,,
+networkx/algorithms/community/tests/__pycache__/test_centrality.cpython-312.pyc,,
+networkx/algorithms/community/tests/__pycache__/test_divisive.cpython-312.pyc,,
+networkx/algorithms/community/tests/__pycache__/test_kclique.cpython-312.pyc,,
+networkx/algorithms/community/tests/__pycache__/test_label_propagation.cpython-312.pyc,,
+networkx/algorithms/community/tests/__pycache__/test_leiden.cpython-312.pyc,,
+networkx/algorithms/community/tests/__pycache__/test_local.cpython-312.pyc,,
+networkx/algorithms/community/tests/__pycache__/test_louvain.cpython-312.pyc,,
+networkx/algorithms/community/tests/__pycache__/test_lukes.cpython-312.pyc,,
+networkx/algorithms/community/tests/__pycache__/test_modularity_max.cpython-312.pyc,,
+networkx/algorithms/community/tests/__pycache__/test_quality.cpython-312.pyc,,
+networkx/algorithms/community/tests/__pycache__/test_utils.cpython-312.pyc,,
+networkx/algorithms/community/tests/test_asyn_fluid.py,sha256=XziMTOiEhzX6cvJdLeODUC1zjOLWchhHf9Z_9Eb3TME,3738
+networkx/algorithms/community/tests/test_bipartitions.py,sha256=w7kxfw5WjKzIosCdq3eHsvuYhUoElaO9Q3lK0kVyNg4,4639
+networkx/algorithms/community/tests/test_centrality.py,sha256=s8q4k5aThR0OgO9CDQk_PXMxfllmf5uC1GlvyUc_8EY,2932
+networkx/algorithms/community/tests/test_divisive.py,sha256=-Ee40OR-mPDReTngTEhbpx4_uLtNI7cqFkt8cZT9t5Y,3441
+networkx/algorithms/community/tests/test_kclique.py,sha256=iA0SBqwbDfaD2u7KM6ccs6LfgAQY_xxrnW05UIT_tFA,2413
+networkx/algorithms/community/tests/test_label_propagation.py,sha256=IHidFEv7MI781zsdk7XT848rLvLwDk2wBK1FjL-CRv4,7985
+networkx/algorithms/community/tests/test_leiden.py,sha256=bl4jr-Z0m59AISIAl-OLsnATz1lDacNssc-ICKn72Nw,4803
+networkx/algorithms/community/tests/test_local.py,sha256=c-dy1rs1L0ahhDTQwNZP1zNbffjzRgw5IBFTCBV-fas,1809
+networkx/algorithms/community/tests/test_louvain.py,sha256=TwW1nlSKWGJeIKr9QOJ8xGehSY6R0Nz01xsnFqzt0Oo,8071
+networkx/algorithms/community/tests/test_lukes.py,sha256=f_JU-EzY6PwXEkPN8kk5_3NVg6phlX0nrj1f57M49lk,3961
+networkx/algorithms/community/tests/test_modularity_max.py,sha256=XYyPuDkxL4CYFwnpTdU_qD4GydpqgiRAIJO3CHQN_m4,10617
+networkx/algorithms/community/tests/test_quality.py,sha256=sZEy10hh3zlelUmww5r2pk5LxpZAht06PC5zCHxV1bs,5275
+networkx/algorithms/community/tests/test_utils.py,sha256=gomD6rFgAaywxT1Yjdi4ozY-1rC0ina4jgfvWeCvwGE,704
+networkx/algorithms/components/__init__.py,sha256=Dt74KZWp_cJ_j0lL5hd_S50_hia5DKcC2SjuRnubr6M,173
+networkx/algorithms/components/__pycache__/__init__.cpython-312.pyc,,
+networkx/algorithms/components/__pycache__/attracting.cpython-312.pyc,,
+networkx/algorithms/components/__pycache__/biconnected.cpython-312.pyc,,
+networkx/algorithms/components/__pycache__/connected.cpython-312.pyc,,
+networkx/algorithms/components/__pycache__/semiconnected.cpython-312.pyc,,
+networkx/algorithms/components/__pycache__/strongly_connected.cpython-312.pyc,,
+networkx/algorithms/components/__pycache__/weakly_connected.cpython-312.pyc,,
+networkx/algorithms/components/attracting.py,sha256=6az3lgqWhHTXaWUUuOPZfW9t7okliAhooFRotQY5JoM,2712
+networkx/algorithms/components/biconnected.py,sha256=_9GJdPZgqusGKZLzqT9tUSj1XZr2DgohiT6hcHVyil4,12782
+networkx/algorithms/components/connected.py,sha256=s-uvEdHkY8dNxNPS5G8jnk-qTCum-bet_yKAx8_qTXc,7904
+networkx/algorithms/components/semiconnected.py,sha256=BaBMFlQ208vuHOo5y1xeV0PDEI3yDUfH6zFb_jkcVhQ,2030
+networkx/algorithms/components/strongly_connected.py,sha256=oZGBBDzhsrCBQjIfqYlkzvXkE3sF-WTRtYEa5UYy6-k,9911
+networkx/algorithms/components/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/components/tests/__pycache__/__init__.cpython-312.pyc,,
+networkx/algorithms/components/tests/__pycache__/test_attracting.cpython-312.pyc,,
+networkx/algorithms/components/tests/__pycache__/test_biconnected.cpython-312.pyc,,
+networkx/algorithms/components/tests/__pycache__/test_connected.cpython-312.pyc,,
+networkx/algorithms/components/tests/__pycache__/test_semiconnected.cpython-312.pyc,,
+networkx/algorithms/components/tests/__pycache__/test_strongly_connected.cpython-312.pyc,,
+networkx/algorithms/components/tests/__pycache__/test_weakly_connected.cpython-312.pyc,,
+networkx/algorithms/components/tests/test_attracting.py,sha256=b3N3ZR9E5gLSQWGgaqhcRfRs4KBW6GnnkVYeAjdxC_o,2243
+networkx/algorithms/components/tests/test_biconnected.py,sha256=N-J-dgBgI77ytYUUrXjduLxtDydH7jS-af98fyPBkYc,6036
+networkx/algorithms/components/tests/test_connected.py,sha256=KMYm55BpbFdGXk_B2WozS9rIagQROd7_k0LT3HFQmr4,4815
+networkx/algorithms/components/tests/test_semiconnected.py,sha256=q860lIxZF5M2JmDwwdzy-SGSXnrillOefMx23GcJpw0,1792
+networkx/algorithms/components/tests/test_strongly_connected.py,sha256=Zm7MgUIZbuPPJu66xZH1zfMZQ_3X1YBl2fLCOjph7NQ,6021
+networkx/algorithms/components/tests/test_weakly_connected.py,sha256=_eUx7226dxme_K2WNmvSIwZXQlKNoCuglWOOC3kFUW4,3083
+networkx/algorithms/components/weakly_connected.py,sha256=q5siwSHQYtbKDcVc4dUDzfKh-DClETmuy3jLQN2_K4o,4413
+networkx/algorithms/connectivity/__init__.py,sha256=EvYKw8LJn7wyZECHAsuEkIaSl-cV-LhymR6tqcn90p8,281
+networkx/algorithms/connectivity/__pycache__/__init__.cpython-312.pyc,,
+networkx/algorithms/connectivity/__pycache__/connectivity.cpython-312.pyc,,
+networkx/algorithms/connectivity/__pycache__/cuts.cpython-312.pyc,,
+networkx/algorithms/connectivity/__pycache__/disjoint_paths.cpython-312.pyc,,
+networkx/algorithms/connectivity/__pycache__/edge_augmentation.cpython-312.pyc,,
+networkx/algorithms/connectivity/__pycache__/edge_kcomponents.cpython-312.pyc,,
+networkx/algorithms/connectivity/__pycache__/kcomponents.cpython-312.pyc,,
+networkx/algorithms/connectivity/__pycache__/kcutsets.cpython-312.pyc,,
+networkx/algorithms/connectivity/__pycache__/stoerwagner.cpython-312.pyc,,
+networkx/algorithms/connectivity/__pycache__/utils.cpython-312.pyc,,
+networkx/algorithms/connectivity/connectivity.py,sha256=xck9yth1asWFAM9Hp7UP6vdUh-Kr0IOmq046plOAXPQ,29367
+networkx/algorithms/connectivity/cuts.py,sha256=o-5GRQotOVXsNq7Kx_w7yBBVuGLa57whS2YF5DVb1KQ,23199
+networkx/algorithms/connectivity/disjoint_paths.py,sha256=57ZerbGqn30B8cwomcsS0GScectvP-mgCMb0GH-RYb8,14649
+networkx/algorithms/connectivity/edge_augmentation.py,sha256=cK9S6pRnsKLyb_57guKfrAbLiXL6sMALHCf7pR4tzFM,44063
+networkx/algorithms/connectivity/edge_kcomponents.py,sha256=hqABcfCqZ-rb45I0qYE-X4NtstsKJbxl37FZzzmoXA4,20894
+networkx/algorithms/connectivity/kcomponents.py,sha256=qDDeMqPb5rWbi6EKZwetBft5Qmv6PSUngQTVunJxyy0,8086
+networkx/algorithms/connectivity/kcutsets.py,sha256=zYohzgkR2FODi_Ew2M9uMLb_a9ZP5fNqcXJwMYy6P7o,9371
+networkx/algorithms/connectivity/stoerwagner.py,sha256=WodsJEqKgsmTTcyUBk2u3wV_CXeon-cAzveWgIGgFmA,5431
+networkx/algorithms/connectivity/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/connectivity/tests/__pycache__/__init__.cpython-312.pyc,,
+networkx/algorithms/connectivity/tests/__pycache__/test_connectivity.cpython-312.pyc,,
+networkx/algorithms/connectivity/tests/__pycache__/test_cuts.cpython-312.pyc,,
+networkx/algorithms/connectivity/tests/__pycache__/test_disjoint_paths.cpython-312.pyc,,
+networkx/algorithms/connectivity/tests/__pycache__/test_edge_augmentation.cpython-312.pyc,,
+networkx/algorithms/connectivity/tests/__pycache__/test_edge_kcomponents.cpython-312.pyc,,
+networkx/algorithms/connectivity/tests/__pycache__/test_kcomponents.cpython-312.pyc,,
+networkx/algorithms/connectivity/tests/__pycache__/test_kcutsets.cpython-312.pyc,,
+networkx/algorithms/connectivity/tests/__pycache__/test_stoer_wagner.cpython-312.pyc,,
+networkx/algorithms/connectivity/tests/test_connectivity.py,sha256=eSmsi8uQk6MI591JgtSu2elIusb08bmSZS0h9gxb76I,15027
+networkx/algorithms/connectivity/tests/test_cuts.py,sha256=q8dxYBAnsGtIBBPZCjIvMszZvXOYST2cVVsCJvXbIhw,10356
+networkx/algorithms/connectivity/tests/test_disjoint_paths.py,sha256=NLHReLoXSKoA6KPBNRbjF84ktg5PEaaktIj2AII3SDY,8392
+networkx/algorithms/connectivity/tests/test_edge_augmentation.py,sha256=gIu58oxk_uSexawlr3H1ds2HGqkTHHGhhVYUCNmfrb4,15737
+networkx/algorithms/connectivity/tests/test_edge_kcomponents.py,sha256=Bzo77zG79Lv_-OzdI1ZZKO_c13wrnFmfv60FrkDyXI0,16453
+networkx/algorithms/connectivity/tests/test_kcomponents.py,sha256=vLwQOLRevXeeid3e7SSKVpd_OyAJE8PxiAU8GYX0Tf0,9276
+networkx/algorithms/connectivity/tests/test_kcutsets.py,sha256=w5DyrjndNqyT3qxQH6WTBCuBR0ljYXatZCtcT1WeiYM,8974
+networkx/algorithms/connectivity/tests/test_stoer_wagner.py,sha256=A291C30_t2CI1erPCqN1W0DoAj3zqNA8fThPIj4Rku0,3011
+networkx/algorithms/connectivity/utils.py,sha256=gL8LmZnK4GKAZQcIPEhVNYmVi18Mqsqwg4O4j_et56s,3217
+networkx/algorithms/core.py,sha256=6SO5Wz-LSkx6t2DSq0GPmOvFALGe0gVsXdsvno9Fljs,17479
+networkx/algorithms/covering.py,sha256=I_on4DUgmwbtbo-qlBq4YWhOsNjuSHCfVGZNAL-Sefs,5278
+networkx/algorithms/cuts.py,sha256=eqwi5bhCMchItKlRAUw4wGVRtHUK0JzTkaXJFUyxXEw,10419
+networkx/algorithms/cycles.py,sha256=AGpANFoLZ2td8YkGn0cHypASJuRllAwj_-g2Vve7QW8,43302
+networkx/algorithms/d_separation.py,sha256=DpOl1YaI-72_fgUJ2NI3Piuj7EQRQ8xmyAQCRdLgjTw,26089
+networkx/algorithms/dag.py,sha256=OPgrOtnKJVMwxu2AxBGWPZyO7ti6qXa6pn57SsO8FAQ,44673
+networkx/algorithms/distance_measures.py,sha256=cQIRYjP4FtpbA3SP_dOPM6hvwpM1z77oMfmuZ4w8suI,37618
+networkx/algorithms/distance_regular.py,sha256=M9m6qitAtCXYbv2k9hDjF0CpxdeEXPu2_KOI8CCGc_I,8391
+networkx/algorithms/dominance.py,sha256=00Ng1SMzAvxodLTfAeLnXexpPb13IlB_S_mDEuT8JhY,3897
+networkx/algorithms/dominating.py,sha256=yoRB4WCe0wMvJpkbKtNo2fpd0jTVq6b09JsCYcaeR_Y,8145
+networkx/algorithms/efficiency_measures.py,sha256=VKbLKJgdIbno-YnJaLaCZt7TNXXnQPdz8N99uJCo748,4741
+networkx/algorithms/euler.py,sha256=yCqKaGchFSRPTRDXq7u1fH2IXZF94wWf9S10K9-Cd6U,14205
+networkx/algorithms/flow/__init__.py,sha256=rVtMUy6dViPLewjDRntmn15QF0bQwiDdQbZZx9j7Drc,341
+networkx/algorithms/flow/__pycache__/__init__.cpython-312.pyc,,
+networkx/algorithms/flow/__pycache__/boykovkolmogorov.cpython-312.pyc,,
+networkx/algorithms/flow/__pycache__/capacityscaling.cpython-312.pyc,,
+networkx/algorithms/flow/__pycache__/dinitz_alg.cpython-312.pyc,,
+networkx/algorithms/flow/__pycache__/edmondskarp.cpython-312.pyc,,
+networkx/algorithms/flow/__pycache__/gomory_hu.cpython-312.pyc,,
+networkx/algorithms/flow/__pycache__/maxflow.cpython-312.pyc,,
+networkx/algorithms/flow/__pycache__/mincost.cpython-312.pyc,,
+networkx/algorithms/flow/__pycache__/networksimplex.cpython-312.pyc,,
+networkx/algorithms/flow/__pycache__/preflowpush.cpython-312.pyc,,
+networkx/algorithms/flow/__pycache__/shortestaugmentingpath.cpython-312.pyc,,
+networkx/algorithms/flow/__pycache__/utils.cpython-312.pyc,,
+networkx/algorithms/flow/boykovkolmogorov.py,sha256=qFcppmiXz4VKKFd4RbDsiWOqJODtDTHbNr9_UFTjQaU,13334
+networkx/algorithms/flow/capacityscaling.py,sha256=8rng2qO5kawNSxq2S8BNlUMmdvNSoC6R8ekiBGU8LxU,14469
+networkx/algorithms/flow/dinitz_alg.py,sha256=I5nnZVsj0aU8-9Cje0umey407epFzpd7BDJpkI6ESK4,8341
+networkx/algorithms/flow/edmondskarp.py,sha256=PEIwLftevS2VYHaTzzZMSOLPy7QSBPsWPedjx1lR6Cs,8056
+networkx/algorithms/flow/gomory_hu.py,sha256=EuibaxPl65shGM9Jxvaa9WMwMmoczDvXXc2b0E81cqM,6345
+networkx/algorithms/flow/maxflow.py,sha256=GuVA4MlPwdOeCdPRXW2QVW1OdJqgzSpPhEyASr302u4,22975
+networkx/algorithms/flow/mincost.py,sha256=GzMYInS4QcNe0yImGrVXJ0bRd7t5TSSMa9jSeenIoOk,12853
+networkx/algorithms/flow/networksimplex.py,sha256=6F1JNT1pMEMt-C27H3PsdZYF-53SrJMrHaakQ8pD7Ng,25098
+networkx/algorithms/flow/preflowpush.py,sha256=CUKZ0-7X9l7P7qH_2n2Immbf8mFm8vocH2SY0tIwjGo,15721
+networkx/algorithms/flow/shortestaugmentingpath.py,sha256=gXXdkY3nH4d0hXVn0P2-kzfC3DHcuCdrudFdxetflKI,10372
+networkx/algorithms/flow/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/flow/tests/__pycache__/__init__.cpython-312.pyc,,
+networkx/algorithms/flow/tests/__pycache__/test_gomory_hu.cpython-312.pyc,,
+networkx/algorithms/flow/tests/__pycache__/test_maxflow.cpython-312.pyc,,
+networkx/algorithms/flow/tests/__pycache__/test_maxflow_large_graph.cpython-312.pyc,,
+networkx/algorithms/flow/tests/__pycache__/test_mincost.cpython-312.pyc,,
+networkx/algorithms/flow/tests/__pycache__/test_networksimplex.cpython-312.pyc,,
+networkx/algorithms/flow/tests/gl1.gpickle.bz2,sha256=z4-BzrXqruFiGqYLiS2D5ZamFz9vZRc1m2ef89qhsPg,44623
+networkx/algorithms/flow/tests/gw1.gpickle.bz2,sha256=b3nw6Q-kxR7HkWXxWWPh7YlHdXbga8qmeuYiwmBBGTE,42248
+networkx/algorithms/flow/tests/netgen-2.gpickle.bz2,sha256=OxfmbN7ajtuNHexyYmx38fZd1GdeP3bcL8T9hKoDjjA,18972
+networkx/algorithms/flow/tests/test_gomory_hu.py,sha256=aWtbI3AHofIK6LDJnmj9UH1QOfulXsi5NyB7bNyV2Vw,4471
+networkx/algorithms/flow/tests/test_maxflow.py,sha256=4CtGOqeyloAxFSajaxPfGuyVhE0R3IdJf2SuIg4kHKQ,18940
+networkx/algorithms/flow/tests/test_maxflow_large_graph.py,sha256=P2e7G8TKN17zrMeOEbSIkLwK08MjfOtNhPva3nLM-B0,4612
+networkx/algorithms/flow/tests/test_mincost.py,sha256=vI61ZCLoWAzwYU4hU0AJS8Ori8vAWEPzFDCUoiloVRk,17806
+networkx/algorithms/flow/tests/test_networksimplex.py,sha256=tCw5C1hLEwbUbt_ySWgkvRyLKj-1T2wfXV9HT4Fx77Q,14162
+networkx/algorithms/flow/tests/wlm3.gpickle.bz2,sha256=zKy6Hg-_swvsNh8OSOyIyZnTR0_Npd35O9RErOF8-g4,88132
+networkx/algorithms/flow/utils.py,sha256=jexiKM-_BQfSAy15f4iZ_Km7DvRrcdOKqi6hxu9X0MM,6246
+networkx/algorithms/graph_hashing.py,sha256=kS881g6vUvMZms856A_tblq3ljB6BanUbt5az37fSlo,16918
+networkx/algorithms/graphical.py,sha256=1NdlhXuGEgUkHPo47EoNTWUMfdeTpiv7BBVM9ty2ivw,15831
+networkx/algorithms/hierarchy.py,sha256=_KFhCF1Afr2TrkPhqx-1PXUXEtfYLhbRShC58ZKbDGE,1786
+networkx/algorithms/hybrid.py,sha256=z3sIFMOpja1wlj-lI8YI6OIbSLZWHr66uSqyVESZWXY,6209
+networkx/algorithms/isolate.py,sha256=8F4GCBHZIW21CZresBlHuZhvq85ruPH_pnlxYetbHuQ,2251
+networkx/algorithms/isomorphism/__init__.py,sha256=gPRQ-_X6xN2lJZPQNw86IVj4NemGmbQYTejf5yJ32N4,406
+networkx/algorithms/isomorphism/__pycache__/__init__.cpython-312.pyc,,
+networkx/algorithms/isomorphism/__pycache__/ismags.cpython-312.pyc,,
+networkx/algorithms/isomorphism/__pycache__/isomorph.cpython-312.pyc,,
+networkx/algorithms/isomorphism/__pycache__/isomorphvf2.cpython-312.pyc,,
+networkx/algorithms/isomorphism/__pycache__/matchhelpers.cpython-312.pyc,,
+networkx/algorithms/isomorphism/__pycache__/temporalisomorphvf2.cpython-312.pyc,,
+networkx/algorithms/isomorphism/__pycache__/tree_isomorphism.cpython-312.pyc,,
+networkx/algorithms/isomorphism/__pycache__/vf2pp.cpython-312.pyc,,
+networkx/algorithms/isomorphism/__pycache__/vf2userfunc.cpython-312.pyc,,
+networkx/algorithms/isomorphism/ismags.py,sha256=AwJKq94d5e_RU0PZs5Gm7D73v-eOBBP8QDkpPxUocd0,60177
+networkx/algorithms/isomorphism/isomorph.py,sha256=O2TZtUPe89CsZxoNchv6FyYsGU79kWrwywGFBeonksE,10561
+networkx/algorithms/isomorphism/isomorphvf2.py,sha256=NTc9uCm2RnR9RxuKsAS_70RWD1zJYCJNPhefcJZUi5U,47637
+networkx/algorithms/isomorphism/matchhelpers.py,sha256=PaZ7PjmNNsJO9KoeRrf9JgcDHIcFr1tZckQc_ol4e9I,10884
+networkx/algorithms/isomorphism/temporalisomorphvf2.py,sha256=-1NW81l8kM9orQ2ni9tcNizQzEhOUE9BaBJXjUWqhiI,10948
+networkx/algorithms/isomorphism/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/isomorphism/tests/__pycache__/__init__.cpython-312.pyc,,
+networkx/algorithms/isomorphism/tests/__pycache__/test_ismags.cpython-312.pyc,,
+networkx/algorithms/isomorphism/tests/__pycache__/test_isomorphism.cpython-312.pyc,,
+networkx/algorithms/isomorphism/tests/__pycache__/test_isomorphvf2.cpython-312.pyc,,
+networkx/algorithms/isomorphism/tests/__pycache__/test_match_helpers.cpython-312.pyc,,
+networkx/algorithms/isomorphism/tests/__pycache__/test_temporalisomorphvf2.cpython-312.pyc,,
+networkx/algorithms/isomorphism/tests/__pycache__/test_tree_isomorphism.cpython-312.pyc,,
+networkx/algorithms/isomorphism/tests/__pycache__/test_vf2pp.cpython-312.pyc,,
+networkx/algorithms/isomorphism/tests/__pycache__/test_vf2pp_helpers.cpython-312.pyc,,
+networkx/algorithms/isomorphism/tests/__pycache__/test_vf2userfunc.cpython-312.pyc,,
+networkx/algorithms/isomorphism/tests/iso_r01_s80.A99,sha256=hKzMtYLUR8Oqp9pmJR6RwG7qo31aNPZcnXy4KHDGhqU,1442
+networkx/algorithms/isomorphism/tests/iso_r01_s80.B99,sha256=AHx_W2xG4JEcz1xKoN5TwCHVE6-UO2PiMByynkd4TPE,1442
+networkx/algorithms/isomorphism/tests/si2_b06_m200.A99,sha256=NVnPFA52amNl3qM55G1V9eL9ZlP9NwugBlPf-zekTFU,310
+networkx/algorithms/isomorphism/tests/si2_b06_m200.B99,sha256=-clIDp05LFNRHA2BghhGTeyuXDqBBqA9XpEzpB7Ku7M,1602
+networkx/algorithms/isomorphism/tests/test_ismags.py,sha256=YIrF8xSbnY8zsxiqjSZkzMFXF9TKwZ91m9araTfxJwE,24323
+networkx/algorithms/isomorphism/tests/test_isomorphism.py,sha256=e92l9AcYLKISmXB3hOdKanrvgKlUKuQ0TuXz7xuCD1Q,4576
+networkx/algorithms/isomorphism/tests/test_isomorphvf2.py,sha256=fVZZQgTU_L_kgp6KsiVwy5iLBewVFzXGDl72VQ0CgS0,15303
+networkx/algorithms/isomorphism/tests/test_match_helpers.py,sha256=uuTcvjgf2LPqSQzzECPIh0dezw8-a1IN0u42u8TxwAw,2483
+networkx/algorithms/isomorphism/tests/test_temporalisomorphvf2.py,sha256=k8032J4ItZ4aFHeOraOpiF8y4aPm2O1g44UvUfrQJgg,7343
+networkx/algorithms/isomorphism/tests/test_tree_isomorphism.py,sha256=mZPWRv2sSVJ9PbpGi5MEj5GaFbrp_ha2bL1wre1-Jqo,5681
+networkx/algorithms/isomorphism/tests/test_vf2pp.py,sha256=u_baOdKDdp34CQWwPob8henY90k8_hdK82SQDGesaO0,51386
+networkx/algorithms/isomorphism/tests/test_vf2pp_helpers.py,sha256=A8Y-FcGsLPWvmci5oHHDowSeh-Fhl_y88TrvboPZwdw,90251
+networkx/algorithms/isomorphism/tests/test_vf2userfunc.py,sha256=TrXs7E3Ynva18dBmaJDO4QGsySteCwK32cUKw-WkZ0I,6309
+networkx/algorithms/isomorphism/tree_isomorphism.py,sha256=J4RfMpO5LfL5z_wI3xP2wcbK2vMFEsxAQqBddPdw3YA,9033
+networkx/algorithms/isomorphism/vf2pp.py,sha256=jM3mzJNC0EutWHDmDkKIh1JfsB9XbpTkzEC6qXD0Lpo,36681
+networkx/algorithms/isomorphism/vf2userfunc.py,sha256=HiPwyr7nJF1QS9w69MzKf6wGvO8cgjvdS5vW59iwCew,7371
+networkx/algorithms/link_analysis/__init__.py,sha256=UkcgTDdzsIu-jsJ4jBwP8sF2CsRPC1YcZZT-q5Wlj3I,118
+networkx/algorithms/link_analysis/__pycache__/__init__.cpython-312.pyc,,
+networkx/algorithms/link_analysis/__pycache__/hits_alg.cpython-312.pyc,,
+networkx/algorithms/link_analysis/__pycache__/pagerank_alg.cpython-312.pyc,,
+networkx/algorithms/link_analysis/hits_alg.py,sha256=ot5sEhIvQ-JruYgcqCoi_EvNk89UWx_skG4KayIuO9I,10439
+networkx/algorithms/link_analysis/pagerank_alg.py,sha256=e7HuXXXVCG79YG0iuIOr1wqA_zC60hKoXGlMfvh9k1o,17202
+networkx/algorithms/link_analysis/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/link_analysis/tests/__pycache__/__init__.cpython-312.pyc,,
+networkx/algorithms/link_analysis/tests/__pycache__/test_hits.cpython-312.pyc,,
+networkx/algorithms/link_analysis/tests/__pycache__/test_pagerank.cpython-312.pyc,,
+networkx/algorithms/link_analysis/tests/test_hits.py,sha256=BQ7QHXvJDkXtK-_VDFagtdp_-VXxVerwPymjGjzFWA0,2546
+networkx/algorithms/link_analysis/tests/test_pagerank.py,sha256=rUJNa_2nKDSk75Fg1yygMPAqg_Bdk0gGWMDRKY8g1lk,7282
+networkx/algorithms/link_prediction.py,sha256=UYo_LJgoVXcM1iLMXswM2g4jvUJmvxln3e5bVfXxQ10,22253
+networkx/algorithms/lowest_common_ancestors.py,sha256=D1LgoX_ibv2hR-viKEx6l_qp3mWVCkW6YAlGGdoWgXQ,9286
+networkx/algorithms/matching.py,sha256=Xgi-zy9C2pNvGwTixTFV7ut7W-l8s7zUgJha9v8D0s8,44325
+networkx/algorithms/minors/__init__.py,sha256=ceeKdsZ6U1H40ED-KmtVGkbADxeWMTVG07Ja8P7N_Pg,587
+networkx/algorithms/minors/__pycache__/__init__.cpython-312.pyc,,
+networkx/algorithms/minors/__pycache__/contraction.cpython-312.pyc,,
+networkx/algorithms/minors/contraction.py,sha256=o5i1UfWpI1KhD4-pVx4yuFJvwi00yJx58Te6GYpys7Y,27606
+networkx/algorithms/minors/tests/__pycache__/test_contraction.cpython-312.pyc,,
+networkx/algorithms/minors/tests/test_contraction.py,sha256=31FgiENkElrScHzJrQ3DcKG8W2ieow6zI7PZ9wgVJKE,17674
+networkx/algorithms/mis.py,sha256=BEMv_dW8R6CjMMXJQGIhS4HpS8A8AkLJJWnz3GstuS4,2344
+networkx/algorithms/moral.py,sha256=z5lp42k4kqYk7t_FfszVj5KAC7BxXe6Adik3T2qvA6o,1535
+networkx/algorithms/node_classification.py,sha256=s2yjsHk4mj_6llCuawgGvJ59HyswbcW6ufGQC4UBmG0,6465
+networkx/algorithms/non_randomness.py,sha256=rjIoT7-aqKwGSBNoYxgKniDFgqSDwV8Hh21lkWRYGVE,5787
+networkx/algorithms/operators/__init__.py,sha256=dJ3xOXvHxSzzM3-YcfvjGTJ_ndxULF1TybkIRzUS87Y,201
+networkx/algorithms/operators/__pycache__/__init__.cpython-312.pyc,,
+networkx/algorithms/operators/__pycache__/all.cpython-312.pyc,,
+networkx/algorithms/operators/__pycache__/binary.cpython-312.pyc,,
+networkx/algorithms/operators/__pycache__/product.cpython-312.pyc,,
+networkx/algorithms/operators/__pycache__/unary.cpython-312.pyc,,
+networkx/algorithms/operators/all.py,sha256=v_W9ZT3u4STNvT4YI9zYn1Z2PDMhqfh4vfhtO4glaIA,9718
+networkx/algorithms/operators/binary.py,sha256=hziSCLDIVIoTWPV56fED5gI1pErOdyLOQ3Z_E_Nz9As,13150
+networkx/algorithms/operators/product.py,sha256=FQkSIduOv-z1ktVzid2T40759S-BmAfTlya88VytuZc,19632
+networkx/algorithms/operators/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/operators/tests/__pycache__/__init__.cpython-312.pyc,,
+networkx/algorithms/operators/tests/__pycache__/test_all.cpython-312.pyc,,
+networkx/algorithms/operators/tests/__pycache__/test_binary.cpython-312.pyc,,
+networkx/algorithms/operators/tests/__pycache__/test_product.cpython-312.pyc,,
+networkx/algorithms/operators/tests/__pycache__/test_unary.cpython-312.pyc,,
+networkx/algorithms/operators/tests/test_all.py,sha256=Jn8IfNZ1P4Aa51C0gU58S2A-DPksQUFersWco0kG0Yw,8280
+networkx/algorithms/operators/tests/test_binary.py,sha256=BdZQS-qsWbEbRXuWANvH2eXEv7myAKyuldtQzHj6n4Y,12190
+networkx/algorithms/operators/tests/test_product.py,sha256=i4pBb5A4NmaCsllR1XizyhUToaQFMuLZ-JrywkQFdbU,15155
+networkx/algorithms/operators/tests/test_unary.py,sha256=UZdzbt5GI9hnflEizUWXihGqBWmSFJDkzjwVv6wziQE,1415
+networkx/algorithms/operators/unary.py,sha256=Eo2yeTg-F5uODGWSWR_im5VaKZQ97LyATIuKZcAFQR8,1795
+networkx/algorithms/perfect_graph.py,sha256=aMdQkfcXEySVutIOwngHkvDEy1qinO_92uZFJx6Ydnk,2597
+networkx/algorithms/planar_drawing.py,sha256=AXuoT3aFgEtCeMnAaUsRqjxCABdNYZ8Oo9sGOKBQto0,16254
+networkx/algorithms/planarity.py,sha256=nN6QCMz9PJYRqnAa06qEDANdd9bxsbO64PQdbVEGwk4,49887
+networkx/algorithms/polynomials.py,sha256=iP30_mcOlj81Vrzt4iB_ZZxYiRokubs-O1i9RW4pgTw,11278
+networkx/algorithms/reciprocity.py,sha256=1WMhLbSMkVPxRPlfUvbgO5FgVvJHn1doXQF4WuqSLQk,2855
+networkx/algorithms/regular.py,sha256=fEHD4VBREbJwSlR48okVZBuwgvD76GXdT28NitJI8qQ,4877
+networkx/algorithms/richclub.py,sha256=kARzso3M6wnUcAJo2g8ga_ZtigL2czDNzeUDzBtRfqo,4892
+networkx/algorithms/shortest_paths/__init__.py,sha256=Rmxtsje-mPdQyeYhE8TP2NId-iZEOu4eAsWhVRm2Xqk,285
+networkx/algorithms/shortest_paths/__pycache__/__init__.cpython-312.pyc,,
+networkx/algorithms/shortest_paths/__pycache__/astar.cpython-312.pyc,,
+networkx/algorithms/shortest_paths/__pycache__/dense.cpython-312.pyc,,
+networkx/algorithms/shortest_paths/__pycache__/generic.cpython-312.pyc,,
+networkx/algorithms/shortest_paths/__pycache__/unweighted.cpython-312.pyc,,
+networkx/algorithms/shortest_paths/__pycache__/weighted.cpython-312.pyc,,
+networkx/algorithms/shortest_paths/astar.py,sha256=0pEnYNzG7Z86zWqyFe0OL8HTlQO9PwjDABy_ypC30_A,8937
+networkx/algorithms/shortest_paths/dense.py,sha256=5Y8ziU-RsWZRTzxEEzg5gB7f4j9yxbNhplTbLaMliG8,8261
+networkx/algorithms/shortest_paths/generic.py,sha256=-7wIqqDWeScy8brYFkdt68nuxkSgXVs1iXcwGWoBZAU,25337
+networkx/algorithms/shortest_paths/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/shortest_paths/tests/__pycache__/__init__.cpython-312.pyc,,
+networkx/algorithms/shortest_paths/tests/__pycache__/test_astar.cpython-312.pyc,,
+networkx/algorithms/shortest_paths/tests/__pycache__/test_dense.cpython-312.pyc,,
+networkx/algorithms/shortest_paths/tests/__pycache__/test_dense_numpy.cpython-312.pyc,,
+networkx/algorithms/shortest_paths/tests/__pycache__/test_generic.cpython-312.pyc,,
+networkx/algorithms/shortest_paths/tests/__pycache__/test_unweighted.cpython-312.pyc,,
+networkx/algorithms/shortest_paths/tests/__pycache__/test_weighted.cpython-312.pyc,,
+networkx/algorithms/shortest_paths/tests/test_astar.py,sha256=F0zXZ7R0eXP8Et4F3mrCtdtfE1-tQTGB2ATcFveDUHI,8989
+networkx/algorithms/shortest_paths/tests/test_dense.py,sha256=ievl4gu3Exl_31hp4OKcsAGPb3g3_xFUM4t3NnvrG_A,6747
+networkx/algorithms/shortest_paths/tests/test_dense_numpy.py,sha256=IEwhjPNTlc2H1on-B3WhFoyLkDkJVdAFBjn675XALHA,2299
+networkx/algorithms/shortest_paths/tests/test_generic.py,sha256=CQJxa5by1xE1a2E8iZm8GAtiPy_DILcrB4dIyWVM_qM,20609
+networkx/algorithms/shortest_paths/tests/test_unweighted.py,sha256=r1F5qVEDZnzPn5yJ71Rp-Z7pq33CzJFfZmDhVBekR9Y,5879
+networkx/algorithms/shortest_paths/tests/test_weighted.py,sha256=dzMts7Y1mMUuz4zEz4adEqYUNoXi9BMf-oyzQ0BMG3s,35502
+networkx/algorithms/shortest_paths/unweighted.py,sha256=iuJAO3WzB1p-fwpDyGM4snuFB5k57KIsVGcAJUhCpi0,17825
+networkx/algorithms/shortest_paths/weighted.py,sha256=PphAp7PmN9qpWzkLudePIVgvySh_SGDi5GhdQN5iufk,84155
+networkx/algorithms/similarity.py,sha256=E8P8vWqCR-r2SFVSqW9Y-Bb4I4R7BzUc_jzhiCYx7tU,72679
+networkx/algorithms/simple_paths.py,sha256=8oG_bRDVRrBKVCDEjZLHW3Qyzrv5KVynp-Hl0m5SNmA,31091
+networkx/algorithms/smallworld.py,sha256=3xT-z2_CVdp5-Ap8vF6fsd3DiavDYtspFNZrcwcpXG0,13565
+networkx/algorithms/smetric.py,sha256=_Aj4BIMnafiXbJtLkvAfAnIEMdI9OcVvMy6kk9KKTns,770
+networkx/algorithms/sparsifiers.py,sha256=4T8pMlh-usEHA2-rZFh-CmZbBY9dcXIHjoqR-oJ2hSw,10048
+networkx/algorithms/structuralholes.py,sha256=rYaVkndSJ3kFxbjkhfQd6uMBpYO7NNlcsOPR0Xbiy7Y,12626
+networkx/algorithms/summarization.py,sha256=CygTsSthyCKHs0ZTZsCgWnyaT8annQbLpUtahmfY9Sw,23251
+networkx/algorithms/swap.py,sha256=NVZMmlnkdxgwwNw5GDrc8waNERcdCu52ydHcBdOA_hw,14744
+networkx/algorithms/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/tests/__pycache__/__init__.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_asteroidal.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_boundary.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_bridges.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_broadcasting.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_chains.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_chordal.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_clique.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_cluster.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_communicability.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_core.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_covering.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_cuts.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_cycles.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_d_separation.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_dag.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_distance_measures.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_distance_regular.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_dominance.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_dominating.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_efficiency.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_euler.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_graph_hashing.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_graphical.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_hierarchy.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_hybrid.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_isolate.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_link_prediction.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_lowest_common_ancestors.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_matching.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_max_weight_clique.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_mis.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_moral.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_node_classification.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_non_randomness.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_perfect_graph.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_planar_drawing.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_planarity.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_polynomials.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_reciprocity.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_regular.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_richclub.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_similarity.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_simple_paths.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_smallworld.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_smetric.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_sparsifiers.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_structuralholes.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_summarization.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_swap.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_threshold.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_time_dependent.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_tournament.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_triads.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_vitality.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_voronoi.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_walks.cpython-312.pyc,,
+networkx/algorithms/tests/__pycache__/test_wiener.cpython-312.pyc,,
+networkx/algorithms/tests/test_asteroidal.py,sha256=DnWI5_jnaaZMxtG44XD0K690HZs8ez7HU_9dSR-p6eA,502
+networkx/algorithms/tests/test_boundary.py,sha256=1OSJh32FYFhAVYB5zqxhZGEXZLS0HPp9kvfHZvWmD3o,6227
+networkx/algorithms/tests/test_bridges.py,sha256=jSCguECho0GNHnu0vpRh1twyfGP6tWFcaYL1rgvc8mU,4026
+networkx/algorithms/tests/test_broadcasting.py,sha256=GqjkpHC5Z7ogZZdf1qsz5B1lmX-Pd5pFMD5e3QRPAkI,3034
+networkx/algorithms/tests/test_chains.py,sha256=4fR5Uh2NMrTZGT1yR6sAsQEP3uy1U3UnwjcXLFk9d1Y,4196
+networkx/algorithms/tests/test_chordal.py,sha256=DPdNPY7KtqCsCwYVb4xQfnIm-z35dUJIWxNHtAiQLAQ,4438
+networkx/algorithms/tests/test_clique.py,sha256=RX1Q38DRDmclLLJ04pfE5RIFAy86EuTZ2QAERrtkjS4,9772
+networkx/algorithms/tests/test_cluster.py,sha256=b0OXtKvUYGzDxBrnIbPh8A3vo3jmRYOFzW02MVSWYgo,19320
+networkx/algorithms/tests/test_communicability.py,sha256=4KK9wU9gAUqHAAAyHwAKpq2dV9g415s_X0qd7Tt83gU,2938
+networkx/algorithms/tests/test_core.py,sha256=Q3bi_c0LpxZ-0VopHU6Lyzkb_JKseVT16H45qDuax9A,9619
+networkx/algorithms/tests/test_covering.py,sha256=EeBjQ5mxcVctgavqXZ255T8ryFocuxjxdVpIxVUNFvw,2718
+networkx/algorithms/tests/test_cuts.py,sha256=gKm9VDtnmwFli6kgwV1ktEFI_rw84p2Sg02Em6SoW5Q,5376
+networkx/algorithms/tests/test_cycles.py,sha256=CBEQ_kNlHg5PHb9vKMS9ot-lqUuvs_cAgaPtnEQn76g,34851
+networkx/algorithms/tests/test_d_separation.py,sha256=cxoAOA_EahXQHFsFaRopz6cp3h5sMnD7D_isq4_EuWI,10714
+networkx/algorithms/tests/test_dag.py,sha256=sd6OlsrK57rY7x6vMfWSf11tEiKH5BakNp7747KvCnA,29407
+networkx/algorithms/tests/test_distance_measures.py,sha256=kF-pR5WbVBs1d_IO-U6Dr-sf8MaRHfxc_D286sBN62E,28793
+networkx/algorithms/tests/test_distance_regular.py,sha256=w27OTUtAI0VQv7cikkOdJg4bo4q7xTNIVE8nbU_x7b8,2915
+networkx/algorithms/tests/test_dominance.py,sha256=rD-m7LVQpqrOTCUJrli43lYpezYxajfkcNd3xvGhTj8,9811
+networkx/algorithms/tests/test_dominating.py,sha256=5WwPlrQ6_pFaVx_-K4D5cHNbCZL23qp-PytgsXDuS4Q,3112
+networkx/algorithms/tests/test_efficiency.py,sha256=QKWMvyjCG1Byt-oNp7Rz_qxnVeT77Zk27lrzI1qH0mA,1894
+networkx/algorithms/tests/test_euler.py,sha256=L4L1ljHVxQxjQQludO2r6k3UZU7WAY_N6WYUjFx1fEk,11209
+networkx/algorithms/tests/test_graph_hashing.py,sha256=ribxC8ZkNxkkBDyjSZ8P2f8J6y5y4g-Ik-k5hBgZcx4,31567
+networkx/algorithms/tests/test_graphical.py,sha256=uhFjvs04odxABToY4IRig_CaUTpAC3SfZRu1p1T7FwY,5366
+networkx/algorithms/tests/test_hierarchy.py,sha256=uW8DqCdXiAeypkNPKcAYX7aW86CawYH84Q0bW4cDTXo,1184
+networkx/algorithms/tests/test_hybrid.py,sha256=kQLzaMoqZcKFaJ3D7PKbY2O-FX59XDZ1pN5un8My-tk,720
+networkx/algorithms/tests/test_isolate.py,sha256=LyR0YYHJDH5vppQzGzGiJK-aaIV17_Jmla8dMf93olg,555
+networkx/algorithms/tests/test_link_prediction.py,sha256=lP6slSHwXdzdJzNSeMTUsP88ypSqe6EeVy-bUP2d-48,20451
+networkx/algorithms/tests/test_lowest_common_ancestors.py,sha256=5ZT_17q-5ipw7NNgNisaVcxIxrY6XeQQaUlBXHx9k9g,14160
+networkx/algorithms/tests/test_matching.py,sha256=1IKeUi49HR8aAOm2V4cmBL2NGXvF9cb8mqW9jnkNGuY,18319
+networkx/algorithms/tests/test_max_weight_clique.py,sha256=M1eoy8OtuQVZkEvNMauV9vqR6hHtOCrtq6INv2qzMyA,6739
+networkx/algorithms/tests/test_mis.py,sha256=Z2tKoqbs-AFPzEBDYO7S8U-F7usLfZJ2l6j2DpZUts4,1865
+networkx/algorithms/tests/test_moral.py,sha256=15PZgkx7O9aXQB1npQ2JNqBBkEqPPP2RfeZzKqY-GNU,452
+networkx/algorithms/tests/test_node_classification.py,sha256=NgJJKUHH1GoD1GE3F4QRYBLM3fUo_En3RNtZvhqCjlg,4663
+networkx/algorithms/tests/test_non_randomness.py,sha256=iDHCFzFvxGXCi_vWnv-DkXHcmO9uU6KVpYGMCpHKQG8,1678
+networkx/algorithms/tests/test_perfect_graph.py,sha256=Y2mpreh5TNCkqn4PDO57MFkgYozt-tlZFScKH3TZJRg,609
+networkx/algorithms/tests/test_planar_drawing.py,sha256=fBTd9JzDkTqNQz7GBQCS9lShU1P3lWRQ7L-E5WhSdlA,8765
+networkx/algorithms/tests/test_planarity.py,sha256=2iy22H4APB2K0DiPcoWmiQV9BTQlJ9JSOexubN14sU0,17312
+networkx/algorithms/tests/test_polynomials.py,sha256=baI0Kua1pRngRC6Scm5gRRwi1bl0iET5_Xxo3AZTP3A,1983
+networkx/algorithms/tests/test_reciprocity.py,sha256=X_PXWFOTzuEcyMWpRdwEJfm8lJOfNE_1rb9AAybf4is,1296
+networkx/algorithms/tests/test_regular.py,sha256=ppXES6zvpsppoZmzXPFim-S4ZMWPG2Zhhmlgc67y_GA,2951
+networkx/algorithms/tests/test_richclub.py,sha256=Wl8aE0CSswaXJiHCQ42IkyRvjWaJQZ2OQcbC7LpIgfo,3962
+networkx/algorithms/tests/test_similarity.py,sha256=l02q6PMnweng8EfUm6Z0yor-Uy-zd6WN0Tm28lh3pBU,41248
+networkx/algorithms/tests/test_simple_paths.py,sha256=7U9wCXz4SHK0XeYrs1k2KjYgrYVQDnts2ggQLzU18p0,25181
+networkx/algorithms/tests/test_smallworld.py,sha256=bmoNDxIuhV0bBKWh2hgFw0XYTPCc2rgg1y77uMg6rE8,2390
+networkx/algorithms/tests/test_smetric.py,sha256=VM14L4X1AABvINDL9qKXzlech_Q2g4Aee-ozWM2Qrr4,144
+networkx/algorithms/tests/test_sparsifiers.py,sha256=1GRbQy1vfmwv6eUhP4Io0aykH2VyTJfFWmncrXmTqi4,4044
+networkx/algorithms/tests/test_structuralholes.py,sha256=F0xZ1nlKJLGmQDebDiExju4fMffu79qThnyF7ZGA53A,7592
+networkx/algorithms/tests/test_summarization.py,sha256=uNyaUstobIEu6M_Hexik-3YiYTRSy_XO6LUqoE4wazw,21312
+networkx/algorithms/tests/test_swap.py,sha256=WJtGMkSbAd1Cv06VaUeDVHosNOtdigsqEspyux0ExCs,6144
+networkx/algorithms/tests/test_threshold.py,sha256=x0hqqbH65nbDNEUV0vYz0J2TSmmBbJ0daEgLIR7CRm0,9733
+networkx/algorithms/tests/test_time_dependent.py,sha256=NmuV2kDo4nh2MeN0hwcJf0QSDtqMD0dfSeeKSsYBtQ8,13342
+networkx/algorithms/tests/test_tournament.py,sha256=tfOPwN7YHnw0oxl9d7-ErPBFKz6KBfSc5S3tbGrGHs8,4107
+networkx/algorithms/tests/test_triads.py,sha256=CbnFABCMDU0X1mzu3tzW4-WL2qn5ptaDTOShNaTjIwk,8219
+networkx/algorithms/tests/test_vitality.py,sha256=p5lPWCtVMtbvxDw6TJUaf8vpb0zKPoz5pND722xiypQ,1380
+networkx/algorithms/tests/test_voronoi.py,sha256=M4B6JtkJUw56ULEWRs1kyVEUsroNrnb5FBq9OioAyHM,3477
+networkx/algorithms/tests/test_walks.py,sha256=X8cb-YvGHiiqbMEXuKMSdTAb9WtVtbHjIESNSqpJTmU,1499
+networkx/algorithms/tests/test_wiener.py,sha256=uT6Es_OFbJqxnVY7lImzlJSRTQS4eJnMaKotKbObMd8,4186
+networkx/algorithms/threshold.py,sha256=maOMixTxDibvBL2BkVcaYz1Co_09jg8d7DpAW2blNnY,30776
+networkx/algorithms/time_dependent.py,sha256=PAeJ7Yt8kUqbDgvBaz_ZfUFZg-w-vf1gPC0HO6go_TI,5762
+networkx/algorithms/tournament.py,sha256=TyWD0P-8JYXsckulbyr-bkKOoc0gLUHK59R1RQm2We4,11613
+networkx/algorithms/traversal/__init__.py,sha256=YtFrfNjciqTOI6jGePQaJ01tRSEQXTHqTGGNhDEDb_8,142
+networkx/algorithms/traversal/__pycache__/__init__.cpython-312.pyc,,
+networkx/algorithms/traversal/__pycache__/beamsearch.cpython-312.pyc,,
+networkx/algorithms/traversal/__pycache__/breadth_first_search.cpython-312.pyc,,
+networkx/algorithms/traversal/__pycache__/depth_first_search.cpython-312.pyc,,
+networkx/algorithms/traversal/__pycache__/edgebfs.cpython-312.pyc,,
+networkx/algorithms/traversal/__pycache__/edgedfs.cpython-312.pyc,,
+networkx/algorithms/traversal/beamsearch.py,sha256=Vn0U4Wck8ICShIAGggv3tVtQWVW0ABEz_hcBsGrql6o,3473
+networkx/algorithms/traversal/breadth_first_search.py,sha256=KGpFnXuCQrDwcQg27Irtrqu7hcIWlFSlVWGpA26XbHA,18259
+networkx/algorithms/traversal/depth_first_search.py,sha256=2V4T3tGujcAtV3W6WcTQUjGAAe3b1rqinONowUhLsa8,16795
+networkx/algorithms/traversal/edgebfs.py,sha256=JJ1mQCmv8WydqQtIVQC1HqkqEFDMeKVzJ_hexwU8sXA,6333
+networkx/algorithms/traversal/edgedfs.py,sha256=T1xHGr8p_eC1pEUyCP-kpaYlIY_la_ms-J0-50c4EDk,6041
+networkx/algorithms/traversal/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/traversal/tests/__pycache__/__init__.cpython-312.pyc,,
+networkx/algorithms/traversal/tests/__pycache__/test_beamsearch.cpython-312.pyc,,
+networkx/algorithms/traversal/tests/__pycache__/test_bfs.cpython-312.pyc,,
+networkx/algorithms/traversal/tests/__pycache__/test_dfs.cpython-312.pyc,,
+networkx/algorithms/traversal/tests/__pycache__/test_edgebfs.cpython-312.pyc,,
+networkx/algorithms/traversal/tests/__pycache__/test_edgedfs.cpython-312.pyc,,
+networkx/algorithms/traversal/tests/test_beamsearch.py,sha256=bzUcswZ1qo0ecDZYSER_4enbsW6SjTpb_3Nb3fqmkAo,900
+networkx/algorithms/traversal/tests/test_bfs.py,sha256=tGQSiYhc6BxaZEuw-G3ZxVfYLN7q0zrP_BeKl6EfxkU,6447
+networkx/algorithms/traversal/tests/test_dfs.py,sha256=rQMq7GToM6CVU3WwIZfmqa-HrqlmvIT1DryRU7NbU_U,10580
+networkx/algorithms/traversal/tests/test_edgebfs.py,sha256=8oplCu0fct3QipT0JB0-292EA2aOm8zWlMkPedfe6iY,4702
+networkx/algorithms/traversal/tests/test_edgedfs.py,sha256=HGmC3GUYSn9XLMHQpdefdE6g-Uh3KqbmgEEXBcckdYc,4775
+networkx/algorithms/tree/__init__.py,sha256=wOh_v70XEdFHL2qUMje7qkJI5RcjFNrDremJYl4zzkg,182
+networkx/algorithms/tree/__pycache__/__init__.cpython-312.pyc,,
+networkx/algorithms/tree/__pycache__/branchings.cpython-312.pyc,,
+networkx/algorithms/tree/__pycache__/coding.cpython-312.pyc,,
+networkx/algorithms/tree/__pycache__/decomposition.cpython-312.pyc,,
+networkx/algorithms/tree/__pycache__/distance_measures.cpython-312.pyc,,
+networkx/algorithms/tree/__pycache__/mst.cpython-312.pyc,,
+networkx/algorithms/tree/__pycache__/operations.cpython-312.pyc,,
+networkx/algorithms/tree/__pycache__/recognition.cpython-312.pyc,,
+networkx/algorithms/tree/branchings.py,sha256=B0c_uKpcnV2SwJMZJRK0BMEz8LkvIcOhv1y0AI0gTnY,34339
+networkx/algorithms/tree/coding.py,sha256=l9P4jhmhg_9uYBVMNSmLYW8btHJH07-Sl2SIKJtO1LA,13466
+networkx/algorithms/tree/decomposition.py,sha256=lY_rqx9JxnLEkp1wiAv0mX62PGPwGQ6SW4Jp48o8aiw,3071
+networkx/algorithms/tree/distance_measures.py,sha256=Dwtk2BRTXmEGjFFtpiAbk02HrX2Hb5kjXusfwn6nm9M,6981
+networkx/algorithms/tree/mst.py,sha256=UMeSnnpKrPeq7a_w_tR415w9TOLltmzuXyIy_HfqbAU,46145
+networkx/algorithms/tree/operations.py,sha256=TjfLQpxwlaLgdOnhLkdzHfZ68yFCYz6BMzzh_d_2mJc,4048
+networkx/algorithms/tree/recognition.py,sha256=bYnaDN0ZaIWTgq0tbPEHAcdxQBWZpDvWypZarBbA334,7569
+networkx/algorithms/tree/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/tree/tests/__pycache__/__init__.cpython-312.pyc,,
+networkx/algorithms/tree/tests/__pycache__/test_branchings.cpython-312.pyc,,
+networkx/algorithms/tree/tests/__pycache__/test_coding.cpython-312.pyc,,
+networkx/algorithms/tree/tests/__pycache__/test_decomposition.cpython-312.pyc,,
+networkx/algorithms/tree/tests/__pycache__/test_distance_measures.cpython-312.pyc,,
+networkx/algorithms/tree/tests/__pycache__/test_mst.cpython-312.pyc,,
+networkx/algorithms/tree/tests/__pycache__/test_operations.cpython-312.pyc,,
+networkx/algorithms/tree/tests/__pycache__/test_recognition.cpython-312.pyc,,
+networkx/algorithms/tree/tests/test_branchings.py,sha256=euky-3tFOV5CVV5v_yFawuVGCaqTuTrKtBIkCygwhiA,17731
+networkx/algorithms/tree/tests/test_coding.py,sha256=XC6SbfA2zVGH4FyJJyv6o8eOnBu7FNzNot3SKs7QmEo,3955
+networkx/algorithms/tree/tests/test_decomposition.py,sha256=vnl_xoQzi1LnlZL25vXOZWwvaWmon3-x222OKt4eDqE,1871
+networkx/algorithms/tree/tests/test_distance_measures.py,sha256=WNzqjgDuFLUt_NgjD4R8gGhbYhQ3F5a4HZfBBipunv0,3389
+networkx/algorithms/tree/tests/test_mst.py,sha256=D3o217cjuUtf0TxZ9ks1wqQ4cpwVySoOBYfg0Jmr1AU,32376
+networkx/algorithms/tree/tests/test_operations.py,sha256=ybU96kROTVJRTyjLG7JSJjYlPxaWmYjUVJqbXV5VGGI,1961
+networkx/algorithms/tree/tests/test_recognition.py,sha256=qeMEIvg-j2MqaU-TNIQhCcXxao8vTBy0wjpU7jr2iw8,4521
+networkx/algorithms/triads.py,sha256=FqOtB5fi40k4EoA_-bV1TBwimsRihAqrVdFyNnq0hns,14233
+networkx/algorithms/vitality.py,sha256=8M1cubIydO49El2kwVCURHZ2UwCtfGVFeGS8-JYt1ko,2289
+networkx/algorithms/voronoi.py,sha256=07SnSpxLDz4k6K59Jo-VTNA-Qy5knaHfBC-y_5vAOLQ,3183
+networkx/algorithms/walks.py,sha256=5A611YwX9D8IZYbFcQ4aT3cuKZWHq1QOzCpy4mAM6XE,2312
+networkx/algorithms/wiener.py,sha256=88sTSCXt6gakAmxP4BD_ir1R-_0NOUxXlyZKeElzzvs,9221
+networkx/classes/__init__.py,sha256=Q9oONJrnTFs874SGpwcbV_kyJTDcrLI69GFt99MiE6I,364
+networkx/classes/__pycache__/__init__.cpython-312.pyc,,
+networkx/classes/__pycache__/coreviews.cpython-312.pyc,,
+networkx/classes/__pycache__/digraph.cpython-312.pyc,,
+networkx/classes/__pycache__/filters.cpython-312.pyc,,
+networkx/classes/__pycache__/function.cpython-312.pyc,,
+networkx/classes/__pycache__/graph.cpython-312.pyc,,
+networkx/classes/__pycache__/graphviews.cpython-312.pyc,,
+networkx/classes/__pycache__/multidigraph.cpython-312.pyc,,
+networkx/classes/__pycache__/multigraph.cpython-312.pyc,,
+networkx/classes/__pycache__/reportviews.cpython-312.pyc,,
+networkx/classes/coreviews.py,sha256=5Dgi8PjMZJz_Uun2SXL5a6mxtAfdbm3kPIdbgzSTXgM,13251
+networkx/classes/digraph.py,sha256=ys8hmrqUjto00TDwBNCwiaNAahFbizNvKkkx84BxS30,48781
+networkx/classes/filters.py,sha256=PCy7BsoIby8VcamqDjZQiNAe_5egI0WKUq-y5nc9unQ,2817
+networkx/classes/function.py,sha256=pPpy-TgC33yNX3nPMZoSjfVmaiiSTbfwYJJMFGa35hQ,43794
+networkx/classes/graph.py,sha256=bY5x7WQHoQxSZow95OUAmU8UZaYV0ZWQvhrEFjSAt0Y,72337
+networkx/classes/graphviews.py,sha256=ulUTLozEK_hj_4TGHdgvxveR2-rb92Q14jjxH4oH4Go,8520
+networkx/classes/multidigraph.py,sha256=qBhb2eoiMejz5fkv-ihLsqwQKKYnUjUANHnrWZKYQfI,37036
+networkx/classes/multigraph.py,sha256=7SD8_ZT7yE1EfIotDzIgITSj4HkKLxZfj6ZnWjQ7hIA,47931
+networkx/classes/reportviews.py,sha256=u0hNZqaWXCfLMP_lq835XCIVStkZQJ9HaQPeDPPoo88,46132
+networkx/classes/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/classes/tests/__pycache__/__init__.cpython-312.pyc,,
+networkx/classes/tests/__pycache__/dispatch_interface.cpython-312.pyc,,
+networkx/classes/tests/__pycache__/historical_tests.cpython-312.pyc,,
+networkx/classes/tests/__pycache__/test_coreviews.cpython-312.pyc,,
+networkx/classes/tests/__pycache__/test_digraph.cpython-312.pyc,,
+networkx/classes/tests/__pycache__/test_digraph_historical.cpython-312.pyc,,
+networkx/classes/tests/__pycache__/test_filters.cpython-312.pyc,,
+networkx/classes/tests/__pycache__/test_function.cpython-312.pyc,,
+networkx/classes/tests/__pycache__/test_graph.cpython-312.pyc,,
+networkx/classes/tests/__pycache__/test_graph_historical.cpython-312.pyc,,
+networkx/classes/tests/__pycache__/test_graphviews.cpython-312.pyc,,
+networkx/classes/tests/__pycache__/test_multidigraph.cpython-312.pyc,,
+networkx/classes/tests/__pycache__/test_multigraph.cpython-312.pyc,,
+networkx/classes/tests/__pycache__/test_reportviews.cpython-312.pyc,,
+networkx/classes/tests/__pycache__/test_special.cpython-312.pyc,,
+networkx/classes/tests/__pycache__/test_subgraphviews.cpython-312.pyc,,
+networkx/classes/tests/dispatch_interface.py,sha256=gffiIwS4OZWKIgRkfvghixQds5hY0tPBi86p0lpV7eY,6823
+networkx/classes/tests/historical_tests.py,sha256=oUJSS-QhvInhad9AJCXCCk0x7OzAclIF9RjBSZ6gB58,16291
+networkx/classes/tests/test_coreviews.py,sha256=qzdozzWK8vLag-CAUqrXAM2CZZwMFN5vMu6Tdrwdf-E,12128
+networkx/classes/tests/test_digraph.py,sha256=uw0FuEu3y_YI-PSGuQCRytFpXLF7Eye2fqLJaKbXkBc,12283
+networkx/classes/tests/test_digraph_historical.py,sha256=8TbDcvmLgfllfGomTRStSpT5WIQiTHLt-rS3GyJEItU,3668
+networkx/classes/tests/test_filters.py,sha256=fBLig8z548gsBBlQw6VJdGZb4IcqJj7_0mi2Fd2ncEM,5851
+networkx/classes/tests/test_function.py,sha256=PDtKrB31Ix1-abPc8NzuP-h7HOOIRtkL5bvcOE8mshU,35481
+networkx/classes/tests/test_graph.py,sha256=ST12bvoj72uzUDpnyVz-Zx0mlXV2CegcEg3txT5qS6k,31798
+networkx/classes/tests/test_graph_historical.py,sha256=EVAndjelyyZ9laQCTrj6KR6lhdmG8Y1raP2IrxkZxdA,258
+networkx/classes/tests/test_graphviews.py,sha256=JoTS_ZY7u4dBHEttD55WT1pD47FcvELBEzw-uJQiqv4,11496
+networkx/classes/tests/test_multidigraph.py,sha256=ryTKegCoYixXbAqOn3mIt9vSMb5666Dv-pfMkXEjoUE,16342
+networkx/classes/tests/test_multigraph.py,sha256=0vFQO3RCJaBpzXvnQzdWa_qYLHNo_I9DICYhPZJNUMk,18777
+networkx/classes/tests/test_reportviews.py,sha256=MgP9_cKlw4aTU5m1XbsNTM3ZjmO7roOOf-7x-Hn9xKs,41332
+networkx/classes/tests/test_special.py,sha256=wl-Idzdc55eOQ4Tn5SNqOG21AjwLb2TTp9x102Qx3Ms,4053
+networkx/classes/tests/test_subgraphviews.py,sha256=iIMkbHdtJsgDlcdphhE_uUTJ0VGTGFzKIVvMd7oamoU,13669
+networkx/conftest.py,sha256=5-BwqVMgfaZyRZICFpG1plLMJ2G1IchSQVEuRjoBtyc,8041
+networkx/convert.py,sha256=Xmkhacuyw9CDviBTZPlH6nmD-JabSk0aPcVmGgp4LeY,16143
+networkx/convert_matrix.py,sha256=9BXSEXzCEIte1nx8f35cWhXo-EVYjOkuW4H3Jutq-oE,45342
+networkx/drawing/__init__.py,sha256=rnTFNzLc4fis1hTAEpnWTC80neAR88-llVQ-LObN-i4,160
+networkx/drawing/__pycache__/__init__.cpython-312.pyc,,
+networkx/drawing/__pycache__/layout.cpython-312.pyc,,
+networkx/drawing/__pycache__/nx_agraph.cpython-312.pyc,,
+networkx/drawing/__pycache__/nx_latex.cpython-312.pyc,,
+networkx/drawing/__pycache__/nx_pydot.cpython-312.pyc,,
+networkx/drawing/__pycache__/nx_pylab.cpython-312.pyc,,
+networkx/drawing/layout.py,sha256=5MUr2NTp4L3IbOShTb_m7fD4SH1HPZKJPJ4G1mJC3Js,66346
+networkx/drawing/nx_agraph.py,sha256=4Vd8JQH4BQ7BaRO8TmYlqBKmFPm8e2XcDDJiqFkNMxM,14248
+networkx/drawing/nx_latex.py,sha256=PySHixo2YhGV0xbKLroaX-_XcI1L5u8IF8nP6xdV2NU,24846
+networkx/drawing/nx_pydot.py,sha256=9KbNVrVcU5gFmo1GPpB_UMBXcD1tnBYDBzxHvgg6mOs,9992
+networkx/drawing/nx_pylab.py,sha256=MHoDvYE4FO9kJRogqeB1FfqrStyLcjQTq3fr67vAjOE,103488
+networkx/drawing/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/drawing/tests/__pycache__/__init__.cpython-312.pyc,,
+networkx/drawing/tests/__pycache__/test_agraph.cpython-312.pyc,,
+networkx/drawing/tests/__pycache__/test_image_comparison_pylab_mpl.cpython-312.pyc,,
+networkx/drawing/tests/__pycache__/test_latex.cpython-312.pyc,,
+networkx/drawing/tests/__pycache__/test_layout.cpython-312.pyc,,
+networkx/drawing/tests/__pycache__/test_pydot.cpython-312.pyc,,
+networkx/drawing/tests/__pycache__/test_pylab.cpython-312.pyc,,
+networkx/drawing/tests/baseline/test_display_complex.png,sha256=3YPN6JEuyq1KEpRgSnH-2yECI81frU_5fw0VxHlwo9A,142315
+networkx/drawing/tests/baseline/test_display_empty_graph.png,sha256=XsOkBCZlt-55c40ElwEapBENVfmdc4TZKIF1ufs5Dzk,3257
+networkx/drawing/tests/baseline/test_display_house_with_colors.png,sha256=uiEx6_2RddHG-516OsRVM0AG7M5CGiAo4tpDgbgPKIU,26002
+networkx/drawing/tests/baseline/test_display_labels_and_colors.png,sha256=RfA1OtWYKttP5_LDScIcx8MFbC-_5wljXeDsZAqAqDU,62571
+networkx/drawing/tests/baseline/test_display_shortest_path.png,sha256=6W7EMitF8jojJ8epmaYEWpjhYRlzBlL7QV98MStxvvQ,35264
+networkx/drawing/tests/baseline/test_house_with_colors.png,sha256=FQi9pIRFwjq4gvgB8cDdBHL5euQUJFw6sQlABf2kRVo,21918
+networkx/drawing/tests/test_agraph.py,sha256=5cbqLGEgJmAocWOMSikv_9ykRWfBymjGfalvKbR1_KE,8725
+networkx/drawing/tests/test_image_comparison_pylab_mpl.py,sha256=2UtGMJFpcWiG0sQtXIYT0j03Q2LhGqWM2G-pfKY3Sw0,6340
+networkx/drawing/tests/test_latex.py,sha256=YQjLxsZnx7_CX2sJ3nN0cUiJzC7p6UhyFN6ufbox5G0,8621
+networkx/drawing/tests/test_layout.py,sha256=2_wJfBcCcHwBm1JRrQiLMcnNWoaURX6F4LFcn5OPul4,23709
+networkx/drawing/tests/test_pydot.py,sha256=X9b66gWqMgdTEyRJ7Zmy5kL9cr22waI688K9BJUf4Bk,4973
+networkx/drawing/tests/test_pylab.py,sha256=TMGpM6IKm5vTSu9Dbfm8mvyhMqz2aAu1gafGbLiOU1k,54825
+networkx/exception.py,sha256=hC8efPfIzOFo0jiWiQbTPaNKuNTuUwhp9RPw--pdv4U,3787
+networkx/generators/__init__.py,sha256=EoYB5c5ZE4rsNKZvl1TRQy2Vo2D3T2H-YunyD2i6sa0,1366
+networkx/generators/__pycache__/__init__.cpython-312.pyc,,
+networkx/generators/__pycache__/atlas.cpython-312.pyc,,
+networkx/generators/__pycache__/classic.cpython-312.pyc,,
+networkx/generators/__pycache__/cographs.cpython-312.pyc,,
+networkx/generators/__pycache__/community.cpython-312.pyc,,
+networkx/generators/__pycache__/degree_seq.cpython-312.pyc,,
+networkx/generators/__pycache__/directed.cpython-312.pyc,,
+networkx/generators/__pycache__/duplication.cpython-312.pyc,,
+networkx/generators/__pycache__/ego.cpython-312.pyc,,
+networkx/generators/__pycache__/expanders.cpython-312.pyc,,
+networkx/generators/__pycache__/geometric.cpython-312.pyc,,
+networkx/generators/__pycache__/harary_graph.cpython-312.pyc,,
+networkx/generators/__pycache__/internet_as_graphs.cpython-312.pyc,,
+networkx/generators/__pycache__/intersection.cpython-312.pyc,,
+networkx/generators/__pycache__/interval_graph.cpython-312.pyc,,
+networkx/generators/__pycache__/joint_degree_seq.cpython-312.pyc,,
+networkx/generators/__pycache__/lattice.cpython-312.pyc,,
+networkx/generators/__pycache__/line.cpython-312.pyc,,
+networkx/generators/__pycache__/mycielski.cpython-312.pyc,,
+networkx/generators/__pycache__/nonisomorphic_trees.cpython-312.pyc,,
+networkx/generators/__pycache__/random_clustered.cpython-312.pyc,,
+networkx/generators/__pycache__/random_graphs.cpython-312.pyc,,
+networkx/generators/__pycache__/small.cpython-312.pyc,,
+networkx/generators/__pycache__/social.cpython-312.pyc,,
+networkx/generators/__pycache__/spectral_graph_forge.cpython-312.pyc,,
+networkx/generators/__pycache__/stochastic.cpython-312.pyc,,
+networkx/generators/__pycache__/sudoku.cpython-312.pyc,,
+networkx/generators/__pycache__/time_series.cpython-312.pyc,,
+networkx/generators/__pycache__/trees.cpython-312.pyc,,
+networkx/generators/__pycache__/triads.cpython-312.pyc,,
+networkx/generators/atlas.dat.gz,sha256=c_xBbfAWSSNgd1HLdZ9K6B3rX2VQvyW-Wcht47dH5B0,8887
+networkx/generators/atlas.py,sha256=cbki_oYDi_7vniSesqJZ-PCEM3BvnzEdjSc3TA3s1xc,6955
+networkx/generators/classic.py,sha256=Wzey-Pl6Rm-ELYyg2lIb0lFZAxywRr5iQxv7zo3d9Bk,32658
+networkx/generators/cographs.py,sha256=-WR4_yrNk_X5nj7egb7A22eKPVymOdIYM-IftSRH4WA,1891
+networkx/generators/community.py,sha256=_p_4OfItbg8nS0b3EvojCXZ8cESdC-0Gj67V5w2veuM,34911
+networkx/generators/degree_seq.py,sha256=Hxv1rjY2NS8qmnvSWh4rcvublDZzor3D3IiB2OAFXoE,30493
+networkx/generators/directed.py,sha256=rtgf2Imf34SogrWA0BNgDltlA5kUv_l2NkxKPcJgGtQ,18149
+networkx/generators/duplication.py,sha256=hmYAHJBez7WlfdVGGa288JFUBHoIUdVqEGCodApKOr4,5831
+networkx/generators/ego.py,sha256=ylW-UMvg9C8cqygw9vrBNLGAVZJT4U5EWbU4gaT_H1g,1894
+networkx/generators/expanders.py,sha256=gJioNdyhBOnNcjh0qC-kfbFs1SEMU5_o9GHy85pdJXk,15184
+networkx/generators/geometric.py,sha256=6slgS0vraxql67AOP9lWzBrpNbx_OBZCoBwYuSkQQXg,39461
+networkx/generators/harary_graph.py,sha256=N2_b49xrET0bjZ4C7sgcG2xLv64ia9xjvJ2NB75CAz8,4950
+networkx/generators/internet_as_graphs.py,sha256=RuhEW9rQ8f5VzeIyZe6GqSWgxKtMVuwqnzv0llW3FeY,14226
+networkx/generators/intersection.py,sha256=EFm0AOjnqyp8KcT7kGWqANq-_vq9kQ0d_0DzVyQyP-o,4101
+networkx/generators/interval_graph.py,sha256=ZTmdgQbBx3M6sysGWXbGyngYYOC1TAXD3Ozkw4deQFw,2204
+networkx/generators/joint_degree_seq.py,sha256=nyp86NC_4XvzvwpwwzKrrCSz1i_4bESSDtVjWvpkWFg,24773
+networkx/generators/lattice.py,sha256=5iujIY5pF_VhbWEE2osM5i7uuYqs5Hv1wS33WGPMn_o,14740
+networkx/generators/line.py,sha256=DDQZvD2Y2c-4kc_xTuUWpmmViLftTSGKFukgqSiyI_c,17540
+networkx/generators/mycielski.py,sha256=xBX2m77sCzumoH5cAGitksvEEW-ocbCnbdaN7fKUtVk,3314
+networkx/generators/nonisomorphic_trees.py,sha256=62FIt4Qx-giwDflNKP5BrDoCv1HbQmlp6oVGjqGeRlE,6993
+networkx/generators/random_clustered.py,sha256=i_NdvvchHvsvbwgQtoWSY_pLwvhO9Lh02MSZXzgGb7c,4183
+networkx/generators/random_graphs.py,sha256=WIJ4v8PSNpHePclSCQ3IcLWwcipZJ2Cn9pNx6XenBEo,51669
+networkx/generators/small.py,sha256=duBVJgz4f2TByU4SdyRGHw7YyLHrlrr0UFw6spVTCbo,30967
+networkx/generators/social.py,sha256=brzAScpAxWGRExE9J7FuiJ29QZxBm8bXpRgCc0IoHP0,23416
+networkx/generators/spectral_graph_forge.py,sha256=9r6d9f5Y03KPX138sQTKWG3_RjeiYQVUJJWwCHqG4MA,4282
+networkx/generators/stochastic.py,sha256=Qg9vWm9EOug2OQVIHL_dZ5HrXc16lxnWyzX52KWNEPI,1981
+networkx/generators/sudoku.py,sha256=kLM2AP0H4966uYiNO1oAFEmv5qBftU_bOfYucRxexM0,4288
+networkx/generators/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/generators/tests/__pycache__/__init__.cpython-312.pyc,,
+networkx/generators/tests/__pycache__/test_atlas.cpython-312.pyc,,
+networkx/generators/tests/__pycache__/test_classic.cpython-312.pyc,,
+networkx/generators/tests/__pycache__/test_cographs.cpython-312.pyc,,
+networkx/generators/tests/__pycache__/test_community.cpython-312.pyc,,
+networkx/generators/tests/__pycache__/test_degree_seq.cpython-312.pyc,,
+networkx/generators/tests/__pycache__/test_directed.cpython-312.pyc,,
+networkx/generators/tests/__pycache__/test_duplication.cpython-312.pyc,,
+networkx/generators/tests/__pycache__/test_ego.cpython-312.pyc,,
+networkx/generators/tests/__pycache__/test_expanders.cpython-312.pyc,,
+networkx/generators/tests/__pycache__/test_geometric.cpython-312.pyc,,
+networkx/generators/tests/__pycache__/test_harary_graph.cpython-312.pyc,,
+networkx/generators/tests/__pycache__/test_internet_as_graphs.cpython-312.pyc,,
+networkx/generators/tests/__pycache__/test_intersection.cpython-312.pyc,,
+networkx/generators/tests/__pycache__/test_interval_graph.cpython-312.pyc,,
+networkx/generators/tests/__pycache__/test_joint_degree_seq.cpython-312.pyc,,
+networkx/generators/tests/__pycache__/test_lattice.cpython-312.pyc,,
+networkx/generators/tests/__pycache__/test_line.cpython-312.pyc,,
+networkx/generators/tests/__pycache__/test_mycielski.cpython-312.pyc,,
+networkx/generators/tests/__pycache__/test_nonisomorphic_trees.cpython-312.pyc,,
+networkx/generators/tests/__pycache__/test_random_clustered.cpython-312.pyc,,
+networkx/generators/tests/__pycache__/test_random_graphs.cpython-312.pyc,,
+networkx/generators/tests/__pycache__/test_small.cpython-312.pyc,,
+networkx/generators/tests/__pycache__/test_spectral_graph_forge.cpython-312.pyc,,
+networkx/generators/tests/__pycache__/test_stochastic.cpython-312.pyc,,
+networkx/generators/tests/__pycache__/test_sudoku.cpython-312.pyc,,
+networkx/generators/tests/__pycache__/test_time_series.cpython-312.pyc,,
+networkx/generators/tests/__pycache__/test_trees.cpython-312.pyc,,
+networkx/generators/tests/__pycache__/test_triads.cpython-312.pyc,,
+networkx/generators/tests/test_atlas.py,sha256=nwXJL4O5jUqhTwqhkPxHY8s3KXHQTDEdsfbg4MsSzVQ,2530
+networkx/generators/tests/test_classic.py,sha256=eRtftt3fcr5kYJI8PffuY3tWOnn4u0yJZwKav1bZACU,24400
+networkx/generators/tests/test_cographs.py,sha256=v2fYoolmfwfCpJZRKRtH9YKyWcuJkaPOQUpDK9DMsn0,553
+networkx/generators/tests/test_community.py,sha256=FGcDo3Ajb-yYc5kUkFbVfOJVMG-YppbAtjgBPcVzjLc,11311
+networkx/generators/tests/test_degree_seq.py,sha256=V_X-Mc0H2sqEy7OTJb4yY9khsi-9HD-DIA_fvngW-VE,7284
+networkx/generators/tests/test_directed.py,sha256=e8C7AF2whjaqdxga7WSvCrtIx7ByBG_JyJ9gYqJ6HBA,6020
+networkx/generators/tests/test_duplication.py,sha256=UdIGDF_fishanWid1xO_aH4NDfie8xpIqd26qndhOqI,3155
+networkx/generators/tests/test_ego.py,sha256=8v1Qjmkli9wIhhUuqzgqCzysr0C1Z2C3oJMCUoNvgY4,1327
+networkx/generators/tests/test_expanders.py,sha256=Cf0cCJOplngPlN23OVqDcrny2QZlrYMrrWHeIi0APaA,6363
+networkx/generators/tests/test_geometric.py,sha256=gnVm4dam_Er88YwaNpNZC6mjJjfgwMYhyLOtU9oPn1o,18087
+networkx/generators/tests/test_harary_graph.py,sha256=GiX5LXXJaNxzjvd-Nyw_QuARzbFGkA6zE1R1eX8mclw,4936
+networkx/generators/tests/test_internet_as_graphs.py,sha256=3et6aawAPZ9bPNWqADJ3bQN_2KhyqPf8VFgrBAkgABQ,8514
+networkx/generators/tests/test_intersection.py,sha256=hcIit5fKfOn3VjMhz9KqovZK9tzxZfmC6ezvA7gZAvM,819
+networkx/generators/tests/test_interval_graph.py,sha256=JYMi-QMkJQdBU9uOdfm0Xr6MEYqIbhU5oSDa6D3tSb0,4277
+networkx/generators/tests/test_joint_degree_seq.py,sha256=8TXTZI3Um2gBXtP-4yhGKf9vCi78-NVmWZw9r9WG3F8,4270
+networkx/generators/tests/test_lattice.py,sha256=iYB2F7j1Qt3QAHkhGnGKcgiRNB1Gq9MxtE3152XdS_A,10102
+networkx/generators/tests/test_line.py,sha256=Dt1R1Hnm47aq_8FX9gRFdby0sV3Oxyap1R5Z4eK0A5o,10516
+networkx/generators/tests/test_mycielski.py,sha256=fwZLO1ybcltRy6TzCel8tPBil1oZWv9QSXs779H6Xt0,946
+networkx/generators/tests/test_nonisomorphic_trees.py,sha256=KFRwMfx-x_a9oGvPlhtMlWGk__rKgm77Gk4LtbxFrZE,2945
+networkx/generators/tests/test_random_clustered.py,sha256=SalHqWvpnXA3QrDRMjLx15dk2c4Us8Ck52clUERoUI8,1297
+networkx/generators/tests/test_random_graphs.py,sha256=R5dHYuzAbcIBduoP7PUdoV-6CFauqk5r1Ak1Slwlsho,19565
+networkx/generators/tests/test_small.py,sha256=y9rZHpwQG4Bjp-sHJp18rM3A0uEGOUkbklqlJec11ao,8074
+networkx/generators/tests/test_spectral_graph_forge.py,sha256=x4jyTiQiydaUPWYaGsNFsIB47PAzSSwQYCNXGa2B4SU,1594
+networkx/generators/tests/test_stochastic.py,sha256=f-5KD3RpoQf369gXHH7KGebE19g5lCkXR_alcwmFm_s,2179
+networkx/generators/tests/test_sudoku.py,sha256=dgOmk-B7MxCVkbHdZzsLZppQ61FAArVy4McSVL8Afzo,1968
+networkx/generators/tests/test_time_series.py,sha256=rgmFcitlKa_kF6TzJ2ze91lSmNJlqjhvgrYet0AUZx8,2230
+networkx/generators/tests/test_trees.py,sha256=Pvh0MvTKaRuZuwWL-wpJIC0zlBAcnTirpSLJi-9c7qc,7006
+networkx/generators/tests/test_triads.py,sha256=K8anVEP8R90Y172IrKIOrYRWRJBGeqxNqU9isX7Ybxs,333
+networkx/generators/time_series.py,sha256=_DMiY9X95O_9sK2BSeeTb2yMWfStBwKFWwn6FUOXN4Q,2439
+networkx/generators/trees.py,sha256=KvKYhZwwSl1KKMyKBe_6G_UTpLwLLeqdWwRkWJ2Xxz4,36517
+networkx/generators/triads.py,sha256=7kScTf3ITDi3qsSa-IvGMpa9diEaFwQnRuIf3Tv4UBI,2452
+networkx/lazy_imports.py,sha256=pZWn3f6NCY-lGtViKQh11NJ5Cn-cXBKhvacMycg3844,5764
+networkx/linalg/__init__.py,sha256=7iyNZ_YYBnlsW8zSfhUgvEkywOrUWfpIuyS86ZOKlG8,568
+networkx/linalg/__pycache__/__init__.cpython-312.pyc,,
+networkx/linalg/__pycache__/algebraicconnectivity.cpython-312.pyc,,
+networkx/linalg/__pycache__/attrmatrix.cpython-312.pyc,,
+networkx/linalg/__pycache__/bethehessianmatrix.cpython-312.pyc,,
+networkx/linalg/__pycache__/graphmatrix.cpython-312.pyc,,
+networkx/linalg/__pycache__/laplacianmatrix.cpython-312.pyc,,
+networkx/linalg/__pycache__/modularitymatrix.cpython-312.pyc,,
+networkx/linalg/__pycache__/spectrum.cpython-312.pyc,,
+networkx/linalg/algebraicconnectivity.py,sha256=qAjHk8Ew2av9HM-Sevf99alKHWkeo4R76U-1SFn2so8,20790
+networkx/linalg/attrmatrix.py,sha256=gG2cZZm4N7PQhXuq5nxZq1S_OmW61641rdRnrDiX_ws,15900
+networkx/linalg/bethehessianmatrix.py,sha256=Q5dJZOMopwWnvpSdebfo9QSQABEmLy-z1_hGCWsopDo,2513
+networkx/linalg/graphmatrix.py,sha256=NIs2uWGS_8lJJ5IQ8Og9aIWHawghtlCDWifqOIKV2-c,5623
+networkx/linalg/laplacianmatrix.py,sha256=YrzwLTLoGIisJVS2NLaD9g4fA3VDKzlYo1u3yOCVrF4,16722
+networkx/linalg/modularitymatrix.py,sha256=R_VITtgIkGenxlsCLN4u6CYxj3_HiPXfeU29yarntRo,4706
+networkx/linalg/spectrum.py,sha256=aRY7ApYv5HxrO_4O8brxpZRw3SJU3fYzlgMwhEIXcrc,4215
+networkx/linalg/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/linalg/tests/__pycache__/__init__.cpython-312.pyc,,
+networkx/linalg/tests/__pycache__/test_algebraic_connectivity.cpython-312.pyc,,
+networkx/linalg/tests/__pycache__/test_attrmatrix.cpython-312.pyc,,
+networkx/linalg/tests/__pycache__/test_bethehessian.cpython-312.pyc,,
+networkx/linalg/tests/__pycache__/test_graphmatrix.cpython-312.pyc,,
+networkx/linalg/tests/__pycache__/test_laplacian.cpython-312.pyc,,
+networkx/linalg/tests/__pycache__/test_modularity.cpython-312.pyc,,
+networkx/linalg/tests/__pycache__/test_spectrum.cpython-312.pyc,,
+networkx/linalg/tests/test_algebraic_connectivity.py,sha256=uXq7h1fCmvcUyJhh3DujyZvJH2SGlgo-JRdLbff3bKI,13735
+networkx/linalg/tests/test_attrmatrix.py,sha256=I8p_ME5Cq__SZJoxla1y5ynGaa_b4UruZRcuzPOh_wE,2833
+networkx/linalg/tests/test_bethehessian.py,sha256=WQM3H_y1GWrtM2B659HYQ2vvYGs-4H9V1qeo3Bx75B4,1268
+networkx/linalg/tests/test_graphmatrix.py,sha256=6y-DSezX5slSms8LtEJcoggI4wP_duBqodNYWKKvM4w,8655
+networkx/linalg/tests/test_laplacian.py,sha256=sIJ64KVVCUcK3b4ohF-443222vR64myIlV6addwwfWs,13953
+networkx/linalg/tests/test_modularity.py,sha256=Xs7iaUr_QqcxG0t0xHx54iYbM2VyQNmFeANovTMJomE,3056
+networkx/linalg/tests/test_spectrum.py,sha256=Hrl3FE0Z0u4urwY5eNMx0VcH4IRTYgudT04EmfhkosA,2769
+networkx/readwrite/__init__.py,sha256=TvSbnGEHQ5F9CY2tkpjWYOyrUj6BeW3sc6P4_IczbKA,561
+networkx/readwrite/__pycache__/__init__.cpython-312.pyc,,
+networkx/readwrite/__pycache__/adjlist.cpython-312.pyc,,
+networkx/readwrite/__pycache__/edgelist.cpython-312.pyc,,
+networkx/readwrite/__pycache__/gexf.cpython-312.pyc,,
+networkx/readwrite/__pycache__/gml.cpython-312.pyc,,
+networkx/readwrite/__pycache__/graph6.cpython-312.pyc,,
+networkx/readwrite/__pycache__/graphml.cpython-312.pyc,,
+networkx/readwrite/__pycache__/leda.cpython-312.pyc,,
+networkx/readwrite/__pycache__/multiline_adjlist.cpython-312.pyc,,
+networkx/readwrite/__pycache__/p2g.cpython-312.pyc,,
+networkx/readwrite/__pycache__/pajek.cpython-312.pyc,,
+networkx/readwrite/__pycache__/sparse6.cpython-312.pyc,,
+networkx/readwrite/__pycache__/text.cpython-312.pyc,,
+networkx/readwrite/adjlist.py,sha256=XkmtOO-aP-BGLoIjMoSXEOhCIEQz1TJcSrhMHGPCJTc,9050
+networkx/readwrite/edgelist.py,sha256=XwemCOs-xNet3mVIGpxol3RgFVJVa1iXsgBonAHDmug,14292
+networkx/readwrite/gexf.py,sha256=B5rj7Ra1XHSZR4qO5DRJMAEgWwQfiL0IKlE85fzQZ5Q,40438
+networkx/readwrite/gml.py,sha256=JcP0hsDKwpZOPzZeXdoEiKBBNd94Ox8y7_cjT5AVBT4,31193
+networkx/readwrite/graph6.py,sha256=dED6yWelHARFvyKniX8xSTtqj1-asDs1vUBWuZOG9cA,11684
+networkx/readwrite/graphml.py,sha256=sb-D5I5gmqyNj_TSNUvLn-96NBXtOAPFMEKvT3mkdTw,39326
+networkx/readwrite/json_graph/__init__.py,sha256=37XJPMmilcwwo8KqouLWUly7Yv5tZ7IKraMHbBRx3fI,677
+networkx/readwrite/json_graph/__pycache__/__init__.cpython-312.pyc,,
+networkx/readwrite/json_graph/__pycache__/adjacency.cpython-312.pyc,,
+networkx/readwrite/json_graph/__pycache__/cytoscape.cpython-312.pyc,,
+networkx/readwrite/json_graph/__pycache__/node_link.cpython-312.pyc,,
+networkx/readwrite/json_graph/__pycache__/tree.cpython-312.pyc,,
+networkx/readwrite/json_graph/adjacency.py,sha256=WM6fdncV87WDLPOfF-IbOlOOBMX0utUjJ09UsxtwRAo,4716
+networkx/readwrite/json_graph/cytoscape.py,sha256=NaHGbwLuQCx_GB5R7Uag2ACKSmrpCFQKsRk3y9hE6Io,5841
+networkx/readwrite/json_graph/node_link.py,sha256=9hr4sk2fIHYDPuwSyyGNLNKDhahf6aFAEsIRhd5V890,7850
+networkx/readwrite/json_graph/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/readwrite/json_graph/tests/__pycache__/__init__.cpython-312.pyc,,
+networkx/readwrite/json_graph/tests/__pycache__/test_adjacency.cpython-312.pyc,,
+networkx/readwrite/json_graph/tests/__pycache__/test_cytoscape.cpython-312.pyc,,
+networkx/readwrite/json_graph/tests/__pycache__/test_node_link.cpython-312.pyc,,
+networkx/readwrite/json_graph/tests/__pycache__/test_tree.cpython-312.pyc,,
+networkx/readwrite/json_graph/tests/test_adjacency.py,sha256=jueQE3Z_W5BZuCjr0hEsOWSfoQ2fP51p0o0m7IcXUuE,2456
+networkx/readwrite/json_graph/tests/test_cytoscape.py,sha256=vFoDzcSRI9THlmp4Fu2HHhIF9AUmECWs5mftVWjaWWs,2044
+networkx/readwrite/json_graph/tests/test_node_link.py,sha256=3RbMNRlLBLN86EG4YyCvNmA3ISzmECqr17EqTcov3kI,3364
+networkx/readwrite/json_graph/tests/test_tree.py,sha256=zBXv3_db2XGxFs3XQ35btNf_ku52aLXXiHZmmX4ixAs,1352
+networkx/readwrite/json_graph/tree.py,sha256=K4rF4Kds4g0JhgcPTrrR_I3Pswpze8yCVH4M-WF9nn0,3851
+networkx/readwrite/leda.py,sha256=mtuIRKecfykiInePt-oIw91JB1vIgNXuUEbuBInO7Hs,2852
+networkx/readwrite/multiline_adjlist.py,sha256=TyvVZih3DIYaCQ6MC7XF8GuGBfcYIX-q-ccYu2Qs05M,11384
+networkx/readwrite/p2g.py,sha256=wDPg_3u42rlsv8pFtVLbZIjo-BN6dd95jCxFAoEC_6E,3253
+networkx/readwrite/pajek.py,sha256=0Xli27YbjyW5Ny6-qqVOtBmhZkPj4i3cJPvwjU3mMjM,8746
+networkx/readwrite/sparse6.py,sha256=kGEbDmnK1qcR5I6LZnPKYXLe7Qp6esT6gftkwSt1xcs,10442
+networkx/readwrite/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/readwrite/tests/__pycache__/__init__.cpython-312.pyc,,
+networkx/readwrite/tests/__pycache__/test_adjlist.cpython-312.pyc,,
+networkx/readwrite/tests/__pycache__/test_edgelist.cpython-312.pyc,,
+networkx/readwrite/tests/__pycache__/test_gexf.cpython-312.pyc,,
+networkx/readwrite/tests/__pycache__/test_gml.cpython-312.pyc,,
+networkx/readwrite/tests/__pycache__/test_graph6.cpython-312.pyc,,
+networkx/readwrite/tests/__pycache__/test_graphml.cpython-312.pyc,,
+networkx/readwrite/tests/__pycache__/test_leda.cpython-312.pyc,,
+networkx/readwrite/tests/__pycache__/test_p2g.cpython-312.pyc,,
+networkx/readwrite/tests/__pycache__/test_pajek.cpython-312.pyc,,
+networkx/readwrite/tests/__pycache__/test_sparse6.cpython-312.pyc,,
+networkx/readwrite/tests/__pycache__/test_text.cpython-312.pyc,,
+networkx/readwrite/tests/test_adjlist.py,sha256=aCDyLpv8cekWwEZgv5rB4gtwUvor7_YDArTYvL2ngPs,12756
+networkx/readwrite/tests/test_edgelist.py,sha256=5_rZ5rI_o8VDJr-R4besR-XcPwKY8-dHn4VmrrlBorc,10190
+networkx/readwrite/tests/test_gexf.py,sha256=TJLCj0ULSewUt5PlqEuoD8yhZoc6jFPqElIyQYhoKz0,21327
+networkx/readwrite/tests/test_gml.py,sha256=SIuCCSoH9psZdjKkrJfdGHbMROhUsfms70B71rnozUU,21399
+networkx/readwrite/tests/test_graph6.py,sha256=WMQmTgrI_VDcli1Gl5cjM17EFKc8_AkwoR14FLS1sXQ,6559
+networkx/readwrite/tests/test_graphml.py,sha256=RHZqs_-0Vw_NboMK1Sq65Nmk_XPAjfvnsgiPCptnpnI,67633
+networkx/readwrite/tests/test_leda.py,sha256=_5F4nLLQ1oAZQMZtTQoFncZL0Oc-IsztFBglEdQeH3k,1392
+networkx/readwrite/tests/test_p2g.py,sha256=0kvtohQuM2zjw88ogoDMhVbFcm85R3Sk2_yFdQ7TcWg,1319
+networkx/readwrite/tests/test_pajek.py,sha256=VxMk_TXQE1R-2t2B2OTSkwvPepKNYwExDbdlTDb0SOM,4696
+networkx/readwrite/tests/test_sparse6.py,sha256=zpd0hUPtOqwAJiuke4FXWFaQVa6Fa47dgIdHpCWXQ6U,5288
+networkx/readwrite/tests/test_text.py,sha256=x1N97hD31HPkj9Wn2PYti5-gcwaFNnStkaN_38HKnIg,55319
+networkx/readwrite/text.py,sha256=u62a-zG_7NpJD4Bh6kBZbUntORVM4XZId9zGX9wJBGQ,29140
+networkx/relabel.py,sha256=0HptAQOBToKhLZzxscd6FQpzVCNMlYmiHjHul69ct8o,10300
+networkx/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/tests/__pycache__/__init__.cpython-312.pyc,,
+networkx/tests/__pycache__/test_all_random_functions.cpython-312.pyc,,
+networkx/tests/__pycache__/test_convert.cpython-312.pyc,,
+networkx/tests/__pycache__/test_convert_numpy.cpython-312.pyc,,
+networkx/tests/__pycache__/test_convert_pandas.cpython-312.pyc,,
+networkx/tests/__pycache__/test_convert_scipy.cpython-312.pyc,,
+networkx/tests/__pycache__/test_exceptions.cpython-312.pyc,,
+networkx/tests/__pycache__/test_import.cpython-312.pyc,,
+networkx/tests/__pycache__/test_lazy_imports.cpython-312.pyc,,
+networkx/tests/__pycache__/test_relabel.cpython-312.pyc,,
+networkx/tests/__pycache__/test_removed_functions_exception_messages.cpython-312.pyc,,
+networkx/tests/test_all_random_functions.py,sha256=T6bYvfqCmBfqOHAAJAqCv95VceTqdT32cN740HZTWH0,8549
+networkx/tests/test_convert.py,sha256=SoIVrqJFF9Gu9Jff_apfbpqg8QhkfC6QW4qzoSM-ukM,12731
+networkx/tests/test_convert_numpy.py,sha256=wivMBF5pmDd2FdrHX72J4Xt26IxTIfb12G-t-TWch40,19032
+networkx/tests/test_convert_pandas.py,sha256=VXumRYNIV2jdr4dfDsRidqpUDXHlgbhAFhaiqWlcx6s,13361
+networkx/tests/test_convert_scipy.py,sha256=IO9Xfke5Vk0SC4c7UR4YbQMjVZBuADQBt_wlMaOxTSQ,10381
+networkx/tests/test_exceptions.py,sha256=XYkpPzqMepSw3MPRUJN5LcFsUsy3YT_fiRDhm0OeAeQ,927
+networkx/tests/test_import.py,sha256=Gm4ujfH9JkQtDrSjOlwXXXUuubI057wskKLCkF6Z92k,220
+networkx/tests/test_lazy_imports.py,sha256=PylxEvRtD8ekwH-1M1sjnV_4uyhCYQl4WvlyF6ah0wo,2675
+networkx/tests/test_relabel.py,sha256=2qua3Z45m9mXkBQYmD82h17-pK6fYHJLpntn6ILj9cg,14554
+networkx/tests/test_removed_functions_exception_messages.py,sha256=V6AyU-RHQmilakEMJ1kpK4HSgzKbmimIxu0pBQ1DVaY,177
+networkx/utils/__init__.py,sha256=7pxleRNpBWuL3FEQz3CzKLn17b6_eSwkM7dqnL1okDk,302
+networkx/utils/__pycache__/__init__.cpython-312.pyc,,
+networkx/utils/__pycache__/backends.cpython-312.pyc,,
+networkx/utils/__pycache__/configs.cpython-312.pyc,,
+networkx/utils/__pycache__/decorators.cpython-312.pyc,,
+networkx/utils/__pycache__/heaps.cpython-312.pyc,,
+networkx/utils/__pycache__/mapped_queue.cpython-312.pyc,,
+networkx/utils/__pycache__/misc.cpython-312.pyc,,
+networkx/utils/__pycache__/random_sequence.cpython-312.pyc,,
+networkx/utils/__pycache__/rcm.cpython-312.pyc,,
+networkx/utils/__pycache__/union_find.cpython-312.pyc,,
+networkx/utils/backends.py,sha256=IDXNJjBWOfcqPm3Any5-kfwU9hZTH33R16gr3vZ6wnE,96862
+networkx/utils/configs.py,sha256=1LFNHgkR6CdXxTpNT8j4QdQ5vn5r7BTzPlxFYrEm7_E,15440
+networkx/utils/decorators.py,sha256=rRgAZw6glxOBYN6n5kkbQ7RS43EH3eVbJ5F91-uk0IM,44713
+networkx/utils/heaps.py,sha256=98tdylWKqrLQKdNlpjT2NvIpuOF2mT2Lhh5OzVg3Hu8,10355
+networkx/utils/mapped_queue.py,sha256=WdIRk27D_ArmPs9tdpvQLQCV4Tmus212BQhxsFIMYgk,10184
+networkx/utils/misc.py,sha256=zifBxwKM3msQsmMVg5vAMDo84ZPByU_yEig0VPS0iek,22844
+networkx/utils/random_sequence.py,sha256=kk3F8_5cazolIeSL_eDdZzQ15aB3b5lHazef9kM1NNw,5303
+networkx/utils/rcm.py,sha256=t2LJq6BG39JnPl_353nM8eDfGWy3LVL8BdrBZCcAy2g,4618
+networkx/utils/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/utils/tests/__pycache__/__init__.cpython-312.pyc,,
+networkx/utils/tests/__pycache__/test__init.cpython-312.pyc,,
+networkx/utils/tests/__pycache__/test_backends.cpython-312.pyc,,
+networkx/utils/tests/__pycache__/test_config.cpython-312.pyc,,
+networkx/utils/tests/__pycache__/test_decorators.cpython-312.pyc,,
+networkx/utils/tests/__pycache__/test_heaps.cpython-312.pyc,,
+networkx/utils/tests/__pycache__/test_mapped_queue.cpython-312.pyc,,
+networkx/utils/tests/__pycache__/test_misc.cpython-312.pyc,,
+networkx/utils/tests/__pycache__/test_random_sequence.cpython-312.pyc,,
+networkx/utils/tests/__pycache__/test_rcm.cpython-312.pyc,,
+networkx/utils/tests/__pycache__/test_unionfind.cpython-312.pyc,,
+networkx/utils/tests/test__init.py,sha256=QE0i-lNE4pG2eYjB2mZ0uw7jPD-7TdL7Y9p73JoWQmo,363
+networkx/utils/tests/test_backends.py,sha256=VzzgmdT_ymvQ7EKB4BbdntkBYaO5w6OgXzvr7pbgQsY,7784
+networkx/utils/tests/test_config.py,sha256=eBAiwADWJgCAIyJjgF3-zn89VPIGftiWMWyccpFnyMU,8717
+networkx/utils/tests/test_decorators.py,sha256=dm3b5yiQPlnlT_4pSm0FwK-xBGV9dcnhv14Vh9Jiz1o,14050
+networkx/utils/tests/test_heaps.py,sha256=qCuWMzpcMH1Gwu014CAams78o151QD5YL0mB1fz16Yw,3711
+networkx/utils/tests/test_mapped_queue.py,sha256=l1Nguzz68Fv91FnAT7y7B0GXSoje9uoWiObHo7TliGM,7354
+networkx/utils/tests/test_misc.py,sha256=3rKc5wy3qAwk1JdVZYD8FaTF4_4Y1_Tq1nbza6eR_jc,13965
+networkx/utils/tests/test_random_sequence.py,sha256=yvfWhJQJJqM1W-_etHo7BsLXA18YiHcLaF-IdhSwcYA,1502
+networkx/utils/tests/test_rcm.py,sha256=UvUAkgmQMGk_Nn94TJyQsle4A5SLQFqMQWld1tiQ2lk,1421
+networkx/utils/tests/test_unionfind.py,sha256=j-DF5XyeJzq1hoeAgN5Nye2Au7EPD040t8oS4Aw2IwU,1579
+networkx/utils/union_find.py,sha256=NxKlBlyS71A1Wlnt28L-wyZoI9ExZvJth_0e2XSVris,3338
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/networkx-3.6.1.dist-info/WHEEL b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/networkx-3.6.1.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..e7fa31b6f3f78deb1022c1f7927f07d4d16da822
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/networkx-3.6.1.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/networkx-3.6.1.dist-info/entry_points.txt b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/networkx-3.6.1.dist-info/entry_points.txt
new file mode 100644
index 0000000000000000000000000000000000000000..377282a2e4c3dc8b924035d0dfd32d7ae50920c8
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/networkx-3.6.1.dist-info/entry_points.txt
@@ -0,0 +1,2 @@
+[networkx.backends]
+nx_loopback = networkx.classes.tests.dispatch_interface:backend_interface
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/networkx-3.6.1.dist-info/top_level.txt b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/networkx-3.6.1.dist-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4d07dfe2f85d6849d7f416dcce756b2501ba847e
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/networkx-3.6.1.dist-info/top_level.txt
@@ -0,0 +1 @@
+networkx
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_cuda_cupti_cu12-12.8.90.dist-info/INSTALLER b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_cuda_cupti_cu12-12.8.90.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_cuda_cupti_cu12-12.8.90.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_cuda_cupti_cu12-12.8.90.dist-info/License.txt b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_cuda_cupti_cu12-12.8.90.dist-info/License.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b491c70e0aef319022ded661e111ddbd45b8a17f
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_cuda_cupti_cu12-12.8.90.dist-info/License.txt
@@ -0,0 +1,1568 @@
+End User License Agreement
+--------------------------
+
+
+Preface
+-------
+
+The Software License Agreement in Chapter 1 and the Supplement
+in Chapter 2 contain license terms and conditions that govern
+the use of NVIDIA software. By accepting this agreement, you
+agree to comply with all the terms and conditions applicable
+to the product(s) included herein.
+
+
+NVIDIA Driver
+
+
+Description
+
+This package contains the operating system driver and
+fundamental system software components for NVIDIA GPUs.
+
+
+NVIDIA CUDA Toolkit
+
+
+Description
+
+The NVIDIA CUDA Toolkit provides command-line and graphical
+tools for building, debugging and optimizing the performance
+of applications accelerated by NVIDIA GPUs, runtime and math
+libraries, and documentation including programming guides,
+user manuals, and API references.
+
+
+Default Install Location of CUDA Toolkit
+
+Windows platform:
+
+%ProgramFiles%\NVIDIA GPU Computing Toolkit\CUDA\v#.#
+
+Linux platform:
+
+/usr/local/cuda-#.#
+
+Mac platform:
+
+/Developer/NVIDIA/CUDA-#.#
+
+
+NVIDIA CUDA Samples
+
+
+Description
+
+This package includes over 100+ CUDA examples that demonstrate
+various CUDA programming principles, and efficient CUDA
+implementation of algorithms in specific application domains.
+
+
+Default Install Location of CUDA Samples
+
+Windows platform:
+
+%ProgramData%\NVIDIA Corporation\CUDA Samples\v#.#
+
+Linux platform:
+
+/usr/local/cuda-#.#/samples
+
+and
+
+$HOME/NVIDIA_CUDA-#.#_Samples
+
+Mac platform:
+
+/Developer/NVIDIA/CUDA-#.#/samples
+
+
+NVIDIA Nsight Visual Studio Edition (Windows only)
+
+
+Description
+
+NVIDIA Nsight Development Platform, Visual Studio Edition is a
+development environment integrated into Microsoft Visual
+Studio that provides tools for debugging, profiling, analyzing
+and optimizing your GPU computing and graphics applications.
+
+
+Default Install Location of Nsight Visual Studio Edition
+
+Windows platform:
+
+%ProgramFiles(x86)%\NVIDIA Corporation\Nsight Visual Studio Edition #.#
+
+
+1. License Agreement for NVIDIA Software Development Kits
+---------------------------------------------------------
+
+
+Release Date: July 26, 2018
+---------------------------
+
+
+Important NoticeRead before downloading, installing,
+copying or using the licensed software:
+-------------------------------------------------------
+
+This license agreement, including exhibits attached
+("Agreement”) is a legal agreement between you and NVIDIA
+Corporation ("NVIDIA") and governs your use of a NVIDIA
+software development kit (“SDK”).
+
+Each SDK has its own set of software and materials, but here
+is a description of the types of items that may be included in
+a SDK: source code, header files, APIs, data sets and assets
+(examples include images, textures, models, scenes, videos,
+native API input/output files), binary software, sample code,
+libraries, utility programs, programming code and
+documentation.
+
+This Agreement can be accepted only by an adult of legal age
+of majority in the country in which the SDK is used.
+
+If you are entering into this Agreement on behalf of a company
+or other legal entity, you represent that you have the legal
+authority to bind the entity to this Agreement, in which case
+“you” will mean the entity you represent.
+
+If you don’t have the required age or authority to accept
+this Agreement, or if you don’t accept all the terms and
+conditions of this Agreement, do not download, install or use
+the SDK.
+
+You agree to use the SDK only for purposes that are permitted
+by (a) this Agreement, and (b) any applicable law, regulation
+or generally accepted practices or guidelines in the relevant
+jurisdictions.
+
+
+1.1. License
+
+
+1.1.1. License Grant
+
+Subject to the terms of this Agreement, NVIDIA hereby grants
+you a non-exclusive, non-transferable license, without the
+right to sublicense (except as expressly provided in this
+Agreement) to:
+
+ 1. Install and use the SDK,
+
+ 2. Modify and create derivative works of sample source code
+ delivered in the SDK, and
+
+ 3. Distribute those portions of the SDK that are identified
+ in this Agreement as distributable, as incorporated in
+ object code format into a software application that meets
+ the distribution requirements indicated in this Agreement.
+
+
+1.1.2. Distribution Requirements
+
+These are the distribution requirements for you to exercise
+the distribution grant:
+
+ 1. Your application must have material additional
+ functionality, beyond the included portions of the SDK.
+
+ 2. The distributable portions of the SDK shall only be
+ accessed by your application.
+
+ 3. The following notice shall be included in modifications
+ and derivative works of sample source code distributed:
+ “This software contains source code provided by NVIDIA
+ Corporation.”
+
+ 4. Unless a developer tool is identified in this Agreement
+ as distributable, it is delivered for your internal use
+ only.
+
+ 5. The terms under which you distribute your application
+ must be consistent with the terms of this Agreement,
+ including (without limitation) terms relating to the
+ license grant and license restrictions and protection of
+ NVIDIA’s intellectual property rights. Additionally, you
+ agree that you will protect the privacy, security and
+ legal rights of your application users.
+
+ 6. You agree to notify NVIDIA in writing of any known or
+ suspected distribution or use of the SDK not in compliance
+ with the requirements of this Agreement, and to enforce
+ the terms of your agreements with respect to distributed
+ SDK.
+
+
+1.1.3. Authorized Users
+
+You may allow employees and contractors of your entity or of
+your subsidiary(ies) to access and use the SDK from your
+secure network to perform work on your behalf.
+
+If you are an academic institution you may allow users
+enrolled or employed by the academic institution to access and
+use the SDK from your secure network.
+
+You are responsible for the compliance with the terms of this
+Agreement by your authorized users. If you become aware that
+your authorized users didn’t follow the terms of this
+Agreement, you agree to take reasonable steps to resolve the
+non-compliance and prevent new occurrences.
+
+
+1.1.4. Pre-Release SDK
+
+The SDK versions identified as alpha, beta, preview or
+otherwise as pre-release, may not be fully functional, may
+contain errors or design flaws, and may have reduced or
+different security, privacy, accessibility, availability, and
+reliability standards relative to commercial versions of
+NVIDIA software and materials. Use of a pre-release SDK may
+result in unexpected results, loss of data, project delays or
+other unpredictable damage or loss.
+
+You may use a pre-release SDK at your own risk, understanding
+that pre-release SDKs are not intended for use in production
+or business-critical systems.
+
+NVIDIA may choose not to make available a commercial version
+of any pre-release SDK. NVIDIA may also choose to abandon
+development and terminate the availability of a pre-release
+SDK at any time without liability.
+
+
+1.1.5. Updates
+
+NVIDIA may, at its option, make available patches, workarounds
+or other updates to this SDK. Unless the updates are provided
+with their separate governing terms, they are deemed part of
+the SDK licensed to you as provided in this Agreement. You
+agree that the form and content of the SDK that NVIDIA
+provides may change without prior notice to you. While NVIDIA
+generally maintains compatibility between versions, NVIDIA may
+in some cases make changes that introduce incompatibilities in
+future versions of the SDK.
+
+
+1.1.6. Third Party Licenses
+
+The SDK may come bundled with, or otherwise include or be
+distributed with, third party software licensed by a NVIDIA
+supplier and/or open source software provided under an open
+source license. Use of third party software is subject to the
+third-party license terms, or in the absence of third party
+terms, the terms of this Agreement. Copyright to third party
+software is held by the copyright holders indicated in the
+third-party software or license.
+
+
+1.1.7. Reservation of Rights
+
+NVIDIA reserves all rights, title, and interest in and to the
+SDK, not expressly granted to you under this Agreement.
+
+
+1.2. Limitations
+
+The following license limitations apply to your use of the
+SDK:
+
+ 1. You may not reverse engineer, decompile or disassemble,
+ or remove copyright or other proprietary notices from any
+ portion of the SDK or copies of the SDK.
+
+ 2. Except as expressly provided in this Agreement, you may
+ not copy, sell, rent, sublicense, transfer, distribute,
+ modify, or create derivative works of any portion of the
+ SDK. For clarity, you may not distribute or sublicense the
+ SDK as a stand-alone product.
+
+ 3. Unless you have an agreement with NVIDIA for this
+ purpose, you may not indicate that an application created
+ with the SDK is sponsored or endorsed by NVIDIA.
+
+ 4. You may not bypass, disable, or circumvent any
+ encryption, security, digital rights management or
+ authentication mechanism in the SDK.
+
+ 5. You may not use the SDK in any manner that would cause it
+ to become subject to an open source software license. As
+ examples, licenses that require as a condition of use,
+ modification, and/or distribution that the SDK be:
+
+ a. Disclosed or distributed in source code form;
+
+ b. Licensed for the purpose of making derivative works;
+ or
+
+ c. Redistributable at no charge.
+
+ 6. Unless you have an agreement with NVIDIA for this
+ purpose, you may not use the SDK with any system or
+ application where the use or failure of the system or
+ application can reasonably be expected to threaten or
+ result in personal injury, death, or catastrophic loss.
+ Examples include use in avionics, navigation, military,
+ medical, life support or other life critical applications.
+ NVIDIA does not design, test or manufacture the SDK for
+ these critical uses and NVIDIA shall not be liable to you
+ or any third party, in whole or in part, for any claims or
+ damages arising from such uses.
+
+ 7. You agree to defend, indemnify and hold harmless NVIDIA
+ and its affiliates, and their respective employees,
+ contractors, agents, officers and directors, from and
+ against any and all claims, damages, obligations, losses,
+ liabilities, costs or debt, fines, restitutions and
+ expenses (including but not limited to attorney’s fees
+ and costs incident to establishing the right of
+ indemnification) arising out of or related to your use of
+ the SDK outside of the scope of this Agreement, or not in
+ compliance with its terms.
+
+
+1.3. Ownership
+
+ 1. NVIDIA or its licensors hold all rights, title and
+ interest in and to the SDK and its modifications and
+ derivative works, including their respective intellectual
+ property rights, subject to your rights described in this
+ section. This SDK may include software and materials from
+ NVIDIA’s licensors, and these licensors are intended
+ third party beneficiaries that may enforce this Agreement
+ with respect to their intellectual property rights.
+
+ 2. You hold all rights, title and interest in and to your
+ applications and your derivative works of the sample
+ source code delivered in the SDK, including their
+ respective intellectual property rights, subject to
+ NVIDIA’s rights described in this section.
+
+ 3. You may, but don’t have to, provide to NVIDIA
+ suggestions, feature requests or other feedback regarding
+ the SDK, including possible enhancements or modifications
+ to the SDK. For any feedback that you voluntarily provide,
+ you hereby grant NVIDIA and its affiliates a perpetual,
+ non-exclusive, worldwide, irrevocable license to use,
+ reproduce, modify, license, sublicense (through multiple
+ tiers of sublicensees), and distribute (through multiple
+ tiers of distributors) it without the payment of any
+ royalties or fees to you. NVIDIA will use feedback at its
+ choice. NVIDIA is constantly looking for ways to improve
+ its products, so you may send feedback to NVIDIA through
+ the developer portal at https://developer.nvidia.com.
+
+
+1.4. No Warranties
+
+THE SDK IS PROVIDED BY NVIDIA “AS IS” AND “WITH ALL
+FAULTS.” TO THE MAXIMUM EXTENT PERMITTED BY LAW, NVIDIA AND
+ITS AFFILIATES EXPRESSLY DISCLAIM ALL WARRANTIES OF ANY KIND
+OR NATURE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING,
+BUT NOT LIMITED TO, ANY WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE, TITLE, NON-INFRINGEMENT, OR THE
+ABSENCE OF ANY DEFECTS THEREIN, WHETHER LATENT OR PATENT. NO
+WARRANTY IS MADE ON THE BASIS OF TRADE USAGE, COURSE OF
+DEALING OR COURSE OF TRADE.
+
+
+1.5. Limitation of Liability
+
+TO THE MAXIMUM EXTENT PERMITTED BY LAW, NVIDIA AND ITS
+AFFILIATES SHALL NOT BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
+PUNITIVE OR CONSEQUENTIAL DAMAGES, OR ANY LOST PROFITS, LOSS
+OF USE, LOSS OF DATA OR LOSS OF GOODWILL, OR THE COSTS OF
+PROCURING SUBSTITUTE PRODUCTS, ARISING OUT OF OR IN CONNECTION
+WITH THIS AGREEMENT OR THE USE OR PERFORMANCE OF THE SDK,
+WHETHER SUCH LIABILITY ARISES FROM ANY CLAIM BASED UPON BREACH
+OF CONTRACT, BREACH OF WARRANTY, TORT (INCLUDING NEGLIGENCE),
+PRODUCT LIABILITY OR ANY OTHER CAUSE OF ACTION OR THEORY OF
+LIABILITY. IN NO EVENT WILL NVIDIA’S AND ITS AFFILIATES
+TOTAL CUMULATIVE LIABILITY UNDER OR ARISING OUT OF THIS
+AGREEMENT EXCEED US$10.00. THE NATURE OF THE LIABILITY OR THE
+NUMBER OF CLAIMS OR SUITS SHALL NOT ENLARGE OR EXTEND THIS
+LIMIT.
+
+These exclusions and limitations of liability shall apply
+regardless if NVIDIA or its affiliates have been advised of
+the possibility of such damages, and regardless of whether a
+remedy fails its essential purpose. These exclusions and
+limitations of liability form an essential basis of the
+bargain between the parties, and, absent any of these
+exclusions or limitations of liability, the provisions of this
+Agreement, including, without limitation, the economic terms,
+would be substantially different.
+
+
+1.6. Termination
+
+ 1. This Agreement will continue to apply until terminated by
+ either you or NVIDIA as described below.
+
+ 2. If you want to terminate this Agreement, you may do so by
+ stopping to use the SDK.
+
+ 3. NVIDIA may, at any time, terminate this Agreement if:
+
+ a. (i) you fail to comply with any term of this
+ Agreement and the non-compliance is not fixed within
+ thirty (30) days following notice from NVIDIA (or
+ immediately if you violate NVIDIA’s intellectual
+ property rights);
+
+ b. (ii) you commence or participate in any legal
+ proceeding against NVIDIA with respect to the SDK; or
+
+ c. (iii) NVIDIA decides to no longer provide the SDK in
+ a country or, in NVIDIA’s sole discretion, the
+ continued use of it is no longer commercially viable.
+
+ 4. Upon any termination of this Agreement, you agree to
+ promptly discontinue use of the SDK and destroy all copies
+ in your possession or control. Your prior distributions in
+ accordance with this Agreement are not affected by the
+ termination of this Agreement. Upon written request, you
+ will certify in writing that you have complied with your
+ commitments under this section. Upon any termination of
+ this Agreement all provisions survive except for the
+ license grant provisions.
+
+
+1.7. General
+
+If you wish to assign this Agreement or your rights and
+obligations, including by merger, consolidation, dissolution
+or operation of law, contact NVIDIA to ask for permission. Any
+attempted assignment not approved by NVIDIA in writing shall
+be void and of no effect. NVIDIA may assign, delegate or
+transfer this Agreement and its rights and obligations, and if
+to a non-affiliate you will be notified.
+
+You agree to cooperate with NVIDIA and provide reasonably
+requested information to verify your compliance with this
+Agreement.
+
+This Agreement will be governed in all respects by the laws of
+the United States and of the State of Delaware as those laws
+are applied to contracts entered into and performed entirely
+within Delaware by Delaware residents, without regard to the
+conflicts of laws principles. The United Nations Convention on
+Contracts for the International Sale of Goods is specifically
+disclaimed. You agree to all terms of this Agreement in the
+English language.
+
+The state or federal courts residing in Santa Clara County,
+California shall have exclusive jurisdiction over any dispute
+or claim arising out of this Agreement. Notwithstanding this,
+you agree that NVIDIA shall still be allowed to apply for
+injunctive remedies or an equivalent type of urgent legal
+relief in any jurisdiction.
+
+If any court of competent jurisdiction determines that any
+provision of this Agreement is illegal, invalid or
+unenforceable, such provision will be construed as limited to
+the extent necessary to be consistent with and fully
+enforceable under the law and the remaining provisions will
+remain in full force and effect. Unless otherwise specified,
+remedies are cumulative.
+
+Each party acknowledges and agrees that the other is an
+independent contractor in the performance of this Agreement.
+
+The SDK has been developed entirely at private expense and is
+“commercial items” consisting of “commercial computer
+software” and “commercial computer software
+documentation” provided with RESTRICTED RIGHTS. Use,
+duplication or disclosure by the U.S. Government or a U.S.
+Government subcontractor is subject to the restrictions in
+this Agreement pursuant to DFARS 227.7202-3(a) or as set forth
+in subparagraphs (c)(1) and (2) of the Commercial Computer
+Software - Restricted Rights clause at FAR 52.227-19, as
+applicable. Contractor/manufacturer is NVIDIA, 2788 San Tomas
+Expressway, Santa Clara, CA 95051.
+
+The SDK is subject to United States export laws and
+regulations. You agree that you will not ship, transfer or
+export the SDK into any country, or use the SDK in any manner,
+prohibited by the United States Bureau of Industry and
+Security or economic sanctions regulations administered by the
+U.S. Department of Treasury’s Office of Foreign Assets
+Control (OFAC), or any applicable export laws, restrictions or
+regulations. These laws include restrictions on destinations,
+end users and end use. By accepting this Agreement, you
+confirm that you are not a resident or citizen of any country
+currently embargoed by the U.S. and that you are not otherwise
+prohibited from receiving the SDK.
+
+Any notice delivered by NVIDIA to you under this Agreement
+will be delivered via mail, email or fax. You agree that any
+notices that NVIDIA sends you electronically will satisfy any
+legal communication requirements. Please direct your legal
+notices or other correspondence to NVIDIA Corporation, 2788
+San Tomas Expressway, Santa Clara, California 95051, United
+States of America, Attention: Legal Department.
+
+This Agreement and any exhibits incorporated into this
+Agreement constitute the entire agreement of the parties with
+respect to the subject matter of this Agreement and supersede
+all prior negotiations or documentation exchanged between the
+parties relating to this SDK license. Any additional and/or
+conflicting terms on documents issued by you are null, void,
+and invalid. Any amendment or waiver under this Agreement
+shall be in writing and signed by representatives of both
+parties.
+
+
+2. CUDA Toolkit Supplement to Software License Agreement for
+NVIDIA Software Development Kits
+------------------------------------------------------------
+
+
+Release date: August 16, 2018
+-----------------------------
+
+The terms in this supplement govern your use of the NVIDIA
+CUDA Toolkit SDK under the terms of your license agreement
+(“Agreement”) as modified by this supplement. Capitalized
+terms used but not defined below have the meaning assigned to
+them in the Agreement.
+
+This supplement is an exhibit to the Agreement and is
+incorporated as an integral part of the Agreement. In the
+event of conflict between the terms in this supplement and the
+terms in the Agreement, the terms in this supplement govern.
+
+
+2.1. License Scope
+
+The SDK is licensed for you to develop applications only for
+use in systems with NVIDIA GPUs.
+
+
+2.2. Distribution
+
+The portions of the SDK that are distributable under the
+Agreement are listed in Attachment A.
+
+
+2.3. Operating Systems
+
+Those portions of the SDK designed exclusively for use on the
+Linux or FreeBSD operating systems, or other operating systems
+derived from the source code to these operating systems, may
+be copied and redistributed for use in accordance with this
+Agreement, provided that the object code files are not
+modified in any way (except for unzipping of compressed
+files).
+
+
+2.4. Audio and Video Encoders and Decoders
+
+You acknowledge and agree that it is your sole responsibility
+to obtain any additional third-party licenses required to
+make, have made, use, have used, sell, import, and offer for
+sale your products or services that include or incorporate any
+third-party software and content relating to audio and/or
+video encoders and decoders from, including but not limited
+to, Microsoft, Thomson, Fraunhofer IIS, Sisvel S.p.A.,
+MPEG-LA, and Coding Technologies. NVIDIA does not grant to you
+under this Agreement any necessary patent or other rights with
+respect to any audio and/or video encoders and decoders.
+
+
+2.5. Licensing
+
+If the distribution terms in this Agreement are not suitable
+for your organization, or for any questions regarding this
+Agreement, please contact NVIDIA at
+nvidia-compute-license-questions@nvidia.com.
+
+
+2.6. Attachment A
+
+The following portions of the SDK are distributable under the
+Agreement:
+
+Component
+
+CUDA Runtime
+
+Windows
+
+cudart.dll, cudart_static.lib, cudadevrt.lib
+
+Mac OSX
+
+libcudart.dylib, libcudart_static.a, libcudadevrt.a
+
+Linux
+
+libcudart.so, libcudart_static.a, libcudadevrt.a
+
+Android
+
+libcudart.so, libcudart_static.a, libcudadevrt.a
+
+Component
+
+CUDA FFT Library
+
+Windows
+
+cufft.dll, cufftw.dll, cufft.lib, cufftw.lib
+
+Mac OSX
+
+libcufft.dylib, libcufft_static.a, libcufftw.dylib,
+libcufftw_static.a
+
+Linux
+
+libcufft.so, libcufft_static.a, libcufftw.so,
+libcufftw_static.a
+
+Android
+
+libcufft.so, libcufft_static.a, libcufftw.so,
+libcufftw_static.a
+
+Component
+
+CUDA BLAS Library
+
+Windows
+
+cublas.dll, cublasLt.dll
+
+Mac OSX
+
+libcublas.dylib, libcublasLt.dylib, libcublas_static.a,
+libcublasLt_static.a
+
+Linux
+
+libcublas.so, libcublasLt.so, libcublas_static.a,
+libcublasLt_static.a
+
+Android
+
+libcublas.so, libcublasLt.so, libcublas_static.a,
+libcublasLt_static.a
+
+Component
+
+NVIDIA "Drop-in" BLAS Library
+
+Windows
+
+nvblas.dll
+
+Mac OSX
+
+libnvblas.dylib
+
+Linux
+
+libnvblas.so
+
+Component
+
+CUDA Sparse Matrix Library
+
+Windows
+
+cusparse.dll, cusparse.lib
+
+Mac OSX
+
+libcusparse.dylib, libcusparse_static.a
+
+Linux
+
+libcusparse.so, libcusparse_static.a
+
+Android
+
+libcusparse.so, libcusparse_static.a
+
+Component
+
+CUDA Linear Solver Library
+
+Windows
+
+cusolver.dll, cusolver.lib
+
+Mac OSX
+
+libcusolver.dylib, libcusolver_static.a
+
+Linux
+
+libcusolver.so, libcusolver_static.a
+
+Android
+
+libcusolver.so, libcusolver_static.a
+
+Component
+
+CUDA Random Number Generation Library
+
+Windows
+
+curand.dll, curand.lib
+
+Mac OSX
+
+libcurand.dylib, libcurand_static.a
+
+Linux
+
+libcurand.so, libcurand_static.a
+
+Android
+
+libcurand.so, libcurand_static.a
+
+Component
+
+CUDA Accelerated Graph Library
+
+Component
+
+NVIDIA Performance Primitives Library
+
+Windows
+
+nppc.dll, nppc.lib, nppial.dll, nppial.lib, nppicc.dll,
+nppicc.lib, nppicom.dll, nppicom.lib, nppidei.dll,
+nppidei.lib, nppif.dll, nppif.lib, nppig.dll, nppig.lib,
+nppim.dll, nppim.lib, nppist.dll, nppist.lib, nppisu.dll,
+nppisu.lib, nppitc.dll, nppitc.lib, npps.dll, npps.lib
+
+Mac OSX
+
+libnppc.dylib, libnppc_static.a, libnppial.dylib,
+libnppial_static.a, libnppicc.dylib, libnppicc_static.a,
+libnppicom.dylib, libnppicom_static.a, libnppidei.dylib,
+libnppidei_static.a, libnppif.dylib, libnppif_static.a,
+libnppig.dylib, libnppig_static.a, libnppim.dylib,
+libnppisu_static.a, libnppitc.dylib, libnppitc_static.a,
+libnpps.dylib, libnpps_static.a
+
+Linux
+
+libnppc.so, libnppc_static.a, libnppial.so,
+libnppial_static.a, libnppicc.so, libnppicc_static.a,
+libnppicom.so, libnppicom_static.a, libnppidei.so,
+libnppidei_static.a, libnppif.so, libnppif_static.a
+libnppig.so, libnppig_static.a, libnppim.so,
+libnppim_static.a, libnppist.so, libnppist_static.a,
+libnppisu.so, libnppisu_static.a, libnppitc.so
+libnppitc_static.a, libnpps.so, libnpps_static.a
+
+Android
+
+libnppc.so, libnppc_static.a, libnppial.so,
+libnppial_static.a, libnppicc.so, libnppicc_static.a,
+libnppicom.so, libnppicom_static.a, libnppidei.so,
+libnppidei_static.a, libnppif.so, libnppif_static.a
+libnppig.so, libnppig_static.a, libnppim.so,
+libnppim_static.a, libnppist.so, libnppist_static.a,
+libnppisu.so, libnppisu_static.a, libnppitc.so
+libnppitc_static.a, libnpps.so, libnpps_static.a
+
+Component
+
+NVIDIA JPEG Library
+
+Linux
+
+libnvjpeg.so, libnvjpeg_static.a
+
+Component
+
+Internal common library required for statically linking to
+cuBLAS, cuSPARSE, cuFFT, cuRAND, nvJPEG and NPP
+
+Mac OSX
+
+libculibos.a
+
+Linux
+
+libculibos.a
+
+Component
+
+NVIDIA Runtime Compilation Library and Header
+
+All
+
+nvrtc.h
+
+Windows
+
+nvrtc.dll, nvrtc-builtins.dll
+
+Mac OSX
+
+libnvrtc.dylib, libnvrtc-builtins.dylib
+
+Linux
+
+libnvrtc.so, libnvrtc-builtins.so
+
+Component
+
+NVIDIA Optimizing Compiler Library
+
+Windows
+
+nvvm.dll
+
+Mac OSX
+
+libnvvm.dylib
+
+Linux
+
+libnvvm.so
+
+Component
+
+NVIDIA Common Device Math Functions Library
+
+Windows
+
+libdevice.10.bc
+
+Mac OSX
+
+libdevice.10.bc
+
+Linux
+
+libdevice.10.bc
+
+Component
+
+CUDA Occupancy Calculation Header Library
+
+All
+
+cuda_occupancy.h
+
+Component
+
+CUDA Half Precision Headers
+
+All
+
+cuda_fp16.h, cuda_fp16.hpp
+
+Component
+
+CUDA Profiling Tools Interface (CUPTI) Library
+
+Windows
+
+cupti.dll
+
+Mac OSX
+
+libcupti.dylib
+
+Linux
+
+libcupti.so
+
+Component
+
+NVIDIA Tools Extension Library
+
+Windows
+
+nvToolsExt.dll, nvToolsExt.lib
+
+Mac OSX
+
+libnvToolsExt.dylib
+
+Linux
+
+libnvToolsExt.so
+
+Component
+
+NVIDIA CUDA Driver Libraries
+
+Linux
+
+libcuda.so, libnvidia-fatbinaryloader.so,
+libnvidia-ptxjitcompiler.so
+
+The NVIDIA CUDA Driver Libraries are only distributable in
+applications that meet this criteria:
+
+ 1. The application was developed starting from a NVIDIA CUDA
+ container obtained from Docker Hub or the NVIDIA GPU
+ Cloud, and
+
+ 2. The resulting application is packaged as a Docker
+ container and distributed to users on Docker Hub or the
+ NVIDIA GPU Cloud only.
+
+
+2.7. Attachment B
+
+
+Additional Licensing Obligations
+
+The following third party components included in the SOFTWARE
+are licensed to Licensee pursuant to the following terms and
+conditions:
+
+ 1. Licensee's use of the GDB third party component is
+ subject to the terms and conditions of GNU GPL v3:
+
+ This product includes copyrighted third-party software licensed
+ under the terms of the GNU General Public License v3 ("GPL v3").
+ All third-party software packages are copyright by their respective
+ authors. GPL v3 terms and conditions are hereby incorporated into
+ the Agreement by this reference: http://www.gnu.org/licenses/gpl.txt
+
+ Consistent with these licensing requirements, the software
+ listed below is provided under the terms of the specified
+ open source software licenses. To obtain source code for
+ software provided under licenses that require
+ redistribution of source code, including the GNU General
+ Public License (GPL) and GNU Lesser General Public License
+ (LGPL), contact oss-requests@nvidia.com. This offer is
+ valid for a period of three (3) years from the date of the
+ distribution of this product by NVIDIA CORPORATION.
+
+ Component License
+ CUDA-GDB GPL v3
+
+ 2. Licensee represents and warrants that any and all third
+ party licensing and/or royalty payment obligations in
+ connection with Licensee's use of the H.264 video codecs
+ are solely the responsibility of Licensee.
+
+ 3. Licensee's use of the Thrust library is subject to the
+ terms and conditions of the Apache License Version 2.0.
+ All third-party software packages are copyright by their
+ respective authors. Apache License Version 2.0 terms and
+ conditions are hereby incorporated into the Agreement by
+ this reference.
+ http://www.apache.org/licenses/LICENSE-2.0.html
+
+ In addition, Licensee acknowledges the following notice:
+ Thrust includes source code from the Boost Iterator,
+ Tuple, System, and Random Number libraries.
+
+ Boost Software License - Version 1.0 - August 17th, 2003
+ . . . .
+
+ Permission is hereby granted, free of charge, to any person or
+ organization obtaining a copy of the software and accompanying
+ documentation covered by this license (the "Software") to use,
+ reproduce, display, distribute, execute, and transmit the Software,
+ and to prepare derivative works of the Software, and to permit
+ third-parties to whom the Software is furnished to do so, all
+ subject to the following:
+
+ The copyright notices in the Software and this entire statement,
+ including the above license grant, this restriction and the following
+ disclaimer, must be included in all copies of the Software, in whole
+ or in part, and all derivative works of the Software, unless such
+ copies or derivative works are solely in the form of machine-executable
+ object code generated by a source language processor.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND
+ NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
+ ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES OR
+ OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ OTHER DEALINGS IN THE SOFTWARE.
+
+ 4. Licensee's use of the LLVM third party component is
+ subject to the following terms and conditions:
+
+ ======================================================
+ LLVM Release License
+ ======================================================
+ University of Illinois/NCSA
+ Open Source License
+
+ Copyright (c) 2003-2010 University of Illinois at Urbana-Champaign.
+ All rights reserved.
+
+ Developed by:
+
+ LLVM Team
+
+ University of Illinois at Urbana-Champaign
+
+ http://llvm.org
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to
+ deal with the Software without restriction, including without limitation the
+ rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ sell copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ * Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimers.
+
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimers in the
+ documentation and/or other materials provided with the distribution.
+
+ * Neither the names of the LLVM Team, University of Illinois at Urbana-
+ Champaign, nor the names of its contributors may be used to endorse or
+ promote products derived from this Software without specific prior
+ written permission.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ THE CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ DEALINGS WITH THE SOFTWARE.
+
+ 5. Licensee's use (e.g. nvprof) of the PCRE third party
+ component is subject to the following terms and
+ conditions:
+
+ ------------
+ PCRE LICENCE
+ ------------
+ PCRE is a library of functions to support regular expressions whose syntax
+ and semantics are as close as possible to those of the Perl 5 language.
+ Release 8 of PCRE is distributed under the terms of the "BSD" licence, as
+ specified below. The documentation for PCRE, supplied in the "doc"
+ directory, is distributed under the same terms as the software itself. The
+ basic library functions are written in C and are freestanding. Also
+ included in the distribution is a set of C++ wrapper functions, and a just-
+ in-time compiler that can be used to optimize pattern matching. These are
+ both optional features that can be omitted when the library is built.
+
+ THE BASIC LIBRARY FUNCTIONS
+ ---------------------------
+ Written by: Philip Hazel
+ Email local part: ph10
+ Email domain: cam.ac.uk
+ University of Cambridge Computing Service,
+ Cambridge, England.
+ Copyright (c) 1997-2012 University of Cambridge
+ All rights reserved.
+
+ PCRE JUST-IN-TIME COMPILATION SUPPORT
+ -------------------------------------
+ Written by: Zoltan Herczeg
+ Email local part: hzmester
+ Emain domain: freemail.hu
+ Copyright(c) 2010-2012 Zoltan Herczeg
+ All rights reserved.
+
+ STACK-LESS JUST-IN-TIME COMPILER
+ --------------------------------
+ Written by: Zoltan Herczeg
+ Email local part: hzmester
+ Emain domain: freemail.hu
+ Copyright(c) 2009-2012 Zoltan Herczeg
+ All rights reserved.
+
+ THE C++ WRAPPER FUNCTIONS
+ -------------------------
+ Contributed by: Google Inc.
+ Copyright (c) 2007-2012, Google Inc.
+ All rights reserved.
+
+ THE "BSD" LICENCE
+ -----------------
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ * Neither the name of the University of Cambridge nor the name of Google
+ Inc. nor the names of their contributors may be used to endorse or
+ promote products derived from this software without specific prior
+ written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.
+
+ 6. Some of the cuBLAS library routines were written by or
+ derived from code written by Vasily Volkov and are subject
+ to the Modified Berkeley Software Distribution License as
+ follows:
+
+ Copyright (c) 2007-2009, Regents of the University of California
+
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are
+ met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the following
+ disclaimer in the documentation and/or other materials provided
+ with the distribution.
+ * Neither the name of the University of California, Berkeley nor
+ the names of its contributors may be used to endorse or promote
+ products derived from this software without specific prior
+ written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR
+ IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.
+
+ 7. Some of the cuBLAS library routines were written by or
+ derived from code written by Davide Barbieri and are
+ subject to the Modified Berkeley Software Distribution
+ License as follows:
+
+ Copyright (c) 2008-2009 Davide Barbieri @ University of Rome Tor Vergata.
+
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are
+ met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the following
+ disclaimer in the documentation and/or other materials provided
+ with the distribution.
+ * The name of the author may not be used to endorse or promote
+ products derived from this software without specific prior
+ written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR
+ IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.
+
+ 8. Some of the cuBLAS library routines were derived from
+ code developed by the University of Tennessee and are
+ subject to the Modified Berkeley Software Distribution
+ License as follows:
+
+ Copyright (c) 2010 The University of Tennessee.
+
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are
+ met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the following
+ disclaimer listed in this license in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the name of the copyright holders nor the names of its
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ 9. Some of the cuBLAS library routines were written by or
+ derived from code written by Jonathan Hogg and are subject
+ to the Modified Berkeley Software Distribution License as
+ follows:
+
+ Copyright (c) 2012, The Science and Technology Facilities Council (STFC).
+
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are
+ met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the following
+ disclaimer in the documentation and/or other materials provided
+ with the distribution.
+ * Neither the name of the STFC nor the names of its contributors
+ may be used to endorse or promote products derived from this
+ software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE STFC BE
+ LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ 10. Some of the cuBLAS library routines were written by or
+ derived from code written by Ahmad M. Abdelfattah, David
+ Keyes, and Hatem Ltaief, and are subject to the Apache
+ License, Version 2.0, as follows:
+
+ -- (C) Copyright 2013 King Abdullah University of Science and Technology
+ Authors:
+ Ahmad Abdelfattah (ahmad.ahmad@kaust.edu.sa)
+ David Keyes (david.keyes@kaust.edu.sa)
+ Hatem Ltaief (hatem.ltaief@kaust.edu.sa)
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions
+ are met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+ * Neither the name of the King Abdullah University of Science and
+ Technology nor the names of its contributors may be used to endorse
+ or promote products derived from this software without specific prior
+ written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
+
+ 11. Some of the cuSPARSE library routines were written by or
+ derived from code written by Li-Wen Chang and are subject
+ to the NCSA Open Source License as follows:
+
+ Copyright (c) 2012, University of Illinois.
+
+ All rights reserved.
+
+ Developed by: IMPACT Group, University of Illinois, http://impact.crhc.illinois.edu
+
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of this software and associated documentation files (the
+ "Software"), to deal with the Software without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to
+ permit persons to whom the Software is furnished to do so, subject to
+ the following conditions:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the following
+ disclaimers in the documentation and/or other materials provided
+ with the distribution.
+ * Neither the names of IMPACT Group, University of Illinois, nor
+ the names of its contributors may be used to endorse or promote
+ products derived from this Software without specific prior
+ written permission.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE CONTRIBUTORS OR COPYRIGHT
+ HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+ IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
+ SOFTWARE.
+
+ 12. Some of the cuRAND library routines were written by or
+ derived from code written by Mutsuo Saito and Makoto
+ Matsumoto and are subject to the following license:
+
+ Copyright (c) 2009, 2010 Mutsuo Saito, Makoto Matsumoto and Hiroshima
+ University. All rights reserved.
+
+ Copyright (c) 2011 Mutsuo Saito, Makoto Matsumoto, Hiroshima
+ University and University of Tokyo. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are
+ met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the following
+ disclaimer in the documentation and/or other materials provided
+ with the distribution.
+ * Neither the name of the Hiroshima University nor the names of
+ its contributors may be used to endorse or promote products
+ derived from this software without specific prior written
+ permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ 13. Some of the cuRAND library routines were derived from
+ code developed by D. E. Shaw Research and are subject to
+ the following license:
+
+ Copyright 2010-2011, D. E. Shaw Research.
+
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are
+ met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions, and the following disclaimer.
+ * Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions, and the following
+ disclaimer in the documentation and/or other materials provided
+ with the distribution.
+ * Neither the name of D. E. Shaw Research nor the names of its
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ 14. Some of the Math library routines were written by or
+ derived from code developed by Norbert Juffa and are
+ subject to the following license:
+
+ Copyright (c) 2015-2017, Norbert Juffa
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions
+ are met:
+
+ 1. Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ 15. Licensee's use of the lz4 third party component is
+ subject to the following terms and conditions:
+
+ Copyright (C) 2011-2013, Yann Collet.
+ BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are
+ met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the following disclaimer
+ in the documentation and/or other materials provided with the
+ distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ 16. The NPP library uses code from the Boost Math Toolkit,
+ and is subject to the following license:
+
+ Boost Software License - Version 1.0 - August 17th, 2003
+ . . . .
+
+ Permission is hereby granted, free of charge, to any person or
+ organization obtaining a copy of the software and accompanying
+ documentation covered by this license (the "Software") to use,
+ reproduce, display, distribute, execute, and transmit the Software,
+ and to prepare derivative works of the Software, and to permit
+ third-parties to whom the Software is furnished to do so, all
+ subject to the following:
+
+ The copyright notices in the Software and this entire statement,
+ including the above license grant, this restriction and the following
+ disclaimer, must be included in all copies of the Software, in whole
+ or in part, and all derivative works of the Software, unless such
+ copies or derivative works are solely in the form of machine-executable
+ object code generated by a source language processor.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND
+ NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
+ ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES OR
+ OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ OTHER DEALINGS IN THE SOFTWARE.
+
+ 17. Portions of the Nsight Eclipse Edition is subject to the
+ following license:
+
+ The Eclipse Foundation makes available all content in this plug-in
+ ("Content"). Unless otherwise indicated below, the Content is provided
+ to you under the terms and conditions of the Eclipse Public License
+ Version 1.0 ("EPL"). A copy of the EPL is available at http://
+ www.eclipse.org/legal/epl-v10.html. For purposes of the EPL, "Program"
+ will mean the Content.
+
+ If you did not receive this Content directly from the Eclipse
+ Foundation, the Content is being redistributed by another party
+ ("Redistributor") and different terms and conditions may apply to your
+ use of any object code in the Content. Check the Redistributor's
+ license that was provided with the Content. If no such license exists,
+ contact the Redistributor. Unless otherwise indicated below, the terms
+ and conditions of the EPL still apply to any source code in the
+ Content and such source code may be obtained at http://www.eclipse.org.
+
+ 18. Some of the cuBLAS library routines uses code from
+ OpenAI, which is subject to the following license:
+
+ License URL
+ https://github.com/openai/openai-gemm/blob/master/LICENSE
+
+ License Text
+ The MIT License
+
+ Copyright (c) 2016 OpenAI (http://openai.com), 2016 Google Inc.
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+
+ 19. Licensee's use of the Visual Studio Setup Configuration
+ Samples is subject to the following license:
+
+ The MIT License (MIT)
+ Copyright (C) Microsoft Corporation. All rights reserved.
+
+ Permission is hereby granted, free of charge, to any person
+ obtaining a copy of this software and associated documentation
+ files (the "Software"), to deal in the Software without restriction,
+ including without limitation the rights to use, copy, modify, merge,
+ publish, distribute, sublicense, and/or sell copies of the Software,
+ and to permit persons to whom the Software is furnished to do so,
+ subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included
+ in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+ 20. Licensee's use of linmath.h header for CPU functions for
+ GL vector/matrix operations from lunarG is subject to the
+ Apache License Version 2.0.
+
+ 21. The DX12-CUDA sample uses the d3dx12.h header, which is
+ subject to the MIT license .
+
+-----------------
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_cuda_cupti_cu12-12.8.90.dist-info/METADATA b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_cuda_cupti_cu12-12.8.90.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..c36cf7041f12162438176dfa15e5ff5deb561f11
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_cuda_cupti_cu12-12.8.90.dist-info/METADATA
@@ -0,0 +1,44 @@
+Metadata-Version: 2.2
+Name: nvidia-cuda-cupti-cu12
+Version: 12.8.90
+Summary: CUDA profiling tools runtime libs.
+Home-page: https://developer.nvidia.com/cuda-zone
+Author: Nvidia CUDA Installer Team
+Author-email: compute_installer@nvidia.com
+License: NVIDIA Proprietary Software
+Keywords: cuda,nvidia,runtime,machine learning,deep learning
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: Other/Proprietary License
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3
+License-File: License.txt
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: requires-python
+Dynamic: summary
+
+Provides libraries to enable third party tools using GPU profiling APIs.
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_cuda_cupti_cu12-12.8.90.dist-info/RECORD b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_cuda_cupti_cu12-12.8.90.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..9cb87fb1660774b7eaff3f18e159f64507dc265e
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_cuda_cupti_cu12-12.8.90.dist-info/RECORD
@@ -0,0 +1,56 @@
+nvidia/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nvidia/__pycache__/__init__.cpython-312.pyc,,
+nvidia/cuda_cupti/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nvidia/cuda_cupti/__pycache__/__init__.cpython-312.pyc,,
+nvidia/cuda_cupti/include/Openacc/cupti_openacc.h,sha256=Z0OM5e_hbd3cxdXyn3SCHqBBQawLg4QORnlm57Cr2-M,3513
+nvidia/cuda_cupti/include/Openmp/cupti_openmp.h,sha256=E1WNmeb_7HaUSmBegtUNe4IV1i7pXeNxgzIlyKn1zrM,3491
+nvidia/cuda_cupti/include/Openmp/omp-tools.h,sha256=AmuC_xPC7VPu3B-W4PmXuCNufFawhY8PjNXePaQFAOg,37403
+nvidia/cuda_cupti/include/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nvidia/cuda_cupti/include/__pycache__/__init__.cpython-312.pyc,,
+nvidia/cuda_cupti/include/cuda_stdint.h,sha256=XbFOk9CtJjKqk7PpYNqbSVsDxAsVM8avA4rWpPi0BjQ,4093
+nvidia/cuda_cupti/include/cupti.h,sha256=JkVyAGTIMYzwm62dfVqas3nMcILhgP_Wdz6fh4_NED0,4697
+nvidia/cuda_cupti/include/cupti_activity.h,sha256=gJKGlG2JifW36Lx-ujJcKBlnUrNOoTxar51k28GrUtU,229848
+nvidia/cuda_cupti/include/cupti_activity_deprecated.h,sha256=B0p4zbll2vUn1j0ImTG6QIbpp6Hiw8y-X021Zmf7flE,137602
+nvidia/cuda_cupti/include/cupti_callbacks.h,sha256=aZ-SE0YMFfT9R-Uh5MHboPg0ypHMjeSSAJw3zdP7OCs,29689
+nvidia/cuda_cupti/include/cupti_checkpoint.h,sha256=rTz8JoWxqESBXyZWUhZJGm4xeYcx4OJOtJ7Ld13T_b0,5264
+nvidia/cuda_cupti/include/cupti_common.h,sha256=85m74bxUgXp3tEaPQpezeazmpsNMw41PsjNSYmQdT20,3514
+nvidia/cuda_cupti/include/cupti_driver_cbid.h,sha256=mkBNPYkLfcExhQZFDo0iYHlaHJWGD2vOMdtzaV-lEUk,77280
+nvidia/cuda_cupti/include/cupti_events.h,sha256=81wcvFvvHj8RmECbbEp5FfgjJIQDoC_81FhvqznFupY,51923
+nvidia/cuda_cupti/include/cupti_metrics.h,sha256=zmfZxq5VkUJp6Tj7oXEkP9oycRNw1zB9VNhoQlbhiN4,32175
+nvidia/cuda_cupti/include/cupti_nvtx_cbid.h,sha256=_azPtR1g4qivvX7qbvHRUg0RHCWF7iEOJyHMN9qZe9E,5912
+nvidia/cuda_cupti/include/cupti_pcsampling.h,sha256=ycJHT36DmPIaVzHsB3xxjXkhFyEfMCJOl3LbCsHFgyA,32144
+nvidia/cuda_cupti/include/cupti_pcsampling_util.h,sha256=lx8CaNXowJe5Zvc06LE-u_Zry_jODs1mM6j9Q5WIX9E,12430
+nvidia/cuda_cupti/include/cupti_pmsampling.h,sha256=U95hKOwIkZSbGNVP11QSmMawB8qdJsljY_tUJY4vedc,20440
+nvidia/cuda_cupti/include/cupti_profiler_host.h,sha256=MkkfXlKBRrRL4NfaPFiuE4D4z_gpmxiBWWTBixyyMTk,22155
+nvidia/cuda_cupti/include/cupti_profiler_target.h,sha256=MdLutIefwdMTI7wsce0LO3NuCm3FRgFR3GxAkqadMs4,32294
+nvidia/cuda_cupti/include/cupti_range_profiler.h,sha256=ue5bUA-3xCwAtQGyDe5O1d5rAmRbVbcrXKfITd4xM1I,18779
+nvidia/cuda_cupti/include/cupti_result.h,sha256=xQqBsZRoicBSWdk1lZAE_WeZj88MLH6ClTo58oshx-8,13114
+nvidia/cuda_cupti/include/cupti_runtime_cbid.h,sha256=BZJnzsvf2RjRlHKEhPjCk0CdjLI9_L-nClTwe4v9NUc,48372
+nvidia/cuda_cupti/include/cupti_sass_metrics.h,sha256=3RW9snJuFQdOhrEn3wDJOru05q0V_zssWrqD7tvVJKw,19674
+nvidia/cuda_cupti/include/cupti_target.h,sha256=x4Vz1Upb6m9ixmVpmGaKQldDWYQI3OZ-ocEXGzNK0EE,1263
+nvidia/cuda_cupti/include/cupti_version.h,sha256=KFXmjB4o-iZGvO8la9Sf9Urg4q4srmEimnxbPCyd2N8,4506
+nvidia/cuda_cupti/include/generated_cudaGL_meta.h,sha256=dfd2QuaRdEjbStOKvaQLi1Md_qrpRQh8PfyZznJ8bWY,3115
+nvidia/cuda_cupti/include/generated_cudaVDPAU_meta.h,sha256=fAedsoQxaU3hIAApAWDOKsa9kgcuQw4tdyf8klLm-3k,1453
+nvidia/cuda_cupti/include/generated_cuda_gl_interop_meta.h,sha256=LXOqvQCej0sCgAT1LUKKYZ466EFxN4hIwf9oIhXOLF0,2250
+nvidia/cuda_cupti/include/generated_cuda_meta.h,sha256=DDdgfW84GVtsGbr7daNJchmmZDS_xfvDHvFCm3I1OEc,98664
+nvidia/cuda_cupti/include/generated_cuda_runtime_api_meta.h,sha256=CuziaDwO2Mh33paCLGKqi73PQfYNmzp38wYrhAK-fng,72208
+nvidia/cuda_cupti/include/generated_cuda_vdpau_interop_meta.h,sha256=8OLqWN26aEYpTWUXtbHJvA5GYhVv3ybYVOTW7yK37z8,1367
+nvidia/cuda_cupti/include/generated_cudart_removed_meta.h,sha256=X3I5WXmhtsJNNlgY7coJ5vg4t11G5FRR6Xo7MboIeck,5172
+nvidia/cuda_cupti/include/generated_nvtx_meta.h,sha256=YHb_RD8g3s4m8PJn7Z0wnxvUHarl7BOAX5ADr-BL3HI,7513
+nvidia/cuda_cupti/include/nvperf_common.h,sha256=ykeTJ5I6c0z8KqMQh13hlJaMaHiqqVUB60oGXOCu7Bg,17255
+nvidia/cuda_cupti/include/nvperf_cuda_host.h,sha256=gC0JWoUdTyAOJs8y4uoJIhie9Xq4yF4HzoumLsYNVzU,7562
+nvidia/cuda_cupti/include/nvperf_host.h,sha256=wCB4mR8aIHWiqT1TsxztQgWBRh_yiq5ABFm8sb3_jwg,49197
+nvidia/cuda_cupti/include/nvperf_target.h,sha256=jRqQtuNLTrCzPDdyeANkTrPEijSCTjLy2A1qjKu0SdM,23607
+nvidia/cuda_cupti/lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nvidia/cuda_cupti/lib/__pycache__/__init__.cpython-312.pyc,,
+nvidia/cuda_cupti/lib/libcheckpoint.so,sha256=BrqCvQkje5NM8W2iFy7VlDxYLKo1x5tSz8_rD_cfclA,1644872
+nvidia/cuda_cupti/lib/libcupti.so.12,sha256=_M3F_MfDL4z0s-2bF_fxh6GFpvoKW8wG40NMvRaHyAg,7595792
+nvidia/cuda_cupti/lib/libnvperf_host.so,sha256=YJ9UBjwlPa_277p5_kklL90jJDCKsP-5kcwSXT6aHqs,25825936
+nvidia/cuda_cupti/lib/libnvperf_target.so,sha256=LxDhEJ_DQaV0NMKOQAa0WokkeAHiD1rOE1wwLBc-B3A,5275312
+nvidia/cuda_cupti/lib/libpcsamplingutil.so,sha256=5vongwd5dPsnZb-py66_mAc233Tuv5lMWcdZaYiuyDs,970064
+nvidia_cuda_cupti_cu12-12.8.90.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+nvidia_cuda_cupti_cu12-12.8.90.dist-info/License.txt,sha256=rW9YU_ugyg0VnQ9Y1JrkmDDC-Mk_epJki5zpCttMbM0,59262
+nvidia_cuda_cupti_cu12-12.8.90.dist-info/METADATA,sha256=bff6L836BG65UvP4wXL1JLLhmmVOwDfaPbsy6T2WcdE,1730
+nvidia_cuda_cupti_cu12-12.8.90.dist-info/RECORD,,
+nvidia_cuda_cupti_cu12-12.8.90.dist-info/WHEEL,sha256=ygM8qpYgOvrn5C-8vbfzPi-0iFPECh71lLWqkqrTjYw,144
+nvidia_cuda_cupti_cu12-12.8.90.dist-info/top_level.txt,sha256=fTkAtiFuL16nUrB9ytDDtpytz2t0B4NvYTnRzwAhO14,7
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_cuda_cupti_cu12-12.8.90.dist-info/WHEEL b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_cuda_cupti_cu12-12.8.90.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..287a9d7e1a3d4435e9542cc8216b8c5eaf2c0ed2
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_cuda_cupti_cu12-12.8.90.dist-info/WHEEL
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.8.0)
+Root-Is-Purelib: true
+Tag: py3-none-manylinux2014_x86_64
+Tag: py3-none-manylinux_2_17_x86_64
+
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_cuda_cupti_cu12-12.8.90.dist-info/top_level.txt b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_cuda_cupti_cu12-12.8.90.dist-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..862f7abf232cdfbb928609856247292e81c9decb
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_cuda_cupti_cu12-12.8.90.dist-info/top_level.txt
@@ -0,0 +1 @@
+nvidia
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_cufile_cu12-1.13.1.3.dist-info/INSTALLER b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_cufile_cu12-1.13.1.3.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_cufile_cu12-1.13.1.3.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_cufile_cu12-1.13.1.3.dist-info/License.txt b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_cufile_cu12-1.13.1.3.dist-info/License.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b491c70e0aef319022ded661e111ddbd45b8a17f
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_cufile_cu12-1.13.1.3.dist-info/License.txt
@@ -0,0 +1,1568 @@
+End User License Agreement
+--------------------------
+
+
+Preface
+-------
+
+The Software License Agreement in Chapter 1 and the Supplement
+in Chapter 2 contain license terms and conditions that govern
+the use of NVIDIA software. By accepting this agreement, you
+agree to comply with all the terms and conditions applicable
+to the product(s) included herein.
+
+
+NVIDIA Driver
+
+
+Description
+
+This package contains the operating system driver and
+fundamental system software components for NVIDIA GPUs.
+
+
+NVIDIA CUDA Toolkit
+
+
+Description
+
+The NVIDIA CUDA Toolkit provides command-line and graphical
+tools for building, debugging and optimizing the performance
+of applications accelerated by NVIDIA GPUs, runtime and math
+libraries, and documentation including programming guides,
+user manuals, and API references.
+
+
+Default Install Location of CUDA Toolkit
+
+Windows platform:
+
+%ProgramFiles%\NVIDIA GPU Computing Toolkit\CUDA\v#.#
+
+Linux platform:
+
+/usr/local/cuda-#.#
+
+Mac platform:
+
+/Developer/NVIDIA/CUDA-#.#
+
+
+NVIDIA CUDA Samples
+
+
+Description
+
+This package includes over 100+ CUDA examples that demonstrate
+various CUDA programming principles, and efficient CUDA
+implementation of algorithms in specific application domains.
+
+
+Default Install Location of CUDA Samples
+
+Windows platform:
+
+%ProgramData%\NVIDIA Corporation\CUDA Samples\v#.#
+
+Linux platform:
+
+/usr/local/cuda-#.#/samples
+
+and
+
+$HOME/NVIDIA_CUDA-#.#_Samples
+
+Mac platform:
+
+/Developer/NVIDIA/CUDA-#.#/samples
+
+
+NVIDIA Nsight Visual Studio Edition (Windows only)
+
+
+Description
+
+NVIDIA Nsight Development Platform, Visual Studio Edition is a
+development environment integrated into Microsoft Visual
+Studio that provides tools for debugging, profiling, analyzing
+and optimizing your GPU computing and graphics applications.
+
+
+Default Install Location of Nsight Visual Studio Edition
+
+Windows platform:
+
+%ProgramFiles(x86)%\NVIDIA Corporation\Nsight Visual Studio Edition #.#
+
+
+1. License Agreement for NVIDIA Software Development Kits
+---------------------------------------------------------
+
+
+Release Date: July 26, 2018
+---------------------------
+
+
+Important NoticeRead before downloading, installing,
+copying or using the licensed software:
+-------------------------------------------------------
+
+This license agreement, including exhibits attached
+("Agreement”) is a legal agreement between you and NVIDIA
+Corporation ("NVIDIA") and governs your use of a NVIDIA
+software development kit (“SDK”).
+
+Each SDK has its own set of software and materials, but here
+is a description of the types of items that may be included in
+a SDK: source code, header files, APIs, data sets and assets
+(examples include images, textures, models, scenes, videos,
+native API input/output files), binary software, sample code,
+libraries, utility programs, programming code and
+documentation.
+
+This Agreement can be accepted only by an adult of legal age
+of majority in the country in which the SDK is used.
+
+If you are entering into this Agreement on behalf of a company
+or other legal entity, you represent that you have the legal
+authority to bind the entity to this Agreement, in which case
+“you” will mean the entity you represent.
+
+If you don’t have the required age or authority to accept
+this Agreement, or if you don’t accept all the terms and
+conditions of this Agreement, do not download, install or use
+the SDK.
+
+You agree to use the SDK only for purposes that are permitted
+by (a) this Agreement, and (b) any applicable law, regulation
+or generally accepted practices or guidelines in the relevant
+jurisdictions.
+
+
+1.1. License
+
+
+1.1.1. License Grant
+
+Subject to the terms of this Agreement, NVIDIA hereby grants
+you a non-exclusive, non-transferable license, without the
+right to sublicense (except as expressly provided in this
+Agreement) to:
+
+ 1. Install and use the SDK,
+
+ 2. Modify and create derivative works of sample source code
+ delivered in the SDK, and
+
+ 3. Distribute those portions of the SDK that are identified
+ in this Agreement as distributable, as incorporated in
+ object code format into a software application that meets
+ the distribution requirements indicated in this Agreement.
+
+
+1.1.2. Distribution Requirements
+
+These are the distribution requirements for you to exercise
+the distribution grant:
+
+ 1. Your application must have material additional
+ functionality, beyond the included portions of the SDK.
+
+ 2. The distributable portions of the SDK shall only be
+ accessed by your application.
+
+ 3. The following notice shall be included in modifications
+ and derivative works of sample source code distributed:
+ “This software contains source code provided by NVIDIA
+ Corporation.”
+
+ 4. Unless a developer tool is identified in this Agreement
+ as distributable, it is delivered for your internal use
+ only.
+
+ 5. The terms under which you distribute your application
+ must be consistent with the terms of this Agreement,
+ including (without limitation) terms relating to the
+ license grant and license restrictions and protection of
+ NVIDIA’s intellectual property rights. Additionally, you
+ agree that you will protect the privacy, security and
+ legal rights of your application users.
+
+ 6. You agree to notify NVIDIA in writing of any known or
+ suspected distribution or use of the SDK not in compliance
+ with the requirements of this Agreement, and to enforce
+ the terms of your agreements with respect to distributed
+ SDK.
+
+
+1.1.3. Authorized Users
+
+You may allow employees and contractors of your entity or of
+your subsidiary(ies) to access and use the SDK from your
+secure network to perform work on your behalf.
+
+If you are an academic institution you may allow users
+enrolled or employed by the academic institution to access and
+use the SDK from your secure network.
+
+You are responsible for the compliance with the terms of this
+Agreement by your authorized users. If you become aware that
+your authorized users didn’t follow the terms of this
+Agreement, you agree to take reasonable steps to resolve the
+non-compliance and prevent new occurrences.
+
+
+1.1.4. Pre-Release SDK
+
+The SDK versions identified as alpha, beta, preview or
+otherwise as pre-release, may not be fully functional, may
+contain errors or design flaws, and may have reduced or
+different security, privacy, accessibility, availability, and
+reliability standards relative to commercial versions of
+NVIDIA software and materials. Use of a pre-release SDK may
+result in unexpected results, loss of data, project delays or
+other unpredictable damage or loss.
+
+You may use a pre-release SDK at your own risk, understanding
+that pre-release SDKs are not intended for use in production
+or business-critical systems.
+
+NVIDIA may choose not to make available a commercial version
+of any pre-release SDK. NVIDIA may also choose to abandon
+development and terminate the availability of a pre-release
+SDK at any time without liability.
+
+
+1.1.5. Updates
+
+NVIDIA may, at its option, make available patches, workarounds
+or other updates to this SDK. Unless the updates are provided
+with their separate governing terms, they are deemed part of
+the SDK licensed to you as provided in this Agreement. You
+agree that the form and content of the SDK that NVIDIA
+provides may change without prior notice to you. While NVIDIA
+generally maintains compatibility between versions, NVIDIA may
+in some cases make changes that introduce incompatibilities in
+future versions of the SDK.
+
+
+1.1.6. Third Party Licenses
+
+The SDK may come bundled with, or otherwise include or be
+distributed with, third party software licensed by a NVIDIA
+supplier and/or open source software provided under an open
+source license. Use of third party software is subject to the
+third-party license terms, or in the absence of third party
+terms, the terms of this Agreement. Copyright to third party
+software is held by the copyright holders indicated in the
+third-party software or license.
+
+
+1.1.7. Reservation of Rights
+
+NVIDIA reserves all rights, title, and interest in and to the
+SDK, not expressly granted to you under this Agreement.
+
+
+1.2. Limitations
+
+The following license limitations apply to your use of the
+SDK:
+
+ 1. You may not reverse engineer, decompile or disassemble,
+ or remove copyright or other proprietary notices from any
+ portion of the SDK or copies of the SDK.
+
+ 2. Except as expressly provided in this Agreement, you may
+ not copy, sell, rent, sublicense, transfer, distribute,
+ modify, or create derivative works of any portion of the
+ SDK. For clarity, you may not distribute or sublicense the
+ SDK as a stand-alone product.
+
+ 3. Unless you have an agreement with NVIDIA for this
+ purpose, you may not indicate that an application created
+ with the SDK is sponsored or endorsed by NVIDIA.
+
+ 4. You may not bypass, disable, or circumvent any
+ encryption, security, digital rights management or
+ authentication mechanism in the SDK.
+
+ 5. You may not use the SDK in any manner that would cause it
+ to become subject to an open source software license. As
+ examples, licenses that require as a condition of use,
+ modification, and/or distribution that the SDK be:
+
+ a. Disclosed or distributed in source code form;
+
+ b. Licensed for the purpose of making derivative works;
+ or
+
+ c. Redistributable at no charge.
+
+ 6. Unless you have an agreement with NVIDIA for this
+ purpose, you may not use the SDK with any system or
+ application where the use or failure of the system or
+ application can reasonably be expected to threaten or
+ result in personal injury, death, or catastrophic loss.
+ Examples include use in avionics, navigation, military,
+ medical, life support or other life critical applications.
+ NVIDIA does not design, test or manufacture the SDK for
+ these critical uses and NVIDIA shall not be liable to you
+ or any third party, in whole or in part, for any claims or
+ damages arising from such uses.
+
+ 7. You agree to defend, indemnify and hold harmless NVIDIA
+ and its affiliates, and their respective employees,
+ contractors, agents, officers and directors, from and
+ against any and all claims, damages, obligations, losses,
+ liabilities, costs or debt, fines, restitutions and
+ expenses (including but not limited to attorney’s fees
+ and costs incident to establishing the right of
+ indemnification) arising out of or related to your use of
+ the SDK outside of the scope of this Agreement, or not in
+ compliance with its terms.
+
+
+1.3. Ownership
+
+ 1. NVIDIA or its licensors hold all rights, title and
+ interest in and to the SDK and its modifications and
+ derivative works, including their respective intellectual
+ property rights, subject to your rights described in this
+ section. This SDK may include software and materials from
+ NVIDIA’s licensors, and these licensors are intended
+ third party beneficiaries that may enforce this Agreement
+ with respect to their intellectual property rights.
+
+ 2. You hold all rights, title and interest in and to your
+ applications and your derivative works of the sample
+ source code delivered in the SDK, including their
+ respective intellectual property rights, subject to
+ NVIDIA’s rights described in this section.
+
+ 3. You may, but don’t have to, provide to NVIDIA
+ suggestions, feature requests or other feedback regarding
+ the SDK, including possible enhancements or modifications
+ to the SDK. For any feedback that you voluntarily provide,
+ you hereby grant NVIDIA and its affiliates a perpetual,
+ non-exclusive, worldwide, irrevocable license to use,
+ reproduce, modify, license, sublicense (through multiple
+ tiers of sublicensees), and distribute (through multiple
+ tiers of distributors) it without the payment of any
+ royalties or fees to you. NVIDIA will use feedback at its
+ choice. NVIDIA is constantly looking for ways to improve
+ its products, so you may send feedback to NVIDIA through
+ the developer portal at https://developer.nvidia.com.
+
+
+1.4. No Warranties
+
+THE SDK IS PROVIDED BY NVIDIA “AS IS” AND “WITH ALL
+FAULTS.” TO THE MAXIMUM EXTENT PERMITTED BY LAW, NVIDIA AND
+ITS AFFILIATES EXPRESSLY DISCLAIM ALL WARRANTIES OF ANY KIND
+OR NATURE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING,
+BUT NOT LIMITED TO, ANY WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE, TITLE, NON-INFRINGEMENT, OR THE
+ABSENCE OF ANY DEFECTS THEREIN, WHETHER LATENT OR PATENT. NO
+WARRANTY IS MADE ON THE BASIS OF TRADE USAGE, COURSE OF
+DEALING OR COURSE OF TRADE.
+
+
+1.5. Limitation of Liability
+
+TO THE MAXIMUM EXTENT PERMITTED BY LAW, NVIDIA AND ITS
+AFFILIATES SHALL NOT BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
+PUNITIVE OR CONSEQUENTIAL DAMAGES, OR ANY LOST PROFITS, LOSS
+OF USE, LOSS OF DATA OR LOSS OF GOODWILL, OR THE COSTS OF
+PROCURING SUBSTITUTE PRODUCTS, ARISING OUT OF OR IN CONNECTION
+WITH THIS AGREEMENT OR THE USE OR PERFORMANCE OF THE SDK,
+WHETHER SUCH LIABILITY ARISES FROM ANY CLAIM BASED UPON BREACH
+OF CONTRACT, BREACH OF WARRANTY, TORT (INCLUDING NEGLIGENCE),
+PRODUCT LIABILITY OR ANY OTHER CAUSE OF ACTION OR THEORY OF
+LIABILITY. IN NO EVENT WILL NVIDIA’S AND ITS AFFILIATES
+TOTAL CUMULATIVE LIABILITY UNDER OR ARISING OUT OF THIS
+AGREEMENT EXCEED US$10.00. THE NATURE OF THE LIABILITY OR THE
+NUMBER OF CLAIMS OR SUITS SHALL NOT ENLARGE OR EXTEND THIS
+LIMIT.
+
+These exclusions and limitations of liability shall apply
+regardless if NVIDIA or its affiliates have been advised of
+the possibility of such damages, and regardless of whether a
+remedy fails its essential purpose. These exclusions and
+limitations of liability form an essential basis of the
+bargain between the parties, and, absent any of these
+exclusions or limitations of liability, the provisions of this
+Agreement, including, without limitation, the economic terms,
+would be substantially different.
+
+
+1.6. Termination
+
+ 1. This Agreement will continue to apply until terminated by
+ either you or NVIDIA as described below.
+
+ 2. If you want to terminate this Agreement, you may do so by
+ stopping to use the SDK.
+
+ 3. NVIDIA may, at any time, terminate this Agreement if:
+
+ a. (i) you fail to comply with any term of this
+ Agreement and the non-compliance is not fixed within
+ thirty (30) days following notice from NVIDIA (or
+ immediately if you violate NVIDIA’s intellectual
+ property rights);
+
+ b. (ii) you commence or participate in any legal
+ proceeding against NVIDIA with respect to the SDK; or
+
+ c. (iii) NVIDIA decides to no longer provide the SDK in
+ a country or, in NVIDIA’s sole discretion, the
+ continued use of it is no longer commercially viable.
+
+ 4. Upon any termination of this Agreement, you agree to
+ promptly discontinue use of the SDK and destroy all copies
+ in your possession or control. Your prior distributions in
+ accordance with this Agreement are not affected by the
+ termination of this Agreement. Upon written request, you
+ will certify in writing that you have complied with your
+ commitments under this section. Upon any termination of
+ this Agreement all provisions survive except for the
+ license grant provisions.
+
+
+1.7. General
+
+If you wish to assign this Agreement or your rights and
+obligations, including by merger, consolidation, dissolution
+or operation of law, contact NVIDIA to ask for permission. Any
+attempted assignment not approved by NVIDIA in writing shall
+be void and of no effect. NVIDIA may assign, delegate or
+transfer this Agreement and its rights and obligations, and if
+to a non-affiliate you will be notified.
+
+You agree to cooperate with NVIDIA and provide reasonably
+requested information to verify your compliance with this
+Agreement.
+
+This Agreement will be governed in all respects by the laws of
+the United States and of the State of Delaware as those laws
+are applied to contracts entered into and performed entirely
+within Delaware by Delaware residents, without regard to the
+conflicts of laws principles. The United Nations Convention on
+Contracts for the International Sale of Goods is specifically
+disclaimed. You agree to all terms of this Agreement in the
+English language.
+
+The state or federal courts residing in Santa Clara County,
+California shall have exclusive jurisdiction over any dispute
+or claim arising out of this Agreement. Notwithstanding this,
+you agree that NVIDIA shall still be allowed to apply for
+injunctive remedies or an equivalent type of urgent legal
+relief in any jurisdiction.
+
+If any court of competent jurisdiction determines that any
+provision of this Agreement is illegal, invalid or
+unenforceable, such provision will be construed as limited to
+the extent necessary to be consistent with and fully
+enforceable under the law and the remaining provisions will
+remain in full force and effect. Unless otherwise specified,
+remedies are cumulative.
+
+Each party acknowledges and agrees that the other is an
+independent contractor in the performance of this Agreement.
+
+The SDK has been developed entirely at private expense and is
+“commercial items” consisting of “commercial computer
+software” and “commercial computer software
+documentation” provided with RESTRICTED RIGHTS. Use,
+duplication or disclosure by the U.S. Government or a U.S.
+Government subcontractor is subject to the restrictions in
+this Agreement pursuant to DFARS 227.7202-3(a) or as set forth
+in subparagraphs (c)(1) and (2) of the Commercial Computer
+Software - Restricted Rights clause at FAR 52.227-19, as
+applicable. Contractor/manufacturer is NVIDIA, 2788 San Tomas
+Expressway, Santa Clara, CA 95051.
+
+The SDK is subject to United States export laws and
+regulations. You agree that you will not ship, transfer or
+export the SDK into any country, or use the SDK in any manner,
+prohibited by the United States Bureau of Industry and
+Security or economic sanctions regulations administered by the
+U.S. Department of Treasury’s Office of Foreign Assets
+Control (OFAC), or any applicable export laws, restrictions or
+regulations. These laws include restrictions on destinations,
+end users and end use. By accepting this Agreement, you
+confirm that you are not a resident or citizen of any country
+currently embargoed by the U.S. and that you are not otherwise
+prohibited from receiving the SDK.
+
+Any notice delivered by NVIDIA to you under this Agreement
+will be delivered via mail, email or fax. You agree that any
+notices that NVIDIA sends you electronically will satisfy any
+legal communication requirements. Please direct your legal
+notices or other correspondence to NVIDIA Corporation, 2788
+San Tomas Expressway, Santa Clara, California 95051, United
+States of America, Attention: Legal Department.
+
+This Agreement and any exhibits incorporated into this
+Agreement constitute the entire agreement of the parties with
+respect to the subject matter of this Agreement and supersede
+all prior negotiations or documentation exchanged between the
+parties relating to this SDK license. Any additional and/or
+conflicting terms on documents issued by you are null, void,
+and invalid. Any amendment or waiver under this Agreement
+shall be in writing and signed by representatives of both
+parties.
+
+
+2. CUDA Toolkit Supplement to Software License Agreement for
+NVIDIA Software Development Kits
+------------------------------------------------------------
+
+
+Release date: August 16, 2018
+-----------------------------
+
+The terms in this supplement govern your use of the NVIDIA
+CUDA Toolkit SDK under the terms of your license agreement
+(“Agreement”) as modified by this supplement. Capitalized
+terms used but not defined below have the meaning assigned to
+them in the Agreement.
+
+This supplement is an exhibit to the Agreement and is
+incorporated as an integral part of the Agreement. In the
+event of conflict between the terms in this supplement and the
+terms in the Agreement, the terms in this supplement govern.
+
+
+2.1. License Scope
+
+The SDK is licensed for you to develop applications only for
+use in systems with NVIDIA GPUs.
+
+
+2.2. Distribution
+
+The portions of the SDK that are distributable under the
+Agreement are listed in Attachment A.
+
+
+2.3. Operating Systems
+
+Those portions of the SDK designed exclusively for use on the
+Linux or FreeBSD operating systems, or other operating systems
+derived from the source code to these operating systems, may
+be copied and redistributed for use in accordance with this
+Agreement, provided that the object code files are not
+modified in any way (except for unzipping of compressed
+files).
+
+
+2.4. Audio and Video Encoders and Decoders
+
+You acknowledge and agree that it is your sole responsibility
+to obtain any additional third-party licenses required to
+make, have made, use, have used, sell, import, and offer for
+sale your products or services that include or incorporate any
+third-party software and content relating to audio and/or
+video encoders and decoders from, including but not limited
+to, Microsoft, Thomson, Fraunhofer IIS, Sisvel S.p.A.,
+MPEG-LA, and Coding Technologies. NVIDIA does not grant to you
+under this Agreement any necessary patent or other rights with
+respect to any audio and/or video encoders and decoders.
+
+
+2.5. Licensing
+
+If the distribution terms in this Agreement are not suitable
+for your organization, or for any questions regarding this
+Agreement, please contact NVIDIA at
+nvidia-compute-license-questions@nvidia.com.
+
+
+2.6. Attachment A
+
+The following portions of the SDK are distributable under the
+Agreement:
+
+Component
+
+CUDA Runtime
+
+Windows
+
+cudart.dll, cudart_static.lib, cudadevrt.lib
+
+Mac OSX
+
+libcudart.dylib, libcudart_static.a, libcudadevrt.a
+
+Linux
+
+libcudart.so, libcudart_static.a, libcudadevrt.a
+
+Android
+
+libcudart.so, libcudart_static.a, libcudadevrt.a
+
+Component
+
+CUDA FFT Library
+
+Windows
+
+cufft.dll, cufftw.dll, cufft.lib, cufftw.lib
+
+Mac OSX
+
+libcufft.dylib, libcufft_static.a, libcufftw.dylib,
+libcufftw_static.a
+
+Linux
+
+libcufft.so, libcufft_static.a, libcufftw.so,
+libcufftw_static.a
+
+Android
+
+libcufft.so, libcufft_static.a, libcufftw.so,
+libcufftw_static.a
+
+Component
+
+CUDA BLAS Library
+
+Windows
+
+cublas.dll, cublasLt.dll
+
+Mac OSX
+
+libcublas.dylib, libcublasLt.dylib, libcublas_static.a,
+libcublasLt_static.a
+
+Linux
+
+libcublas.so, libcublasLt.so, libcublas_static.a,
+libcublasLt_static.a
+
+Android
+
+libcublas.so, libcublasLt.so, libcublas_static.a,
+libcublasLt_static.a
+
+Component
+
+NVIDIA "Drop-in" BLAS Library
+
+Windows
+
+nvblas.dll
+
+Mac OSX
+
+libnvblas.dylib
+
+Linux
+
+libnvblas.so
+
+Component
+
+CUDA Sparse Matrix Library
+
+Windows
+
+cusparse.dll, cusparse.lib
+
+Mac OSX
+
+libcusparse.dylib, libcusparse_static.a
+
+Linux
+
+libcusparse.so, libcusparse_static.a
+
+Android
+
+libcusparse.so, libcusparse_static.a
+
+Component
+
+CUDA Linear Solver Library
+
+Windows
+
+cusolver.dll, cusolver.lib
+
+Mac OSX
+
+libcusolver.dylib, libcusolver_static.a
+
+Linux
+
+libcusolver.so, libcusolver_static.a
+
+Android
+
+libcusolver.so, libcusolver_static.a
+
+Component
+
+CUDA Random Number Generation Library
+
+Windows
+
+curand.dll, curand.lib
+
+Mac OSX
+
+libcurand.dylib, libcurand_static.a
+
+Linux
+
+libcurand.so, libcurand_static.a
+
+Android
+
+libcurand.so, libcurand_static.a
+
+Component
+
+CUDA Accelerated Graph Library
+
+Component
+
+NVIDIA Performance Primitives Library
+
+Windows
+
+nppc.dll, nppc.lib, nppial.dll, nppial.lib, nppicc.dll,
+nppicc.lib, nppicom.dll, nppicom.lib, nppidei.dll,
+nppidei.lib, nppif.dll, nppif.lib, nppig.dll, nppig.lib,
+nppim.dll, nppim.lib, nppist.dll, nppist.lib, nppisu.dll,
+nppisu.lib, nppitc.dll, nppitc.lib, npps.dll, npps.lib
+
+Mac OSX
+
+libnppc.dylib, libnppc_static.a, libnppial.dylib,
+libnppial_static.a, libnppicc.dylib, libnppicc_static.a,
+libnppicom.dylib, libnppicom_static.a, libnppidei.dylib,
+libnppidei_static.a, libnppif.dylib, libnppif_static.a,
+libnppig.dylib, libnppig_static.a, libnppim.dylib,
+libnppisu_static.a, libnppitc.dylib, libnppitc_static.a,
+libnpps.dylib, libnpps_static.a
+
+Linux
+
+libnppc.so, libnppc_static.a, libnppial.so,
+libnppial_static.a, libnppicc.so, libnppicc_static.a,
+libnppicom.so, libnppicom_static.a, libnppidei.so,
+libnppidei_static.a, libnppif.so, libnppif_static.a
+libnppig.so, libnppig_static.a, libnppim.so,
+libnppim_static.a, libnppist.so, libnppist_static.a,
+libnppisu.so, libnppisu_static.a, libnppitc.so
+libnppitc_static.a, libnpps.so, libnpps_static.a
+
+Android
+
+libnppc.so, libnppc_static.a, libnppial.so,
+libnppial_static.a, libnppicc.so, libnppicc_static.a,
+libnppicom.so, libnppicom_static.a, libnppidei.so,
+libnppidei_static.a, libnppif.so, libnppif_static.a
+libnppig.so, libnppig_static.a, libnppim.so,
+libnppim_static.a, libnppist.so, libnppist_static.a,
+libnppisu.so, libnppisu_static.a, libnppitc.so
+libnppitc_static.a, libnpps.so, libnpps_static.a
+
+Component
+
+NVIDIA JPEG Library
+
+Linux
+
+libnvjpeg.so, libnvjpeg_static.a
+
+Component
+
+Internal common library required for statically linking to
+cuBLAS, cuSPARSE, cuFFT, cuRAND, nvJPEG and NPP
+
+Mac OSX
+
+libculibos.a
+
+Linux
+
+libculibos.a
+
+Component
+
+NVIDIA Runtime Compilation Library and Header
+
+All
+
+nvrtc.h
+
+Windows
+
+nvrtc.dll, nvrtc-builtins.dll
+
+Mac OSX
+
+libnvrtc.dylib, libnvrtc-builtins.dylib
+
+Linux
+
+libnvrtc.so, libnvrtc-builtins.so
+
+Component
+
+NVIDIA Optimizing Compiler Library
+
+Windows
+
+nvvm.dll
+
+Mac OSX
+
+libnvvm.dylib
+
+Linux
+
+libnvvm.so
+
+Component
+
+NVIDIA Common Device Math Functions Library
+
+Windows
+
+libdevice.10.bc
+
+Mac OSX
+
+libdevice.10.bc
+
+Linux
+
+libdevice.10.bc
+
+Component
+
+CUDA Occupancy Calculation Header Library
+
+All
+
+cuda_occupancy.h
+
+Component
+
+CUDA Half Precision Headers
+
+All
+
+cuda_fp16.h, cuda_fp16.hpp
+
+Component
+
+CUDA Profiling Tools Interface (CUPTI) Library
+
+Windows
+
+cupti.dll
+
+Mac OSX
+
+libcupti.dylib
+
+Linux
+
+libcupti.so
+
+Component
+
+NVIDIA Tools Extension Library
+
+Windows
+
+nvToolsExt.dll, nvToolsExt.lib
+
+Mac OSX
+
+libnvToolsExt.dylib
+
+Linux
+
+libnvToolsExt.so
+
+Component
+
+NVIDIA CUDA Driver Libraries
+
+Linux
+
+libcuda.so, libnvidia-fatbinaryloader.so,
+libnvidia-ptxjitcompiler.so
+
+The NVIDIA CUDA Driver Libraries are only distributable in
+applications that meet this criteria:
+
+ 1. The application was developed starting from a NVIDIA CUDA
+ container obtained from Docker Hub or the NVIDIA GPU
+ Cloud, and
+
+ 2. The resulting application is packaged as a Docker
+ container and distributed to users on Docker Hub or the
+ NVIDIA GPU Cloud only.
+
+
+2.7. Attachment B
+
+
+Additional Licensing Obligations
+
+The following third party components included in the SOFTWARE
+are licensed to Licensee pursuant to the following terms and
+conditions:
+
+ 1. Licensee's use of the GDB third party component is
+ subject to the terms and conditions of GNU GPL v3:
+
+ This product includes copyrighted third-party software licensed
+ under the terms of the GNU General Public License v3 ("GPL v3").
+ All third-party software packages are copyright by their respective
+ authors. GPL v3 terms and conditions are hereby incorporated into
+ the Agreement by this reference: http://www.gnu.org/licenses/gpl.txt
+
+ Consistent with these licensing requirements, the software
+ listed below is provided under the terms of the specified
+ open source software licenses. To obtain source code for
+ software provided under licenses that require
+ redistribution of source code, including the GNU General
+ Public License (GPL) and GNU Lesser General Public License
+ (LGPL), contact oss-requests@nvidia.com. This offer is
+ valid for a period of three (3) years from the date of the
+ distribution of this product by NVIDIA CORPORATION.
+
+ Component License
+ CUDA-GDB GPL v3
+
+ 2. Licensee represents and warrants that any and all third
+ party licensing and/or royalty payment obligations in
+ connection with Licensee's use of the H.264 video codecs
+ are solely the responsibility of Licensee.
+
+ 3. Licensee's use of the Thrust library is subject to the
+ terms and conditions of the Apache License Version 2.0.
+ All third-party software packages are copyright by their
+ respective authors. Apache License Version 2.0 terms and
+ conditions are hereby incorporated into the Agreement by
+ this reference.
+ http://www.apache.org/licenses/LICENSE-2.0.html
+
+ In addition, Licensee acknowledges the following notice:
+ Thrust includes source code from the Boost Iterator,
+ Tuple, System, and Random Number libraries.
+
+ Boost Software License - Version 1.0 - August 17th, 2003
+ . . . .
+
+ Permission is hereby granted, free of charge, to any person or
+ organization obtaining a copy of the software and accompanying
+ documentation covered by this license (the "Software") to use,
+ reproduce, display, distribute, execute, and transmit the Software,
+ and to prepare derivative works of the Software, and to permit
+ third-parties to whom the Software is furnished to do so, all
+ subject to the following:
+
+ The copyright notices in the Software and this entire statement,
+ including the above license grant, this restriction and the following
+ disclaimer, must be included in all copies of the Software, in whole
+ or in part, and all derivative works of the Software, unless such
+ copies or derivative works are solely in the form of machine-executable
+ object code generated by a source language processor.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND
+ NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
+ ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES OR
+ OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ OTHER DEALINGS IN THE SOFTWARE.
+
+ 4. Licensee's use of the LLVM third party component is
+ subject to the following terms and conditions:
+
+ ======================================================
+ LLVM Release License
+ ======================================================
+ University of Illinois/NCSA
+ Open Source License
+
+ Copyright (c) 2003-2010 University of Illinois at Urbana-Champaign.
+ All rights reserved.
+
+ Developed by:
+
+ LLVM Team
+
+ University of Illinois at Urbana-Champaign
+
+ http://llvm.org
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to
+ deal with the Software without restriction, including without limitation the
+ rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ sell copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ * Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimers.
+
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimers in the
+ documentation and/or other materials provided with the distribution.
+
+ * Neither the names of the LLVM Team, University of Illinois at Urbana-
+ Champaign, nor the names of its contributors may be used to endorse or
+ promote products derived from this Software without specific prior
+ written permission.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ THE CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ DEALINGS WITH THE SOFTWARE.
+
+ 5. Licensee's use (e.g. nvprof) of the PCRE third party
+ component is subject to the following terms and
+ conditions:
+
+ ------------
+ PCRE LICENCE
+ ------------
+ PCRE is a library of functions to support regular expressions whose syntax
+ and semantics are as close as possible to those of the Perl 5 language.
+ Release 8 of PCRE is distributed under the terms of the "BSD" licence, as
+ specified below. The documentation for PCRE, supplied in the "doc"
+ directory, is distributed under the same terms as the software itself. The
+ basic library functions are written in C and are freestanding. Also
+ included in the distribution is a set of C++ wrapper functions, and a just-
+ in-time compiler that can be used to optimize pattern matching. These are
+ both optional features that can be omitted when the library is built.
+
+ THE BASIC LIBRARY FUNCTIONS
+ ---------------------------
+ Written by: Philip Hazel
+ Email local part: ph10
+ Email domain: cam.ac.uk
+ University of Cambridge Computing Service,
+ Cambridge, England.
+ Copyright (c) 1997-2012 University of Cambridge
+ All rights reserved.
+
+ PCRE JUST-IN-TIME COMPILATION SUPPORT
+ -------------------------------------
+ Written by: Zoltan Herczeg
+ Email local part: hzmester
+ Emain domain: freemail.hu
+ Copyright(c) 2010-2012 Zoltan Herczeg
+ All rights reserved.
+
+ STACK-LESS JUST-IN-TIME COMPILER
+ --------------------------------
+ Written by: Zoltan Herczeg
+ Email local part: hzmester
+ Emain domain: freemail.hu
+ Copyright(c) 2009-2012 Zoltan Herczeg
+ All rights reserved.
+
+ THE C++ WRAPPER FUNCTIONS
+ -------------------------
+ Contributed by: Google Inc.
+ Copyright (c) 2007-2012, Google Inc.
+ All rights reserved.
+
+ THE "BSD" LICENCE
+ -----------------
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ * Neither the name of the University of Cambridge nor the name of Google
+ Inc. nor the names of their contributors may be used to endorse or
+ promote products derived from this software without specific prior
+ written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.
+
+ 6. Some of the cuBLAS library routines were written by or
+ derived from code written by Vasily Volkov and are subject
+ to the Modified Berkeley Software Distribution License as
+ follows:
+
+ Copyright (c) 2007-2009, Regents of the University of California
+
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are
+ met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the following
+ disclaimer in the documentation and/or other materials provided
+ with the distribution.
+ * Neither the name of the University of California, Berkeley nor
+ the names of its contributors may be used to endorse or promote
+ products derived from this software without specific prior
+ written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR
+ IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.
+
+ 7. Some of the cuBLAS library routines were written by or
+ derived from code written by Davide Barbieri and are
+ subject to the Modified Berkeley Software Distribution
+ License as follows:
+
+ Copyright (c) 2008-2009 Davide Barbieri @ University of Rome Tor Vergata.
+
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are
+ met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the following
+ disclaimer in the documentation and/or other materials provided
+ with the distribution.
+ * The name of the author may not be used to endorse or promote
+ products derived from this software without specific prior
+ written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR
+ IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.
+
+ 8. Some of the cuBLAS library routines were derived from
+ code developed by the University of Tennessee and are
+ subject to the Modified Berkeley Software Distribution
+ License as follows:
+
+ Copyright (c) 2010 The University of Tennessee.
+
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are
+ met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the following
+ disclaimer listed in this license in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the name of the copyright holders nor the names of its
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ 9. Some of the cuBLAS library routines were written by or
+ derived from code written by Jonathan Hogg and are subject
+ to the Modified Berkeley Software Distribution License as
+ follows:
+
+ Copyright (c) 2012, The Science and Technology Facilities Council (STFC).
+
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are
+ met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the following
+ disclaimer in the documentation and/or other materials provided
+ with the distribution.
+ * Neither the name of the STFC nor the names of its contributors
+ may be used to endorse or promote products derived from this
+ software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE STFC BE
+ LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ 10. Some of the cuBLAS library routines were written by or
+ derived from code written by Ahmad M. Abdelfattah, David
+ Keyes, and Hatem Ltaief, and are subject to the Apache
+ License, Version 2.0, as follows:
+
+ -- (C) Copyright 2013 King Abdullah University of Science and Technology
+ Authors:
+ Ahmad Abdelfattah (ahmad.ahmad@kaust.edu.sa)
+ David Keyes (david.keyes@kaust.edu.sa)
+ Hatem Ltaief (hatem.ltaief@kaust.edu.sa)
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions
+ are met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+ * Neither the name of the King Abdullah University of Science and
+ Technology nor the names of its contributors may be used to endorse
+ or promote products derived from this software without specific prior
+ written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
+
+ 11. Some of the cuSPARSE library routines were written by or
+ derived from code written by Li-Wen Chang and are subject
+ to the NCSA Open Source License as follows:
+
+ Copyright (c) 2012, University of Illinois.
+
+ All rights reserved.
+
+ Developed by: IMPACT Group, University of Illinois, http://impact.crhc.illinois.edu
+
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of this software and associated documentation files (the
+ "Software"), to deal with the Software without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to
+ permit persons to whom the Software is furnished to do so, subject to
+ the following conditions:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the following
+ disclaimers in the documentation and/or other materials provided
+ with the distribution.
+ * Neither the names of IMPACT Group, University of Illinois, nor
+ the names of its contributors may be used to endorse or promote
+ products derived from this Software without specific prior
+ written permission.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE CONTRIBUTORS OR COPYRIGHT
+ HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+ IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
+ SOFTWARE.
+
+ 12. Some of the cuRAND library routines were written by or
+ derived from code written by Mutsuo Saito and Makoto
+ Matsumoto and are subject to the following license:
+
+ Copyright (c) 2009, 2010 Mutsuo Saito, Makoto Matsumoto and Hiroshima
+ University. All rights reserved.
+
+ Copyright (c) 2011 Mutsuo Saito, Makoto Matsumoto, Hiroshima
+ University and University of Tokyo. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are
+ met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the following
+ disclaimer in the documentation and/or other materials provided
+ with the distribution.
+ * Neither the name of the Hiroshima University nor the names of
+ its contributors may be used to endorse or promote products
+ derived from this software without specific prior written
+ permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ 13. Some of the cuRAND library routines were derived from
+ code developed by D. E. Shaw Research and are subject to
+ the following license:
+
+ Copyright 2010-2011, D. E. Shaw Research.
+
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are
+ met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions, and the following disclaimer.
+ * Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions, and the following
+ disclaimer in the documentation and/or other materials provided
+ with the distribution.
+ * Neither the name of D. E. Shaw Research nor the names of its
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ 14. Some of the Math library routines were written by or
+ derived from code developed by Norbert Juffa and are
+ subject to the following license:
+
+ Copyright (c) 2015-2017, Norbert Juffa
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions
+ are met:
+
+ 1. Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ 15. Licensee's use of the lz4 third party component is
+ subject to the following terms and conditions:
+
+ Copyright (C) 2011-2013, Yann Collet.
+ BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are
+ met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the following disclaimer
+ in the documentation and/or other materials provided with the
+ distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ 16. The NPP library uses code from the Boost Math Toolkit,
+ and is subject to the following license:
+
+ Boost Software License - Version 1.0 - August 17th, 2003
+ . . . .
+
+ Permission is hereby granted, free of charge, to any person or
+ organization obtaining a copy of the software and accompanying
+ documentation covered by this license (the "Software") to use,
+ reproduce, display, distribute, execute, and transmit the Software,
+ and to prepare derivative works of the Software, and to permit
+ third-parties to whom the Software is furnished to do so, all
+ subject to the following:
+
+ The copyright notices in the Software and this entire statement,
+ including the above license grant, this restriction and the following
+ disclaimer, must be included in all copies of the Software, in whole
+ or in part, and all derivative works of the Software, unless such
+ copies or derivative works are solely in the form of machine-executable
+ object code generated by a source language processor.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND
+ NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
+ ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES OR
+ OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ OTHER DEALINGS IN THE SOFTWARE.
+
+ 17. Portions of the Nsight Eclipse Edition is subject to the
+ following license:
+
+ The Eclipse Foundation makes available all content in this plug-in
+ ("Content"). Unless otherwise indicated below, the Content is provided
+ to you under the terms and conditions of the Eclipse Public License
+ Version 1.0 ("EPL"). A copy of the EPL is available at http://
+ www.eclipse.org/legal/epl-v10.html. For purposes of the EPL, "Program"
+ will mean the Content.
+
+ If you did not receive this Content directly from the Eclipse
+ Foundation, the Content is being redistributed by another party
+ ("Redistributor") and different terms and conditions may apply to your
+ use of any object code in the Content. Check the Redistributor's
+ license that was provided with the Content. If no such license exists,
+ contact the Redistributor. Unless otherwise indicated below, the terms
+ and conditions of the EPL still apply to any source code in the
+ Content and such source code may be obtained at http://www.eclipse.org.
+
+ 18. Some of the cuBLAS library routines uses code from
+ OpenAI, which is subject to the following license:
+
+ License URL
+ https://github.com/openai/openai-gemm/blob/master/LICENSE
+
+ License Text
+ The MIT License
+
+ Copyright (c) 2016 OpenAI (http://openai.com), 2016 Google Inc.
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+
+ 19. Licensee's use of the Visual Studio Setup Configuration
+ Samples is subject to the following license:
+
+ The MIT License (MIT)
+ Copyright (C) Microsoft Corporation. All rights reserved.
+
+ Permission is hereby granted, free of charge, to any person
+ obtaining a copy of this software and associated documentation
+ files (the "Software"), to deal in the Software without restriction,
+ including without limitation the rights to use, copy, modify, merge,
+ publish, distribute, sublicense, and/or sell copies of the Software,
+ and to permit persons to whom the Software is furnished to do so,
+ subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included
+ in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+ 20. Licensee's use of linmath.h header for CPU functions for
+ GL vector/matrix operations from lunarG is subject to the
+ Apache License Version 2.0.
+
+ 21. The DX12-CUDA sample uses the d3dx12.h header, which is
+ subject to the MIT license .
+
+-----------------
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_cufile_cu12-1.13.1.3.dist-info/METADATA b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_cufile_cu12-1.13.1.3.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..4d22d2b0a860e67abb882c6ec18c0a5dc468a39f
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_cufile_cu12-1.13.1.3.dist-info/METADATA
@@ -0,0 +1,44 @@
+Metadata-Version: 2.2
+Name: nvidia-cufile-cu12
+Version: 1.13.1.3
+Summary: cuFile GPUDirect libraries
+Home-page: https://developer.nvidia.com/cuda-zone
+Author: Nvidia CUDA Installer Team
+Author-email: compute_installer@nvidia.com
+License: NVIDIA Proprietary Software
+Keywords: cuda,nvidia,runtime,machine learning,deep learning
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: Other/Proprietary License
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3
+License-File: License.txt
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: requires-python
+Dynamic: summary
+
+cuFile GPUDirect libraries
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_cufile_cu12-1.13.1.3.dist-info/RECORD b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_cufile_cu12-1.13.1.3.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..63bb2ad6d6d62ccb334a291f589f501c0620f8f3
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_cufile_cu12-1.13.1.3.dist-info/RECORD
@@ -0,0 +1,17 @@
+nvidia/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nvidia/__pycache__/__init__.cpython-312.pyc,,
+nvidia/cufile/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nvidia/cufile/__pycache__/__init__.cpython-312.pyc,,
+nvidia/cufile/include/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nvidia/cufile/include/__pycache__/__init__.cpython-312.pyc,,
+nvidia/cufile/include/cufile.h,sha256=5bNDkZZNOF_qHbDBkN04OfwF09BEcrAxxPW61HJSzX0,29530
+nvidia/cufile/lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nvidia/cufile/lib/__pycache__/__init__.cpython-312.pyc,,
+nvidia/cufile/lib/libcufile.so.0,sha256=ovSFQXf2ZsGoxxm0huTLERnr_dhY66pjSctjxVSdJ-g,3209496
+nvidia/cufile/lib/libcufile_rdma.so.1,sha256=mpEoGEkKqSa07RW1ACaa4GTXKHgDFBjOYLjIu773fM8,46528
+nvidia_cufile_cu12-1.13.1.3.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+nvidia_cufile_cu12-1.13.1.3.dist-info/License.txt,sha256=rW9YU_ugyg0VnQ9Y1JrkmDDC-Mk_epJki5zpCttMbM0,59262
+nvidia_cufile_cu12-1.13.1.3.dist-info/METADATA,sha256=33E6JjiagFLRf-48FSFWPgYLJKA3mDs4if_1T5Bu8og,1673
+nvidia_cufile_cu12-1.13.1.3.dist-info/RECORD,,
+nvidia_cufile_cu12-1.13.1.3.dist-info/WHEEL,sha256=ygM8qpYgOvrn5C-8vbfzPi-0iFPECh71lLWqkqrTjYw,144
+nvidia_cufile_cu12-1.13.1.3.dist-info/top_level.txt,sha256=fTkAtiFuL16nUrB9ytDDtpytz2t0B4NvYTnRzwAhO14,7
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_cufile_cu12-1.13.1.3.dist-info/WHEEL b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_cufile_cu12-1.13.1.3.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..287a9d7e1a3d4435e9542cc8216b8c5eaf2c0ed2
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_cufile_cu12-1.13.1.3.dist-info/WHEEL
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.8.0)
+Root-Is-Purelib: true
+Tag: py3-none-manylinux2014_x86_64
+Tag: py3-none-manylinux_2_17_x86_64
+
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_cufile_cu12-1.13.1.3.dist-info/top_level.txt b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_cufile_cu12-1.13.1.3.dist-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..862f7abf232cdfbb928609856247292e81c9decb
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_cufile_cu12-1.13.1.3.dist-info/top_level.txt
@@ -0,0 +1 @@
+nvidia
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_nvtx_cu12-12.8.90.dist-info/INSTALLER b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_nvtx_cu12-12.8.90.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_nvtx_cu12-12.8.90.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_nvtx_cu12-12.8.90.dist-info/License.txt b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_nvtx_cu12-12.8.90.dist-info/License.txt
new file mode 100644
index 0000000000000000000000000000000000000000..bd8b243dfa02d4e7080150180520f742d2861d15
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_nvtx_cu12-12.8.90.dist-info/License.txt
@@ -0,0 +1,218 @@
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+
+--- LLVM Exceptions to the Apache 2.0 License ----
+
+As an exception, if, as a result of your compiling your source code, portions
+of this Software are embedded into an Object form of such source code, you
+may redistribute such embedded portions in such Object form without complying
+with the conditions of Sections 4(a), 4(b) and 4(d) of the License.
+
+In addition, if you combine or link compiled forms of this Software with
+software that is licensed under the GPLv2 ("Combined Software") and if a
+court of competent jurisdiction determines that the patent provision (Section
+3), the indemnity provision (Section 9) or other Section of the License
+conflicts with the conditions of the GPLv2, you may retroactively and
+prospectively choose to deem waived or otherwise exclude such Section(s) of
+the License, but only in their entirety and only with respect to the Combined
+Software.
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_nvtx_cu12-12.8.90.dist-info/METADATA b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_nvtx_cu12-12.8.90.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..b31bb610bfc7d774be17ed73f760af6e477d819b
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_nvtx_cu12-12.8.90.dist-info/METADATA
@@ -0,0 +1,44 @@
+Metadata-Version: 2.2
+Name: nvidia-nvtx-cu12
+Version: 12.8.90
+Summary: NVIDIA Tools Extension
+Home-page: https://developer.nvidia.com/cuda-zone
+Author: Nvidia CUDA Installer Team
+Author-email: compute_installer@nvidia.com
+License: Apache 2.0
+Keywords: cuda,nvidia,runtime,machine learning,deep learning
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: Other/Proprietary License
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3
+License-File: License.txt
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: requires-python
+Dynamic: summary
+
+A C-based API for annotating events, code ranges, and resources in your applications. Applications which integrate NVTX can use the Visual Profiler to capture and visualize these events and ranges.
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_nvtx_cu12-12.8.90.dist-info/RECORD b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_nvtx_cu12-12.8.90.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..7690ec4cf59a080c3c551218a85efefd10f174b7
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_nvtx_cu12-12.8.90.dist-info/RECORD
@@ -0,0 +1,36 @@
+nvidia/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nvidia/__pycache__/__init__.cpython-312.pyc,,
+nvidia/nvtx/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nvidia/nvtx/__pycache__/__init__.cpython-312.pyc,,
+nvidia/nvtx/include/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nvidia/nvtx/include/__pycache__/__init__.cpython-312.pyc,,
+nvidia/nvtx/include/nvToolsExt.h,sha256=TFV6WIqHrKh2wbll0lk3SsSL3KMoDav5cnwgEGuCbXI,55254
+nvidia/nvtx/include/nvToolsExtCuda.h,sha256=UDA1pbmvoRFmlJ11Et9tIMEztOtOVw-10mO27Q6K8jg,6009
+nvidia/nvtx/include/nvToolsExtCudaRt.h,sha256=6IbgdRGObly53jzRqvsZ4FQoTrXJOJwSyCOLuXr9ncA,5192
+nvidia/nvtx/include/nvToolsExtOpenCL.h,sha256=gETZH9ch_o6MYE_BYQ2pj9SSuxyAo1H4ptmRK-DMWSo,8360
+nvidia/nvtx/include/nvToolsExtSync.h,sha256=wqONIiycUPaUUCzQBmCippilgKt8sOL9tpzG773u0nY,14562
+nvidia/nvtx/include/nvtx3/nvToolsExt.h,sha256=TFEF3fx1043EwMdbS7FqvvavwK0koZeGrIOAsCrB12s,52247
+nvidia/nvtx/include/nvtx3/nvToolsExtCuda.h,sha256=4ZbZHUMcmHRf4SdKB7nH0E3uHd_9ZhZBuwuWPItK-Vs,6204
+nvidia/nvtx/include/nvtx3/nvToolsExtCudaRt.h,sha256=boW0zdYobNFFE9wwxCyzBGBLcSGtdbQ5osKjQGNC2E8,5393
+nvidia/nvtx/include/nvtx3/nvToolsExtOpenCL.h,sha256=RPfsZl3lHAPIOCzTipmz07-vaiIO4cxelcx12EjB2L0,8563
+nvidia/nvtx/include/nvtx3/nvToolsExtSync.h,sha256=C-HIVBaupxYom3BqMggQ_ePq1bxFhw8kXsOfYJKBWrI,14756
+nvidia/nvtx/include/nvtx3/nvtxDetail/nvtxImpl.h,sha256=jEnYF3MyLsD72euw2It3Bz0X0GK4Xv_htEd8BeIrPjY,23333
+nvidia/nvtx/include/nvtx3/nvtxDetail/nvtxImplCore.h,sha256=sYpWqZfYrjsMddxtezPX3qSTIbAOn4dlEoLiYQ9M2nM,9756
+nvidia/nvtx/include/nvtx3/nvtxDetail/nvtxImplCudaRt_v3.h,sha256=SoaiprvsI80yLmEAnlFX0iFufv6RtKjjMMrVwQZjjQI,4775
+nvidia/nvtx/include/nvtx3/nvtxDetail/nvtxImplCuda_v3.h,sha256=IEor-ISqComCRGVDdIzKBLU3eWCuDI0Igqz-eRKKcvg,5550
+nvidia/nvtx/include/nvtx3/nvtxDetail/nvtxImplOpenCL_v3.h,sha256=iPR2x74bJE3plFQBT9FWGBaTm4sC-Pll6WAjpKRnz7g,8275
+nvidia/nvtx/include/nvtx3/nvtxDetail/nvtxImplSync_v3.h,sha256=TqwQfEUVbwc58bpHioE13NMweFhOuHXNql65BnLzhvc,5022
+nvidia/nvtx/include/nvtx3/nvtxDetail/nvtxInit.h,sha256=foajOFacvLGx3BN5ntw5v8o4J3OY4hqkVZE5ZC0x3e4,14716
+nvidia/nvtx/include/nvtx3/nvtxDetail/nvtxInitDecls.h,sha256=-Qyxcy9CDXOBhEtYZ8L7iYd6daJ9aCeyQM48X0BafMM,9361
+nvidia/nvtx/include/nvtx3/nvtxDetail/nvtxInitDefs.h,sha256=dLhOV4knhNrmT2DnUNzXreOt_Qc6GAa3yIlmqJFCeVI,35432
+nvidia/nvtx/include/nvtx3/nvtxDetail/nvtxLinkOnce.h,sha256=Jp-z6LTz_p8fKRulcFfdcskIxzcZ6ybbHkGB9mpJa2M,3863
+nvidia/nvtx/include/nvtx3/nvtxDetail/nvtxTypes.h,sha256=jkbCwyvIP1G-Ef8SwYp4kDi69hjZbzaxKSk7ScgrNI8,17352
+nvidia/nvtx/lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nvidia/nvtx/lib/__pycache__/__init__.cpython-312.pyc,,
+nvidia/nvtx/lib/libnvToolsExt.so.1,sha256=xJj8urAgKIbCegrerESr8jOt4D0waA_6LSq-k6uI2RM,36024
+nvidia_nvtx_cu12-12.8.90.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+nvidia_nvtx_cu12-12.8.90.dist-info/License.txt,sha256=nkXoVr7czun2clQILKEYUdlU3i_tdEjEvtGa2aq5mpE,12262
+nvidia_nvtx_cu12-12.8.90.dist-info/METADATA,sha256=xjwj4E6M8EFDch_3GMuoeirlYwpQRRt3-DV6DSYTPPE,1820
+nvidia_nvtx_cu12-12.8.90.dist-info/RECORD,,
+nvidia_nvtx_cu12-12.8.90.dist-info/WHEEL,sha256=ygM8qpYgOvrn5C-8vbfzPi-0iFPECh71lLWqkqrTjYw,144
+nvidia_nvtx_cu12-12.8.90.dist-info/top_level.txt,sha256=fTkAtiFuL16nUrB9ytDDtpytz2t0B4NvYTnRzwAhO14,7
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_nvtx_cu12-12.8.90.dist-info/WHEEL b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_nvtx_cu12-12.8.90.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..287a9d7e1a3d4435e9542cc8216b8c5eaf2c0ed2
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_nvtx_cu12-12.8.90.dist-info/WHEEL
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.8.0)
+Root-Is-Purelib: true
+Tag: py3-none-manylinux2014_x86_64
+Tag: py3-none-manylinux_2_17_x86_64
+
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_nvtx_cu12-12.8.90.dist-info/top_level.txt b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_nvtx_cu12-12.8.90.dist-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..862f7abf232cdfbb928609856247292e81c9decb
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/nvidia_nvtx_cu12-12.8.90.dist-info/top_level.txt
@@ -0,0 +1 @@
+nvidia
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas-2.2.3.dist-info/INSTALLER b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas-2.2.3.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas-2.2.3.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas-2.2.3.dist-info/LICENSE b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas-2.2.3.dist-info/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..733963a744c3d6710058de9f0ea316893c5492ca
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas-2.2.3.dist-info/LICENSE
@@ -0,0 +1,1250 @@
+BSD 3-Clause License
+
+Copyright (c) 2008-2011, AQR Capital Management, LLC, Lambda Foundry, Inc. and PyData Development Team
+All rights reserved.
+
+Copyright (c) 2011-2023, Open source contributors.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+Copyright (c) 2010-2019 Keith Goodman
+Copyright (c) 2019 Bottleneck Developers
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.Copyright 2017- Paul Ganssle
+Copyright 2017- dateutil contributors (see AUTHORS file)
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+The above license applies to all contributions after 2017-12-01, as well as
+all contributions that have been re-licensed (see AUTHORS file for the list of
+contributors who have re-licensed their code).
+--------------------------------------------------------------------------------
+dateutil - Extensions to the standard Python datetime module.
+
+Copyright (c) 2003-2011 - Gustavo Niemeyer
+Copyright (c) 2012-2014 - Tomi Pieviläinen
+Copyright (c) 2014-2016 - Yaron de Leeuw
+Copyright (c) 2015- - Paul Ganssle
+Copyright (c) 2015- - dateutil contributors (see AUTHORS file)
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ * Neither the name of the copyright holder nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+The above BSD License Applies to all code, even that also covered by Apache 2.0.# MIT License
+
+Copyright (c) 2019 Hadley Wickham; RStudio; and Evan Miller
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+Based on http://opensource.org/licenses/MIT
+
+This is a template. Complete and ship as file LICENSE the following 2
+lines (only)
+
+YEAR:
+COPYRIGHT HOLDER:
+
+and specify as
+
+License: MIT + file LICENSE
+
+Copyright (c) ,
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+The MIT License
+
+Copyright (c) 2008- Attractive Chaos
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.musl as a whole is licensed under the following standard MIT license:
+
+----------------------------------------------------------------------
+Copyright © 2005-2020 Rich Felker, et al.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+----------------------------------------------------------------------
+
+Authors/contributors include:
+
+A. Wilcox
+Ada Worcester
+Alex Dowad
+Alex Suykov
+Alexander Monakov
+Andre McCurdy
+Andrew Kelley
+Anthony G. Basile
+Aric Belsito
+Arvid Picciani
+Bartosz Brachaczek
+Benjamin Peterson
+Bobby Bingham
+Boris Brezillon
+Brent Cook
+Chris Spiegel
+Clément Vasseur
+Daniel Micay
+Daniel Sabogal
+Daurnimator
+David Carlier
+David Edelsohn
+Denys Vlasenko
+Dmitry Ivanov
+Dmitry V. Levin
+Drew DeVault
+Emil Renner Berthing
+Fangrui Song
+Felix Fietkau
+Felix Janda
+Gianluca Anzolin
+Hauke Mehrtens
+He X
+Hiltjo Posthuma
+Isaac Dunham
+Jaydeep Patil
+Jens Gustedt
+Jeremy Huntwork
+Jo-Philipp Wich
+Joakim Sindholt
+John Spencer
+Julien Ramseier
+Justin Cormack
+Kaarle Ritvanen
+Khem Raj
+Kylie McClain
+Leah Neukirchen
+Luca Barbato
+Luka Perkov
+M Farkas-Dyck (Strake)
+Mahesh Bodapati
+Markus Wichmann
+Masanori Ogino
+Michael Clark
+Michael Forney
+Mikhail Kremnyov
+Natanael Copa
+Nicholas J. Kain
+orc
+Pascal Cuoq
+Patrick Oppenlander
+Petr Hosek
+Petr Skocik
+Pierre Carrier
+Reini Urban
+Rich Felker
+Richard Pennington
+Ryan Fairfax
+Samuel Holland
+Segev Finer
+Shiz
+sin
+Solar Designer
+Stefan Kristiansson
+Stefan O'Rear
+Szabolcs Nagy
+Timo Teräs
+Trutz Behn
+Valentin Ochs
+Will Dietz
+William Haddon
+William Pitcock
+
+Portions of this software are derived from third-party works licensed
+under terms compatible with the above MIT license:
+
+The TRE regular expression implementation (src/regex/reg* and
+src/regex/tre*) is Copyright © 2001-2008 Ville Laurikari and licensed
+under a 2-clause BSD license (license text in the source files). The
+included version has been heavily modified by Rich Felker in 2012, in
+the interests of size, simplicity, and namespace cleanliness.
+
+Much of the math library code (src/math/* and src/complex/*) is
+Copyright © 1993,2004 Sun Microsystems or
+Copyright © 2003-2011 David Schultz or
+Copyright © 2003-2009 Steven G. Kargl or
+Copyright © 2003-2009 Bruce D. Evans or
+Copyright © 2008 Stephen L. Moshier or
+Copyright © 2017-2018 Arm Limited
+and labelled as such in comments in the individual source files. All
+have been licensed under extremely permissive terms.
+
+The ARM memcpy code (src/string/arm/memcpy.S) is Copyright © 2008
+The Android Open Source Project and is licensed under a two-clause BSD
+license. It was taken from Bionic libc, used on Android.
+
+The AArch64 memcpy and memset code (src/string/aarch64/*) are
+Copyright © 1999-2019, Arm Limited.
+
+The implementation of DES for crypt (src/crypt/crypt_des.c) is
+Copyright © 1994 David Burren. It is licensed under a BSD license.
+
+The implementation of blowfish crypt (src/crypt/crypt_blowfish.c) was
+originally written by Solar Designer and placed into the public
+domain. The code also comes with a fallback permissive license for use
+in jurisdictions that may not recognize the public domain.
+
+The smoothsort implementation (src/stdlib/qsort.c) is Copyright © 2011
+Valentin Ochs and is licensed under an MIT-style license.
+
+The x86_64 port was written by Nicholas J. Kain and is licensed under
+the standard MIT terms.
+
+The mips and microblaze ports were originally written by Richard
+Pennington for use in the ellcc project. The original code was adapted
+by Rich Felker for build system and code conventions during upstream
+integration. It is licensed under the standard MIT terms.
+
+The mips64 port was contributed by Imagination Technologies and is
+licensed under the standard MIT terms.
+
+The powerpc port was also originally written by Richard Pennington,
+and later supplemented and integrated by John Spencer. It is licensed
+under the standard MIT terms.
+
+All other files which have no copyright comments are original works
+produced specifically for use as part of this library, written either
+by Rich Felker, the main author of the library, or by one or more
+contibutors listed above. Details on authorship of individual files
+can be found in the git version control history of the project. The
+omission of copyright and license comments in each file is in the
+interest of source tree size.
+
+In addition, permission is hereby granted for all public header files
+(include/* and arch/*/bits/*) and crt files intended to be linked into
+applications (crt/*, ldso/dlstart.c, and arch/*/crt_arch.h) to omit
+the copyright notice and permission notice otherwise required by the
+license, and to use these files without any requirement of
+attribution. These files include substantial contributions from:
+
+Bobby Bingham
+John Spencer
+Nicholas J. Kain
+Rich Felker
+Richard Pennington
+Stefan Kristiansson
+Szabolcs Nagy
+
+all of whom have explicitly granted such permission.
+
+This file previously contained text expressing a belief that most of
+the files covered by the above exception were sufficiently trivial not
+to be subject to copyright, resulting in confusion over whether it
+negated the permissions granted in the license. In the spirit of
+permissive licensing, and of not having licensing issues being an
+obstacle to adoption, that text has been removed.Copyright (c) 2005-2023, NumPy Developers.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the following
+ disclaimer in the documentation and/or other materials provided
+ with the distribution.
+
+ * Neither the name of the NumPy Developers nor the names of any
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+
+Copyright (c) Donald Stufft and individual contributors.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.A. HISTORY OF THE SOFTWARE
+==========================
+
+Python was created in the early 1990s by Guido van Rossum at Stichting
+Mathematisch Centrum (CWI, see https://www.cwi.nl) in the Netherlands
+as a successor of a language called ABC. Guido remains Python's
+principal author, although it includes many contributions from others.
+
+In 1995, Guido continued his work on Python at the Corporation for
+National Research Initiatives (CNRI, see https://www.cnri.reston.va.us)
+in Reston, Virginia where he released several versions of the
+software.
+
+In May 2000, Guido and the Python core development team moved to
+BeOpen.com to form the BeOpen PythonLabs team. In October of the same
+year, the PythonLabs team moved to Digital Creations, which became
+Zope Corporation. In 2001, the Python Software Foundation (PSF, see
+https://www.python.org/psf/) was formed, a non-profit organization
+created specifically to own Python-related Intellectual Property.
+Zope Corporation was a sponsoring member of the PSF.
+
+All Python releases are Open Source (see https://opensource.org for
+the Open Source Definition). Historically, most, but not all, Python
+releases have also been GPL-compatible; the table below summarizes
+the various releases.
+
+ Release Derived Year Owner GPL-
+ from compatible? (1)
+
+ 0.9.0 thru 1.2 1991-1995 CWI yes
+ 1.3 thru 1.5.2 1.2 1995-1999 CNRI yes
+ 1.6 1.5.2 2000 CNRI no
+ 2.0 1.6 2000 BeOpen.com no
+ 1.6.1 1.6 2001 CNRI yes (2)
+ 2.1 2.0+1.6.1 2001 PSF no
+ 2.0.1 2.0+1.6.1 2001 PSF yes
+ 2.1.1 2.1+2.0.1 2001 PSF yes
+ 2.1.2 2.1.1 2002 PSF yes
+ 2.1.3 2.1.2 2002 PSF yes
+ 2.2 and above 2.1.1 2001-now PSF yes
+
+Footnotes:
+
+(1) GPL-compatible doesn't mean that we're distributing Python under
+ the GPL. All Python licenses, unlike the GPL, let you distribute
+ a modified version without making your changes open source. The
+ GPL-compatible licenses make it possible to combine Python with
+ other software that is released under the GPL; the others don't.
+
+(2) According to Richard Stallman, 1.6.1 is not GPL-compatible,
+ because its license has a choice of law clause. According to
+ CNRI, however, Stallman's lawyer has told CNRI's lawyer that 1.6.1
+ is "not incompatible" with the GPL.
+
+Thanks to the many outside volunteers who have worked under Guido's
+direction to make these releases possible.
+
+
+B. TERMS AND CONDITIONS FOR ACCESSING OR OTHERWISE USING PYTHON
+===============================================================
+
+Python software and documentation are licensed under the
+Python Software Foundation License Version 2.
+
+Starting with Python 3.8.6, examples, recipes, and other code in
+the documentation are dual licensed under the PSF License Version 2
+and the Zero-Clause BSD license.
+
+Some software incorporated into Python is under different licenses.
+The licenses are listed with code falling under that license.
+
+
+PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+--------------------------------------------
+
+1. This LICENSE AGREEMENT is between the Python Software Foundation
+("PSF"), and the Individual or Organization ("Licensee") accessing and
+otherwise using this software ("Python") in source or binary form and
+its associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, PSF hereby
+grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
+analyze, test, perform and/or display publicly, prepare derivative works,
+distribute, and otherwise use Python alone or in any derivative version,
+provided, however, that PSF's License Agreement and PSF's notice of copyright,
+i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023 Python Software Foundation;
+All Rights Reserved" are retained in Python alone or in any derivative version
+prepared by Licensee.
+
+3. In the event Licensee prepares a derivative work that is based on
+or incorporates Python or any part thereof, and wants to make
+the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to Python.
+
+4. PSF is making Python available to Licensee on an "AS IS"
+basis. PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON,
+OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. Nothing in this License Agreement shall be deemed to create any
+relationship of agency, partnership, or joint venture between PSF and
+Licensee. This License Agreement does not grant permission to use PSF
+trademarks or trade name in a trademark sense to endorse or promote
+products or services of Licensee, or any third party.
+
+8. By copying, installing or otherwise using Python, Licensee
+agrees to be bound by the terms and conditions of this License
+Agreement.
+
+
+BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0
+-------------------------------------------
+
+BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1
+
+1. This LICENSE AGREEMENT is between BeOpen.com ("BeOpen"), having an
+office at 160 Saratoga Avenue, Santa Clara, CA 95051, and the
+Individual or Organization ("Licensee") accessing and otherwise using
+this software in source or binary form and its associated
+documentation ("the Software").
+
+2. Subject to the terms and conditions of this BeOpen Python License
+Agreement, BeOpen hereby grants Licensee a non-exclusive,
+royalty-free, world-wide license to reproduce, analyze, test, perform
+and/or display publicly, prepare derivative works, distribute, and
+otherwise use the Software alone or in any derivative version,
+provided, however, that the BeOpen Python License is retained in the
+Software, alone or in any derivative version prepared by Licensee.
+
+3. BeOpen is making the Software available to Licensee on an "AS IS"
+basis. BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE
+SOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS
+AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY
+DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+5. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+6. This License Agreement shall be governed by and interpreted in all
+respects by the law of the State of California, excluding conflict of
+law provisions. Nothing in this License Agreement shall be deemed to
+create any relationship of agency, partnership, or joint venture
+between BeOpen and Licensee. This License Agreement does not grant
+permission to use BeOpen trademarks or trade names in a trademark
+sense to endorse or promote products or services of Licensee, or any
+third party. As an exception, the "BeOpen Python" logos available at
+http://www.pythonlabs.com/logos.html may be used according to the
+permissions granted on that web page.
+
+7. By copying, installing or otherwise using the software, Licensee
+agrees to be bound by the terms and conditions of this License
+Agreement.
+
+
+CNRI LICENSE AGREEMENT FOR PYTHON 1.6.1
+---------------------------------------
+
+1. This LICENSE AGREEMENT is between the Corporation for National
+Research Initiatives, having an office at 1895 Preston White Drive,
+Reston, VA 20191 ("CNRI"), and the Individual or Organization
+("Licensee") accessing and otherwise using Python 1.6.1 software in
+source or binary form and its associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, CNRI
+hereby grants Licensee a nonexclusive, royalty-free, world-wide
+license to reproduce, analyze, test, perform and/or display publicly,
+prepare derivative works, distribute, and otherwise use Python 1.6.1
+alone or in any derivative version, provided, however, that CNRI's
+License Agreement and CNRI's notice of copyright, i.e., "Copyright (c)
+1995-2001 Corporation for National Research Initiatives; All Rights
+Reserved" are retained in Python 1.6.1 alone or in any derivative
+version prepared by Licensee. Alternately, in lieu of CNRI's License
+Agreement, Licensee may substitute the following text (omitting the
+quotes): "Python 1.6.1 is made available subject to the terms and
+conditions in CNRI's License Agreement. This Agreement together with
+Python 1.6.1 may be located on the internet using the following
+unique, persistent identifier (known as a handle): 1895.22/1013. This
+Agreement may also be obtained from a proxy server on the internet
+using the following URL: http://hdl.handle.net/1895.22/1013".
+
+3. In the event Licensee prepares a derivative work that is based on
+or incorporates Python 1.6.1 or any part thereof, and wants to make
+the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to Python 1.6.1.
+
+4. CNRI is making Python 1.6.1 available to Licensee on an "AS IS"
+basis. CNRI MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 1.6.1 WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+1.6.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1,
+OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. This License Agreement shall be governed by the federal
+intellectual property law of the United States, including without
+limitation the federal copyright law, and, to the extent such
+U.S. federal law does not apply, by the law of the Commonwealth of
+Virginia, excluding Virginia's conflict of law provisions.
+Notwithstanding the foregoing, with regard to derivative works based
+on Python 1.6.1 that incorporate non-separable material that was
+previously distributed under the GNU General Public License (GPL), the
+law of the Commonwealth of Virginia shall govern this License
+Agreement only as to issues arising under or with respect to
+Paragraphs 4, 5, and 7 of this License Agreement. Nothing in this
+License Agreement shall be deemed to create any relationship of
+agency, partnership, or joint venture between CNRI and Licensee. This
+License Agreement does not grant permission to use CNRI trademarks or
+trade name in a trademark sense to endorse or promote products or
+services of Licensee, or any third party.
+
+8. By clicking on the "ACCEPT" button where indicated, or by copying,
+installing or otherwise using Python 1.6.1, Licensee agrees to be
+bound by the terms and conditions of this License Agreement.
+
+ ACCEPT
+
+
+CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2
+--------------------------------------------------
+
+Copyright (c) 1991 - 1995, Stichting Mathematisch Centrum Amsterdam,
+The Netherlands. All rights reserved.
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Stichting Mathematisch
+Centrum or CWI not be used in advertising or publicity pertaining to
+distribution of the software without specific, written prior
+permission.
+
+STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
+THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
+FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+ZERO-CLAUSE BSD LICENSE FOR CODE IN THE PYTHON DOCUMENTATION
+----------------------------------------------------------------------
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+Copyright (c) 2014, Al Sweigart
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+* Neither the name of the {organization} nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.Copyright (c) 2017 Anthony Sottile
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.Copyright (c) 2015-2019 Jared Hobbs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.Developed by ESN, an Electronic Arts Inc. studio.
+Copyright (c) 2014, Electronic Arts Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+* Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+* Neither the name of ESN, Electronic Arts Inc. nor the
+names of its contributors may be used to endorse or promote products
+derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS INC. BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----
+
+Portions of code from MODP_ASCII - Ascii transformations (upper/lower, etc)
+https://github.com/client9/stringencoders
+
+ Copyright 2005, 2006, 2007
+ Nick Galbreath -- nickg [at] modp [dot] com
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are
+ met:
+
+ Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ Neither the name of the modp.com nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ This is the standard "new" BSD license:
+ http://www.opensource.org/licenses/bsd-license.php
+
+https://github.com/client9/stringencoders/blob/cfd5c1507325ae497ea9bacdacba12c0ffd79d30/COPYING
+
+----
+
+Numeric decoder derived from from TCL library
+https://opensource.apple.com/source/tcl/tcl-14/tcl/license.terms
+ * Copyright (c) 1988-1993 The Regents of the University of California.
+ * Copyright (c) 1994 Sun Microsystems, Inc.
+
+ This software is copyrighted by the Regents of the University of
+ California, Sun Microsystems, Inc., Scriptics Corporation, ActiveState
+ Corporation and other parties. The following terms apply to all files
+ associated with the software unless explicitly disclaimed in
+ individual files.
+
+ The authors hereby grant permission to use, copy, modify, distribute,
+ and license this software and its documentation for any purpose, provided
+ that existing copyright notices are retained in all copies and that this
+ notice is included verbatim in any distributions. No written agreement,
+ license, or royalty fee is required for any of the authorized uses.
+ Modifications to this software may be copyrighted by their authors
+ and need not follow the licensing terms described here, provided that
+ the new terms are clearly indicated on the first page of each file where
+ they apply.
+
+ IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY
+ FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
+ ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY
+ DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.
+
+ THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
+ INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT. THIS SOFTWARE
+ IS PROVIDED ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE
+ NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR
+ MODIFICATIONS.
+
+ GOVERNMENT USE: If you are acquiring this software on behalf of the
+ U.S. government, the Government shall have only "Restricted Rights"
+ in the software and related documentation as defined in the Federal
+ Acquisition Regulations (FARs) in Clause 52.227.19 (c) (2). If you
+ are acquiring the software on behalf of the Department of Defense, the
+ software shall be classified as "Commercial Computer Software" and the
+ Government shall have only "Restricted Rights" as defined in Clause
+ 252.227-7013 (c) (1) of DFARs. Notwithstanding the foregoing, the
+ authors grant the U.S. Government and others acting in its behalf
+ permission to use and distribute the software in accordance with the
+ terms specified in this license.Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright
+owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities
+that control, are controlled by, or are under common control with that entity.
+For the purposes of this definition, "control" means (i) the power, direct or
+indirect, to cause the direction or management of such entity, whether by
+contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising
+permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including
+but not limited to software source code, documentation source, and configuration
+files.
+
+"Object" form shall mean any form resulting from mechanical transformation or
+translation of a Source form, including but not limited to compiled object code,
+generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form, made
+available under the License, as indicated by a copyright notice that is included
+in or attached to the work (an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that
+is based on (or derived from) the Work and for which the editorial revisions,
+annotations, elaborations, or other modifications represent, as a whole, an
+original work of authorship. For the purposes of this License, Derivative Works
+shall not include works that remain separable from, or merely link (or bind by
+name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original version
+of the Work and any modifications or additions to that Work or Derivative Works
+thereof, that is intentionally submitted to Licensor for inclusion in the Work
+by the copyright owner or by an individual or Legal Entity authorized to submit
+on behalf of the copyright owner. For the purposes of this definition,
+"submitted" means any form of electronic, verbal, or written communication sent
+to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems, and
+issue tracking systems that are managed by, or on behalf of, the Licensor for
+the purpose of discussing and improving the Work, but excluding communication
+that is conspicuously marked or otherwise designated in writing by the copyright
+owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf
+of whom a Contribution has been received by Licensor and subsequently
+incorporated within the Work.
+
+2. Grant of Copyright License.
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable copyright license to reproduce, prepare Derivative Works of,
+publicly display, publicly perform, sublicense, and distribute the Work and such
+Derivative Works in Source or Object form.
+
+3. Grant of Patent License.
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable (except as stated in this section) patent license to make, have
+made, use, offer to sell, sell, import, and otherwise transfer the Work, where
+such license applies only to those patent claims licensable by such Contributor
+that are necessarily infringed by their Contribution(s) alone or by combination
+of their Contribution(s) with the Work to which such Contribution(s) was
+submitted. If You institute patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Work or a
+Contribution incorporated within the Work constitutes direct or contributory
+patent infringement, then any patent licenses granted to You under this License
+for that Work shall terminate as of the date such litigation is filed.
+
+4. Redistribution.
+
+You may reproduce and distribute copies of the Work or Derivative Works thereof
+in any medium, with or without modifications, and in Source or Object form,
+provided that You meet the following conditions:
+
+You must give any other recipients of the Work or Derivative Works a copy of
+this License; and
+You must cause any modified files to carry prominent notices stating that You
+changed the files; and
+You must retain, in the Source form of any Derivative Works that You distribute,
+all copyright, patent, trademark, and attribution notices from the Source form
+of the Work, excluding those notices that do not pertain to any part of the
+Derivative Works; and
+If the Work includes a "NOTICE" text file as part of its distribution, then any
+Derivative Works that You distribute must include a readable copy of the
+attribution notices contained within such NOTICE file, excluding those notices
+that do not pertain to any part of the Derivative Works, in at least one of the
+following places: within a NOTICE text file distributed as part of the
+Derivative Works; within the Source form or documentation, if provided along
+with the Derivative Works; or, within a display generated by the Derivative
+Works, if and wherever such third-party notices normally appear. The contents of
+the NOTICE file are for informational purposes only and do not modify the
+License. You may add Your own attribution notices within Derivative Works that
+You distribute, alongside or as an addendum to the NOTICE text from the Work,
+provided that such additional attribution notices cannot be construed as
+modifying the License.
+You may add Your own copyright statement to Your modifications and may provide
+additional or different license terms and conditions for use, reproduction, or
+distribution of Your modifications, or for any such Derivative Works as a whole,
+provided Your use, reproduction, and distribution of the Work otherwise complies
+with the conditions stated in this License.
+
+5. Submission of Contributions.
+
+Unless You explicitly state otherwise, any Contribution intentionally submitted
+for inclusion in the Work by You to the Licensor shall be under the terms and
+conditions of this License, without any additional terms or conditions.
+Notwithstanding the above, nothing herein shall supersede or modify the terms of
+any separate license agreement you may have executed with Licensor regarding
+such Contributions.
+
+6. Trademarks.
+
+This License does not grant permission to use the trade names, trademarks,
+service marks, or product names of the Licensor, except as required for
+reasonable and customary use in describing the origin of the Work and
+reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty.
+
+Unless required by applicable law or agreed to in writing, Licensor provides the
+Work (and each Contributor provides its Contributions) on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,
+including, without limitation, any warranties or conditions of TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are
+solely responsible for determining the appropriateness of using or
+redistributing the Work and assume any risks associated with Your exercise of
+permissions under this License.
+
+8. Limitation of Liability.
+
+In no event and under no legal theory, whether in tort (including negligence),
+contract, or otherwise, unless required by applicable law (such as deliberate
+and grossly negligent acts) or agreed to in writing, shall any Contributor be
+liable to You for damages, including any direct, indirect, special, incidental,
+or consequential damages of any character arising as a result of this License or
+out of the use or inability to use the Work (including but not limited to
+damages for loss of goodwill, work stoppage, computer failure or malfunction, or
+any and all other commercial damages or losses), even if such Contributor has
+been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability.
+
+While redistributing the Work or Derivative Works thereof, You may choose to
+offer, and charge a fee for, acceptance of support, warranty, indemnity, or
+other liability obligations and/or rights consistent with this License. However,
+in accepting such obligations, You may act only on Your own behalf and on Your
+sole responsibility, not on behalf of any other Contributor, and only if You
+agree to indemnify, defend, and hold each Contributor harmless for any liability
+incurred by, or claims asserted against, such Contributor by reason of your
+accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work
+
+To apply the Apache License to your work, attach the following boilerplate
+notice, with the fields enclosed by brackets "[]" replaced with your own
+identifying information. (Don't include the brackets!) The text should be
+enclosed in the appropriate comment syntax for the file format. We also
+recommend that a file or class name and description of purpose be included on
+the same "printed page" as the copyright notice for easier identification within
+third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
\ No newline at end of file
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas-2.2.3.dist-info/METADATA b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas-2.2.3.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..344345f4c22cf91766ee26bc3bf91d625e7330f7
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas-2.2.3.dist-info/METADATA
@@ -0,0 +1,1573 @@
+Metadata-Version: 2.1
+Name: pandas
+Version: 2.2.3
+Summary: Powerful data structures for data analysis, time series, and statistics
+Home-page: https://pandas.pydata.org
+Author-Email: The Pandas Development Team
+License: BSD 3-Clause License
+
+ Copyright (c) 2008-2011, AQR Capital Management, LLC, Lambda Foundry, Inc. and PyData Development Team
+ All rights reserved.
+
+ Copyright (c) 2011-2023, Open source contributors.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ * Neither the name of the copyright holder nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ Copyright (c) 2010-2019 Keith Goodman
+ Copyright (c) 2019 Bottleneck Developers
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.Copyright 2017- Paul Ganssle
+ Copyright 2017- dateutil contributors (see AUTHORS file)
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+ The above license applies to all contributions after 2017-12-01, as well as
+ all contributions that have been re-licensed (see AUTHORS file for the list of
+ contributors who have re-licensed their code).
+ --------------------------------------------------------------------------------
+ dateutil - Extensions to the standard Python datetime module.
+
+ Copyright (c) 2003-2011 - Gustavo Niemeyer
+ Copyright (c) 2012-2014 - Tomi Pieviläinen
+ Copyright (c) 2014-2016 - Yaron de Leeuw
+ Copyright (c) 2015- - Paul Ganssle
+ Copyright (c) 2015- - dateutil contributors (see AUTHORS file)
+
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ * Neither the name of the copyright holder nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ The above BSD License Applies to all code, even that also covered by Apache 2.0.# MIT License
+
+ Copyright (c) 2019 Hadley Wickham; RStudio; and Evan Miller
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+ Based on http://opensource.org/licenses/MIT
+
+ This is a template. Complete and ship as file LICENSE the following 2
+ lines (only)
+
+ YEAR:
+ COPYRIGHT HOLDER:
+
+ and specify as
+
+ License: MIT + file LICENSE
+
+ Copyright (c) ,
+
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of this software and associated documentation files (the
+ "Software"), to deal in the Software without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to
+ permit persons to whom the Software is furnished to do so, subject to
+ the following conditions:
+
+ The above copyright notice and this permission notice shall be
+ included in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ The MIT License
+
+ Copyright (c) 2008- Attractive Chaos
+
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of this software and associated documentation files (the
+ "Software"), to deal in the Software without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to
+ permit persons to whom the Software is furnished to do so, subject to
+ the following conditions:
+
+ The above copyright notice and this permission notice shall be
+ included in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.musl as a whole is licensed under the following standard MIT license:
+
+ ----------------------------------------------------------------------
+ Copyright © 2005-2020 Rich Felker, et al.
+
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of this software and associated documentation files (the
+ "Software"), to deal in the Software without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to
+ permit persons to whom the Software is furnished to do so, subject to
+ the following conditions:
+
+ The above copyright notice and this permission notice shall be
+ included in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ ----------------------------------------------------------------------
+
+ Authors/contributors include:
+
+ A. Wilcox
+ Ada Worcester
+ Alex Dowad
+ Alex Suykov
+ Alexander Monakov
+ Andre McCurdy
+ Andrew Kelley
+ Anthony G. Basile
+ Aric Belsito
+ Arvid Picciani
+ Bartosz Brachaczek
+ Benjamin Peterson
+ Bobby Bingham
+ Boris Brezillon
+ Brent Cook
+ Chris Spiegel
+ Clément Vasseur
+ Daniel Micay
+ Daniel Sabogal
+ Daurnimator
+ David Carlier
+ David Edelsohn
+ Denys Vlasenko
+ Dmitry Ivanov
+ Dmitry V. Levin
+ Drew DeVault
+ Emil Renner Berthing
+ Fangrui Song
+ Felix Fietkau
+ Felix Janda
+ Gianluca Anzolin
+ Hauke Mehrtens
+ He X
+ Hiltjo Posthuma
+ Isaac Dunham
+ Jaydeep Patil
+ Jens Gustedt
+ Jeremy Huntwork
+ Jo-Philipp Wich
+ Joakim Sindholt
+ John Spencer
+ Julien Ramseier
+ Justin Cormack
+ Kaarle Ritvanen
+ Khem Raj
+ Kylie McClain
+ Leah Neukirchen
+ Luca Barbato
+ Luka Perkov
+ M Farkas-Dyck (Strake)
+ Mahesh Bodapati
+ Markus Wichmann
+ Masanori Ogino
+ Michael Clark
+ Michael Forney
+ Mikhail Kremnyov
+ Natanael Copa
+ Nicholas J. Kain
+ orc
+ Pascal Cuoq
+ Patrick Oppenlander
+ Petr Hosek
+ Petr Skocik
+ Pierre Carrier
+ Reini Urban
+ Rich Felker
+ Richard Pennington
+ Ryan Fairfax
+ Samuel Holland
+ Segev Finer
+ Shiz
+ sin
+ Solar Designer
+ Stefan Kristiansson
+ Stefan O'Rear
+ Szabolcs Nagy
+ Timo Teräs
+ Trutz Behn
+ Valentin Ochs
+ Will Dietz
+ William Haddon
+ William Pitcock
+
+ Portions of this software are derived from third-party works licensed
+ under terms compatible with the above MIT license:
+
+ The TRE regular expression implementation (src/regex/reg* and
+ src/regex/tre*) is Copyright © 2001-2008 Ville Laurikari and licensed
+ under a 2-clause BSD license (license text in the source files). The
+ included version has been heavily modified by Rich Felker in 2012, in
+ the interests of size, simplicity, and namespace cleanliness.
+
+ Much of the math library code (src/math/* and src/complex/*) is
+ Copyright © 1993,2004 Sun Microsystems or
+ Copyright © 2003-2011 David Schultz or
+ Copyright © 2003-2009 Steven G. Kargl or
+ Copyright © 2003-2009 Bruce D. Evans or
+ Copyright © 2008 Stephen L. Moshier or
+ Copyright © 2017-2018 Arm Limited
+ and labelled as such in comments in the individual source files. All
+ have been licensed under extremely permissive terms.
+
+ The ARM memcpy code (src/string/arm/memcpy.S) is Copyright © 2008
+ The Android Open Source Project and is licensed under a two-clause BSD
+ license. It was taken from Bionic libc, used on Android.
+
+ The AArch64 memcpy and memset code (src/string/aarch64/*) are
+ Copyright © 1999-2019, Arm Limited.
+
+ The implementation of DES for crypt (src/crypt/crypt_des.c) is
+ Copyright © 1994 David Burren. It is licensed under a BSD license.
+
+ The implementation of blowfish crypt (src/crypt/crypt_blowfish.c) was
+ originally written by Solar Designer and placed into the public
+ domain. The code also comes with a fallback permissive license for use
+ in jurisdictions that may not recognize the public domain.
+
+ The smoothsort implementation (src/stdlib/qsort.c) is Copyright © 2011
+ Valentin Ochs and is licensed under an MIT-style license.
+
+ The x86_64 port was written by Nicholas J. Kain and is licensed under
+ the standard MIT terms.
+
+ The mips and microblaze ports were originally written by Richard
+ Pennington for use in the ellcc project. The original code was adapted
+ by Rich Felker for build system and code conventions during upstream
+ integration. It is licensed under the standard MIT terms.
+
+ The mips64 port was contributed by Imagination Technologies and is
+ licensed under the standard MIT terms.
+
+ The powerpc port was also originally written by Richard Pennington,
+ and later supplemented and integrated by John Spencer. It is licensed
+ under the standard MIT terms.
+
+ All other files which have no copyright comments are original works
+ produced specifically for use as part of this library, written either
+ by Rich Felker, the main author of the library, or by one or more
+ contibutors listed above. Details on authorship of individual files
+ can be found in the git version control history of the project. The
+ omission of copyright and license comments in each file is in the
+ interest of source tree size.
+
+ In addition, permission is hereby granted for all public header files
+ (include/* and arch/*/bits/*) and crt files intended to be linked into
+ applications (crt/*, ldso/dlstart.c, and arch/*/crt_arch.h) to omit
+ the copyright notice and permission notice otherwise required by the
+ license, and to use these files without any requirement of
+ attribution. These files include substantial contributions from:
+
+ Bobby Bingham
+ John Spencer
+ Nicholas J. Kain
+ Rich Felker
+ Richard Pennington
+ Stefan Kristiansson
+ Szabolcs Nagy
+
+ all of whom have explicitly granted such permission.
+
+ This file previously contained text expressing a belief that most of
+ the files covered by the above exception were sufficiently trivial not
+ to be subject to copyright, resulting in confusion over whether it
+ negated the permissions granted in the license. In the spirit of
+ permissive licensing, and of not having licensing issues being an
+ obstacle to adoption, that text has been removed.Copyright (c) 2005-2023, NumPy Developers.
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are
+ met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the following
+ disclaimer in the documentation and/or other materials provided
+ with the distribution.
+
+ * Neither the name of the NumPy Developers nor the names of any
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+
+ Copyright (c) Donald Stufft and individual contributors.
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.A. HISTORY OF THE SOFTWARE
+ ==========================
+
+ Python was created in the early 1990s by Guido van Rossum at Stichting
+ Mathematisch Centrum (CWI, see https://www.cwi.nl) in the Netherlands
+ as a successor of a language called ABC. Guido remains Python's
+ principal author, although it includes many contributions from others.
+
+ In 1995, Guido continued his work on Python at the Corporation for
+ National Research Initiatives (CNRI, see https://www.cnri.reston.va.us)
+ in Reston, Virginia where he released several versions of the
+ software.
+
+ In May 2000, Guido and the Python core development team moved to
+ BeOpen.com to form the BeOpen PythonLabs team. In October of the same
+ year, the PythonLabs team moved to Digital Creations, which became
+ Zope Corporation. In 2001, the Python Software Foundation (PSF, see
+ https://www.python.org/psf/) was formed, a non-profit organization
+ created specifically to own Python-related Intellectual Property.
+ Zope Corporation was a sponsoring member of the PSF.
+
+ All Python releases are Open Source (see https://opensource.org for
+ the Open Source Definition). Historically, most, but not all, Python
+ releases have also been GPL-compatible; the table below summarizes
+ the various releases.
+
+ Release Derived Year Owner GPL-
+ from compatible? (1)
+
+ 0.9.0 thru 1.2 1991-1995 CWI yes
+ 1.3 thru 1.5.2 1.2 1995-1999 CNRI yes
+ 1.6 1.5.2 2000 CNRI no
+ 2.0 1.6 2000 BeOpen.com no
+ 1.6.1 1.6 2001 CNRI yes (2)
+ 2.1 2.0+1.6.1 2001 PSF no
+ 2.0.1 2.0+1.6.1 2001 PSF yes
+ 2.1.1 2.1+2.0.1 2001 PSF yes
+ 2.1.2 2.1.1 2002 PSF yes
+ 2.1.3 2.1.2 2002 PSF yes
+ 2.2 and above 2.1.1 2001-now PSF yes
+
+ Footnotes:
+
+ (1) GPL-compatible doesn't mean that we're distributing Python under
+ the GPL. All Python licenses, unlike the GPL, let you distribute
+ a modified version without making your changes open source. The
+ GPL-compatible licenses make it possible to combine Python with
+ other software that is released under the GPL; the others don't.
+
+ (2) According to Richard Stallman, 1.6.1 is not GPL-compatible,
+ because its license has a choice of law clause. According to
+ CNRI, however, Stallman's lawyer has told CNRI's lawyer that 1.6.1
+ is "not incompatible" with the GPL.
+
+ Thanks to the many outside volunteers who have worked under Guido's
+ direction to make these releases possible.
+
+
+ B. TERMS AND CONDITIONS FOR ACCESSING OR OTHERWISE USING PYTHON
+ ===============================================================
+
+ Python software and documentation are licensed under the
+ Python Software Foundation License Version 2.
+
+ Starting with Python 3.8.6, examples, recipes, and other code in
+ the documentation are dual licensed under the PSF License Version 2
+ and the Zero-Clause BSD license.
+
+ Some software incorporated into Python is under different licenses.
+ The licenses are listed with code falling under that license.
+
+
+ PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+ --------------------------------------------
+
+ 1. This LICENSE AGREEMENT is between the Python Software Foundation
+ ("PSF"), and the Individual or Organization ("Licensee") accessing and
+ otherwise using this software ("Python") in source or binary form and
+ its associated documentation.
+
+ 2. Subject to the terms and conditions of this License Agreement, PSF hereby
+ grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
+ analyze, test, perform and/or display publicly, prepare derivative works,
+ distribute, and otherwise use Python alone or in any derivative version,
+ provided, however, that PSF's License Agreement and PSF's notice of copyright,
+ i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+ 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023 Python Software Foundation;
+ All Rights Reserved" are retained in Python alone or in any derivative version
+ prepared by Licensee.
+
+ 3. In the event Licensee prepares a derivative work that is based on
+ or incorporates Python or any part thereof, and wants to make
+ the derivative work available to others as provided herein, then
+ Licensee hereby agrees to include in any such work a brief summary of
+ the changes made to Python.
+
+ 4. PSF is making Python available to Licensee on an "AS IS"
+ basis. PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+ IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
+ DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+ FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
+ INFRINGE ANY THIRD PARTY RIGHTS.
+
+ 5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+ FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+ A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON,
+ OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+ 6. This License Agreement will automatically terminate upon a material
+ breach of its terms and conditions.
+
+ 7. Nothing in this License Agreement shall be deemed to create any
+ relationship of agency, partnership, or joint venture between PSF and
+ Licensee. This License Agreement does not grant permission to use PSF
+ trademarks or trade name in a trademark sense to endorse or promote
+ products or services of Licensee, or any third party.
+
+ 8. By copying, installing or otherwise using Python, Licensee
+ agrees to be bound by the terms and conditions of this License
+ Agreement.
+
+
+ BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0
+ -------------------------------------------
+
+ BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1
+
+ 1. This LICENSE AGREEMENT is between BeOpen.com ("BeOpen"), having an
+ office at 160 Saratoga Avenue, Santa Clara, CA 95051, and the
+ Individual or Organization ("Licensee") accessing and otherwise using
+ this software in source or binary form and its associated
+ documentation ("the Software").
+
+ 2. Subject to the terms and conditions of this BeOpen Python License
+ Agreement, BeOpen hereby grants Licensee a non-exclusive,
+ royalty-free, world-wide license to reproduce, analyze, test, perform
+ and/or display publicly, prepare derivative works, distribute, and
+ otherwise use the Software alone or in any derivative version,
+ provided, however, that the BeOpen Python License is retained in the
+ Software, alone or in any derivative version prepared by Licensee.
+
+ 3. BeOpen is making the Software available to Licensee on an "AS IS"
+ basis. BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+ IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND
+ DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+ FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE WILL NOT
+ INFRINGE ANY THIRD PARTY RIGHTS.
+
+ 4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE
+ SOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS
+ AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY
+ DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+ 5. This License Agreement will automatically terminate upon a material
+ breach of its terms and conditions.
+
+ 6. This License Agreement shall be governed by and interpreted in all
+ respects by the law of the State of California, excluding conflict of
+ law provisions. Nothing in this License Agreement shall be deemed to
+ create any relationship of agency, partnership, or joint venture
+ between BeOpen and Licensee. This License Agreement does not grant
+ permission to use BeOpen trademarks or trade names in a trademark
+ sense to endorse or promote products or services of Licensee, or any
+ third party. As an exception, the "BeOpen Python" logos available at
+ http://www.pythonlabs.com/logos.html may be used according to the
+ permissions granted on that web page.
+
+ 7. By copying, installing or otherwise using the software, Licensee
+ agrees to be bound by the terms and conditions of this License
+ Agreement.
+
+
+ CNRI LICENSE AGREEMENT FOR PYTHON 1.6.1
+ ---------------------------------------
+
+ 1. This LICENSE AGREEMENT is between the Corporation for National
+ Research Initiatives, having an office at 1895 Preston White Drive,
+ Reston, VA 20191 ("CNRI"), and the Individual or Organization
+ ("Licensee") accessing and otherwise using Python 1.6.1 software in
+ source or binary form and its associated documentation.
+
+ 2. Subject to the terms and conditions of this License Agreement, CNRI
+ hereby grants Licensee a nonexclusive, royalty-free, world-wide
+ license to reproduce, analyze, test, perform and/or display publicly,
+ prepare derivative works, distribute, and otherwise use Python 1.6.1
+ alone or in any derivative version, provided, however, that CNRI's
+ License Agreement and CNRI's notice of copyright, i.e., "Copyright (c)
+ 1995-2001 Corporation for National Research Initiatives; All Rights
+ Reserved" are retained in Python 1.6.1 alone or in any derivative
+ version prepared by Licensee. Alternately, in lieu of CNRI's License
+ Agreement, Licensee may substitute the following text (omitting the
+ quotes): "Python 1.6.1 is made available subject to the terms and
+ conditions in CNRI's License Agreement. This Agreement together with
+ Python 1.6.1 may be located on the internet using the following
+ unique, persistent identifier (known as a handle): 1895.22/1013. This
+ Agreement may also be obtained from a proxy server on the internet
+ using the following URL: http://hdl.handle.net/1895.22/1013".
+
+ 3. In the event Licensee prepares a derivative work that is based on
+ or incorporates Python 1.6.1 or any part thereof, and wants to make
+ the derivative work available to others as provided herein, then
+ Licensee hereby agrees to include in any such work a brief summary of
+ the changes made to Python 1.6.1.
+
+ 4. CNRI is making Python 1.6.1 available to Licensee on an "AS IS"
+ basis. CNRI MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+ IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO AND
+ DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+ FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 1.6.1 WILL NOT
+ INFRINGE ANY THIRD PARTY RIGHTS.
+
+ 5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+ 1.6.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+ A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1,
+ OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+ 6. This License Agreement will automatically terminate upon a material
+ breach of its terms and conditions.
+
+ 7. This License Agreement shall be governed by the federal
+ intellectual property law of the United States, including without
+ limitation the federal copyright law, and, to the extent such
+ U.S. federal law does not apply, by the law of the Commonwealth of
+ Virginia, excluding Virginia's conflict of law provisions.
+ Notwithstanding the foregoing, with regard to derivative works based
+ on Python 1.6.1 that incorporate non-separable material that was
+ previously distributed under the GNU General Public License (GPL), the
+ law of the Commonwealth of Virginia shall govern this License
+ Agreement only as to issues arising under or with respect to
+ Paragraphs 4, 5, and 7 of this License Agreement. Nothing in this
+ License Agreement shall be deemed to create any relationship of
+ agency, partnership, or joint venture between CNRI and Licensee. This
+ License Agreement does not grant permission to use CNRI trademarks or
+ trade name in a trademark sense to endorse or promote products or
+ services of Licensee, or any third party.
+
+ 8. By clicking on the "ACCEPT" button where indicated, or by copying,
+ installing or otherwise using Python 1.6.1, Licensee agrees to be
+ bound by the terms and conditions of this License Agreement.
+
+ ACCEPT
+
+
+ CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2
+ --------------------------------------------------
+
+ Copyright (c) 1991 - 1995, Stichting Mathematisch Centrum Amsterdam,
+ The Netherlands. All rights reserved.
+
+ Permission to use, copy, modify, and distribute this software and its
+ documentation for any purpose and without fee is hereby granted,
+ provided that the above copyright notice appear in all copies and that
+ both that copyright notice and this permission notice appear in
+ supporting documentation, and that the name of Stichting Mathematisch
+ Centrum or CWI not be used in advertising or publicity pertaining to
+ distribution of the software without specific, written prior
+ permission.
+
+ STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
+ THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
+ FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+ OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+ ZERO-CLAUSE BSD LICENSE FOR CODE IN THE PYTHON DOCUMENTATION
+ ----------------------------------------------------------------------
+
+ Permission to use, copy, modify, and/or distribute this software for any
+ purpose with or without fee is hereby granted.
+
+ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+ REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+ AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+ INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+ LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+ OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ PERFORMANCE OF THIS SOFTWARE.
+ Copyright (c) 2014, Al Sweigart
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ * Neither the name of the {organization} nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.Copyright (c) 2017 Anthony Sottile
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.Copyright (c) 2015-2019 Jared Hobbs
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy of
+ this software and associated documentation files (the "Software"), to deal in
+ the Software without restriction, including without limitation the rights to
+ use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ of the Software, and to permit persons to whom the Software is furnished to do
+ so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.Developed by ESN, an Electronic Arts Inc. studio.
+ Copyright (c) 2014, Electronic Arts Inc.
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+ * Neither the name of ESN, Electronic Arts Inc. nor the
+ names of its contributors may be used to endorse or promote products
+ derived from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS INC. BE LIABLE
+ FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ----
+
+ Portions of code from MODP_ASCII - Ascii transformations (upper/lower, etc)
+ https://github.com/client9/stringencoders
+
+ Copyright 2005, 2006, 2007
+ Nick Galbreath -- nickg [at] modp [dot] com
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are
+ met:
+
+ Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ Neither the name of the modp.com nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ This is the standard "new" BSD license:
+ http://www.opensource.org/licenses/bsd-license.php
+
+ https://github.com/client9/stringencoders/blob/cfd5c1507325ae497ea9bacdacba12c0ffd79d30/COPYING
+
+ ----
+
+ Numeric decoder derived from from TCL library
+ https://opensource.apple.com/source/tcl/tcl-14/tcl/license.terms
+ * Copyright (c) 1988-1993 The Regents of the University of California.
+ * Copyright (c) 1994 Sun Microsystems, Inc.
+
+ This software is copyrighted by the Regents of the University of
+ California, Sun Microsystems, Inc., Scriptics Corporation, ActiveState
+ Corporation and other parties. The following terms apply to all files
+ associated with the software unless explicitly disclaimed in
+ individual files.
+
+ The authors hereby grant permission to use, copy, modify, distribute,
+ and license this software and its documentation for any purpose, provided
+ that existing copyright notices are retained in all copies and that this
+ notice is included verbatim in any distributions. No written agreement,
+ license, or royalty fee is required for any of the authorized uses.
+ Modifications to this software may be copyrighted by their authors
+ and need not follow the licensing terms described here, provided that
+ the new terms are clearly indicated on the first page of each file where
+ they apply.
+
+ IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY
+ FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
+ ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY
+ DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.
+
+ THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
+ INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT. THIS SOFTWARE
+ IS PROVIDED ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE
+ NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR
+ MODIFICATIONS.
+
+ GOVERNMENT USE: If you are acquiring this software on behalf of the
+ U.S. government, the Government shall have only "Restricted Rights"
+ in the software and related documentation as defined in the Federal
+ Acquisition Regulations (FARs) in Clause 52.227.19 (c) (2). If you
+ are acquiring the software on behalf of the Department of Defense, the
+ software shall be classified as "Commercial Computer Software" and the
+ Government shall have only "Restricted Rights" as defined in Clause
+ 252.227-7013 (c) (1) of DFARs. Notwithstanding the foregoing, the
+ authors grant the U.S. Government and others acting in its behalf
+ permission to use and distribute the software in accordance with the
+ terms specified in this license.Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction, and
+ distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by the copyright
+ owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all other entities
+ that control, are controlled by, or are under common control with that entity.
+ For the purposes of this definition, "control" means (i) the power, direct or
+ indirect, to cause the direction or management of such entity, whether by
+ contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity exercising
+ permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications, including
+ but not limited to software source code, documentation source, and configuration
+ files.
+
+ "Object" form shall mean any form resulting from mechanical transformation or
+ translation of a Source form, including but not limited to compiled object code,
+ generated documentation, and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or Object form, made
+ available under the License, as indicated by a copyright notice that is included
+ in or attached to the work (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object form, that
+ is based on (or derived from) the Work and for which the editorial revisions,
+ annotations, elaborations, or other modifications represent, as a whole, an
+ original work of authorship. For the purposes of this License, Derivative Works
+ shall not include works that remain separable from, or merely link (or bind by
+ name) to the interfaces of, the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including the original version
+ of the Work and any modifications or additions to that Work or Derivative Works
+ thereof, that is intentionally submitted to Licensor for inclusion in the Work
+ by the copyright owner or by an individual or Legal Entity authorized to submit
+ on behalf of the copyright owner. For the purposes of this definition,
+ "submitted" means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems, and
+ issue tracking systems that are managed by, or on behalf of, the Licensor for
+ the purpose of discussing and improving the Work, but excluding communication
+ that is conspicuously marked or otherwise designated in writing by the copyright
+ owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity on behalf
+ of whom a Contribution has been received by Licensor and subsequently
+ incorporated within the Work.
+
+ 2. Grant of Copyright License.
+
+ Subject to the terms and conditions of this License, each Contributor hereby
+ grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+ irrevocable copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the Work and such
+ Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License.
+
+ Subject to the terms and conditions of this License, each Contributor hereby
+ grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+ irrevocable (except as stated in this section) patent license to make, have
+ made, use, offer to sell, sell, import, and otherwise transfer the Work, where
+ such license applies only to those patent claims licensable by such Contributor
+ that are necessarily infringed by their Contribution(s) alone or by combination
+ of their Contribution(s) with the Work to which such Contribution(s) was
+ submitted. If You institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work or a
+ Contribution incorporated within the Work constitutes direct or contributory
+ patent infringement, then any patent licenses granted to You under this License
+ for that Work shall terminate as of the date such litigation is filed.
+
+ 4. Redistribution.
+
+ You may reproduce and distribute copies of the Work or Derivative Works thereof
+ in any medium, with or without modifications, and in Source or Object form,
+ provided that You meet the following conditions:
+
+ You must give any other recipients of the Work or Derivative Works a copy of
+ this License; and
+ You must cause any modified files to carry prominent notices stating that You
+ changed the files; and
+ You must retain, in the Source form of any Derivative Works that You distribute,
+ all copyright, patent, trademark, and attribution notices from the Source form
+ of the Work, excluding those notices that do not pertain to any part of the
+ Derivative Works; and
+ If the Work includes a "NOTICE" text file as part of its distribution, then any
+ Derivative Works that You distribute must include a readable copy of the
+ attribution notices contained within such NOTICE file, excluding those notices
+ that do not pertain to any part of the Derivative Works, in at least one of the
+ following places: within a NOTICE text file distributed as part of the
+ Derivative Works; within the Source form or documentation, if provided along
+ with the Derivative Works; or, within a display generated by the Derivative
+ Works, if and wherever such third-party notices normally appear. The contents of
+ the NOTICE file are for informational purposes only and do not modify the
+ License. You may add Your own attribution notices within Derivative Works that
+ You distribute, alongside or as an addendum to the NOTICE text from the Work,
+ provided that such additional attribution notices cannot be construed as
+ modifying the License.
+ You may add Your own copyright statement to Your modifications and may provide
+ additional or different license terms and conditions for use, reproduction, or
+ distribution of Your modifications, or for any such Derivative Works as a whole,
+ provided Your use, reproduction, and distribution of the Work otherwise complies
+ with the conditions stated in this License.
+
+ 5. Submission of Contributions.
+
+ Unless You explicitly state otherwise, any Contribution intentionally submitted
+ for inclusion in the Work by You to the Licensor shall be under the terms and
+ conditions of this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify the terms of
+ any separate license agreement you may have executed with Licensor regarding
+ such Contributions.
+
+ 6. Trademarks.
+
+ This License does not grant permission to use the trade names, trademarks,
+ service marks, or product names of the Licensor, except as required for
+ reasonable and customary use in describing the origin of the Work and
+ reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty.
+
+ Unless required by applicable law or agreed to in writing, Licensor provides the
+ Work (and each Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,
+ including, without limitation, any warranties or conditions of TITLE,
+ NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are
+ solely responsible for determining the appropriateness of using or
+ redistributing the Work and assume any risks associated with Your exercise of
+ permissions under this License.
+
+ 8. Limitation of Liability.
+
+ In no event and under no legal theory, whether in tort (including negligence),
+ contract, or otherwise, unless required by applicable law (such as deliberate
+ and grossly negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special, incidental,
+ or consequential damages of any character arising as a result of this License or
+ out of the use or inability to use the Work (including but not limited to
+ damages for loss of goodwill, work stoppage, computer failure or malfunction, or
+ any and all other commercial damages or losses), even if such Contributor has
+ been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability.
+
+ While redistributing the Work or Derivative Works thereof, You may choose to
+ offer, and charge a fee for, acceptance of support, warranty, indemnity, or
+ other liability obligations and/or rights consistent with this License. However,
+ in accepting such obligations, You may act only on Your own behalf and on Your
+ sole responsibility, not on behalf of any other Contributor, and only if You
+ agree to indemnify, defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason of your
+ accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work
+
+ To apply the Apache License to your work, attach the following boilerplate
+ notice, with the fields enclosed by brackets "[]" replaced with your own
+ identifying information. (Don't include the brackets!) The text should be
+ enclosed in the appropriate comment syntax for the file format. We also
+ recommend that a file or class name and description of purpose be included on
+ the same "printed page" as the copyright notice for easier identification within
+ third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Cython
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Project-URL: Homepage, https://pandas.pydata.org
+Project-URL: Documentation, https://pandas.pydata.org/docs/
+Project-URL: Repository, https://github.com/pandas-dev/pandas
+Requires-Python: >=3.9
+Requires-Dist: numpy>=1.22.4; python_version < "3.11"
+Requires-Dist: numpy>=1.23.2; python_version == "3.11"
+Requires-Dist: numpy>=1.26.0; python_version >= "3.12"
+Requires-Dist: python-dateutil>=2.8.2
+Requires-Dist: pytz>=2020.1
+Requires-Dist: tzdata>=2022.7
+Requires-Dist: hypothesis>=6.46.1; extra == "test"
+Requires-Dist: pytest>=7.3.2; extra == "test"
+Requires-Dist: pytest-xdist>=2.2.0; extra == "test"
+Requires-Dist: pyarrow>=10.0.1; extra == "pyarrow"
+Requires-Dist: bottleneck>=1.3.6; extra == "performance"
+Requires-Dist: numba>=0.56.4; extra == "performance"
+Requires-Dist: numexpr>=2.8.4; extra == "performance"
+Requires-Dist: scipy>=1.10.0; extra == "computation"
+Requires-Dist: xarray>=2022.12.0; extra == "computation"
+Requires-Dist: fsspec>=2022.11.0; extra == "fss"
+Requires-Dist: s3fs>=2022.11.0; extra == "aws"
+Requires-Dist: gcsfs>=2022.11.0; extra == "gcp"
+Requires-Dist: pandas-gbq>=0.19.0; extra == "gcp"
+Requires-Dist: odfpy>=1.4.1; extra == "excel"
+Requires-Dist: openpyxl>=3.1.0; extra == "excel"
+Requires-Dist: python-calamine>=0.1.7; extra == "excel"
+Requires-Dist: pyxlsb>=1.0.10; extra == "excel"
+Requires-Dist: xlrd>=2.0.1; extra == "excel"
+Requires-Dist: xlsxwriter>=3.0.5; extra == "excel"
+Requires-Dist: pyarrow>=10.0.1; extra == "parquet"
+Requires-Dist: pyarrow>=10.0.1; extra == "feather"
+Requires-Dist: tables>=3.8.0; extra == "hdf5"
+Requires-Dist: pyreadstat>=1.2.0; extra == "spss"
+Requires-Dist: SQLAlchemy>=2.0.0; extra == "postgresql"
+Requires-Dist: psycopg2>=2.9.6; extra == "postgresql"
+Requires-Dist: adbc-driver-postgresql>=0.8.0; extra == "postgresql"
+Requires-Dist: SQLAlchemy>=2.0.0; extra == "mysql"
+Requires-Dist: pymysql>=1.0.2; extra == "mysql"
+Requires-Dist: SQLAlchemy>=2.0.0; extra == "sql-other"
+Requires-Dist: adbc-driver-postgresql>=0.8.0; extra == "sql-other"
+Requires-Dist: adbc-driver-sqlite>=0.8.0; extra == "sql-other"
+Requires-Dist: beautifulsoup4>=4.11.2; extra == "html"
+Requires-Dist: html5lib>=1.1; extra == "html"
+Requires-Dist: lxml>=4.9.2; extra == "html"
+Requires-Dist: lxml>=4.9.2; extra == "xml"
+Requires-Dist: matplotlib>=3.6.3; extra == "plot"
+Requires-Dist: jinja2>=3.1.2; extra == "output-formatting"
+Requires-Dist: tabulate>=0.9.0; extra == "output-formatting"
+Requires-Dist: PyQt5>=5.15.9; extra == "clipboard"
+Requires-Dist: qtpy>=2.3.0; extra == "clipboard"
+Requires-Dist: zstandard>=0.19.0; extra == "compression"
+Requires-Dist: dataframe-api-compat>=0.1.7; extra == "consortium-standard"
+Requires-Dist: adbc-driver-postgresql>=0.8.0; extra == "all"
+Requires-Dist: adbc-driver-sqlite>=0.8.0; extra == "all"
+Requires-Dist: beautifulsoup4>=4.11.2; extra == "all"
+Requires-Dist: bottleneck>=1.3.6; extra == "all"
+Requires-Dist: dataframe-api-compat>=0.1.7; extra == "all"
+Requires-Dist: fastparquet>=2022.12.0; extra == "all"
+Requires-Dist: fsspec>=2022.11.0; extra == "all"
+Requires-Dist: gcsfs>=2022.11.0; extra == "all"
+Requires-Dist: html5lib>=1.1; extra == "all"
+Requires-Dist: hypothesis>=6.46.1; extra == "all"
+Requires-Dist: jinja2>=3.1.2; extra == "all"
+Requires-Dist: lxml>=4.9.2; extra == "all"
+Requires-Dist: matplotlib>=3.6.3; extra == "all"
+Requires-Dist: numba>=0.56.4; extra == "all"
+Requires-Dist: numexpr>=2.8.4; extra == "all"
+Requires-Dist: odfpy>=1.4.1; extra == "all"
+Requires-Dist: openpyxl>=3.1.0; extra == "all"
+Requires-Dist: pandas-gbq>=0.19.0; extra == "all"
+Requires-Dist: psycopg2>=2.9.6; extra == "all"
+Requires-Dist: pyarrow>=10.0.1; extra == "all"
+Requires-Dist: pymysql>=1.0.2; extra == "all"
+Requires-Dist: PyQt5>=5.15.9; extra == "all"
+Requires-Dist: pyreadstat>=1.2.0; extra == "all"
+Requires-Dist: pytest>=7.3.2; extra == "all"
+Requires-Dist: pytest-xdist>=2.2.0; extra == "all"
+Requires-Dist: python-calamine>=0.1.7; extra == "all"
+Requires-Dist: pyxlsb>=1.0.10; extra == "all"
+Requires-Dist: qtpy>=2.3.0; extra == "all"
+Requires-Dist: scipy>=1.10.0; extra == "all"
+Requires-Dist: s3fs>=2022.11.0; extra == "all"
+Requires-Dist: SQLAlchemy>=2.0.0; extra == "all"
+Requires-Dist: tables>=3.8.0; extra == "all"
+Requires-Dist: tabulate>=0.9.0; extra == "all"
+Requires-Dist: xarray>=2022.12.0; extra == "all"
+Requires-Dist: xlrd>=2.0.1; extra == "all"
+Requires-Dist: xlsxwriter>=3.0.5; extra == "all"
+Requires-Dist: zstandard>=0.19.0; extra == "all"
+Provides-Extra: test
+Provides-Extra: pyarrow
+Provides-Extra: performance
+Provides-Extra: computation
+Provides-Extra: fss
+Provides-Extra: aws
+Provides-Extra: gcp
+Provides-Extra: excel
+Provides-Extra: parquet
+Provides-Extra: feather
+Provides-Extra: hdf5
+Provides-Extra: spss
+Provides-Extra: postgresql
+Provides-Extra: mysql
+Provides-Extra: sql-other
+Provides-Extra: html
+Provides-Extra: xml
+Provides-Extra: plot
+Provides-Extra: output-formatting
+Provides-Extra: clipboard
+Provides-Extra: compression
+Provides-Extra: consortium-standard
+Provides-Extra: all
+Description-Content-Type: text/markdown
+
+
+ 
+
+
+-----------------
+
+# pandas: powerful Python data analysis toolkit
+
+| | |
+| --- | --- |
+| Testing | [](https://github.com/pandas-dev/pandas/actions/workflows/unit-tests.yml) [](https://codecov.io/gh/pandas-dev/pandas) |
+| Package | [](https://pypi.org/project/pandas/) [](https://pypi.org/project/pandas/) [](https://anaconda.org/conda-forge/pandas) [](https://anaconda.org/conda-forge/pandas) |
+| Meta | [](https://numfocus.org) [](https://doi.org/10.5281/zenodo.3509134) [](https://github.com/pandas-dev/pandas/blob/main/LICENSE) [](https://pandas.pydata.org/docs/dev/development/community.html?highlight=slack#community-slack) |
+
+
+## What is it?
+
+**pandas** is a Python package that provides fast, flexible, and expressive data
+structures designed to make working with "relational" or "labeled" data both
+easy and intuitive. It aims to be the fundamental high-level building block for
+doing practical, **real world** data analysis in Python. Additionally, it has
+the broader goal of becoming **the most powerful and flexible open source data
+analysis / manipulation tool available in any language**. It is already well on
+its way towards this goal.
+
+## Table of Contents
+
+- [Main Features](#main-features)
+- [Where to get it](#where-to-get-it)
+- [Dependencies](#dependencies)
+- [Installation from sources](#installation-from-sources)
+- [License](#license)
+- [Documentation](#documentation)
+- [Background](#background)
+- [Getting Help](#getting-help)
+- [Discussion and Development](#discussion-and-development)
+- [Contributing to pandas](#contributing-to-pandas)
+
+## Main Features
+Here are just a few of the things that pandas does well:
+
+ - Easy handling of [**missing data**][missing-data] (represented as
+ `NaN`, `NA`, or `NaT`) in floating point as well as non-floating point data
+ - Size mutability: columns can be [**inserted and
+ deleted**][insertion-deletion] from DataFrame and higher dimensional
+ objects
+ - Automatic and explicit [**data alignment**][alignment]: objects can
+ be explicitly aligned to a set of labels, or the user can simply
+ ignore the labels and let `Series`, `DataFrame`, etc. automatically
+ align the data for you in computations
+ - Powerful, flexible [**group by**][groupby] functionality to perform
+ split-apply-combine operations on data sets, for both aggregating
+ and transforming data
+ - Make it [**easy to convert**][conversion] ragged,
+ differently-indexed data in other Python and NumPy data structures
+ into DataFrame objects
+ - Intelligent label-based [**slicing**][slicing], [**fancy
+ indexing**][fancy-indexing], and [**subsetting**][subsetting] of
+ large data sets
+ - Intuitive [**merging**][merging] and [**joining**][joining] data
+ sets
+ - Flexible [**reshaping**][reshape] and [**pivoting**][pivot-table] of
+ data sets
+ - [**Hierarchical**][mi] labeling of axes (possible to have multiple
+ labels per tick)
+ - Robust IO tools for loading data from [**flat files**][flat-files]
+ (CSV and delimited), [**Excel files**][excel], [**databases**][db],
+ and saving/loading data from the ultrafast [**HDF5 format**][hdfstore]
+ - [**Time series**][timeseries]-specific functionality: date range
+ generation and frequency conversion, moving window statistics,
+ date shifting and lagging
+
+
+ [missing-data]: https://pandas.pydata.org/pandas-docs/stable/user_guide/missing_data.html
+ [insertion-deletion]: https://pandas.pydata.org/pandas-docs/stable/user_guide/dsintro.html#column-selection-addition-deletion
+ [alignment]: https://pandas.pydata.org/pandas-docs/stable/user_guide/dsintro.html?highlight=alignment#intro-to-data-structures
+ [groupby]: https://pandas.pydata.org/pandas-docs/stable/user_guide/groupby.html#group-by-split-apply-combine
+ [conversion]: https://pandas.pydata.org/pandas-docs/stable/user_guide/dsintro.html#dataframe
+ [slicing]: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#slicing-ranges
+ [fancy-indexing]: https://pandas.pydata.org/pandas-docs/stable/user_guide/advanced.html#advanced
+ [subsetting]: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#boolean-indexing
+ [merging]: https://pandas.pydata.org/pandas-docs/stable/user_guide/merging.html#database-style-dataframe-or-named-series-joining-merging
+ [joining]: https://pandas.pydata.org/pandas-docs/stable/user_guide/merging.html#joining-on-index
+ [reshape]: https://pandas.pydata.org/pandas-docs/stable/user_guide/reshaping.html
+ [pivot-table]: https://pandas.pydata.org/pandas-docs/stable/user_guide/reshaping.html
+ [mi]: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#hierarchical-indexing-multiindex
+ [flat-files]: https://pandas.pydata.org/pandas-docs/stable/user_guide/io.html#csv-text-files
+ [excel]: https://pandas.pydata.org/pandas-docs/stable/user_guide/io.html#excel-files
+ [db]: https://pandas.pydata.org/pandas-docs/stable/user_guide/io.html#sql-queries
+ [hdfstore]: https://pandas.pydata.org/pandas-docs/stable/user_guide/io.html#hdf5-pytables
+ [timeseries]: https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#time-series-date-functionality
+
+## Where to get it
+The source code is currently hosted on GitHub at:
+https://github.com/pandas-dev/pandas
+
+Binary installers for the latest released version are available at the [Python
+Package Index (PyPI)](https://pypi.org/project/pandas) and on [Conda](https://docs.conda.io/en/latest/).
+
+```sh
+# conda
+conda install -c conda-forge pandas
+```
+
+```sh
+# or PyPI
+pip install pandas
+```
+
+The list of changes to pandas between each release can be found
+[here](https://pandas.pydata.org/pandas-docs/stable/whatsnew/index.html). For full
+details, see the commit logs at https://github.com/pandas-dev/pandas.
+
+## Dependencies
+- [NumPy - Adds support for large, multi-dimensional arrays, matrices and high-level mathematical functions to operate on these arrays](https://www.numpy.org)
+- [python-dateutil - Provides powerful extensions to the standard datetime module](https://dateutil.readthedocs.io/en/stable/index.html)
+- [pytz - Brings the Olson tz database into Python which allows accurate and cross platform timezone calculations](https://github.com/stub42/pytz)
+
+See the [full installation instructions](https://pandas.pydata.org/pandas-docs/stable/install.html#dependencies) for minimum supported versions of required, recommended and optional dependencies.
+
+## Installation from sources
+To install pandas from source you need [Cython](https://cython.org/) in addition to the normal
+dependencies above. Cython can be installed from PyPI:
+
+```sh
+pip install cython
+```
+
+In the `pandas` directory (same one where you found this file after
+cloning the git repo), execute:
+
+```sh
+pip install .
+```
+
+or for installing in [development mode](https://pip.pypa.io/en/latest/cli/pip_install/#install-editable):
+
+
+```sh
+python -m pip install -ve . --no-build-isolation --config-settings=editable-verbose=true
+```
+
+See the full instructions for [installing from source](https://pandas.pydata.org/docs/dev/development/contributing_environment.html).
+
+## License
+[BSD 3](LICENSE)
+
+## Documentation
+The official documentation is hosted on [PyData.org](https://pandas.pydata.org/pandas-docs/stable/).
+
+## Background
+Work on ``pandas`` started at [AQR](https://www.aqr.com/) (a quantitative hedge fund) in 2008 and
+has been under active development since then.
+
+## Getting Help
+
+For usage questions, the best place to go to is [StackOverflow](https://stackoverflow.com/questions/tagged/pandas).
+Further, general questions and discussions can also take place on the [pydata mailing list](https://groups.google.com/forum/?fromgroups#!forum/pydata).
+
+## Discussion and Development
+Most development discussions take place on GitHub in this repo, via the [GitHub issue tracker](https://github.com/pandas-dev/pandas/issues).
+
+Further, the [pandas-dev mailing list](https://mail.python.org/mailman/listinfo/pandas-dev) can also be used for specialized discussions or design issues, and a [Slack channel](https://pandas.pydata.org/docs/dev/development/community.html?highlight=slack#community-slack) is available for quick development related questions.
+
+There are also frequent [community meetings](https://pandas.pydata.org/docs/dev/development/community.html#community-meeting) for project maintainers open to the community as well as monthly [new contributor meetings](https://pandas.pydata.org/docs/dev/development/community.html#new-contributor-meeting) to help support new contributors.
+
+Additional information on the communication channels can be found on the [contributor community](https://pandas.pydata.org/docs/development/community.html) page.
+
+## Contributing to pandas
+
+[](https://www.codetriage.com/pandas-dev/pandas)
+
+All contributions, bug reports, bug fixes, documentation improvements, enhancements, and ideas are welcome.
+
+A detailed overview on how to contribute can be found in the **[contributing guide](https://pandas.pydata.org/docs/dev/development/contributing.html)**.
+
+If you are simply looking to start working with the pandas codebase, navigate to the [GitHub "issues" tab](https://github.com/pandas-dev/pandas/issues) and start looking through interesting issues. There are a number of issues listed under [Docs](https://github.com/pandas-dev/pandas/issues?labels=Docs&sort=updated&state=open) and [good first issue](https://github.com/pandas-dev/pandas/issues?labels=good+first+issue&sort=updated&state=open) where you could start out.
+
+You can also triage issues which may include reproducing bug reports, or asking for vital information such as version numbers or reproduction instructions. If you would like to start triaging issues, one easy way to get started is to [subscribe to pandas on CodeTriage](https://www.codetriage.com/pandas-dev/pandas).
+
+Or maybe through using pandas you have an idea of your own or are looking for something in the documentation and thinking ‘this can be improved’...you can do something about it!
+
+Feel free to ask questions on the [mailing list](https://groups.google.com/forum/?fromgroups#!forum/pydata) or on [Slack](https://pandas.pydata.org/docs/dev/development/community.html?highlight=slack#community-slack).
+
+As contributors and maintainers to this project, you are expected to abide by pandas' code of conduct. More information can be found at: [Contributor Code of Conduct](https://github.com/pandas-dev/.github/blob/master/CODE_OF_CONDUCT.md)
+
+
+
+[Go to Top](#table-of-contents)
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas-2.2.3.dist-info/RECORD b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas-2.2.3.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..a65bf4b290db15b16949b8ae032b1bc1359ff01d
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas-2.2.3.dist-info/RECORD
@@ -0,0 +1,2922 @@
+pandas-2.2.3.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+pandas-2.2.3.dist-info/LICENSE,sha256=HeougO0cvQIz-EzuRIaylonxM7q6zPTSleUcQwUfMhY,62399
+pandas-2.2.3.dist-info/METADATA,sha256=8FQjE5gG0NddUnq6QmiSYAhNx6La0fTzKxZ3D5fR9w8,89901
+pandas-2.2.3.dist-info/RECORD,,
+pandas-2.2.3.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas-2.2.3.dist-info/WHEEL,sha256=3qIDcXCk577AXiK3pDifO-gE9U_MYWYGgtD78gLa2_U,137
+pandas-2.2.3.dist-info/entry_points.txt,sha256=OVLKNEPs-Q7IWypWBL6fxv56_zt4sRnEI7zawo6y_0w,69
+pandas/__init__.py,sha256=EIvoyjrhoqXHZe5vh-iGfYfC-1qJEH5sLTpqzJZhK3s,8658
+pandas/__pycache__/__init__.cpython-312.pyc,,
+pandas/__pycache__/_typing.cpython-312.pyc,,
+pandas/__pycache__/_version.cpython-312.pyc,,
+pandas/__pycache__/_version_meson.cpython-312.pyc,,
+pandas/__pycache__/conftest.cpython-312.pyc,,
+pandas/__pycache__/testing.cpython-312.pyc,,
+pandas/_config/__init__.py,sha256=hdg_O-v73cCSrIj6uLoz1NRxgYtOILOs8mOPKdDoEUk,1437
+pandas/_config/__pycache__/__init__.cpython-312.pyc,,
+pandas/_config/__pycache__/config.cpython-312.pyc,,
+pandas/_config/__pycache__/dates.cpython-312.pyc,,
+pandas/_config/__pycache__/display.cpython-312.pyc,,
+pandas/_config/__pycache__/localization.cpython-312.pyc,,
+pandas/_config/config.py,sha256=YwadTnEN93OFAxyzW289d_v4dhWLzxpMHGZrl3xt_XY,25454
+pandas/_config/dates.py,sha256=HgZFPT02hugJO7uhSTjwebcKOd34JkcYY2gSPtOydmg,668
+pandas/_config/display.py,sha256=xv_TetWUhFlVpog23QzyhMYsScops_OOsWIAGnmKdJ8,1804
+pandas/_config/localization.py,sha256=79Q2KU1aHxX6Q8Wn8EGOEUAyv3XIjQ4YaTaEzeFbtwM,5190
+pandas/_libs/__init__.py,sha256=6i-pdZncVhiCRL_ChKyrTLNhn14aDbsYw243-PfAnJQ,673
+pandas/_libs/__pycache__/__init__.cpython-312.pyc,,
+pandas/_libs/algos.cpython-312-x86_64-linux-gnu.so,sha256=xTDe0_dupqafEITA6-mnNYlkI4uUPlGFXqTQDuGwxZU,2103944
+pandas/_libs/algos.pyi,sha256=KEF48zZLn3TSUCmd8thdo4DzYvJ5zaCK60hYX6nzyZI,15182
+pandas/_libs/arrays.cpython-312-x86_64-linux-gnu.so,sha256=y4U0L-G0vDA5w12BAW1vZVucuDIF9zw_J7yWhaKaCAc,133152
+pandas/_libs/arrays.pyi,sha256=PfpeOMplxyN2vbfFCdkkSKGCg21SFRydvqBdeJhBVqQ,1105
+pandas/_libs/byteswap.cpython-312-x86_64-linux-gnu.so,sha256=v26KD8OjLlAe8z3JQH2Q6mik1Hxn2GWx-RRyt4bamt8,61696
+pandas/_libs/byteswap.pyi,sha256=SxL2I1rKqe73WZgkO511PWJx20P160V4hrws1TG0JTk,423
+pandas/_libs/groupby.cpython-312-x86_64-linux-gnu.so,sha256=72Y6FP5obQmJC6qwTtLpRE2r6mdUpqefbcBSmY8cyCU,2654792
+pandas/_libs/groupby.pyi,sha256=Q-jrhgZskMvXOhpHP6EhPhutdW4zAoNI2TQ7iE_68qc,7251
+pandas/_libs/hashing.cpython-312-x86_64-linux-gnu.so,sha256=rKDVkmOl-_nUEUktGoG1_me6tSh9Ndm0Zu_rIKS8k6M,213000
+pandas/_libs/hashing.pyi,sha256=cdNwppEilaMnVN77ABt3TBadjUawMtMFgSQb1PCqwQk,181
+pandas/_libs/hashtable.cpython-312-x86_64-linux-gnu.so,sha256=YWtGFY29Cu6Tu8cHhhQ6Ga_M0EfNjzG-KcUibyNGqT0,2165256
+pandas/_libs/hashtable.pyi,sha256=jBv8QuQii-ikWklP76_DPCYfms88fpj6pPOaCOK6s0M,7424
+pandas/_libs/index.cpython-312-x86_64-linux-gnu.so,sha256=t0iDHnQqvQGqBJj7xXSJHd6p6Ch5UXvF-GHm6IdTBLs,934728
+pandas/_libs/index.pyi,sha256=w3sVStmL_0qAt8C_OyGXSyzugtcnELzL7ZJuCiTHXzY,3695
+pandas/_libs/indexing.cpython-312-x86_64-linux-gnu.so,sha256=Z06bjXHYzRkaZZAwmqkCwhGZMGj7Q9pIeXwd-KmfBtM,70656
+pandas/_libs/indexing.pyi,sha256=hlJwakbofPRdt1Lm31bfQ3CvHW-nMxm0nrInSWAey58,427
+pandas/_libs/internals.cpython-312-x86_64-linux-gnu.so,sha256=z-L_Y98xCFmos0XCdB-97exLQCLj20ll4FJ3Uspcfn0,403272
+pandas/_libs/internals.pyi,sha256=1zfOoULlHvpbbRHvPlcrV_kbY7WI3qEXYExbENEDdtE,2761
+pandas/_libs/interval.cpython-312-x86_64-linux-gnu.so,sha256=M0C3wZvrNOqRd2pFDHuiGMtEaodAY_x5nGZ-mavhvTI,1442344
+pandas/_libs/interval.pyi,sha256=cotxOfoqp7DX7XgIeKrGd31mfAeNerW1WD-yBrLfTlE,5378
+pandas/_libs/join.cpython-312-x86_64-linux-gnu.so,sha256=X85LKMPK-w6oWxZ-3fHe_G6vY3YKRbC32czyuAjr4BM,1368968
+pandas/_libs/join.pyi,sha256=O61ZOIYi-I3gZJjDpLYIWWEe3iG0pogEQIB0ZxJ_E3Y,2780
+pandas/_libs/json.cpython-312-x86_64-linux-gnu.so,sha256=-n-TUHdXhkMJo3ul5kD8YWVsB0lD7EXlTHKu8732rH0,64272
+pandas/_libs/json.pyi,sha256=kbqlmh7HTk4cc2hIDWdXZSFqOfh0cqGpBwcys3m32XM,496
+pandas/_libs/lib.cpython-312-x86_64-linux-gnu.so,sha256=Zo8SLBy8fN7XV3BydNM18wGs489M6IzD2XR21RhWOCA,896648
+pandas/_libs/lib.pyi,sha256=CjVLZ1Jm6BKylmgNXq4YZxMNS1_ITw_paZznoH27S4g,7103
+pandas/_libs/missing.cpython-312-x86_64-linux-gnu.so,sha256=JkW4lkkTlmRLaUFI_8N2CjKaUpyfdrvl3czFB8bgQh0,203208
+pandas/_libs/missing.pyi,sha256=iIftmSeHBcfgz7d9JWW_FQcyyAkuBzRiSnZw690OhDw,524
+pandas/_libs/ops.cpython-312-x86_64-linux-gnu.so,sha256=xqTBrtwiwaQZHB4c1TzyfiF96CDC1AXmLSWZu1FI3Dg,258184
+pandas/_libs/ops.pyi,sha256=99NSmMUkneVNWOojl8Dsb8GmbUa5y_uhKUtfIgwgwek,1318
+pandas/_libs/ops_dispatch.cpython-312-x86_64-linux-gnu.so,sha256=1zJMUSOcjlXnhY6YNkIIJwg7-6VCf-QUq26cTiWbsYk,65760
+pandas/_libs/ops_dispatch.pyi,sha256=Yxq3SUJ-qoMZ8ErL7wfHfCsTTcETOuu0FuoCOyhmGl0,124
+pandas/_libs/pandas_datetime.cpython-312-x86_64-linux-gnu.so,sha256=jWjmNIAnEL724kP-qwBEMIsFoXqEn4t1uCTZoz7G0zI,39264
+pandas/_libs/pandas_parser.cpython-312-x86_64-linux-gnu.so,sha256=wUiIvOmmwIZahqWgTCc97a0L9Sec33Y4FSEc4OmDkv0,43424
+pandas/_libs/parsers.cpython-312-x86_64-linux-gnu.so,sha256=XlbVWtuH07eT2rPBFWFjoydgJ2vJ-7ibEQBbVqR3c-8,574248
+pandas/_libs/parsers.pyi,sha256=raoGhPLoRKLQAthm9JQT5rTjLR1PGFDS179aqtQdgnY,2378
+pandas/_libs/properties.cpython-312-x86_64-linux-gnu.so,sha256=iJvKzkSimQmCeRZ5a6lL6wCFPyxV5ks6mOoz1Y2fv_g,96000
+pandas/_libs/properties.pyi,sha256=HF93vy5OSNtQKz5NL_zwTnOj6tzBtW9Cog-5Zk2bnAA,717
+pandas/_libs/reshape.cpython-312-x86_64-linux-gnu.so,sha256=OwnEa9ehZBC8xpJXKmxxG_lAOfUH6yf9MvsWL4Ax7SA,338312
+pandas/_libs/reshape.pyi,sha256=xaU-NNnRhXVT9AVrksVXrbKfAC7Ny9p-Vwp6srRoGns,419
+pandas/_libs/sas.cpython-312-x86_64-linux-gnu.so,sha256=U7WKqfq6_Z1ESzrTqNdSK6WLr0otYEjimsIKmznUSeQ,263016
+pandas/_libs/sas.pyi,sha256=qkrJiuBd7GQbw3DQyhH9M6cMfNSkovArOXRdhJ8PFDA,224
+pandas/_libs/sparse.cpython-312-x86_64-linux-gnu.so,sha256=trkvbztemlYDWdWymmF_O4Jge7OHxQYUf9MfYnVQOmE,919176
+pandas/_libs/sparse.pyi,sha256=Yyi7QHpAt7K6l2iEhxgufRqbvSRfYpBHeC_hJaSK8Ho,1485
+pandas/_libs/testing.cpython-312-x86_64-linux-gnu.so,sha256=QZzCsTsr7SsEKjLIaA90sj5YYksqSLzoxujTrl3NyYQ,135616
+pandas/_libs/testing.pyi,sha256=_fpEWiBmlWGR_3QUj1RU42WCTtW2Ug-EXHpM-kP6vB0,243
+pandas/_libs/tslib.cpython-312-x86_64-linux-gnu.so,sha256=mkYI7aKc9GzgvJr9b3JQglh1xCL35dgMdoRLPd-tPF4,327944
+pandas/_libs/tslib.pyi,sha256=aWJDfzlbmlF6sAst1BTMKMcWt3me50-sqCS5YwWt0HI,969
+pandas/_libs/tslibs/__init__.py,sha256=dowITNV3Gxq8wB3XdqiyRCtEDn83_GkLcGJiQnzM1mA,2125
+pandas/_libs/tslibs/__pycache__/__init__.cpython-312.pyc,,
+pandas/_libs/tslibs/base.cpython-312-x86_64-linux-gnu.so,sha256=2h3qE1GrVq5sqcwyX6fq6603lB2UXHuikgRHKE_-2Mg,66368
+pandas/_libs/tslibs/ccalendar.cpython-312-x86_64-linux-gnu.so,sha256=ZmkWZOrst3uvG_wCgD8JRD5_Ga1mKhWtRvFPWN8vDS8,106848
+pandas/_libs/tslibs/ccalendar.pyi,sha256=dizWWmYtxWa5Lc4Hv69iRaJoazRhegJaDGWYgWtJu-U,502
+pandas/_libs/tslibs/conversion.cpython-312-x86_64-linux-gnu.so,sha256=Wy1t5gWD3eth0tI-h4Lqup4pUeEpUyKgh3PE5Nw8Ktc,304104
+pandas/_libs/tslibs/conversion.pyi,sha256=sHO9CBRrDh0wovkr736kI5G6gaW1WY9tSOOAkBi63MA,300
+pandas/_libs/tslibs/dtypes.cpython-312-x86_64-linux-gnu.so,sha256=zTc-7lR2fvBhUNqkOGiHK7G_K5UlRYd-xZeX2xsILXY,202592
+pandas/_libs/tslibs/dtypes.pyi,sha256=ZNUPcAyhkkh7kIGLDIDTfUmwefbtdxxvn668YN-AAeE,1988
+pandas/_libs/tslibs/fields.cpython-312-x86_64-linux-gnu.so,sha256=IMXqVOLxVb9ag4k58qoK7vwQ_zzZ_2CS77veOxsWdmI,328712
+pandas/_libs/tslibs/fields.pyi,sha256=LOke0XZ9XJnzX2MC9nL3u-JpbmddBfpy0UQ_d-_NvN8,1860
+pandas/_libs/tslibs/nattype.cpython-312-x86_64-linux-gnu.so,sha256=nYx4WbNjUwHFpFb256WMJKJYJdg5HObWbVyFUI8YsLI,224896
+pandas/_libs/tslibs/nattype.pyi,sha256=R3qw7RgZFLG7IgKTssmJdjm-lP3V18GEz810nzVHsTs,4116
+pandas/_libs/tslibs/np_datetime.cpython-312-x86_64-linux-gnu.so,sha256=oMsgqV2Lei7GJRFWEN1Eld0IbwzzR2vW-xqFE6LjMEk,148064
+pandas/_libs/tslibs/np_datetime.pyi,sha256=Y6l1KVdyKTMiYfzOjXNwV946GjoFAHaCEEhLDsHRCxI,831
+pandas/_libs/tslibs/offsets.cpython-312-x86_64-linux-gnu.so,sha256=L6dxl_edwSoWo0Rnugo21RyznDDqemSo39mwo-lIoqU,1138272
+pandas/_libs/tslibs/offsets.pyi,sha256=QkYq2CgQ4aZ-92e_8wSpuxaACBIKjk2eI4-M-6wSeZU,8345
+pandas/_libs/tslibs/parsing.cpython-312-x86_64-linux-gnu.so,sha256=VkLOr4l1MrIOLyAVtCISyZ9yoE_At5V2Xxj8jUpPSZU,448808
+pandas/_libs/tslibs/parsing.pyi,sha256=cbS8tHb95ygwDU-9gNaFs83FpbVj8aoQfw7gwJGEE6o,914
+pandas/_libs/tslibs/period.cpython-312-x86_64-linux-gnu.so,sha256=rmJCyX0meJgP8X4iR4z3gwgwGpgAjkeITkCUurTj83c,519912
+pandas/_libs/tslibs/period.pyi,sha256=Bf0lYd6dh9O61Gq_TReVI4NcRf-5aINkdYJNDaq5az8,3908
+pandas/_libs/tslibs/strptime.cpython-312-x86_64-linux-gnu.so,sha256=T29cWee70A-jzMKHYDR6ac_lPQtJSdBc890-xSzpIfc,394056
+pandas/_libs/tslibs/strptime.pyi,sha256=dizASoJenvjCydaWDo72_FQmiNOjLmnCZbUZgCm8EnI,349
+pandas/_libs/tslibs/timedeltas.cpython-312-x86_64-linux-gnu.so,sha256=miRrU3Co3QcXbcedBx72GsdnIxlnuz4BN_zla5GQg8E,619176
+pandas/_libs/tslibs/timedeltas.pyi,sha256=6MW61MbVDqOH4JUQoR32z8qYUWRfPECV3fcQSrOkI_M,5009
+pandas/_libs/tslibs/timestamps.cpython-312-x86_64-linux-gnu.so,sha256=94APoupBDcrbhbIMW544eCVPeVFV9aFNGTtRtEYHlP8,640328
+pandas/_libs/tslibs/timestamps.pyi,sha256=zCu9cAbFf_IVDb1sf5j_Ww5LYSFzGVwMhpZZUP370kw,7831
+pandas/_libs/tslibs/timezones.cpython-312-x86_64-linux-gnu.so,sha256=SakZyICn4kWxhojo56-Eh8XMOUlznzs26acl0PsWj6w,282664
+pandas/_libs/tslibs/timezones.pyi,sha256=MZ9kC5E1J3XlVqyBwFuVd7NsqL8STztzT8W8NK-_2r0,600
+pandas/_libs/tslibs/tzconversion.cpython-312-x86_64-linux-gnu.so,sha256=K2CtRznaEQF9gxF-bW8lucIT02htvn01pO3lPGoh7_c,332680
+pandas/_libs/tslibs/tzconversion.pyi,sha256=MW4HtIKZpf7ZcOUQ4U6FL24BiJpASXI-mN0DOADtl10,560
+pandas/_libs/tslibs/vectorized.cpython-312-x86_64-linux-gnu.so,sha256=AlrzWUx5QT6FXF9kp2AUdDQMLj6JLxKMi0r-Et81de0,241576
+pandas/_libs/tslibs/vectorized.pyi,sha256=Dv5ryF4HiPZcHWMyxyfP4D_tONdqLm2Mn4MpVi5RKCc,1239
+pandas/_libs/window/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/_libs/window/__pycache__/__init__.cpython-312.pyc,,
+pandas/_libs/window/aggregations.cpython-312-x86_64-linux-gnu.so,sha256=jKkzAR5rwjnyNe50vZi0gO-wi-n5LYKBfC4aO6ChZWY,394264
+pandas/_libs/window/aggregations.pyi,sha256=vVjfgqY4cBPmjFadcrDc6heCiFbJ5Lz65bCadbHJbwU,4063
+pandas/_libs/window/indexers.cpython-312-x86_64-linux-gnu.so,sha256=ISau5eVdOoiJEfsx7ygO1fUidv_NUt06tUUV6ChHmiY,212936
+pandas/_libs/window/indexers.pyi,sha256=53aBxew7jBcAc9sbSoOlvpQHhiLDSWPXFcVbCeJDbQA,319
+pandas/_libs/writers.cpython-312-x86_64-linux-gnu.so,sha256=pLRPZww1rfePCwFh_r00GvWrNP57a6SDpFPxQH7YdGg,254856
+pandas/_libs/writers.pyi,sha256=RvwFCzrsU4RkKm7Mc3wo12RqdGdo-PuANkMo3Z9hLiU,516
+pandas/_testing/__init__.py,sha256=9-kM4agqo_qFFPSVACpl1zoM5D06biVAQUoDUK92Y0A,17554
+pandas/_testing/__pycache__/__init__.cpython-312.pyc,,
+pandas/_testing/__pycache__/_hypothesis.cpython-312.pyc,,
+pandas/_testing/__pycache__/_io.cpython-312.pyc,,
+pandas/_testing/__pycache__/_warnings.cpython-312.pyc,,
+pandas/_testing/__pycache__/asserters.cpython-312.pyc,,
+pandas/_testing/__pycache__/compat.cpython-312.pyc,,
+pandas/_testing/__pycache__/contexts.cpython-312.pyc,,
+pandas/_testing/_hypothesis.py,sha256=WS4ysEJwmMor02cwMw15kBtAR0SLvUUpTfYEpc0c6iI,2426
+pandas/_testing/_io.py,sha256=OwfQ9L0XZgD_Yfi5mF8_BLgPx8pgGZbTzq46uTa7jDo,4448
+pandas/_testing/_warnings.py,sha256=x7YMaPkmSaimJquGT3vAt9pKn0r_Hj5lE1uV0eCoDiU,8357
+pandas/_testing/asserters.py,sha256=nCygrO7daDLBmBtPpJyp87exFgT65accJYgQcjJhNB8,47201
+pandas/_testing/compat.py,sha256=0o_biVI-wLh7kcw9FHvbwYyzNvM0PI06QRD2ZhiD2Fs,658
+pandas/_testing/contexts.py,sha256=TmKKWG1VF-lZTz_6DUuUAbcW7ZqcQ59nVNUxNoLzz3g,6551
+pandas/_typing.py,sha256=gVSimiU46Dduc2Ez8ZaOczv8c-UHTH4FZeg6LL6mnGk,14037
+pandas/_version.py,sha256=yFQDRxMdgDLf9OmPX4d0cyT6tsYJEWLV4QgS5yuNgkE,23612
+pandas/_version_meson.py,sha256=LCx3vAY16LA5zd6bZeSfh2kVnOxvilsYwcRrvSgWEQk,79
+pandas/api/__init__.py,sha256=QnoYVW828TM17uq-3ELeethZm8XN2Y0DkEaTc3sLr3Q,219
+pandas/api/__pycache__/__init__.cpython-312.pyc,,
+pandas/api/extensions/__init__.py,sha256=O7tmzpvIT0uv9H5K-yMTKcwZpml9cEaB5CLVMiUkRCk,685
+pandas/api/extensions/__pycache__/__init__.cpython-312.pyc,,
+pandas/api/indexers/__init__.py,sha256=kNbZv9nja9iLVmGZU2D6w2dqB2ndsbqTfcsZsGz_Yo0,357
+pandas/api/indexers/__pycache__/__init__.cpython-312.pyc,,
+pandas/api/interchange/__init__.py,sha256=J2hQIYAvL7gyh8hG9r3XYPX69lK7nJS3IIHZl4FESjw,230
+pandas/api/interchange/__pycache__/__init__.cpython-312.pyc,,
+pandas/api/types/__init__.py,sha256=bOU3TUuskT12Dpp-SsCYtCWdHvBDp3MWf3Etq4ZMdT8,447
+pandas/api/types/__pycache__/__init__.cpython-312.pyc,,
+pandas/api/typing/__init__.py,sha256=IC4_ZmjsX4804Nnu-lQDccQr0zt5mzIZEaB3Bzdva8Y,1244
+pandas/api/typing/__pycache__/__init__.cpython-312.pyc,,
+pandas/arrays/__init__.py,sha256=gMhtojH1KdRwxMmM_Ulblxk4L09o7WLUsXLp6qdUS-I,1227
+pandas/arrays/__pycache__/__init__.cpython-312.pyc,,
+pandas/compat/__init__.py,sha256=kDGb_S-Lep8ZdS_-pGPINcrvoSPbj3x0hVVR1Z8pgy8,4280
+pandas/compat/__pycache__/__init__.cpython-312.pyc,,
+pandas/compat/__pycache__/_constants.cpython-312.pyc,,
+pandas/compat/__pycache__/_optional.cpython-312.pyc,,
+pandas/compat/__pycache__/compressors.cpython-312.pyc,,
+pandas/compat/__pycache__/pickle_compat.cpython-312.pyc,,
+pandas/compat/__pycache__/pyarrow.cpython-312.pyc,,
+pandas/compat/_constants.py,sha256=3_ryOkmiJTO-iTQAla_ApEJfp3V_lClbnepSM3Gi9S4,536
+pandas/compat/_optional.py,sha256=96Zlc2gqUYneSzSlraVRGfh2BsTWp4cOUcG2gHjw2E0,5089
+pandas/compat/compressors.py,sha256=GdDWdKzWqkImjdwzuVBwW2JvI7aMzpPV8QyhxWgJo0g,1975
+pandas/compat/numpy/__init__.py,sha256=UO-06Rj2g2Mk9rptXZG_fLtA3BhSPMVF4JhTLdSt5AM,1366
+pandas/compat/numpy/__pycache__/__init__.cpython-312.pyc,,
+pandas/compat/numpy/__pycache__/function.cpython-312.pyc,,
+pandas/compat/numpy/function.py,sha256=Qvflr9h4rYCw9o8I3RggkhdRqxvav1yioq_JeEUh2T4,13291
+pandas/compat/pickle_compat.py,sha256=MTp_LYeueJWVJBWKzWUyiwcwu9MvjEtBzEC0SozvWs8,7723
+pandas/compat/pyarrow.py,sha256=WzcKBzCsZapuUPMIUL7IVMiXm1L7yzA4QHv3CF5AuxI,1006
+pandas/conftest.py,sha256=dYirfwk99jRP_W1R20BvUz92mrqoWevlW3Zdfu9fQ5A,48625
+pandas/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/core/__pycache__/__init__.cpython-312.pyc,,
+pandas/core/__pycache__/accessor.cpython-312.pyc,,
+pandas/core/__pycache__/algorithms.cpython-312.pyc,,
+pandas/core/__pycache__/api.cpython-312.pyc,,
+pandas/core/__pycache__/apply.cpython-312.pyc,,
+pandas/core/__pycache__/arraylike.cpython-312.pyc,,
+pandas/core/__pycache__/base.cpython-312.pyc,,
+pandas/core/__pycache__/common.cpython-312.pyc,,
+pandas/core/__pycache__/config_init.cpython-312.pyc,,
+pandas/core/__pycache__/construction.cpython-312.pyc,,
+pandas/core/__pycache__/flags.cpython-312.pyc,,
+pandas/core/__pycache__/frame.cpython-312.pyc,,
+pandas/core/__pycache__/generic.cpython-312.pyc,,
+pandas/core/__pycache__/indexing.cpython-312.pyc,,
+pandas/core/__pycache__/missing.cpython-312.pyc,,
+pandas/core/__pycache__/nanops.cpython-312.pyc,,
+pandas/core/__pycache__/resample.cpython-312.pyc,,
+pandas/core/__pycache__/roperator.cpython-312.pyc,,
+pandas/core/__pycache__/sample.cpython-312.pyc,,
+pandas/core/__pycache__/series.cpython-312.pyc,,
+pandas/core/__pycache__/shared_docs.cpython-312.pyc,,
+pandas/core/__pycache__/sorting.cpython-312.pyc,,
+pandas/core/_numba/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/core/_numba/__pycache__/__init__.cpython-312.pyc,,
+pandas/core/_numba/__pycache__/executor.cpython-312.pyc,,
+pandas/core/_numba/__pycache__/extensions.cpython-312.pyc,,
+pandas/core/_numba/executor.py,sha256=vsH8jIzWRHho1Au4euWT2opfg5YLG4SBD7xlpvvXGUs,7530
+pandas/core/_numba/extensions.py,sha256=xRSojNahM3OPU28Bns1S4MXALqHKCmfK2SGleZhkm68,18374
+pandas/core/_numba/kernels/__init__.py,sha256=Z1t4IUC2MO0a5KbA0LurWfRZL4wNksHVBDLprGtPLlo,520
+pandas/core/_numba/kernels/__pycache__/__init__.cpython-312.pyc,,
+pandas/core/_numba/kernels/__pycache__/mean_.cpython-312.pyc,,
+pandas/core/_numba/kernels/__pycache__/min_max_.cpython-312.pyc,,
+pandas/core/_numba/kernels/__pycache__/shared.cpython-312.pyc,,
+pandas/core/_numba/kernels/__pycache__/sum_.cpython-312.pyc,,
+pandas/core/_numba/kernels/__pycache__/var_.cpython-312.pyc,,
+pandas/core/_numba/kernels/mean_.py,sha256=BesqY1gwFXPIeuXAQtDvvDBZuegsszFVTnl4lxguXEA,5646
+pandas/core/_numba/kernels/min_max_.py,sha256=tJ7OSKhne7jXpy4XSBpQS0tkP_0LggkH6iqWlxQ-FeE,3284
+pandas/core/_numba/kernels/shared.py,sha256=JUBa96LX4NmXhgXNyo859IwMXEl29EyhmRdMoQo1n78,611
+pandas/core/_numba/kernels/sum_.py,sha256=FeKOQl22qO6kN4hAmwmA3wXihrph5S03ucSt65GBquU,6488
+pandas/core/_numba/kernels/var_.py,sha256=5BaLdr7HKzdUvKvyifvL9qM36W16SAqk3Ny11OtpW9o,6973
+pandas/core/accessor.py,sha256=u57BIkm61_SNRzSdQjL210Jtil7BWFUB0HPNl9wCKdo,10044
+pandas/core/algorithms.py,sha256=8ENQpDWiM0ESh8EZEnXzw_XtbUUiFojvFi7MOZE16dY,55181
+pandas/core/api.py,sha256=9tm275sTpOKtdUvsFCXYQHmBdeJczGNBV1QGv3TQOOc,2911
+pandas/core/apply.py,sha256=TexZlMDp-LmxlCReQuHB4g_jCM-CHKD-NR9Fy_d5NUc,67345
+pandas/core/array_algos/__init__.py,sha256=8YLlO6TysEPxltfbNKdG9MlVXeDLfTIGNo2nUR-Zwl0,408
+pandas/core/array_algos/__pycache__/__init__.cpython-312.pyc,,
+pandas/core/array_algos/__pycache__/datetimelike_accumulations.cpython-312.pyc,,
+pandas/core/array_algos/__pycache__/masked_accumulations.cpython-312.pyc,,
+pandas/core/array_algos/__pycache__/masked_reductions.cpython-312.pyc,,
+pandas/core/array_algos/__pycache__/putmask.cpython-312.pyc,,
+pandas/core/array_algos/__pycache__/quantile.cpython-312.pyc,,
+pandas/core/array_algos/__pycache__/replace.cpython-312.pyc,,
+pandas/core/array_algos/__pycache__/take.cpython-312.pyc,,
+pandas/core/array_algos/__pycache__/transforms.cpython-312.pyc,,
+pandas/core/array_algos/datetimelike_accumulations.py,sha256=BCy87HXqI2WO0_cCGK-redvi2STJzCxswYYs06YdxB4,1686
+pandas/core/array_algos/masked_accumulations.py,sha256=PL-ZAMai7H1PIXLKE2f9LSL2Ow6WZqkusSQkFfIE8d4,2618
+pandas/core/array_algos/masked_reductions.py,sha256=iUFmp_Fu3-BXM0EBiFfiPERteITlIFFI7IEpHXVkvoY,4855
+pandas/core/array_algos/putmask.py,sha256=g02wtMt5MTIuT4IS6ukE1Eh8KWb3Hi932hc47dszqJ4,4593
+pandas/core/array_algos/quantile.py,sha256=zdzcwgoVRP3eBSM4NJHwocBJC3PINYN1jB02mJubFow,6548
+pandas/core/array_algos/replace.py,sha256=p8CdDslj7WwVNYjpLsT_36e8dmrxfeWzh5ECHe4uxCQ,3918
+pandas/core/array_algos/take.py,sha256=n_pjn9mU7QQJ77SFXogEc5ofoMqRgNbkimwXFunz79M,20815
+pandas/core/array_algos/transforms.py,sha256=TPpSPX5CiePVGTFUwnimpcC5YeBOtjAPK20wQvG92QI,1104
+pandas/core/arraylike.py,sha256=BD2ZQP4zGPd4rJas9lS5C-_qp3XXDL2udU8tzD9bQIQ,17655
+pandas/core/arrays/__init__.py,sha256=dE6WRTblcq40JKhXJQDsOwvhFPJstj_8cegiLthH0ks,1314
+pandas/core/arrays/__pycache__/__init__.cpython-312.pyc,,
+pandas/core/arrays/__pycache__/_arrow_string_mixins.cpython-312.pyc,,
+pandas/core/arrays/__pycache__/_mixins.cpython-312.pyc,,
+pandas/core/arrays/__pycache__/_ranges.cpython-312.pyc,,
+pandas/core/arrays/__pycache__/_utils.cpython-312.pyc,,
+pandas/core/arrays/__pycache__/base.cpython-312.pyc,,
+pandas/core/arrays/__pycache__/boolean.cpython-312.pyc,,
+pandas/core/arrays/__pycache__/categorical.cpython-312.pyc,,
+pandas/core/arrays/__pycache__/datetimelike.cpython-312.pyc,,
+pandas/core/arrays/__pycache__/datetimes.cpython-312.pyc,,
+pandas/core/arrays/__pycache__/floating.cpython-312.pyc,,
+pandas/core/arrays/__pycache__/integer.cpython-312.pyc,,
+pandas/core/arrays/__pycache__/interval.cpython-312.pyc,,
+pandas/core/arrays/__pycache__/masked.cpython-312.pyc,,
+pandas/core/arrays/__pycache__/numeric.cpython-312.pyc,,
+pandas/core/arrays/__pycache__/numpy_.cpython-312.pyc,,
+pandas/core/arrays/__pycache__/period.cpython-312.pyc,,
+pandas/core/arrays/__pycache__/string_.cpython-312.pyc,,
+pandas/core/arrays/__pycache__/string_arrow.cpython-312.pyc,,
+pandas/core/arrays/__pycache__/timedeltas.cpython-312.pyc,,
+pandas/core/arrays/_arrow_string_mixins.py,sha256=EaRHU4W7E3cOVkXhdp7wT2UGFD_FI9HYIzf26BBtleE,2608
+pandas/core/arrays/_mixins.py,sha256=NxUqWabMVxhv85tKqBu8JAAptApEq_avk6wbnN46xtI,17396
+pandas/core/arrays/_ranges.py,sha256=Ig3E_ROJ5mbOtK639SJ0UqcI229BrtsAfa_avbqrO8g,6996
+pandas/core/arrays/_utils.py,sha256=RmwOy6xNhgZ61qmk_PFnQ5sW-RVrkOhsl4AvQyqOuAY,1901
+pandas/core/arrays/arrow/__init__.py,sha256=-EKwaHww-yrbm7Z5d3AN_KETWmXYgZ2dW6KHaE2iiLI,221
+pandas/core/arrays/arrow/__pycache__/__init__.cpython-312.pyc,,
+pandas/core/arrays/arrow/__pycache__/_arrow_utils.cpython-312.pyc,,
+pandas/core/arrays/arrow/__pycache__/accessors.cpython-312.pyc,,
+pandas/core/arrays/arrow/__pycache__/array.cpython-312.pyc,,
+pandas/core/arrays/arrow/__pycache__/extension_types.cpython-312.pyc,,
+pandas/core/arrays/arrow/_arrow_utils.py,sha256=KjsV7ts963RSyNEGLGQliypzHJ_hs3mTslWPMXZpGpE,2151
+pandas/core/arrays/arrow/accessors.py,sha256=XxV7NzS1PHca7-Feesus0W8K3HwUHa-aSIIawdCTE8g,13863
+pandas/core/arrays/arrow/array.py,sha256=foZ2kgb9oYx_tx2PhreM_c3THxTy_f6ZdpKPCejU93E,102796
+pandas/core/arrays/arrow/extension_types.py,sha256=NJLTuf_8U8u-Fjt_qfWm7zhUtPQdvjH1JV8fY3oRv-Y,5459
+pandas/core/arrays/base.py,sha256=vEQaNCkTKkgjmuFxlzScuLpMJFLCbscDGrRA0f7WMFk,85047
+pandas/core/arrays/boolean.py,sha256=ln7GjlHHTtByAhQKX9XuymhifZTCNSpk1j7I-fQKObo,12440
+pandas/core/arrays/categorical.py,sha256=cmLBaSSjzKaANAbMi64Euk-Lxvu6n-PZ0zLH-vxrS2o,98997
+pandas/core/arrays/datetimelike.py,sha256=0t3rDfaBmvj8qSyVfxc1DDPdnhAU7m4HRaJsmvTTYUw,89288
+pandas/core/arrays/datetimes.py,sha256=DqOHEGkUk18oIQdDj8CiBbE_XGWWTQeE7uqMxX7S2VU,92345
+pandas/core/arrays/floating.py,sha256=pvZ72VDstzgslAM5-36KEyJ0z5PBVwTNogcJAxhhMP8,4286
+pandas/core/arrays/integer.py,sha256=FWsrgzs_DB3eG8VX1kfzUTMcKOHfa-ACFQh_xVpZPJU,6470
+pandas/core/arrays/interval.py,sha256=ro_WPcUzlxWKjocGLgEseEcljbBInjzrl8yPOCt87G0,63176
+pandas/core/arrays/masked.py,sha256=gVJpxoiEaY5kca8umAkRt6Az2L0GK3ffwjB63ELG62M,55634
+pandas/core/arrays/numeric.py,sha256=lVpSpsG_66z2QMHghCRoYef6dVJJ_QZAf9vkpLMJokI,9165
+pandas/core/arrays/numpy_.py,sha256=6A5ErMvdNooTI91M1qkV6RWL1B9bN1JJgjueq2QRvdU,17493
+pandas/core/arrays/period.py,sha256=M0cLFbFBn_yD99y_kQ8YY4NWMaH1nVdywBf56CrpiJk,40756
+pandas/core/arrays/sparse/__init__.py,sha256=iwvVqa2GG9TjYrd1rxCBjdLeGQBoRqUO2fZnILElbZg,356
+pandas/core/arrays/sparse/__pycache__/__init__.cpython-312.pyc,,
+pandas/core/arrays/sparse/__pycache__/accessor.cpython-312.pyc,,
+pandas/core/arrays/sparse/__pycache__/array.cpython-312.pyc,,
+pandas/core/arrays/sparse/__pycache__/scipy_sparse.cpython-312.pyc,,
+pandas/core/arrays/sparse/accessor.py,sha256=lZa3hwvXJKLMkXhqiWU8eev8qthvYQ1HgtW875qQe7g,12503
+pandas/core/arrays/sparse/array.py,sha256=vZng8r0PWtKVb74jc0NlEipWyuevqueRWtOhAt8x6xA,63884
+pandas/core/arrays/sparse/scipy_sparse.py,sha256=rVaj3PtVRrMPlzkoVFSkIopWV0xg0GJnpt1YljWT_zg,6462
+pandas/core/arrays/string_.py,sha256=LhTi6O0RG-XesI-VCunUjOmu-WBvFb6MaMv49JX2gW8,21814
+pandas/core/arrays/string_arrow.py,sha256=7wLrp0wOUJuPmwB9_9BLWOm4BAYiQHahSy0umtg7YIY,24913
+pandas/core/arrays/timedeltas.py,sha256=eTi8b16Jumac8WIx8LLf_9ZeFzA4u1nipHMUoc5-lyM,37830
+pandas/core/base.py,sha256=tvXmsVrlfhc-Br3bae5HKiuQlmKPWL9tRVbi7MhhZpw,40940
+pandas/core/common.py,sha256=WwkpCOI8b9j5rxkhL_Dh5l-7EdkHFfSjIIx-QBsefa0,17449
+pandas/core/computation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/core/computation/__pycache__/__init__.cpython-312.pyc,,
+pandas/core/computation/__pycache__/align.cpython-312.pyc,,
+pandas/core/computation/__pycache__/api.cpython-312.pyc,,
+pandas/core/computation/__pycache__/check.cpython-312.pyc,,
+pandas/core/computation/__pycache__/common.cpython-312.pyc,,
+pandas/core/computation/__pycache__/engines.cpython-312.pyc,,
+pandas/core/computation/__pycache__/eval.cpython-312.pyc,,
+pandas/core/computation/__pycache__/expr.cpython-312.pyc,,
+pandas/core/computation/__pycache__/expressions.cpython-312.pyc,,
+pandas/core/computation/__pycache__/ops.cpython-312.pyc,,
+pandas/core/computation/__pycache__/parsing.cpython-312.pyc,,
+pandas/core/computation/__pycache__/pytables.cpython-312.pyc,,
+pandas/core/computation/__pycache__/scope.cpython-312.pyc,,
+pandas/core/computation/align.py,sha256=IBp-G1qbFMICrgm8DYOF-Kt18iCcY_P3peeIGsDkNv4,6161
+pandas/core/computation/api.py,sha256=CQ2AF0hwydcgTHycMCFiyZIAU57RcZT-TVid17SIsV4,65
+pandas/core/computation/check.py,sha256=Vb1YqLq381-nUp8Vjkg6ycJOxP3dV2aO9XjyM1uhe2Q,226
+pandas/core/computation/common.py,sha256=-2EHScxo2jfEQ1oqnnlQ_2eOvtAIn8O2krBaveSwmjs,1442
+pandas/core/computation/engines.py,sha256=g9eiyVCUtNmJGbexh7KvTreAKKhs5mQaWx4Z5UeOZ5s,3314
+pandas/core/computation/eval.py,sha256=21MaqANbDE4xoBk1Ts_iAj_l7Nn3iERNFX0dHvbeN4Y,14047
+pandas/core/computation/expr.py,sha256=utZSSpAHz692aNvfUpMsqgUyOEfC53B6Gv8ybtppDnE,25064
+pandas/core/computation/expressions.py,sha256=K0vu_v8JBVjJn6eQqNocC4ciNKsIYnEZrq8xwvhik2M,7503
+pandas/core/computation/ops.py,sha256=x5Qe3PfjHF5v-FHBerUr39iNXk_T0hLvw0Wchm0RiAQ,14829
+pandas/core/computation/parsing.py,sha256=VhYh3en2onhyJkzTelz32-U4Vc3XadyjTwOVctsqlEI,6399
+pandas/core/computation/pytables.py,sha256=7-L2GZ43aWNKG6hz-j8RhL8BIEGAEvpYi6rX6Zsvm_4,20745
+pandas/core/computation/scope.py,sha256=eyMdfx-gcgJaVIRY2NBgQDt2nW5KSdUZ3M9VRPYUJtU,10203
+pandas/core/config_init.py,sha256=1WBaE0u_9DDurUtAmLL9vy9rdS4hK5SudW9vhmD8taA,26460
+pandas/core/construction.py,sha256=QbsRsoxwBh0EQFoF8Wr5PgU96s7Lt4LW0f7BFtEwyQk,26339
+pandas/core/dtypes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/core/dtypes/__pycache__/__init__.cpython-312.pyc,,
+pandas/core/dtypes/__pycache__/api.cpython-312.pyc,,
+pandas/core/dtypes/__pycache__/astype.cpython-312.pyc,,
+pandas/core/dtypes/__pycache__/base.cpython-312.pyc,,
+pandas/core/dtypes/__pycache__/cast.cpython-312.pyc,,
+pandas/core/dtypes/__pycache__/common.cpython-312.pyc,,
+pandas/core/dtypes/__pycache__/concat.cpython-312.pyc,,
+pandas/core/dtypes/__pycache__/dtypes.cpython-312.pyc,,
+pandas/core/dtypes/__pycache__/generic.cpython-312.pyc,,
+pandas/core/dtypes/__pycache__/inference.cpython-312.pyc,,
+pandas/core/dtypes/__pycache__/missing.cpython-312.pyc,,
+pandas/core/dtypes/api.py,sha256=5mtML1OspdDbsWShw1fsDq93pg2pmuUGSBrvQWQcCgg,1819
+pandas/core/dtypes/astype.py,sha256=awzOpnfZ0dCYhzw_J4fekT7u0F0VwgsIapuiAbBkxxg,9207
+pandas/core/dtypes/base.py,sha256=EeL8zNbMtrvObdEJtqjkG_vIsoQE8zDZiIR2dHzHKPI,17042
+pandas/core/dtypes/cast.py,sha256=Uny9eaZD1jGRfWmh6p6_65HSevmNm16vP0BvTzvH5hQ,62164
+pandas/core/dtypes/common.py,sha256=0KQTfjHC6fhcpXg69-aMF54SuRIQFeiHzU_1VBVyGzg,47319
+pandas/core/dtypes/concat.py,sha256=Q_QujfB0C-CIWbcTlktmB02RgxCf7xQsOgEkOV67VPo,12579
+pandas/core/dtypes/dtypes.py,sha256=w3P6AphBpTFUBqdZLpJ36ziH23YdMGMH0r75KsTObYs,76035
+pandas/core/dtypes/generic.py,sha256=avKoJBzIQ0pJiFg9mmQ1D5ltkZsYxu8uPa46Hat70Ro,4122
+pandas/core/dtypes/inference.py,sha256=OqA9itS2osQBP-mp8jJK9RJZJps4VPsTIvQFCX4EbGM,9012
+pandas/core/dtypes/missing.py,sha256=BPzbmr7O7ihmjLKE9A31ck54ANjAtrp8-dVT20MR5fQ,23632
+pandas/core/flags.py,sha256=NxbTcYlNEaO8MKCpbEc22PEpInFn7f7za7EAO6-mxEE,3763
+pandas/core/frame.py,sha256=m4ExWWBrYq8Dv-dqcInaKC0tYJHzCM8vTZDdBmGgEQU,447104
+pandas/core/generic.py,sha256=UEIXZg--GqdP-YsxvqCTvZBDzWHDWronIHNGTzjkbyI,474370
+pandas/core/groupby/__init__.py,sha256=KamY9WI5B4cMap_3wZ5ycMdXM_rOxGSL7RtoKKPfjAo,301
+pandas/core/groupby/__pycache__/__init__.cpython-312.pyc,,
+pandas/core/groupby/__pycache__/base.cpython-312.pyc,,
+pandas/core/groupby/__pycache__/categorical.cpython-312.pyc,,
+pandas/core/groupby/__pycache__/generic.cpython-312.pyc,,
+pandas/core/groupby/__pycache__/groupby.cpython-312.pyc,,
+pandas/core/groupby/__pycache__/grouper.cpython-312.pyc,,
+pandas/core/groupby/__pycache__/indexing.cpython-312.pyc,,
+pandas/core/groupby/__pycache__/numba_.cpython-312.pyc,,
+pandas/core/groupby/__pycache__/ops.cpython-312.pyc,,
+pandas/core/groupby/base.py,sha256=OrqG2_h_Bp8Z_MeLrAGWGROG-MtSloGqeaJ79qYbJm0,2740
+pandas/core/groupby/categorical.py,sha256=iCsl3d_unK4zAh_lR3eDIBVOhwsv9Bj9X1wbnaR90pw,3047
+pandas/core/groupby/generic.py,sha256=LCsrCIjuhcEz-yw3gyk5nYKNiMF1h8en6nQO1hhTywE,96885
+pandas/core/groupby/groupby.py,sha256=yjNsgJmutrWxZj-6oveCtkDFgJg6S4rcXHsJ8rsjVTU,195730
+pandas/core/groupby/grouper.py,sha256=utxyUS7M-sTYaiWek9uRaIaAHHm0jaTbIqDX-GjEHYE,38672
+pandas/core/groupby/indexing.py,sha256=QY4GZ4wDd-1K-we0EfdiFvmdAZ_VxVgPrYB0kBZf6wU,9510
+pandas/core/groupby/numba_.py,sha256=XjfPfYGbYJgkIKYFiq7Gjnr5wwZ8mKrkeHKTW42HZMg,4894
+pandas/core/groupby/ops.py,sha256=qZPzps8n5_67_FcGpByM9G4PFqr7f4PWcwf52Os16uI,38234
+pandas/core/indexers/__init__.py,sha256=M4CyNLiQoQ5ohoAMH5HES9Rh2lpryAM1toL-b1TJXj0,736
+pandas/core/indexers/__pycache__/__init__.cpython-312.pyc,,
+pandas/core/indexers/__pycache__/objects.cpython-312.pyc,,
+pandas/core/indexers/__pycache__/utils.cpython-312.pyc,,
+pandas/core/indexers/objects.py,sha256=PR063DVlu8_-ti7GsLRb0e7o4oAz2xpMil0nMee18z0,14737
+pandas/core/indexers/utils.py,sha256=TgVCAX9r4MZw3QPH6aE-d55gRZcKN9H9X-MTZ4u-LiY,16069
+pandas/core/indexes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/core/indexes/__pycache__/__init__.cpython-312.pyc,,
+pandas/core/indexes/__pycache__/accessors.cpython-312.pyc,,
+pandas/core/indexes/__pycache__/api.cpython-312.pyc,,
+pandas/core/indexes/__pycache__/base.cpython-312.pyc,,
+pandas/core/indexes/__pycache__/category.cpython-312.pyc,,
+pandas/core/indexes/__pycache__/datetimelike.cpython-312.pyc,,
+pandas/core/indexes/__pycache__/datetimes.cpython-312.pyc,,
+pandas/core/indexes/__pycache__/extension.cpython-312.pyc,,
+pandas/core/indexes/__pycache__/frozen.cpython-312.pyc,,
+pandas/core/indexes/__pycache__/interval.cpython-312.pyc,,
+pandas/core/indexes/__pycache__/multi.cpython-312.pyc,,
+pandas/core/indexes/__pycache__/period.cpython-312.pyc,,
+pandas/core/indexes/__pycache__/range.cpython-312.pyc,,
+pandas/core/indexes/__pycache__/timedeltas.cpython-312.pyc,,
+pandas/core/indexes/accessors.py,sha256=MdP8zNlSQeeU7psOXwGUdQ1-8XKzYCl5mKMIcpMCiN8,19152
+pandas/core/indexes/api.py,sha256=tDBBn84I19nvPFQKj0GAZhb0zioLJqTUJjSVqyc4Fn4,10426
+pandas/core/indexes/base.py,sha256=LVD4AAYIKU0HTYvxSpzcSJ9L3TK6W4HyM7zQDETD_yQ,264290
+pandas/core/indexes/category.py,sha256=_6LpQtBGFsgB4KSZhxEQT4QX57W3172MbvLIAzxboPA,16128
+pandas/core/indexes/datetimelike.py,sha256=JH8_o2NJNQj1A0N0YFcC3m5nQGStacI5bv1G-dzYKVA,28377
+pandas/core/indexes/datetimes.py,sha256=b0B5j5HGthjGLy4FLsMQtjPPjleZEH8agIWfLVne9v0,38327
+pandas/core/indexes/extension.py,sha256=Wy4XfMrJdc4HxuApZw4D-Xr3RyBlGCOKbI27L16tHEE,5188
+pandas/core/indexes/frozen.py,sha256=QuFW2zV8wqY7PD5PHbUMJQc3a-c5Eyfkjblp4umOylM,3482
+pandas/core/indexes/interval.py,sha256=79ddOFRsEoj7glRYNcq-L7rPB5y3jFxuOFnCD5lQW-o,38190
+pandas/core/indexes/multi.py,sha256=JskZSKvKotqbeS-2UE5hTB5eyJ5tuuotoZ3u47v33UY,143195
+pandas/core/indexes/period.py,sha256=ohh7J43CgV1ijxn9ozNhO5Vwu0k1-3yURIWTWeNPRgg,18978
+pandas/core/indexes/range.py,sha256=qt5IS2batjnOHe90UK5jES7pZhglppW_-1wieLlZysA,39511
+pandas/core/indexes/timedeltas.py,sha256=9a5m2wLQUA2v2O6JibpDSssNvNzV8Af6dAJETEpD4qM,10960
+pandas/core/indexing.py,sha256=TRrbtBeUrELiuFiCpAVuP0yIsfrxVLvBbT9bPvlCAmY,97236
+pandas/core/interchange/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/core/interchange/__pycache__/__init__.cpython-312.pyc,,
+pandas/core/interchange/__pycache__/buffer.cpython-312.pyc,,
+pandas/core/interchange/__pycache__/column.cpython-312.pyc,,
+pandas/core/interchange/__pycache__/dataframe.cpython-312.pyc,,
+pandas/core/interchange/__pycache__/dataframe_protocol.cpython-312.pyc,,
+pandas/core/interchange/__pycache__/from_dataframe.cpython-312.pyc,,
+pandas/core/interchange/__pycache__/utils.cpython-312.pyc,,
+pandas/core/interchange/buffer.py,sha256=KujVQ1qeXMjgRdvwea37FqO9f2ULmLa6Rtr_mTQ11XU,3453
+pandas/core/interchange/column.py,sha256=tlHYyU6RP9ESD693d4WpDUNP0hq7MaTZnm6tLJXSq98,17547
+pandas/core/interchange/dataframe.py,sha256=M1mWjS70pYLFJau534NtgslcpY_8NiY4dRmRgT73TVo,3879
+pandas/core/interchange/dataframe_protocol.py,sha256=L9Wy8vB5oTsuYJQ9NBY4RIEAWXBclnTOH3I_txkIbZk,16177
+pandas/core/interchange/from_dataframe.py,sha256=VOTMZlybK4-omYdw-roufRYmQd9qJ-ryldcim0fyw_w,17043
+pandas/core/interchange/utils.py,sha256=mYIOfiwjnZd-I2j-SNRWRLFcSIlBtA9MLFCdzgynSFM,4837
+pandas/core/internals/__init__.py,sha256=LE8M58WRu_cvQZns2dxUMeBVjqNfwRWw6vtWKiBrr2I,2615
+pandas/core/internals/__pycache__/__init__.cpython-312.pyc,,
+pandas/core/internals/__pycache__/api.cpython-312.pyc,,
+pandas/core/internals/__pycache__/array_manager.cpython-312.pyc,,
+pandas/core/internals/__pycache__/base.cpython-312.pyc,,
+pandas/core/internals/__pycache__/blocks.cpython-312.pyc,,
+pandas/core/internals/__pycache__/concat.cpython-312.pyc,,
+pandas/core/internals/__pycache__/construction.cpython-312.pyc,,
+pandas/core/internals/__pycache__/managers.cpython-312.pyc,,
+pandas/core/internals/__pycache__/ops.cpython-312.pyc,,
+pandas/core/internals/api.py,sha256=s78Hb4dHuBAufRH9vTd1KO6o0bs-9CoBOsRF6GP03lE,4695
+pandas/core/internals/array_manager.py,sha256=q_QKlETGKdb1r8aFKVfV4ZrMoVO1wFNAC2JNHCZ6rGE,43927
+pandas/core/internals/base.py,sha256=pO6sju5EIq7u23J7CGPZNTEotbL4KYKzRgyIEmBhqpg,11161
+pandas/core/internals/blocks.py,sha256=W7IYinBFN8KW5Rt0o7BJvmcgpgStQeLUq3PxpVEsrY8,98485
+pandas/core/internals/concat.py,sha256=Q_MnHIKSMBvIvA6DpMNkcsQSv8aU9DivUn1mlA_9zEs,19151
+pandas/core/internals/construction.py,sha256=IsWPruU6jDjeUAQqxsFJUIFr0MHUXNQNatP-AJYv2IA,33987
+pandas/core/internals/managers.py,sha256=toDgoWhpnOJiwytqyR_X5AmJkmqetYvBq6KbMR9T6-U,81576
+pandas/core/internals/ops.py,sha256=Rh2-gWjeSwXnjkiacohSNM5iNvqQqBiAqgblwP6rD9o,5145
+pandas/core/methods/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/core/methods/__pycache__/__init__.cpython-312.pyc,,
+pandas/core/methods/__pycache__/describe.cpython-312.pyc,,
+pandas/core/methods/__pycache__/selectn.cpython-312.pyc,,
+pandas/core/methods/__pycache__/to_dict.cpython-312.pyc,,
+pandas/core/methods/describe.py,sha256=IeCkAFDUdVNxoPPqP1R1HzDlKFQHvlg46AgIxntD5Cs,11961
+pandas/core/methods/selectn.py,sha256=oomBEebumUfbJ5OLi9vw7saH31vbiy3lK-i63VKWBOw,7696
+pandas/core/methods/to_dict.py,sha256=sep0EfimrQ5UNJu-KwC1uYzx1BvbrackOe2-qxl2F5Y,8649
+pandas/core/missing.py,sha256=x_XOmge6_k9uIij2tyJZBEFKpAju1xUS9knQhe5kleU,35270
+pandas/core/nanops.py,sha256=kJpYqWg4E-D89HOXcufquZH0_rPFRbgbmZAULygpDnU,50984
+pandas/core/ops/__init__.py,sha256=CQ7tQB-QPUxD6ZnbS2SzFVjjvCD7-ciglexkdbbn7y8,1620
+pandas/core/ops/__pycache__/__init__.cpython-312.pyc,,
+pandas/core/ops/__pycache__/array_ops.cpython-312.pyc,,
+pandas/core/ops/__pycache__/common.cpython-312.pyc,,
+pandas/core/ops/__pycache__/dispatch.cpython-312.pyc,,
+pandas/core/ops/__pycache__/docstrings.cpython-312.pyc,,
+pandas/core/ops/__pycache__/invalid.cpython-312.pyc,,
+pandas/core/ops/__pycache__/mask_ops.cpython-312.pyc,,
+pandas/core/ops/__pycache__/missing.cpython-312.pyc,,
+pandas/core/ops/array_ops.py,sha256=wNV7RL-HZoB_I61YlF5nskpH-4RxA2n3P_gj31i18FM,19079
+pandas/core/ops/common.py,sha256=jVf_L_oN6bKcUOuH6FgaKOx18se9C3Hl2JPd0Uoj4t4,3500
+pandas/core/ops/dispatch.py,sha256=5XFIr7HV1Dicohgm0ZJu-6argn2Qd0OwES2bBxQwCj0,635
+pandas/core/ops/docstrings.py,sha256=WlGWcWjNsldPW73krxbgRwQvkacmKqRqJsN4VVz-FXU,18448
+pandas/core/ops/invalid.py,sha256=5-gRzdBfk2F8qIZ_vzUlnI-vo1HsAh2F5BYJUEN--m0,1433
+pandas/core/ops/mask_ops.py,sha256=0sm9L1LB_USp8DxNBuCdoB8cJ_MzzvSAb_u3QQmQrKI,5409
+pandas/core/ops/missing.py,sha256=0WlqN_us0LU5RAdoitM-Ko_4xghJ_HBRkteLQ53fU14,5140
+pandas/core/resample.py,sha256=lckInCT6z43EuK8cf0Qono3W_LeJ2UqAoxMTWMxnvtQ,95578
+pandas/core/reshape/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/core/reshape/__pycache__/__init__.cpython-312.pyc,,
+pandas/core/reshape/__pycache__/api.cpython-312.pyc,,
+pandas/core/reshape/__pycache__/concat.cpython-312.pyc,,
+pandas/core/reshape/__pycache__/encoding.cpython-312.pyc,,
+pandas/core/reshape/__pycache__/melt.cpython-312.pyc,,
+pandas/core/reshape/__pycache__/merge.cpython-312.pyc,,
+pandas/core/reshape/__pycache__/pivot.cpython-312.pyc,,
+pandas/core/reshape/__pycache__/reshape.cpython-312.pyc,,
+pandas/core/reshape/__pycache__/tile.cpython-312.pyc,,
+pandas/core/reshape/__pycache__/util.cpython-312.pyc,,
+pandas/core/reshape/api.py,sha256=Qk5y-D5-OdRYKkCgc-ktcxKGNGSCPteISEsByXFWI9M,680
+pandas/core/reshape/concat.py,sha256=qwXsAlI9pnLld1pj9uqHf2zinXd-fj8GE3kZ-XNVacU,28253
+pandas/core/reshape/encoding.py,sha256=BN4hXm16hkz6bFQ56BgvoRb0YfdK-4CjWb4FcYRFBfk,18970
+pandas/core/reshape/melt.py,sha256=Zj6PSyI3Dbi_aQPhYyFTz_cWi9m8kIubwItq57JNCFQ,17400
+pandas/core/reshape/merge.py,sha256=K31zarc63I1cEl74TSPPITrLdpcVVAlpOslP2dTLYUo,99585
+pandas/core/reshape/pivot.py,sha256=ylkSVYQcoMmuxqvEoyEP6YHzeVtGL9y6ueAEfN6_RzY,28917
+pandas/core/reshape/reshape.py,sha256=_slnrYBb1ZFgqP1501D5JNF5LmWzD2PQGDtrzwk-eP0,34661
+pandas/core/reshape/tile.py,sha256=bDzSjjPydhiCce0DOJab1327a613mhs98PimwfIddjQ,21947
+pandas/core/reshape/util.py,sha256=zrShSZARSsWULoXI5tdWqwgZSLQ-u_3xNPS5cpB4QbY,2014
+pandas/core/roperator.py,sha256=ljko3iHhBm5ZvEVqrGEbwGV4z0cXd4TE1uSzf-LZlQ8,1114
+pandas/core/sample.py,sha256=QEPzbFmeMRMxAIqfkRrJLnIjUZgSupbP8YUEezW-Pcw,4626
+pandas/core/series.py,sha256=C6VAX8KkmsW-0T4ydIMqw7LoruFa5Yy14hcrvmTR8NA,213072
+pandas/core/shared_docs.py,sha256=Fdd7Xi1TQ_esZXq32Gu-ZPiShIHE2VROSSRtzet509s,30103
+pandas/core/sorting.py,sha256=kxr4Phz8HHAsEbyx9J5SCYZ4xENhoZnFmMEAUI-NpIU,22976
+pandas/core/sparse/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/core/sparse/__pycache__/__init__.cpython-312.pyc,,
+pandas/core/sparse/__pycache__/api.cpython-312.pyc,,
+pandas/core/sparse/api.py,sha256=y0onCpBKCj_5Iaybw5e-gxk8zAa9d1p5Zu58RLzPT1k,143
+pandas/core/strings/__init__.py,sha256=KYCMtwb7XWzZXsIZGijtjw9ofs2DIqE9psfKoxRsHuw,1087
+pandas/core/strings/__pycache__/__init__.cpython-312.pyc,,
+pandas/core/strings/__pycache__/accessor.cpython-312.pyc,,
+pandas/core/strings/__pycache__/base.cpython-312.pyc,,
+pandas/core/strings/__pycache__/object_array.cpython-312.pyc,,
+pandas/core/strings/accessor.py,sha256=_IAdGo_ZBjznkpvqStUZ2xyYyCuCoYtze9Trxb8Gd5I,112575
+pandas/core/strings/base.py,sha256=AdPlNkPgT218Mffx6Blt4aJF1GGxSYII3mem6EjWntY,5528
+pandas/core/strings/object_array.py,sha256=mCAo6lx6V1_UaoxcGWOgiAV0N-381rKcyAkqUHJ9kic,15438
+pandas/core/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/core/tools/__pycache__/__init__.cpython-312.pyc,,
+pandas/core/tools/__pycache__/datetimes.cpython-312.pyc,,
+pandas/core/tools/__pycache__/numeric.cpython-312.pyc,,
+pandas/core/tools/__pycache__/timedeltas.cpython-312.pyc,,
+pandas/core/tools/__pycache__/times.cpython-312.pyc,,
+pandas/core/tools/datetimes.py,sha256=3KYS9voe_xTCyaVnZnqqEqt1lv1YVM9BzcvuV27sI_c,43404
+pandas/core/tools/numeric.py,sha256=f8HKUnKTNIPvlrFa4bbLy6pMH3ULSgce04qRzK5qV_Y,11025
+pandas/core/tools/timedeltas.py,sha256=kyDgKp9yRpw-gzucChvvekVQKy1sHu8J5qQwbwWaukg,8858
+pandas/core/tools/times.py,sha256=_-z5faRW4NA04LKN-eUgvklqOjRIncQyndFdSzwzDXI,5373
+pandas/core/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/core/util/__pycache__/__init__.cpython-312.pyc,,
+pandas/core/util/__pycache__/hashing.cpython-312.pyc,,
+pandas/core/util/__pycache__/numba_.cpython-312.pyc,,
+pandas/core/util/hashing.py,sha256=LlYoJfn80z0zj0xNt5P3PYRVFJafXI3bRnSYV361Avs,9657
+pandas/core/util/numba_.py,sha256=U-2_obqjB_DwLc7Bu6swTCdPdNU62Z9l0QpxYM5Edng,2582
+pandas/core/window/__init__.py,sha256=DewB8XXkLGEDgtQqICYPmnkZZ3Y4tN6zPoTYvpNuJGE,450
+pandas/core/window/__pycache__/__init__.cpython-312.pyc,,
+pandas/core/window/__pycache__/common.cpython-312.pyc,,
+pandas/core/window/__pycache__/doc.cpython-312.pyc,,
+pandas/core/window/__pycache__/ewm.cpython-312.pyc,,
+pandas/core/window/__pycache__/expanding.cpython-312.pyc,,
+pandas/core/window/__pycache__/numba_.cpython-312.pyc,,
+pandas/core/window/__pycache__/online.cpython-312.pyc,,
+pandas/core/window/__pycache__/rolling.cpython-312.pyc,,
+pandas/core/window/common.py,sha256=LZBddjEy7C_nb-9gmsk2wQr-FsF1WBMsGKd8ptmMdug,6714
+pandas/core/window/doc.py,sha256=iCAs_hJ_pwstet2FHwSilVSXoTaKRuuMHwyZ9l2dz_c,4158
+pandas/core/window/ewm.py,sha256=nniOOhhrrx88wUd1iG2C2vyhT6mfd1N4UbDt4pY1F78,35190
+pandas/core/window/expanding.py,sha256=MnepmpreeY11OX9nQHj5TxgYdnOPJIRC-Cr3MyDnC38,27845
+pandas/core/window/numba_.py,sha256=7x9RvcIvPab0C5uXT4U9cP1VNaI7Yym0CevTsMIu27U,10606
+pandas/core/window/online.py,sha256=NKHkFpehR5QDT5VrCESEqjZ9a_Fq0JkchzmXFtzLRds,3735
+pandas/core/window/rolling.py,sha256=jj5NmCV28NgsWXMaBVqV-j8-JPwZOCu3heLi9AAbTMU,95504
+pandas/errors/__init__.py,sha256=DotJJfd-bS7FSQbnLC6SKWCfz_GqGYS6Gy6Fc9AJZg0,27164
+pandas/errors/__pycache__/__init__.cpython-312.pyc,,
+pandas/io/__init__.py,sha256=4YJcSmLT6iTWceVgxGNSyRJq91wxhrgsNr47uc4Rw-I,293
+pandas/io/__pycache__/__init__.cpython-312.pyc,,
+pandas/io/__pycache__/_util.cpython-312.pyc,,
+pandas/io/__pycache__/api.cpython-312.pyc,,
+pandas/io/__pycache__/clipboards.cpython-312.pyc,,
+pandas/io/__pycache__/common.cpython-312.pyc,,
+pandas/io/__pycache__/feather_format.cpython-312.pyc,,
+pandas/io/__pycache__/gbq.cpython-312.pyc,,
+pandas/io/__pycache__/html.cpython-312.pyc,,
+pandas/io/__pycache__/orc.cpython-312.pyc,,
+pandas/io/__pycache__/parquet.cpython-312.pyc,,
+pandas/io/__pycache__/pickle.cpython-312.pyc,,
+pandas/io/__pycache__/pytables.cpython-312.pyc,,
+pandas/io/__pycache__/spss.cpython-312.pyc,,
+pandas/io/__pycache__/sql.cpython-312.pyc,,
+pandas/io/__pycache__/stata.cpython-312.pyc,,
+pandas/io/__pycache__/xml.cpython-312.pyc,,
+pandas/io/_util.py,sha256=0_dKFBocN0FV3XTzhOlDP55ToeHCre22RIKe6d6tRZs,961
+pandas/io/api.py,sha256=w7Ux3U8PI-SeP13hD3PMjWMf3YbOGog6zCDqj0nfnpI,1264
+pandas/io/clipboard/__init__.py,sha256=3aFzdoqbabE8XM-FYjdYIctTps_sTAJDJMrhEbDv_UU,24235
+pandas/io/clipboard/__pycache__/__init__.cpython-312.pyc,,
+pandas/io/clipboards.py,sha256=t88NnxP8TOpmM1V438o6jgvlEMzlRLaqWBxUQiH_EQ8,6320
+pandas/io/common.py,sha256=hsjBpZc8i9O_aKMpCms0tuQ2jAqbkVzLXnUKI01TVcU,40615
+pandas/io/excel/__init__.py,sha256=w62gHQ9nF3XgBOmjhM8eHmV-YXF7gflz1lFqxFq7io8,486
+pandas/io/excel/__pycache__/__init__.cpython-312.pyc,,
+pandas/io/excel/__pycache__/_base.cpython-312.pyc,,
+pandas/io/excel/__pycache__/_calamine.cpython-312.pyc,,
+pandas/io/excel/__pycache__/_odfreader.cpython-312.pyc,,
+pandas/io/excel/__pycache__/_odswriter.cpython-312.pyc,,
+pandas/io/excel/__pycache__/_openpyxl.cpython-312.pyc,,
+pandas/io/excel/__pycache__/_pyxlsb.cpython-312.pyc,,
+pandas/io/excel/__pycache__/_util.cpython-312.pyc,,
+pandas/io/excel/__pycache__/_xlrd.cpython-312.pyc,,
+pandas/io/excel/__pycache__/_xlsxwriter.cpython-312.pyc,,
+pandas/io/excel/_base.py,sha256=tEBB5m3LcL8ZHv62Kv7G4Ul9MElr2X8JrkXvadypzC4,59073
+pandas/io/excel/_calamine.py,sha256=7O8I8yg-dpaK6OqdZflV14ggDbNDJrinhgAPxXgh9ro,3474
+pandas/io/excel/_odfreader.py,sha256=vMVZ-lNJpMB0vQ8cewanVpjj3-sFzUAS-I-w28nOmoY,8262
+pandas/io/excel/_odswriter.py,sha256=o7dP9MQYRyDO88kFeJMiyW5SmCxusykb8vew4QHMjsg,11210
+pandas/io/excel/_openpyxl.py,sha256=CshETVibZ0_rwbNq0y7sPkzSgnXpwI7FUtvAj8efU6Q,19861
+pandas/io/excel/_pyxlsb.py,sha256=74huu-7ISIsfvguwDID84B3KIooHtU53XOP3PFkX6ts,4358
+pandas/io/excel/_util.py,sha256=1fwMlNjLSd_qlCGLGBcXDPLnZ_SOpAZTIaUgYUVr0_0,8105
+pandas/io/excel/_xlrd.py,sha256=tddoGt7ugmyTTryMeqSvU6FE9vgajsMYfrSLQytMEV0,4556
+pandas/io/excel/_xlsxwriter.py,sha256=b0o_2MRgeTNG0loBRybT-xDoa65CjUeVC2wmuTUoR0M,9191
+pandas/io/feather_format.py,sha256=BjbwRVYhEvbp8w05sYd838VfgS4dNktb8T7m2PicjCM,4443
+pandas/io/formats/__init__.py,sha256=MGhPbyRcirFXg_uAGxyQ_q8Bky6ZUpBZ0nHXQa5LYd8,238
+pandas/io/formats/__pycache__/__init__.cpython-312.pyc,,
+pandas/io/formats/__pycache__/_color_data.cpython-312.pyc,,
+pandas/io/formats/__pycache__/console.cpython-312.pyc,,
+pandas/io/formats/__pycache__/css.cpython-312.pyc,,
+pandas/io/formats/__pycache__/csvs.cpython-312.pyc,,
+pandas/io/formats/__pycache__/excel.cpython-312.pyc,,
+pandas/io/formats/__pycache__/format.cpython-312.pyc,,
+pandas/io/formats/__pycache__/html.cpython-312.pyc,,
+pandas/io/formats/__pycache__/info.cpython-312.pyc,,
+pandas/io/formats/__pycache__/printing.cpython-312.pyc,,
+pandas/io/formats/__pycache__/string.cpython-312.pyc,,
+pandas/io/formats/__pycache__/style.cpython-312.pyc,,
+pandas/io/formats/__pycache__/style_render.cpython-312.pyc,,
+pandas/io/formats/__pycache__/xml.cpython-312.pyc,,
+pandas/io/formats/_color_data.py,sha256=fZ_QluvMFUNKUE4-T32x7Pn0nulQgxmsEMHB9URcBOY,4332
+pandas/io/formats/console.py,sha256=dcoFM-rirR8qdc1bvgJySPhZvk23S6Nkz3-2Lc30pMk,2748
+pandas/io/formats/css.py,sha256=gCSjRV6QatAMY-La26wnrQmyF78G4BruMfpWrDIKIkk,12793
+pandas/io/formats/csvs.py,sha256=JAI3kO6xKSMjsLxlYk4EijBuktOHRwU9U91a92OvYnQ,10526
+pandas/io/formats/excel.py,sha256=vW5_Pii4i_wv_VNVR0wn-7IFwdgf2tzROor4eThVO68,32994
+pandas/io/formats/format.py,sha256=FPeKW4UASjOLB-N73HfVZWVviqUbDPoBoVLCQxhJJjE,66127
+pandas/io/formats/html.py,sha256=AiROfWxTRrMT75LZsrBMJTIs3ky9n1x3nUnXzKpZILM,24165
+pandas/io/formats/info.py,sha256=heCm4flQPvNMNW6zecz_XUrfV5O-_zWdpam_dk3V2Tc,32621
+pandas/io/formats/printing.py,sha256=Hrs0vaaacrfswH7FuPCM9FnVg5kKL5vGYl8-ZxAQC4Q,17950
+pandas/io/formats/string.py,sha256=f6UNLnvUV-iO-7k7zXqWBOs7hOoU7_fWQzogyeY8c7I,6707
+pandas/io/formats/style.py,sha256=7bM9ookFZdRMVjamIUzCcyfiYAWM0ksTd9m3UnvyDA0,155854
+pandas/io/formats/style_render.py,sha256=TgyXK40A4dp8geKIeGWMwNm_v597jWQmJZH-H-TSSdQ,90899
+pandas/io/formats/templates/html.tpl,sha256=KA-w_npfnHM_1c5trtJtkd3OD9j8hqtoQAY4GCC5UgI,412
+pandas/io/formats/templates/html_style.tpl,sha256=_gCqktLyUGAo5TzL3I-UCp1Njj8KyeLCWunHz4nYHsE,694
+pandas/io/formats/templates/html_table.tpl,sha256=MJxwJFwOa4KNli-ix7vYAGjRzw59FLAmYKHMy9nC32k,1811
+pandas/io/formats/templates/latex.tpl,sha256=m-YMxqKVJ52kLd61CA9V2MiC_Dtwwa-apvU8YtH8TYU,127
+pandas/io/formats/templates/latex_longtable.tpl,sha256=opn-JNfuMX81g1UOWYFJLKdQSUwoSP_UAKbK4kYRph4,2877
+pandas/io/formats/templates/latex_table.tpl,sha256=YNvnvjtwYXrWFVXndQZdJqKFIXYTUj8f1YOUdMmxXmQ,2221
+pandas/io/formats/templates/string.tpl,sha256=Opr87f1tY8yp_G7GOY8ouFllR_7vffN_ok7Ndf98joE,344
+pandas/io/formats/xml.py,sha256=dLBpVLGltVRiOxYCIVLb4okLXwhPneRp7whi2VbV1gk,16029
+pandas/io/gbq.py,sha256=nkdYZ0w5ZetYdWpIIKALLh5_3nNhFE1hvVV9rJ5yyhk,9372
+pandas/io/html.py,sha256=E4rdZT6DVcMRSeDaceBsMpWrc-A9aAEvF5sbW4DstIg,39546
+pandas/io/json/__init__.py,sha256=ArWTQnIKhxDVaMI1j0Whgpk0ci6dP0mpUiGwMRqEdtY,270
+pandas/io/json/__pycache__/__init__.cpython-312.pyc,,
+pandas/io/json/__pycache__/_json.cpython-312.pyc,,
+pandas/io/json/__pycache__/_normalize.cpython-312.pyc,,
+pandas/io/json/__pycache__/_table_schema.cpython-312.pyc,,
+pandas/io/json/_json.py,sha256=KxErOL4x5IkSnFsgivvNBs6ZWuSxAWX29cKguk2OEQs,48572
+pandas/io/json/_normalize.py,sha256=rbyrEKwuxotrABiv6Jmb9JN6k6rCXd99ONrEZv2IbXI,17212
+pandas/io/json/_table_schema.py,sha256=Ld6OMQsdCutRvmGHPayKOTf08BNTnhuFwcQGRnlCq_w,11594
+pandas/io/orc.py,sha256=c6HnmrCBhfe6dzGu4LxfKwxDOraHckh-WYf9UNN_xno,8385
+pandas/io/parquet.py,sha256=npe1SKcJbfLM6vSPVDQDeoEsPIIfJzlAKstzNGmoOVQ,23835
+pandas/io/parsers/__init__.py,sha256=7BLx4kn9y5ipgfZUWZ4y_MLEUNgX6MQ5DyDwshhJxVM,204
+pandas/io/parsers/__pycache__/__init__.cpython-312.pyc,,
+pandas/io/parsers/__pycache__/arrow_parser_wrapper.cpython-312.pyc,,
+pandas/io/parsers/__pycache__/base_parser.cpython-312.pyc,,
+pandas/io/parsers/__pycache__/c_parser_wrapper.cpython-312.pyc,,
+pandas/io/parsers/__pycache__/python_parser.cpython-312.pyc,,
+pandas/io/parsers/__pycache__/readers.cpython-312.pyc,,
+pandas/io/parsers/arrow_parser_wrapper.py,sha256=XE5SuEdcu2M-wlEgAC8gAZaZDvA_O31_vJRFJqMAbWg,11409
+pandas/io/parsers/base_parser.py,sha256=HRzZBK2fm9dmi7OcBiljVtQdd6c-cWsCZcHLFRiblo0,49443
+pandas/io/parsers/c_parser_wrapper.py,sha256=yXK-ZrUOxZcXdZ9rtINgRl7l426tdoch8GyZIS_nCMI,14199
+pandas/io/parsers/python_parser.py,sha256=9fnAQ5iFQwBETy-6ptu66-3Ppu8tn81CGSRyYxhgE2I,48456
+pandas/io/parsers/readers.py,sha256=yP4xBAdreacpmmKamh7w6O4CTl0NQ5z0UVSuA7LSs0c,87157
+pandas/io/pickle.py,sha256=t4OulGy7CQL60LXTC8kebegWM7QaJOmudlynAgWxo4w,6582
+pandas/io/pytables.py,sha256=o8JItkD0B5Uewjks5IPtyv5JtHzqD94yUO6xVQ90kX8,177239
+pandas/io/sas/__init__.py,sha256=AIAudC9f784kcEzuho8GiXU63vj2ThRitKznl7Imkq4,69
+pandas/io/sas/__pycache__/__init__.cpython-312.pyc,,
+pandas/io/sas/__pycache__/sas7bdat.cpython-312.pyc,,
+pandas/io/sas/__pycache__/sas_constants.cpython-312.pyc,,
+pandas/io/sas/__pycache__/sas_xport.cpython-312.pyc,,
+pandas/io/sas/__pycache__/sasreader.cpython-312.pyc,,
+pandas/io/sas/sas7bdat.py,sha256=IGdDWp_EivJPJYmfv3jbJNtt6BZtbupRskKPvQ16KIo,27534
+pandas/io/sas/sas_constants.py,sha256=CM1wSNzXn6nkjLMSTeBhBJlL6d0hU-1YdNwEO8HE-9U,8719
+pandas/io/sas/sas_xport.py,sha256=_N7sGHw4Z80u-emCxS4lv6UFs6N01eKj5CZkTzq7XiM,15134
+pandas/io/sas/sasreader.py,sha256=S7bRlsXahhpoTkKdsHoWY9TLo_jgzNJJdsb6gxpcfuY,4885
+pandas/io/spss.py,sha256=p4vW9rJEFLPBqEIHMR5fCmo2U-JBTvgnDNd74Y7DFuI,2182
+pandas/io/sql.py,sha256=AezlzGw76UejHVblu1x9tGpex6bmSg2_QuuvBVnSf0g,101704
+pandas/io/stata.py,sha256=dgPveWarql9uZ6oSOO02Dfnf7ZmiFye2LUG0-9IrEiY,135790
+pandas/io/xml.py,sha256=ZKHsFACIJhlNJqU8nNBpG-OjHZ2uE_wzh94OOBuj8iI,38656
+pandas/plotting/__init__.py,sha256=W_2wP9v02mNCK4lV5ekG1iJHYSF8dD1NbByJiNq3g8I,2826
+pandas/plotting/__pycache__/__init__.cpython-312.pyc,,
+pandas/plotting/__pycache__/_core.cpython-312.pyc,,
+pandas/plotting/__pycache__/_misc.cpython-312.pyc,,
+pandas/plotting/_core.py,sha256=BLIzDrRcaDDYBpXj8nfw3aIXabos6YlwPjondYmh6II,66558
+pandas/plotting/_matplotlib/__init__.py,sha256=jGq_ouunQTV3zzX_crl9kCVX2ztk1p62McqD2WVRnAk,2044
+pandas/plotting/_matplotlib/__pycache__/__init__.cpython-312.pyc,,
+pandas/plotting/_matplotlib/__pycache__/boxplot.cpython-312.pyc,,
+pandas/plotting/_matplotlib/__pycache__/converter.cpython-312.pyc,,
+pandas/plotting/_matplotlib/__pycache__/core.cpython-312.pyc,,
+pandas/plotting/_matplotlib/__pycache__/groupby.cpython-312.pyc,,
+pandas/plotting/_matplotlib/__pycache__/hist.cpython-312.pyc,,
+pandas/plotting/_matplotlib/__pycache__/misc.cpython-312.pyc,,
+pandas/plotting/_matplotlib/__pycache__/style.cpython-312.pyc,,
+pandas/plotting/_matplotlib/__pycache__/timeseries.cpython-312.pyc,,
+pandas/plotting/_matplotlib/__pycache__/tools.cpython-312.pyc,,
+pandas/plotting/_matplotlib/boxplot.py,sha256=xzXBEoBmC1U9VGlYCvqXEfjAabAFgI69nUbOzHm9zmc,18261
+pandas/plotting/_matplotlib/converter.py,sha256=EcdgaqQPOqYIO2noB-6J2xkODsBwATamuwA315SCVog,37033
+pandas/plotting/_matplotlib/core.py,sha256=20oTgXZwzTQDfqBY6g_HT9CsGd1RkuNtnu0YE-rtO5U,71826
+pandas/plotting/_matplotlib/groupby.py,sha256=vg8RYC3SxN2Khc-34GDV3UpCVSPnawt4zwYqIuzb5HE,4343
+pandas/plotting/_matplotlib/hist.py,sha256=uljuycUD16A6u3GdktvZwXdU3qMKPfFLFMgYmBX4zQU,16816
+pandas/plotting/_matplotlib/misc.py,sha256=tzbAVRDGc1Ep6BR3QbYAEKEHgkX2vwMBX9k9uwN-j8c,13358
+pandas/plotting/_matplotlib/style.py,sha256=mKDcq4cBmYF9zDrBv3st3fNFvSn-91rYEH5cLXaYiw0,8368
+pandas/plotting/_matplotlib/timeseries.py,sha256=Mw3zTUVL8NR1bUCxWrait8kPCB9DHBkm8skT_RdEQ3k,11531
+pandas/plotting/_matplotlib/tools.py,sha256=7YrV3B-bXVm6AI-QekcC4CSKRLB9ZM7fakEOzm5gm1k,15389
+pandas/plotting/_misc.py,sha256=sbOaqkE9lA5HbikzcFBcXe9tdqHMVAxxMH3V9QfYr-c,20929
+pandas/pyproject.toml,sha256=zVYCcwPAWYkyN0xtApuGIQUfWpd-c-VJ55WzQNx2LkQ,24456
+pandas/testing.py,sha256=3XTHuY440lezW7rxw4LW9gfxzDEa7s0l16cdnkRYwwM,313
+pandas/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/__pycache__/test_aggregation.cpython-312.pyc,,
+pandas/tests/__pycache__/test_algos.cpython-312.pyc,,
+pandas/tests/__pycache__/test_common.cpython-312.pyc,,
+pandas/tests/__pycache__/test_downstream.cpython-312.pyc,,
+pandas/tests/__pycache__/test_errors.cpython-312.pyc,,
+pandas/tests/__pycache__/test_expressions.cpython-312.pyc,,
+pandas/tests/__pycache__/test_flags.cpython-312.pyc,,
+pandas/tests/__pycache__/test_multilevel.cpython-312.pyc,,
+pandas/tests/__pycache__/test_nanops.cpython-312.pyc,,
+pandas/tests/__pycache__/test_optional_dependency.cpython-312.pyc,,
+pandas/tests/__pycache__/test_register_accessor.cpython-312.pyc,,
+pandas/tests/__pycache__/test_sorting.cpython-312.pyc,,
+pandas/tests/__pycache__/test_take.cpython-312.pyc,,
+pandas/tests/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/api/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/api/__pycache__/test_api.cpython-312.pyc,,
+pandas/tests/api/__pycache__/test_types.cpython-312.pyc,,
+pandas/tests/api/test_api.py,sha256=ZQI3_TgIuolTfuKy-a4eds0io74Q4kvy8fG6NZDoj-M,9394
+pandas/tests/api/test_types.py,sha256=ZR8n_efaY7HWGY6XnRZKNIiRWmaszpNU8p22kvAbyEQ,1711
+pandas/tests/apply/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/apply/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/apply/__pycache__/common.cpython-312.pyc,,
+pandas/tests/apply/__pycache__/test_frame_apply.cpython-312.pyc,,
+pandas/tests/apply/__pycache__/test_frame_apply_relabeling.cpython-312.pyc,,
+pandas/tests/apply/__pycache__/test_frame_transform.cpython-312.pyc,,
+pandas/tests/apply/__pycache__/test_invalid_arg.cpython-312.pyc,,
+pandas/tests/apply/__pycache__/test_numba.cpython-312.pyc,,
+pandas/tests/apply/__pycache__/test_series_apply.cpython-312.pyc,,
+pandas/tests/apply/__pycache__/test_series_apply_relabeling.cpython-312.pyc,,
+pandas/tests/apply/__pycache__/test_series_transform.cpython-312.pyc,,
+pandas/tests/apply/__pycache__/test_str.cpython-312.pyc,,
+pandas/tests/apply/common.py,sha256=A8TqjvKR4h4WaLtovGR9hDULpWs4rV-1Jx_Q4Zz5Dew,298
+pandas/tests/apply/test_frame_apply.py,sha256=MNA70UiPF9BisXVGpvQTt1SjZTMj7-J5p_43BaZ-4Ao,54256
+pandas/tests/apply/test_frame_apply_relabeling.py,sha256=jHfewakLcFvc1nartXtElv7HM5eGUIelIcm-McXX2KQ,3772
+pandas/tests/apply/test_frame_transform.py,sha256=bbAcYmXxlfEo8-zPQdxlp26s9LPlRbpVKpQu9yEVkCI,8020
+pandas/tests/apply/test_invalid_arg.py,sha256=4X6SQ_1Y21KMxhpn7CFx5l1Gdky70ERJwRClcGxYJwA,10983
+pandas/tests/apply/test_numba.py,sha256=XUiNthXaQTEB1mJSD_wkNEE_h0Blk1lMkVt9DBwBHCs,3810
+pandas/tests/apply/test_series_apply.py,sha256=Mak1zJWdYx6mX-0-OzHImTzYSGl9UVPSsPKVUAdMNoI,22485
+pandas/tests/apply/test_series_apply_relabeling.py,sha256=_HkoIybNJQFEpIaafHvD1Q0nx_U9J2aL8ualcwhp5Fs,1510
+pandas/tests/apply/test_series_transform.py,sha256=rrJO-C5HagNKJo542h32eB5TOWVDxirJv1u5PXJkh_I,2404
+pandas/tests/apply/test_str.py,sha256=k34l2s3s5p2NUzwUFOtW6sePl9ureo6Q8EaY5PEqy1w,11043
+pandas/tests/arithmetic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/arithmetic/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/arithmetic/__pycache__/common.cpython-312.pyc,,
+pandas/tests/arithmetic/__pycache__/conftest.cpython-312.pyc,,
+pandas/tests/arithmetic/__pycache__/test_array_ops.cpython-312.pyc,,
+pandas/tests/arithmetic/__pycache__/test_categorical.cpython-312.pyc,,
+pandas/tests/arithmetic/__pycache__/test_datetime64.cpython-312.pyc,,
+pandas/tests/arithmetic/__pycache__/test_interval.cpython-312.pyc,,
+pandas/tests/arithmetic/__pycache__/test_numeric.cpython-312.pyc,,
+pandas/tests/arithmetic/__pycache__/test_object.cpython-312.pyc,,
+pandas/tests/arithmetic/__pycache__/test_period.cpython-312.pyc,,
+pandas/tests/arithmetic/__pycache__/test_timedelta64.cpython-312.pyc,,
+pandas/tests/arithmetic/common.py,sha256=C_s1Zc2_0U_oBciQNt5xJp-8FaLmkscEdmnX2Nq16UY,4362
+pandas/tests/arithmetic/conftest.py,sha256=uUtu5-T5FBdFQAo21vRLQSHPiNEjWkc69UwH6llpnsM,3473
+pandas/tests/arithmetic/test_array_ops.py,sha256=4lmZRZAlbJEnphzzwfcvsO4kEv1LG9l3uCmaF_8kcAA,1064
+pandas/tests/arithmetic/test_categorical.py,sha256=lK5fXv4cRIu69ocvOHfKL5bjeK0jDdW3psvrrssjDoA,742
+pandas/tests/arithmetic/test_datetime64.py,sha256=f97V90PrRZrFZ_IrBxfEtgDXvYI_JGqMsIl__9b0y9E,90255
+pandas/tests/arithmetic/test_interval.py,sha256=2TG1Lh4VZXaxwjs5y5RjXzIukOfoVetyLfPlOo5h4vQ,10951
+pandas/tests/arithmetic/test_numeric.py,sha256=569JY7Pjl453iXP_txrlktVyUyH1CR_3677due2sfwU,55511
+pandas/tests/arithmetic/test_object.py,sha256=PJ-_UpBqHXs1_29Q60xlhK4J0m2yX-HIvW_Auknsr98,13525
+pandas/tests/arithmetic/test_period.py,sha256=uxdkrPIpMM7BWUKmwloViCEE1JtOsxkXKCdfxLQ6E1A,59617
+pandas/tests/arithmetic/test_timedelta64.py,sha256=OH0dD4KNrVEf8FlC75MezthgEDohA8dyk3uxwouF8LM,78911
+pandas/tests/arrays/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/arrays/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/arrays/__pycache__/masked_shared.cpython-312.pyc,,
+pandas/tests/arrays/__pycache__/test_array.cpython-312.pyc,,
+pandas/tests/arrays/__pycache__/test_datetimelike.cpython-312.pyc,,
+pandas/tests/arrays/__pycache__/test_datetimes.cpython-312.pyc,,
+pandas/tests/arrays/__pycache__/test_ndarray_backed.cpython-312.pyc,,
+pandas/tests/arrays/__pycache__/test_period.cpython-312.pyc,,
+pandas/tests/arrays/__pycache__/test_timedeltas.cpython-312.pyc,,
+pandas/tests/arrays/boolean/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/arrays/boolean/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/arrays/boolean/__pycache__/test_arithmetic.cpython-312.pyc,,
+pandas/tests/arrays/boolean/__pycache__/test_astype.cpython-312.pyc,,
+pandas/tests/arrays/boolean/__pycache__/test_comparison.cpython-312.pyc,,
+pandas/tests/arrays/boolean/__pycache__/test_construction.cpython-312.pyc,,
+pandas/tests/arrays/boolean/__pycache__/test_function.cpython-312.pyc,,
+pandas/tests/arrays/boolean/__pycache__/test_indexing.cpython-312.pyc,,
+pandas/tests/arrays/boolean/__pycache__/test_logical.cpython-312.pyc,,
+pandas/tests/arrays/boolean/__pycache__/test_ops.cpython-312.pyc,,
+pandas/tests/arrays/boolean/__pycache__/test_reduction.cpython-312.pyc,,
+pandas/tests/arrays/boolean/__pycache__/test_repr.cpython-312.pyc,,
+pandas/tests/arrays/boolean/test_arithmetic.py,sha256=C6y1v1C7kz73WCfl3MS-KleylT4aYdVUDdtP0RBxrg8,4241
+pandas/tests/arrays/boolean/test_astype.py,sha256=0AEVw8lNNjHomdqgpQ7ZYCauUb23QHvxY3NPDe7vIQw,1614
+pandas/tests/arrays/boolean/test_comparison.py,sha256=QIX85ffCwMvtzXtLkWePFQkso_mVtIffWpbgy4ykEz0,1976
+pandas/tests/arrays/boolean/test_construction.py,sha256=1KGaMjJ3FTmoisMbEnKUuxAkylVyzTsfuRXZV5UXlIk,12332
+pandas/tests/arrays/boolean/test_function.py,sha256=eAVsu1XUeokLh7Ko0-bDNUQqmVrGAyOvv9vJdWCQj0M,4061
+pandas/tests/arrays/boolean/test_indexing.py,sha256=BorrK8_ZJbN5HWcIX9fCP-BbTCaJsgAGUiza5IwhYr4,361
+pandas/tests/arrays/boolean/test_logical.py,sha256=7kJTl0KbLA7n8dOV0PZtiZ7gPm65Ggc3p0tHOF5i0d0,9335
+pandas/tests/arrays/boolean/test_ops.py,sha256=iM_FRYMtvvdEpMtLUSuBd_Ww5nHr284v2fRxHaydvIM,975
+pandas/tests/arrays/boolean/test_reduction.py,sha256=eBdonU5n9zsbC86AscHCLxF68XqiqhWWyBJV-7YCOdA,2183
+pandas/tests/arrays/boolean/test_repr.py,sha256=RRljPIDi6jDNhUdbjKMc75Mst-wm92l-H6b5Y-lCCJA,437
+pandas/tests/arrays/categorical/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/arrays/categorical/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/arrays/categorical/__pycache__/test_algos.cpython-312.pyc,,
+pandas/tests/arrays/categorical/__pycache__/test_analytics.cpython-312.pyc,,
+pandas/tests/arrays/categorical/__pycache__/test_api.cpython-312.pyc,,
+pandas/tests/arrays/categorical/__pycache__/test_astype.cpython-312.pyc,,
+pandas/tests/arrays/categorical/__pycache__/test_constructors.cpython-312.pyc,,
+pandas/tests/arrays/categorical/__pycache__/test_dtypes.cpython-312.pyc,,
+pandas/tests/arrays/categorical/__pycache__/test_indexing.cpython-312.pyc,,
+pandas/tests/arrays/categorical/__pycache__/test_map.cpython-312.pyc,,
+pandas/tests/arrays/categorical/__pycache__/test_missing.cpython-312.pyc,,
+pandas/tests/arrays/categorical/__pycache__/test_operators.cpython-312.pyc,,
+pandas/tests/arrays/categorical/__pycache__/test_replace.cpython-312.pyc,,
+pandas/tests/arrays/categorical/__pycache__/test_repr.cpython-312.pyc,,
+pandas/tests/arrays/categorical/__pycache__/test_sorting.cpython-312.pyc,,
+pandas/tests/arrays/categorical/__pycache__/test_subclass.cpython-312.pyc,,
+pandas/tests/arrays/categorical/__pycache__/test_take.cpython-312.pyc,,
+pandas/tests/arrays/categorical/__pycache__/test_warnings.cpython-312.pyc,,
+pandas/tests/arrays/categorical/test_algos.py,sha256=SLguZHlE5eyi14kRoMUGpIohPJM7jQqboKlnTvidpg0,2710
+pandas/tests/arrays/categorical/test_analytics.py,sha256=Bl7A_lPouoS7uK8EnybqvtMXp6WatI7U89OQwMecWVY,13213
+pandas/tests/arrays/categorical/test_api.py,sha256=Ivy3G6MW43fLMYwWn9QdE9wXRxLrpF8IFoUpB-TplCc,19879
+pandas/tests/arrays/categorical/test_astype.py,sha256=EJc8J2mrxN2Epg_6ufPxf3qLlqIsV66dyDbvjJoJDJg,5546
+pandas/tests/arrays/categorical/test_constructors.py,sha256=NFmmMYKBtBHxrM3d4nBxG0Zck1-n-uEQsbADePuAbl0,30705
+pandas/tests/arrays/categorical/test_dtypes.py,sha256=h1ZhuPvbHp9aFA4doAkmQ96zQW4A5UX6y6Yv2G5QTb8,5523
+pandas/tests/arrays/categorical/test_indexing.py,sha256=u43KuLMFtxe5ZAs0dphmGqpHsygyxtmTHxdGEfoDVQg,12972
+pandas/tests/arrays/categorical/test_map.py,sha256=TO6GY6B2n2dhkcNRQinbvID9eBfwtVnWsT1yexQg00U,5152
+pandas/tests/arrays/categorical/test_missing.py,sha256=5KdSj982_KUkfB8Cg-l7Jcir5I8n7Gz6SbnHnIqmu8A,7814
+pandas/tests/arrays/categorical/test_operators.py,sha256=NDc6FKDGOrGIdvSDpJ9Mq9O-aE0xw-LoI6L-rcrW0cI,15968
+pandas/tests/arrays/categorical/test_replace.py,sha256=I3jiQGmNSQ2i1WTLgVjIKcH-D919sf9EWTOm-hh_emE,4102
+pandas/tests/arrays/categorical/test_repr.py,sha256=4ft4OCt7r3qZDFd5CPrsyYSq7ZVrxcrRwpxQs91Mm-A,27107
+pandas/tests/arrays/categorical/test_sorting.py,sha256=gEhLklhDxhqf8UDOB17TMKhrabxS5n0evPg9DWSMd5s,5052
+pandas/tests/arrays/categorical/test_subclass.py,sha256=Y4nURd4hFM0Q3aVET1OO-z11pZzzZ0HFfl2s-9OWemw,903
+pandas/tests/arrays/categorical/test_take.py,sha256=O4g_LYDeK0NzHDId5cBBEp1ns_a762NsYHn088ocYzg,3501
+pandas/tests/arrays/categorical/test_warnings.py,sha256=XqvGeAb9lrXP1VdwKSOvbDuytqDuJ5VSDsLKQAa5gIk,682
+pandas/tests/arrays/datetimes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/arrays/datetimes/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/arrays/datetimes/__pycache__/test_constructors.cpython-312.pyc,,
+pandas/tests/arrays/datetimes/__pycache__/test_cumulative.cpython-312.pyc,,
+pandas/tests/arrays/datetimes/__pycache__/test_reductions.cpython-312.pyc,,
+pandas/tests/arrays/datetimes/test_constructors.py,sha256=xZsxdsUxxbk7UCawlCS3_aAkhsuexX0-uf3XQMlvSA8,11050
+pandas/tests/arrays/datetimes/test_cumulative.py,sha256=X_SHtt9n_WzA_C2wPlRJHRS8LUmjNNmr2-XL6AszJd0,1307
+pandas/tests/arrays/datetimes/test_reductions.py,sha256=Cg1qwq8wASnMeOdZ5_wowrILL6e1ZT_j8m-rIOkwrkg,5787
+pandas/tests/arrays/floating/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/arrays/floating/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/arrays/floating/__pycache__/conftest.cpython-312.pyc,,
+pandas/tests/arrays/floating/__pycache__/test_arithmetic.cpython-312.pyc,,
+pandas/tests/arrays/floating/__pycache__/test_astype.cpython-312.pyc,,
+pandas/tests/arrays/floating/__pycache__/test_comparison.cpython-312.pyc,,
+pandas/tests/arrays/floating/__pycache__/test_concat.cpython-312.pyc,,
+pandas/tests/arrays/floating/__pycache__/test_construction.cpython-312.pyc,,
+pandas/tests/arrays/floating/__pycache__/test_contains.cpython-312.pyc,,
+pandas/tests/arrays/floating/__pycache__/test_function.cpython-312.pyc,,
+pandas/tests/arrays/floating/__pycache__/test_repr.cpython-312.pyc,,
+pandas/tests/arrays/floating/__pycache__/test_to_numpy.cpython-312.pyc,,
+pandas/tests/arrays/floating/conftest.py,sha256=PkAOd0oDvePBtXL-N0MnmEGCmDMP3_Dw-YwpxgNfl-k,1161
+pandas/tests/arrays/floating/test_arithmetic.py,sha256=z2y4ca3ntG7WZPntefFBO5IbwLSc98uNUHJeoKzi_Dc,8353
+pandas/tests/arrays/floating/test_astype.py,sha256=pvgAFQ0bTRyuoBpgmiyQza_zPOXBC7RYdGJc7F6tP4c,4047
+pandas/tests/arrays/floating/test_comparison.py,sha256=C-rwNTv5FtUvo3oWB8XNquCOa_XQHf6R9JRYX6JVAG0,2071
+pandas/tests/arrays/floating/test_concat.py,sha256=-RO-pwRRY93FQnOjBLs1fMVf7uBCoEGRkGWPAdX8ltU,573
+pandas/tests/arrays/floating/test_construction.py,sha256=weDvGh2hSfHmVnQ-6Kc5QmAUaGTF9mvEI3qtZSEHHAk,6455
+pandas/tests/arrays/floating/test_contains.py,sha256=oTsN_kyhRi7hHdKRzi9PzwSu2gHiE3EP4FkuR31BZFM,204
+pandas/tests/arrays/floating/test_function.py,sha256=YiXRdFHEU2iAGXwd68kDyfsjBZ8ztoC8fikZU6AnbRE,6403
+pandas/tests/arrays/floating/test_repr.py,sha256=N_BX7NbU8Pljiz2bouWMzrP22xh_6w_8pHePEB2ycVw,1157
+pandas/tests/arrays/floating/test_to_numpy.py,sha256=d0k_2WXrkIu4JOGkIQlzijmgsm7X-XW2XmobaN_3Q_s,4954
+pandas/tests/arrays/integer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/arrays/integer/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/arrays/integer/__pycache__/conftest.cpython-312.pyc,,
+pandas/tests/arrays/integer/__pycache__/test_arithmetic.cpython-312.pyc,,
+pandas/tests/arrays/integer/__pycache__/test_comparison.cpython-312.pyc,,
+pandas/tests/arrays/integer/__pycache__/test_concat.cpython-312.pyc,,
+pandas/tests/arrays/integer/__pycache__/test_construction.cpython-312.pyc,,
+pandas/tests/arrays/integer/__pycache__/test_dtypes.cpython-312.pyc,,
+pandas/tests/arrays/integer/__pycache__/test_function.cpython-312.pyc,,
+pandas/tests/arrays/integer/__pycache__/test_indexing.cpython-312.pyc,,
+pandas/tests/arrays/integer/__pycache__/test_reduction.cpython-312.pyc,,
+pandas/tests/arrays/integer/__pycache__/test_repr.cpython-312.pyc,,
+pandas/tests/arrays/integer/conftest.py,sha256=TejO1KxvoPETsN-ZdefGePhwJ-szaoYanP9AQXHgY18,1555
+pandas/tests/arrays/integer/test_arithmetic.py,sha256=JAlNBmbw3cR-XhUVHqyRk61Xth__oFFq_h6H-88LRaI,12391
+pandas/tests/arrays/integer/test_comparison.py,sha256=jUr8dmk_6FQsTNjDkYsazWnioHis4cLi94noy4txG54,1212
+pandas/tests/arrays/integer/test_concat.py,sha256=TmHNsCxxvp-KDLD5SaTmeEuWJDzUS51Eg04uSWet9Pg,2351
+pandas/tests/arrays/integer/test_construction.py,sha256=jnzOs0w8i4X55JOrtXc0ylMaiBo8mhRl6uwrnEWr_0o,7768
+pandas/tests/arrays/integer/test_dtypes.py,sha256=5pq5zqlv9oEGyk8v0KOUF_BCwnsogS08uEnCV1cF0yk,8756
+pandas/tests/arrays/integer/test_function.py,sha256=hCqZIrrISPtn_7mlX92wpQNItAF1o-q-g56W93wnyhI,6627
+pandas/tests/arrays/integer/test_indexing.py,sha256=rgwcafGbwJztl_N4CalvAnW6FKfKVNzJcE-RjcXMpR8,498
+pandas/tests/arrays/integer/test_reduction.py,sha256=vOyzjEWQTpsGXLOa2H8ehkahUiYBBcKvEI__6YQtzdo,4215
+pandas/tests/arrays/integer/test_repr.py,sha256=fLTZusgFHPXO4orpygmHIOG6JQLzYcdbTJHRvvsN0sM,1652
+pandas/tests/arrays/interval/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/arrays/interval/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/arrays/interval/__pycache__/test_astype.cpython-312.pyc,,
+pandas/tests/arrays/interval/__pycache__/test_formats.cpython-312.pyc,,
+pandas/tests/arrays/interval/__pycache__/test_interval.cpython-312.pyc,,
+pandas/tests/arrays/interval/__pycache__/test_interval_pyarrow.cpython-312.pyc,,
+pandas/tests/arrays/interval/__pycache__/test_overlaps.cpython-312.pyc,,
+pandas/tests/arrays/interval/test_astype.py,sha256=8rb7rssqvIoSztzCfFb5pY4oIH_GjDStKrXkC6bnUZk,776
+pandas/tests/arrays/interval/test_formats.py,sha256=AARSRfiyQa0Fu6jCBdhx83yJOXdCWtfs0q0Yd8mMxwg,317
+pandas/tests/arrays/interval/test_interval.py,sha256=cfZXy6J5AtUqwd5HY4m9lxTyu0m0xsZbD9FlcBebuio,8082
+pandas/tests/arrays/interval/test_interval_pyarrow.py,sha256=PkPTrpsrTLL_3Vd17ENP0I3NFE71XpSQi38HG09hXxo,5202
+pandas/tests/arrays/interval/test_overlaps.py,sha256=4QNJBVY5Fb150Rf3lS5a6p_ScHy8U-sAuWTWetbCmVc,3279
+pandas/tests/arrays/masked/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/arrays/masked/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/arrays/masked/__pycache__/test_arithmetic.cpython-312.pyc,,
+pandas/tests/arrays/masked/__pycache__/test_arrow_compat.cpython-312.pyc,,
+pandas/tests/arrays/masked/__pycache__/test_function.cpython-312.pyc,,
+pandas/tests/arrays/masked/__pycache__/test_indexing.cpython-312.pyc,,
+pandas/tests/arrays/masked/test_arithmetic.py,sha256=wchNK8BesRBPSclagK_egl_EG9J4KPCquzL9iRZOK20,8175
+pandas/tests/arrays/masked/test_arrow_compat.py,sha256=0uJbBERGPJs4G_BweVktYjW2Z82LD48zdx7rHGQybfM,7193
+pandas/tests/arrays/masked/test_function.py,sha256=qkFCkI5KNijaX2SurVoilnhtBFbismLBS4SyEybNXZ8,1954
+pandas/tests/arrays/masked/test_indexing.py,sha256=xjr8EECp7WStcIeEY8YNhmkZ90Q2o-l3izolkLpG2W0,1916
+pandas/tests/arrays/masked_shared.py,sha256=ANp_CU9Hcly9-NBxknm7g-uWxljstTmriq3S8f5kPsM,5194
+pandas/tests/arrays/numpy_/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/arrays/numpy_/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/arrays/numpy_/__pycache__/test_indexing.cpython-312.pyc,,
+pandas/tests/arrays/numpy_/__pycache__/test_numpy.cpython-312.pyc,,
+pandas/tests/arrays/numpy_/test_indexing.py,sha256=-0lB-Mw-gzM4Mpe-SRCj-w4C6QxLfp3BH65U_DVULNY,1452
+pandas/tests/arrays/numpy_/test_numpy.py,sha256=N4s8S8Kp8YwUZgtza6wUB5RnI_5WYaXMAFQxvEMOXKo,8764
+pandas/tests/arrays/period/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/arrays/period/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/arrays/period/__pycache__/test_arrow_compat.cpython-312.pyc,,
+pandas/tests/arrays/period/__pycache__/test_astype.cpython-312.pyc,,
+pandas/tests/arrays/period/__pycache__/test_constructors.cpython-312.pyc,,
+pandas/tests/arrays/period/__pycache__/test_reductions.cpython-312.pyc,,
+pandas/tests/arrays/period/test_arrow_compat.py,sha256=YuEM6oIOfRhdFaTFs5X0um9nLqygEkuxIZGl9V-qQcg,3709
+pandas/tests/arrays/period/test_astype.py,sha256=lKLDDqZSdU7s6PyHbrywkaCJnMJ4TKSphRqmno7BcbU,2344
+pandas/tests/arrays/period/test_constructors.py,sha256=C6J0nmKRSK5nyEja7-gZgf5tCZpPA0aZ9lux-z6gHxA,5089
+pandas/tests/arrays/period/test_reductions.py,sha256=gYiheQK3Z0Bwdo-0UaHIyfXGpmL1_UvoMP9FVIpztlM,1050
+pandas/tests/arrays/sparse/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/arrays/sparse/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/arrays/sparse/__pycache__/test_accessor.cpython-312.pyc,,
+pandas/tests/arrays/sparse/__pycache__/test_arithmetics.cpython-312.pyc,,
+pandas/tests/arrays/sparse/__pycache__/test_array.cpython-312.pyc,,
+pandas/tests/arrays/sparse/__pycache__/test_astype.cpython-312.pyc,,
+pandas/tests/arrays/sparse/__pycache__/test_combine_concat.cpython-312.pyc,,
+pandas/tests/arrays/sparse/__pycache__/test_constructors.cpython-312.pyc,,
+pandas/tests/arrays/sparse/__pycache__/test_dtype.cpython-312.pyc,,
+pandas/tests/arrays/sparse/__pycache__/test_indexing.cpython-312.pyc,,
+pandas/tests/arrays/sparse/__pycache__/test_libsparse.cpython-312.pyc,,
+pandas/tests/arrays/sparse/__pycache__/test_reductions.cpython-312.pyc,,
+pandas/tests/arrays/sparse/__pycache__/test_unary.cpython-312.pyc,,
+pandas/tests/arrays/sparse/test_accessor.py,sha256=EReITkC1ib-_36L6gS5UfjWai_Brp8Iaf4w7WObJZjM,9025
+pandas/tests/arrays/sparse/test_arithmetics.py,sha256=TC2Af6gA4OkRIxDTWy_5jmHNIrgsqWGmOVF707wOn8M,20152
+pandas/tests/arrays/sparse/test_array.py,sha256=HbW0y7KLlWPz3QI6gtE44ZRZF5vS8ZwjM3IjOQfNNSQ,16794
+pandas/tests/arrays/sparse/test_astype.py,sha256=JwcFBWzfg2KOv9_6GsP0oV4WWDmFugT8dHrXDWCLZwM,4763
+pandas/tests/arrays/sparse/test_combine_concat.py,sha256=3NMQXaRQc7Bxn5HhSHffcUE24GZi_VYflnFLnixOgbs,2651
+pandas/tests/arrays/sparse/test_constructors.py,sha256=N5GJ8SrwVZ4hNGaM_QlALl283EM13nSVbtO8uBRSAwY,10835
+pandas/tests/arrays/sparse/test_dtype.py,sha256=xcZIrh0SPqvPzMt9EbMF04ADSu5Xueemvl81llkjq64,6122
+pandas/tests/arrays/sparse/test_indexing.py,sha256=8INC1paA06XrCp8L63FSllr0OK48pgiKda5sOgrUhf8,10425
+pandas/tests/arrays/sparse/test_libsparse.py,sha256=_hfr36t-jm-QOhI9Gwbd6sQZI5aVWMMixHY-OYOqKuM,19293
+pandas/tests/arrays/sparse/test_reductions.py,sha256=D7R_jhlFtmH8l-tERmhtP1K3KbcAyPuyIy_Y_gVcN6Q,9721
+pandas/tests/arrays/sparse/test_unary.py,sha256=GtqeMdylKdtu-0HPxmTDVjo32riOcEtqPhjI_XK5LkM,2864
+pandas/tests/arrays/string_/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/arrays/string_/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/arrays/string_/__pycache__/test_string.cpython-312.pyc,,
+pandas/tests/arrays/string_/__pycache__/test_string_arrow.cpython-312.pyc,,
+pandas/tests/arrays/string_/test_string.py,sha256=2Jb7cC3pDkGA0nhEwsIgW0tNJ4meEy8htFwX3zO9Flc,23988
+pandas/tests/arrays/string_/test_string_arrow.py,sha256=JbP4dLrozNXsjwzqiiTXzbrPo7CVGYFl9nsmAEPSkFg,9140
+pandas/tests/arrays/test_array.py,sha256=xFDZAd6Lls_wI782aoOOFJGPA-XEiyE5JvftU03RRkg,15663
+pandas/tests/arrays/test_datetimelike.py,sha256=SpCxw8hR_Ocbm5tNrUcGPTTIduEGdSJPxRkyEtKZLkI,45423
+pandas/tests/arrays/test_datetimes.py,sha256=FoODE0J_-8KIBbNS5ROkEWVgNnF3PwaToqJ38YtiAYU,29112
+pandas/tests/arrays/test_ndarray_backed.py,sha256=6unFuF9S6hG5FDJDjiqbKg3rL8ItzJQHwY9vMdju4-0,2331
+pandas/tests/arrays/test_period.py,sha256=S_7TMRLEmVamhGKlVO50qJIj3OFDWRzY_oxEcXzp3zs,5572
+pandas/tests/arrays/test_timedeltas.py,sha256=VdMdnCrOL5_oUa4RxL-gaVre6Qp3iu__qNMaUb7kqfE,10673
+pandas/tests/arrays/timedeltas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/arrays/timedeltas/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/arrays/timedeltas/__pycache__/test_constructors.cpython-312.pyc,,
+pandas/tests/arrays/timedeltas/__pycache__/test_cumulative.cpython-312.pyc,,
+pandas/tests/arrays/timedeltas/__pycache__/test_reductions.cpython-312.pyc,,
+pandas/tests/arrays/timedeltas/test_constructors.py,sha256=gwBy_iuOc-EEMusjK2bITGQhCyeeI9OzI9uI8xOact0,4248
+pandas/tests/arrays/timedeltas/test_cumulative.py,sha256=cRR6I-lIsefG95vEZb8TuXdvmw7pdPFedpBneLVKBG8,692
+pandas/tests/arrays/timedeltas/test_reductions.py,sha256=cw6I3Bxi0R2_DD2y1WD-AHTYR_ufAtN9ztCtDGypQnM,6520
+pandas/tests/base/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/base/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/base/__pycache__/common.cpython-312.pyc,,
+pandas/tests/base/__pycache__/test_constructors.cpython-312.pyc,,
+pandas/tests/base/__pycache__/test_conversion.cpython-312.pyc,,
+pandas/tests/base/__pycache__/test_fillna.cpython-312.pyc,,
+pandas/tests/base/__pycache__/test_misc.cpython-312.pyc,,
+pandas/tests/base/__pycache__/test_transpose.cpython-312.pyc,,
+pandas/tests/base/__pycache__/test_unique.cpython-312.pyc,,
+pandas/tests/base/__pycache__/test_value_counts.cpython-312.pyc,,
+pandas/tests/base/common.py,sha256=-cLXvhzuQi0XMfU-NdqTQAiruN0MU9A9HE2goo7ZzJQ,266
+pandas/tests/base/test_constructors.py,sha256=mFPWRfNgWYQyYqhYKErJ-obd1hVWfm50aMFH5wgHkU0,5309
+pandas/tests/base/test_conversion.py,sha256=fm58V7TCp45uXmJAQRyF7yz3e6ydG6JVCQ2oanNb7xY,17685
+pandas/tests/base/test_fillna.py,sha256=q9LZhUp2HXaVQw4wSxK0VU4Z9z62WI12r9ivsZu0gOg,1522
+pandas/tests/base/test_misc.py,sha256=FwzkBajbi3JLRuzaapLTrRI803DqKgME68WWo1jhhjc,6040
+pandas/tests/base/test_transpose.py,sha256=138_O_JwwdCmfmyjp47PSVa-4Sr7SOuLprr0PzRm6BQ,1694
+pandas/tests/base/test_unique.py,sha256=tMDzvNfhUYXRl2IOYvlHo0cuFbLrE-oR1bPJc0hFAio,4370
+pandas/tests/base/test_value_counts.py,sha256=e-OG-UOKyEIxOim4TXa4rGbaOzeb8l6XemkruFfDyw4,11778
+pandas/tests/computation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/computation/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/computation/__pycache__/test_compat.cpython-312.pyc,,
+pandas/tests/computation/__pycache__/test_eval.cpython-312.pyc,,
+pandas/tests/computation/test_compat.py,sha256=dHstyvdaXybrwm1WQndV9aQBwOsOvCIVZb5pxLXsYfM,872
+pandas/tests/computation/test_eval.py,sha256=tAJDNLwur6BJUEqUzOce3Gr2UcrpJWFHE7dRDi4Hfb4,71739
+pandas/tests/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/config/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/config/__pycache__/test_config.cpython-312.pyc,,
+pandas/tests/config/__pycache__/test_localization.cpython-312.pyc,,
+pandas/tests/config/test_config.py,sha256=T3PKV_lWTp_4ZU566fpWt_N9_tr3BfsxHlJ_vqnQiiQ,15858
+pandas/tests/config/test_localization.py,sha256=xC7SJfih_Kus5WGpSWZdwyAQR3ttgpsxxlNesbwrYfM,4479
+pandas/tests/construction/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/construction/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/construction/__pycache__/test_extract_array.cpython-312.pyc,,
+pandas/tests/construction/test_extract_array.py,sha256=L3fEjATPsAy3a6zrdQJaXXaQ7FvR2LOeiPJMjGNkwKQ,637
+pandas/tests/copy_view/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/copy_view/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/copy_view/__pycache__/test_array.cpython-312.pyc,,
+pandas/tests/copy_view/__pycache__/test_astype.cpython-312.pyc,,
+pandas/tests/copy_view/__pycache__/test_chained_assignment_deprecation.cpython-312.pyc,,
+pandas/tests/copy_view/__pycache__/test_clip.cpython-312.pyc,,
+pandas/tests/copy_view/__pycache__/test_constructors.cpython-312.pyc,,
+pandas/tests/copy_view/__pycache__/test_core_functionalities.cpython-312.pyc,,
+pandas/tests/copy_view/__pycache__/test_functions.cpython-312.pyc,,
+pandas/tests/copy_view/__pycache__/test_indexing.cpython-312.pyc,,
+pandas/tests/copy_view/__pycache__/test_internals.cpython-312.pyc,,
+pandas/tests/copy_view/__pycache__/test_interp_fillna.cpython-312.pyc,,
+pandas/tests/copy_view/__pycache__/test_methods.cpython-312.pyc,,
+pandas/tests/copy_view/__pycache__/test_replace.cpython-312.pyc,,
+pandas/tests/copy_view/__pycache__/test_setitem.cpython-312.pyc,,
+pandas/tests/copy_view/__pycache__/test_util.cpython-312.pyc,,
+pandas/tests/copy_view/__pycache__/util.cpython-312.pyc,,
+pandas/tests/copy_view/index/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/copy_view/index/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/copy_view/index/__pycache__/test_datetimeindex.cpython-312.pyc,,
+pandas/tests/copy_view/index/__pycache__/test_index.cpython-312.pyc,,
+pandas/tests/copy_view/index/__pycache__/test_periodindex.cpython-312.pyc,,
+pandas/tests/copy_view/index/__pycache__/test_timedeltaindex.cpython-312.pyc,,
+pandas/tests/copy_view/index/test_datetimeindex.py,sha256=Sl224XCNK_lx-N6k9heXS_g2_bwmqCJJyKDv7pE_HQw,1980
+pandas/tests/copy_view/index/test_index.py,sha256=B849E4vf72tsWv11NfixJU6vjX0gpMlyvHRKSBk0V1Q,5363
+pandas/tests/copy_view/index/test_periodindex.py,sha256=qSR4PUuAHEPq1o8NUeif_MSrN43rvSeWQtsmTK6I1a4,653
+pandas/tests/copy_view/index/test_timedeltaindex.py,sha256=L1fGDsy2dmZqf_y3bXVo9mUMr1Jsli9BdScChOEQkns,661
+pandas/tests/copy_view/test_array.py,sha256=t4Tk1_-bwXOpuE80MqCkVsEsb753CPq6A87ZCI3WJBo,5840
+pandas/tests/copy_view/test_astype.py,sha256=SHB7qM1GIjguoiqzO9tPosiPVG7cftVbIzlau9lgXW0,8935
+pandas/tests/copy_view/test_chained_assignment_deprecation.py,sha256=BJqJ30DdsTUeoUZZm2kZKFOwUoz9Rkmg5AH3R6nk0F4,5750
+pandas/tests/copy_view/test_clip.py,sha256=ahKf7EUwJeYahLnPVhUuNanG4Va53Ez5kULzCdzeX60,3077
+pandas/tests/copy_view/test_constructors.py,sha256=JMWj_yBB7tNSTkUxdbhtzTVyJ03jho9imeKMXZaTb38,13950
+pandas/tests/copy_view/test_core_functionalities.py,sha256=M-ExonPcx6W-8z_TLTaP16DJtelSVeQHZKO1aWObSuA,3506
+pandas/tests/copy_view/test_functions.py,sha256=FZP92GSOEUNCVogDxngdGS2eodNwhw7w7Xs6jQgZGyg,15505
+pandas/tests/copy_view/test_indexing.py,sha256=4OUGrcgMHlai3p7tQt0sXopNYTrGdEFSUaVf6S7ZzyI,42980
+pandas/tests/copy_view/test_internals.py,sha256=mBEJH08zBch3LBtSzU7wXqBKc01uH2GTzZgUx3otcC8,5020
+pandas/tests/copy_view/test_interp_fillna.py,sha256=ztjjLWcR07fHYSaaTrrSD6S5s6rrOvUt_2S1BE3tRlQ,15235
+pandas/tests/copy_view/test_methods.py,sha256=ka2yDAm6yXDQC5rpLyxLHYq80XIQGhXUt4RUURvYjSk,71109
+pandas/tests/copy_view/test_replace.py,sha256=5KVB1Xc1qTBOCrhTL0my-36NoDUDRozzZ5bV0oyJLVk,17120
+pandas/tests/copy_view/test_setitem.py,sha256=ewuJiYuD9VI2wuFZiDjGYVP7gnlP4H9uVFnjjelW55U,4822
+pandas/tests/copy_view/test_util.py,sha256=ClWLprMJhf6okUNu9AX6Ar9IXZgKkY0nNuDzHRO70Hk,385
+pandas/tests/copy_view/util.py,sha256=oNtCgxmTmkiM1DiUxjnzTeAxCj_7jjeewtby-3gdoo0,899
+pandas/tests/dtypes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/dtypes/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/dtypes/__pycache__/test_common.cpython-312.pyc,,
+pandas/tests/dtypes/__pycache__/test_concat.cpython-312.pyc,,
+pandas/tests/dtypes/__pycache__/test_dtypes.cpython-312.pyc,,
+pandas/tests/dtypes/__pycache__/test_generic.cpython-312.pyc,,
+pandas/tests/dtypes/__pycache__/test_inference.cpython-312.pyc,,
+pandas/tests/dtypes/__pycache__/test_missing.cpython-312.pyc,,
+pandas/tests/dtypes/cast/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/dtypes/cast/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/dtypes/cast/__pycache__/test_can_hold_element.cpython-312.pyc,,
+pandas/tests/dtypes/cast/__pycache__/test_construct_from_scalar.cpython-312.pyc,,
+pandas/tests/dtypes/cast/__pycache__/test_construct_ndarray.cpython-312.pyc,,
+pandas/tests/dtypes/cast/__pycache__/test_construct_object_arr.cpython-312.pyc,,
+pandas/tests/dtypes/cast/__pycache__/test_dict_compat.cpython-312.pyc,,
+pandas/tests/dtypes/cast/__pycache__/test_downcast.cpython-312.pyc,,
+pandas/tests/dtypes/cast/__pycache__/test_find_common_type.cpython-312.pyc,,
+pandas/tests/dtypes/cast/__pycache__/test_infer_datetimelike.cpython-312.pyc,,
+pandas/tests/dtypes/cast/__pycache__/test_infer_dtype.cpython-312.pyc,,
+pandas/tests/dtypes/cast/__pycache__/test_maybe_box_native.cpython-312.pyc,,
+pandas/tests/dtypes/cast/__pycache__/test_promote.cpython-312.pyc,,
+pandas/tests/dtypes/cast/test_can_hold_element.py,sha256=2zASUgxB7l8ttG2fKjCpIjtt_TQ7j4NJ2L9xFzcyUPU,2408
+pandas/tests/dtypes/cast/test_construct_from_scalar.py,sha256=INdOiQ7MowXLr6ZReCiq0JykUeFvRWocxk3f-ilk9v0,1780
+pandas/tests/dtypes/cast/test_construct_ndarray.py,sha256=Z4tTuoWxUoXiMVq8sJx2PPGIyRoz1dzzRIC1w8npDKQ,1303
+pandas/tests/dtypes/cast/test_construct_object_arr.py,sha256=eOmUu4q0ihGTbYpCleoCnYtvwh1TBCEZQQjLeJaUMNA,717
+pandas/tests/dtypes/cast/test_dict_compat.py,sha256=qyn7kP5b14MywtqOUL5C-NOvjf2qK4PsXGpCvqmo-4E,476
+pandas/tests/dtypes/cast/test_downcast.py,sha256=CzuywDTWQ3xTi__4Nd36qgcx6mDs2tpYUsVztduVC9s,2778
+pandas/tests/dtypes/cast/test_find_common_type.py,sha256=c__GbgnRawwgqWut8g5Q928en8-_O3oTZEQVbqQ8MrE,5226
+pandas/tests/dtypes/cast/test_infer_datetimelike.py,sha256=6vor_eqEbMKcBLEkfayXzVzwwf5BZcCvQhFZuqhvyKU,603
+pandas/tests/dtypes/cast/test_infer_dtype.py,sha256=WCLts2TG3Zs4V69O2f_HYmuXEkSHPUXVTIuGpVvICuY,6001
+pandas/tests/dtypes/cast/test_maybe_box_native.py,sha256=uEkoLnSVi4kR8-c5FMhpEba7luZum3PeRIrxIdeGeM4,996
+pandas/tests/dtypes/cast/test_promote.py,sha256=B4dgs3EWIm8qKuoQMn6FNaGGf_qAm_EAm4l2X3cHDMM,20755
+pandas/tests/dtypes/test_common.py,sha256=8XCSOz1J9y9K9Dxe3c55YOy-ONRlvRc3CWF0EVaxEa8,26390
+pandas/tests/dtypes/test_concat.py,sha256=vlsumyKcJ7b8EdJKONU5txCA34zMaoKDvA0KmcuP8XU,1799
+pandas/tests/dtypes/test_dtypes.py,sha256=7GaJl1ZXzioL7mll-RdNie3eVoki91FogtyBYQdFRkQ,43847
+pandas/tests/dtypes/test_generic.py,sha256=TzUIinbvMdsyxH_y2VYQ2XCYLQXh005qij9LWWF9bDc,4842
+pandas/tests/dtypes/test_inference.py,sha256=uNEZEE9cgR2T3ZTe0pBld9rnbupyx5XilbQj_PmiB20,70781
+pandas/tests/dtypes/test_missing.py,sha256=_FPqIAM5yZbYSlcndWuaItNVkgs3ylKEPb-o63QRzEE,30750
+pandas/tests/extension/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/extension/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/extension/__pycache__/conftest.cpython-312.pyc,,
+pandas/tests/extension/__pycache__/test_arrow.cpython-312.pyc,,
+pandas/tests/extension/__pycache__/test_categorical.cpython-312.pyc,,
+pandas/tests/extension/__pycache__/test_common.cpython-312.pyc,,
+pandas/tests/extension/__pycache__/test_datetime.cpython-312.pyc,,
+pandas/tests/extension/__pycache__/test_extension.cpython-312.pyc,,
+pandas/tests/extension/__pycache__/test_interval.cpython-312.pyc,,
+pandas/tests/extension/__pycache__/test_masked.cpython-312.pyc,,
+pandas/tests/extension/__pycache__/test_numpy.cpython-312.pyc,,
+pandas/tests/extension/__pycache__/test_period.cpython-312.pyc,,
+pandas/tests/extension/__pycache__/test_sparse.cpython-312.pyc,,
+pandas/tests/extension/__pycache__/test_string.cpython-312.pyc,,
+pandas/tests/extension/array_with_attr/__init__.py,sha256=bXkwWSW6GRX8Xw221iMyaQOQVaWmyuRP3tGhvjXtiV8,149
+pandas/tests/extension/array_with_attr/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/extension/array_with_attr/__pycache__/array.cpython-312.pyc,,
+pandas/tests/extension/array_with_attr/__pycache__/test_array_with_attr.cpython-312.pyc,,
+pandas/tests/extension/array_with_attr/array.py,sha256=Vo6gYBpAJHAztlq8m3gH-9GqKUkxSOHg2fk6cApHgFE,2496
+pandas/tests/extension/array_with_attr/test_array_with_attr.py,sha256=TuuBA1lCxjVOgWsWM9jhgc-PyGuXzajO3UWWKZEquZA,1373
+pandas/tests/extension/base/__init__.py,sha256=5OjQDaQnbihqkwRdCBAV-eF-QRE8p3V4frJ764P5-jQ,4353
+pandas/tests/extension/base/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/extension/base/__pycache__/accumulate.cpython-312.pyc,,
+pandas/tests/extension/base/__pycache__/base.cpython-312.pyc,,
+pandas/tests/extension/base/__pycache__/casting.cpython-312.pyc,,
+pandas/tests/extension/base/__pycache__/constructors.cpython-312.pyc,,
+pandas/tests/extension/base/__pycache__/dim2.cpython-312.pyc,,
+pandas/tests/extension/base/__pycache__/dtype.cpython-312.pyc,,
+pandas/tests/extension/base/__pycache__/getitem.cpython-312.pyc,,
+pandas/tests/extension/base/__pycache__/groupby.cpython-312.pyc,,
+pandas/tests/extension/base/__pycache__/index.cpython-312.pyc,,
+pandas/tests/extension/base/__pycache__/interface.cpython-312.pyc,,
+pandas/tests/extension/base/__pycache__/io.cpython-312.pyc,,
+pandas/tests/extension/base/__pycache__/methods.cpython-312.pyc,,
+pandas/tests/extension/base/__pycache__/missing.cpython-312.pyc,,
+pandas/tests/extension/base/__pycache__/ops.cpython-312.pyc,,
+pandas/tests/extension/base/__pycache__/printing.cpython-312.pyc,,
+pandas/tests/extension/base/__pycache__/reduce.cpython-312.pyc,,
+pandas/tests/extension/base/__pycache__/reshaping.cpython-312.pyc,,
+pandas/tests/extension/base/__pycache__/setitem.cpython-312.pyc,,
+pandas/tests/extension/base/accumulate.py,sha256=66bubZOQfkzzpcca1jz2WVky4mxi4uGyq8TsQpV288k,1411
+pandas/tests/extension/base/base.py,sha256=aSfTPvuvzzQUxEIrGUASWuwcVv6Uw5bvkFXvqjhRV1M,35
+pandas/tests/extension/base/casting.py,sha256=KWGZGeC1Kh2mDXUto7Xap6lkSja8661Qi1g58HgFpSM,3077
+pandas/tests/extension/base/constructors.py,sha256=Y2Pny2SrEj7jsCEUN6KRKi_9G2HA7RIfVs5GVf9Nz5w,5609
+pandas/tests/extension/base/dim2.py,sha256=8Ni4nnBW5wxH3e6f0kX1yTDjecmd12sAZdkBt-1tTss,11992
+pandas/tests/extension/base/dtype.py,sha256=4v3RO3H-2xDIPujcTYdjb0AzWpctqALOXUHLHyHBLDg,4006
+pandas/tests/extension/base/getitem.py,sha256=leq9dxp_KexAv7mhexLCWXcIMKNBPOVfhFv6Nuc5PkQ,15673
+pandas/tests/extension/base/groupby.py,sha256=5A_X0G3x1MD13QXpX-v0nYABeU9TRINcvOwVhd3JBpQ,6465
+pandas/tests/extension/base/index.py,sha256=fD5Jugbt_39nZ1eVjPNdAgoDRuNXTcnZB9lA4w687vM,517
+pandas/tests/extension/base/interface.py,sha256=rdJUhxcnMwnHUoGzhj0_89ik5JETiTz0kjDmepTU5lU,4699
+pandas/tests/extension/base/io.py,sha256=SNvCa6LXo-4V92Bm6A1RZPXwfDdu3hTWLje8_D3Xwo8,1475
+pandas/tests/extension/base/methods.py,sha256=xQvGXCoxo-_1A-fonAgDbB7GyFeg22RAxbjxTeL2lnM,26723
+pandas/tests/extension/base/missing.py,sha256=D4by9EHLsc32icNeDutH7JdoGyHE8pD0XPM2o7FiGQU,6606
+pandas/tests/extension/base/ops.py,sha256=EmsLXfCMbJf4RAru_ewAhc_Epd-ZAROKygwjBf7EzYg,11058
+pandas/tests/extension/base/printing.py,sha256=pVwGn1id_vO_b9nrz3M9Q_Qh9vqDqC0eZHom0_oGr-A,1109
+pandas/tests/extension/base/reduce.py,sha256=IaF6nI-fMTYzG4fNVUoPei_lf9vCHHIf0NnKCssnYlk,5968
+pandas/tests/extension/base/reshaping.py,sha256=Hf8czQWubrTjZrkYTL3FdOh6h97pCQaN5fK49GbRyRA,13931
+pandas/tests/extension/base/setitem.py,sha256=VcSUUuSqnLftzeeaIlBJIeoo841vVenX_FL5JceS91g,15075
+pandas/tests/extension/conftest.py,sha256=nvR8zq82gsIqh5rbOWj7_sOYLgL8J3M0loXw_L-OGag,5061
+pandas/tests/extension/date/__init__.py,sha256=-pIaBe_vmgnM_ok6T_-t-wVHetXtNw30SOMWVWNDqLI,118
+pandas/tests/extension/date/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/extension/date/__pycache__/array.cpython-312.pyc,,
+pandas/tests/extension/date/array.py,sha256=da7NoKcUFxS78IIEAsY6kXzL-mOCrV0yyhFWQUN6p8k,5971
+pandas/tests/extension/decimal/__init__.py,sha256=wgvjyfS3v3AHfh3sEfb5C8rSuOyo2satof8ESijM7bw,191
+pandas/tests/extension/decimal/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/extension/decimal/__pycache__/array.cpython-312.pyc,,
+pandas/tests/extension/decimal/__pycache__/test_decimal.cpython-312.pyc,,
+pandas/tests/extension/decimal/array.py,sha256=8YbmByqfIzEXW9i3-Ct6VM6M0QkmEEB9CQp79udfmYw,9694
+pandas/tests/extension/decimal/test_decimal.py,sha256=82ggMNpjkSYDu4Tk3vmS0zTwn8AZ3VqCi-MkQTP2paA,19459
+pandas/tests/extension/json/__init__.py,sha256=JvjCnVMfzIUSoHKL-umrkT9H5T8J3Alt8-QoKXMSB4I,146
+pandas/tests/extension/json/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/extension/json/__pycache__/array.cpython-312.pyc,,
+pandas/tests/extension/json/__pycache__/test_json.cpython-312.pyc,,
+pandas/tests/extension/json/array.py,sha256=Lt-hgallWZaJiaDjBbkE7ztKDM9S8FFj23GzxrxxIkY,8335
+pandas/tests/extension/json/test_json.py,sha256=usY52SN9Yd8lUugiCxI1B7DB06l2Lc8mr9tbxu9iOgI,17951
+pandas/tests/extension/list/__init__.py,sha256=FlpTrgdAMl_5puN2zDjvdmosw8aTvaCD-Hi2GtIK-k0,146
+pandas/tests/extension/list/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/extension/list/__pycache__/array.cpython-312.pyc,,
+pandas/tests/extension/list/__pycache__/test_list.cpython-312.pyc,,
+pandas/tests/extension/list/array.py,sha256=ngSHFQPRfmOkDOo54sX-l5JjQvr7ZTE9OzS9aPicc3o,4001
+pandas/tests/extension/list/test_list.py,sha256=VFPo5wGu-UvtAOFx3hoxILmRdI9kTOxCIIJM4fqgRBk,671
+pandas/tests/extension/test_arrow.py,sha256=Fil3KeJKWxmy9_Yb7Tkwl5uiK-3EwaSnptfpwpfCfm8,116199
+pandas/tests/extension/test_categorical.py,sha256=DhFKjDxrDfg4q6LXIgdIGVnv7VIK3IxUHsQ0rK_nQfE,6828
+pandas/tests/extension/test_common.py,sha256=4LO2slr0E0zODDK_Es4g9bPBH1U77nI8x9O1Mdddn1U,2975
+pandas/tests/extension/test_datetime.py,sha256=eBTSFWcQp2M1TgYzr01F-KQrdCJLHPrcPMGvuCsIj1s,4614
+pandas/tests/extension/test_extension.py,sha256=eyLZa4imT1Qdd7PCbDX9l0EtDu39T80eCrSre2wmTuE,559
+pandas/tests/extension/test_interval.py,sha256=TFLuAsCeXdkWLPfyYY2v4IdhvI7plwcaatL8LJl9kGI,2711
+pandas/tests/extension/test_masked.py,sha256=jrBlSzzwlXMAYj3fYXzDhiOKwUW7WBzyHLp-ce4VDf8,14338
+pandas/tests/extension/test_numpy.py,sha256=eFM6D2CiLgrsmwN5KQm_kYrzIdG7lmFXUuUiNoFrelE,15586
+pandas/tests/extension/test_period.py,sha256=e3RIO2xBPhF-PxPZtPM8VkVhkjYdUNtch9vcoRpHuEE,3528
+pandas/tests/extension/test_sparse.py,sha256=HIUEftSLmtr-LV7xrkP99vKwNj2zyXv4z1Ij_LWJd7Q,18011
+pandas/tests/extension/test_string.py,sha256=v3DaptVQ4lBckrCg_nLfWlJNBRHVaDjc8fE1bIlN4rU,8165
+pandas/tests/frame/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/frame/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/frame/__pycache__/common.cpython-312.pyc,,
+pandas/tests/frame/__pycache__/conftest.cpython-312.pyc,,
+pandas/tests/frame/__pycache__/test_alter_axes.cpython-312.pyc,,
+pandas/tests/frame/__pycache__/test_api.cpython-312.pyc,,
+pandas/tests/frame/__pycache__/test_arithmetic.cpython-312.pyc,,
+pandas/tests/frame/__pycache__/test_arrow_interface.cpython-312.pyc,,
+pandas/tests/frame/__pycache__/test_block_internals.cpython-312.pyc,,
+pandas/tests/frame/__pycache__/test_constructors.cpython-312.pyc,,
+pandas/tests/frame/__pycache__/test_cumulative.cpython-312.pyc,,
+pandas/tests/frame/__pycache__/test_iteration.cpython-312.pyc,,
+pandas/tests/frame/__pycache__/test_logical_ops.cpython-312.pyc,,
+pandas/tests/frame/__pycache__/test_nonunique_indexes.cpython-312.pyc,,
+pandas/tests/frame/__pycache__/test_npfuncs.cpython-312.pyc,,
+pandas/tests/frame/__pycache__/test_query_eval.cpython-312.pyc,,
+pandas/tests/frame/__pycache__/test_reductions.cpython-312.pyc,,
+pandas/tests/frame/__pycache__/test_repr.cpython-312.pyc,,
+pandas/tests/frame/__pycache__/test_stack_unstack.cpython-312.pyc,,
+pandas/tests/frame/__pycache__/test_subclass.cpython-312.pyc,,
+pandas/tests/frame/__pycache__/test_ufunc.cpython-312.pyc,,
+pandas/tests/frame/__pycache__/test_unary.cpython-312.pyc,,
+pandas/tests/frame/__pycache__/test_validate.cpython-312.pyc,,
+pandas/tests/frame/common.py,sha256=BmnEMlREF7G0B5zdaJRsdzqIRdh8diiTisBbCVI6Fp0,1873
+pandas/tests/frame/conftest.py,sha256=q2Oh2Ej-YIJvDdhsPCNDGvtTr5XWPRKZ2sylqmv5dys,2644
+pandas/tests/frame/constructors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/frame/constructors/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/frame/constructors/__pycache__/test_from_dict.cpython-312.pyc,,
+pandas/tests/frame/constructors/__pycache__/test_from_records.cpython-312.pyc,,
+pandas/tests/frame/constructors/test_from_dict.py,sha256=CTTFXUB5bamlx91XWQnmmG3DIlY8v6Qnc1ycZvjClT8,8152
+pandas/tests/frame/constructors/test_from_records.py,sha256=O6NwCZK5wa9w9a8Om6LHA2kWSLfTerakkjrgYXGJIao,18601
+pandas/tests/frame/indexing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/frame/indexing/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/frame/indexing/__pycache__/test_coercion.cpython-312.pyc,,
+pandas/tests/frame/indexing/__pycache__/test_delitem.cpython-312.pyc,,
+pandas/tests/frame/indexing/__pycache__/test_get.cpython-312.pyc,,
+pandas/tests/frame/indexing/__pycache__/test_get_value.cpython-312.pyc,,
+pandas/tests/frame/indexing/__pycache__/test_getitem.cpython-312.pyc,,
+pandas/tests/frame/indexing/__pycache__/test_indexing.cpython-312.pyc,,
+pandas/tests/frame/indexing/__pycache__/test_insert.cpython-312.pyc,,
+pandas/tests/frame/indexing/__pycache__/test_mask.cpython-312.pyc,,
+pandas/tests/frame/indexing/__pycache__/test_set_value.cpython-312.pyc,,
+pandas/tests/frame/indexing/__pycache__/test_setitem.cpython-312.pyc,,
+pandas/tests/frame/indexing/__pycache__/test_take.cpython-312.pyc,,
+pandas/tests/frame/indexing/__pycache__/test_where.cpython-312.pyc,,
+pandas/tests/frame/indexing/__pycache__/test_xs.cpython-312.pyc,,
+pandas/tests/frame/indexing/test_coercion.py,sha256=rHCkOLIlUkukh-P0XzPMtD4B8Lha3i1hqdvvZwCIAm8,5991
+pandas/tests/frame/indexing/test_delitem.py,sha256=-YERBfZbhTZ3eKzjmWln8AjoQEO7Yvae6elau4njhM0,1832
+pandas/tests/frame/indexing/test_get.py,sha256=N00_igU25_HjYuvAqDQKqBpqbz6HjB97o9Exvbo9BzM,662
+pandas/tests/frame/indexing/test_get_value.py,sha256=A-GbCHlbDfVPGB10dNGnGg4DtrKrlRbRspYfuDTUmPM,679
+pandas/tests/frame/indexing/test_getitem.py,sha256=9xogr1RzStjgP4HvWm_tm9VWUol660FgSmBwN-wC5Tw,15002
+pandas/tests/frame/indexing/test_indexing.py,sha256=XIcq7eJfuJgAsI1ZgZ-Eojw32fSBzhrQqQsb4aMycEk,70208
+pandas/tests/frame/indexing/test_insert.py,sha256=0XsNprKi0XQ9od6dOImwzQwh8YMdgdE0BZFGFHGPEYg,4074
+pandas/tests/frame/indexing/test_mask.py,sha256=1Bql-TBfyBDmlXkECYXk-ZH_y4SPSOZYjCR2Ex7Km1k,4862
+pandas/tests/frame/indexing/test_set_value.py,sha256=q0Bzs0u_q5G6VzFvU5mRSxohG5FTh4sw7sRrRdhY0YM,2622
+pandas/tests/frame/indexing/test_setitem.py,sha256=z5mPGNnxv5nNlpPJiDeXbtdURAQeXIeddsKzPd-3OWE,51434
+pandas/tests/frame/indexing/test_take.py,sha256=SMBM5BO7ybxTq8gTAX1Qg1UW8vcNiRrHTQwrt1f-Rig,3230
+pandas/tests/frame/indexing/test_where.py,sha256=Y3oOgYjYJxUAHn_PiW2eWHrz1tWNVuNXtJcf3RJE2PY,38125
+pandas/tests/frame/indexing/test_xs.py,sha256=86w_A-gePZXZETqs9UYKfEZrNKXyvmd0DwScTbHH9Dg,15980
+pandas/tests/frame/methods/__init__.py,sha256=M6dCS5d750Fzf9GX7xyNka-SZ2wJFCL66y5j-moHhwo,229
+pandas/tests/frame/methods/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_add_prefix_suffix.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_align.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_asfreq.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_asof.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_assign.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_astype.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_at_time.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_between_time.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_clip.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_combine.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_combine_first.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_compare.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_convert_dtypes.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_copy.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_count.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_cov_corr.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_describe.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_diff.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_dot.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_drop.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_drop_duplicates.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_droplevel.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_dropna.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_dtypes.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_duplicated.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_equals.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_explode.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_fillna.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_filter.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_first_and_last.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_first_valid_index.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_get_numeric_data.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_head_tail.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_infer_objects.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_info.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_interpolate.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_is_homogeneous_dtype.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_isetitem.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_isin.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_iterrows.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_join.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_map.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_matmul.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_nlargest.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_pct_change.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_pipe.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_pop.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_quantile.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_rank.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_reindex.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_reindex_like.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_rename.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_rename_axis.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_reorder_levels.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_replace.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_reset_index.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_round.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_sample.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_select_dtypes.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_set_axis.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_set_index.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_shift.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_size.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_sort_index.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_sort_values.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_swapaxes.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_swaplevel.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_to_csv.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_to_dict.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_to_dict_of_blocks.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_to_numpy.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_to_period.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_to_records.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_to_timestamp.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_transpose.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_truncate.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_tz_convert.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_tz_localize.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_update.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_value_counts.cpython-312.pyc,,
+pandas/tests/frame/methods/__pycache__/test_values.cpython-312.pyc,,
+pandas/tests/frame/methods/test_add_prefix_suffix.py,sha256=iPfzSPx0CArx79na7xcI9ZcPTAwq73IdOCcREVO7k4E,1910
+pandas/tests/frame/methods/test_align.py,sha256=FwQrqdCesXbgkQ8bfYPlf3LfK-Sdvud9pHEC2tCnwQ0,17941
+pandas/tests/frame/methods/test_asfreq.py,sha256=MCJkjukZtOVCauc4FZDbor1h99AvG4eMNfQZW8L1h5c,9341
+pandas/tests/frame/methods/test_asof.py,sha256=bkK2i5xcGvz2oy1MVbf_C1oVixMy_1qYqYcuOg-K2Bk,6732
+pandas/tests/frame/methods/test_assign.py,sha256=xFGREzLhP1wj3MowBimeYbMWBNiII0280DiOXI6WDB0,2982
+pandas/tests/frame/methods/test_astype.py,sha256=lIFj0WqQvEZVESqYOfP8flVquMoVEYp1ubJGYaCZJgQ,32102
+pandas/tests/frame/methods/test_at_time.py,sha256=JrQYFlNIIyW1xDvgmGE7zRfjXnmKMELh9Stiw0btGbM,4708
+pandas/tests/frame/methods/test_between_time.py,sha256=rD-k1a4LVOa-nMlLXOaZO7iTa3hL_C9tghqt8DWW0Qs,8083
+pandas/tests/frame/methods/test_clip.py,sha256=6h1zwE0SKP-uknyuE5Pi5X9vTS4L5ZBts_iSbs6cSL8,7554
+pandas/tests/frame/methods/test_combine.py,sha256=wNaQqokqHsJmrZ9NQIao58ZT0hSkkTH14I7_Oq8tADs,1359
+pandas/tests/frame/methods/test_combine_first.py,sha256=K0YQAGhGyaK_j5tmP9IbQx8zO56ID9GhbTaT9v-3T1M,19726
+pandas/tests/frame/methods/test_compare.py,sha256=j7Z_-yBVts4-xl1fVsJtOBAXYbLao2hwzI2x3aniFz0,9615
+pandas/tests/frame/methods/test_convert_dtypes.py,sha256=sLJ-7LM95vWBzEUFKuWfpj9j5TmX5339pRXZW3dFXCw,7958
+pandas/tests/frame/methods/test_copy.py,sha256=QeDoh44tS__y9LK7LwUBAc-SD5RS-phPA4eYWPl5yIg,1873
+pandas/tests/frame/methods/test_count.py,sha256=avzIu1dZ3pls4SM6g173M7Q4i8zMUzeAVI2EeIzWC0c,1083
+pandas/tests/frame/methods/test_cov_corr.py,sha256=ydpNMfWcjDf6zNVvLGFc8eOHWs_scU6rvMobn3EPm2U,17873
+pandas/tests/frame/methods/test_describe.py,sha256=DAY04ar1XixwEscl6taSddki4Y_rYnQnV8zF61-z1ZY,14500
+pandas/tests/frame/methods/test_diff.py,sha256=Dyz4lYFWrLVm5fN_B0Z1xZ_l8gyGFQhzwhmRKMuA6io,10099
+pandas/tests/frame/methods/test_dot.py,sha256=tfZD1HWlbO78DEgdjpBctgjWHtzjC3K9essVl_5XBMA,4623
+pandas/tests/frame/methods/test_drop.py,sha256=41RTmD-suQbCnZjpFcG56VlIx1ZP-ReC-j5YIhpJ3WA,20362
+pandas/tests/frame/methods/test_drop_duplicates.py,sha256=GSJ7VundpGtt6KBhl2mld6CwNc9La_pGRwXuNNiRE9Y,14503
+pandas/tests/frame/methods/test_droplevel.py,sha256=L1gAMjYYPB6eYmSppXfbwPVKa3HCNofqPVUZ3gxLldA,1253
+pandas/tests/frame/methods/test_dropna.py,sha256=9l8GBOLpvmEowzFaq0kRxN3815gJCuNamX4S5dn5Mmw,10315
+pandas/tests/frame/methods/test_dtypes.py,sha256=YrKxnM9gY4UlcsXjLBLJRTHE_8CthS71mIMZH3ubPpg,5093
+pandas/tests/frame/methods/test_duplicated.py,sha256=1DQFuK4KjfSpsl8W0jXne8PPUsL1nFe3lI_9VYBd33I,3305
+pandas/tests/frame/methods/test_equals.py,sha256=AFmbc9SmfgpQV0PD9hCXuktRCRkNvDF5S1Z7z31E2xE,2996
+pandas/tests/frame/methods/test_explode.py,sha256=ZK-uow3VD8csy96x6hkDItUOh4U2kkYSwrdH83tkjAM,8824
+pandas/tests/frame/methods/test_fillna.py,sha256=GAPSWMAQ8MXdOVwj3ionMLvG8W_N9FolE6cSnU39uSM,34156
+pandas/tests/frame/methods/test_filter.py,sha256=oT63-WLaQv3isFsWJFtqZwxiw2J-7xZwyOOxpn-kTNo,5422
+pandas/tests/frame/methods/test_first_and_last.py,sha256=hKvLBnx3YtQLilE_9PlL9804dAI6E7Hk2gHDgXqbcsU,5349
+pandas/tests/frame/methods/test_first_valid_index.py,sha256=DRoZKic0mpCom31NeygnBftZlxc6wsCT4-DN2KV5wWI,2574
+pandas/tests/frame/methods/test_get_numeric_data.py,sha256=jXqHisuyym78GRZTo0c2uN1U4YPcMkXUJ9eDRZE8BPA,3313
+pandas/tests/frame/methods/test_head_tail.py,sha256=quuFkpS5IgonJDSb9_Po4eO3Wi5wlcNKq723EMYL6Ns,1935
+pandas/tests/frame/methods/test_infer_objects.py,sha256=LNOf2VJsV17FDT9ogEDba6la414yUmm5z_7B97nLN24,1241
+pandas/tests/frame/methods/test_info.py,sha256=gvIGMmte029dnuvDjFxuVs20VblEBuQof2-xjzSe6EI,16867
+pandas/tests/frame/methods/test_interpolate.py,sha256=8A7qxsIgVgdC9-P_WClkvIWbRObBd4aw2Hf78elyx4c,20120
+pandas/tests/frame/methods/test_is_homogeneous_dtype.py,sha256=8Ndf_2Z07SAqrN0ookvH0PDAmECGVJkUieeqSaz2aRQ,1455
+pandas/tests/frame/methods/test_isetitem.py,sha256=VoxA-yXow_CRikJ1tlni1PsAAOT1D2X8PtTZyJOGQXU,1428
+pandas/tests/frame/methods/test_isin.py,sha256=P2TVUsL_p366aSxwWcq27VlT9zFstOXlsJSTFlw2n20,7599
+pandas/tests/frame/methods/test_iterrows.py,sha256=hfFRA20tRYmXJAoJZLGI04J131Z7QaaEbINm3FwfVbQ,338
+pandas/tests/frame/methods/test_join.py,sha256=oGHrJh9Gb6k8Cgg1iHNVoJuamkIHqnzs5EoU_XdY9hM,17523
+pandas/tests/frame/methods/test_map.py,sha256=UIY-wd0ozerUNyILMavuJ47qdWwp8dREjeKeeR8zvc8,5994
+pandas/tests/frame/methods/test_matmul.py,sha256=i1BG41S9da2R0nATvc3kZXsiwl5t6MHDFIb0IJ4lAbQ,3137
+pandas/tests/frame/methods/test_nlargest.py,sha256=6G_UUSJT858jxia3p92pf4jivcg6yhj4xiXRZ7EUeW0,8195
+pandas/tests/frame/methods/test_pct_change.py,sha256=s0Ho617mHdRHBEV-9cRAz3_Z_Q5BzTd_cd6MuobTlbo,6530
+pandas/tests/frame/methods/test_pipe.py,sha256=ts5ghk8g6PYXKpdsBdovBXxPGO2qq75FEVzBgjAVfRw,1023
+pandas/tests/frame/methods/test_pop.py,sha256=e0CBRelgiASCGdB1NFRMSr04BbaggjyHAZYvmUUh1sM,2223
+pandas/tests/frame/methods/test_quantile.py,sha256=HK6wwPSW-yLLkxbj8Cn0C1nPho8WBsjPhcvGtiDCaPM,36280
+pandas/tests/frame/methods/test_rank.py,sha256=SnZTqSgarPjHAFSnyLCSZevOBMyXNb13QAAI-qz0Z1c,17566
+pandas/tests/frame/methods/test_reindex.py,sha256=tmNvHk4dcGnrZ81EA5UGtPq6LdSa0Y64yQ5MzIZoKP8,48343
+pandas/tests/frame/methods/test_reindex_like.py,sha256=2qgqaHDSEKYO1hwE9MaPTFJhl4m7rejHyuOcrmvqaBg,1187
+pandas/tests/frame/methods/test_rename.py,sha256=P-SIwbh-n6QdPqFns4ebPtGFwdXd7vmeWt5_dwo0Kq4,15354
+pandas/tests/frame/methods/test_rename_axis.py,sha256=90QFtDi0p-8bxEdFfLs75EtJQtJEOTmCdXoiS7h9F-Y,4091
+pandas/tests/frame/methods/test_reorder_levels.py,sha256=VJVEdltyRoz89mQR1Xp0A9yKlTeEFIpsPaKWQujT-C8,2729
+pandas/tests/frame/methods/test_replace.py,sha256=IW0My1nADFCpbkjMFLWfXT36Nxbcs9m7FSiksSHM4jc,64846
+pandas/tests/frame/methods/test_reset_index.py,sha256=yo9nZBpcOblU-3bgfmTg3-CQT7p-p3mciEroMVDfmDE,27931
+pandas/tests/frame/methods/test_round.py,sha256=dcPlBxHqpKJ6JTBJskvw2CE3IYfa-Xt020jfSslwLjs,7978
+pandas/tests/frame/methods/test_sample.py,sha256=vPDSUU6oBD5X2C5rKUhIHk6o2xftm0zzMTwvuipelRM,13431
+pandas/tests/frame/methods/test_select_dtypes.py,sha256=SsvEwmjNFFwfOqxMlA-Z72qHJDtxNtvFWbtV-sbIODg,16638
+pandas/tests/frame/methods/test_set_axis.py,sha256=xiyZyjgDIO0B5HWGLeV_fVDyXj3YMDBfLyEDh5rQvcw,4608
+pandas/tests/frame/methods/test_set_index.py,sha256=h2a7zL_ZgN6zoRNcAV3QrgfqI59PR5jsiPPGC-V8F_U,26598
+pandas/tests/frame/methods/test_shift.py,sha256=unBlSwoV0OwFfysSr8ZKrqrrfoH7FRbPlGp18XW84OQ,27731
+pandas/tests/frame/methods/test_size.py,sha256=zFzVSvOpjHkA9_tEB2mPnfq9PJIBuBa4lCi6BvXbBDE,571
+pandas/tests/frame/methods/test_sort_index.py,sha256=BbCjfh_Zke1R7M9fPoRASORNfXS2KZ0IgWOF6jNnor0,34826
+pandas/tests/frame/methods/test_sort_values.py,sha256=NTmGhvm_flc6gzdtOeAOXsO3ai6K3peyH476Sj-qfLA,32982
+pandas/tests/frame/methods/test_swapaxes.py,sha256=-IuPIvjEz7X8-qxnWy1no5hG2WklPn6qERkmQQ-gAv0,1466
+pandas/tests/frame/methods/test_swaplevel.py,sha256=Y8npUpIQM0lSdIwY7auGcLJaF21JOb-KlVU3cvSLsOg,1277
+pandas/tests/frame/methods/test_to_csv.py,sha256=xkx76kpxWG7ZK6hcTEb0etllFg5_uSy0dLo1O6kfugI,51721
+pandas/tests/frame/methods/test_to_dict.py,sha256=BEKNs7rUFnd_cZZ7wQz0AmKJ7U-7KsEI6V3eApb1chw,18640
+pandas/tests/frame/methods/test_to_dict_of_blocks.py,sha256=dFL2fLKCQl-GXp2ephKiYgwjuQI_SEvsrG13RUIo1gE,2524
+pandas/tests/frame/methods/test_to_numpy.py,sha256=47-d29xA6qzZYnd08lBaKK3yj9aBZ9TKkoqgguGl1oQ,1795
+pandas/tests/frame/methods/test_to_period.py,sha256=Xiebi3IA_vUKrFNftLBkhF4N0gMbpI76ZCQpqhgO4iU,2863
+pandas/tests/frame/methods/test_to_records.py,sha256=35K3btxiApCcRVPG429FZAqqXIKRHKx4bVc8Sg3DCmE,18553
+pandas/tests/frame/methods/test_to_timestamp.py,sha256=1j6yjp4_WlxcDXSBKOk-IfrEbWtC4HvbIIHeM2x25ys,5866
+pandas/tests/frame/methods/test_transpose.py,sha256=JNhwvci37DlDMYHBaJz4Km998vw8NGfl7f4UYwwnsmM,6830
+pandas/tests/frame/methods/test_truncate.py,sha256=ZTnK8yZYqEhG3pe8KVwmJf4K890RMu8a60A4nC_qznM,5216
+pandas/tests/frame/methods/test_tz_convert.py,sha256=vsJm9M19ciCPqG0t5d_BlxuCmDphDkgb75SuYPtOhmE,4707
+pandas/tests/frame/methods/test_tz_localize.py,sha256=rMvd0K3W7N24qn7Q_tTkvbz7dOemIv3w89hthc6c5Y0,2084
+pandas/tests/frame/methods/test_update.py,sha256=npFHtPQmLMdhHa5xHbEL_zxXBuL4YK23CAnfIhTGn1k,6904
+pandas/tests/frame/methods/test_value_counts.py,sha256=YpYs0AZ8YgJE75W84O1KMfhd5oqpiuIJvLjz_YIz2KE,5556
+pandas/tests/frame/methods/test_values.py,sha256=ASljAwM9CEBMX6bA3FqWoSv4sOcRjuz8ZTfLSjo_F6Y,9406
+pandas/tests/frame/test_alter_axes.py,sha256=yHyCho1zs84UETsGGtw-gf3eTIyPj9zYUUA7wHTdRVk,873
+pandas/tests/frame/test_api.py,sha256=tn9xTbXzsDYRjqK3QJmBh64vNA8eV0JoGV2YAJrxTnU,12439
+pandas/tests/frame/test_arithmetic.py,sha256=xS3sOPjFEzALlHpwe-TMARDdV0xkpwBQ8NkqKMdhA9I,73152
+pandas/tests/frame/test_arrow_interface.py,sha256=KpAkREuJwWnlDBC45RvqogU_o1NSG0k44oMQAbgWCNw,1273
+pandas/tests/frame/test_block_internals.py,sha256=eG32ki-zsd8rMs7mI6Lc7j_2gM4Ga5aNqh2M1rTCZNA,16432
+pandas/tests/frame/test_constructors.py,sha256=_IWa5cMtmTMZcqH8Cs5M36Et2npqCskwgvQbx1oXbb8,123649
+pandas/tests/frame/test_cumulative.py,sha256=Ku20LYWW1hrycH8gslF8oNwXMv88RmaJC7x0a5GPbYw,2389
+pandas/tests/frame/test_iteration.py,sha256=BuyW6QePxoNZl-Cgxp5WLah_e-kSK2hsN8Gud_g0aoc,5077
+pandas/tests/frame/test_logical_ops.py,sha256=pUkVXQdIekK-OcmaqprYMp7cwND3t84Y2U25aMtYUq0,7352
+pandas/tests/frame/test_nonunique_indexes.py,sha256=wtBZpClv_46EwBSk59H1iXay2SR6Wv7m4ajh0tjisJg,11937
+pandas/tests/frame/test_npfuncs.py,sha256=DRLl7MSP7e5vRrVs3FgOooI4pZNmECurbVqkAAqvlUI,2751
+pandas/tests/frame/test_query_eval.py,sha256=Pe0xN0v1H4YPz55WIZs5tyV6zJwRkrLak_x1xXH6dBQ,54906
+pandas/tests/frame/test_reductions.py,sha256=j2qm6fsJfT8z0B1aeto9QbbY4LRSA36158tVk-033QY,77136
+pandas/tests/frame/test_repr.py,sha256=ycc0HNsBrKxPA88FIQturuMotBtqJco-ppO1NZE4JaI,16942
+pandas/tests/frame/test_stack_unstack.py,sha256=oRnTFLWq9JneBPR8vOElUmVgAVE120r71F1Sf5fhKhI,97375
+pandas/tests/frame/test_subclass.py,sha256=XqNKwBK-Zj06S4ATYGd59nKPzrzu8jmk_VbpStvB7ts,27880
+pandas/tests/frame/test_ufunc.py,sha256=YcUXnFE2n7lO5XN9aUvOJfeJyGqIDui0VhH-H1gUf1I,10554
+pandas/tests/frame/test_unary.py,sha256=fkB8LKCsctsyM9WS0g4JDiTD56gJy2l-cK7NcIQ2FHc,6603
+pandas/tests/frame/test_validate.py,sha256=hSQAfdZOKBe2MnbTBgWULmtA459zctixj7Qjy6bRg20,1094
+pandas/tests/generic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/generic/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/generic/__pycache__/test_duplicate_labels.cpython-312.pyc,,
+pandas/tests/generic/__pycache__/test_finalize.cpython-312.pyc,,
+pandas/tests/generic/__pycache__/test_frame.cpython-312.pyc,,
+pandas/tests/generic/__pycache__/test_generic.cpython-312.pyc,,
+pandas/tests/generic/__pycache__/test_label_or_level_utils.cpython-312.pyc,,
+pandas/tests/generic/__pycache__/test_series.cpython-312.pyc,,
+pandas/tests/generic/__pycache__/test_to_xarray.cpython-312.pyc,,
+pandas/tests/generic/test_duplicate_labels.py,sha256=-t-hhIiI3E1Byv1-jjvXDRAS8_tJzZaOIf-EsK6hrXg,14506
+pandas/tests/generic/test_finalize.py,sha256=HWv668IFuaSNElG3g1J5DL-wMHpU5T_iQYTOkaJA80U,28852
+pandas/tests/generic/test_frame.py,sha256=h6r5f3L-_V4JV5pP0AoFyvjtJP1ng7DJplN6Rrx4gzI,7332
+pandas/tests/generic/test_generic.py,sha256=MUhx9EVhCuo-fTOYRH2nzhQH8ip9-5QaNMjEPWx-NI4,17447
+pandas/tests/generic/test_label_or_level_utils.py,sha256=PhsVWjYjOHPZRqX4mwUc7jlOH3tnd7p9pkMFh87CtKU,10244
+pandas/tests/generic/test_series.py,sha256=oyFxVdh9G2GCBiTQktXNuafAw0wrbXs6Af8UnwUUiow,5677
+pandas/tests/generic/test_to_xarray.py,sha256=qGohtFgMtA8FS5y9AtnJQsd_-4Mg_Oach84Z8qDbHeg,4265
+pandas/tests/groupby/__init__.py,sha256=O41hwVGLyFtIhv-zbe2JBZiqD3heGA7LOk10RuxfcKc,659
+pandas/tests/groupby/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/groupby/__pycache__/conftest.cpython-312.pyc,,
+pandas/tests/groupby/__pycache__/test_all_methods.cpython-312.pyc,,
+pandas/tests/groupby/__pycache__/test_api.cpython-312.pyc,,
+pandas/tests/groupby/__pycache__/test_apply.cpython-312.pyc,,
+pandas/tests/groupby/__pycache__/test_apply_mutate.cpython-312.pyc,,
+pandas/tests/groupby/__pycache__/test_bin_groupby.cpython-312.pyc,,
+pandas/tests/groupby/__pycache__/test_categorical.cpython-312.pyc,,
+pandas/tests/groupby/__pycache__/test_counting.cpython-312.pyc,,
+pandas/tests/groupby/__pycache__/test_cumulative.cpython-312.pyc,,
+pandas/tests/groupby/__pycache__/test_filters.cpython-312.pyc,,
+pandas/tests/groupby/__pycache__/test_groupby.cpython-312.pyc,,
+pandas/tests/groupby/__pycache__/test_groupby_dropna.cpython-312.pyc,,
+pandas/tests/groupby/__pycache__/test_groupby_subclass.cpython-312.pyc,,
+pandas/tests/groupby/__pycache__/test_grouping.cpython-312.pyc,,
+pandas/tests/groupby/__pycache__/test_index_as_string.cpython-312.pyc,,
+pandas/tests/groupby/__pycache__/test_indexing.cpython-312.pyc,,
+pandas/tests/groupby/__pycache__/test_libgroupby.cpython-312.pyc,,
+pandas/tests/groupby/__pycache__/test_missing.cpython-312.pyc,,
+pandas/tests/groupby/__pycache__/test_numba.cpython-312.pyc,,
+pandas/tests/groupby/__pycache__/test_numeric_only.cpython-312.pyc,,
+pandas/tests/groupby/__pycache__/test_pipe.cpython-312.pyc,,
+pandas/tests/groupby/__pycache__/test_raises.cpython-312.pyc,,
+pandas/tests/groupby/__pycache__/test_reductions.cpython-312.pyc,,
+pandas/tests/groupby/__pycache__/test_timegrouper.cpython-312.pyc,,
+pandas/tests/groupby/aggregate/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/groupby/aggregate/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/groupby/aggregate/__pycache__/test_aggregate.cpython-312.pyc,,
+pandas/tests/groupby/aggregate/__pycache__/test_cython.cpython-312.pyc,,
+pandas/tests/groupby/aggregate/__pycache__/test_numba.cpython-312.pyc,,
+pandas/tests/groupby/aggregate/__pycache__/test_other.cpython-312.pyc,,
+pandas/tests/groupby/aggregate/test_aggregate.py,sha256=4S6PEKvRgk0ULSozn37cOsh6ohnEHZ3yaSGEp0Dmh9k,55554
+pandas/tests/groupby/aggregate/test_cython.py,sha256=XWKVeZTdLnpbaKlU128KkVmtIHntdpu_auCaHyyapXg,12800
+pandas/tests/groupby/aggregate/test_numba.py,sha256=Ba1zZzFC2-cjXE4OMOAStDvh_CeHy3hZwUhwDLDGkcY,13039
+pandas/tests/groupby/aggregate/test_other.py,sha256=LAuSm_tjHQlp_0oekNc14NCbj2gei4RR9jowjb_u65o,20669
+pandas/tests/groupby/conftest.py,sha256=uxnebcMXbaC_tH4Pg2wRZvXlWMZ_WnNIUeX8ftK7gWo,4785
+pandas/tests/groupby/methods/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/groupby/methods/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/groupby/methods/__pycache__/test_corrwith.cpython-312.pyc,,
+pandas/tests/groupby/methods/__pycache__/test_describe.cpython-312.pyc,,
+pandas/tests/groupby/methods/__pycache__/test_groupby_shift_diff.cpython-312.pyc,,
+pandas/tests/groupby/methods/__pycache__/test_is_monotonic.cpython-312.pyc,,
+pandas/tests/groupby/methods/__pycache__/test_nlargest_nsmallest.cpython-312.pyc,,
+pandas/tests/groupby/methods/__pycache__/test_nth.cpython-312.pyc,,
+pandas/tests/groupby/methods/__pycache__/test_quantile.cpython-312.pyc,,
+pandas/tests/groupby/methods/__pycache__/test_rank.cpython-312.pyc,,
+pandas/tests/groupby/methods/__pycache__/test_sample.cpython-312.pyc,,
+pandas/tests/groupby/methods/__pycache__/test_size.cpython-312.pyc,,
+pandas/tests/groupby/methods/__pycache__/test_skew.cpython-312.pyc,,
+pandas/tests/groupby/methods/__pycache__/test_value_counts.cpython-312.pyc,,
+pandas/tests/groupby/methods/test_corrwith.py,sha256=nseP6eDkLjiNIOSxm2EDFTkemTqNFUNqvvNJpMiNZVY,615
+pandas/tests/groupby/methods/test_describe.py,sha256=KFu1CeWWqpy3NWNh9IbzsirR36OKB9Q27yEUGZaM7og,9672
+pandas/tests/groupby/methods/test_groupby_shift_diff.py,sha256=4XMAhqV0JrGeXQn1_07ec9Nu25Dy1LOcDfojo4qEhNI,7925
+pandas/tests/groupby/methods/test_is_monotonic.py,sha256=OpnlOamR5gX1S7MVtZFGxnbt1Fem_wWH1Irc5aqkdq4,2566
+pandas/tests/groupby/methods/test_nlargest_nsmallest.py,sha256=MFS6cWChs3aBw3vb-n234pOV8_YYet2jOdDNN0lrMkg,3401
+pandas/tests/groupby/methods/test_nth.py,sha256=k2Pe1sTNCELszUfRU3SVf-54WHRjigSp0D51Cq2pmRA,28189
+pandas/tests/groupby/methods/test_quantile.py,sha256=deK9SMCVErwfQUDF_bc9DTH3fhxRBxuCxC4OHc3G6q0,16354
+pandas/tests/groupby/methods/test_rank.py,sha256=NE_ciV_TwLbTGoq1OFUFX5yadyiYoP3m5ppVOoD5264,24263
+pandas/tests/groupby/methods/test_sample.py,sha256=n_dLYblQo9MWnpngMRIIGLZFGEGOeAfEqsL9c9gLCKg,5155
+pandas/tests/groupby/methods/test_size.py,sha256=PQ2op8vrqyDhNYwQyM2x19v2jJzrTvUH0GCSv0xE_eU,4250
+pandas/tests/groupby/methods/test_skew.py,sha256=_FTlnXtE_fic6ZZ322S583IXUY5hEQggi-3Xbuboahw,841
+pandas/tests/groupby/methods/test_value_counts.py,sha256=8awMEsjBh7R_8s-w5roAq-mZrhl_9NrWQOU8lV8CYPs,39874
+pandas/tests/groupby/test_all_methods.py,sha256=eQsLKoyDyGZNPecbxC1HRzdIwW_DBEp0x_r3gD620pw,3077
+pandas/tests/groupby/test_api.py,sha256=IpMVl4g9F2317jWVTSiHoAsZKaOQWFx0Oi_jLWfv_DQ,8481
+pandas/tests/groupby/test_apply.py,sha256=z0nCK9dbF8ww3RoA3MhwZX5_BE-WF8AAF8672e2YnVs,54859
+pandas/tests/groupby/test_apply_mutate.py,sha256=b5rtOE-IwkLsEp5VTcyPDtKfCTB9MYw95a0U8ThKLE0,5047
+pandas/tests/groupby/test_bin_groupby.py,sha256=nZGe01NsuZmS88cMqq8fGFbKl-umvmWjXd8BGmR3jTo,1769
+pandas/tests/groupby/test_categorical.py,sha256=73Njrb3YH6fGMnL-9x1_rlT4_jGROdM5sVIQeCRaU-A,74271
+pandas/tests/groupby/test_counting.py,sha256=59N0fV7J8XRijMaIU0Cu5-odZmaoS73cGvzCuuOKrBA,13623
+pandas/tests/groupby/test_cumulative.py,sha256=c6C7ZNo0O5DH9SowsAXp4j_SF-wskjrUlNtfDJomjxQ,10588
+pandas/tests/groupby/test_filters.py,sha256=uFvXjXF2fpQJSwZUhGOUfguyJk7xoXYyL0ShN2KfXx8,21870
+pandas/tests/groupby/test_groupby.py,sha256=btnUSXmk3LKZJ5WBvaWe8ylA2FyaLbc1na2X6S3DTtU,108274
+pandas/tests/groupby/test_groupby_dropna.py,sha256=8OcPba3g6S_FwrxLBsrF8QGFO3Y9VH-bAPeu15h50eQ,23530
+pandas/tests/groupby/test_groupby_subclass.py,sha256=b13F2oZyPfzGngygHRHtBK_vlPfzdik-DiLaWWDcKZ8,4568
+pandas/tests/groupby/test_grouping.py,sha256=0KurYwG--QzwakI0Da37ZfP82qEpMYp22y-wWrvIll8,45862
+pandas/tests/groupby/test_index_as_string.py,sha256=bwAMXa4aSzVDUY1t3HmzK4y-jO5jIwbbRu85Jmb8-U0,2274
+pandas/tests/groupby/test_indexing.py,sha256=Ln_43WnuxtAVrWoaUHWh1IqUSY0i42nY9VnEnw86oXg,9521
+pandas/tests/groupby/test_libgroupby.py,sha256=xiFJcUw_cwTUpQh6E9L47EZm8HopmDrKuYSTI0gHnDs,10457
+pandas/tests/groupby/test_missing.py,sha256=u6mv6_D1ydhkK3jLXqfvidDlOXYdUsN44ySzFksaIlU,5358
+pandas/tests/groupby/test_numba.py,sha256=B2ygkBddeTyLE7a6okHM_CbFwsOaqMceHh4h6fmmQNg,3260
+pandas/tests/groupby/test_numeric_only.py,sha256=gmxCGXKDLN_AZr4dQ2lA4zKrU84uDtwfFrdAUdFzDNA,18573
+pandas/tests/groupby/test_pipe.py,sha256=BpMDqw-ZGT-tHUJN7k6XoWz2H46sBqSxmouppbWMHsU,2098
+pandas/tests/groupby/test_raises.py,sha256=lzNGHyOBhvWL71QarVtajs8_ZSjIvSBJIwrk4-YbgdY,22214
+pandas/tests/groupby/test_reductions.py,sha256=vcpcNtIckgBbcv2gCCA6b3pP3WoUquLqnutMpNwAOMA,36833
+pandas/tests/groupby/test_timegrouper.py,sha256=5EdFromkRWltGo9xlkfRRb2eSwIpNrV834F3P_bqnNI,34779
+pandas/tests/groupby/transform/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/groupby/transform/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/groupby/transform/__pycache__/test_numba.cpython-312.pyc,,
+pandas/tests/groupby/transform/__pycache__/test_transform.cpython-312.pyc,,
+pandas/tests/groupby/transform/test_numba.py,sha256=6GJOeWL6kOIJQQaBCAD9ajv_-m6NmCrpxB9wwoCSr0A,9684
+pandas/tests/groupby/transform/test_transform.py,sha256=0rG5_Lma8MEIs_l_GS8g0eDhALsk5_wokg9IuzRvSRs,57218
+pandas/tests/indexes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/indexes/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/indexes/__pycache__/conftest.cpython-312.pyc,,
+pandas/tests/indexes/__pycache__/test_any_index.cpython-312.pyc,,
+pandas/tests/indexes/__pycache__/test_base.cpython-312.pyc,,
+pandas/tests/indexes/__pycache__/test_common.cpython-312.pyc,,
+pandas/tests/indexes/__pycache__/test_datetimelike.cpython-312.pyc,,
+pandas/tests/indexes/__pycache__/test_engines.cpython-312.pyc,,
+pandas/tests/indexes/__pycache__/test_frozen.cpython-312.pyc,,
+pandas/tests/indexes/__pycache__/test_index_new.cpython-312.pyc,,
+pandas/tests/indexes/__pycache__/test_indexing.cpython-312.pyc,,
+pandas/tests/indexes/__pycache__/test_numpy_compat.cpython-312.pyc,,
+pandas/tests/indexes/__pycache__/test_old_base.cpython-312.pyc,,
+pandas/tests/indexes/__pycache__/test_setops.cpython-312.pyc,,
+pandas/tests/indexes/__pycache__/test_subclass.cpython-312.pyc,,
+pandas/tests/indexes/base_class/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/indexes/base_class/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/indexes/base_class/__pycache__/test_constructors.cpython-312.pyc,,
+pandas/tests/indexes/base_class/__pycache__/test_formats.cpython-312.pyc,,
+pandas/tests/indexes/base_class/__pycache__/test_indexing.cpython-312.pyc,,
+pandas/tests/indexes/base_class/__pycache__/test_pickle.cpython-312.pyc,,
+pandas/tests/indexes/base_class/__pycache__/test_reshape.cpython-312.pyc,,
+pandas/tests/indexes/base_class/__pycache__/test_setops.cpython-312.pyc,,
+pandas/tests/indexes/base_class/__pycache__/test_where.cpython-312.pyc,,
+pandas/tests/indexes/base_class/test_constructors.py,sha256=c4hEi_fFI9WNCKw-HhXTtb6fX9bV7RmL4IoTxag5GH4,2763
+pandas/tests/indexes/base_class/test_formats.py,sha256=TfviPEyXl7e0N6iiySBiaPBiMaNc8hDpiY7iEpBXXcE,6329
+pandas/tests/indexes/base_class/test_indexing.py,sha256=1zbBHv-nJCIfXRicDPXPtyLBL3Iy-LvH5bkamnoFGrI,3687
+pandas/tests/indexes/base_class/test_pickle.py,sha256=ANKn2SirZRA2AHaZoCDHCB1AjLEuUTgXU2mXI6n3Tvw,309
+pandas/tests/indexes/base_class/test_reshape.py,sha256=F5i0CHj5vPBP1Xvg71l7bTt9u2krFVqltowHc_2l9FA,3168
+pandas/tests/indexes/base_class/test_setops.py,sha256=X84dGTmkrEJ2oSQfr-WfozQA3moGUpnmbhkTYzJWH7k,9076
+pandas/tests/indexes/base_class/test_where.py,sha256=uq7oB-lk7rsgYQer8qeUsqD5aSECtRPSEUfKzn91BiE,341
+pandas/tests/indexes/categorical/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/indexes/categorical/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/indexes/categorical/__pycache__/test_append.cpython-312.pyc,,
+pandas/tests/indexes/categorical/__pycache__/test_astype.cpython-312.pyc,,
+pandas/tests/indexes/categorical/__pycache__/test_category.cpython-312.pyc,,
+pandas/tests/indexes/categorical/__pycache__/test_constructors.cpython-312.pyc,,
+pandas/tests/indexes/categorical/__pycache__/test_equals.cpython-312.pyc,,
+pandas/tests/indexes/categorical/__pycache__/test_fillna.cpython-312.pyc,,
+pandas/tests/indexes/categorical/__pycache__/test_formats.cpython-312.pyc,,
+pandas/tests/indexes/categorical/__pycache__/test_indexing.cpython-312.pyc,,
+pandas/tests/indexes/categorical/__pycache__/test_map.cpython-312.pyc,,
+pandas/tests/indexes/categorical/__pycache__/test_reindex.cpython-312.pyc,,
+pandas/tests/indexes/categorical/__pycache__/test_setops.cpython-312.pyc,,
+pandas/tests/indexes/categorical/test_append.py,sha256=LjLMq8GkNrsIVNfTrujLv_TlKo79oA_XbpNUFs-pqVQ,2191
+pandas/tests/indexes/categorical/test_astype.py,sha256=mQjQ9hbRf940DjzvC9OD6t8BzwphBXJdrROyEul1tzU,2860
+pandas/tests/indexes/categorical/test_category.py,sha256=-jO0jW9IJDvFWnl41MkcGuiWgkeuedUdRDIgVyoyB38,14683
+pandas/tests/indexes/categorical/test_constructors.py,sha256=g3hEVtOS576z11miVwakwud3cLXkFI2ErImUaFW9N6U,5536
+pandas/tests/indexes/categorical/test_equals.py,sha256=AIrr-W5WeqDj5KbELqjHm3-hqqx3q8YxBrv1z2oco94,3569
+pandas/tests/indexes/categorical/test_fillna.py,sha256=sH68aWCabI2qy5dbgxQCXeTfvn1NQgDfM1OT4ojFmaU,1850
+pandas/tests/indexes/categorical/test_formats.py,sha256=Rw-qSZ8zLRJkATk1UhPNAuVJMbbHBpuoALCXUDPR5PM,6297
+pandas/tests/indexes/categorical/test_indexing.py,sha256=zBvryPgX3VF5P4HqUQ1h1FD2warHLfSvb0nBq6rxjrc,14978
+pandas/tests/indexes/categorical/test_map.py,sha256=VHsSFGWEBmgQLvvquC6-y3QDq3lwzSpqPWZHTLiGdzw,4664
+pandas/tests/indexes/categorical/test_reindex.py,sha256=vPCV9O582vxJpubqCm33UHcaOKMZNg8OMzDF3lQQDiM,2938
+pandas/tests/indexes/categorical/test_setops.py,sha256=YiBoQN3Dor2p32HCUColWIZBH620H1aPa4easA5FMgc,462
+pandas/tests/indexes/conftest.py,sha256=aP9iTl0n1HpZWIP_02i__XxFnSMJF8iCM5Ein2MRK80,987
+pandas/tests/indexes/datetimelike_/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/indexes/datetimelike_/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/indexes/datetimelike_/__pycache__/test_drop_duplicates.cpython-312.pyc,,
+pandas/tests/indexes/datetimelike_/__pycache__/test_equals.cpython-312.pyc,,
+pandas/tests/indexes/datetimelike_/__pycache__/test_indexing.cpython-312.pyc,,
+pandas/tests/indexes/datetimelike_/__pycache__/test_is_monotonic.cpython-312.pyc,,
+pandas/tests/indexes/datetimelike_/__pycache__/test_nat.cpython-312.pyc,,
+pandas/tests/indexes/datetimelike_/__pycache__/test_sort_values.cpython-312.pyc,,
+pandas/tests/indexes/datetimelike_/__pycache__/test_value_counts.cpython-312.pyc,,
+pandas/tests/indexes/datetimelike_/test_drop_duplicates.py,sha256=UEmTzsZerSOIE6mPfaw4kQd7UFEo02H-EW5GOPpDTKU,2600
+pandas/tests/indexes/datetimelike_/test_equals.py,sha256=7Jnk1MjPYvI-I_YMRNRF29-g5CLaFmU3ZqQ6aO9KqIE,6348
+pandas/tests/indexes/datetimelike_/test_indexing.py,sha256=QoTXbCiqjK4tBDHUbq1TKPp0NroYkeheFjRq-VxlsP0,1310
+pandas/tests/indexes/datetimelike_/test_is_monotonic.py,sha256=_5PXF7mVilu1S4EJv7F-XMYIoz40kBkdSs4RJ8jTVdI,1522
+pandas/tests/indexes/datetimelike_/test_nat.py,sha256=6-Yr-n4JskfsjbaEPFgaRPKX4S7R-LhQOEQSC7cBybw,1335
+pandas/tests/indexes/datetimelike_/test_sort_values.py,sha256=iIhZOW7CEwVD3KuJUFEOM2z18KORCx04W09bwsdKSNs,11463
+pandas/tests/indexes/datetimelike_/test_value_counts.py,sha256=o090A9QuhmahJjH0WgKBIxXdBVxPkAc8vikXqZLuoD4,3150
+pandas/tests/indexes/datetimes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/indexes/datetimes/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/indexes/datetimes/__pycache__/test_arithmetic.cpython-312.pyc,,
+pandas/tests/indexes/datetimes/__pycache__/test_constructors.cpython-312.pyc,,
+pandas/tests/indexes/datetimes/__pycache__/test_date_range.cpython-312.pyc,,
+pandas/tests/indexes/datetimes/__pycache__/test_datetime.cpython-312.pyc,,
+pandas/tests/indexes/datetimes/__pycache__/test_formats.cpython-312.pyc,,
+pandas/tests/indexes/datetimes/__pycache__/test_freq_attr.cpython-312.pyc,,
+pandas/tests/indexes/datetimes/__pycache__/test_indexing.cpython-312.pyc,,
+pandas/tests/indexes/datetimes/__pycache__/test_iter.cpython-312.pyc,,
+pandas/tests/indexes/datetimes/__pycache__/test_join.cpython-312.pyc,,
+pandas/tests/indexes/datetimes/__pycache__/test_npfuncs.cpython-312.pyc,,
+pandas/tests/indexes/datetimes/__pycache__/test_ops.cpython-312.pyc,,
+pandas/tests/indexes/datetimes/__pycache__/test_partial_slicing.cpython-312.pyc,,
+pandas/tests/indexes/datetimes/__pycache__/test_pickle.cpython-312.pyc,,
+pandas/tests/indexes/datetimes/__pycache__/test_reindex.cpython-312.pyc,,
+pandas/tests/indexes/datetimes/__pycache__/test_scalar_compat.cpython-312.pyc,,
+pandas/tests/indexes/datetimes/__pycache__/test_setops.cpython-312.pyc,,
+pandas/tests/indexes/datetimes/__pycache__/test_timezones.cpython-312.pyc,,
+pandas/tests/indexes/datetimes/methods/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/indexes/datetimes/methods/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/indexes/datetimes/methods/__pycache__/test_asof.cpython-312.pyc,,
+pandas/tests/indexes/datetimes/methods/__pycache__/test_astype.cpython-312.pyc,,
+pandas/tests/indexes/datetimes/methods/__pycache__/test_delete.cpython-312.pyc,,
+pandas/tests/indexes/datetimes/methods/__pycache__/test_factorize.cpython-312.pyc,,
+pandas/tests/indexes/datetimes/methods/__pycache__/test_fillna.cpython-312.pyc,,
+pandas/tests/indexes/datetimes/methods/__pycache__/test_insert.cpython-312.pyc,,
+pandas/tests/indexes/datetimes/methods/__pycache__/test_isocalendar.cpython-312.pyc,,
+pandas/tests/indexes/datetimes/methods/__pycache__/test_map.cpython-312.pyc,,
+pandas/tests/indexes/datetimes/methods/__pycache__/test_normalize.cpython-312.pyc,,
+pandas/tests/indexes/datetimes/methods/__pycache__/test_repeat.cpython-312.pyc,,
+pandas/tests/indexes/datetimes/methods/__pycache__/test_resolution.cpython-312.pyc,,
+pandas/tests/indexes/datetimes/methods/__pycache__/test_round.cpython-312.pyc,,
+pandas/tests/indexes/datetimes/methods/__pycache__/test_shift.cpython-312.pyc,,
+pandas/tests/indexes/datetimes/methods/__pycache__/test_snap.cpython-312.pyc,,
+pandas/tests/indexes/datetimes/methods/__pycache__/test_to_frame.cpython-312.pyc,,
+pandas/tests/indexes/datetimes/methods/__pycache__/test_to_julian_date.cpython-312.pyc,,
+pandas/tests/indexes/datetimes/methods/__pycache__/test_to_period.cpython-312.pyc,,
+pandas/tests/indexes/datetimes/methods/__pycache__/test_to_pydatetime.cpython-312.pyc,,
+pandas/tests/indexes/datetimes/methods/__pycache__/test_to_series.cpython-312.pyc,,
+pandas/tests/indexes/datetimes/methods/__pycache__/test_tz_convert.cpython-312.pyc,,
+pandas/tests/indexes/datetimes/methods/__pycache__/test_tz_localize.cpython-312.pyc,,
+pandas/tests/indexes/datetimes/methods/__pycache__/test_unique.cpython-312.pyc,,
+pandas/tests/indexes/datetimes/methods/test_asof.py,sha256=gd-nBXLe-Dc5Voc_Ksgmq9mOU6S_I5ZZqlXcapgKzfE,738
+pandas/tests/indexes/datetimes/methods/test_astype.py,sha256=S04yQ6BdlxSXpR5DFRCsWlDTO4IUEDNSHIuMP1Jk6Zw,12201
+pandas/tests/indexes/datetimes/methods/test_delete.py,sha256=JaaHDwYuTarkta3Qd2fbteZd9k0oOzJsWCPEHUHHG4k,4441
+pandas/tests/indexes/datetimes/methods/test_factorize.py,sha256=Mif09gcfRfIO2uhCqNN9OC_NXggKizbuwaz6ScGzMUE,4468
+pandas/tests/indexes/datetimes/methods/test_fillna.py,sha256=eESnVTQ8J3iBL24bWKt7TmHxC5FJiLZMpKjw1V376qY,2004
+pandas/tests/indexes/datetimes/methods/test_insert.py,sha256=StmxdK3meNNEDO_CGzVIqltbXxwfX0pQxsngnPQfdtA,9343
+pandas/tests/indexes/datetimes/methods/test_isocalendar.py,sha256=JEABIm6LNySCbSUq6HLS-_qTGK3HgVcScSXLpDsrJ8o,908
+pandas/tests/indexes/datetimes/methods/test_map.py,sha256=1JR2lb_zk_8aIgRqnuWHfeXRPZBsFtdT4tRXeTDNqsQ,1358
+pandas/tests/indexes/datetimes/methods/test_normalize.py,sha256=rztamd3kwUZMcVQjeR1JcaIKr7pT0ACFcU4-FFynZkA,3041
+pandas/tests/indexes/datetimes/methods/test_repeat.py,sha256=GN-wTWws2sjodNibctZOi_NDX85y36Lr2BBmAs3LLMM,2740
+pandas/tests/indexes/datetimes/methods/test_resolution.py,sha256=RzkIL8IX63X1fgwr8o4_xuKvdOtPHdodPbsS75u9BRM,785
+pandas/tests/indexes/datetimes/methods/test_round.py,sha256=Ic1FFoRHdPv4TF1dSnOWVzVX90GowbXumbuNgTFPYlM,7822
+pandas/tests/indexes/datetimes/methods/test_shift.py,sha256=NhyUs0PMDuzSM573tqUamx3THf03WUNKz0nSOzDta5M,5933
+pandas/tests/indexes/datetimes/methods/test_snap.py,sha256=smwfWvN33B6UgLagKaBQkllTuGAm7Wiaq87M9nxu8g8,1305
+pandas/tests/indexes/datetimes/methods/test_to_frame.py,sha256=C6glyGdxSs-hMDQSt9jkftmRlTGPMCGdIQlfChR9iGk,998
+pandas/tests/indexes/datetimes/methods/test_to_julian_date.py,sha256=u6JLYazILIdltbe1uZE3iBAqE_ixXwx0oqwS6T-Mpng,1608
+pandas/tests/indexes/datetimes/methods/test_to_period.py,sha256=IIzHPLsk8BR43Ib5-8-EVxLQc_rkTcGBSk1M4-9OhYw,7986
+pandas/tests/indexes/datetimes/methods/test_to_pydatetime.py,sha256=sM22b33Cxwrpc5nShAp5QH2KQPOlEpi5d8G6fM3vVI8,1345
+pandas/tests/indexes/datetimes/methods/test_to_series.py,sha256=8ZW3AxMkHj3IV1wVgM797SH_rRLKQ9zld1UVkhk1C8Q,493
+pandas/tests/indexes/datetimes/methods/test_tz_convert.py,sha256=-Tuxq1egpSCBnBB7E_rAj1FudFgTm2DDYQ_wPMKgzwQ,11295
+pandas/tests/indexes/datetimes/methods/test_tz_localize.py,sha256=Q7A54lsovDxBDEqU7XNBJql3PoNLF7NVeXwvMFgrVI0,14830
+pandas/tests/indexes/datetimes/methods/test_unique.py,sha256=qZorAPI_oWcz5WdBEr0nQuT_mrApTgShqg3JVlzpVKU,2096
+pandas/tests/indexes/datetimes/test_arithmetic.py,sha256=l2q_n3zBT98OvI4gV7XZOZMCvo54xgM9frByNKCsbyU,1796
+pandas/tests/indexes/datetimes/test_constructors.py,sha256=zzICypvVbu8_PCfL3jiDGjSJWSflWjJbpqS5iNkd1kA,43922
+pandas/tests/indexes/datetimes/test_date_range.py,sha256=2CECH8fOYUP7LxyqlehEHVme2oSN4ZvEl3hjH8t-TDY,61363
+pandas/tests/indexes/datetimes/test_datetime.py,sha256=Q_dwJTXtSuVYTlMmnGhiNGCRrqHONu9wu2N5wgZw4pY,7305
+pandas/tests/indexes/datetimes/test_formats.py,sha256=rN90ZOq3e83t7X6uyd-cR1czM4A01nr3z_GIJJ0sy0k,12738
+pandas/tests/indexes/datetimes/test_freq_attr.py,sha256=oX_cweTcpKd27ywN976KCYpg0oFe77MeDWqnRJQwVRo,1732
+pandas/tests/indexes/datetimes/test_indexing.py,sha256=MncSVI_l914qEW2CUg_livQrJ6AcOxvzmaiNOdzlOoA,25241
+pandas/tests/indexes/datetimes/test_iter.py,sha256=7r3wuHLeCBHfX8kaHNK-4Ecr6ZqR89Dhzkisx2C7jOI,2590
+pandas/tests/indexes/datetimes/test_join.py,sha256=LUV-a1_kCQ4BCr8R-iBWU7VmlOhYK4OZYIgDd-9E0cg,4742
+pandas/tests/indexes/datetimes/test_npfuncs.py,sha256=YJihZytss-MVNprp4p5pAL_emeC5pb3hBwtaS3yMCcU,384
+pandas/tests/indexes/datetimes/test_ops.py,sha256=h9MI1sM5I_T4a7kEPdZs2QuXTdlcnvKQJdI5jh6j4h4,1340
+pandas/tests/indexes/datetimes/test_partial_slicing.py,sha256=OlC1IDbJ2y_qjp-HCFERReBOHb07DnlPZ3lMlhwMSLA,16495
+pandas/tests/indexes/datetimes/test_pickle.py,sha256=cpuQl8fsaqJhP4qroLU0LUQjqFQ0uaX3sHql2UYOSg4,1358
+pandas/tests/indexes/datetimes/test_reindex.py,sha256=s1pt3OlK_JdWcaHsxlsvSh34mqFsR4wrONAwFBo5yVw,2145
+pandas/tests/indexes/datetimes/test_scalar_compat.py,sha256=pJz6r8-pnr5nl_KkUaCkTu2A3SGzJbH_0dpTFRjUUz8,11156
+pandas/tests/indexes/datetimes/test_setops.py,sha256=HThtofPALvrCNqwnFk-tqdvCIe_ij2f-VOObJfZQ93w,23574
+pandas/tests/indexes/datetimes/test_timezones.py,sha256=LfELNHXgQN5-7zwBW5OweUZm6y8Ogtm-ir7l-RQAJpQ,8046
+pandas/tests/indexes/interval/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/indexes/interval/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/indexes/interval/__pycache__/test_astype.cpython-312.pyc,,
+pandas/tests/indexes/interval/__pycache__/test_constructors.cpython-312.pyc,,
+pandas/tests/indexes/interval/__pycache__/test_equals.cpython-312.pyc,,
+pandas/tests/indexes/interval/__pycache__/test_formats.cpython-312.pyc,,
+pandas/tests/indexes/interval/__pycache__/test_indexing.cpython-312.pyc,,
+pandas/tests/indexes/interval/__pycache__/test_interval.cpython-312.pyc,,
+pandas/tests/indexes/interval/__pycache__/test_interval_range.cpython-312.pyc,,
+pandas/tests/indexes/interval/__pycache__/test_interval_tree.cpython-312.pyc,,
+pandas/tests/indexes/interval/__pycache__/test_join.cpython-312.pyc,,
+pandas/tests/indexes/interval/__pycache__/test_pickle.cpython-312.pyc,,
+pandas/tests/indexes/interval/__pycache__/test_setops.cpython-312.pyc,,
+pandas/tests/indexes/interval/test_astype.py,sha256=7h7n8euKiXPnRU2d-4FYTAf-6iqPDR703dU7Oq10qwM,8809
+pandas/tests/indexes/interval/test_constructors.py,sha256=THCXDlRG7AncX5wzRlp9w1RNrYA0bTpWmzErMVfT0-w,19853
+pandas/tests/indexes/interval/test_equals.py,sha256=a7GA_whLbOiS4WxUdtDrqKOUhsfqq3TL0nkhqPccuss,1226
+pandas/tests/indexes/interval/test_formats.py,sha256=sUwFbFSiq-BBvB73vB1gZ4G5BTqQHWRRsmZzdx372DI,3921
+pandas/tests/indexes/interval/test_indexing.py,sha256=ig3f396aAkl3Lh1VX-MWOrDCn5t8bOop7xjOWjuCF7U,25320
+pandas/tests/indexes/interval/test_interval.py,sha256=L4Zo4GWIMVzHpOQ3Q09-GH_0Ixtge5ATR6kIgMYYjoc,34741
+pandas/tests/indexes/interval/test_interval_range.py,sha256=z_ZiNlL_7esHwH4Kd77k2gPm5Ev0Zy_NgACSkKoy4vA,13758
+pandas/tests/indexes/interval/test_interval_tree.py,sha256=yHyolu5v8YRazksfOBRgWd3O3eFVtzPc6NePpcV0ceU,7560
+pandas/tests/indexes/interval/test_join.py,sha256=HQJQLS9-RT7de6nBHsw50lBo4arBmXEVZhVMt4iuHyg,1148
+pandas/tests/indexes/interval/test_pickle.py,sha256=Jsmm_p3_qQpfJ9OqCpD3uLMzBkpsxufj1w6iUorYqmk,435
+pandas/tests/indexes/interval/test_setops.py,sha256=nwBz1MHuHiM7JQc74w2doEpgTSwg3NYfGwGbQFXWKw8,8346
+pandas/tests/indexes/multi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/indexes/multi/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/indexes/multi/__pycache__/conftest.cpython-312.pyc,,
+pandas/tests/indexes/multi/__pycache__/test_analytics.cpython-312.pyc,,
+pandas/tests/indexes/multi/__pycache__/test_astype.cpython-312.pyc,,
+pandas/tests/indexes/multi/__pycache__/test_compat.cpython-312.pyc,,
+pandas/tests/indexes/multi/__pycache__/test_constructors.cpython-312.pyc,,
+pandas/tests/indexes/multi/__pycache__/test_conversion.cpython-312.pyc,,
+pandas/tests/indexes/multi/__pycache__/test_copy.cpython-312.pyc,,
+pandas/tests/indexes/multi/__pycache__/test_drop.cpython-312.pyc,,
+pandas/tests/indexes/multi/__pycache__/test_duplicates.cpython-312.pyc,,
+pandas/tests/indexes/multi/__pycache__/test_equivalence.cpython-312.pyc,,
+pandas/tests/indexes/multi/__pycache__/test_formats.cpython-312.pyc,,
+pandas/tests/indexes/multi/__pycache__/test_get_level_values.cpython-312.pyc,,
+pandas/tests/indexes/multi/__pycache__/test_get_set.cpython-312.pyc,,
+pandas/tests/indexes/multi/__pycache__/test_indexing.cpython-312.pyc,,
+pandas/tests/indexes/multi/__pycache__/test_integrity.cpython-312.pyc,,
+pandas/tests/indexes/multi/__pycache__/test_isin.cpython-312.pyc,,
+pandas/tests/indexes/multi/__pycache__/test_join.cpython-312.pyc,,
+pandas/tests/indexes/multi/__pycache__/test_lexsort.cpython-312.pyc,,
+pandas/tests/indexes/multi/__pycache__/test_missing.cpython-312.pyc,,
+pandas/tests/indexes/multi/__pycache__/test_monotonic.cpython-312.pyc,,
+pandas/tests/indexes/multi/__pycache__/test_names.cpython-312.pyc,,
+pandas/tests/indexes/multi/__pycache__/test_partial_indexing.cpython-312.pyc,,
+pandas/tests/indexes/multi/__pycache__/test_pickle.cpython-312.pyc,,
+pandas/tests/indexes/multi/__pycache__/test_reindex.cpython-312.pyc,,
+pandas/tests/indexes/multi/__pycache__/test_reshape.cpython-312.pyc,,
+pandas/tests/indexes/multi/__pycache__/test_setops.cpython-312.pyc,,
+pandas/tests/indexes/multi/__pycache__/test_sorting.cpython-312.pyc,,
+pandas/tests/indexes/multi/__pycache__/test_take.cpython-312.pyc,,
+pandas/tests/indexes/multi/conftest.py,sha256=42mdJqtqvX3PlBSdch1Y6jRBvhe0IzZxOoLt-BGX03Q,698
+pandas/tests/indexes/multi/test_analytics.py,sha256=FeKERG9vHP-fAeGhlrzKO3IfAFpOOQnxQD7fRu2ycLY,6710
+pandas/tests/indexes/multi/test_astype.py,sha256=YmTnPF6qXwvYY82wZfQ8XFwVwOYYsIls3LSrdADDW-4,924
+pandas/tests/indexes/multi/test_compat.py,sha256=q53DVV5fYOKRVEQBl_2ws6WXrNsrGr5w4FXvXLUBeuQ,3918
+pandas/tests/indexes/multi/test_constructors.py,sha256=LP51k4lUfQgpfu7tjeIvvxaFgv-x_6VapDDx9I-y00I,26775
+pandas/tests/indexes/multi/test_conversion.py,sha256=8okPvlaOQgJzneUiy3MTwHU4Z9_th4cadqAxPiV-nLc,4957
+pandas/tests/indexes/multi/test_copy.py,sha256=9Xperk7a4yBTQKo8fgk3gCa2SwJr30mH2JYYMYWguWY,2405
+pandas/tests/indexes/multi/test_drop.py,sha256=Mv5FB-riRSuwwvVFJ60GwxRGbuFkU_LU5DPW8KY8NTk,6089
+pandas/tests/indexes/multi/test_duplicates.py,sha256=7_FP6fYuzDdffF2Wvgl8VKW4Auzq0xJ5ZVfp5Evnm3A,11559
+pandas/tests/indexes/multi/test_equivalence.py,sha256=LKBMAg82PbzkuMMy18u6Iktjzuavo1PIY-IxtPGBpZE,8530
+pandas/tests/indexes/multi/test_formats.py,sha256=Ra7L6T0N4zh6rZUg3gFP6bGC902uhBKV4kyLku7HCuI,9538
+pandas/tests/indexes/multi/test_get_level_values.py,sha256=WFSDmHIAXZ1RvDl-mK2HtXmWRO6IwSX5F0J7j5z0cm8,3971
+pandas/tests/indexes/multi/test_get_set.py,sha256=S3n29xb_Em0uKOsd6MPc_HR2bCQ54DHSdGi1bj1RSAE,12801
+pandas/tests/indexes/multi/test_indexing.py,sha256=lbx9kPQFf5EFfdCZ-yg1nGSqmJOYcpuHCBMC6vs_ZvA,36399
+pandas/tests/indexes/multi/test_integrity.py,sha256=VzyV3RrhWkQxwWzzLeLT6Lmc-njl4FnpoAIshI1BFW8,9031
+pandas/tests/indexes/multi/test_isin.py,sha256=OtlwJ9zZDvwgZOgbeY_oidWPOUmii_JBCCBpHnLw8us,3426
+pandas/tests/indexes/multi/test_join.py,sha256=aRp18UCIgoSXazdYdirOwGV0k8Gj4o5eNRJL56p56Bc,8440
+pandas/tests/indexes/multi/test_lexsort.py,sha256=KbwMnYF6GTIdefQ7eACQusNNuehbtiuqzBMqsOSfDU0,1358
+pandas/tests/indexes/multi/test_missing.py,sha256=hHjKWxl5vkG5k9B9fxglrYB4eQldKamkMbACAu6OvUY,3348
+pandas/tests/indexes/multi/test_monotonic.py,sha256=5xlESrQOEcFWdr0iB3OipJtA6-RzriU3Yq2OQGgP0M4,7007
+pandas/tests/indexes/multi/test_names.py,sha256=zx_8kapVXzDS_SsylRzTFia2OrNJeEq3kmNHUA4RVPM,6601
+pandas/tests/indexes/multi/test_partial_indexing.py,sha256=sVNIk9_NxMDsHuRQzPCernPmchTF5INAUFkzQV7t8T0,4765
+pandas/tests/indexes/multi/test_pickle.py,sha256=ZJVZo0DcXDtV6BAUuPAKbwMV8aGfazJLU7Lw6lRmBcw,259
+pandas/tests/indexes/multi/test_reindex.py,sha256=ww8fSIx426wfqBTogkJrKS533CjKorf-B4bhyKdEnD4,5856
+pandas/tests/indexes/multi/test_reshape.py,sha256=yRcnTGS0M5749jUZGEZA8_UxSZ-CeOeCsWYBbTS0nTY,6711
+pandas/tests/indexes/multi/test_setops.py,sha256=74Ob19TAIflChAm-jfGmi5KTC8fnQkHvprHBxLYSELM,25466
+pandas/tests/indexes/multi/test_sorting.py,sha256=69C8BENuzyUvnQXEbjVvADmBAr5G6wzM-ELHOMLV2Do,10745
+pandas/tests/indexes/multi/test_take.py,sha256=4MaxPM4ZJQPXJKiqgwEwhZ71TyH4KQfIs5LgS40vvLM,2487
+pandas/tests/indexes/numeric/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/indexes/numeric/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/indexes/numeric/__pycache__/test_astype.cpython-312.pyc,,
+pandas/tests/indexes/numeric/__pycache__/test_indexing.cpython-312.pyc,,
+pandas/tests/indexes/numeric/__pycache__/test_join.cpython-312.pyc,,
+pandas/tests/indexes/numeric/__pycache__/test_numeric.cpython-312.pyc,,
+pandas/tests/indexes/numeric/__pycache__/test_setops.cpython-312.pyc,,
+pandas/tests/indexes/numeric/test_astype.py,sha256=P19W9zZl8tN0EK-PaEi2gIFHLwCbruTMEUm7_ALGH9Q,3618
+pandas/tests/indexes/numeric/test_indexing.py,sha256=nDzkrokWvcmHkeHWjE8umPfxX4lR6AnQorAV7ppElCI,22761
+pandas/tests/indexes/numeric/test_join.py,sha256=OuSnYPH-jIM4UZRUKQ9NFxxd8Ot1HEP7KA3_ZpPX3Ks,15039
+pandas/tests/indexes/numeric/test_numeric.py,sha256=mEAFY8sSQdkVA0rJCTZb8cqjVAsTvL6mXzQSEXyxEgc,18586
+pandas/tests/indexes/numeric/test_setops.py,sha256=nO-3m7tb_ytjXx0Z8SqBkPSAnPVDz_PL3r2fzWtE7fg,5874
+pandas/tests/indexes/object/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/indexes/object/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/indexes/object/__pycache__/test_astype.cpython-312.pyc,,
+pandas/tests/indexes/object/__pycache__/test_indexing.cpython-312.pyc,,
+pandas/tests/indexes/object/test_astype.py,sha256=id6izR4uYcs_9q9ej3-_07n7uvIh8eC_qb9ZFVYjT0s,1060
+pandas/tests/indexes/object/test_indexing.py,sha256=pyc-tiHJlAMkIj67-wN3k079C_gtiNQVJWpxklRJ5l4,9410
+pandas/tests/indexes/period/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/indexes/period/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/indexes/period/__pycache__/test_constructors.cpython-312.pyc,,
+pandas/tests/indexes/period/__pycache__/test_formats.cpython-312.pyc,,
+pandas/tests/indexes/period/__pycache__/test_freq_attr.cpython-312.pyc,,
+pandas/tests/indexes/period/__pycache__/test_indexing.cpython-312.pyc,,
+pandas/tests/indexes/period/__pycache__/test_join.cpython-312.pyc,,
+pandas/tests/indexes/period/__pycache__/test_monotonic.cpython-312.pyc,,
+pandas/tests/indexes/period/__pycache__/test_partial_slicing.cpython-312.pyc,,
+pandas/tests/indexes/period/__pycache__/test_period.cpython-312.pyc,,
+pandas/tests/indexes/period/__pycache__/test_period_range.cpython-312.pyc,,
+pandas/tests/indexes/period/__pycache__/test_pickle.cpython-312.pyc,,
+pandas/tests/indexes/period/__pycache__/test_resolution.cpython-312.pyc,,
+pandas/tests/indexes/period/__pycache__/test_scalar_compat.cpython-312.pyc,,
+pandas/tests/indexes/period/__pycache__/test_searchsorted.cpython-312.pyc,,
+pandas/tests/indexes/period/__pycache__/test_setops.cpython-312.pyc,,
+pandas/tests/indexes/period/__pycache__/test_tools.cpython-312.pyc,,
+pandas/tests/indexes/period/methods/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/indexes/period/methods/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/indexes/period/methods/__pycache__/test_asfreq.cpython-312.pyc,,
+pandas/tests/indexes/period/methods/__pycache__/test_astype.cpython-312.pyc,,
+pandas/tests/indexes/period/methods/__pycache__/test_factorize.cpython-312.pyc,,
+pandas/tests/indexes/period/methods/__pycache__/test_fillna.cpython-312.pyc,,
+pandas/tests/indexes/period/methods/__pycache__/test_insert.cpython-312.pyc,,
+pandas/tests/indexes/period/methods/__pycache__/test_is_full.cpython-312.pyc,,
+pandas/tests/indexes/period/methods/__pycache__/test_repeat.cpython-312.pyc,,
+pandas/tests/indexes/period/methods/__pycache__/test_shift.cpython-312.pyc,,
+pandas/tests/indexes/period/methods/__pycache__/test_to_timestamp.cpython-312.pyc,,
+pandas/tests/indexes/period/methods/test_asfreq.py,sha256=PAqk5Zktd2OvLYwNoUGeXOh39HIIz9-5FqXnzrH6rtA,7080
+pandas/tests/indexes/period/methods/test_astype.py,sha256=k_xiGDPZOip3iw26LcB2E7UiRGHBZ39EOrsJxQoci6k,5469
+pandas/tests/indexes/period/methods/test_factorize.py,sha256=FXQh6VmGkuGkB2IAT4Y-2V5UaD2LCUNjQZ6amfBao80,1425
+pandas/tests/indexes/period/methods/test_fillna.py,sha256=jAYnaWGMuUaG993yxLwr1eT6J1ut43CcBaKds4Ce3-0,1125
+pandas/tests/indexes/period/methods/test_insert.py,sha256=JT9lBhbF90m2zRgIwarhPqPtVbrvkLiihZxO-4WHvTU,482
+pandas/tests/indexes/period/methods/test_is_full.py,sha256=RqIErBofIn5Ewh-MomVePHOn0hViZbe4laMC2vh8nPs,570
+pandas/tests/indexes/period/methods/test_repeat.py,sha256=1Nwn-ePYBEXWY4N9pFdHaqcZoKhWuinKdFJ-EjZtFlY,772
+pandas/tests/indexes/period/methods/test_shift.py,sha256=P7XDpMkLEYarH06RLBglFJKoGPkax4oLdiuI676KLek,4405
+pandas/tests/indexes/period/methods/test_to_timestamp.py,sha256=DCFf_Dt5cNsuSWJnYQAGfJrx1y2Z0GQiSTh0ajQJhjA,4888
+pandas/tests/indexes/period/test_constructors.py,sha256=LkRK-O65VdhX3EDQJHDdeGVQHfA6BQHT_PCi97M4xIs,27175
+pandas/tests/indexes/period/test_formats.py,sha256=DFLAMAPFzX2DI1iAAEjVY_nM9TuoYmCje3m7Q17A0EU,13259
+pandas/tests/indexes/period/test_freq_attr.py,sha256=KL1xaip5r7nY-3oLW16bmogfkYljsGJEJGKxn6w72Fo,646
+pandas/tests/indexes/period/test_indexing.py,sha256=jms77VvgkIgm0bSCHX-IMOtYuR0w2jd5uW3UoC2fm_4,27893
+pandas/tests/indexes/period/test_join.py,sha256=mwVL-OKx7tKTvMeSLNTh8jv6ViU6-NXcWr5O4hCmkOc,1835
+pandas/tests/indexes/period/test_monotonic.py,sha256=9Sb4WOykj99hn3MQOfm_MqYRxO5kADZt6OuakhSukp4,1258
+pandas/tests/indexes/period/test_partial_slicing.py,sha256=gXvS-qB0jPHYLKvjaP2rBW4p2UAm-ahM6KCCpT-u7ns,7433
+pandas/tests/indexes/period/test_period.py,sha256=91AawBQiPn_J3b6aG4sEzU24VaNJBTMn8shm_qkcE2g,7861
+pandas/tests/indexes/period/test_period_range.py,sha256=PB_VIuobx3NgnGOSmYZ0fyk79Zpoop22oYDP-TW-36Y,8979
+pandas/tests/indexes/period/test_pickle.py,sha256=l9A79u5PTcoa70g26wFPLTGnbvYpe76hPk1Iv334gb0,692
+pandas/tests/indexes/period/test_resolution.py,sha256=0TmnJeZCOaTWneeWA66DlxKgaUZJTfP0jKgLAY1jiyg,571
+pandas/tests/indexes/period/test_scalar_compat.py,sha256=CJuW0w6SdwDPtlk2Dl14g0ewuCcsIKPwtnmIMBSYEuc,1350
+pandas/tests/indexes/period/test_searchsorted.py,sha256=_u7DlvBnFx0_c8u3FIKYVOUcjlvN7p0gojLl9fZDkMQ,2604
+pandas/tests/indexes/period/test_setops.py,sha256=BcwDXv1-fnqOJLtzNqY2rEOye97Smyk2iXMnZx_IQE8,12547
+pandas/tests/indexes/period/test_tools.py,sha256=DFoxBsCYRWqodmNaDNPnQrZTTXiaSvwNZkwrybe7cl0,1361
+pandas/tests/indexes/ranges/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/indexes/ranges/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/indexes/ranges/__pycache__/test_constructors.cpython-312.pyc,,
+pandas/tests/indexes/ranges/__pycache__/test_indexing.cpython-312.pyc,,
+pandas/tests/indexes/ranges/__pycache__/test_join.cpython-312.pyc,,
+pandas/tests/indexes/ranges/__pycache__/test_range.cpython-312.pyc,,
+pandas/tests/indexes/ranges/__pycache__/test_setops.cpython-312.pyc,,
+pandas/tests/indexes/ranges/test_constructors.py,sha256=ceX79fbjGyc5VNkmz29Q1N7WGXLj40BvTuz5PfNAw4I,5328
+pandas/tests/indexes/ranges/test_indexing.py,sha256=WCJFjnEzFIqQUv_i2cy-wHRQ4Txfi8uq4UBp20s4LRw,5171
+pandas/tests/indexes/ranges/test_join.py,sha256=lniHRyuEJWY7UGc0TpJ20xzUftn6BpYJbZQPo2I0dxE,6268
+pandas/tests/indexes/ranges/test_range.py,sha256=AaoOQ_PufgrgnOmS7ARYRydbdU1jsb6-DKu2oX52LuI,20937
+pandas/tests/indexes/ranges/test_setops.py,sha256=yuiXAKlZJ5c3LkjPzFltAKFQmhVqaBleiJ7nzXs4_eA,17534
+pandas/tests/indexes/test_any_index.py,sha256=QgHuIfkF_E3BFaNveFThmGAbrMpyR_UL-KQ0FhPFTyY,5131
+pandas/tests/indexes/test_base.py,sha256=Te-rph8bo9g9lXscCEsVesaT6SYu2OB_8jIBOVsSN5Q,60624
+pandas/tests/indexes/test_common.py,sha256=sFM-TarVMvFsE8VGYMxcKVikmviNNPJSDxwGGijBvPY,17899
+pandas/tests/indexes/test_datetimelike.py,sha256=6ue74lBTp8Es6PZoE1e_5Fo6k3j7Hq_HkpLnBjAYspE,5598
+pandas/tests/indexes/test_engines.py,sha256=rq3JzDXNc2mZS5ZC2mQLpTeydheOX9OLoq1FLR53wbI,6699
+pandas/tests/indexes/test_frozen.py,sha256=ocwmaa3rzwC7UrU2Ng6o9xxQgxc8lDnrlAhlGNvQE0E,3125
+pandas/tests/indexes/test_index_new.py,sha256=6tO12VIGCoGKN3uk1SlPdPXn5vQaOJ9tECa3oVyWC8c,14923
+pandas/tests/indexes/test_indexing.py,sha256=jwcq_dujP7z8tfnLqQ-G2NoJ0CxrDIa33jWwRLKk-8w,11309
+pandas/tests/indexes/test_numpy_compat.py,sha256=fnrc8fNrV7v3BRTY7Huu9cyrBw2aNUrv5i4UUEublFE,5776
+pandas/tests/indexes/test_old_base.py,sha256=NnfN4Wb-Ua9i1WlibiNBrsaI6-YCLi760URJjJJJD0Q,39926
+pandas/tests/indexes/test_setops.py,sha256=0q7sa-WferJk9rjM9Lz-J4bWTac3O8WK_yYd9OV2O_U,32938
+pandas/tests/indexes/test_subclass.py,sha256=lmZHuQ8OSlwP3xcR8Xy2Mfvjxp2ry2zUL4DO2P4hbnk,1058
+pandas/tests/indexes/timedeltas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/indexes/timedeltas/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/indexes/timedeltas/__pycache__/test_arithmetic.cpython-312.pyc,,
+pandas/tests/indexes/timedeltas/__pycache__/test_constructors.cpython-312.pyc,,
+pandas/tests/indexes/timedeltas/__pycache__/test_delete.cpython-312.pyc,,
+pandas/tests/indexes/timedeltas/__pycache__/test_formats.cpython-312.pyc,,
+pandas/tests/indexes/timedeltas/__pycache__/test_freq_attr.cpython-312.pyc,,
+pandas/tests/indexes/timedeltas/__pycache__/test_indexing.cpython-312.pyc,,
+pandas/tests/indexes/timedeltas/__pycache__/test_join.cpython-312.pyc,,
+pandas/tests/indexes/timedeltas/__pycache__/test_ops.cpython-312.pyc,,
+pandas/tests/indexes/timedeltas/__pycache__/test_pickle.cpython-312.pyc,,
+pandas/tests/indexes/timedeltas/__pycache__/test_scalar_compat.cpython-312.pyc,,
+pandas/tests/indexes/timedeltas/__pycache__/test_searchsorted.cpython-312.pyc,,
+pandas/tests/indexes/timedeltas/__pycache__/test_setops.cpython-312.pyc,,
+pandas/tests/indexes/timedeltas/__pycache__/test_timedelta.cpython-312.pyc,,
+pandas/tests/indexes/timedeltas/__pycache__/test_timedelta_range.cpython-312.pyc,,
+pandas/tests/indexes/timedeltas/methods/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/indexes/timedeltas/methods/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/indexes/timedeltas/methods/__pycache__/test_astype.cpython-312.pyc,,
+pandas/tests/indexes/timedeltas/methods/__pycache__/test_factorize.cpython-312.pyc,,
+pandas/tests/indexes/timedeltas/methods/__pycache__/test_fillna.cpython-312.pyc,,
+pandas/tests/indexes/timedeltas/methods/__pycache__/test_insert.cpython-312.pyc,,
+pandas/tests/indexes/timedeltas/methods/__pycache__/test_repeat.cpython-312.pyc,,
+pandas/tests/indexes/timedeltas/methods/__pycache__/test_shift.cpython-312.pyc,,
+pandas/tests/indexes/timedeltas/methods/test_astype.py,sha256=gnbDreTvP4IrdYSzScM0jlpj9SJdzvTRt2sOL54hA8E,6129
+pandas/tests/indexes/timedeltas/methods/test_factorize.py,sha256=aqhhwRKZvfGxa3v09X5vZ7uBup8n5OjaUadfJpV6FoI,1292
+pandas/tests/indexes/timedeltas/methods/test_fillna.py,sha256=F7fBoEG-mnu16ypWYmK5wbIovQJKL0h86C1MzGkhPoE,597
+pandas/tests/indexes/timedeltas/methods/test_insert.py,sha256=fDYCuOIefgjNBJ7zhAUYniNVl5SltSs275XaNoL0S-s,4713
+pandas/tests/indexes/timedeltas/methods/test_repeat.py,sha256=vPcNBkY4H2RxsykW1bjTg-FSlTlQ2H1yLb-ZsYffsEg,926
+pandas/tests/indexes/timedeltas/methods/test_shift.py,sha256=MzVVupnLHEvuwlVCn6mR7LQ9pLeNiWM2lWwNlIwoo98,2756
+pandas/tests/indexes/timedeltas/test_arithmetic.py,sha256=YocDQIovXnrpXEzz3Ac-3l2PdGaDf2_sF8UPcLVF1Z8,1561
+pandas/tests/indexes/timedeltas/test_constructors.py,sha256=atU_oy_1oyUtMWRg47A94j3S4nPJbDRRgUhDCW6TO6M,10600
+pandas/tests/indexes/timedeltas/test_delete.py,sha256=-5uYhDUCD55zv5I3Z8aVFEBzdChSWtbPNSP05nqUEiA,2398
+pandas/tests/indexes/timedeltas/test_formats.py,sha256=4yUVmL5NEabGi9AXPA5isM3c4F3Rgslk4zqcfS-ua3s,3807
+pandas/tests/indexes/timedeltas/test_freq_attr.py,sha256=gYGl9w9UdtcfN26KUx1QyY4mjh6A0m4Csk3gsCIcdos,2176
+pandas/tests/indexes/timedeltas/test_indexing.py,sha256=9C-U4bwBd7D1GnaKgi51Jlgod7KhONIlgrA9t7jSQ80,12160
+pandas/tests/indexes/timedeltas/test_join.py,sha256=7JUirtgNGJMRL1-k2gekrvondwYuIVvuI2548v4nfIo,1396
+pandas/tests/indexes/timedeltas/test_ops.py,sha256=nfGyNJvNy7_jmWebKjevLKhyAMNvI5jytkZTNlpEC-g,393
+pandas/tests/indexes/timedeltas/test_pickle.py,sha256=QesBThE22Ba17eUdG21lWNqPRvBhyupLnPsXueLazHw,302
+pandas/tests/indexes/timedeltas/test_scalar_compat.py,sha256=hldSSTxREuBBuLAhvLTjX7FUmJ9DzcJxmMqzaClnErg,4573
+pandas/tests/indexes/timedeltas/test_searchsorted.py,sha256=kCE0PkuPk1CxkZHODe3aZ54V-Hc1AiHkyNNVjN5REIM,967
+pandas/tests/indexes/timedeltas/test_setops.py,sha256=Y6OwY82XC1hDgME55I_9q_UzGZdKhAhI1sxXS8bzr1w,9503
+pandas/tests/indexes/timedeltas/test_timedelta.py,sha256=UxobS6Dhfoqy4bnoAuMlLO8acpNrCDGsYWl4vGbDO8Q,1934
+pandas/tests/indexes/timedeltas/test_timedelta_range.py,sha256=tZqv_j045dPD3K2sbqdhdvEb-qE7szf9S7DJNX5Ri3o,6220
+pandas/tests/indexing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/indexing/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/indexing/__pycache__/common.cpython-312.pyc,,
+pandas/tests/indexing/__pycache__/conftest.cpython-312.pyc,,
+pandas/tests/indexing/__pycache__/test_at.cpython-312.pyc,,
+pandas/tests/indexing/__pycache__/test_categorical.cpython-312.pyc,,
+pandas/tests/indexing/__pycache__/test_chaining_and_caching.cpython-312.pyc,,
+pandas/tests/indexing/__pycache__/test_check_indexer.cpython-312.pyc,,
+pandas/tests/indexing/__pycache__/test_coercion.cpython-312.pyc,,
+pandas/tests/indexing/__pycache__/test_datetime.cpython-312.pyc,,
+pandas/tests/indexing/__pycache__/test_floats.cpython-312.pyc,,
+pandas/tests/indexing/__pycache__/test_iat.cpython-312.pyc,,
+pandas/tests/indexing/__pycache__/test_iloc.cpython-312.pyc,,
+pandas/tests/indexing/__pycache__/test_indexers.cpython-312.pyc,,
+pandas/tests/indexing/__pycache__/test_indexing.cpython-312.pyc,,
+pandas/tests/indexing/__pycache__/test_loc.cpython-312.pyc,,
+pandas/tests/indexing/__pycache__/test_na_indexing.cpython-312.pyc,,
+pandas/tests/indexing/__pycache__/test_partial.cpython-312.pyc,,
+pandas/tests/indexing/__pycache__/test_scalar.cpython-312.pyc,,
+pandas/tests/indexing/common.py,sha256=LtCDO4TeMhLWAiTGiJET3YP8RO6T3OQqmdpJ8JH391g,1021
+pandas/tests/indexing/conftest.py,sha256=9C84qvdnHzbM5C0KIVw3ueQhHzuUMoAlw07dVJqCAmQ,2677
+pandas/tests/indexing/interval/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/indexing/interval/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/indexing/interval/__pycache__/test_interval.cpython-312.pyc,,
+pandas/tests/indexing/interval/__pycache__/test_interval_new.cpython-312.pyc,,
+pandas/tests/indexing/interval/test_interval.py,sha256=pB8gTluRFlmZZVCcRDtjXUygjSJegI3YRYI3XIPgsy0,7482
+pandas/tests/indexing/interval/test_interval_new.py,sha256=IkPyCHTHvwyHf25ljz4o6Q0CnHVpnLD2jVUF3TbtLS4,7976
+pandas/tests/indexing/multiindex/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/indexing/multiindex/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/indexing/multiindex/__pycache__/test_chaining_and_caching.cpython-312.pyc,,
+pandas/tests/indexing/multiindex/__pycache__/test_datetime.cpython-312.pyc,,
+pandas/tests/indexing/multiindex/__pycache__/test_getitem.cpython-312.pyc,,
+pandas/tests/indexing/multiindex/__pycache__/test_iloc.cpython-312.pyc,,
+pandas/tests/indexing/multiindex/__pycache__/test_indexing_slow.cpython-312.pyc,,
+pandas/tests/indexing/multiindex/__pycache__/test_loc.cpython-312.pyc,,
+pandas/tests/indexing/multiindex/__pycache__/test_multiindex.cpython-312.pyc,,
+pandas/tests/indexing/multiindex/__pycache__/test_partial.cpython-312.pyc,,
+pandas/tests/indexing/multiindex/__pycache__/test_setitem.cpython-312.pyc,,
+pandas/tests/indexing/multiindex/__pycache__/test_slice.cpython-312.pyc,,
+pandas/tests/indexing/multiindex/__pycache__/test_sorted.cpython-312.pyc,,
+pandas/tests/indexing/multiindex/test_chaining_and_caching.py,sha256=hPcMvvPamIHI8AeSL7xvqs3eOT-5ONMjLy2XK2Mgt4Q,2922
+pandas/tests/indexing/multiindex/test_datetime.py,sha256=tl1yr3h50R0t7uvwTcfsRW-jt1n9vsqf4BWp4dNTdd8,1234
+pandas/tests/indexing/multiindex/test_getitem.py,sha256=wNftnfXLfiyjduEYeq8MSfE8K1OKaZG0WpmKWBqWk6o,13230
+pandas/tests/indexing/multiindex/test_iloc.py,sha256=G2CUPRhd5pRImZpH0uOVIPid7fzB4OuJZjH8arQMrE0,4918
+pandas/tests/indexing/multiindex/test_indexing_slow.py,sha256=nMfW1LQn7YlJauNceeR-uo_yPxRG2E8hcbgqTBMxaH4,3335
+pandas/tests/indexing/multiindex/test_loc.py,sha256=aVvEHILvJS7cYhNKEka_QiJlEcPim76s29FQlNbFYRw,32795
+pandas/tests/indexing/multiindex/test_multiindex.py,sha256=bIihrEIUXO1s8wAnKof9ATiwqAvwuLIWzE_oZlMxlOs,8065
+pandas/tests/indexing/multiindex/test_partial.py,sha256=05MXMJmAevJ31bqHIVikEL14x6s7IUASxLaw62w44mQ,8858
+pandas/tests/indexing/multiindex/test_setitem.py,sha256=cn0FPeh4oKRpI0o01tFx24VOoNQr90GCiKIMo8cBaE0,19840
+pandas/tests/indexing/multiindex/test_slice.py,sha256=7JcyCAq91OpruPy1awmdQmblxPzQF4UrnUN2XHrahbY,27104
+pandas/tests/indexing/multiindex/test_sorted.py,sha256=xCdmS_0DBN2yoTVcSB-x6Ecwcw93p6erw3bTiU6_J3s,5192
+pandas/tests/indexing/test_at.py,sha256=Vnv3lP2MkIjLvaj5LTsPvZN_GTsaGDl7c4dzdHbEZBI,8194
+pandas/tests/indexing/test_categorical.py,sha256=JPn8mSo7FSTuFaHzpiELgVBwTsqmjISLnGoxloy6SjU,19699
+pandas/tests/indexing/test_chaining_and_caching.py,sha256=-T0e9bh8ktgrHrB8CXd-MjcvLnckuiSSyBC8Cr6q-uE,23479
+pandas/tests/indexing/test_check_indexer.py,sha256=tfr2a1h6uokN2MJDE7TKiZ0iRaHvfSWPPC-86RqaaDU,3159
+pandas/tests/indexing/test_coercion.py,sha256=RxeenIaFXLT9bPDEnV7zfpcPv5UC5QMVjp-hb0Igv9g,32629
+pandas/tests/indexing/test_datetime.py,sha256=Gj5Fo4ywd4md3H-zbk11bSbNEmktbnlHORVRzBfN0oE,5703
+pandas/tests/indexing/test_floats.py,sha256=KG_T_POIEc5nnVL7Zi8zSwamhahbfjUxBYrC3ilRlEI,20603
+pandas/tests/indexing/test_iat.py,sha256=cQrMr1MYQv5LZS5E34NumdqqeK8hvcN6duLRTaeZ6Go,1492
+pandas/tests/indexing/test_iloc.py,sha256=Y6LdDIOVnWoLlcqVI8eLoRwS4TgpNNRipr0Q-90FbM0,51335
+pandas/tests/indexing/test_indexers.py,sha256=agN_MCo403fOvqapKi_WYQli9AkDFAk4TDB5XpbJ8js,1661
+pandas/tests/indexing/test_indexing.py,sha256=a3ChWUgSad-7yXrvRU4wr6lY5Oqt24308Z_kMkqFxxg,40042
+pandas/tests/indexing/test_loc.py,sha256=mV2746VJwKa8-Rwn4iK-nvDl_CuMcHoDPOxP3wfJ5V8,119354
+pandas/tests/indexing/test_na_indexing.py,sha256=Ek_7A7ctm_WB-32NePbODbQ5LDMZBAmCvDgPKbIUOcg,2322
+pandas/tests/indexing/test_partial.py,sha256=f32wptlfPdvAdRSgt2N5USZQdtNt-GM31QoQpJSpXeA,25256
+pandas/tests/indexing/test_scalar.py,sha256=BuLsr0F1OA4IeA816BzuLFiSNGppPoALpieV2_8Nfg8,9643
+pandas/tests/interchange/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/interchange/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/interchange/__pycache__/test_impl.cpython-312.pyc,,
+pandas/tests/interchange/__pycache__/test_spec_conformance.cpython-312.pyc,,
+pandas/tests/interchange/__pycache__/test_utils.cpython-312.pyc,,
+pandas/tests/interchange/test_impl.py,sha256=Exl81IoyGGPYt1Nz2ipJQ79cDXqlVZnJuFhCuIfKt5Q,19878
+pandas/tests/interchange/test_spec_conformance.py,sha256=JnE2kQOLr4EjUCH6Nzc1fCEXhbZ52WzKbioW6f6EVxo,5593
+pandas/tests/interchange/test_utils.py,sha256=15liIDJirQDoP7TxxQkmZJ9gCAVNCd2BwShW_GlwL2A,2965
+pandas/tests/internals/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/internals/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/internals/__pycache__/test_api.cpython-312.pyc,,
+pandas/tests/internals/__pycache__/test_internals.cpython-312.pyc,,
+pandas/tests/internals/__pycache__/test_managers.cpython-312.pyc,,
+pandas/tests/internals/test_api.py,sha256=7s-n3jyp-e0ikVxkIqxf3xRtxk3aBV4h5FsnMIcStMY,2166
+pandas/tests/internals/test_internals.py,sha256=jeWXqpUIEnygO0BwnHdQZNsolBusoxvRSNndgaCnuUE,49657
+pandas/tests/internals/test_managers.py,sha256=uIuBmkOCjbFuGGNOodZ7ITijw4CfsG4aOUqRLCEfg-s,3556
+pandas/tests/io/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/io/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/io/__pycache__/conftest.cpython-312.pyc,,
+pandas/tests/io/__pycache__/generate_legacy_storage_files.cpython-312.pyc,,
+pandas/tests/io/__pycache__/test_clipboard.cpython-312.pyc,,
+pandas/tests/io/__pycache__/test_common.cpython-312.pyc,,
+pandas/tests/io/__pycache__/test_compression.cpython-312.pyc,,
+pandas/tests/io/__pycache__/test_feather.cpython-312.pyc,,
+pandas/tests/io/__pycache__/test_fsspec.cpython-312.pyc,,
+pandas/tests/io/__pycache__/test_gbq.cpython-312.pyc,,
+pandas/tests/io/__pycache__/test_gcs.cpython-312.pyc,,
+pandas/tests/io/__pycache__/test_html.cpython-312.pyc,,
+pandas/tests/io/__pycache__/test_http_headers.cpython-312.pyc,,
+pandas/tests/io/__pycache__/test_orc.cpython-312.pyc,,
+pandas/tests/io/__pycache__/test_parquet.cpython-312.pyc,,
+pandas/tests/io/__pycache__/test_pickle.cpython-312.pyc,,
+pandas/tests/io/__pycache__/test_s3.cpython-312.pyc,,
+pandas/tests/io/__pycache__/test_spss.cpython-312.pyc,,
+pandas/tests/io/__pycache__/test_sql.cpython-312.pyc,,
+pandas/tests/io/__pycache__/test_stata.cpython-312.pyc,,
+pandas/tests/io/conftest.py,sha256=F72gAcQcyFdyv07CQkjbTT8dOkXSVHtwDQaIHFTB9xY,6406
+pandas/tests/io/excel/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/io/excel/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/io/excel/__pycache__/test_odf.cpython-312.pyc,,
+pandas/tests/io/excel/__pycache__/test_odswriter.cpython-312.pyc,,
+pandas/tests/io/excel/__pycache__/test_openpyxl.cpython-312.pyc,,
+pandas/tests/io/excel/__pycache__/test_readers.cpython-312.pyc,,
+pandas/tests/io/excel/__pycache__/test_style.cpython-312.pyc,,
+pandas/tests/io/excel/__pycache__/test_writers.cpython-312.pyc,,
+pandas/tests/io/excel/__pycache__/test_xlrd.cpython-312.pyc,,
+pandas/tests/io/excel/__pycache__/test_xlsxwriter.cpython-312.pyc,,
+pandas/tests/io/excel/test_odf.py,sha256=DoE6DfjKkIKGJtRUG8uvBNNGBOvoqVZnL8Jr_I1vOLQ,1999
+pandas/tests/io/excel/test_odswriter.py,sha256=2SmPARRnXiOAstiUaEFaVfGu2kVQ5vVHGODlozrlUFI,3268
+pandas/tests/io/excel/test_openpyxl.py,sha256=wnADQLARvjB4BMYgd2fMs5jsvYm8DQvqFngJVnhSH1Q,15227
+pandas/tests/io/excel/test_readers.py,sha256=Qn8L41hKdO_2xkpTNBi2eqpUx0OAV3BfqeUKoSOn0aM,63198
+pandas/tests/io/excel/test_style.py,sha256=mQ7roFc4ZfBfrjc4Das0lNnYXIcV1cO1AOuXVRw1Dqw,11284
+pandas/tests/io/excel/test_writers.py,sha256=udzFSri-07QXgV0v-xHJ3Cx8wKvJJaoCByyAwwIg6gM,54899
+pandas/tests/io/excel/test_xlrd.py,sha256=e5QrByVFVm6rEZbdSifYBBCY-czTzWZZ5y7OyfrPksw,1977
+pandas/tests/io/excel/test_xlsxwriter.py,sha256=DUmibvRcUD6O2OcD_YcMymQPvMgkckIH92NjYsamyOE,2773
+pandas/tests/io/formats/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/io/formats/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/io/formats/__pycache__/test_console.cpython-312.pyc,,
+pandas/tests/io/formats/__pycache__/test_css.cpython-312.pyc,,
+pandas/tests/io/formats/__pycache__/test_eng_formatting.cpython-312.pyc,,
+pandas/tests/io/formats/__pycache__/test_format.cpython-312.pyc,,
+pandas/tests/io/formats/__pycache__/test_ipython_compat.cpython-312.pyc,,
+pandas/tests/io/formats/__pycache__/test_printing.cpython-312.pyc,,
+pandas/tests/io/formats/__pycache__/test_to_csv.cpython-312.pyc,,
+pandas/tests/io/formats/__pycache__/test_to_excel.cpython-312.pyc,,
+pandas/tests/io/formats/__pycache__/test_to_html.cpython-312.pyc,,
+pandas/tests/io/formats/__pycache__/test_to_latex.cpython-312.pyc,,
+pandas/tests/io/formats/__pycache__/test_to_markdown.cpython-312.pyc,,
+pandas/tests/io/formats/__pycache__/test_to_string.cpython-312.pyc,,
+pandas/tests/io/formats/style/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/io/formats/style/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/io/formats/style/__pycache__/test_bar.cpython-312.pyc,,
+pandas/tests/io/formats/style/__pycache__/test_exceptions.cpython-312.pyc,,
+pandas/tests/io/formats/style/__pycache__/test_format.cpython-312.pyc,,
+pandas/tests/io/formats/style/__pycache__/test_highlight.cpython-312.pyc,,
+pandas/tests/io/formats/style/__pycache__/test_html.cpython-312.pyc,,
+pandas/tests/io/formats/style/__pycache__/test_matplotlib.cpython-312.pyc,,
+pandas/tests/io/formats/style/__pycache__/test_non_unique.cpython-312.pyc,,
+pandas/tests/io/formats/style/__pycache__/test_style.cpython-312.pyc,,
+pandas/tests/io/formats/style/__pycache__/test_to_latex.cpython-312.pyc,,
+pandas/tests/io/formats/style/__pycache__/test_to_string.cpython-312.pyc,,
+pandas/tests/io/formats/style/__pycache__/test_tooltip.cpython-312.pyc,,
+pandas/tests/io/formats/style/test_bar.py,sha256=czy40UZacoi9uyzM-w-AC5lMu2z2cwKwyE9Ml0i6x_k,12014
+pandas/tests/io/formats/style/test_exceptions.py,sha256=qm62Nu_E61TOrGXzxMSYm5Ciqm7qKhCFaTDP0QJmjJo,1002
+pandas/tests/io/formats/style/test_format.py,sha256=9siaXSHvCrA-YEuRI0-zun0gwQf2fVZwSPMIrb7CLTE,21154
+pandas/tests/io/formats/style/test_highlight.py,sha256=p2vRhU8aefAfmqLptxNO4XYbrVsccERvFQRd1OowC10,7003
+pandas/tests/io/formats/style/test_html.py,sha256=FvW0Zh6U8CkOKo0Plvz8W-udOgsczg9qawyVq-xzKqc,32702
+pandas/tests/io/formats/style/test_matplotlib.py,sha256=KPTvs_DbJlT5u7xQiQW3Ct-0jmpFHuah_lfQgZkiuQw,11649
+pandas/tests/io/formats/style/test_non_unique.py,sha256=JG_rE5A5Zk5exlfivZHnOI3Upzm8dJjmKKHkwEje4LQ,4366
+pandas/tests/io/formats/style/test_style.py,sha256=x7r8-nhnYdifw_PjopT0a4t99MTGzlOBv-g38HOHxik,58095
+pandas/tests/io/formats/style/test_to_latex.py,sha256=EbsBCluJ-2eVLSxXHgLo6Uus6VsnrbzqO9sYaRuewgs,33008
+pandas/tests/io/formats/style/test_to_string.py,sha256=w1GvLm3FtKQd9t2nwN3vF55X5f0GQKGCGXpYFZxITpA,1910
+pandas/tests/io/formats/style/test_tooltip.py,sha256=GMqwXrXi9Ppp0khfZHEwgeRqahwju5U2iIhZan3ndZE,2899
+pandas/tests/io/formats/test_console.py,sha256=jAk1wudhPiLBhhtydTNRlZ43961LqFu3uYt6cVA_jV0,2435
+pandas/tests/io/formats/test_css.py,sha256=YFHK3UFe2jcnz6AhmOFb7ZU1jd5Y_LYxIx5PBrJXNLQ,8669
+pandas/tests/io/formats/test_eng_formatting.py,sha256=QqFZJMUBVnU5SpZB63tCOHX3CqZbjgesOZc6nxbhp4c,8454
+pandas/tests/io/formats/test_format.py,sha256=10Nmscrr_GplWPa9t7nAluixTS73AqJfCNbiX4Kf5HI,83181
+pandas/tests/io/formats/test_ipython_compat.py,sha256=pRAOUIZ3Vsb2LVYywzk30d834GzqLH9N8kjTGlf2MXc,3055
+pandas/tests/io/formats/test_printing.py,sha256=hLBoT3FE7J2VjxCJIAS_N24g6pMoQcyQphGTnwt0Ehc,4499
+pandas/tests/io/formats/test_to_csv.py,sha256=mThYTrnKefL4fWiqsLmJP9nsJcKx9ejdPNXndW6ADzo,27541
+pandas/tests/io/formats/test_to_excel.py,sha256=ecNeSrVd2mSPsdIqm3lM911b4mPwLIVkoz3MnJFZE3g,15320
+pandas/tests/io/formats/test_to_html.py,sha256=elbKQSMvV8p3qWEFVFA_nneSjdXl432QYDlha1cGVGw,38699
+pandas/tests/io/formats/test_to_latex.py,sha256=ka8kOxa7dLP3wQf7b4dGHLNP9lc6TI1MCepsLSfYoTQ,41660
+pandas/tests/io/formats/test_to_markdown.py,sha256=2DUY7KrRVUu_OU6q4biW8rNFEINN6fPSkqs8VzY8rlE,2757
+pandas/tests/io/formats/test_to_string.py,sha256=aCcTOFjwdLQbEZ3JLEvlUySigpY-M4Gp8pV8ue-S0Ig,39371
+pandas/tests/io/generate_legacy_storage_files.py,sha256=c-J8fZLOyR7FRP8ijI6WcJrqequzwHJBZPs_1xC3bHI,9853
+pandas/tests/io/json/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/io/json/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/io/json/__pycache__/conftest.cpython-312.pyc,,
+pandas/tests/io/json/__pycache__/test_compression.cpython-312.pyc,,
+pandas/tests/io/json/__pycache__/test_deprecated_kwargs.cpython-312.pyc,,
+pandas/tests/io/json/__pycache__/test_json_table_schema.cpython-312.pyc,,
+pandas/tests/io/json/__pycache__/test_json_table_schema_ext_dtype.cpython-312.pyc,,
+pandas/tests/io/json/__pycache__/test_normalize.cpython-312.pyc,,
+pandas/tests/io/json/__pycache__/test_pandas.cpython-312.pyc,,
+pandas/tests/io/json/__pycache__/test_readlines.cpython-312.pyc,,
+pandas/tests/io/json/__pycache__/test_ujson.cpython-312.pyc,,
+pandas/tests/io/json/conftest.py,sha256=Zp83o90PvZ56MbhNRr1NZEPTpho7jRHcLYiEA9R_BZw,205
+pandas/tests/io/json/test_compression.py,sha256=PNaQlGwVdCL8K6ujRinmALn9O28tNZbxgelGcK-6MSo,4506
+pandas/tests/io/json/test_deprecated_kwargs.py,sha256=DKuEh2V2IkJOu-BnurWvax8Mq5EcQHtG-K-zncGZRpo,690
+pandas/tests/io/json/test_json_table_schema.py,sha256=lWCSq6HZNqPpjffejfkqc9JKjhRPUUVuLPWyWTyXDG4,30676
+pandas/tests/io/json/test_json_table_schema_ext_dtype.py,sha256=mTwJ_IpOBewvrLU98eLo-_yibYtOqD64LKLI_WIr5n0,9500
+pandas/tests/io/json/test_normalize.py,sha256=eOQoJQBGjAqFcswdNBipHoGMGBgLiwLFNIzTuZ5XSkI,30816
+pandas/tests/io/json/test_pandas.py,sha256=JlBn9DVzXvHbDKPYfyF6dt8njaNOeQ6mkR3vdJFUM_I,78323
+pandas/tests/io/json/test_readlines.py,sha256=NaIeCB9w7iM_Ptamx4IoLMRwIG9eUQxsTJpU2cBB5y0,18819
+pandas/tests/io/json/test_ujson.py,sha256=UYh87hxO7ySZ60Q8ycDjbEqzcbBD51mV9qIlMCDA_Fc,36424
+pandas/tests/io/parser/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/io/parser/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/io/parser/__pycache__/conftest.cpython-312.pyc,,
+pandas/tests/io/parser/__pycache__/test_c_parser_only.cpython-312.pyc,,
+pandas/tests/io/parser/__pycache__/test_comment.cpython-312.pyc,,
+pandas/tests/io/parser/__pycache__/test_compression.cpython-312.pyc,,
+pandas/tests/io/parser/__pycache__/test_concatenate_chunks.cpython-312.pyc,,
+pandas/tests/io/parser/__pycache__/test_converters.cpython-312.pyc,,
+pandas/tests/io/parser/__pycache__/test_dialect.cpython-312.pyc,,
+pandas/tests/io/parser/__pycache__/test_encoding.cpython-312.pyc,,
+pandas/tests/io/parser/__pycache__/test_header.cpython-312.pyc,,
+pandas/tests/io/parser/__pycache__/test_index_col.cpython-312.pyc,,
+pandas/tests/io/parser/__pycache__/test_mangle_dupes.cpython-312.pyc,,
+pandas/tests/io/parser/__pycache__/test_multi_thread.cpython-312.pyc,,
+pandas/tests/io/parser/__pycache__/test_na_values.cpython-312.pyc,,
+pandas/tests/io/parser/__pycache__/test_network.cpython-312.pyc,,
+pandas/tests/io/parser/__pycache__/test_parse_dates.cpython-312.pyc,,
+pandas/tests/io/parser/__pycache__/test_python_parser_only.cpython-312.pyc,,
+pandas/tests/io/parser/__pycache__/test_quoting.cpython-312.pyc,,
+pandas/tests/io/parser/__pycache__/test_read_fwf.cpython-312.pyc,,
+pandas/tests/io/parser/__pycache__/test_skiprows.cpython-312.pyc,,
+pandas/tests/io/parser/__pycache__/test_textreader.cpython-312.pyc,,
+pandas/tests/io/parser/__pycache__/test_unsupported.cpython-312.pyc,,
+pandas/tests/io/parser/__pycache__/test_upcast.cpython-312.pyc,,
+pandas/tests/io/parser/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/io/parser/common/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/io/parser/common/__pycache__/test_chunksize.cpython-312.pyc,,
+pandas/tests/io/parser/common/__pycache__/test_common_basic.cpython-312.pyc,,
+pandas/tests/io/parser/common/__pycache__/test_data_list.cpython-312.pyc,,
+pandas/tests/io/parser/common/__pycache__/test_decimal.cpython-312.pyc,,
+pandas/tests/io/parser/common/__pycache__/test_file_buffer_url.cpython-312.pyc,,
+pandas/tests/io/parser/common/__pycache__/test_float.cpython-312.pyc,,
+pandas/tests/io/parser/common/__pycache__/test_index.cpython-312.pyc,,
+pandas/tests/io/parser/common/__pycache__/test_inf.cpython-312.pyc,,
+pandas/tests/io/parser/common/__pycache__/test_ints.cpython-312.pyc,,
+pandas/tests/io/parser/common/__pycache__/test_iterator.cpython-312.pyc,,
+pandas/tests/io/parser/common/__pycache__/test_read_errors.cpython-312.pyc,,
+pandas/tests/io/parser/common/__pycache__/test_verbose.cpython-312.pyc,,
+pandas/tests/io/parser/common/test_chunksize.py,sha256=IEeKcV5GYLee7U0ACIyDJtR-Q176X9zfRg7YqrdeWx8,11103
+pandas/tests/io/parser/common/test_common_basic.py,sha256=7RdM9Bh71Qmpf2bkUPu2MiHDwdUb2NJIwmxK3g1QEBc,30872
+pandas/tests/io/parser/common/test_data_list.py,sha256=XTWzTbtaLRGFdrjfRTJH3TTedD8Y0uCWRzji1qnrdk4,2228
+pandas/tests/io/parser/common/test_decimal.py,sha256=6WZy1C7G2vNpSo165GZAoRFGiy9OMgKygAIEYNalQ-Y,1932
+pandas/tests/io/parser/common/test_file_buffer_url.py,sha256=Gr7jx2idDJrMKF6tdwe-hxd9ewWxRokSAlFYjAeRgfM,14007
+pandas/tests/io/parser/common/test_float.py,sha256=5XM0Cndv31L4_7ER2MOB-Bnk9_GELTpakFp1-dNRjyM,2582
+pandas/tests/io/parser/common/test_index.py,sha256=kNF9uReFUMb4YaK9Cz10zUWnUXxT3OpZIhiy1fZTu_4,8234
+pandas/tests/io/parser/common/test_inf.py,sha256=yXUF6DrDhiPKEfEXJLnb71bZnycbo4CKXkl14Vyv3QY,2114
+pandas/tests/io/parser/common/test_ints.py,sha256=K49T03jXs77ktsxIFFQqBisPI3z042A8GATZcn1Tq44,7243
+pandas/tests/io/parser/common/test_iterator.py,sha256=FljWxY67UNOCedqg_as_nY4GtkU4HDwqwgpLkxU00Aw,3702
+pandas/tests/io/parser/common/test_read_errors.py,sha256=Aas1e5CM0ohMBXNQ2tSZao7jZbWTk9LA85FglJ8CRLE,9592
+pandas/tests/io/parser/common/test_verbose.py,sha256=kil5N51khhQifV9az-x2ijMr3wGtddKrU5oAbr0b1hs,2339
+pandas/tests/io/parser/conftest.py,sha256=PW00EmO-nd14_zUV7Uf8EO5tezaI-_zFcn2jP-Msxow,8725
+pandas/tests/io/parser/dtypes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/io/parser/dtypes/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/io/parser/dtypes/__pycache__/test_categorical.cpython-312.pyc,,
+pandas/tests/io/parser/dtypes/__pycache__/test_dtypes_basic.cpython-312.pyc,,
+pandas/tests/io/parser/dtypes/__pycache__/test_empty.cpython-312.pyc,,
+pandas/tests/io/parser/dtypes/test_categorical.py,sha256=H8HO6IYwkJryJV87hKep0rtyx4XmXAHh1ICuprkmYjM,9836
+pandas/tests/io/parser/dtypes/test_dtypes_basic.py,sha256=9IoehDR7qPsZOIAHDcsX4ekahkeU8MEkpeYMqb_fwAg,18502
+pandas/tests/io/parser/dtypes/test_empty.py,sha256=bFuG8P_48stM0rEB8J0pF-sRl3kezS-9wB3fycgCjFo,5258
+pandas/tests/io/parser/test_c_parser_only.py,sha256=qSNbMmaYlQG4ddezez8HkcFtSEtH8BCnL7UM1FwANbU,20534
+pandas/tests/io/parser/test_comment.py,sha256=QO0E262p5tnOpm9oxqTO1rwl0KU-mKMP_jydlahyFMM,7560
+pandas/tests/io/parser/test_compression.py,sha256=hW1GxllxvM8sUQhmTVibkkqdj0JcAAR9b7nKCxuXblk,6403
+pandas/tests/io/parser/test_concatenate_chunks.py,sha256=RD1MUklgLBtBNvJu5J92cVZbrO3n38UzdQvh4BAvAqI,1128
+pandas/tests/io/parser/test_converters.py,sha256=iA5iv_5YSfwloTccNfdgE-9QO-Zm9Z_taDspYeRvAF4,7453
+pandas/tests/io/parser/test_dialect.py,sha256=tgsdnhEkYBtjIKd-9BKAyQ8ATTSivnzIkiWiuLi513M,5844
+pandas/tests/io/parser/test_encoding.py,sha256=Og-q60V-nd-8xl5VBWDPtYqxGeemrs8rYCoCCWKdjmc,10782
+pandas/tests/io/parser/test_header.py,sha256=zvSu-S51vJaIGPOdZgdC2IeHd2Y_1FTId-QGJc_7BWU,21029
+pandas/tests/io/parser/test_index_col.py,sha256=deEpoBpT2KvbrcUgpnSmylzdpdAY5uhPtPRKzhJyUcE,11501
+pandas/tests/io/parser/test_mangle_dupes.py,sha256=Xwci86pIvocxp6Gc0hT2bk0QahFZwTQdhKewCrC-W38,5390
+pandas/tests/io/parser/test_multi_thread.py,sha256=x40FWVAiCprn9T83Tu7cVaiUcGIcSSOgp7lauIUsdjo,4315
+pandas/tests/io/parser/test_na_values.py,sha256=P4mcmVpprWhd0TsFdABCJnNPQrkrLLFwIrpKaHe8bJo,22138
+pandas/tests/io/parser/test_network.py,sha256=8bNvzZHJ6r_m1WEJ7qt6fZtUbxLkxWP_aGqGnrtk_Po,12319
+pandas/tests/io/parser/test_parse_dates.py,sha256=lnel1CZGmZqmRdTG5ltGwVKl9GChQU07v8uyG25ci1k,69737
+pandas/tests/io/parser/test_python_parser_only.py,sha256=wkXRjsAKI6pZnvhetAyLanvn_0pjIxQBALYDHazXrf8,15897
+pandas/tests/io/parser/test_quoting.py,sha256=7g4XLvgjtkRf9qgl7eksjwJ-N42e4dq-nCEPWP9hS9g,6244
+pandas/tests/io/parser/test_read_fwf.py,sha256=DM-YTi6mkb6dup72srdA4GTIx6nzDiBoQqIGfwa1BQg,30107
+pandas/tests/io/parser/test_skiprows.py,sha256=D0dm01x-53YqSXXvj1jczRV5SWEDNkNP87tquehyn9w,9457
+pandas/tests/io/parser/test_textreader.py,sha256=R_yeB-k6g45i6ZTQ-PdF8DIJYdodhH059OGrRdM8IOM,10672
+pandas/tests/io/parser/test_unsupported.py,sha256=149HYApTOEJP9xEXuXuncyS2zq_lpF_AyBfu_SIjjes,7986
+pandas/tests/io/parser/test_upcast.py,sha256=XEjHUvgExlKwxTCSjSfWMxjwge0HeW9q2BMIQGuxfTk,3141
+pandas/tests/io/parser/usecols/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/io/parser/usecols/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/io/parser/usecols/__pycache__/test_parse_dates.cpython-312.pyc,,
+pandas/tests/io/parser/usecols/__pycache__/test_strings.cpython-312.pyc,,
+pandas/tests/io/parser/usecols/__pycache__/test_usecols_basic.cpython-312.pyc,,
+pandas/tests/io/parser/usecols/test_parse_dates.py,sha256=7PYxerT3Eok6kVV6dfU2e-qlBpde-gfCGMg1NEht8cM,5469
+pandas/tests/io/parser/usecols/test_strings.py,sha256=-ZUBWSpxMgoxqRfGAa0mgb5motUoKveF06V9LUH-nQg,2588
+pandas/tests/io/parser/usecols/test_usecols_basic.py,sha256=BKr0EIu8g1aLiF6a_g61zF2NHPVY8Cl6CRcNnHLQ_4o,17646
+pandas/tests/io/pytables/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/io/pytables/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/io/pytables/__pycache__/common.cpython-312.pyc,,
+pandas/tests/io/pytables/__pycache__/conftest.cpython-312.pyc,,
+pandas/tests/io/pytables/__pycache__/test_append.cpython-312.pyc,,
+pandas/tests/io/pytables/__pycache__/test_categorical.cpython-312.pyc,,
+pandas/tests/io/pytables/__pycache__/test_compat.cpython-312.pyc,,
+pandas/tests/io/pytables/__pycache__/test_complex.cpython-312.pyc,,
+pandas/tests/io/pytables/__pycache__/test_errors.cpython-312.pyc,,
+pandas/tests/io/pytables/__pycache__/test_file_handling.cpython-312.pyc,,
+pandas/tests/io/pytables/__pycache__/test_keys.cpython-312.pyc,,
+pandas/tests/io/pytables/__pycache__/test_put.cpython-312.pyc,,
+pandas/tests/io/pytables/__pycache__/test_pytables_missing.cpython-312.pyc,,
+pandas/tests/io/pytables/__pycache__/test_read.cpython-312.pyc,,
+pandas/tests/io/pytables/__pycache__/test_retain_attributes.cpython-312.pyc,,
+pandas/tests/io/pytables/__pycache__/test_round_trip.cpython-312.pyc,,
+pandas/tests/io/pytables/__pycache__/test_select.cpython-312.pyc,,
+pandas/tests/io/pytables/__pycache__/test_store.cpython-312.pyc,,
+pandas/tests/io/pytables/__pycache__/test_subclass.cpython-312.pyc,,
+pandas/tests/io/pytables/__pycache__/test_time_series.cpython-312.pyc,,
+pandas/tests/io/pytables/__pycache__/test_timezones.cpython-312.pyc,,
+pandas/tests/io/pytables/common.py,sha256=m3IH26TCzLDpS8ctvzJKLA8x414ur5jlX3sdT4sB4m8,1264
+pandas/tests/io/pytables/conftest.py,sha256=vQgspEHypJUvbAU3P0I5BDBW2vRK4CgmcNqY5ZXksns,136
+pandas/tests/io/pytables/test_append.py,sha256=BlbvStEsoiOGbA85pP9hw8ufZXrqixjTjGaD6msIJuE,36668
+pandas/tests/io/pytables/test_categorical.py,sha256=l_Xyc15J7E4f3_jA9Lr_sz1AhW_jyIBm9xWuRb3X154,6994
+pandas/tests/io/pytables/test_compat.py,sha256=qsaDgIDMQOOMA_ZYv7r9r9sBUUbA9Fe2jb2j8XAeY_s,2547
+pandas/tests/io/pytables/test_complex.py,sha256=CUEEEU3zJh6pmj-gws7ahyhsHJTxO0W9MKraXeFg89A,5948
+pandas/tests/io/pytables/test_errors.py,sha256=Eqf2Jad_QDt2W3SCgUf6KpS_yH5HncsmLK2K-dFpggs,8372
+pandas/tests/io/pytables/test_file_handling.py,sha256=31di39gTGo5oNr7JRGGDdRBTsOOUPMX4LZoGPpTwyZk,14592
+pandas/tests/io/pytables/test_keys.py,sha256=trCYnTHa2LhD2xnqVJ6iv1BEahHpG4FDMNbjw_MG07w,2671
+pandas/tests/io/pytables/test_put.py,sha256=OHoalcEnIuqiGN0URxnagPXjguU6-sRAjeEucN2bboA,12335
+pandas/tests/io/pytables/test_pytables_missing.py,sha256=mK_l-tuF_TeoK4gZqRncm-FCe2PUgk2AS3q6q0M1YIU,345
+pandas/tests/io/pytables/test_read.py,sha256=coGLYjldztQ7XDYywtSWM6oQnG71J2q5Jg_yohuhHSg,13242
+pandas/tests/io/pytables/test_retain_attributes.py,sha256=WY5rbnlT_NqERl4OSJ9C2iWLtFpZZCW57iNiF-UbZDM,2970
+pandas/tests/io/pytables/test_round_trip.py,sha256=LTTDrvuzkO5INLmxunr4aHtQLhec_CN0kzB0fHm6Yv0,18753
+pandas/tests/io/pytables/test_select.py,sha256=ogfh1U88Zm1e0huKtgNGG16VBwgprZxaorDU09BF_ZA,37100
+pandas/tests/io/pytables/test_store.py,sha256=fL4f1vm40WPdrJ1YXlMd4hzc-DkyQksRMdKEdGc27Dw,37378
+pandas/tests/io/pytables/test_subclass.py,sha256=fgiunpfa4hECpAXsZrq4nB1a1z5txJxEj9MqyOBI3fQ,1369
+pandas/tests/io/pytables/test_time_series.py,sha256=hduw-GMBvahyZHh6JVrLKrxvU3NR0vl0cWTWamlgZw4,2481
+pandas/tests/io/pytables/test_timezones.py,sha256=3wUurqaoR-UdgndFKyPxmluEzl4euTPBFDcL6nV2IqM,11804
+pandas/tests/io/sas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/io/sas/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/io/sas/__pycache__/test_byteswap.cpython-312.pyc,,
+pandas/tests/io/sas/__pycache__/test_sas.cpython-312.pyc,,
+pandas/tests/io/sas/__pycache__/test_sas7bdat.cpython-312.pyc,,
+pandas/tests/io/sas/__pycache__/test_xport.cpython-312.pyc,,
+pandas/tests/io/sas/test_byteswap.py,sha256=fIqzF9LZs3TLm7JI4tEk4JxkynmWqZ5TydCmc12sGQs,1987
+pandas/tests/io/sas/test_sas.py,sha256=M9OeR39l3-DGJSBr84IVmnYMpMs_3xVfCgSSR8u7m-k,1057
+pandas/tests/io/sas/test_sas7bdat.py,sha256=DynUdplEj6lJUo7R6rmq5CAS1i3Jdp24AMhGBcDtaqc,14807
+pandas/tests/io/sas/test_xport.py,sha256=-gNRR9_2QZS2dQ7Zu756Omg5Bpaz-2I5nCovqEqJVwU,5728
+pandas/tests/io/test_clipboard.py,sha256=ePzhUM4NAeDeLs5HtICUJsGjJiuq1C5GZjN6fkmRND4,13302
+pandas/tests/io/test_common.py,sha256=ZCxsN-pvRYpdcw0-Dcy5wLL0MFM3fesBwQvhXcXCjnM,23778
+pandas/tests/io/test_compression.py,sha256=OGRUhXoSSY1uAUP2VUb45eRleOCuHTct3wRXVSdvpR8,12343
+pandas/tests/io/test_feather.py,sha256=uQRnNCEaENrmSWimfpgO88LAMS0p1bKy4Q4v0LrOBfY,9222
+pandas/tests/io/test_fsspec.py,sha256=fbJmi7UQIG-RDb0dw8zil2dj43OzyG0tyNww5Fiw6a4,10418
+pandas/tests/io/test_gbq.py,sha256=9tA62qL0uGbSKMZdxMwNjANpxaNB4buEdKfqAQej0HQ,401
+pandas/tests/io/test_gcs.py,sha256=gBXSRHyfJnkdVD5bI64KzG-NSv0dWDpKAOY3_rm82nM,7362
+pandas/tests/io/test_html.py,sha256=mY8-tmi5bqBngXwhfTNS2x_1fwncLP3io0TwHwT-n5k,56862
+pandas/tests/io/test_http_headers.py,sha256=_p5LsnX0QXVk7RGMU7TG-NqBWpPGVA-W79eeugdpXoU,4753
+pandas/tests/io/test_orc.py,sha256=rYZCqSiNAPDQIK-2RczRh--E96NkLGV82tp42XR5n-A,13663
+pandas/tests/io/test_parquet.py,sha256=nvzpnsoTzULj1m0pzR53xRKdrIkl_gqNkt_7FqSfHRg,50215
+pandas/tests/io/test_pickle.py,sha256=eY7TI1oVlRXu9fAIJpiE0ig7H6bRC-L2YEOJNqIjh14,20755
+pandas/tests/io/test_s3.py,sha256=vLi6EkvAGMKudRcbxcosxHV7z_q6GbknZuYdEisHjy4,1181
+pandas/tests/io/test_spss.py,sha256=qp310khtYqh_uMjB_Y28MAJVuBUJEbSXwBtPCt2VoWg,6326
+pandas/tests/io/test_sql.py,sha256=wpkLb5iYSdRZCWnoYCHX2eFPB5Dayau2c3RH23kJDX4,145081
+pandas/tests/io/test_stata.py,sha256=ZMqmUmrVz1Jh5PF6-HSqHQth1T7z6tZiFYoFE4jrHJU,92292
+pandas/tests/io/xml/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/io/xml/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/io/xml/__pycache__/conftest.cpython-312.pyc,,
+pandas/tests/io/xml/__pycache__/test_to_xml.cpython-312.pyc,,
+pandas/tests/io/xml/__pycache__/test_xml.cpython-312.pyc,,
+pandas/tests/io/xml/__pycache__/test_xml_dtypes.cpython-312.pyc,,
+pandas/tests/io/xml/conftest.py,sha256=ex3IgyE-7MBC_y5T2gJphlfUex7nqRG5VfX62mTbe5E,850
+pandas/tests/io/xml/test_to_xml.py,sha256=IxG7rT8KV0BghiUMvVMyd5GkbDR9xqWSmSDqT3CUAKM,35612
+pandas/tests/io/xml/test_xml.py,sha256=vuVe3eJJ1_fBoJNgDoLdTYCiqXhMmSH5qHGsd3T7I2A,61257
+pandas/tests/io/xml/test_xml_dtypes.py,sha256=z8unMuhwvcrDUQ-7j4PBKBzr55QXNprA7qALGW7vYw0,13266
+pandas/tests/libs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/libs/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/libs/__pycache__/test_hashtable.cpython-312.pyc,,
+pandas/tests/libs/__pycache__/test_join.cpython-312.pyc,,
+pandas/tests/libs/__pycache__/test_lib.cpython-312.pyc,,
+pandas/tests/libs/__pycache__/test_libalgos.cpython-312.pyc,,
+pandas/tests/libs/test_hashtable.py,sha256=4rXFphd6C9bf5AVIqOohTwsJ7mA14SZmq3hcWtC7m-w,26091
+pandas/tests/libs/test_join.py,sha256=z5JeLRMmF_vu4wwOpi3cG6k-p6lkhjAKPad6ShMqS30,10811
+pandas/tests/libs/test_lib.py,sha256=iiYT79WGEiF-nHJuz7k-AoKwxd9x0BjcGry4j5SCFrc,10592
+pandas/tests/libs/test_libalgos.py,sha256=saDyCbchGU690HmrfZUJ6q1iCLNeW4x50Y-A2o1fgrg,5322
+pandas/tests/plotting/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/plotting/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/plotting/__pycache__/common.cpython-312.pyc,,
+pandas/tests/plotting/__pycache__/conftest.cpython-312.pyc,,
+pandas/tests/plotting/__pycache__/test_backend.cpython-312.pyc,,
+pandas/tests/plotting/__pycache__/test_boxplot_method.cpython-312.pyc,,
+pandas/tests/plotting/__pycache__/test_common.cpython-312.pyc,,
+pandas/tests/plotting/__pycache__/test_converter.cpython-312.pyc,,
+pandas/tests/plotting/__pycache__/test_datetimelike.cpython-312.pyc,,
+pandas/tests/plotting/__pycache__/test_groupby.cpython-312.pyc,,
+pandas/tests/plotting/__pycache__/test_hist_method.cpython-312.pyc,,
+pandas/tests/plotting/__pycache__/test_misc.cpython-312.pyc,,
+pandas/tests/plotting/__pycache__/test_series.cpython-312.pyc,,
+pandas/tests/plotting/__pycache__/test_style.cpython-312.pyc,,
+pandas/tests/plotting/common.py,sha256=6oADaI21vWLSPgHVqckoLiPFWsrGXw71fel7HHxJyZc,16871
+pandas/tests/plotting/conftest.py,sha256=WGxjahxQkw-Gk4DlnLW0rDsei0dmuoCuZusNMepwty0,1531
+pandas/tests/plotting/frame/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/plotting/frame/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/plotting/frame/__pycache__/test_frame.cpython-312.pyc,,
+pandas/tests/plotting/frame/__pycache__/test_frame_color.cpython-312.pyc,,
+pandas/tests/plotting/frame/__pycache__/test_frame_groupby.cpython-312.pyc,,
+pandas/tests/plotting/frame/__pycache__/test_frame_legend.cpython-312.pyc,,
+pandas/tests/plotting/frame/__pycache__/test_frame_subplots.cpython-312.pyc,,
+pandas/tests/plotting/frame/__pycache__/test_hist_box_by.cpython-312.pyc,,
+pandas/tests/plotting/frame/test_frame.py,sha256=q1Yqth7KkCdlm3UBASDvzVfm-fQMT9JPDp1INECJM4A,98409
+pandas/tests/plotting/frame/test_frame_color.py,sha256=gBkX_6DMH-joE-4GjwZpIYgWHJkrWPPDJ8R9gKuHqH8,28488
+pandas/tests/plotting/frame/test_frame_groupby.py,sha256=JNd4J9E4BEtcU5ed47_SZK5p77P6vthENn_shRPbAJQ,2547
+pandas/tests/plotting/frame/test_frame_legend.py,sha256=10NvOjyNdV703r-9mLhYXIxeyZJFq_-24N9XNkNReJw,10443
+pandas/tests/plotting/frame/test_frame_subplots.py,sha256=kRVFvweJSAwzh9gNIzoifuy6_U2d9mZ-K7zXR_K5otw,28986
+pandas/tests/plotting/frame/test_hist_box_by.py,sha256=8jqVQfLrE5AKvn7iKMX7L5Gbe7e4rv6Ic8MnNp7NALI,10969
+pandas/tests/plotting/test_backend.py,sha256=rE7SNyeJiSUOWwkvxndq3qtpUEOYkUetCwdO_ey-eWM,3382
+pandas/tests/plotting/test_boxplot_method.py,sha256=DZ7MuTRTuNzQfzbMpRerX8oMhgLwTokFNK6o_YdP6Ag,29319
+pandas/tests/plotting/test_common.py,sha256=if9WnxryRdUhub-3yjdTEKO2PME-Yhf5YIG8e2nvAXU,1869
+pandas/tests/plotting/test_converter.py,sha256=pC3IZ6pfKITbmzTZBwoPwG1abGtPT6Sp1YLMuKLDKG8,13251
+pandas/tests/plotting/test_datetimelike.py,sha256=Jvsqdvr_SKrdzgRYwoTlNJeS_NWMSTD183sQF-lQMAs,66544
+pandas/tests/plotting/test_groupby.py,sha256=mcM2bOmfvJteLz9H0qMawxN3Yef-Nj2zCa_MUUBWF_c,5735
+pandas/tests/plotting/test_hist_method.py,sha256=2Rkk6DlGz9I4rXDjs6qBrZiRvUNWiBDCIKk44m0mrxw,34972
+pandas/tests/plotting/test_misc.py,sha256=_IoHRNT_OSGTyFfIu5giv5BnaUFWENQH36VKN8q32tI,25201
+pandas/tests/plotting/test_series.py,sha256=73VoBpLMLjKHwIaZKM50rGpOSx1kBsCxlxxNSsPwh8k,35318
+pandas/tests/plotting/test_style.py,sha256=3YMcq45IgmIomuihBowBT-lyJfpJR_Q8fbMOEQXUkao,5172
+pandas/tests/reductions/__init__.py,sha256=vflo8yMcocx2X1Rdw9vt8NpiZ4ZFq9xZRC3PW6Gp-Cs,125
+pandas/tests/reductions/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/reductions/__pycache__/test_reductions.cpython-312.pyc,,
+pandas/tests/reductions/__pycache__/test_stat_reductions.cpython-312.pyc,,
+pandas/tests/reductions/test_reductions.py,sha256=KCjnnzvnla6IysKlbvUO8bXSZ3hxxqfskc9CweDd1iM,57446
+pandas/tests/reductions/test_stat_reductions.py,sha256=Q-sfitViCm3-oQQVHWDwjKKia1ZuUX6079cGmv3i3oU,9722
+pandas/tests/resample/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/resample/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/resample/__pycache__/conftest.cpython-312.pyc,,
+pandas/tests/resample/__pycache__/test_base.cpython-312.pyc,,
+pandas/tests/resample/__pycache__/test_datetime_index.cpython-312.pyc,,
+pandas/tests/resample/__pycache__/test_period_index.cpython-312.pyc,,
+pandas/tests/resample/__pycache__/test_resample_api.cpython-312.pyc,,
+pandas/tests/resample/__pycache__/test_resampler_grouper.cpython-312.pyc,,
+pandas/tests/resample/__pycache__/test_time_grouper.cpython-312.pyc,,
+pandas/tests/resample/__pycache__/test_timedelta.cpython-312.pyc,,
+pandas/tests/resample/conftest.py,sha256=XXj72zj-3AH2jPBUacVV6GSpY9Y4in_38g8cSf8UfYg,3355
+pandas/tests/resample/test_base.py,sha256=vKNx1a1KdSun8OIPEy62VUk390Eew6XyVgHQNbjPRFc,15475
+pandas/tests/resample/test_datetime_index.py,sha256=yQMqPpYkVcrH6MngHltPa9uVDd5n-Hv8jgy-jQVCIvs,74496
+pandas/tests/resample/test_period_index.py,sha256=zlaCtN0II7xAg9-sHDo6HdMNJhrmhCLVbSWe4QPZkR8,43093
+pandas/tests/resample/test_resample_api.py,sha256=QP9mj7ElUdWz7mMIfOJBLxYFsPhWugrzNZNGellLXTM,34082
+pandas/tests/resample/test_resampler_grouper.py,sha256=j2WlubBPgs6CJ8u1nJHhhLOi9LxFkhd6Si2fg2M7yGc,23266
+pandas/tests/resample/test_time_grouper.py,sha256=7VGDIWdewbXeWGH80i_w0s0ffBPke0r-nqmv9_PC52s,11837
+pandas/tests/resample/test_timedelta.py,sha256=H_ZjEJhXN6fhWbpwEwuPsxFDWQermDwUvsM7oaE2pG0,7469
+pandas/tests/reshape/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/reshape/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/reshape/__pycache__/test_crosstab.cpython-312.pyc,,
+pandas/tests/reshape/__pycache__/test_cut.cpython-312.pyc,,
+pandas/tests/reshape/__pycache__/test_from_dummies.cpython-312.pyc,,
+pandas/tests/reshape/__pycache__/test_get_dummies.cpython-312.pyc,,
+pandas/tests/reshape/__pycache__/test_melt.cpython-312.pyc,,
+pandas/tests/reshape/__pycache__/test_pivot.cpython-312.pyc,,
+pandas/tests/reshape/__pycache__/test_pivot_multilevel.cpython-312.pyc,,
+pandas/tests/reshape/__pycache__/test_qcut.cpython-312.pyc,,
+pandas/tests/reshape/__pycache__/test_union_categoricals.cpython-312.pyc,,
+pandas/tests/reshape/__pycache__/test_util.cpython-312.pyc,,
+pandas/tests/reshape/concat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/reshape/concat/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/reshape/concat/__pycache__/conftest.cpython-312.pyc,,
+pandas/tests/reshape/concat/__pycache__/test_append.cpython-312.pyc,,
+pandas/tests/reshape/concat/__pycache__/test_append_common.cpython-312.pyc,,
+pandas/tests/reshape/concat/__pycache__/test_categorical.cpython-312.pyc,,
+pandas/tests/reshape/concat/__pycache__/test_concat.cpython-312.pyc,,
+pandas/tests/reshape/concat/__pycache__/test_dataframe.cpython-312.pyc,,
+pandas/tests/reshape/concat/__pycache__/test_datetimes.cpython-312.pyc,,
+pandas/tests/reshape/concat/__pycache__/test_empty.cpython-312.pyc,,
+pandas/tests/reshape/concat/__pycache__/test_index.cpython-312.pyc,,
+pandas/tests/reshape/concat/__pycache__/test_invalid.cpython-312.pyc,,
+pandas/tests/reshape/concat/__pycache__/test_series.cpython-312.pyc,,
+pandas/tests/reshape/concat/__pycache__/test_sort.cpython-312.pyc,,
+pandas/tests/reshape/concat/conftest.py,sha256=s94n_rOGHsQKdP2KbCAQEfZeQpesYmhH_d-RNNTkvYc,162
+pandas/tests/reshape/concat/test_append.py,sha256=mCBndbLvwmM8qTbwH7HoyZjFGLQWOsOMGjn1I1Mz8PA,14299
+pandas/tests/reshape/concat/test_append_common.py,sha256=Z2hBl4TyKpIJ-staPnWVmAbRMv9Wg0tQK_W8YpcIMXQ,27866
+pandas/tests/reshape/concat/test_categorical.py,sha256=37u7FkYgN0-HZX6z7_5MpAkgv4SCTX1xT4GfSgEfw5o,9531
+pandas/tests/reshape/concat/test_concat.py,sha256=tGbGgnotYE5XJLt0cG9D_FfziSflb9oNzlfqyeZbNL4,32440
+pandas/tests/reshape/concat/test_dataframe.py,sha256=-vObBDtkJ7N_eeIFgjpOVVrMJf_bB9KKknHZg1DbG7k,8864
+pandas/tests/reshape/concat/test_datetimes.py,sha256=dZc65JXlR1l5ulBaQrVzkLv0z8LgwXBlrBFxOxRSBZk,21584
+pandas/tests/reshape/concat/test_empty.py,sha256=wyQDnoujsaY-_dz5MlE-fpXqZyESi1mp0g8BFLQ3kyw,10242
+pandas/tests/reshape/concat/test_index.py,sha256=cauuUpDyWBOAmwmvaSnehWuve5XpFtGoNj2xuEFwdp4,17453
+pandas/tests/reshape/concat/test_invalid.py,sha256=E7InfrzodepcICRP_zFyg11CMs-2SmNrxFY3f8bhqjA,1608
+pandas/tests/reshape/concat/test_series.py,sha256=af0lLNaUEvGml86Ziy-VLJt-wQ-rwQZuQoFROulm9Z8,6061
+pandas/tests/reshape/concat/test_sort.py,sha256=RuXIJduLa56IJDmUQaCwyYOz_U0KXMDWf04WEzi8y7E,4350
+pandas/tests/reshape/merge/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/reshape/merge/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/reshape/merge/__pycache__/test_join.cpython-312.pyc,,
+pandas/tests/reshape/merge/__pycache__/test_merge.cpython-312.pyc,,
+pandas/tests/reshape/merge/__pycache__/test_merge_asof.cpython-312.pyc,,
+pandas/tests/reshape/merge/__pycache__/test_merge_cross.cpython-312.pyc,,
+pandas/tests/reshape/merge/__pycache__/test_merge_index_as_string.cpython-312.pyc,,
+pandas/tests/reshape/merge/__pycache__/test_merge_ordered.cpython-312.pyc,,
+pandas/tests/reshape/merge/__pycache__/test_multi.cpython-312.pyc,,
+pandas/tests/reshape/merge/test_join.py,sha256=uCi2kLp2Liq430VMue_iNsG49vML1J5DtIFKxs_yRyc,37570
+pandas/tests/reshape/merge/test_merge.py,sha256=2R-652Kz2iamzZiT6o-kgsgHEUNg9i_iQmC7p5ZIdSU,106202
+pandas/tests/reshape/merge/test_merge_asof.py,sha256=Gib-41Z735fnPUh0Ipn6V_XyxKhPL3zm1iFFTNywclo,121614
+pandas/tests/reshape/merge/test_merge_cross.py,sha256=9BVH6HWJRh-dHKDTBy8Q2it97gjVW79FgPC99HNLIc4,3146
+pandas/tests/reshape/merge/test_merge_index_as_string.py,sha256=w_9BccpqfB7yPhy_TBlMGx2BPOBwPhfg-pYRKA4HEC8,5357
+pandas/tests/reshape/merge/test_merge_ordered.py,sha256=Y4GLA6hxUoUdo6XhJ5inFBf867JJ8XqiaMi7GY4tsNY,7731
+pandas/tests/reshape/merge/test_multi.py,sha256=kV5tUCNAljJ78IPNrhaeDX9AyKtN2KdF8ZpNMTeDyzY,31130
+pandas/tests/reshape/test_crosstab.py,sha256=fJTqrjVg45YUp8aPCcpgRzrNEoXibZIAz8Tmz2cTM7k,32578
+pandas/tests/reshape/test_cut.py,sha256=vr9TM1AwpJc1c_roHi43ydZ3cMDPBvNv29qqYiypbDk,24554
+pandas/tests/reshape/test_from_dummies.py,sha256=-EzZAKwOfAIdfmAf36a9yJoXb9EDee5s8b3Niz0QXSQ,13272
+pandas/tests/reshape/test_get_dummies.py,sha256=EwXZfFJkidYfSSfV3b22rjxl87oO4IzHlL7_anciR1g,27650
+pandas/tests/reshape/test_melt.py,sha256=myoJF1JEbXammo_jC8SoxfWBSMDUoybuAYyleerElJ0,42211
+pandas/tests/reshape/test_pivot.py,sha256=52TJ3gtJ4K79Q4_kc0GCCAKD3SD0j9niybWoxmI8Z_U,93311
+pandas/tests/reshape/test_pivot_multilevel.py,sha256=DYp3BZ0h80UEgqFs0sNVqnUWBWgYU4622wp62SdCDdI,7549
+pandas/tests/reshape/test_qcut.py,sha256=0XO-B9XmAGiWLhEFW8wujFo-VR1r62SZP7MT-DBz1VE,8477
+pandas/tests/reshape/test_union_categoricals.py,sha256=-5HAPWXufLo52xxRMFedZjSfadNv9GFy4c-OKvN8GBA,15207
+pandas/tests/reshape/test_util.py,sha256=mk60VTWL9YPWNPAmVBHwkOAOtrHIDU6L3EAnlasx6IQ,2897
+pandas/tests/scalar/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/scalar/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/scalar/__pycache__/test_na_scalar.cpython-312.pyc,,
+pandas/tests/scalar/__pycache__/test_nat.cpython-312.pyc,,
+pandas/tests/scalar/interval/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/scalar/interval/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/scalar/interval/__pycache__/test_arithmetic.cpython-312.pyc,,
+pandas/tests/scalar/interval/__pycache__/test_constructors.cpython-312.pyc,,
+pandas/tests/scalar/interval/__pycache__/test_contains.cpython-312.pyc,,
+pandas/tests/scalar/interval/__pycache__/test_formats.cpython-312.pyc,,
+pandas/tests/scalar/interval/__pycache__/test_interval.cpython-312.pyc,,
+pandas/tests/scalar/interval/__pycache__/test_overlaps.cpython-312.pyc,,
+pandas/tests/scalar/interval/test_arithmetic.py,sha256=qrUOEDp9dOkOoEfuuUHhmzKTZuPbj727p2PxO1kgxxM,5937
+pandas/tests/scalar/interval/test_constructors.py,sha256=DI5iRKoIg51lI_-FysKQyyaJnwrd8CqLjk7b7iqFIp0,1599
+pandas/tests/scalar/interval/test_contains.py,sha256=MSjo5U7KLuqugnEtURC8znpldI3-cLIfXQlIhNvQLI4,2354
+pandas/tests/scalar/interval/test_formats.py,sha256=Ep7692gGQMdrYiCxxudqXX-CA6S1sO3L2P2I4NHIreo,344
+pandas/tests/scalar/interval/test_interval.py,sha256=W54SKFbFSlsvFwoXkNhb6JK52klz8is2ww2ZQ7AIjUs,2656
+pandas/tests/scalar/interval/test_overlaps.py,sha256=2FHG23scoclsfZZAngK9sesna_3xgbjgSKoUzlMxHro,2274
+pandas/tests/scalar/period/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/scalar/period/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/scalar/period/__pycache__/test_arithmetic.cpython-312.pyc,,
+pandas/tests/scalar/period/__pycache__/test_asfreq.cpython-312.pyc,,
+pandas/tests/scalar/period/__pycache__/test_period.cpython-312.pyc,,
+pandas/tests/scalar/period/test_arithmetic.py,sha256=YYt1270I1WxtnQqGck_49ECYtrpw__lX8qx8t-GuIZM,16775
+pandas/tests/scalar/period/test_asfreq.py,sha256=dbmg35zwFwPSiYR-5OuSA790slBEct8N6C1jkEXchBs,38445
+pandas/tests/scalar/period/test_period.py,sha256=zjHRVTyPeR7y2SgMn1UsUM1M37EfT1kypoPuqjxsFGI,40121
+pandas/tests/scalar/test_na_scalar.py,sha256=0t4r9nDTQtXUSeXRBxDfgWegznLM6TvMk2pK0gLScJc,7227
+pandas/tests/scalar/test_nat.py,sha256=pUhNNUxLBv4_D-l2tsHICFiT5ruDjvlj24oEkNZycxk,19972
+pandas/tests/scalar/timedelta/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/scalar/timedelta/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/scalar/timedelta/__pycache__/test_arithmetic.cpython-312.pyc,,
+pandas/tests/scalar/timedelta/__pycache__/test_constructors.cpython-312.pyc,,
+pandas/tests/scalar/timedelta/__pycache__/test_formats.cpython-312.pyc,,
+pandas/tests/scalar/timedelta/__pycache__/test_timedelta.cpython-312.pyc,,
+pandas/tests/scalar/timedelta/methods/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/scalar/timedelta/methods/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/scalar/timedelta/methods/__pycache__/test_as_unit.cpython-312.pyc,,
+pandas/tests/scalar/timedelta/methods/__pycache__/test_round.cpython-312.pyc,,
+pandas/tests/scalar/timedelta/methods/test_as_unit.py,sha256=Ut-_d5xcdAq9eD5_dknpSsnhjndzRyilGuT7PxOYl5s,2518
+pandas/tests/scalar/timedelta/methods/test_round.py,sha256=kAqNhW8GJMKvaACF1b6eKhO9DOvYUJuRrMyoxG2-nHM,6338
+pandas/tests/scalar/timedelta/test_arithmetic.py,sha256=mYTdK4okwMitWPPh335LY3wzy5hXncEXPnxLd1XrDXA,38156
+pandas/tests/scalar/timedelta/test_constructors.py,sha256=49f8ARiuEAbImuDasW9-NowtijVRPyoY6ARtX6iuNnM,22433
+pandas/tests/scalar/timedelta/test_formats.py,sha256=_5svunXjM1H4X5tMqgT7aO9CoDR96XgybUYHXNdcyDo,4161
+pandas/tests/scalar/timedelta/test_timedelta.py,sha256=VAEnw5O0egqtlazzAy6oJkgFGHCKDXp3NwRyBEQ19as,23413
+pandas/tests/scalar/timestamp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/scalar/timestamp/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/scalar/timestamp/__pycache__/test_arithmetic.cpython-312.pyc,,
+pandas/tests/scalar/timestamp/__pycache__/test_comparisons.cpython-312.pyc,,
+pandas/tests/scalar/timestamp/__pycache__/test_constructors.cpython-312.pyc,,
+pandas/tests/scalar/timestamp/__pycache__/test_formats.cpython-312.pyc,,
+pandas/tests/scalar/timestamp/__pycache__/test_timestamp.cpython-312.pyc,,
+pandas/tests/scalar/timestamp/__pycache__/test_timezones.cpython-312.pyc,,
+pandas/tests/scalar/timestamp/methods/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/scalar/timestamp/methods/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/scalar/timestamp/methods/__pycache__/test_as_unit.cpython-312.pyc,,
+pandas/tests/scalar/timestamp/methods/__pycache__/test_normalize.cpython-312.pyc,,
+pandas/tests/scalar/timestamp/methods/__pycache__/test_replace.cpython-312.pyc,,
+pandas/tests/scalar/timestamp/methods/__pycache__/test_round.cpython-312.pyc,,
+pandas/tests/scalar/timestamp/methods/__pycache__/test_timestamp_method.cpython-312.pyc,,
+pandas/tests/scalar/timestamp/methods/__pycache__/test_to_julian_date.cpython-312.pyc,,
+pandas/tests/scalar/timestamp/methods/__pycache__/test_to_pydatetime.cpython-312.pyc,,
+pandas/tests/scalar/timestamp/methods/__pycache__/test_tz_convert.cpython-312.pyc,,
+pandas/tests/scalar/timestamp/methods/__pycache__/test_tz_localize.cpython-312.pyc,,
+pandas/tests/scalar/timestamp/methods/test_as_unit.py,sha256=Od0YhrglrVPaad4kzpjPKoVf-pBz0_lTbdaj7cpD7eU,2706
+pandas/tests/scalar/timestamp/methods/test_normalize.py,sha256=NMQXgPRwSB8Z8YtQLrU4qNbxhaq1InqKqwS8veJ_Cts,831
+pandas/tests/scalar/timestamp/methods/test_replace.py,sha256=JT-qoGosdZa0tgjg2AtKrniJnT6-o1YIXQrq-pFDL5E,7055
+pandas/tests/scalar/timestamp/methods/test_round.py,sha256=mA1FyUI8-J14yZ1Vf5Se0OeW2u4nv9-1s0r9eOmOxnE,13027
+pandas/tests/scalar/timestamp/methods/test_timestamp_method.py,sha256=JlFBfEixuZiw96lRZc88wXR9-5uOt74gBCUql321H6w,1017
+pandas/tests/scalar/timestamp/methods/test_to_julian_date.py,sha256=izPqS1f7lJ3Tqkiz65t3NjZqtgxu1_jbSg-LmZheiD4,810
+pandas/tests/scalar/timestamp/methods/test_to_pydatetime.py,sha256=duSR43OjYJiMOHjt7lLVrSdBZa74GQRqwJz5RPdbQ5M,2871
+pandas/tests/scalar/timestamp/methods/test_tz_convert.py,sha256=yw1GiCOn7F8ZDof9d7IvG6T28e6nsB-_XswfO0HN-Dc,1710
+pandas/tests/scalar/timestamp/methods/test_tz_localize.py,sha256=drtq_N4h6E-25vsQuJJO4Sc5dUXyCwIWTHM0ozIc8gI,12774
+pandas/tests/scalar/timestamp/test_arithmetic.py,sha256=4exZrHW0m6i4mCzKVFhehECC232IJYyc3IW1f-YzPbM,10852
+pandas/tests/scalar/timestamp/test_comparisons.py,sha256=zxzSqDtYxP7Fc4vXcIqxYq0Yg7KeKEdAn3iwbgAv-ns,10059
+pandas/tests/scalar/timestamp/test_constructors.py,sha256=qC0ZLNT77BDnBQ1atxBN20AG06mi10ur8-4BP9zEKDg,39486
+pandas/tests/scalar/timestamp/test_formats.py,sha256=TKn4H02mIrLpoWm4YuDsA3gUy87bYVqNLu8SgnckZA0,6864
+pandas/tests/scalar/timestamp/test_timestamp.py,sha256=c0ZhIgkRq9JfpohnixtM-n2frtyF2fR2pnUFjFER8fY,31042
+pandas/tests/scalar/timestamp/test_timezones.py,sha256=dXCPtLiGfQ9B2pg_s_YK7fvWwUW-CbVOPYUn9paFosk,666
+pandas/tests/series/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/series/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/series/__pycache__/test_api.cpython-312.pyc,,
+pandas/tests/series/__pycache__/test_arithmetic.cpython-312.pyc,,
+pandas/tests/series/__pycache__/test_constructors.cpython-312.pyc,,
+pandas/tests/series/__pycache__/test_cumulative.cpython-312.pyc,,
+pandas/tests/series/__pycache__/test_formats.cpython-312.pyc,,
+pandas/tests/series/__pycache__/test_iteration.cpython-312.pyc,,
+pandas/tests/series/__pycache__/test_logical_ops.cpython-312.pyc,,
+pandas/tests/series/__pycache__/test_missing.cpython-312.pyc,,
+pandas/tests/series/__pycache__/test_npfuncs.cpython-312.pyc,,
+pandas/tests/series/__pycache__/test_reductions.cpython-312.pyc,,
+pandas/tests/series/__pycache__/test_subclass.cpython-312.pyc,,
+pandas/tests/series/__pycache__/test_ufunc.cpython-312.pyc,,
+pandas/tests/series/__pycache__/test_unary.cpython-312.pyc,,
+pandas/tests/series/__pycache__/test_validate.cpython-312.pyc,,
+pandas/tests/series/accessors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/series/accessors/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/series/accessors/__pycache__/test_cat_accessor.cpython-312.pyc,,
+pandas/tests/series/accessors/__pycache__/test_dt_accessor.cpython-312.pyc,,
+pandas/tests/series/accessors/__pycache__/test_list_accessor.cpython-312.pyc,,
+pandas/tests/series/accessors/__pycache__/test_sparse_accessor.cpython-312.pyc,,
+pandas/tests/series/accessors/__pycache__/test_str_accessor.cpython-312.pyc,,
+pandas/tests/series/accessors/__pycache__/test_struct_accessor.cpython-312.pyc,,
+pandas/tests/series/accessors/test_cat_accessor.py,sha256=1-ZRI4h_lsBclkXljCrYFwGIYXbhrpE1iET-MjNKngk,9611
+pandas/tests/series/accessors/test_dt_accessor.py,sha256=wL3MFsru8nLxaY2KLmCFfZvdpvtIYHJie44Ff6V7eSE,29886
+pandas/tests/series/accessors/test_list_accessor.py,sha256=7OsgwSCkXFDSRh81g5WKniPsv_zcTosuGicGPSemBqo,3425
+pandas/tests/series/accessors/test_sparse_accessor.py,sha256=yPxK1Re7RDPLi5v2r9etrgsUfSL9NN45CAvuR3tYVwA,296
+pandas/tests/series/accessors/test_str_accessor.py,sha256=M29X62c2ekvH1FTv56yye2TLcXyYUCM5AegAQVWLFc8,853
+pandas/tests/series/accessors/test_struct_accessor.py,sha256=Yg_Z1GjJf92XaXOnT0aUaeEtp7AOcQqWPT4guJKGfEg,5443
+pandas/tests/series/indexing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/series/indexing/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/series/indexing/__pycache__/test_datetime.cpython-312.pyc,,
+pandas/tests/series/indexing/__pycache__/test_delitem.cpython-312.pyc,,
+pandas/tests/series/indexing/__pycache__/test_get.cpython-312.pyc,,
+pandas/tests/series/indexing/__pycache__/test_getitem.cpython-312.pyc,,
+pandas/tests/series/indexing/__pycache__/test_indexing.cpython-312.pyc,,
+pandas/tests/series/indexing/__pycache__/test_mask.cpython-312.pyc,,
+pandas/tests/series/indexing/__pycache__/test_set_value.cpython-312.pyc,,
+pandas/tests/series/indexing/__pycache__/test_setitem.cpython-312.pyc,,
+pandas/tests/series/indexing/__pycache__/test_take.cpython-312.pyc,,
+pandas/tests/series/indexing/__pycache__/test_where.cpython-312.pyc,,
+pandas/tests/series/indexing/__pycache__/test_xs.cpython-312.pyc,,
+pandas/tests/series/indexing/test_datetime.py,sha256=1_yUGMkSFYGh7TJOeDN_-5FvqsVyV-rGdgBzOnyqqNk,14752
+pandas/tests/series/indexing/test_delitem.py,sha256=bqam_JdFo9bWPIIglt0Rvms-KJxG1wZ5znTtrAn5eaI,2063
+pandas/tests/series/indexing/test_get.py,sha256=-FooS4ocg7uqbXYDNEZwMvRpTCar5LJCgCqi_CpDoo0,5758
+pandas/tests/series/indexing/test_getitem.py,sha256=TLizXWrxrsUj5KtXGVB2kIxHK3ayq5IsjnjTDqFiPzY,24431
+pandas/tests/series/indexing/test_indexing.py,sha256=UJrjrjD_5-nqaPVcjSz90dQQRdtXeCD5QzZDTCVGjTw,16679
+pandas/tests/series/indexing/test_mask.py,sha256=ecPdJ-CM8HbaaZoGUfwcoOuo0eIz7aEq-x8wL0PZWbE,1711
+pandas/tests/series/indexing/test_set_value.py,sha256=UwVNpW3Fh3PKhNiFzZiVK07W871CmFM2fGtC6CTW5z0,991
+pandas/tests/series/indexing/test_setitem.py,sha256=DdaSjqIX0sTc-zXFv3dbuq0KRcq4qcxJcZEblgdtIyg,60265
+pandas/tests/series/indexing/test_take.py,sha256=574cgL0w0fj-YnZma9b188Y0mTWs-Go6ZzB9zQSdpAk,1353
+pandas/tests/series/indexing/test_where.py,sha256=eAUIGPRMumG78t6CMCtoe50hJCKLUFCWSe8mjHyA5Bo,13441
+pandas/tests/series/indexing/test_xs.py,sha256=8EKGIgnK86_hsBjPIY5lednYnzatv14O6rq3LjR_KxI,2760
+pandas/tests/series/methods/__init__.py,sha256=zVXqGxDIQ-ebxxcetI9KcJ9ZEHeIC4086CoDvyc8CNM,225
+pandas/tests/series/methods/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_add_prefix_suffix.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_align.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_argsort.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_asof.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_astype.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_autocorr.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_between.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_case_when.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_clip.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_combine.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_combine_first.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_compare.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_convert_dtypes.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_copy.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_count.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_cov_corr.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_describe.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_diff.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_drop.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_drop_duplicates.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_dropna.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_dtypes.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_duplicated.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_equals.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_explode.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_fillna.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_get_numeric_data.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_head_tail.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_infer_objects.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_info.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_interpolate.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_is_monotonic.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_is_unique.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_isin.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_isna.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_item.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_map.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_matmul.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_nlargest.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_nunique.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_pct_change.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_pop.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_quantile.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_rank.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_reindex.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_reindex_like.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_rename.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_rename_axis.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_repeat.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_replace.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_reset_index.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_round.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_searchsorted.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_set_name.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_size.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_sort_index.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_sort_values.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_to_csv.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_to_dict.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_to_frame.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_to_numpy.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_tolist.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_truncate.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_tz_localize.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_unique.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_unstack.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_update.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_value_counts.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_values.cpython-312.pyc,,
+pandas/tests/series/methods/__pycache__/test_view.cpython-312.pyc,,
+pandas/tests/series/methods/test_add_prefix_suffix.py,sha256=PeUIeDHa9rGggraEbVJRtLi2GcnNcXkrXb0otlthOC4,1556
+pandas/tests/series/methods/test_align.py,sha256=1qb66VDMKpMXYpivki_WWGR_aHtEishwVQlK1ZIJqHA,7700
+pandas/tests/series/methods/test_argsort.py,sha256=GSvtMvfeUktQkrOsl-bF4di5w8QPCo9GPza1OmeofeM,2871
+pandas/tests/series/methods/test_asof.py,sha256=CqRdyeXFhE7zVdkJB-TxVqK3XPyBNvtOAfb6_a0VGgM,6324
+pandas/tests/series/methods/test_astype.py,sha256=fPZRB30wa7fFvcY66odgPfA7f2_loj-nWthKLGkOHew,25472
+pandas/tests/series/methods/test_autocorr.py,sha256=SnxELB9bcE8H68tYUDN3UKMMPu-sEfbwTlLUn8WirV8,1015
+pandas/tests/series/methods/test_between.py,sha256=9w_8uWI5kcJOTfMwbEwmjGpU2j2cyuMtCYw4MrvgSM0,2584
+pandas/tests/series/methods/test_case_when.py,sha256=0YC-SaigIaoSO2l7h9sO4ebzCrxq0ma5FtiZKiwDMRs,4223
+pandas/tests/series/methods/test_clip.py,sha256=PuUarzkVXrwdYBF6pKqKbRw_GUuXdYsSPoNomgSDyzc,5220
+pandas/tests/series/methods/test_combine.py,sha256=ye8pwpjolpG_kUKSFTC8ZoRdj3ze8qtJXvDUZ5gpap4,627
+pandas/tests/series/methods/test_combine_first.py,sha256=84sHCHBNQIhQEtTRWNZQqAuq_3LuHiVbq7Xmp5pRjZo,5420
+pandas/tests/series/methods/test_compare.py,sha256=uRA4CKyOTPSzW3sihILLvxpxdSD1hb7mHrSydGFV2J4,4658
+pandas/tests/series/methods/test_convert_dtypes.py,sha256=OsSLvgRzG1MKutYTZXPqkHwiNy6-QzXqN-KtohZ7wYs,9724
+pandas/tests/series/methods/test_copy.py,sha256=im14SuY4pXfqYHvd4UamQSSTiXsK8GOP7Ga-5w-XRFs,3164
+pandas/tests/series/methods/test_count.py,sha256=mju3vjyHXg8qRH85cRLWvRL8lFnF7HGdETjt2e_pK7M,938
+pandas/tests/series/methods/test_cov_corr.py,sha256=NfmwlBV_Umm50xTwfuhJhKtNPmrUVEaJOt9GWTsb3DQ,5709
+pandas/tests/series/methods/test_describe.py,sha256=brDSZ2qicnLANI2ReYiYQiXzu6m9VxFr4DVULEyGgSA,6646
+pandas/tests/series/methods/test_diff.py,sha256=vEBvVglFS1cSDpllOLEZ9Dkdv1E02IYP9y6s6nsL6es,2538
+pandas/tests/series/methods/test_drop.py,sha256=nqTXYfvY76BZ2cl46kUb8mkkll5StdCzBaTn_YkGfIk,3394
+pandas/tests/series/methods/test_drop_duplicates.py,sha256=P6jHz77EAtuiI2IE25pNjBx3pXteUc0JUMoj2mWo8T4,9235
+pandas/tests/series/methods/test_dropna.py,sha256=fezc4siTNn-uOEQtOhaqNAOLYBoWN3Rh6STHAtOdk8U,3577
+pandas/tests/series/methods/test_dtypes.py,sha256=IkYkFl0o2LQ5qurobwoPgp4jqi2uKU7phoAk3oZtiYo,209
+pandas/tests/series/methods/test_duplicated.py,sha256=ACzVs9IJY4lC2SQb6frHVe4dGd6YLFID5UAw4BuZa7c,2059
+pandas/tests/series/methods/test_equals.py,sha256=qo8h305o5ktv9ooQ7pMbMUnQFjzOGLWc5TwxL9wD5zg,4182
+pandas/tests/series/methods/test_explode.py,sha256=Pw0yPOLX6iHzLDld7Bo1tC2CjnMYGIo9cEQs1Q6wmDg,5110
+pandas/tests/series/methods/test_fillna.py,sha256=tjuKAfrmByzwY1H_xez3xSwKkZUDac1aSt47ZHP7llI,39985
+pandas/tests/series/methods/test_get_numeric_data.py,sha256=UPWNlzpl2a9Zez1JSfFP2EwsYfs4U4_Re4yOkqGpsl8,1178
+pandas/tests/series/methods/test_head_tail.py,sha256=1EWojjTzcLvYH34VvyvEHxczDy7zL3dMTyayFHsVSzY,343
+pandas/tests/series/methods/test_infer_objects.py,sha256=w0UyAVk4bHlCBX8Ot8BiV6Y0flw-70XiENsh0jsgyhg,1903
+pandas/tests/series/methods/test_info.py,sha256=hff1IZ3mbfwsJzNvLcFyFlnk3aubm3gcxMhROr-F-aI,4907
+pandas/tests/series/methods/test_interpolate.py,sha256=Y0pZXAceQWfdEylQi0Q78g3LLSvwv9qTr0ur9z-SED8,34267
+pandas/tests/series/methods/test_is_monotonic.py,sha256=vvyWZFxiSybq88peF0zN5dM16rH2SgCEEA-gT2rRSSY,838
+pandas/tests/series/methods/test_is_unique.py,sha256=d3aLS5q491IVZkfKx8HTc4jkgTtuN0SOaUVfkyBTImE,953
+pandas/tests/series/methods/test_isin.py,sha256=iOwKDqYVh8mFnkwcdc9oRiJVlxfDF87AwL2i7kBugqQ,8343
+pandas/tests/series/methods/test_isna.py,sha256=TzNID2_dMG6ChWSwOMIqlF9AWcc1UjtjCHLNmT0vlBE,940
+pandas/tests/series/methods/test_item.py,sha256=z9gMBXHmc-Xhpyad9O0fT2RySMhlTa6MSrz2jPSUHxc,1627
+pandas/tests/series/methods/test_map.py,sha256=nVhgNZdZvBhJfLXOckrslAK5AINuZlwtfqpkeEZSuBc,18772
+pandas/tests/series/methods/test_matmul.py,sha256=cIj2nJctMnOvEDgTefpB3jypWJ6-RHasqtxywrxXw0g,2767
+pandas/tests/series/methods/test_nlargest.py,sha256=oIkyZ6Z2NiUL09sSTvAFK7IlcfQDiVgwssFe6NtsyIE,8442
+pandas/tests/series/methods/test_nunique.py,sha256=6B7fs9niuN2QYyxjVNX33WLBJvF2SJZRCn6SInTIz0g,481
+pandas/tests/series/methods/test_pct_change.py,sha256=C_WTtvjTsvfT94CUt22jYodJCHd18nUrkCLorQPf_d8,4523
+pandas/tests/series/methods/test_pop.py,sha256=xr9ZuFCI7O2gTW8a3WBr-ooQcOhBzoUK4N1x0K5G380,295
+pandas/tests/series/methods/test_quantile.py,sha256=DrjNLdKWpR-Sy8htHn2roHNI4roGKtR-ziZ77mPBVo8,8284
+pandas/tests/series/methods/test_rank.py,sha256=PokA09Wyiil9JGQ5CBNqEtRP_uvZlwTWPd-8TsGsrfw,18104
+pandas/tests/series/methods/test_reindex.py,sha256=-AIJ2FzgeE2-1z_WPfkFcktucr78afWJWx_TTU-J-jM,14576
+pandas/tests/series/methods/test_reindex_like.py,sha256=e_nuGo4QLgsdpnZrC49xDVfcz_prTGAOXGyjEEbkKM4,1245
+pandas/tests/series/methods/test_rename.py,sha256=XzMLQMJZ4bYYOnmck8NidsW5DSfw2YlbvQmZidXVoWk,6321
+pandas/tests/series/methods/test_rename_axis.py,sha256=TqGeZdhB3Ektvj48JfbX2Jr_qsCovtoWimpfX_ViJyg,1520
+pandas/tests/series/methods/test_repeat.py,sha256=WvER_QkoVNYU4bg5hQbLdCXIWxqVnSmJ6K3_3OLLLAI,1274
+pandas/tests/series/methods/test_replace.py,sha256=xyO2g1XBJhY9ApbZK4YPhj-3FwlH7vBwRzdJ8o1vEH8,31936
+pandas/tests/series/methods/test_reset_index.py,sha256=D7fTW37psSXR22ZQHrxID1NWgeFkCZU83QLBo1Cb7xI,7848
+pandas/tests/series/methods/test_round.py,sha256=eQ6kSu0XLBX9NSA1A8V4eXEHIgqoxKbSJ79dDGcYxi8,2651
+pandas/tests/series/methods/test_searchsorted.py,sha256=2nk-hXPbFjgZfKm4bO_TiKm2xjd4hj0L9hiqR4nZ2Ss,2493
+pandas/tests/series/methods/test_set_name.py,sha256=rt1BK8BnWMd8D8vrO7yQNN4o-Fnapq5bRmlHyrYpxk4,595
+pandas/tests/series/methods/test_size.py,sha256=3-LfpWtTLM_dPAHFG_mmCxAk3dJY9WIe13czw1d9Fn4,566
+pandas/tests/series/methods/test_sort_index.py,sha256=XIiu2aL5NayZoQDsBRdBbx6po5_pW4pq4us2utrSY2c,12634
+pandas/tests/series/methods/test_sort_values.py,sha256=jIvHYYMz-RySUtJnB9aFLR88s-M20-B5E5PwK9VQhns,9372
+pandas/tests/series/methods/test_to_csv.py,sha256=baTGH5GpQJOz4rpQmRMgClwBXxwVcTpEmM870qCZ2zs,6488
+pandas/tests/series/methods/test_to_dict.py,sha256=XGdcF1jD4R0a_vWAQXwal3IVJoNwEANa1tU7qHtpIGA,1178
+pandas/tests/series/methods/test_to_frame.py,sha256=nUkHQTpMTffkpDR7w3EcQvQAevEfflD6tHm3pTBxpTI,1992
+pandas/tests/series/methods/test_to_numpy.py,sha256=pEB2B08IdIPRYp5n7USYFX9HQbClJl4xOegjVd7mYLc,1321
+pandas/tests/series/methods/test_tolist.py,sha256=5F0VAYJTPDUTlqb5zDNEec-BeBY25ZjnjqYHFQq5GPU,1115
+pandas/tests/series/methods/test_truncate.py,sha256=suMKI1jMEVVSd_b5rlLM2iqsQ08c8a9CbN8mbNKdNEU,2307
+pandas/tests/series/methods/test_tz_localize.py,sha256=chP4Dnhzfg5zphKiHwZpN-43o_p6jf0wqgid3a-ZB-Y,4336
+pandas/tests/series/methods/test_unique.py,sha256=MQB5s4KVopor1V1CgvF6lZNUSX6ZcOS2_H5JRYf7emU,2219
+pandas/tests/series/methods/test_unstack.py,sha256=ahI7kSZhf9rX-TLfy7ymFLqM4m4t2niaD7p-9TV02XE,5116
+pandas/tests/series/methods/test_update.py,sha256=deGclG13lOOd_xEkKYEfFUDge0Iiudp9MJwuv7Yis-M,5339
+pandas/tests/series/methods/test_value_counts.py,sha256=LNmYx4OpzjjbLsjYHOrd4vxJZjKm9pEntq63I3mWttc,10109
+pandas/tests/series/methods/test_values.py,sha256=Q2jACWauws0GxIc_QzxbAOgMrJR6Qs7oyx_6LK7zVt8,747
+pandas/tests/series/methods/test_view.py,sha256=JipUTX6cC-NU4nVaDsyklmpRvfvf_HvUQE_fgYFqxPU,1851
+pandas/tests/series/test_api.py,sha256=_BaBWtliETwBqhysCrXr7x_1bc3r3SIAcIFOcjZ3F_A,10339
+pandas/tests/series/test_arithmetic.py,sha256=ifsEkN9NlowAT5PU5Foi0x68t1NkHkmVdMBQjtvsFl8,33812
+pandas/tests/series/test_constructors.py,sha256=ThOK2BIx6XPEhDiDFaB5qGJdPrurlrPzod80zN67PwQ,85250
+pandas/tests/series/test_cumulative.py,sha256=lYFRlmwTQBWBP-svJnt6e55b_wnCdDVZVhuvP0ezcR8,5034
+pandas/tests/series/test_formats.py,sha256=0zdlyYIuExdMVngGrYOatSq7M5ersVQe5rPZfG48KVs,17122
+pandas/tests/series/test_iteration.py,sha256=LKCUh0-OueVvxOr7uEG8U9cQxrAk7X-WDwfgEIKUekI,1408
+pandas/tests/series/test_logical_ops.py,sha256=4gXWtkqxNRA2ge7QjsomTkXVPnhd4u1t-50rH7L10KY,20199
+pandas/tests/series/test_missing.py,sha256=6TtIBFZgw-vrOYqRzSxhYCIBngoVX8r8-sT5jFgkWKM,3277
+pandas/tests/series/test_npfuncs.py,sha256=BxhxkI2uWC-ygB3DJK_-FX2TOxcuqDUHX4tRQqD9CfU,1093
+pandas/tests/series/test_reductions.py,sha256=hgPH62fS-Ha6Czk8WhKwJ8yy2KoSmG2Jx_ebpDysDxs,6519
+pandas/tests/series/test_subclass.py,sha256=aL5tgGGXZPPIXWIgpCPBrc7Q5KS8h1ipZNKCwciw-jY,2667
+pandas/tests/series/test_ufunc.py,sha256=uo0FJLsk2WFgOIMfKBlsuySEKzwkGYtcTPCRPmJt2qY,14758
+pandas/tests/series/test_unary.py,sha256=Xktw6w940LXm38OKLW-LRqpMZSA9EB5feCt9FMLh-E4,1620
+pandas/tests/series/test_validate.py,sha256=ziCmKi_jYuGyxcnsVaJpVgwSCjBgpHDJ0dbzWLa1-kA,668
+pandas/tests/strings/__init__.py,sha256=_uWelCEA7j9QwfQkgZomjbpFbuB_FlQO1sdMXak8Zn4,367
+pandas/tests/strings/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/strings/__pycache__/conftest.cpython-312.pyc,,
+pandas/tests/strings/__pycache__/test_api.cpython-312.pyc,,
+pandas/tests/strings/__pycache__/test_case_justify.cpython-312.pyc,,
+pandas/tests/strings/__pycache__/test_cat.cpython-312.pyc,,
+pandas/tests/strings/__pycache__/test_extract.cpython-312.pyc,,
+pandas/tests/strings/__pycache__/test_find_replace.cpython-312.pyc,,
+pandas/tests/strings/__pycache__/test_get_dummies.cpython-312.pyc,,
+pandas/tests/strings/__pycache__/test_split_partition.cpython-312.pyc,,
+pandas/tests/strings/__pycache__/test_string_array.cpython-312.pyc,,
+pandas/tests/strings/__pycache__/test_strings.cpython-312.pyc,,
+pandas/tests/strings/conftest.py,sha256=M-9nIdAAynMJ7FvFFTHXJEUZFT8uOTbizf5ZOnOJ-Tk,3960
+pandas/tests/strings/test_api.py,sha256=eW1Z06Ghgx6bRdL7Kmd-YOi9TGHJ7zAUOTFp8I8hOEM,6353
+pandas/tests/strings/test_case_justify.py,sha256=b7vTpbbvc3MSR5F-Bhge2NqUVGPkOlauOuaHwr09W28,13545
+pandas/tests/strings/test_cat.py,sha256=zCJBBRtmaOxMGwXeS4evfDtAVccO3EmloEUn-dMi0ho,13575
+pandas/tests/strings/test_extract.py,sha256=LuGkboI2Q6d60kQgwMDudy-5eEbixaaCGP78CwHli6c,26463
+pandas/tests/strings/test_find_replace.py,sha256=u_XxsoYO6onAYZWc52ATYjEp9RpRoAoInMvxshaPVTE,35016
+pandas/tests/strings/test_get_dummies.py,sha256=LyWHwMrb5pgX69t4b9ouHflXKp4gBXadTCkaZSk_HB4,1608
+pandas/tests/strings/test_split_partition.py,sha256=vi8PvUAnLQgWsWehN0VpR7zfIOShPce0svmGhRNht5U,23234
+pandas/tests/strings/test_string_array.py,sha256=I2Y1NMM_iOn9K6068sRNP_mcXHJYpxqIsDmhk1B2avQ,3558
+pandas/tests/strings/test_strings.py,sha256=rwLDRm3JWax5Nsbnl0v65e7RYSgK70lLWmDULUVrvx4,25502
+pandas/tests/test_aggregation.py,sha256=-9GlIUg7qPr3Ppj_TNbBF85oKjSIMAv056hfcYZvhWw,2779
+pandas/tests/test_algos.py,sha256=-OriW5Hjib-BwwHpO19liYsC-SpkYIhjnMJ3tHfz1Zs,77987
+pandas/tests/test_common.py,sha256=SHkM8XyjSNxUJquSiEDa3lqE0GJ7tLsfwdro0x2leAg,7695
+pandas/tests/test_downstream.py,sha256=--pbHUtoMwjpQB0_gsyOQpHkKAzKrZwOZlrHt-RsZW8,10501
+pandas/tests/test_errors.py,sha256=4WVxQSyv6okTRVQC9LC9thX5ZjXVMrX-3l93bEd9KZ8,2789
+pandas/tests/test_expressions.py,sha256=fyTafylKNf7Wb3qzwlvIGbM4MdlJB7V4yGJrgiMRE5w,14256
+pandas/tests/test_flags.py,sha256=Dsu6pvQ5A6Manyt1VlQLK8pRpZtr-S2T3ubJvRQaRlA,1550
+pandas/tests/test_multilevel.py,sha256=3-Gmz-7nEzWFDYT5k_nzRL17xLCj2ZF3q69dzHO5sL8,12206
+pandas/tests/test_nanops.py,sha256=NWzcF6_g_IT0HQRG9ETV3kimAAKVmoFohuGymqsDLPI,42042
+pandas/tests/test_optional_dependency.py,sha256=wnDdNm9tlr2MFSOwB9EWAPUf1_H3L0GUTbGeZyGUqL8,3159
+pandas/tests/test_register_accessor.py,sha256=L2cU-H7UU1M36_7DU7p69SvGEFWZXpMpUJ8NZS2yOTI,2671
+pandas/tests/test_sorting.py,sha256=0rqJWWFq1kVX8m-W0X7dXdl9XoaYxZKuGHtBiJIn3nQ,16595
+pandas/tests/test_take.py,sha256=YSMLvpggEaY_MOT3PkVtQYUw0MfwN4bVvI3EgmOgxfA,11539
+pandas/tests/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/tools/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/tools/__pycache__/test_to_datetime.cpython-312.pyc,,
+pandas/tests/tools/__pycache__/test_to_numeric.cpython-312.pyc,,
+pandas/tests/tools/__pycache__/test_to_time.cpython-312.pyc,,
+pandas/tests/tools/__pycache__/test_to_timedelta.cpython-312.pyc,,
+pandas/tests/tools/test_to_datetime.py,sha256=9-TkN1fCZiz4hBMUOvCo7YI7bQgHjXib2Nh2H51DmqA,147160
+pandas/tests/tools/test_to_numeric.py,sha256=R9fTxZIebRQp-yNh2oDsHYF8xgszrVLNqlVDYGwnajM,29480
+pandas/tests/tools/test_to_time.py,sha256=e-QmGu5nAe9clT8n9bda5aEwHBH4ZaXqBzs5-mKWMYQ,2417
+pandas/tests/tools/test_to_timedelta.py,sha256=sA-q01yavNfamRKB0JZ08ou3PN-G38PZ1Tuk5KOL8iI,12454
+pandas/tests/tseries/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/tseries/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/tseries/frequencies/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/tseries/frequencies/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/tseries/frequencies/__pycache__/test_freq_code.cpython-312.pyc,,
+pandas/tests/tseries/frequencies/__pycache__/test_frequencies.cpython-312.pyc,,
+pandas/tests/tseries/frequencies/__pycache__/test_inference.cpython-312.pyc,,
+pandas/tests/tseries/frequencies/test_freq_code.py,sha256=hvQl37z3W6CwcLOAqrgc2acqtjOJIbqVbnXkEUBY4cM,1727
+pandas/tests/tseries/frequencies/test_frequencies.py,sha256=tyI9e6ve7sEXdALy9GYjMV3mAQHmQF2IqW-xFzPdgjY,821
+pandas/tests/tseries/frequencies/test_inference.py,sha256=o8bZEapedbcC1zoj_slbggdZkzxX9Z1oh6VuCly8PU4,15111
+pandas/tests/tseries/holiday/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/tseries/holiday/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/tseries/holiday/__pycache__/test_calendar.cpython-312.pyc,,
+pandas/tests/tseries/holiday/__pycache__/test_federal.cpython-312.pyc,,
+pandas/tests/tseries/holiday/__pycache__/test_holiday.cpython-312.pyc,,
+pandas/tests/tseries/holiday/__pycache__/test_observance.cpython-312.pyc,,
+pandas/tests/tseries/holiday/test_calendar.py,sha256=SdMzzgTizQ88wJBRVTmVIgxE8E20_sgLFunP3WHlkZU,3622
+pandas/tests/tseries/holiday/test_federal.py,sha256=ukOOSRoUdcfUOlAT10AWVj8uxiD-88_H8xd--WpOsG0,1948
+pandas/tests/tseries/holiday/test_holiday.py,sha256=0NsEkl5wr2ckwvGiXnrYhluZZRpCc_Ede6SqdrFGc7I,11173
+pandas/tests/tseries/holiday/test_observance.py,sha256=GJBqIF4W6QG4k3Yzz6_13WMOR4nHSVzPbixHxO8Tukw,2723
+pandas/tests/tseries/offsets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/tseries/offsets/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/tseries/offsets/__pycache__/common.cpython-312.pyc,,
+pandas/tests/tseries/offsets/__pycache__/test_business_day.cpython-312.pyc,,
+pandas/tests/tseries/offsets/__pycache__/test_business_hour.cpython-312.pyc,,
+pandas/tests/tseries/offsets/__pycache__/test_business_month.cpython-312.pyc,,
+pandas/tests/tseries/offsets/__pycache__/test_business_quarter.cpython-312.pyc,,
+pandas/tests/tseries/offsets/__pycache__/test_business_year.cpython-312.pyc,,
+pandas/tests/tseries/offsets/__pycache__/test_common.cpython-312.pyc,,
+pandas/tests/tseries/offsets/__pycache__/test_custom_business_day.cpython-312.pyc,,
+pandas/tests/tseries/offsets/__pycache__/test_custom_business_hour.cpython-312.pyc,,
+pandas/tests/tseries/offsets/__pycache__/test_custom_business_month.cpython-312.pyc,,
+pandas/tests/tseries/offsets/__pycache__/test_dst.cpython-312.pyc,,
+pandas/tests/tseries/offsets/__pycache__/test_easter.cpython-312.pyc,,
+pandas/tests/tseries/offsets/__pycache__/test_fiscal.cpython-312.pyc,,
+pandas/tests/tseries/offsets/__pycache__/test_index.cpython-312.pyc,,
+pandas/tests/tseries/offsets/__pycache__/test_month.cpython-312.pyc,,
+pandas/tests/tseries/offsets/__pycache__/test_offsets.cpython-312.pyc,,
+pandas/tests/tseries/offsets/__pycache__/test_offsets_properties.cpython-312.pyc,,
+pandas/tests/tseries/offsets/__pycache__/test_quarter.cpython-312.pyc,,
+pandas/tests/tseries/offsets/__pycache__/test_ticks.cpython-312.pyc,,
+pandas/tests/tseries/offsets/__pycache__/test_week.cpython-312.pyc,,
+pandas/tests/tseries/offsets/__pycache__/test_year.cpython-312.pyc,,
+pandas/tests/tseries/offsets/common.py,sha256=D3D8mcwwzW2kSEB8uX8gO6ARX4dB4PEu3_953APlRmk,900
+pandas/tests/tseries/offsets/test_business_day.py,sha256=dqOwIoAq3Mcxrc0EEeqJnnDvJYCFz5lA0JewVuODhBc,6808
+pandas/tests/tseries/offsets/test_business_hour.py,sha256=PV5Ddc4vEsQXrXhCKyDIcKptcNhXgIe-KiY14zsbVE0,58452
+pandas/tests/tseries/offsets/test_business_month.py,sha256=ZQlcBF15WTMq5w8uC7QeQ6QYVWN8hmfu1PtJvW-ebYU,6717
+pandas/tests/tseries/offsets/test_business_quarter.py,sha256=Tvp5J5r5uDBh8Y9yW65JItTp-B5fdJ4T9G0fxelHYaw,12591
+pandas/tests/tseries/offsets/test_business_year.py,sha256=OBs55t5gGKSPhTsnGafi5Uqsrjmq1cKpfuwWLUBR8Uo,6436
+pandas/tests/tseries/offsets/test_common.py,sha256=HpiuRR_ktnWLWSoFtMe87AVUCedpRcqxoTeVrfCg7is,7406
+pandas/tests/tseries/offsets/test_custom_business_day.py,sha256=YNN53-HvTW4JrbLYwyUiM10rQqIof1iA_W1uYkiHw7w,3180
+pandas/tests/tseries/offsets/test_custom_business_hour.py,sha256=UXa57Q-ZYPDMv307t7UKQGOIE32CH_FmCNY3hX8dcN4,12312
+pandas/tests/tseries/offsets/test_custom_business_month.py,sha256=WBgCVPO6PUa4oX0bDSDk_UE5hOeYbIo2sduIM9X3ASI,13362
+pandas/tests/tseries/offsets/test_dst.py,sha256=0s6bpzEFkVfUKN6lAkeFTiyzMwYRQwrZs49WAu-LK4o,9139
+pandas/tests/tseries/offsets/test_easter.py,sha256=oZlJ3lESuLTEv6A_chVDsD3Pa_cqgbVc4_zxrEE7cvc,1150
+pandas/tests/tseries/offsets/test_fiscal.py,sha256=p_rXA9wPnKZwDp40kaB8uGjq2fpHPCRU5PFF-1rClbA,26732
+pandas/tests/tseries/offsets/test_index.py,sha256=aeW6vyuME-22oikOhiE6q6nrLkIc22TjV3wPxpWXjIk,1147
+pandas/tests/tseries/offsets/test_month.py,sha256=EHsmRpEhG_CLSNEUOtA48auiJxFnr8sPsHQTyZeuu2g,23243
+pandas/tests/tseries/offsets/test_offsets.py,sha256=0yEFO27kh9uvdu4-MYW9bp5OX9Wb3lIKdiC4Jcna-2o,40623
+pandas/tests/tseries/offsets/test_offsets_properties.py,sha256=P_16zBX7ocaGN-br0pEQBGTlewfiDpJsnf5R1ei83JQ,1971
+pandas/tests/tseries/offsets/test_quarter.py,sha256=VBRsOqNS6xzYV63UVrPU3Z3_eAZQw4WefK2gPNfKork,11839
+pandas/tests/tseries/offsets/test_ticks.py,sha256=1n9PC1iEDQwnUKJivCaC6Wms3r8Je8ZKcGua_ySLLqE,11548
+pandas/tests/tseries/offsets/test_week.py,sha256=EUTDq6l4YT8xbBhQb0iHyNfJEme2jVZdjzaeg-Qj75g,12330
+pandas/tests/tseries/offsets/test_year.py,sha256=EM9DThnH2c6CMw518YpxkrpJixPmH3OVQ_Qp8iMIHPQ,10455
+pandas/tests/tslibs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/tslibs/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/tslibs/__pycache__/test_api.cpython-312.pyc,,
+pandas/tests/tslibs/__pycache__/test_array_to_datetime.cpython-312.pyc,,
+pandas/tests/tslibs/__pycache__/test_ccalendar.cpython-312.pyc,,
+pandas/tests/tslibs/__pycache__/test_conversion.cpython-312.pyc,,
+pandas/tests/tslibs/__pycache__/test_fields.cpython-312.pyc,,
+pandas/tests/tslibs/__pycache__/test_libfrequencies.cpython-312.pyc,,
+pandas/tests/tslibs/__pycache__/test_liboffsets.cpython-312.pyc,,
+pandas/tests/tslibs/__pycache__/test_np_datetime.cpython-312.pyc,,
+pandas/tests/tslibs/__pycache__/test_npy_units.cpython-312.pyc,,
+pandas/tests/tslibs/__pycache__/test_parse_iso8601.cpython-312.pyc,,
+pandas/tests/tslibs/__pycache__/test_parsing.cpython-312.pyc,,
+pandas/tests/tslibs/__pycache__/test_period.cpython-312.pyc,,
+pandas/tests/tslibs/__pycache__/test_resolution.cpython-312.pyc,,
+pandas/tests/tslibs/__pycache__/test_strptime.cpython-312.pyc,,
+pandas/tests/tslibs/__pycache__/test_timedeltas.cpython-312.pyc,,
+pandas/tests/tslibs/__pycache__/test_timezones.cpython-312.pyc,,
+pandas/tests/tslibs/__pycache__/test_to_offset.cpython-312.pyc,,
+pandas/tests/tslibs/__pycache__/test_tzconversion.cpython-312.pyc,,
+pandas/tests/tslibs/test_api.py,sha256=ooEY2RyO9oL8Wcbsc958sGrBjveqTQZPauLeBN3n9xc,1525
+pandas/tests/tslibs/test_array_to_datetime.py,sha256=uQOT4gOHQr35s3R6d8GxDdCH21db6rJZzXKQYrh89y0,11871
+pandas/tests/tslibs/test_ccalendar.py,sha256=Rl2OjoB8pHaOyXW5MmshsHmm8nNMuHQvS_Du1L6ODqw,1903
+pandas/tests/tslibs/test_conversion.py,sha256=rgtB7pIs6VvpkNakcew9PFQ8oVHtwCwwBtu2gCFqbh4,4555
+pandas/tests/tslibs/test_fields.py,sha256=BQKlBXOC4LsXe7eT2CK5mRGR_25g9qYykQZ6ojoGjbE,1352
+pandas/tests/tslibs/test_libfrequencies.py,sha256=Ai6deDiGlwUHR9mVvlkIbXYzWZADHuPLlaBjDK0R2wU,717
+pandas/tests/tslibs/test_liboffsets.py,sha256=958cVv4vva5nawrYcmSinfu62NIL7lYOXOHN7yU-gAE,5108
+pandas/tests/tslibs/test_np_datetime.py,sha256=n7MNYHw7i03w4ZcVTM6GkoRN7Y7UIGxnshjHph2eDPs,7889
+pandas/tests/tslibs/test_npy_units.py,sha256=d9NFsygcKGtp-pw-ZpOvIxMhpsRqd1uPBVlqejHkNmU,922
+pandas/tests/tslibs/test_parse_iso8601.py,sha256=XGQ_GBOCosTiOFFjK4rYoDDZcIBitnyIb_0SXxKF9yo,4535
+pandas/tests/tslibs/test_parsing.py,sha256=5b-ObA324ikkn2AjKTS3-666i8bKhiXtTICi3APdBGQ,13889
+pandas/tests/tslibs/test_period.py,sha256=l1xiNGDhMIJFG21BcAcE8Gkd6GODs-dPVOXcNuw6XTA,3424
+pandas/tests/tslibs/test_resolution.py,sha256=YC6IpOJsIHrsn7DUGi_LKdQrAuZgAqofNeW0DU2gays,1544
+pandas/tests/tslibs/test_strptime.py,sha256=DqjYyJ9t-cpSFDRyF3RepxMSZ4qvPllEjvarqvQKw1E,3896
+pandas/tests/tslibs/test_timedeltas.py,sha256=DaaxCrPg5Usv1UtpaVWpiYWixUtNT1FqjtS26MJq9PI,4662
+pandas/tests/tslibs/test_timezones.py,sha256=Hb56aLljCgRtBmXp7N_TaXM55ODLs6Mvl851dncnpsQ,4724
+pandas/tests/tslibs/test_to_offset.py,sha256=GaUG1VE0HhjMFjIj3aAP1LtzqFBCVx5_e0GUX1alIIU,5873
+pandas/tests/tslibs/test_tzconversion.py,sha256=6Ouplo1p8ArDrxCzPNyH9xpYkxERNPvbd4C_-WmTNd4,953
+pandas/tests/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/util/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/util/__pycache__/conftest.cpython-312.pyc,,
+pandas/tests/util/__pycache__/test_assert_almost_equal.cpython-312.pyc,,
+pandas/tests/util/__pycache__/test_assert_attr_equal.cpython-312.pyc,,
+pandas/tests/util/__pycache__/test_assert_categorical_equal.cpython-312.pyc,,
+pandas/tests/util/__pycache__/test_assert_extension_array_equal.cpython-312.pyc,,
+pandas/tests/util/__pycache__/test_assert_frame_equal.cpython-312.pyc,,
+pandas/tests/util/__pycache__/test_assert_index_equal.cpython-312.pyc,,
+pandas/tests/util/__pycache__/test_assert_interval_array_equal.cpython-312.pyc,,
+pandas/tests/util/__pycache__/test_assert_numpy_array_equal.cpython-312.pyc,,
+pandas/tests/util/__pycache__/test_assert_produces_warning.cpython-312.pyc,,
+pandas/tests/util/__pycache__/test_assert_series_equal.cpython-312.pyc,,
+pandas/tests/util/__pycache__/test_deprecate.cpython-312.pyc,,
+pandas/tests/util/__pycache__/test_deprecate_kwarg.cpython-312.pyc,,
+pandas/tests/util/__pycache__/test_deprecate_nonkeyword_arguments.cpython-312.pyc,,
+pandas/tests/util/__pycache__/test_doc.cpython-312.pyc,,
+pandas/tests/util/__pycache__/test_hashing.cpython-312.pyc,,
+pandas/tests/util/__pycache__/test_numba.cpython-312.pyc,,
+pandas/tests/util/__pycache__/test_rewrite_warning.cpython-312.pyc,,
+pandas/tests/util/__pycache__/test_shares_memory.cpython-312.pyc,,
+pandas/tests/util/__pycache__/test_show_versions.cpython-312.pyc,,
+pandas/tests/util/__pycache__/test_util.cpython-312.pyc,,
+pandas/tests/util/__pycache__/test_validate_args.cpython-312.pyc,,
+pandas/tests/util/__pycache__/test_validate_args_and_kwargs.cpython-312.pyc,,
+pandas/tests/util/__pycache__/test_validate_inclusive.cpython-312.pyc,,
+pandas/tests/util/__pycache__/test_validate_kwargs.cpython-312.pyc,,
+pandas/tests/util/conftest.py,sha256=loEbQsEtHtv-T4Umeq_UeV6R7s8SO01GHbW6gn8lvlo,476
+pandas/tests/util/test_assert_almost_equal.py,sha256=K1-2c3XrbAb3jU23Dl9T79ueRfE32_Va7CNPfvopOYo,16803
+pandas/tests/util/test_assert_attr_equal.py,sha256=ZXTojP4V5Kle96QOFhxCZjq-dQf6gHvNOorYyOuFP1I,1045
+pandas/tests/util/test_assert_categorical_equal.py,sha256=yDmVzU22k5k5txSHixGfRJ4nKeP46FdNoh3CY1xEwEM,2728
+pandas/tests/util/test_assert_extension_array_equal.py,sha256=quw84fCgsrwtUMu-TcvHmrq5-08J7l1ZzS_3h1Eh3qw,3887
+pandas/tests/util/test_assert_frame_equal.py,sha256=ds6rGI2yrNUfU4tZfXT1KocldOkcOk0kRpBlLUk4S30,13382
+pandas/tests/util/test_assert_index_equal.py,sha256=V0rKjnd0r3Lpas1UF45kVaFxLvKDBVpQmkCg2nfvErU,10157
+pandas/tests/util/test_assert_interval_array_equal.py,sha256=ITqL0Z8AAy5D1knACPOHodI64AHxmNzxiG-i9FeU0b8,2158
+pandas/tests/util/test_assert_numpy_array_equal.py,sha256=fgb8GdUwX4EYiR3PWbjJULNfAJz4DfJ8RJXchssygO4,6624
+pandas/tests/util/test_assert_produces_warning.py,sha256=A-pN3V12hnIqlbFYArYbdU-992RgJ-fqsaKbM0yvYPw,8412
+pandas/tests/util/test_assert_series_equal.py,sha256=4_pRYe67lrrpjhcm5ceU4XBq9umgbczf7BnpvcuEQ8E,15081
+pandas/tests/util/test_deprecate.py,sha256=1hGoeUQTew5o0DnCjLV5-hOfEuSoIGOXGByq5KpAP7A,1617
+pandas/tests/util/test_deprecate_kwarg.py,sha256=7T2QkCxXUoJHhCxUjAH_5_hM-BHC6nPWG635LFY35lo,2043
+pandas/tests/util/test_deprecate_nonkeyword_arguments.py,sha256=0UkqIi4ehxD3aoA3z7y8-3dpOs6o30_Gp8rZvFX1W9Q,3623
+pandas/tests/util/test_doc.py,sha256=u0fxCg4zZWhB4SkJYc2huQ0xv7sKKAt0OlpWldmhh_M,1492
+pandas/tests/util/test_hashing.py,sha256=ZjoFCs6MoAhGV1j2WyjjEJkqyO9WQgRqwS6xx-3n0oE,13857
+pandas/tests/util/test_numba.py,sha256=6eOVcokESth7h6yyeehVizx61FtwDdVbF8wV8j3t-Ic,308
+pandas/tests/util/test_rewrite_warning.py,sha256=AUHz_OT0HS6kXs-9e59GflBCP3Tb5jy8jl9FxBg5rDs,1151
+pandas/tests/util/test_shares_memory.py,sha256=-ksI1I3vK3PR6jMqcQn_yFyJ5P0v3eLsiMI9vjZVMi4,789
+pandas/tests/util/test_show_versions.py,sha256=FjYUrUMAF7hOzphaXED__8yjeF0HTccZS6q05__rH44,2096
+pandas/tests/util/test_util.py,sha256=4UacWPLyjRQZU697jBxBWO6V1gUgkE4E-KKF6H6aXuE,1463
+pandas/tests/util/test_validate_args.py,sha256=9Z4zTqnKAWn1q9KZNvuO3DF6oszHjQrQgtOOimurWcs,1907
+pandas/tests/util/test_validate_args_and_kwargs.py,sha256=d_XcMRAQ9r--yIAAWSdJML6KeWgksy5qRNFXaY1BMQA,2456
+pandas/tests/util/test_validate_inclusive.py,sha256=w2twetJgIedm6KGQ4WmdmGC_6-RShFjXBMBVxR0gcME,896
+pandas/tests/util/test_validate_kwargs.py,sha256=NAZi-4Z0DrlQKZkkcKrWxoHxzWuKFxY8iphCBweA9jk,1808
+pandas/tests/window/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/window/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/window/__pycache__/conftest.cpython-312.pyc,,
+pandas/tests/window/__pycache__/test_api.cpython-312.pyc,,
+pandas/tests/window/__pycache__/test_apply.cpython-312.pyc,,
+pandas/tests/window/__pycache__/test_base_indexer.cpython-312.pyc,,
+pandas/tests/window/__pycache__/test_cython_aggregations.cpython-312.pyc,,
+pandas/tests/window/__pycache__/test_dtypes.cpython-312.pyc,,
+pandas/tests/window/__pycache__/test_ewm.cpython-312.pyc,,
+pandas/tests/window/__pycache__/test_expanding.cpython-312.pyc,,
+pandas/tests/window/__pycache__/test_groupby.cpython-312.pyc,,
+pandas/tests/window/__pycache__/test_numba.cpython-312.pyc,,
+pandas/tests/window/__pycache__/test_online.cpython-312.pyc,,
+pandas/tests/window/__pycache__/test_pairwise.cpython-312.pyc,,
+pandas/tests/window/__pycache__/test_rolling.cpython-312.pyc,,
+pandas/tests/window/__pycache__/test_rolling_functions.cpython-312.pyc,,
+pandas/tests/window/__pycache__/test_rolling_quantile.cpython-312.pyc,,
+pandas/tests/window/__pycache__/test_rolling_skew_kurt.cpython-312.pyc,,
+pandas/tests/window/__pycache__/test_timeseries_window.cpython-312.pyc,,
+pandas/tests/window/__pycache__/test_win_type.cpython-312.pyc,,
+pandas/tests/window/conftest.py,sha256=rlS3eILzfTByRmmm7HLjk-FHEIbdTVVE9c0Dq-nfxa4,3137
+pandas/tests/window/moments/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/window/moments/__pycache__/__init__.cpython-312.pyc,,
+pandas/tests/window/moments/__pycache__/conftest.cpython-312.pyc,,
+pandas/tests/window/moments/__pycache__/test_moments_consistency_ewm.cpython-312.pyc,,
+pandas/tests/window/moments/__pycache__/test_moments_consistency_expanding.cpython-312.pyc,,
+pandas/tests/window/moments/__pycache__/test_moments_consistency_rolling.cpython-312.pyc,,
+pandas/tests/window/moments/conftest.py,sha256=xSkyyVltsAkJETLDHJSksjRkjcVHsnhfyCiNvhsQ3no,1595
+pandas/tests/window/moments/test_moments_consistency_ewm.py,sha256=4FPmIGVQuOUg13aT5c9l_DN7j7K3J9QEU0KXeO2Qrt0,8107
+pandas/tests/window/moments/test_moments_consistency_expanding.py,sha256=e4Vn3nE02q-UeRH2aWLOSMv0QN4nN04iePKst5N-Vbo,5537
+pandas/tests/window/moments/test_moments_consistency_rolling.py,sha256=UBQL1mWD1qIB3fNb4tizqv-q4xlAz4tGT1nC1G-9RWM,7821
+pandas/tests/window/test_api.py,sha256=QzFr1mgU99ETdYjqoucENyzJLmruPOO-dGR41MCARsY,13192
+pandas/tests/window/test_apply.py,sha256=v9YC4aORGX7yA50RFMjZqMx93SWp9o4Vpjo32xTROx0,9865
+pandas/tests/window/test_base_indexer.py,sha256=Fz81kU5x1g6OnNmRra6PRarPpq5HEYuA8XX0sR_y6LI,15954
+pandas/tests/window/test_cython_aggregations.py,sha256=wPAk76yfrG9D1-IzI0kDklpiTVqgp4xsEGjONe9lCY4,3967
+pandas/tests/window/test_dtypes.py,sha256=a3Xnqcq_jO0kczZmhmuBKkmCsKHOOufy9h6yNCPHlMk,5785
+pandas/tests/window/test_ewm.py,sha256=F1BB5E3_n5i5IzDNTMZeZzmG3aZqxC1jp_Pj-bWcozU,23020
+pandas/tests/window/test_expanding.py,sha256=Kz-2wSWxj4E31kd6y4jo7T7gE7aSe7yGHMYE7b4Bq18,24239
+pandas/tests/window/test_groupby.py,sha256=KXxA5gESxTSJEjmgnIz29Kz1jJRz1PYQsD64GSsoDz0,46719
+pandas/tests/window/test_numba.py,sha256=cd3uGoexUCkQ3BRNrGhfjzBb0DYGJbJ67_PJjnIxU8Q,16046
+pandas/tests/window/test_online.py,sha256=OuVpQr2NExZQ36Fl5RW4cm-2sDF3_CgEhbP-3W2xjUM,3346
+pandas/tests/window/test_pairwise.py,sha256=BXJLxRbolFs00FxTMp3uIFDNpZkciv8VGyAXFMw3zHI,16141
+pandas/tests/window/test_rolling.py,sha256=PzPkVsNDBUh6wgzFZvq_YNba2bdmwSO_H8BUK9ZxAys,61158
+pandas/tests/window/test_rolling_functions.py,sha256=xmaaXFaMq22o1s0Ba4NieIkTZtKWi9WOYae6z8i_rBo,17877
+pandas/tests/window/test_rolling_quantile.py,sha256=AvsqMR5YrVAlAFfhL0lHHAZIazXnzI1VkoVuPuiDEro,5516
+pandas/tests/window/test_rolling_skew_kurt.py,sha256=Emw9AJhTZyuVnxPg-nfYxpRNGJToWJ-he7obTSOy8iU,7807
+pandas/tests/window/test_timeseries_window.py,sha256=I0hk72tAFP4RJUaGesfUrjR5HC_bxBWwcXW7mxgslfg,24250
+pandas/tests/window/test_win_type.py,sha256=GRu_7tF1tQAEH8hcb6kZPSG2FJihUTE1_85tH1iYaN8,17522
+pandas/tseries/__init__.py,sha256=CM1Forog6FJC_5YY4IueiWfQ9cATlSDJ4hF23RTniBQ,293
+pandas/tseries/__pycache__/__init__.cpython-312.pyc,,
+pandas/tseries/__pycache__/api.cpython-312.pyc,,
+pandas/tseries/__pycache__/frequencies.cpython-312.pyc,,
+pandas/tseries/__pycache__/holiday.cpython-312.pyc,,
+pandas/tseries/__pycache__/offsets.cpython-312.pyc,,
+pandas/tseries/api.py,sha256=0Tms-OsqaHcpWH7a2F4mqKqEV-G5btiZKte3cUnEWQM,234
+pandas/tseries/frequencies.py,sha256=HNmBHzxRPhtlnpZF6iBSvq6e2du9J1JZ9gQ2c48Bvv0,17686
+pandas/tseries/holiday.py,sha256=G9kQvaBMzdNUoCs4WApAcxzSkOozFEyfDYFFjL8ZlZc,18596
+pandas/tseries/offsets.py,sha256=wLWH1_fg7dYGDsHDRyBxc62788G9CDhLcpDeZHt5ixI,1531
+pandas/util/__init__.py,sha256=tXNVCMKcgkFf4GETkpUx_UYvN56-54tYCCM0-04OIn4,827
+pandas/util/__pycache__/__init__.cpython-312.pyc,,
+pandas/util/__pycache__/_decorators.cpython-312.pyc,,
+pandas/util/__pycache__/_doctools.cpython-312.pyc,,
+pandas/util/__pycache__/_exceptions.cpython-312.pyc,,
+pandas/util/__pycache__/_print_versions.cpython-312.pyc,,
+pandas/util/__pycache__/_test_decorators.cpython-312.pyc,,
+pandas/util/__pycache__/_tester.cpython-312.pyc,,
+pandas/util/__pycache__/_validators.cpython-312.pyc,,
+pandas/util/_decorators.py,sha256=n1OyKRRG-dcCRUSmyejpKTyfP_iu2kVF0TJ_9yIJkeo,17106
+pandas/util/_doctools.py,sha256=Es1FLqrmsOLpJ_7Y24q_vqdXGw5Vy6vcajcfbIi_FCo,6819
+pandas/util/_exceptions.py,sha256=H6Tz6X1PqPVp6wG_7OsjHEqTvTM9I3SebF5-WcTdZOc,2876
+pandas/util/_print_versions.py,sha256=eHw3wpaF-l66uzupWfl_x2jjXz8WTedHZdH4FFKtWo0,4636
+pandas/util/_test_decorators.py,sha256=KEhS1cMaBbf4U0R0KMRXZl-CcCkPfNqxpVz8BTtb0zY,5079
+pandas/util/_tester.py,sha256=Mluqpd_YwVdcdgZfSu-_oVdadk_JjX9FuPGFjn_S6ZA,1462
+pandas/util/_validators.py,sha256=VGKuOFzz0rY5g2dmbKpWV8vZb5Jb1RV5w-HTVi1GMY0,14300
+pandas/util/version/__init__.py,sha256=57SNOildSF8ehHn99uGwCZeAkTEuA6YMw6cYxjEyQ2I,16394
+pandas/util/version/__pycache__/__init__.cpython-312.pyc,,
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas-2.2.3.dist-info/REQUESTED b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas-2.2.3.dist-info/REQUESTED
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas-2.2.3.dist-info/WHEEL b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas-2.2.3.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..d98ef534f680b37433e9ab0f8470bdbe56c303d8
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas-2.2.3.dist-info/WHEEL
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: meson
+Root-Is-Purelib: false
+Tag: cp312-cp312-manylinux_2_17_x86_64
+Tag: cp312-cp312-manylinux2014_x86_64
+
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas-2.2.3.dist-info/entry_points.txt b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas-2.2.3.dist-info/entry_points.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3c1b523d70758fbd0080e21ca4c7ce6d9c9d9bd5
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas-2.2.3.dist-info/entry_points.txt
@@ -0,0 +1,3 @@
+[pandas_plotting_backends]
+matplotlib = pandas:plotting._matplotlib
+
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pyarrow_hotfix/__about__.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pyarrow_hotfix/__about__.py
new file mode 100644
index 0000000000000000000000000000000000000000..6ec26f8de7ac2f58845ef7fedb147853c2de7626
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pyarrow_hotfix/__about__.py
@@ -0,0 +1,5 @@
+# SPDX-FileCopyrightText: 2023-present Antoine Pitrou
+#
+# SPDX-License-Identifier: Apache-2.0
+
+__version__ = "0.7"
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pyarrow_hotfix/__init__.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pyarrow_hotfix/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..79ab0a4c6304ca2bfa0ed1248037c9a7861191d5
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pyarrow_hotfix/__init__.py
@@ -0,0 +1,118 @@
+# SPDX-FileCopyrightText: 2023-present Antoine Pitrou
+#
+# SPDX-License-Identifier: Apache-2.0
+
+
+_ERROR_MSG = """\
+Disallowed deserialization of 'arrow.py_extension_type':
+storage_type = {storage_type}
+serialized = {serialized}
+pickle disassembly:\n{pickle_disassembly}
+
+Reading of untrusted Parquet or Feather files with a PyExtensionType column
+allows arbitrary code execution.
+If you trust this file, you can enable reading the extension type by one of:
+
+- upgrading to pyarrow >= 14.0.1, and call `pa.PyExtensionType.set_auto_load(True)`
+- disable this error by running `import pyarrow_hotfix; pyarrow_hotfix.uninstall()`
+
+We strongly recommend updating your Parquet/Feather files to use extension types
+derived from `pyarrow.ExtensionType` instead, and register this type explicitly.
+See https://arrow.apache.org/docs/dev/python/extending_types.html#defining-extension-types-user-defined-types
+for more details.
+"""
+
+try:
+ _import_error = ModuleNotFoundError
+except NameError:
+ _import_error = ImportError # ModuleNotFoundError unavailable in py3.5
+
+
+def install():
+ import atexit
+ try:
+ import pyarrow as pa
+ except _import_error:
+ # Not installed; nothing to do here.
+ return
+
+ if not hasattr(pa, "ExtensionType"):
+ # Unsupported PyArrow version?
+ return
+
+ if getattr(pa, "_hotfix_installed", False):
+ return
+
+ class ForbiddenExtensionType(pa.ExtensionType):
+ def __arrow_ext_serialize__(self):
+ return b""
+
+ @classmethod
+ def __arrow_ext_deserialize__(cls, storage_type, serialized):
+ import io
+ import pickletools
+ out = io.StringIO()
+ pickletools.dis(serialized, out)
+ raise RuntimeError(
+ _ERROR_MSG.format(
+ storage_type=storage_type,
+ serialized=serialized,
+ pickle_disassembly=out.getvalue(),
+ )
+ )
+
+ if hasattr(pa, "unregister_extension_type"):
+ if not hasattr(pa, "PyExtensionType"):
+ # 21.0.0 <= PyArrow
+ return
+ else:
+ # 0.15.0 <= PyArrow < 21.0.0
+ pa.unregister_extension_type("arrow.py_extension_type")
+ pa.register_extension_type(ForbiddenExtensionType(pa.null(),
+ "arrow.py_extension_type"))
+ elif hasattr(pa.lib, "_unregister_py_extension_type"):
+ # 0.14.1 <= PyArrow < 0.15.0
+ pa.lib._unregister_py_extension_type()
+ atexit.unregister(pa.lib._unregister_py_extension_type)
+ else:
+ # PyArrow 0.14.0
+ del pa.lib._extension_types_initializer
+
+ pa._hotfix_installed = True
+
+
+def uninstall():
+ import atexit
+ try:
+ import pyarrow as pa
+ except _import_error:
+ # Not installed; nothing to do here.
+ return
+
+ if not hasattr(pa, "ExtensionType"):
+ # Unsupported PyArrow version?
+ return
+
+ if not getattr(pa, "_hotfix_installed", False):
+ return
+
+ if hasattr(pa, "unregister_extension_type"):
+ if not hasattr(pa, "PyExtensionType"):
+ # 21.0.0 <= PyArrow
+ return
+ else:
+ # 0.15.0 <= PyArrow < 21.0.0
+ pa.unregister_extension_type("arrow.py_extension_type")
+ pa.lib._register_py_extension_type()
+ elif hasattr(pa.lib, "_register_py_extension_type"):
+ # 0.14.1 <= PyArrow < 0.15.0
+ pa.lib._register_py_extension_type()
+ atexit.register(pa.lib._unregister_py_extension_type)
+ elif hasattr(pa.lib, "_ExtensionTypesInitializer"):
+ # PyArrow 0.14.0
+ pa.lib._extension_types_initializer = pa.lib._ExtensionTypesInitializer()
+
+ pa._hotfix_installed = False
+
+
+install()
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pytz-2023.4.dist-info/INSTALLER b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pytz-2023.4.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pytz-2023.4.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pytz-2023.4.dist-info/LICENSE.txt b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pytz-2023.4.dist-info/LICENSE.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5f1c11289f6a54cb07ebdbf31d02e8e81b18b07f
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pytz-2023.4.dist-info/LICENSE.txt
@@ -0,0 +1,19 @@
+Copyright (c) 2003-2019 Stuart Bishop
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pytz-2023.4.dist-info/METADATA b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pytz-2023.4.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..4c29169e607ca67f02da1dc399d5e9d52effad5d
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pytz-2023.4.dist-info/METADATA
@@ -0,0 +1,649 @@
+Metadata-Version: 2.1
+Name: pytz
+Version: 2023.4
+Summary: World timezone definitions, modern and historical
+Home-page: http://pythonhosted.org/pytz
+Author: Stuart Bishop
+Author-email: stuart@stuartbishop.net
+Maintainer: Stuart Bishop
+Maintainer-email: stuart@stuartbishop.net
+License: MIT
+Download-URL: https://pypi.org/project/pytz/
+Keywords: timezone,tzinfo,datetime,olson,time
+Platform: Independent
+Classifier: Development Status :: 6 - Mature
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.4
+Classifier: Programming Language :: Python :: 2.5
+Classifier: Programming Language :: Python :: 2.6
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.1
+Classifier: Programming Language :: Python :: 3.2
+Classifier: Programming Language :: Python :: 3.3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+License-File: LICENSE.txt
+
+pytz - World Timezone Definitions for Python
+============================================
+
+:Author: Stuart Bishop
+
+Introduction
+~~~~~~~~~~~~
+
+pytz brings the Olson tz database into Python. This library allows
+accurate and cross platform timezone calculations using Python 2.4
+or higher. It also solves the issue of ambiguous times at the end
+of daylight saving time, which you can read more about in the Python
+Library Reference (``datetime.tzinfo``).
+
+Almost all of the Olson timezones are supported.
+
+.. note::
+
+ Projects using Python 3.9 or later should be using the support
+ now included as part of the standard library, and third party
+ packages work with it such as `tzdata `_.
+
+
+Example & Usage
+~~~~~~~~~~~~~~~
+
+Localized times and date arithmetic
+-----------------------------------
+
+>>> from datetime import datetime, timedelta
+>>> from pytz import timezone
+>>> import pytz
+>>> utc = pytz.utc
+>>> utc.zone
+'UTC'
+>>> eastern = timezone('US/Eastern')
+>>> eastern.zone
+'US/Eastern'
+>>> amsterdam = timezone('Europe/Amsterdam')
+>>> fmt = '%Y-%m-%d %H:%M:%S %Z%z'
+
+This library only supports two ways of building a localized time. The
+first is to use the ``localize()`` method provided by the pytz library.
+This is used to localize a naive datetime (datetime with no timezone
+information):
+
+>>> loc_dt = eastern.localize(datetime(2002, 10, 27, 6, 0, 0))
+>>> print(loc_dt.strftime(fmt))
+2002-10-27 06:00:00 EST-0500
+
+The second way of building a localized time is by converting an existing
+localized time using the standard ``astimezone()`` method:
+
+>>> ams_dt = loc_dt.astimezone(amsterdam)
+>>> ams_dt.strftime(fmt)
+'2002-10-27 12:00:00 CET+0100'
+
+Unfortunately using the tzinfo argument of the standard datetime
+constructors ''does not work'' with pytz for many timezones.
+
+>>> datetime(2002, 10, 27, 12, 0, 0, tzinfo=amsterdam).strftime(fmt) # /!\ Does not work this way!
+'2002-10-27 12:00:00 LMT+0018'
+
+It is safe for timezones without daylight saving transitions though, such
+as UTC:
+
+>>> datetime(2002, 10, 27, 12, 0, 0, tzinfo=pytz.utc).strftime(fmt) # /!\ Not recommended except for UTC
+'2002-10-27 12:00:00 UTC+0000'
+
+The preferred way of dealing with times is to always work in UTC,
+converting to localtime only when generating output to be read
+by humans.
+
+>>> utc_dt = datetime(2002, 10, 27, 6, 0, 0, tzinfo=utc)
+>>> loc_dt = utc_dt.astimezone(eastern)
+>>> loc_dt.strftime(fmt)
+'2002-10-27 01:00:00 EST-0500'
+
+This library also allows you to do date arithmetic using local
+times, although it is more complicated than working in UTC as you
+need to use the ``normalize()`` method to handle daylight saving time
+and other timezone transitions. In this example, ``loc_dt`` is set
+to the instant when daylight saving time ends in the US/Eastern
+timezone.
+
+>>> before = loc_dt - timedelta(minutes=10)
+>>> before.strftime(fmt)
+'2002-10-27 00:50:00 EST-0500'
+>>> eastern.normalize(before).strftime(fmt)
+'2002-10-27 01:50:00 EDT-0400'
+>>> after = eastern.normalize(before + timedelta(minutes=20))
+>>> after.strftime(fmt)
+'2002-10-27 01:10:00 EST-0500'
+
+Creating local times is also tricky, and the reason why working with
+local times is not recommended. Unfortunately, you cannot just pass
+a ``tzinfo`` argument when constructing a datetime (see the next
+section for more details)
+
+>>> dt = datetime(2002, 10, 27, 1, 30, 0)
+>>> dt1 = eastern.localize(dt, is_dst=True)
+>>> dt1.strftime(fmt)
+'2002-10-27 01:30:00 EDT-0400'
+>>> dt2 = eastern.localize(dt, is_dst=False)
+>>> dt2.strftime(fmt)
+'2002-10-27 01:30:00 EST-0500'
+
+Converting between timezones is more easily done, using the
+standard astimezone method.
+
+>>> utc_dt = datetime.fromtimestamp(1143408899, tz=utc)
+>>> utc_dt.strftime(fmt)
+'2006-03-26 21:34:59 UTC+0000'
+>>> au_tz = timezone('Australia/Sydney')
+>>> au_dt = utc_dt.astimezone(au_tz)
+>>> au_dt.strftime(fmt)
+'2006-03-27 08:34:59 AEDT+1100'
+>>> utc_dt2 = au_dt.astimezone(utc)
+>>> utc_dt2.strftime(fmt)
+'2006-03-26 21:34:59 UTC+0000'
+>>> utc_dt == utc_dt2
+True
+
+You can take shortcuts when dealing with the UTC side of timezone
+conversions. ``normalize()`` and ``localize()`` are not really
+necessary when there are no daylight saving time transitions to
+deal with.
+
+>>> utc_dt = datetime.fromtimestamp(1143408899, tz=utc)
+>>> utc_dt.strftime(fmt)
+'2006-03-26 21:34:59 UTC+0000'
+>>> au_tz = timezone('Australia/Sydney')
+>>> au_dt = au_tz.normalize(utc_dt.astimezone(au_tz))
+>>> au_dt.strftime(fmt)
+'2006-03-27 08:34:59 AEDT+1100'
+>>> utc_dt2 = au_dt.astimezone(utc)
+>>> utc_dt2.strftime(fmt)
+'2006-03-26 21:34:59 UTC+0000'
+
+
+``tzinfo`` API
+--------------
+
+The ``tzinfo`` instances returned by the ``timezone()`` function have
+been extended to cope with ambiguous times by adding an ``is_dst``
+parameter to the ``utcoffset()``, ``dst()`` && ``tzname()`` methods.
+
+>>> tz = timezone('America/St_Johns')
+
+>>> normal = datetime(2009, 9, 1)
+>>> ambiguous = datetime(2009, 10, 31, 23, 30)
+
+The ``is_dst`` parameter is ignored for most timestamps. It is only used
+during DST transition ambiguous periods to resolve that ambiguity.
+
+>>> print(tz.utcoffset(normal, is_dst=True))
+-1 day, 21:30:00
+>>> print(tz.dst(normal, is_dst=True))
+1:00:00
+>>> tz.tzname(normal, is_dst=True)
+'NDT'
+
+>>> print(tz.utcoffset(ambiguous, is_dst=True))
+-1 day, 21:30:00
+>>> print(tz.dst(ambiguous, is_dst=True))
+1:00:00
+>>> tz.tzname(ambiguous, is_dst=True)
+'NDT'
+
+>>> print(tz.utcoffset(normal, is_dst=False))
+-1 day, 21:30:00
+>>> tz.dst(normal, is_dst=False).seconds
+3600
+>>> tz.tzname(normal, is_dst=False)
+'NDT'
+
+>>> print(tz.utcoffset(ambiguous, is_dst=False))
+-1 day, 20:30:00
+>>> tz.dst(ambiguous, is_dst=False)
+datetime.timedelta(0)
+>>> tz.tzname(ambiguous, is_dst=False)
+'NST'
+
+If ``is_dst`` is not specified, ambiguous timestamps will raise
+an ``pytz.exceptions.AmbiguousTimeError`` exception.
+
+>>> print(tz.utcoffset(normal))
+-1 day, 21:30:00
+>>> print(tz.dst(normal))
+1:00:00
+>>> tz.tzname(normal)
+'NDT'
+
+>>> import pytz.exceptions
+>>> try:
+... tz.utcoffset(ambiguous)
+... except pytz.exceptions.AmbiguousTimeError:
+... print('pytz.exceptions.AmbiguousTimeError: %s' % ambiguous)
+pytz.exceptions.AmbiguousTimeError: 2009-10-31 23:30:00
+>>> try:
+... tz.dst(ambiguous)
+... except pytz.exceptions.AmbiguousTimeError:
+... print('pytz.exceptions.AmbiguousTimeError: %s' % ambiguous)
+pytz.exceptions.AmbiguousTimeError: 2009-10-31 23:30:00
+>>> try:
+... tz.tzname(ambiguous)
+... except pytz.exceptions.AmbiguousTimeError:
+... print('pytz.exceptions.AmbiguousTimeError: %s' % ambiguous)
+pytz.exceptions.AmbiguousTimeError: 2009-10-31 23:30:00
+
+
+Problems with Localtime
+~~~~~~~~~~~~~~~~~~~~~~~
+
+The major problem we have to deal with is that certain datetimes
+may occur twice in a year. For example, in the US/Eastern timezone
+on the last Sunday morning in October, the following sequence
+happens:
+
+ - 01:00 EDT occurs
+ - 1 hour later, instead of 2:00am the clock is turned back 1 hour
+ and 01:00 happens again (this time 01:00 EST)
+
+In fact, every instant between 01:00 and 02:00 occurs twice. This means
+that if you try and create a time in the 'US/Eastern' timezone
+the standard datetime syntax, there is no way to specify if you meant
+before of after the end-of-daylight-saving-time transition. Using the
+pytz custom syntax, the best you can do is make an educated guess:
+
+>>> loc_dt = eastern.localize(datetime(2002, 10, 27, 1, 30, 00))
+>>> loc_dt.strftime(fmt)
+'2002-10-27 01:30:00 EST-0500'
+
+As you can see, the system has chosen one for you and there is a 50%
+chance of it being out by one hour. For some applications, this does
+not matter. However, if you are trying to schedule meetings with people
+in different timezones or analyze log files it is not acceptable.
+
+The best and simplest solution is to stick with using UTC. The pytz
+package encourages using UTC for internal timezone representation by
+including a special UTC implementation based on the standard Python
+reference implementation in the Python documentation.
+
+The UTC timezone unpickles to be the same instance, and pickles to a
+smaller size than other pytz tzinfo instances. The UTC implementation
+can be obtained as pytz.utc, pytz.UTC, or pytz.timezone('UTC').
+
+>>> import pickle, pytz
+>>> dt = datetime(2005, 3, 1, 14, 13, 21, tzinfo=utc)
+>>> naive = dt.replace(tzinfo=None)
+>>> p = pickle.dumps(dt, 1)
+>>> naive_p = pickle.dumps(naive, 1)
+>>> len(p) - len(naive_p)
+17
+>>> new = pickle.loads(p)
+>>> new == dt
+True
+>>> new is dt
+False
+>>> new.tzinfo is dt.tzinfo
+True
+>>> pytz.utc is pytz.UTC is pytz.timezone('UTC')
+True
+
+Note that some other timezones are commonly thought of as the same (GMT,
+Greenwich, Universal, etc.). The definition of UTC is distinct from these
+other timezones, and they are not equivalent. For this reason, they will
+not compare the same in Python.
+
+>>> utc == pytz.timezone('GMT')
+False
+
+See the section `What is UTC`_, below.
+
+If you insist on working with local times, this library provides a
+facility for constructing them unambiguously:
+
+>>> loc_dt = datetime(2002, 10, 27, 1, 30, 00)
+>>> est_dt = eastern.localize(loc_dt, is_dst=True)
+>>> edt_dt = eastern.localize(loc_dt, is_dst=False)
+>>> print(est_dt.strftime(fmt) + ' / ' + edt_dt.strftime(fmt))
+2002-10-27 01:30:00 EDT-0400 / 2002-10-27 01:30:00 EST-0500
+
+If you pass None as the is_dst flag to localize(), pytz will refuse to
+guess and raise exceptions if you try to build ambiguous or non-existent
+times.
+
+For example, 1:30am on 27th Oct 2002 happened twice in the US/Eastern
+timezone when the clocks where put back at the end of Daylight Saving
+Time:
+
+>>> dt = datetime(2002, 10, 27, 1, 30, 00)
+>>> try:
+... eastern.localize(dt, is_dst=None)
+... except pytz.exceptions.AmbiguousTimeError:
+... print('pytz.exceptions.AmbiguousTimeError: %s' % dt)
+pytz.exceptions.AmbiguousTimeError: 2002-10-27 01:30:00
+
+Similarly, 2:30am on 7th April 2002 never happened at all in the
+US/Eastern timezone, as the clocks where put forward at 2:00am skipping
+the entire hour:
+
+>>> dt = datetime(2002, 4, 7, 2, 30, 00)
+>>> try:
+... eastern.localize(dt, is_dst=None)
+... except pytz.exceptions.NonExistentTimeError:
+... print('pytz.exceptions.NonExistentTimeError: %s' % dt)
+pytz.exceptions.NonExistentTimeError: 2002-04-07 02:30:00
+
+Both of these exceptions share a common base class to make error handling
+easier:
+
+>>> isinstance(pytz.AmbiguousTimeError(), pytz.InvalidTimeError)
+True
+>>> isinstance(pytz.NonExistentTimeError(), pytz.InvalidTimeError)
+True
+
+
+A special case is where countries change their timezone definitions
+with no daylight savings time switch. For example, in 1915 Warsaw
+switched from Warsaw time to Central European time with no daylight savings
+transition. So at the stroke of midnight on August 5th 1915 the clocks
+were wound back 24 minutes creating an ambiguous time period that cannot
+be specified without referring to the timezone abbreviation or the
+actual UTC offset. In this case midnight happened twice, neither time
+during a daylight saving time period. pytz handles this transition by
+treating the ambiguous period before the switch as daylight savings
+time, and the ambiguous period after as standard time.
+
+
+>>> warsaw = pytz.timezone('Europe/Warsaw')
+>>> amb_dt1 = warsaw.localize(datetime(1915, 8, 4, 23, 59, 59), is_dst=True)
+>>> amb_dt1.strftime(fmt)
+'1915-08-04 23:59:59 WMT+0124'
+>>> amb_dt2 = warsaw.localize(datetime(1915, 8, 4, 23, 59, 59), is_dst=False)
+>>> amb_dt2.strftime(fmt)
+'1915-08-04 23:59:59 CET+0100'
+>>> switch_dt = warsaw.localize(datetime(1915, 8, 5, 00, 00, 00), is_dst=False)
+>>> switch_dt.strftime(fmt)
+'1915-08-05 00:00:00 CET+0100'
+>>> str(switch_dt - amb_dt1)
+'0:24:01'
+>>> str(switch_dt - amb_dt2)
+'0:00:01'
+
+The best way of creating a time during an ambiguous time period is
+by converting from another timezone such as UTC:
+
+>>> utc_dt = datetime(1915, 8, 4, 22, 36, tzinfo=pytz.utc)
+>>> utc_dt.astimezone(warsaw).strftime(fmt)
+'1915-08-04 23:36:00 CET+0100'
+
+The standard Python way of handling all these ambiguities is not to
+handle them, such as demonstrated in this example using the US/Eastern
+timezone definition from the Python documentation (Note that this
+implementation only works for dates between 1987 and 2006 - it is
+included for tests only!):
+
+>>> from pytz.reference import Eastern # pytz.reference only for tests
+>>> dt = datetime(2002, 10, 27, 0, 30, tzinfo=Eastern)
+>>> str(dt)
+'2002-10-27 00:30:00-04:00'
+>>> str(dt + timedelta(hours=1))
+'2002-10-27 01:30:00-05:00'
+>>> str(dt + timedelta(hours=2))
+'2002-10-27 02:30:00-05:00'
+>>> str(dt + timedelta(hours=3))
+'2002-10-27 03:30:00-05:00'
+
+Notice the first two results? At first glance you might think they are
+correct, but taking the UTC offset into account you find that they are
+actually two hours appart instead of the 1 hour we asked for.
+
+>>> from pytz.reference import UTC # pytz.reference only for tests
+>>> str(dt.astimezone(UTC))
+'2002-10-27 04:30:00+00:00'
+>>> str((dt + timedelta(hours=1)).astimezone(UTC))
+'2002-10-27 06:30:00+00:00'
+
+
+Country Information
+~~~~~~~~~~~~~~~~~~~
+
+A mechanism is provided to access the timezones commonly in use
+for a particular country, looked up using the ISO 3166 country code.
+It returns a list of strings that can be used to retrieve the relevant
+tzinfo instance using ``pytz.timezone()``:
+
+>>> print(' '.join(pytz.country_timezones['nz']))
+Pacific/Auckland Pacific/Chatham
+
+The Olson database comes with a ISO 3166 country code to English country
+name mapping that pytz exposes as a dictionary:
+
+>>> print(pytz.country_names['nz'])
+New Zealand
+
+
+What is UTC
+~~~~~~~~~~~
+
+'UTC' is `Coordinated Universal Time`_. It is a successor to, but distinct
+from, Greenwich Mean Time (GMT) and the various definitions of Universal
+Time. UTC is now the worldwide standard for regulating clocks and time
+measurement.
+
+All other timezones are defined relative to UTC, and include offsets like
+UTC+0800 - hours to add or subtract from UTC to derive the local time. No
+daylight saving time occurs in UTC, making it a useful timezone to perform
+date arithmetic without worrying about the confusion and ambiguities caused
+by daylight saving time transitions, your country changing its timezone, or
+mobile computers that roam through multiple timezones.
+
+.. _Coordinated Universal Time: https://en.wikipedia.org/wiki/Coordinated_Universal_Time
+
+
+Helpers
+~~~~~~~
+
+There are two lists of timezones provided.
+
+``all_timezones`` is the exhaustive list of the timezone names that can
+be used.
+
+>>> from pytz import all_timezones
+>>> len(all_timezones) >= 500
+True
+>>> 'Etc/Greenwich' in all_timezones
+True
+
+``common_timezones`` is a list of useful, current timezones. It doesn't
+contain deprecated zones or historical zones, except for a few I've
+deemed in common usage, such as US/Eastern (open a bug report if you
+think other timezones are deserving of being included here). It is also
+a sequence of strings.
+
+>>> from pytz import common_timezones
+>>> len(common_timezones) < len(all_timezones)
+True
+>>> 'Etc/Greenwich' in common_timezones
+False
+>>> 'Australia/Melbourne' in common_timezones
+True
+>>> 'US/Eastern' in common_timezones
+True
+>>> 'Canada/Eastern' in common_timezones
+True
+>>> 'Australia/Yancowinna' in all_timezones
+True
+>>> 'Australia/Yancowinna' in common_timezones
+False
+
+Both ``common_timezones`` and ``all_timezones`` are alphabetically
+sorted:
+
+>>> common_timezones_dupe = common_timezones[:]
+>>> common_timezones_dupe.sort()
+>>> common_timezones == common_timezones_dupe
+True
+>>> all_timezones_dupe = all_timezones[:]
+>>> all_timezones_dupe.sort()
+>>> all_timezones == all_timezones_dupe
+True
+
+``all_timezones`` and ``common_timezones`` are also available as sets.
+
+>>> from pytz import all_timezones_set, common_timezones_set
+>>> 'US/Eastern' in all_timezones_set
+True
+>>> 'US/Eastern' in common_timezones_set
+True
+>>> 'Australia/Victoria' in common_timezones_set
+False
+
+You can also retrieve lists of timezones used by particular countries
+using the ``country_timezones()`` function. It requires an ISO-3166
+two letter country code.
+
+>>> from pytz import country_timezones
+>>> print(' '.join(country_timezones('ch')))
+Europe/Zurich
+>>> print(' '.join(country_timezones('CH')))
+Europe/Zurich
+
+
+Internationalization - i18n/l10n
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Pytz is an interface to the IANA database, which uses ASCII names. The `Unicode Consortium's Unicode Locales (CLDR) `_
+project provides translations. Python packages such as
+`Babel `_
+and Thomas Khyn's `l18n `_, and the
+`Atom feed `_
+hosted there.
+
+
+Bugs, Feature Requests & Patches
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Bugs should be reported on `Github `_.
+Feature requests are unlikely to be considered, and efforts instead directed
+to timezone support now built into Python or packages that work with it.
+
+
+Security Issues
+~~~~~~~~~~~~~~~
+
+Reports about security issues can be made via `Tidelift `_.
+
+
+Issues & Limitations
+~~~~~~~~~~~~~~~~~~~~
+
+- This project is in maintenance mode. Projects using Python 3.9 or later
+ are best served by using the timezone functionaly now included in core
+ Python and packages that work with it such as `tzdata
+
+
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pytz-2023.4.dist-info/RECORD b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pytz-2023.4.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..b2ab94a49e5372efae1488d40606d5d4fa2e43bf
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pytz-2023.4.dist-info/RECORD
@@ -0,0 +1,622 @@
+pytz-2023.4.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+pytz-2023.4.dist-info/LICENSE.txt,sha256=vosaN-vibFkqkPbA6zMQOn84POL010mMCvmlJpkKB7g,1088
+pytz-2023.4.dist-info/METADATA,sha256=kl1RcrBLDvGb6b9p7gtpuN_ElD_wWYQkSMBsVlZw4Xg,22325
+pytz-2023.4.dist-info/RECORD,,
+pytz-2023.4.dist-info/WHEEL,sha256=z9j0xAa_JmUKMpmz72K0ZGALSM_n-wQVmGbleXx2VHg,110
+pytz-2023.4.dist-info/top_level.txt,sha256=6xRYlt934v1yHb1JIrXgHyGxn3cqACvd-yE8ski_kcc,5
+pytz-2023.4.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+pytz/__init__.py,sha256=ArFdfgkdXwRuc2Hr6cDVPY6t9_f-KXiPFno9M72qhmc,35101
+pytz/__pycache__/__init__.cpython-312.pyc,,
+pytz/__pycache__/exceptions.cpython-312.pyc,,
+pytz/__pycache__/lazy.cpython-312.pyc,,
+pytz/__pycache__/reference.cpython-312.pyc,,
+pytz/__pycache__/tzfile.cpython-312.pyc,,
+pytz/__pycache__/tzinfo.cpython-312.pyc,,
+pytz/exceptions.py,sha256=434ZcuLlpLQY9mWoGq7zJMV1TyiYvVgpKBU1qZkbDjM,1571
+pytz/lazy.py,sha256=toeR5uDWKBj6ezsUZ4elNP6CEMtK7CO2jS9A30nsFbo,5404
+pytz/reference.py,sha256=zUtCki7JFEmrzrjNsfMD7YL0lWDxynKc1Ubo4iXSs74,3778
+pytz/tzfile.py,sha256=K2y7pZs4vydpZVftrfAA_-hgw17y1Szc7z_QCse6udU,4723
+pytz/tzinfo.py,sha256=XfaVOoO3KsCvtUYaCd0fvgBXWZ8tgevGYUoBh_uiE60,19340
+pytz/zoneinfo/Africa/Abidjan,sha256=0u-sTl8j2IyV1ywdtCgHFw9S9D3ZiiBa9akqkbny2Zc,148
+pytz/zoneinfo/Africa/Accra,sha256=0u-sTl8j2IyV1ywdtCgHFw9S9D3ZiiBa9akqkbny2Zc,148
+pytz/zoneinfo/Africa/Addis_Ababa,sha256=yJsuJTqJJqbOz37_NOS_zbf-JNr_IthHGMMN7sDqSWg,265
+pytz/zoneinfo/Africa/Algiers,sha256=vaFpjNVCwObnbfu82rOQzdJvN6nVgmpXpQ1aqzfzsqY,735
+pytz/zoneinfo/Africa/Asmara,sha256=yJsuJTqJJqbOz37_NOS_zbf-JNr_IthHGMMN7sDqSWg,265
+pytz/zoneinfo/Africa/Asmera,sha256=yJsuJTqJJqbOz37_NOS_zbf-JNr_IthHGMMN7sDqSWg,265
+pytz/zoneinfo/Africa/Bamako,sha256=0u-sTl8j2IyV1ywdtCgHFw9S9D3ZiiBa9akqkbny2Zc,148
+pytz/zoneinfo/Africa/Bangui,sha256=z_6wKCzL1_ug5JP_hneh5abdUZeIUELkN_ladz-ESEY,235
+pytz/zoneinfo/Africa/Banjul,sha256=0u-sTl8j2IyV1ywdtCgHFw9S9D3ZiiBa9akqkbny2Zc,148
+pytz/zoneinfo/Africa/Bissau,sha256=IjuxDP6EZiDHFvl_bHS6NN7sdRxLKXllooBC829poak,194
+pytz/zoneinfo/Africa/Blantyre,sha256=k_GelVHViGiuWCB1LSyTpIYSTDZEY9yclInQRY-LxoI,149
+pytz/zoneinfo/Africa/Brazzaville,sha256=z_6wKCzL1_ug5JP_hneh5abdUZeIUELkN_ladz-ESEY,235
+pytz/zoneinfo/Africa/Bujumbura,sha256=k_GelVHViGiuWCB1LSyTpIYSTDZEY9yclInQRY-LxoI,149
+pytz/zoneinfo/Africa/Cairo,sha256=Lft-GCLQhaSJm9VqUmsEFoHIS1Vhfa7pFJn9GZCpifs,2399
+pytz/zoneinfo/Africa/Casablanca,sha256=4RqVbw_F3ZucopIC2ivAJ8WDwj5wRODAB67tBpdXcgA,2429
+pytz/zoneinfo/Africa/Ceuta,sha256=Cw-2_nFDGbN8WqIsVpcauyZooWX8j3Kmx2PnC0fHut8,2052
+pytz/zoneinfo/Africa/Conakry,sha256=0u-sTl8j2IyV1ywdtCgHFw9S9D3ZiiBa9akqkbny2Zc,148
+pytz/zoneinfo/Africa/Dakar,sha256=0u-sTl8j2IyV1ywdtCgHFw9S9D3ZiiBa9akqkbny2Zc,148
+pytz/zoneinfo/Africa/Dar_es_Salaam,sha256=yJsuJTqJJqbOz37_NOS_zbf-JNr_IthHGMMN7sDqSWg,265
+pytz/zoneinfo/Africa/Djibouti,sha256=yJsuJTqJJqbOz37_NOS_zbf-JNr_IthHGMMN7sDqSWg,265
+pytz/zoneinfo/Africa/Douala,sha256=z_6wKCzL1_ug5JP_hneh5abdUZeIUELkN_ladz-ESEY,235
+pytz/zoneinfo/Africa/El_Aaiun,sha256=UWCCqQLJxd8qsTYw82kz9W1suwW5TRgnZw31sDWDz20,2295
+pytz/zoneinfo/Africa/Freetown,sha256=0u-sTl8j2IyV1ywdtCgHFw9S9D3ZiiBa9akqkbny2Zc,148
+pytz/zoneinfo/Africa/Gaborone,sha256=k_GelVHViGiuWCB1LSyTpIYSTDZEY9yclInQRY-LxoI,149
+pytz/zoneinfo/Africa/Harare,sha256=k_GelVHViGiuWCB1LSyTpIYSTDZEY9yclInQRY-LxoI,149
+pytz/zoneinfo/Africa/Johannesburg,sha256=bBvMdSZo53WFowiuhUO9C8zY6BOGViboCb-U8_49l34,246
+pytz/zoneinfo/Africa/Juba,sha256=UVnIqEPJwHLTMC-r5qZQHNv9opoYVsKdq-ta_5XUw_Q,679
+pytz/zoneinfo/Africa/Kampala,sha256=yJsuJTqJJqbOz37_NOS_zbf-JNr_IthHGMMN7sDqSWg,265
+pytz/zoneinfo/Africa/Khartoum,sha256=MYWDoJ3AcCItZdApoeOgtWWDDxquwTon5v5TOGP70-o,679
+pytz/zoneinfo/Africa/Kigali,sha256=k_GelVHViGiuWCB1LSyTpIYSTDZEY9yclInQRY-LxoI,149
+pytz/zoneinfo/Africa/Kinshasa,sha256=z_6wKCzL1_ug5JP_hneh5abdUZeIUELkN_ladz-ESEY,235
+pytz/zoneinfo/Africa/Lagos,sha256=z_6wKCzL1_ug5JP_hneh5abdUZeIUELkN_ladz-ESEY,235
+pytz/zoneinfo/Africa/Libreville,sha256=z_6wKCzL1_ug5JP_hneh5abdUZeIUELkN_ladz-ESEY,235
+pytz/zoneinfo/Africa/Lome,sha256=0u-sTl8j2IyV1ywdtCgHFw9S9D3ZiiBa9akqkbny2Zc,148
+pytz/zoneinfo/Africa/Luanda,sha256=z_6wKCzL1_ug5JP_hneh5abdUZeIUELkN_ladz-ESEY,235
+pytz/zoneinfo/Africa/Lubumbashi,sha256=k_GelVHViGiuWCB1LSyTpIYSTDZEY9yclInQRY-LxoI,149
+pytz/zoneinfo/Africa/Lusaka,sha256=k_GelVHViGiuWCB1LSyTpIYSTDZEY9yclInQRY-LxoI,149
+pytz/zoneinfo/Africa/Malabo,sha256=z_6wKCzL1_ug5JP_hneh5abdUZeIUELkN_ladz-ESEY,235
+pytz/zoneinfo/Africa/Maputo,sha256=k_GelVHViGiuWCB1LSyTpIYSTDZEY9yclInQRY-LxoI,149
+pytz/zoneinfo/Africa/Maseru,sha256=bBvMdSZo53WFowiuhUO9C8zY6BOGViboCb-U8_49l34,246
+pytz/zoneinfo/Africa/Mbabane,sha256=bBvMdSZo53WFowiuhUO9C8zY6BOGViboCb-U8_49l34,246
+pytz/zoneinfo/Africa/Mogadishu,sha256=yJsuJTqJJqbOz37_NOS_zbf-JNr_IthHGMMN7sDqSWg,265
+pytz/zoneinfo/Africa/Monrovia,sha256=-VsJW5cU4KdvfgYaQVv4lcuzmaKIVFMd42nO6RXOBdU,208
+pytz/zoneinfo/Africa/Nairobi,sha256=yJsuJTqJJqbOz37_NOS_zbf-JNr_IthHGMMN7sDqSWg,265
+pytz/zoneinfo/Africa/Ndjamena,sha256=8T3A0Zm9Gj0Bvm6rd88t3GAXKiKdGUfHlIqYlkYI0KM,199
+pytz/zoneinfo/Africa/Niamey,sha256=z_6wKCzL1_ug5JP_hneh5abdUZeIUELkN_ladz-ESEY,235
+pytz/zoneinfo/Africa/Nouakchott,sha256=0u-sTl8j2IyV1ywdtCgHFw9S9D3ZiiBa9akqkbny2Zc,148
+pytz/zoneinfo/Africa/Ouagadougou,sha256=0u-sTl8j2IyV1ywdtCgHFw9S9D3ZiiBa9akqkbny2Zc,148
+pytz/zoneinfo/Africa/Porto-Novo,sha256=z_6wKCzL1_ug5JP_hneh5abdUZeIUELkN_ladz-ESEY,235
+pytz/zoneinfo/Africa/Sao_Tome,sha256=MdjxpQ268uzJ7Zx1ZroFUtRUwqsJ6F_yY3AYV9FXw1I,254
+pytz/zoneinfo/Africa/Timbuktu,sha256=0u-sTl8j2IyV1ywdtCgHFw9S9D3ZiiBa9akqkbny2Zc,148
+pytz/zoneinfo/Africa/Tripoli,sha256=W1dptGD70T7ppGoo0fczFQeDiIp0nultLNPV66MwB2c,625
+pytz/zoneinfo/Africa/Tunis,sha256=OFVMEM4eYT2Ez0beuhEUCTSIpcFldWxsV2uEoTZIUNI,689
+pytz/zoneinfo/Africa/Windhoek,sha256=xuhvudrMH4alnVmouSTQI8YL8F_HbgsF2EQ7AZKzuHs,955
+pytz/zoneinfo/America/Adak,sha256=IB1DhwJQAKbhPJ9jHLf8zW5Dad7HIkBS-dhv64E1OlM,2356
+pytz/zoneinfo/America/Anchorage,sha256=oZA1NSPS2BWdymYpnCHFO8BlYVS-ll5KLg2Ez9CbETs,2371
+pytz/zoneinfo/America/Anguilla,sha256=hJHlV_-AGoMGUWuMpZRv9fLmghrzFHfrR9fRkcxaZJc,246
+pytz/zoneinfo/America/Antigua,sha256=hJHlV_-AGoMGUWuMpZRv9fLmghrzFHfrR9fRkcxaZJc,246
+pytz/zoneinfo/America/Araguaina,sha256=G6v9wYFZ8EB4WQfIsqRbbiiKd2b27j7Zt5dFjBbzx2o,870
+pytz/zoneinfo/America/Argentina/Buenos_Aires,sha256=JmU8lBwmy29gR6OmeytvFdMRx6ObJKnYNHmLyMmXX2M,1062
+pytz/zoneinfo/America/Argentina/Catamarca,sha256=uMCJXXGYmNESHVvj5RYBZ0McrOdE14hwm17l25MgRW0,1062
+pytz/zoneinfo/America/Argentina/ComodRivadavia,sha256=uMCJXXGYmNESHVvj5RYBZ0McrOdE14hwm17l25MgRW0,1062
+pytz/zoneinfo/America/Argentina/Cordoba,sha256=uniNihhMHnr4XK4WpwiPUnrAT0YPmvzqB6f0hRLtXvY,1062
+pytz/zoneinfo/America/Argentina/Jujuy,sha256=PGmAehypCxj0XCenCSWqylDIPbKLK0DlrwJK_24D590,1034
+pytz/zoneinfo/America/Argentina/La_Rioja,sha256=Um6XoVXhsr62ad1mWuebe6NY0ZHauBdR9tMGDgqCOHg,1076
+pytz/zoneinfo/America/Argentina/Mendoza,sha256=xcOVtvRyVYFAU90y2QYwpyQhpMLyAp7-Fxvku4kgl0c,1062
+pytz/zoneinfo/America/Argentina/Rio_Gallegos,sha256=F9ZKR4o8gLHX7QBuIjMapGIdmzJxpqwbouPgZ5MqDpY,1062
+pytz/zoneinfo/America/Argentina/Salta,sha256=h1KYrDNIapvDkYhi1PaB8WD1qWOe4vhhgDJWDCGV4jc,1034
+pytz/zoneinfo/America/Argentina/San_Juan,sha256=AI2GltA80mPNzhHxYycuEwIbO1ANXyIqBQZMpjqKqdQ,1076
+pytz/zoneinfo/America/Argentina/San_Luis,sha256=2ItGRcLVK2wx8MyJsHbIBBeAkU4B-MN5x1ZxNyZ7UJE,1088
+pytz/zoneinfo/America/Argentina/Tucuman,sha256=twO-FqtNJV8XOzWTvFQ-xnEcWCoDUHY3gpVIG0Mzbf8,1090
+pytz/zoneinfo/America/Argentina/Ushuaia,sha256=A6IbpVlY9IIPoSKMFRR9DMROdwXUSDc2HsASueOSnqo,1062
+pytz/zoneinfo/America/Aruba,sha256=hJHlV_-AGoMGUWuMpZRv9fLmghrzFHfrR9fRkcxaZJc,246
+pytz/zoneinfo/America/Asuncion,sha256=V8wwkUoNqyj0C-fUSADpU7HU8H3Qkr3jNPJ4SLsGUIc,2030
+pytz/zoneinfo/America/Atikokan,sha256=kayA_pdpMcSQ0FjIzotdcf-m1JYfbKE-qcFT8LC8zqA,182
+pytz/zoneinfo/America/Atka,sha256=IB1DhwJQAKbhPJ9jHLf8zW5Dad7HIkBS-dhv64E1OlM,2356
+pytz/zoneinfo/America/Bahia,sha256=qi7dA6FofDhLxVMmd2L8bK3HeaQnc9X-jiijwyfhs3g,1010
+pytz/zoneinfo/America/Bahia_Banderas,sha256=L6iHYbA1Us1pljllFLEIAHW4ZaZhFKoG2Zr8TT5aY38,1152
+pytz/zoneinfo/America/Barbados,sha256=ima-Qrrhazu4Qfvu2Z0-e6E-GTiYknuJBu6c2yVG9LE,436
+pytz/zoneinfo/America/Belem,sha256=aZMUgtFDdHNISpqyQRYbmS2IBD-BAS3CaJnhu6onLCY,562
+pytz/zoneinfo/America/Belize,sha256=pkfLY2KfPchbeJa1pWcXmWAwp4ZlRvxWLVezXnrbkws,1614
+pytz/zoneinfo/America/Blanc-Sablon,sha256=hJHlV_-AGoMGUWuMpZRv9fLmghrzFHfrR9fRkcxaZJc,246
+pytz/zoneinfo/America/Boa_Vista,sha256=dMtaG11kGlJrgJJgGWEDZZAmnO_HfT3L4X8pI72LLFY,618
+pytz/zoneinfo/America/Bogota,sha256=Z1ernZZGQxulE8KFWHYWcM3SV1jn2_QEc1Q0OJzHRak,232
+pytz/zoneinfo/America/Boise,sha256=7HQsNPJiUheQgFz5kVLvTnf5xhXAYaeANqDskxKz2Vs,2410
+pytz/zoneinfo/America/Buenos_Aires,sha256=JmU8lBwmy29gR6OmeytvFdMRx6ObJKnYNHmLyMmXX2M,1062
+pytz/zoneinfo/America/Cambridge_Bay,sha256=_4xRlX3WdVpEcqoT6myD7NeTCXnn9OYk_iH006bwULo,2254
+pytz/zoneinfo/America/Campo_Grande,sha256=gINiXg5i2e6Rh2Nbo2bFqhPAJL4F4cAqGnBankXTDXw,1430
+pytz/zoneinfo/America/Cancun,sha256=lI4ZtiBtxKqNHvU47vRSwc5-GDl8JOdC2A6oc9s8iIo,834
+pytz/zoneinfo/America/Caracas,sha256=mUNMFdDzZLav_ePA1ocBdmqVBierkeEszTIFpNCm5J0,250
+pytz/zoneinfo/America/Catamarca,sha256=uMCJXXGYmNESHVvj5RYBZ0McrOdE14hwm17l25MgRW0,1062
+pytz/zoneinfo/America/Cayenne,sha256=4k7Iv1woX4atqePKrcvMQD2Vk9Tmma7rW_AW_R62pCc,184
+pytz/zoneinfo/America/Cayman,sha256=kayA_pdpMcSQ0FjIzotdcf-m1JYfbKE-qcFT8LC8zqA,182
+pytz/zoneinfo/America/Chicago,sha256=_roybr6I6sIAF6cYdIxGxoRpoef153Fty48dQ6bm9oY,3592
+pytz/zoneinfo/America/Chihuahua,sha256=ZAlPSsUfT3VGp1VdibnHIf-QsdEIqHuzX15wu2P2YQk,1102
+pytz/zoneinfo/America/Ciudad_Juarez,sha256=OQstyPrMxx3nNEbzgDhq_W0mK49-ApNMK7_6p-6dJ64,1538
+pytz/zoneinfo/America/Coral_Harbour,sha256=kayA_pdpMcSQ0FjIzotdcf-m1JYfbKE-qcFT8LC8zqA,182
+pytz/zoneinfo/America/Cordoba,sha256=uniNihhMHnr4XK4WpwiPUnrAT0YPmvzqB6f0hRLtXvY,1062
+pytz/zoneinfo/America/Costa_Rica,sha256=74rYa6lrgIkyls9PkHo8SCYl9oOqiuG5S7MWdnJelP4,316
+pytz/zoneinfo/America/Creston,sha256=illz0sYuLL8lIPK0Tkou6dL0Vck_D0W_3rRTOvFYRmQ,360
+pytz/zoneinfo/America/Cuiaba,sha256=GRJqkhRXNsOUcgjZddQxRIJdRYaw9pM_YLWbun88dkg,1402
+pytz/zoneinfo/America/Curacao,sha256=hJHlV_-AGoMGUWuMpZRv9fLmghrzFHfrR9fRkcxaZJc,246
+pytz/zoneinfo/America/Danmarkshavn,sha256=YRZAfUCoVtaL1L-MYMYMH1wyOaVQnfUo_gFnvMXSuzw,698
+pytz/zoneinfo/America/Dawson,sha256=rAHhyuMuyjf_eyA2SBG76MRBf_fj_xi5FAuiWVQgJhw,1614
+pytz/zoneinfo/America/Dawson_Creek,sha256=aJXCyP4j3ggE4wGCN-LrS9hpD_5zWHzQTeSAKTWEPUM,1050
+pytz/zoneinfo/America/Denver,sha256=MugZwApDs8NI9TnXANQlUE8guNBowWQY0m-ptpPndck,2460
+pytz/zoneinfo/America/Detroit,sha256=hecz8yqY2Cj5B61G3gLZdAVZvRgK9l0P90c_gN-uD5g,2230
+pytz/zoneinfo/America/Dominica,sha256=hJHlV_-AGoMGUWuMpZRv9fLmghrzFHfrR9fRkcxaZJc,246
+pytz/zoneinfo/America/Edmonton,sha256=-TkIfc3QlvaCf0p8COZ43Y1HRBAl-nARUi-JdXeK1vE,2332
+pytz/zoneinfo/America/Eirunepe,sha256=j5eExkjFaqtC-D8XK0rGzoF9yEgbSlTbPqVG9WKhEa8,642
+pytz/zoneinfo/America/El_Salvador,sha256=gvGN8Lkj-sGm2_rs8OUjAMf1oMtKp2Xes6UfWT0WqgU,224
+pytz/zoneinfo/America/Ensenada,sha256=57-Q9LSTNuTidz-lOTwDysmlCoeFUXSecvVVqNWburQ,2374
+pytz/zoneinfo/America/Fort_Nelson,sha256=erfODr3DrSpz65kAdO7Ts2dGbZxvddEP6gx4BX3y2J0,2240
+pytz/zoneinfo/America/Fort_Wayne,sha256=kNKy9Kj9ICsiYYfCCbAggzMA7exf-GpGPMxoXocHUyw,1682
+pytz/zoneinfo/America/Fortaleza,sha256=rjiSB0q1cBuMDOM9orW_uwe5UOLBwTlfjFotwOYe1mU,702
+pytz/zoneinfo/America/Glace_Bay,sha256=G8DGLGCapH_aYCF_OhaL5Qonf7FOAgAPwelO5htCWBc,2192
+pytz/zoneinfo/America/Godthab,sha256=KGXrMN-YkYpVCgLdpcfwMFQ77EsRAGsjUCG3yAUvVfw,1889
+pytz/zoneinfo/America/Goose_Bay,sha256=JgaLueghSvX2g725FOfIgpgvsqxZGykWOhAZWGpQZRY,3210
+pytz/zoneinfo/America/Grand_Turk,sha256=4YOFEPK60Bel2_fCsY6vSZxUcMJKjiKtyOf_Q0khEwU,1834
+pytz/zoneinfo/America/Grenada,sha256=hJHlV_-AGoMGUWuMpZRv9fLmghrzFHfrR9fRkcxaZJc,246
+pytz/zoneinfo/America/Guadeloupe,sha256=hJHlV_-AGoMGUWuMpZRv9fLmghrzFHfrR9fRkcxaZJc,246
+pytz/zoneinfo/America/Guatemala,sha256=dugUgCd6QY52yHkHuUP4jRWzo5x439IQigaYCvEF46Q,280
+pytz/zoneinfo/America/Guayaquil,sha256=j2UuIo-4RgSOlTNfu77mhZ92waNTeKFSvmoVemJooT0,232
+pytz/zoneinfo/America/Guyana,sha256=R0bOvCRDC8SRIexmhsduPdHbbRPwI2GviD9otExiUrk,248
+pytz/zoneinfo/America/Halifax,sha256=TZpmc5PwWoLfTfQoQ_b3U17BE2iVKSeNkR0Ho8mbTn8,3424
+pytz/zoneinfo/America/Havana,sha256=HUQeAuKBsEkI5SLZjqynXICOUVOajkKzKH5r-Ov5Odc,2416
+pytz/zoneinfo/America/Hermosillo,sha256=WnlVBpVBG8ONnz0wpxteXmuvSzOGwSlAisvDd1GtKYA,456
+pytz/zoneinfo/America/Indiana/Indianapolis,sha256=kNKy9Kj9ICsiYYfCCbAggzMA7exf-GpGPMxoXocHUyw,1682
+pytz/zoneinfo/America/Indiana/Knox,sha256=CsvZ5BKw2qVav3x_F8CU9taJdDk7jX41Cfsqms6jXV8,2444
+pytz/zoneinfo/America/Indiana/Marengo,sha256=f3tQ-lgMSUA7nvn64pXhKtJL7mWzGajoCega5MEJSbI,1738
+pytz/zoneinfo/America/Indiana/Petersburg,sha256=A88OHuM0Rg3iMLHjKgXq_d2jZCdVSytUQs-9W0KcFyQ,1920
+pytz/zoneinfo/America/Indiana/Tell_City,sha256=4dWqAr9Y2BXfL4pAQk-81c3gGl2cNdHXOD7_wJhhhn8,1700
+pytz/zoneinfo/America/Indiana/Vevay,sha256=H7VR2G-_sD_C5Rm4P3g1iRC1FWCPg4m0MGD3P1PLzsk,1430
+pytz/zoneinfo/America/Indiana/Vincennes,sha256=62mAxT7APFCaoygflnEzdOpe-fuW1yObI6m6EUUcS7A,1710
+pytz/zoneinfo/America/Indiana/Winamac,sha256=aZGM2jR8CH9BHSUq7XygiweDd6dorXLPXg246XsbR6s,1794
+pytz/zoneinfo/America/Indianapolis,sha256=kNKy9Kj9ICsiYYfCCbAggzMA7exf-GpGPMxoXocHUyw,1682
+pytz/zoneinfo/America/Inuvik,sha256=6J-mapDnrk9A1LtswoE34tqSy_ufedcEBNxixkrEjIo,2074
+pytz/zoneinfo/America/Iqaluit,sha256=feOnxAN0N0r-M1qlkrA4JMyawoc0tqae0iiBCPDAs4k,2202
+pytz/zoneinfo/America/Jamaica,sha256=wlagieUPRf5-beie-h7QsONbNzjGsm8vMs8uf28pw28,482
+pytz/zoneinfo/America/Jujuy,sha256=PGmAehypCxj0XCenCSWqylDIPbKLK0DlrwJK_24D590,1034
+pytz/zoneinfo/America/Juneau,sha256=k7hxb0aGRnfnE-DBi3LkcjAzRPyAf0_Hw0vVFfjGeb0,2353
+pytz/zoneinfo/America/Kentucky/Louisville,sha256=tP072xV_n_vIQjxxcJ77AGeGj6yL1KPpn3fwids9g1U,2788
+pytz/zoneinfo/America/Kentucky/Monticello,sha256=LtdyCo85BrXQs6rlH61Ym-8KqWHH6PwAOjD0QxhIdzM,2368
+pytz/zoneinfo/America/Knox_IN,sha256=CsvZ5BKw2qVav3x_F8CU9taJdDk7jX41Cfsqms6jXV8,2444
+pytz/zoneinfo/America/Kralendijk,sha256=hJHlV_-AGoMGUWuMpZRv9fLmghrzFHfrR9fRkcxaZJc,246
+pytz/zoneinfo/America/La_Paz,sha256=hqfD8LQHupdZhji2e93_9pOQAT-R7muzzjP0nyfbFXY,218
+pytz/zoneinfo/America/Lima,sha256=HHgTnDUnCZzibvL0MrG8qyOuvjmYYw3e3R5VbnxMZs8,392
+pytz/zoneinfo/America/Los_Angeles,sha256=aJd7ua1tGG_vxser02AQpm4wAI3LLTdgh6QcSYYecmg,2852
+pytz/zoneinfo/America/Louisville,sha256=tP072xV_n_vIQjxxcJ77AGeGj6yL1KPpn3fwids9g1U,2788
+pytz/zoneinfo/America/Lower_Princes,sha256=hJHlV_-AGoMGUWuMpZRv9fLmghrzFHfrR9fRkcxaZJc,246
+pytz/zoneinfo/America/Maceio,sha256=3R5DlSe32kQDmoSVIWpcyk2o7qohr-rliwqDSGFIMyQ,730
+pytz/zoneinfo/America/Managua,sha256=xBzF01AHn2E2fD8Qdy-DHFe36UqoeNpKPfChduBKWdk,430
+pytz/zoneinfo/America/Manaus,sha256=F6RLOOeOi9lymZiQmQ9pR8tFpPZ6EguNdPfOc6BhXDE,590
+pytz/zoneinfo/America/Marigot,sha256=hJHlV_-AGoMGUWuMpZRv9fLmghrzFHfrR9fRkcxaZJc,246
+pytz/zoneinfo/America/Martinique,sha256=fMs80kOU2YFvC0f9y2eje97JeAtTYBamXrnlTunNLzQ,232
+pytz/zoneinfo/America/Matamoros,sha256=fq-PqdmZrQ98UsFmHA9ivjBZv5GEBRTOuLQ5Cu5ajW8,1418
+pytz/zoneinfo/America/Mazatlan,sha256=RQQVwlEVHRp2X-c_0hJ46y54abTlqUuLkyrUUicyc5g,1128
+pytz/zoneinfo/America/Mendoza,sha256=xcOVtvRyVYFAU90y2QYwpyQhpMLyAp7-Fxvku4kgl0c,1062
+pytz/zoneinfo/America/Menominee,sha256=Arv9WLbfhNcpRsUjHDU757BEdwlp08Gt30AixG3gZ04,2274
+pytz/zoneinfo/America/Merida,sha256=ORJCGiO2mXG-kk5ZZGro1MNuKqRnJx6HJlvoezTMM90,1004
+pytz/zoneinfo/America/Metlakatla,sha256=twmieGTVY2V-U8nFxqvx7asYv8GVjeWdLtrOI7UApVI,1423
+pytz/zoneinfo/America/Mexico_City,sha256=A5MlfDUZ4O1-jMTRt0WPem7qqcW0Nrslls1hlc8C4-Q,1222
+pytz/zoneinfo/America/Miquelon,sha256=E9KCH4ZHWe40w_3nZR1EFF4LVpEuGWRdKDm5UUgYydw,1652
+pytz/zoneinfo/America/Moncton,sha256=Wmv-bk9aKKcWWzOpc1UFu67HOfwaIk2Wmh3LgqGctys,3154
+pytz/zoneinfo/America/Monterrey,sha256=vKBLVjG0bNVDI07M4WwOVv2KbrYJVNTLmc19iM2CvTU,980
+pytz/zoneinfo/America/Montevideo,sha256=dQEBE4mjZPtyRjKXK6Z-bMHJdFqpwhIzxDH4x04rKYk,1496
+pytz/zoneinfo/America/Montreal,sha256=ggOSzbHkmfgu9wTQzP0MUKsrKMbgveuAeThh1eFl1a0,3494
+pytz/zoneinfo/America/Montserrat,sha256=hJHlV_-AGoMGUWuMpZRv9fLmghrzFHfrR9fRkcxaZJc,246
+pytz/zoneinfo/America/Nassau,sha256=ggOSzbHkmfgu9wTQzP0MUKsrKMbgveuAeThh1eFl1a0,3494
+pytz/zoneinfo/America/New_York,sha256=6e0H177gx2qdRC0JHvHwFmj-58TyYBTAqGixn-bBipU,3552
+pytz/zoneinfo/America/Nipigon,sha256=ggOSzbHkmfgu9wTQzP0MUKsrKMbgveuAeThh1eFl1a0,3494
+pytz/zoneinfo/America/Nome,sha256=2izM3-P-PqJ9za6MdhzFfMvPFNq7Gim69tAvEwPeY2s,2367
+pytz/zoneinfo/America/Noronha,sha256=feeRAijQqKylZgqe84nKhsFLycT5zIBm7mLIvdyGw4w,702
+pytz/zoneinfo/America/North_Dakota/Beulah,sha256=qtgbqNu8M3AkHF2n-_oSps1pYT4SxgclbkkPKbXaBHs,2396
+pytz/zoneinfo/America/North_Dakota/Center,sha256=9ZWbK9YKkquULyBUFS3Lr_idxbt7V7y4W4EO0Kn20sw,2396
+pytz/zoneinfo/America/North_Dakota/New_Salem,sha256=DH_bsQfuUnK2obdb06KgisO4XLqht12BXdrgUsZZveg,2396
+pytz/zoneinfo/America/Nuuk,sha256=KGXrMN-YkYpVCgLdpcfwMFQ77EsRAGsjUCG3yAUvVfw,1889
+pytz/zoneinfo/America/Ojinaga,sha256=9catgEQ2SD7qfuvTMxs15Cdd9SKaUy-svEzPBFw2Q3Q,1524
+pytz/zoneinfo/America/Panama,sha256=kayA_pdpMcSQ0FjIzotdcf-m1JYfbKE-qcFT8LC8zqA,182
+pytz/zoneinfo/America/Pangnirtung,sha256=feOnxAN0N0r-M1qlkrA4JMyawoc0tqae0iiBCPDAs4k,2202
+pytz/zoneinfo/America/Paramaribo,sha256=Z7UZvNlgd-qEUHjEPYXIkLNTgjMcCzk9EfUUEmUyd7M,248
+pytz/zoneinfo/America/Phoenix,sha256=illz0sYuLL8lIPK0Tkou6dL0Vck_D0W_3rRTOvFYRmQ,360
+pytz/zoneinfo/America/Port-au-Prince,sha256=09ZAJd4IOiMpfdpUuF1U44R_hRt6BvpAkFXOnYO9yOM,1434
+pytz/zoneinfo/America/Port_of_Spain,sha256=hJHlV_-AGoMGUWuMpZRv9fLmghrzFHfrR9fRkcxaZJc,246
+pytz/zoneinfo/America/Porto_Acre,sha256=0gpJUl46hQbp0P6Xj1S0NArIWeAryuuDXjsldvB5GHE,614
+pytz/zoneinfo/America/Porto_Velho,sha256=uSMV2hZWj-VyBhFBwC950wcThfN3jq6KlycESmQTLOA,562
+pytz/zoneinfo/America/Puerto_Rico,sha256=hJHlV_-AGoMGUWuMpZRv9fLmghrzFHfrR9fRkcxaZJc,246
+pytz/zoneinfo/America/Punta_Arenas,sha256=tR5uIf1351AWFqrqNtmXnhQWnKREmJaZqKBzaWRVMTQ,1902
+pytz/zoneinfo/America/Rainy_River,sha256=7P-_YQrneFcon7QKSTOnkiGjEppFDn3Z48MJ1qq8VBw,2868
+pytz/zoneinfo/America/Rankin_Inlet,sha256=nXgqjL3O2BV0em-Xk8qVRRZb_X0yQmHE6vmSSvI9Kzc,2066
+pytz/zoneinfo/America/Recife,sha256=bJ_HE0-JFio4-owpZ0pLO8U3ai0fiGu8QHL0DexLiLc,702
+pytz/zoneinfo/America/Regina,sha256=yjqT08pHbICYe83H8JmtaDBvCFqRv7Tfze3Y8xuXukw,980
+pytz/zoneinfo/America/Resolute,sha256=CnMU2dBI-63vt8-J0Q1Ropx-8b9pRCLjhvrycMIedGg,2066
+pytz/zoneinfo/America/Rio_Branco,sha256=0gpJUl46hQbp0P6Xj1S0NArIWeAryuuDXjsldvB5GHE,614
+pytz/zoneinfo/America/Rosario,sha256=uniNihhMHnr4XK4WpwiPUnrAT0YPmvzqB6f0hRLtXvY,1062
+pytz/zoneinfo/America/Santa_Isabel,sha256=57-Q9LSTNuTidz-lOTwDysmlCoeFUXSecvVVqNWburQ,2374
+pytz/zoneinfo/America/Santarem,sha256=VmZP9S5pPucFxyqAOV908EmWXQZvgCgWLmlJJTUl0LE,588
+pytz/zoneinfo/America/Santiago,sha256=0CDw13dCMUsoquMupoJgupkzAUNhDK6E0lVxURA7osA,2515
+pytz/zoneinfo/America/Santo_Domingo,sha256=DKtaEj8fQ92ybITTWU4Bm160S9pzJmUVbjaWRnenxU4,458
+pytz/zoneinfo/America/Sao_Paulo,sha256=BMBnRO4_4HjvO4t3njjrMGZr-ZPmegkvyvL8KPY6ZM4,1430
+pytz/zoneinfo/America/Scoresbysund,sha256=K-qkiMCCFgOe8ccPMABA-lDjc9vb6wpluBOCVfiBdLI,1935
+pytz/zoneinfo/America/Shiprock,sha256=MugZwApDs8NI9TnXANQlUE8guNBowWQY0m-ptpPndck,2460
+pytz/zoneinfo/America/Sitka,sha256=aiS7Fk37hZpzZ9VkeJQeF-BqTLRC1QOTCgMAJwT8UxA,2329
+pytz/zoneinfo/America/St_Barthelemy,sha256=hJHlV_-AGoMGUWuMpZRv9fLmghrzFHfrR9fRkcxaZJc,246
+pytz/zoneinfo/America/St_Johns,sha256=r1-17uKv27eZ3JsVkw_DLZQbo6wvjuuVu7C2pDsmOgI,3655
+pytz/zoneinfo/America/St_Kitts,sha256=hJHlV_-AGoMGUWuMpZRv9fLmghrzFHfrR9fRkcxaZJc,246
+pytz/zoneinfo/America/St_Lucia,sha256=hJHlV_-AGoMGUWuMpZRv9fLmghrzFHfrR9fRkcxaZJc,246
+pytz/zoneinfo/America/St_Thomas,sha256=hJHlV_-AGoMGUWuMpZRv9fLmghrzFHfrR9fRkcxaZJc,246
+pytz/zoneinfo/America/St_Vincent,sha256=hJHlV_-AGoMGUWuMpZRv9fLmghrzFHfrR9fRkcxaZJc,246
+pytz/zoneinfo/America/Swift_Current,sha256=RRKOF7vZC8VvYxD8PP4J1_hUPayKBP7Lu80avRkfPDY,560
+pytz/zoneinfo/America/Tegucigalpa,sha256=EzOz7ntTlreMq69JZ2CcAb8Ps98V9bUMN480tpPIyw4,252
+pytz/zoneinfo/America/Thule,sha256=8xuPRaZU8RgO5ECqFYHYmnHioc81sBOailkVu8Y02i8,1502
+pytz/zoneinfo/America/Thunder_Bay,sha256=ggOSzbHkmfgu9wTQzP0MUKsrKMbgveuAeThh1eFl1a0,3494
+pytz/zoneinfo/America/Tijuana,sha256=57-Q9LSTNuTidz-lOTwDysmlCoeFUXSecvVVqNWburQ,2374
+pytz/zoneinfo/America/Toronto,sha256=ggOSzbHkmfgu9wTQzP0MUKsrKMbgveuAeThh1eFl1a0,3494
+pytz/zoneinfo/America/Tortola,sha256=hJHlV_-AGoMGUWuMpZRv9fLmghrzFHfrR9fRkcxaZJc,246
+pytz/zoneinfo/America/Vancouver,sha256=sknKH0jSPWam-DHfM35qXs8Nam7d5TFlkUI9Sgxryyg,2892
+pytz/zoneinfo/America/Virgin,sha256=hJHlV_-AGoMGUWuMpZRv9fLmghrzFHfrR9fRkcxaZJc,246
+pytz/zoneinfo/America/Whitehorse,sha256=TrR6PCnYG-mSClBMohqlP8qnYhXMUsydI-L-quXFxyM,1614
+pytz/zoneinfo/America/Winnipeg,sha256=7P-_YQrneFcon7QKSTOnkiGjEppFDn3Z48MJ1qq8VBw,2868
+pytz/zoneinfo/America/Yakutat,sha256=tFwnKbvwhyyn4LNTAn5ye_JWDdxjCerNDt7oOwUwO2M,2305
+pytz/zoneinfo/America/Yellowknife,sha256=-TkIfc3QlvaCf0p8COZ43Y1HRBAl-nARUi-JdXeK1vE,2332
+pytz/zoneinfo/Antarctica/Casey,sha256=VeaLOxTfDyjfGXq5Ul95JEIMXNWHSW-0N3yOoS7VK-c,423
+pytz/zoneinfo/Antarctica/Davis,sha256=XB12dEq0Q-3XkzBNTNC7G1fzH-WxxctIuZqI3zp8ypI,283
+pytz/zoneinfo/Antarctica/DumontDUrville,sha256=nB36HBWZTdh3TlP0DLFNz1KRQ0aHIfHbp7LC4Urp9fA,172
+pytz/zoneinfo/Antarctica/Macquarie,sha256=ie7RlaU8RHTorVVj-MX8StKMqx_oXf4UH2PUqpzcwe0,2260
+pytz/zoneinfo/Antarctica/Mawson,sha256=EjIFbqRdr2ZJBaI1XvoWRptnnW1LFrlhydxDDuIQjSI,185
+pytz/zoneinfo/Antarctica/McMurdo,sha256=gADjoyPo_QISQU6UJrAgcHp3HDaMoOFRdH-d23uBSyc,2437
+pytz/zoneinfo/Antarctica/Palmer,sha256=HTZY0M8td7oUx5REPgRCHuqKg5V3fjJEi4lYBNL4Etg,1404
+pytz/zoneinfo/Antarctica/Rothera,sha256=_9NY-f8vkozQYrjbUHP5YjcICg0-LuyA9PnIeK123RU,150
+pytz/zoneinfo/Antarctica/South_Pole,sha256=gADjoyPo_QISQU6UJrAgcHp3HDaMoOFRdH-d23uBSyc,2437
+pytz/zoneinfo/Antarctica/Syowa,sha256=oCKH7uafN8R1o-ijXGoT5U1JZxwvoLzJu_2Cqyi2hUM,151
+pytz/zoneinfo/Antarctica/Troll,sha256=fjcYppwr1FnjEssee-RLgGOANzoUyfjse-RGK46PR2E,1148
+pytz/zoneinfo/Antarctica/Vostok,sha256=KfftwdzK6PkMDz0d-D3z4HKIBgY9KqsqHnTnqsPMrUg,213
+pytz/zoneinfo/Arctic/Longyearbyen,sha256=XuR19xoPwaMvrrhJ-MOcbnqmbW1B7HQrl7OnQ2s7BwE,2298
+pytz/zoneinfo/Asia/Aden,sha256=oCKH7uafN8R1o-ijXGoT5U1JZxwvoLzJu_2Cqyi2hUM,151
+pytz/zoneinfo/Asia/Almaty,sha256=EEs-tB6Fo-eyUID5WZqe2KLIEQgKa_qZZXmwYH9BFCc,983
+pytz/zoneinfo/Asia/Amman,sha256=Qv4cXXw7KBQWE882cgj0kjQ3wh1vpV1orJ2v2Jjxr2U,1433
+pytz/zoneinfo/Asia/Anadyr,sha256=WqKnHo5IHSWZ08d2sS5ytHtv0MQMoczP3W9zbDDrbYU,1174
+pytz/zoneinfo/Asia/Aqtau,sha256=4n654FZtDssXSfhQszjZG5OmtbE2zo1KbiWcYrFJg00,969
+pytz/zoneinfo/Asia/Aqtobe,sha256=1oFHTb-ybcTqLXm0r1ZOVgdYMTHlGoNs-Pgvux50d3E,997
+pytz/zoneinfo/Asia/Ashgabat,sha256=-sfGnRumio7_Bs8w9YH4xRDWgjB3wBeW7c0C56Qqk64,605
+pytz/zoneinfo/Asia/Ashkhabad,sha256=-sfGnRumio7_Bs8w9YH4xRDWgjB3wBeW7c0C56Qqk64,605
+pytz/zoneinfo/Asia/Atyrau,sha256=_U8COUIE9nG_HKddZE1Q0sPuz3rMwfjwmfnVDY_vSmg,977
+pytz/zoneinfo/Asia/Baghdad,sha256=S-plKI4zCLqI0idGABEk3oRTazNyrIj2T98-EtWtZD8,969
+pytz/zoneinfo/Asia/Bahrain,sha256=wklGY3WPGp-z1OUwb_KOHzRTwBndt1RfDg9Uttt36G4,185
+pytz/zoneinfo/Asia/Baku,sha256=6_hq98SGG0j0JA8qYx96WcIMZSLW4w460QXh_OM_ccg,1213
+pytz/zoneinfo/Asia/Bangkok,sha256=hf_5PVegQcFSS60CjS80C7h-TGOrfQ4ncm83N8VmZkk,185
+pytz/zoneinfo/Asia/Barnaul,sha256=3zeUimLTMrIZE0vX6XHFvB3MoqExoVbE5CSm6GV0zf0,1207
+pytz/zoneinfo/Asia/Beirut,sha256=_Z_2ZAg_iL9vU51JDB8CB04uXBDrf1kLIis-JnXaS2o,2154
+pytz/zoneinfo/Asia/Bishkek,sha256=IOoUyjABILCkXu1rjCIqSwAufRYFklc5YAC4jdhVw6Q,969
+pytz/zoneinfo/Asia/Brunei,sha256=D5qtyWJ_SM8bTQeJJIYhqqojxlVKbrFC1EYMDU9GzXQ,469
+pytz/zoneinfo/Asia/Calcutta,sha256=6Qw0EDbLcgMgDik8s7UTJn4QSjmllPNeGVJU5rwKF88,285
+pytz/zoneinfo/Asia/Chita,sha256=LbSlS23swFkANUScg8zkNR0imANWNfOIaYd39HbLdIQ,1207
+pytz/zoneinfo/Asia/Choibalsan,sha256=atm7FmPwZGsftLM7vS1LltjcdaDC-DSg1cIdP2MF17I,935
+pytz/zoneinfo/Asia/Chongqing,sha256=ZP_C5DqUQ1oEPAQNHTr36S0DGtx453N68YYbqk7u8-Y,561
+pytz/zoneinfo/Asia/Chungking,sha256=ZP_C5DqUQ1oEPAQNHTr36S0DGtx453N68YYbqk7u8-Y,561
+pytz/zoneinfo/Asia/Colombo,sha256=w52L7bgT4m5hcgRuevIPY83xytfkBmkLhnKMwp16KsY,358
+pytz/zoneinfo/Asia/Dacca,sha256=-xulJ2KVhvKp6rlZLMydpw7oXVirk-riEH-181xPE54,323
+pytz/zoneinfo/Asia/Damascus,sha256=EthGheaHWmy5IrLCc9NmM3jvASQFHt8TsBF07I1tgbg,1873
+pytz/zoneinfo/Asia/Dhaka,sha256=-xulJ2KVhvKp6rlZLMydpw7oXVirk-riEH-181xPE54,323
+pytz/zoneinfo/Asia/Dili,sha256=0mUs0Utk-uW9deZV3cBUTpfWMgFvl0DyN29JuKvKMyw,213
+pytz/zoneinfo/Asia/Dubai,sha256=pmdhPhaJRwKwONvxiZNGeFSICjlWzyY9JlFHv-H9upY,151
+pytz/zoneinfo/Asia/Dushanbe,sha256=koYnnYWuFsBXd1vJfZsGdpwnbFHEwvkGBmSrrx3KIss,577
+pytz/zoneinfo/Asia/Famagusta,sha256=CFrcygd8ude5x6OEtfM_Dw0KYHoxpPPzq46KoHVxjjc,2028
+pytz/zoneinfo/Asia/Gaza,sha256=i1uMbalRsjOedIJ4XOBsAEyhap2mj5HZ2qUsfzy9apU,3862
+pytz/zoneinfo/Asia/Harbin,sha256=ZP_C5DqUQ1oEPAQNHTr36S0DGtx453N68YYbqk7u8-Y,561
+pytz/zoneinfo/Asia/Hebron,sha256=q_jxV4FQ4N2pYR5QptZLSMCG9fbB5DpeMm1T0rREERw,3890
+pytz/zoneinfo/Asia/Ho_Chi_Minh,sha256=bvC8fvT-K9BpW4a3g4js-HJsIHc9YNaYKwAw7Vbm9Hs,337
+pytz/zoneinfo/Asia/Hong_Kong,sha256=al_O4kPlq5JpgkLYjEaZzrcgiiLul9NC0R5B69JVWhc,1233
+pytz/zoneinfo/Asia/Hovd,sha256=Zn4PLGlD-URJDsbChor5bqWTzuAil2tbrGJW0j5TLbs,877
+pytz/zoneinfo/Asia/Irkutsk,sha256=IVuoXCwdeI-KIUfFkEt6yBjqYP3V9GTrF-_WLnffFzk,1229
+pytz/zoneinfo/Asia/Istanbul,sha256=Jk4wjndDta_uLWc8W1dWdjbavJJbsL5ROTmZboVnGKU,1933
+pytz/zoneinfo/Asia/Jakarta,sha256=TvEzBvSzfzFCdOsMAZ0QgR95JA5xf3kAZONhy5gEXRE,383
+pytz/zoneinfo/Asia/Jayapura,sha256=ihzUd-L8HUVqG-Na10MyPE-YYwjVFj-xerqjTN4EJZs,221
+pytz/zoneinfo/Asia/Jerusalem,sha256=JUuWQmW5Tha0pJjw61Q5aN7CX0z4D7ops9OOSnda6Dc,2388
+pytz/zoneinfo/Asia/Kabul,sha256=JZEbo8bSj_L7HnXUm2gAUlNlCvJlRJhFkSHCg5o3ggk,194
+pytz/zoneinfo/Asia/Kamchatka,sha256=KY1PlJvRSNkY_5hyJBxj5DDweeYVQaBK05ZgL3kdcCY,1152
+pytz/zoneinfo/Asia/Karachi,sha256=iB-mWMTXUyfBwAkZdz8_UmEw0xsgxIub-KNI7akzhkk,379
+pytz/zoneinfo/Asia/Kashgar,sha256=F1ZOdZZDsVHwDJinksR-hjcqPzqOljvdreZIWFulJxY,151
+pytz/zoneinfo/Asia/Kathmandu,sha256=_RsfeSWbCr8kM4YRJi7Xv6hAEiHW14IFhsXsfhbPjoM,198
+pytz/zoneinfo/Asia/Katmandu,sha256=_RsfeSWbCr8kM4YRJi7Xv6hAEiHW14IFhsXsfhbPjoM,198
+pytz/zoneinfo/Asia/Khandyga,sha256=bKfmw6k5qYDQsEHG3Mv-VYis3YhCeV7qijDxfxQNn_g,1257
+pytz/zoneinfo/Asia/Kolkata,sha256=6Qw0EDbLcgMgDik8s7UTJn4QSjmllPNeGVJU5rwKF88,285
+pytz/zoneinfo/Asia/Krasnoyarsk,sha256=D5KE_1wWSD2YdixDy8n3LBNaAlE1_y3TWXw6NrxFKKA,1193
+pytz/zoneinfo/Asia/Kuala_Lumpur,sha256=XmeVImeqcJ8hJzm7TjAti1nWJAxawOqq7jIzDnHX2hI,401
+pytz/zoneinfo/Asia/Kuching,sha256=D5qtyWJ_SM8bTQeJJIYhqqojxlVKbrFC1EYMDU9GzXQ,469
+pytz/zoneinfo/Asia/Kuwait,sha256=oCKH7uafN8R1o-ijXGoT5U1JZxwvoLzJu_2Cqyi2hUM,151
+pytz/zoneinfo/Asia/Macao,sha256=MvAkRyRsrA2r052ItlyF5bh2FheRjI0jPwg0uIiH2Yk,1227
+pytz/zoneinfo/Asia/Macau,sha256=MvAkRyRsrA2r052ItlyF5bh2FheRjI0jPwg0uIiH2Yk,1227
+pytz/zoneinfo/Asia/Magadan,sha256=HccEEXBQvMmLoC_JE-zP_MlLAZ1WmNLQLfM3tJt55M4,1208
+pytz/zoneinfo/Asia/Makassar,sha256=OhJtCqSTEU-u5n0opBVO5Bu-wQzcYPy9S_6aAhJXgOw,254
+pytz/zoneinfo/Asia/Manila,sha256=ujfq0kl1EhxcYSOrG-FS750aNaYUt1TT4bFuK4EcL_c,328
+pytz/zoneinfo/Asia/Muscat,sha256=pmdhPhaJRwKwONvxiZNGeFSICjlWzyY9JlFHv-H9upY,151
+pytz/zoneinfo/Asia/Nicosia,sha256=0Unm0IFT7HyGeQ7F3vTa_-klfysCgrulqFO6BD1plZU,2002
+pytz/zoneinfo/Asia/Novokuznetsk,sha256=pyxxtSUtYDeVmFk0Cg-F33laZS0iKtde9_GJnL9f0KM,1151
+pytz/zoneinfo/Asia/Novosibirsk,sha256=5K2-Gx15ThlHfolyW85S5zREtAcMjeHBYWK4E8x2LdY,1207
+pytz/zoneinfo/Asia/Omsk,sha256=HyXIWItJXBKVHUzWcQPi1Mmd6ZLmZk-QhRUo9Kv2XOI,1193
+pytz/zoneinfo/Asia/Oral,sha256=WQT4qRmC9RI_ll8zB9FvkAL8ezGb8qoqWd75GTlC7kQ,991
+pytz/zoneinfo/Asia/Phnom_Penh,sha256=hf_5PVegQcFSS60CjS80C7h-TGOrfQ4ncm83N8VmZkk,185
+pytz/zoneinfo/Asia/Pontianak,sha256=inOXwuKtjKv1z_eliPZSIqjSt6whtuxhPeG1YpjU_BQ,353
+pytz/zoneinfo/Asia/Pyongyang,sha256=_-g3GnDAtfDX4XAktXH9jFouLUDmOovnjoOfvRpUDsE,237
+pytz/zoneinfo/Asia/Qatar,sha256=wklGY3WPGp-z1OUwb_KOHzRTwBndt1RfDg9Uttt36G4,185
+pytz/zoneinfo/Asia/Qostanay,sha256=Hlgrz7n7Ohgju_zXjTr8mOhzjUW9CzDInSNXLm2NwA0,997
+pytz/zoneinfo/Asia/Qyzylorda,sha256=JZLNN6NuLkqaWEeVaCZiW_gL6BrIFL9lr65iK7myVPg,1011
+pytz/zoneinfo/Asia/Rangoon,sha256=_YHASq4Z5YcUILIdhEzg27CGLzarUHPDHs1Dj0QgNGM,254
+pytz/zoneinfo/Asia/Riyadh,sha256=oCKH7uafN8R1o-ijXGoT5U1JZxwvoLzJu_2Cqyi2hUM,151
+pytz/zoneinfo/Asia/Saigon,sha256=bvC8fvT-K9BpW4a3g4js-HJsIHc9YNaYKwAw7Vbm9Hs,337
+pytz/zoneinfo/Asia/Sakhalin,sha256=xzAor82ihAe-yXEwC6OWiMzo9b6Z-oQl39NIkU5Hhbs,1188
+pytz/zoneinfo/Asia/Samarkand,sha256=zJKSRt3lEvd6Qvg9b49QAyO4cTJyVnTKyPYcyudpHxk,563
+pytz/zoneinfo/Asia/Seoul,sha256=LI9LsV3XcJC0l-KoQf8zI-y7rk-du57erS-N2Ptdi7Q,617
+pytz/zoneinfo/Asia/Shanghai,sha256=ZP_C5DqUQ1oEPAQNHTr36S0DGtx453N68YYbqk7u8-Y,561
+pytz/zoneinfo/Asia/Singapore,sha256=XmeVImeqcJ8hJzm7TjAti1nWJAxawOqq7jIzDnHX2hI,401
+pytz/zoneinfo/Asia/Srednekolymsk,sha256=efaaT8iFHrcccp-VZKNMvtTuPLNjG5V9JH5KKHhH3SI,1194
+pytz/zoneinfo/Asia/Taipei,sha256=DMmQwOpPql25ue3Nf8vAKKT4em06D1Z9rHbLIitxixk,761
+pytz/zoneinfo/Asia/Tashkent,sha256=apRPy251fSRy_ixsg3BOZNmUbHdO86P5-PdgC1Xws7U,577
+pytz/zoneinfo/Asia/Tbilisi,sha256=zQ-2bVq5_USUSbwN6q0qvWjD-HXkKaH4ifMVq1lEeIM,1021
+pytz/zoneinfo/Asia/Tehran,sha256=LQMch2TMA4wI23SQzoIrlZh0_KceXQegurwxCZ5YDlY,1248
+pytz/zoneinfo/Asia/Tel_Aviv,sha256=JUuWQmW5Tha0pJjw61Q5aN7CX0z4D7ops9OOSnda6Dc,2388
+pytz/zoneinfo/Asia/Thimbu,sha256=G2nTQVEMmKlWt0B74_fUAL7KQ3YAu__J6HciiYs2IyU,189
+pytz/zoneinfo/Asia/Thimphu,sha256=G2nTQVEMmKlWt0B74_fUAL7KQ3YAu__J6HciiYs2IyU,189
+pytz/zoneinfo/Asia/Tokyo,sha256=oCueZgRNxcNcX3ZGdif9y6Su4cyVhga4XHdwlcrYLOs,309
+pytz/zoneinfo/Asia/Tomsk,sha256=cr0ULZgWBnQfzDiJeYmqpA7Xo5QRzurvrHsrbZsnhOQ,1207
+pytz/zoneinfo/Asia/Ujung_Pandang,sha256=OhJtCqSTEU-u5n0opBVO5Bu-wQzcYPy9S_6aAhJXgOw,254
+pytz/zoneinfo/Asia/Ulaanbaatar,sha256=qUkXRsTc_u7B90JxULSu7yzKbGtGfKcfEFIasGPC2ec,877
+pytz/zoneinfo/Asia/Ulan_Bator,sha256=qUkXRsTc_u7B90JxULSu7yzKbGtGfKcfEFIasGPC2ec,877
+pytz/zoneinfo/Asia/Urumqi,sha256=F1ZOdZZDsVHwDJinksR-hjcqPzqOljvdreZIWFulJxY,151
+pytz/zoneinfo/Asia/Ust-Nera,sha256=zsG8kgnw0Fcs5N2WwNTVmvWkTlpwf7Oo8y68HcXjYyw,1238
+pytz/zoneinfo/Asia/Vientiane,sha256=hf_5PVegQcFSS60CjS80C7h-TGOrfQ4ncm83N8VmZkk,185
+pytz/zoneinfo/Asia/Vladivostok,sha256=XMQLMh5SPbI6C4R3UO4KhbnG4hWVkHNedzCQeqxFk6A,1194
+pytz/zoneinfo/Asia/Yakutsk,sha256=PPNrRGgg9jefOUM-6M8XqaIm-ElfmRZSWAtSGKLzNXQ,1193
+pytz/zoneinfo/Asia/Yangon,sha256=_YHASq4Z5YcUILIdhEzg27CGLzarUHPDHs1Dj0QgNGM,254
+pytz/zoneinfo/Asia/Yekaterinburg,sha256=4NyEW6Xjr4UsWPh63HIPI4G6GT_tVG1Xkgc2xbwGjzA,1229
+pytz/zoneinfo/Asia/Yerevan,sha256=FM0pUA4NbTWBb_CsJ5KCLVrLoNmad7njBKqFrJBDoxE,1137
+pytz/zoneinfo/Atlantic/Azores,sha256=NyNrE2YIwL9yVddpECcYWwci5JzrfjxiIXP7RP0MrL8,3498
+pytz/zoneinfo/Atlantic/Bermuda,sha256=LNGKfMsnYvwImjTyzXrLhMOHHDu7qI67RbYNKvvI15I,2396
+pytz/zoneinfo/Atlantic/Canary,sha256=ymK9ufqphvNjDK3hzikN4GfkcR3QeCBiPKyVc6FjlbA,1897
+pytz/zoneinfo/Atlantic/Cape_Verde,sha256=o92pLdLFX_b9vUiq3rNpca4tupIO3dx9rNrnPcA8474,256
+pytz/zoneinfo/Atlantic/Faeroe,sha256=NibdZPZtapnYR_myIZnMdTaSKGsOBGgujj0_T2NvAzs,1815
+pytz/zoneinfo/Atlantic/Faroe,sha256=NibdZPZtapnYR_myIZnMdTaSKGsOBGgujj0_T2NvAzs,1815
+pytz/zoneinfo/Atlantic/Jan_Mayen,sha256=XuR19xoPwaMvrrhJ-MOcbnqmbW1B7HQrl7OnQ2s7BwE,2298
+pytz/zoneinfo/Atlantic/Madeira,sha256=21Zcy0xRqDN3oY8jmjjO-LI7aC3G9mcS9ytaYg0g7ik,3503
+pytz/zoneinfo/Atlantic/Reykjavik,sha256=0u-sTl8j2IyV1ywdtCgHFw9S9D3ZiiBa9akqkbny2Zc,148
+pytz/zoneinfo/Atlantic/South_Georgia,sha256=I9SAcPPumy6Xf9P7dg2aE16oxwDIqyKFqinJTC-XsgM,150
+pytz/zoneinfo/Atlantic/St_Helena,sha256=0u-sTl8j2IyV1ywdtCgHFw9S9D3ZiiBa9akqkbny2Zc,148
+pytz/zoneinfo/Atlantic/Stanley,sha256=siEjXTAuTum_4XGtS98MBE34XW_5xgXShEX5OMnSFjo,1200
+pytz/zoneinfo/Australia/ACT,sha256=QsOFdYWxbbL4_9R7oZ-qYPRzNA3o1P6TIOp76GFgWQY,2190
+pytz/zoneinfo/Australia/Adelaide,sha256=ld2EbxU75oVgmPe703z-I6aqLg0Kmv62ZcCGzkT5R20,2208
+pytz/zoneinfo/Australia/Brisbane,sha256=eW6Qzze2t0-speJmmvt1JMzbkSadIKdE84XHc7JUtGc,419
+pytz/zoneinfo/Australia/Broken_Hill,sha256=3k_3ljTvS5GSfo7Xh6w71UgR3aAwYPBsnCJ-mlEYCqQ,2229
+pytz/zoneinfo/Australia/Canberra,sha256=QsOFdYWxbbL4_9R7oZ-qYPRzNA3o1P6TIOp76GFgWQY,2190
+pytz/zoneinfo/Australia/Currie,sha256=GLQSzgIfsWxOvmKOrhpfofWqINQf6h36NYy3mcq6gcg,2358
+pytz/zoneinfo/Australia/Darwin,sha256=fn0IZhIW98FAnzLig-_GBtW5LA54jajdeeUzg4tCGvo,325
+pytz/zoneinfo/Australia/Eucla,sha256=i1-XGG8I6E0dXIdWGF4DlkfDLWhiAxJ_3gMpt-nm_u4,456
+pytz/zoneinfo/Australia/Hobart,sha256=GLQSzgIfsWxOvmKOrhpfofWqINQf6h36NYy3mcq6gcg,2358
+pytz/zoneinfo/Australia/LHI,sha256=oyPFQzmRqWPrSXt9pNHQmEi_PvX11k2clknziOS6ud8,1846
+pytz/zoneinfo/Australia/Lindeman,sha256=xM6Udx22oLNoLR1Y7GQhHOYov8nw3xQNqgc_NVQ2JK4,475
+pytz/zoneinfo/Australia/Lord_Howe,sha256=oyPFQzmRqWPrSXt9pNHQmEi_PvX11k2clknziOS6ud8,1846
+pytz/zoneinfo/Australia/Melbourne,sha256=lvx_MQcunMc6u2smIrl8X427bLsXvjkgpCSdjYCTNBM,2190
+pytz/zoneinfo/Australia/NSW,sha256=QsOFdYWxbbL4_9R7oZ-qYPRzNA3o1P6TIOp76GFgWQY,2190
+pytz/zoneinfo/Australia/North,sha256=fn0IZhIW98FAnzLig-_GBtW5LA54jajdeeUzg4tCGvo,325
+pytz/zoneinfo/Australia/Perth,sha256=Al1DOUh4U_ofMUQSeVlzSyD3x7SUjP9dchSaBUGmeWg,446
+pytz/zoneinfo/Australia/Queensland,sha256=eW6Qzze2t0-speJmmvt1JMzbkSadIKdE84XHc7JUtGc,419
+pytz/zoneinfo/Australia/South,sha256=ld2EbxU75oVgmPe703z-I6aqLg0Kmv62ZcCGzkT5R20,2208
+pytz/zoneinfo/Australia/Sydney,sha256=QsOFdYWxbbL4_9R7oZ-qYPRzNA3o1P6TIOp76GFgWQY,2190
+pytz/zoneinfo/Australia/Tasmania,sha256=GLQSzgIfsWxOvmKOrhpfofWqINQf6h36NYy3mcq6gcg,2358
+pytz/zoneinfo/Australia/Victoria,sha256=lvx_MQcunMc6u2smIrl8X427bLsXvjkgpCSdjYCTNBM,2190
+pytz/zoneinfo/Australia/West,sha256=Al1DOUh4U_ofMUQSeVlzSyD3x7SUjP9dchSaBUGmeWg,446
+pytz/zoneinfo/Australia/Yancowinna,sha256=3k_3ljTvS5GSfo7Xh6w71UgR3aAwYPBsnCJ-mlEYCqQ,2229
+pytz/zoneinfo/Brazil/Acre,sha256=0gpJUl46hQbp0P6Xj1S0NArIWeAryuuDXjsldvB5GHE,614
+pytz/zoneinfo/Brazil/DeNoronha,sha256=feeRAijQqKylZgqe84nKhsFLycT5zIBm7mLIvdyGw4w,702
+pytz/zoneinfo/Brazil/East,sha256=BMBnRO4_4HjvO4t3njjrMGZr-ZPmegkvyvL8KPY6ZM4,1430
+pytz/zoneinfo/Brazil/West,sha256=F6RLOOeOi9lymZiQmQ9pR8tFpPZ6EguNdPfOc6BhXDE,590
+pytz/zoneinfo/CET,sha256=o4omkrM_IsITxooUo8krM921XfBdvRs9JhwGXGd-Ypg,2094
+pytz/zoneinfo/CST6CDT,sha256=WGbtZ1FwjRX6Jeo_TCXKsfeDs4V9uhXGJfcnLJhk3s0,2310
+pytz/zoneinfo/Canada/Atlantic,sha256=TZpmc5PwWoLfTfQoQ_b3U17BE2iVKSeNkR0Ho8mbTn8,3424
+pytz/zoneinfo/Canada/Central,sha256=7P-_YQrneFcon7QKSTOnkiGjEppFDn3Z48MJ1qq8VBw,2868
+pytz/zoneinfo/Canada/Eastern,sha256=ggOSzbHkmfgu9wTQzP0MUKsrKMbgveuAeThh1eFl1a0,3494
+pytz/zoneinfo/Canada/Mountain,sha256=-TkIfc3QlvaCf0p8COZ43Y1HRBAl-nARUi-JdXeK1vE,2332
+pytz/zoneinfo/Canada/Newfoundland,sha256=r1-17uKv27eZ3JsVkw_DLZQbo6wvjuuVu7C2pDsmOgI,3655
+pytz/zoneinfo/Canada/Pacific,sha256=sknKH0jSPWam-DHfM35qXs8Nam7d5TFlkUI9Sgxryyg,2892
+pytz/zoneinfo/Canada/Saskatchewan,sha256=yjqT08pHbICYe83H8JmtaDBvCFqRv7Tfze3Y8xuXukw,980
+pytz/zoneinfo/Canada/Yukon,sha256=TrR6PCnYG-mSClBMohqlP8qnYhXMUsydI-L-quXFxyM,1614
+pytz/zoneinfo/Chile/Continental,sha256=0CDw13dCMUsoquMupoJgupkzAUNhDK6E0lVxURA7osA,2515
+pytz/zoneinfo/Chile/EasterIsland,sha256=QbubBs_xQlvKweAnurhyHjIK4ji77Gh4G-usXul6XVM,2219
+pytz/zoneinfo/Cuba,sha256=HUQeAuKBsEkI5SLZjqynXICOUVOajkKzKH5r-Ov5Odc,2416
+pytz/zoneinfo/EET,sha256=gGVsW5-qnI7ty8vqVK1ADWhunrvAT8kUC79GUf-_7G8,1908
+pytz/zoneinfo/EST,sha256=uKE_VPKfxGyYEsyqV_DdE2MW55vs_qUioOdIn5Goobc,114
+pytz/zoneinfo/EST5EDT,sha256=fwzEMT1jgnY2dDjd0EqDl26_7LC-oF48Bd4ng5311H0,2310
+pytz/zoneinfo/Egypt,sha256=Lft-GCLQhaSJm9VqUmsEFoHIS1Vhfa7pFJn9GZCpifs,2399
+pytz/zoneinfo/Eire,sha256=QOjSocO1cihNo59vQkWxvIFPRSxE9apz0KARVx1czEM,3492
+pytz/zoneinfo/Etc/GMT,sha256=bZ83iIPAefhsA4elVHqSxEmGnYBuB94QCEqwTwJJAY0,114
+pytz/zoneinfo/Etc/GMT+0,sha256=bZ83iIPAefhsA4elVHqSxEmGnYBuB94QCEqwTwJJAY0,114
+pytz/zoneinfo/Etc/GMT+1,sha256=1Qzl2X9rQ_RXEf11yH09wQZCr_ph6UdFP7E0yu9s-IQ,116
+pytz/zoneinfo/Etc/GMT+10,sha256=JEQyQyQlkC0o6ZTdeVjZhCIOh6cK5TF7H00Pkls-sUI,117
+pytz/zoneinfo/Etc/GMT+11,sha256=tWvcvYMFCaE60nJVvDrrov7stJvs1KQYOyrhl3dzcUs,117
+pytz/zoneinfo/Etc/GMT+12,sha256=b70HEhErq8IJmq8x7cOZy4eR__3fq5uHHpjvPBEHqMA,117
+pytz/zoneinfo/Etc/GMT+2,sha256=T6Ep5zhslBKbYaECFUB6gUKh3iTZPyMoW1kjhonxrUo,116
+pytz/zoneinfo/Etc/GMT+3,sha256=QGoYrE04bUJ-OzL37dt2MZT5FxWNLpJDPVXgJbstYZA,116
+pytz/zoneinfo/Etc/GMT+4,sha256=RWrkNki-wV7X-coe0VvufBe6LrWVpkPJgia5QQYEnBo,116
+pytz/zoneinfo/Etc/GMT+5,sha256=oRmeC41dgYXT-zzyZIRKXN9IvdL2Da5nTuwmG2_prIA,116
+pytz/zoneinfo/Etc/GMT+6,sha256=d6dAnwiejyFI2n7AzFlFW0aFAT6zYNEjBIEG0uu0sbQ,116
+pytz/zoneinfo/Etc/GMT+7,sha256=TqjYbzd0YHpx1wisFg08J19wTpg6ztJLLongZY_lozs,116
+pytz/zoneinfo/Etc/GMT+8,sha256=th_8bIMmYgRPCesBrbmBhRr0jQO7whd70LiY9HfwJyk,116
+pytz/zoneinfo/Etc/GMT+9,sha256=Qq5E6iUS7JMJIymT7YoqlI8MtqtVy0mr9t6zWFtWc9Y,116
+pytz/zoneinfo/Etc/GMT-0,sha256=bZ83iIPAefhsA4elVHqSxEmGnYBuB94QCEqwTwJJAY0,114
+pytz/zoneinfo/Etc/GMT-1,sha256=73F1eU8uAQGP3mcoB2q99CjfManGFHk3fefljp9pYC4,117
+pytz/zoneinfo/Etc/GMT-10,sha256=fKWWNwLBOp1OkKjtc1w9LIXJR1mTTD-JdvYflRy1IrU,118
+pytz/zoneinfo/Etc/GMT-11,sha256=D2S79n6psa9t9_2vj5wIrFpHH2OJLcCKP6vtwzFZINY,118
+pytz/zoneinfo/Etc/GMT-12,sha256=me4V6lmWI8gSr8H7N41WAD0Eww1anh_EF34Qr9UoSnI,118
+pytz/zoneinfo/Etc/GMT-13,sha256=xbmbG1BQA6Dlpa_iUwEGyJxW4a3t6lmawdPKAE8vbR8,118
+pytz/zoneinfo/Etc/GMT-14,sha256=PpXoREBh02qFpvxVMj2pV9IAzSQvBE7XPvnN9qSZ-Kc,118
+pytz/zoneinfo/Etc/GMT-2,sha256=ve6hWLdeuiLhqagaWLqMD6HNybS1chRwjudfTZ2bYBE,117
+pytz/zoneinfo/Etc/GMT-3,sha256=N77jILanuLDVkLsdujXZSu-dsHiwN5MIpwh7fMUifso,117
+pytz/zoneinfo/Etc/GMT-4,sha256=LSko5fVHqPl5zfwjGqkbMa_OFnvtpT6o_4xYxNz9n5o,117
+pytz/zoneinfo/Etc/GMT-5,sha256=uLaSR5Mb18HRTsAA5SveY9PAJ97dO8QzIWqNXe3wZb4,117
+pytz/zoneinfo/Etc/GMT-6,sha256=JSN-RUAphJ50fpIv7cYC6unrtrz9S1Wma-piDHlGe7c,117
+pytz/zoneinfo/Etc/GMT-7,sha256=vVAOF8xU9T9ESnw68c0SFXpcvkoopaiwTR0zbefHHSU,117
+pytz/zoneinfo/Etc/GMT-8,sha256=S7xFQbFMpiDZy4v5L4D9fCrjRIzzoLC5p8Se23xi7us,117
+pytz/zoneinfo/Etc/GMT-9,sha256=I5vHNmUK-Yyg_S1skFN44VGVzBgktjFgVQiDIKO4aMI,117
+pytz/zoneinfo/Etc/GMT0,sha256=bZ83iIPAefhsA4elVHqSxEmGnYBuB94QCEqwTwJJAY0,114
+pytz/zoneinfo/Etc/Greenwich,sha256=bZ83iIPAefhsA4elVHqSxEmGnYBuB94QCEqwTwJJAY0,114
+pytz/zoneinfo/Etc/UCT,sha256=i4WEZ5GrLIpUY8g6W-PAQ-JXDXRIQ01BOYlp7Ufj5vI,114
+pytz/zoneinfo/Etc/UTC,sha256=i4WEZ5GrLIpUY8g6W-PAQ-JXDXRIQ01BOYlp7Ufj5vI,114
+pytz/zoneinfo/Etc/Universal,sha256=i4WEZ5GrLIpUY8g6W-PAQ-JXDXRIQ01BOYlp7Ufj5vI,114
+pytz/zoneinfo/Etc/Zulu,sha256=i4WEZ5GrLIpUY8g6W-PAQ-JXDXRIQ01BOYlp7Ufj5vI,114
+pytz/zoneinfo/Europe/Amsterdam,sha256=gS9Vrrbozend9HhuFetCVrIegs9fXSjaG60X2UVwysA,2933
+pytz/zoneinfo/Europe/Andorra,sha256=gTB5jCQmvIw3JJi1_vAcOYuhtzPBR6RXUx9gVV6p6ug,1742
+pytz/zoneinfo/Europe/Astrakhan,sha256=ZeGDZjwVVRoeR-J642zEnN26BPL58ViTJLbwnk7pLXk,1151
+pytz/zoneinfo/Europe/Athens,sha256=XDY-FBUddRyQHN8GxQLZ4awjuOlWlzlUdjv7OdXFNzA,2262
+pytz/zoneinfo/Europe/Belfast,sha256=yFSVBw3KQmh99qHD7ngKJ8vLgvGER1Dqb2QoM6RNKbQ,3664
+pytz/zoneinfo/Europe/Belgrade,sha256=OpWtsGFWBE_S-mYoQcAmjCta9HwbGQANnSmVY9OHCTo,1920
+pytz/zoneinfo/Europe/Berlin,sha256=XuR19xoPwaMvrrhJ-MOcbnqmbW1B7HQrl7OnQ2s7BwE,2298
+pytz/zoneinfo/Europe/Bratislava,sha256=G9fdhUXmzx651BnyZ6V7AOYIV9EV5aMJMm44eJaLLZw,2301
+pytz/zoneinfo/Europe/Brussels,sha256=gS9Vrrbozend9HhuFetCVrIegs9fXSjaG60X2UVwysA,2933
+pytz/zoneinfo/Europe/Bucharest,sha256=nfg6-bU2D6DMEWb9EMIBR5kxnNsbDSx0UKfHH_ZzqFc,2184
+pytz/zoneinfo/Europe/Budapest,sha256=lNwqxWciBvw9ei81VQwIKHbC_ZDJjpgHU6HFg4wCUkY,2368
+pytz/zoneinfo/Europe/Busingen,sha256=K5QY7Ujj2VUchKR4bhhb0hgdAJhmwED71ykXDQOGKe8,1909
+pytz/zoneinfo/Europe/Chisinau,sha256=p1J_rqFE13pL8cpBRrEFe-teCI8f0fKK4uTUy_4diF4,2390
+pytz/zoneinfo/Europe/Copenhagen,sha256=XuR19xoPwaMvrrhJ-MOcbnqmbW1B7HQrl7OnQ2s7BwE,2298
+pytz/zoneinfo/Europe/Dublin,sha256=QOjSocO1cihNo59vQkWxvIFPRSxE9apz0KARVx1czEM,3492
+pytz/zoneinfo/Europe/Gibraltar,sha256=a87WpaBlvxI4gAU9OpQOkN8VUJbirVWYf-VfFLTIoS4,3068
+pytz/zoneinfo/Europe/Guernsey,sha256=yFSVBw3KQmh99qHD7ngKJ8vLgvGER1Dqb2QoM6RNKbQ,3664
+pytz/zoneinfo/Europe/Helsinki,sha256=GEkB7LsVhmegt7YuuWheCDvDGC7b7Nw9bTdDGS9qkJc,1900
+pytz/zoneinfo/Europe/Isle_of_Man,sha256=yFSVBw3KQmh99qHD7ngKJ8vLgvGER1Dqb2QoM6RNKbQ,3664
+pytz/zoneinfo/Europe/Istanbul,sha256=Jk4wjndDta_uLWc8W1dWdjbavJJbsL5ROTmZboVnGKU,1933
+pytz/zoneinfo/Europe/Jersey,sha256=yFSVBw3KQmh99qHD7ngKJ8vLgvGER1Dqb2QoM6RNKbQ,3664
+pytz/zoneinfo/Europe/Kaliningrad,sha256=s7GXSe1YvMcs7AiUhHNTA6I4nAOQn_Kmz_ZqJYO-LMM,1493
+pytz/zoneinfo/Europe/Kiev,sha256=-wrpG9jPuIKFP1NgBVvnxsMRf9L_h5z3J6Q3jj1AwNM,2120
+pytz/zoneinfo/Europe/Kirov,sha256=P7T2Zf5Eo6o4L4Dbg_BfiFjUgTj0dQXlrwY-QZ1eBVk,1185
+pytz/zoneinfo/Europe/Kyiv,sha256=-wrpG9jPuIKFP1NgBVvnxsMRf9L_h5z3J6Q3jj1AwNM,2120
+pytz/zoneinfo/Europe/Lisbon,sha256=mpUpxGexMhbOBImDLSQs5-GAk7pm7tg4qYW044Kkle0,3497
+pytz/zoneinfo/Europe/Ljubljana,sha256=OpWtsGFWBE_S-mYoQcAmjCta9HwbGQANnSmVY9OHCTo,1920
+pytz/zoneinfo/Europe/London,sha256=yFSVBw3KQmh99qHD7ngKJ8vLgvGER1Dqb2QoM6RNKbQ,3664
+pytz/zoneinfo/Europe/Luxembourg,sha256=gS9Vrrbozend9HhuFetCVrIegs9fXSjaG60X2UVwysA,2933
+pytz/zoneinfo/Europe/Madrid,sha256=mkLX03rW3t0tmzKBIPe_noUvaFDErwC6_5ZPZZsWHOo,2614
+pytz/zoneinfo/Europe/Malta,sha256=EhKcbPL47765tWAiQ57cusaK2TaIQqZCgtJoEZs3Ud0,2620
+pytz/zoneinfo/Europe/Mariehamn,sha256=GEkB7LsVhmegt7YuuWheCDvDGC7b7Nw9bTdDGS9qkJc,1900
+pytz/zoneinfo/Europe/Minsk,sha256=KgPm0fHycntgd3xbTmmDl4O13Xh_9e2zUnd8XFSU29o,1307
+pytz/zoneinfo/Europe/Monaco,sha256=q3ehSIot1GZ6TyMHIjbg0oRf4ghAXuwbSDSYVim6evg,2962
+pytz/zoneinfo/Europe/Moscow,sha256=KmkofRcj6T8Ph28PJChm8JVp13uRvef6TZ0GuPzUiDw,1535
+pytz/zoneinfo/Europe/Nicosia,sha256=0Unm0IFT7HyGeQ7F3vTa_-klfysCgrulqFO6BD1plZU,2002
+pytz/zoneinfo/Europe/Oslo,sha256=XuR19xoPwaMvrrhJ-MOcbnqmbW1B7HQrl7OnQ2s7BwE,2298
+pytz/zoneinfo/Europe/Paris,sha256=q3ehSIot1GZ6TyMHIjbg0oRf4ghAXuwbSDSYVim6evg,2962
+pytz/zoneinfo/Europe/Podgorica,sha256=OpWtsGFWBE_S-mYoQcAmjCta9HwbGQANnSmVY9OHCTo,1920
+pytz/zoneinfo/Europe/Prague,sha256=G9fdhUXmzx651BnyZ6V7AOYIV9EV5aMJMm44eJaLLZw,2301
+pytz/zoneinfo/Europe/Riga,sha256=hJ2_0m1taW9IuA-hMyP5n-WX7YOrR0heKszJhgljRWk,2198
+pytz/zoneinfo/Europe/Rome,sha256=1a3oLMSiMpSbh9QxV8hLLDVbZqash89iUO1urYC1AY8,2641
+pytz/zoneinfo/Europe/Samara,sha256=nXL0IxbT6qu10CNuaDHxx4W1OaAnaaKTtIJ9N9URMoU,1201
+pytz/zoneinfo/Europe/San_Marino,sha256=1a3oLMSiMpSbh9QxV8hLLDVbZqash89iUO1urYC1AY8,2641
+pytz/zoneinfo/Europe/Sarajevo,sha256=OpWtsGFWBE_S-mYoQcAmjCta9HwbGQANnSmVY9OHCTo,1920
+pytz/zoneinfo/Europe/Saratov,sha256=ygwjvXN13TgaWxjg6ysWEnHWNxwrVtkEbrk8t9bzVVw,1169
+pytz/zoneinfo/Europe/Simferopol,sha256=tzl7xdNVSZprNCul4YE5LSpoR9JoujmOq8VbbB8wHic,1469
+pytz/zoneinfo/Europe/Skopje,sha256=OpWtsGFWBE_S-mYoQcAmjCta9HwbGQANnSmVY9OHCTo,1920
+pytz/zoneinfo/Europe/Sofia,sha256=hCQKXfMNrnA5xHNw_uzTjKzVw4-Bvsq5oGO4yUCv5tY,2077
+pytz/zoneinfo/Europe/Stockholm,sha256=XuR19xoPwaMvrrhJ-MOcbnqmbW1B7HQrl7OnQ2s7BwE,2298
+pytz/zoneinfo/Europe/Tallinn,sha256=4a6JC0aIpMzqIV7O35zoG0LLJwkQq5AoXZ2ivkic6-w,2148
+pytz/zoneinfo/Europe/Tirane,sha256=ztlZyCS9WCXeVW8nBun3Tyi5HUY0EtFbiBbEc1gucuw,2084
+pytz/zoneinfo/Europe/Tiraspol,sha256=p1J_rqFE13pL8cpBRrEFe-teCI8f0fKK4uTUy_4diF4,2390
+pytz/zoneinfo/Europe/Ulyanovsk,sha256=c8Ad5p7CKj_1cCA7lVRpcPqbQXGYaX83cuu6uIFx-Bg,1253
+pytz/zoneinfo/Europe/Uzhgorod,sha256=-wrpG9jPuIKFP1NgBVvnxsMRf9L_h5z3J6Q3jj1AwNM,2120
+pytz/zoneinfo/Europe/Vaduz,sha256=K5QY7Ujj2VUchKR4bhhb0hgdAJhmwED71ykXDQOGKe8,1909
+pytz/zoneinfo/Europe/Vatican,sha256=1a3oLMSiMpSbh9QxV8hLLDVbZqash89iUO1urYC1AY8,2641
+pytz/zoneinfo/Europe/Vienna,sha256=ZmI3kADE6bnrJEccqh73XXBY36L1G4DkpiTQImtNrUk,2200
+pytz/zoneinfo/Europe/Vilnius,sha256=UFzRX3orCTB8d9IzlxJPy5eUA2oBPuCu1UJl-2D7C3U,2162
+pytz/zoneinfo/Europe/Volgograd,sha256=RgFvt7mzZ-TtIKL9BVHmoNZLIeLIuiDdXeY10g2_vks,1193
+pytz/zoneinfo/Europe/Warsaw,sha256=TiLDPbeVF0ckgLVEkaSeDaKZ8wctdJDOl_HE_Wd5rKs,2654
+pytz/zoneinfo/Europe/Zagreb,sha256=OpWtsGFWBE_S-mYoQcAmjCta9HwbGQANnSmVY9OHCTo,1920
+pytz/zoneinfo/Europe/Zaporozhye,sha256=-wrpG9jPuIKFP1NgBVvnxsMRf9L_h5z3J6Q3jj1AwNM,2120
+pytz/zoneinfo/Europe/Zurich,sha256=K5QY7Ujj2VUchKR4bhhb0hgdAJhmwED71ykXDQOGKe8,1909
+pytz/zoneinfo/Factory,sha256=aFFlKx93HXoJoF4SSuTlD8cZtJA-ne5oKzAa6eX2V4k,116
+pytz/zoneinfo/GB,sha256=yFSVBw3KQmh99qHD7ngKJ8vLgvGER1Dqb2QoM6RNKbQ,3664
+pytz/zoneinfo/GB-Eire,sha256=yFSVBw3KQmh99qHD7ngKJ8vLgvGER1Dqb2QoM6RNKbQ,3664
+pytz/zoneinfo/GMT,sha256=bZ83iIPAefhsA4elVHqSxEmGnYBuB94QCEqwTwJJAY0,114
+pytz/zoneinfo/GMT+0,sha256=bZ83iIPAefhsA4elVHqSxEmGnYBuB94QCEqwTwJJAY0,114
+pytz/zoneinfo/GMT-0,sha256=bZ83iIPAefhsA4elVHqSxEmGnYBuB94QCEqwTwJJAY0,114
+pytz/zoneinfo/GMT0,sha256=bZ83iIPAefhsA4elVHqSxEmGnYBuB94QCEqwTwJJAY0,114
+pytz/zoneinfo/Greenwich,sha256=bZ83iIPAefhsA4elVHqSxEmGnYBuB94QCEqwTwJJAY0,114
+pytz/zoneinfo/HST,sha256=1YkCncvgL9Z5CmUo4Vk8VbQmgA7ZAQ0PtE37j1yOli8,115
+pytz/zoneinfo/Hongkong,sha256=al_O4kPlq5JpgkLYjEaZzrcgiiLul9NC0R5B69JVWhc,1233
+pytz/zoneinfo/Iceland,sha256=0u-sTl8j2IyV1ywdtCgHFw9S9D3ZiiBa9akqkbny2Zc,148
+pytz/zoneinfo/Indian/Antananarivo,sha256=yJsuJTqJJqbOz37_NOS_zbf-JNr_IthHGMMN7sDqSWg,265
+pytz/zoneinfo/Indian/Chagos,sha256=2errXzKdFIcpU0L-XRhSHxhNabIzbI5lXV3Pq6lt40Y,185
+pytz/zoneinfo/Indian/Christmas,sha256=hf_5PVegQcFSS60CjS80C7h-TGOrfQ4ncm83N8VmZkk,185
+pytz/zoneinfo/Indian/Cocos,sha256=_YHASq4Z5YcUILIdhEzg27CGLzarUHPDHs1Dj0QgNGM,254
+pytz/zoneinfo/Indian/Comoro,sha256=yJsuJTqJJqbOz37_NOS_zbf-JNr_IthHGMMN7sDqSWg,265
+pytz/zoneinfo/Indian/Kerguelen,sha256=F73ffVfBoUoHre0-DwsiQrYJcLpPOW-JJGk3n88lM5U,185
+pytz/zoneinfo/Indian/Mahe,sha256=pmdhPhaJRwKwONvxiZNGeFSICjlWzyY9JlFHv-H9upY,151
+pytz/zoneinfo/Indian/Maldives,sha256=F73ffVfBoUoHre0-DwsiQrYJcLpPOW-JJGk3n88lM5U,185
+pytz/zoneinfo/Indian/Mauritius,sha256=Znqrc1chimlciJsYBOl0NvIHnrNdCxncGxWczq1PBeI,227
+pytz/zoneinfo/Indian/Mayotte,sha256=yJsuJTqJJqbOz37_NOS_zbf-JNr_IthHGMMN7sDqSWg,265
+pytz/zoneinfo/Indian/Reunion,sha256=pmdhPhaJRwKwONvxiZNGeFSICjlWzyY9JlFHv-H9upY,151
+pytz/zoneinfo/Iran,sha256=LQMch2TMA4wI23SQzoIrlZh0_KceXQegurwxCZ5YDlY,1248
+pytz/zoneinfo/Israel,sha256=JUuWQmW5Tha0pJjw61Q5aN7CX0z4D7ops9OOSnda6Dc,2388
+pytz/zoneinfo/Jamaica,sha256=wlagieUPRf5-beie-h7QsONbNzjGsm8vMs8uf28pw28,482
+pytz/zoneinfo/Japan,sha256=oCueZgRNxcNcX3ZGdif9y6Su4cyVhga4XHdwlcrYLOs,309
+pytz/zoneinfo/Kwajalein,sha256=TmZ_0f-ySQ-saBAlRXV0f49Itwne51VBXn6rWcrWqHQ,302
+pytz/zoneinfo/Libya,sha256=W1dptGD70T7ppGoo0fczFQeDiIp0nultLNPV66MwB2c,625
+pytz/zoneinfo/MET,sha256=i3CKSuP4N_PAj7o-Cbk8zPEdFs0CWWBCAfg2JXDx5V8,2094
+pytz/zoneinfo/MST,sha256=6IQwvtT12Bz1pTiqFuoVxNY-4ViS7ZrYHo5nPWwzKPw,114
+pytz/zoneinfo/MST7MDT,sha256=910Ek32FKoSyZWY_H19VHaVvqb-JsvnWTOOHvhrKsE0,2310
+pytz/zoneinfo/Mexico/BajaNorte,sha256=57-Q9LSTNuTidz-lOTwDysmlCoeFUXSecvVVqNWburQ,2374
+pytz/zoneinfo/Mexico/BajaSur,sha256=RQQVwlEVHRp2X-c_0hJ46y54abTlqUuLkyrUUicyc5g,1128
+pytz/zoneinfo/Mexico/General,sha256=A5MlfDUZ4O1-jMTRt0WPem7qqcW0Nrslls1hlc8C4-Q,1222
+pytz/zoneinfo/NZ,sha256=gADjoyPo_QISQU6UJrAgcHp3HDaMoOFRdH-d23uBSyc,2437
+pytz/zoneinfo/NZ-CHAT,sha256=xhexVc5lfJ_qAv2d3HrII6lfRSxKZYBAjY2zpYkCGE8,2054
+pytz/zoneinfo/Navajo,sha256=MugZwApDs8NI9TnXANQlUE8guNBowWQY0m-ptpPndck,2460
+pytz/zoneinfo/PRC,sha256=ZP_C5DqUQ1oEPAQNHTr36S0DGtx453N68YYbqk7u8-Y,561
+pytz/zoneinfo/PST8PDT,sha256=Q7TCLkE69a6g7mPoPAkqhg-0dStyiAC0jVlM72KG_R8,2310
+pytz/zoneinfo/Pacific/Apia,sha256=M3QKsp75Q7H1X3aeE_9ZqQli9aEkNCCQctZQ5sEKu00,598
+pytz/zoneinfo/Pacific/Auckland,sha256=gADjoyPo_QISQU6UJrAgcHp3HDaMoOFRdH-d23uBSyc,2437
+pytz/zoneinfo/Pacific/Bougainville,sha256=hWE86eXnNx-vABbp7-YSIqWyecHPMIWLftVloAoPhL8,254
+pytz/zoneinfo/Pacific/Chatham,sha256=xhexVc5lfJ_qAv2d3HrII6lfRSxKZYBAjY2zpYkCGE8,2054
+pytz/zoneinfo/Pacific/Chuuk,sha256=nB36HBWZTdh3TlP0DLFNz1KRQ0aHIfHbp7LC4Urp9fA,172
+pytz/zoneinfo/Pacific/Easter,sha256=QbubBs_xQlvKweAnurhyHjIK4ji77Gh4G-usXul6XVM,2219
+pytz/zoneinfo/Pacific/Efate,sha256=oSxNcQYx5-1FU2_yHzHI-hT-dMJcPxzy4XmdI1UxXAo,524
+pytz/zoneinfo/Pacific/Enderbury,sha256=HNTAKrsH_R2W3QRlKcmNld5KcXdP0ygXCjEovc1i-6Q,220
+pytz/zoneinfo/Pacific/Fakaofo,sha256=qOodpTMKjztvZIXVLe_f_kZ6WcHl9fCLE9ZsyvdFKLI,186
+pytz/zoneinfo/Pacific/Fiji,sha256=jB5FbOsCnHVQQ2ohPiWEQUPhG6JybB3Nog3qT6WJQ0I,564
+pytz/zoneinfo/Pacific/Funafuti,sha256=UyaKimsR8LjgL8Z2g65I0HTvr3tMZuA2wUeBB6_Zp9c,152
+pytz/zoneinfo/Pacific/Galapagos,sha256=_GJUYOjSiIjoNBO2qdq23isLMJ4NCVk3DKIRGeDc8BA,224
+pytz/zoneinfo/Pacific/Gambier,sha256=gAS7gr1HH_re0uYnL6eWo5KGJ-B5QaiM8mV2cY5mQxE,150
+pytz/zoneinfo/Pacific/Guadalcanal,sha256=M4kTWqaSQaV1AMhyLSvmwoBJF7X9icrILbvQJwp940g,152
+pytz/zoneinfo/Pacific/Guam,sha256=Ex9znmf6rNfGze6gNpZJCMr1TT4rkl2SnrhecrdJufI,494
+pytz/zoneinfo/Pacific/Honolulu,sha256=fwPRv1Jk56sCOi75uZfd_Iy2k2aSQHx3B2K5xUlSPzM,329
+pytz/zoneinfo/Pacific/Johnston,sha256=fwPRv1Jk56sCOi75uZfd_Iy2k2aSQHx3B2K5xUlSPzM,329
+pytz/zoneinfo/Pacific/Kanton,sha256=HNTAKrsH_R2W3QRlKcmNld5KcXdP0ygXCjEovc1i-6Q,220
+pytz/zoneinfo/Pacific/Kiritimati,sha256=hYk1Ooz-Lj1PuZCbNV2WJIvOLtCwSwq2u63cb1Z-3NQ,224
+pytz/zoneinfo/Pacific/Kosrae,sha256=Q0jrb4zeDrd61bU4V8TqjMc0Iep8rWZyZqJ0uqsunxs,337
+pytz/zoneinfo/Pacific/Kwajalein,sha256=TmZ_0f-ySQ-saBAlRXV0f49Itwne51VBXn6rWcrWqHQ,302
+pytz/zoneinfo/Pacific/Majuro,sha256=UyaKimsR8LjgL8Z2g65I0HTvr3tMZuA2wUeBB6_Zp9c,152
+pytz/zoneinfo/Pacific/Marquesas,sha256=FTxPJTWtk48LVb3N2U64KLpLsmvu0DQBubTCg-dvyGM,159
+pytz/zoneinfo/Pacific/Midway,sha256=fCYrYphYY6rUfxOw712y5cyRe104AC3pouqD3bCINFg,175
+pytz/zoneinfo/Pacific/Nauru,sha256=9ASKgLHB-8nsTEK1ApzfTH0yQtbNAmGX-JI7uHZiqnA,238
+pytz/zoneinfo/Pacific/Niue,sha256=OllXxukncR7a-SMmdFox5az1xpIPMhbahQhtObmpuDM,189
+pytz/zoneinfo/Pacific/Norfolk,sha256=DMdX1Bm18lzNuiCWzwfeHUMRGXPS8v5AWnh-_EX_AZw,866
+pytz/zoneinfo/Pacific/Noumea,sha256=tkHxxnxsXTOqz3YzWi0mkhTCIONzg-W7EpSRMdPjKdQ,290
+pytz/zoneinfo/Pacific/Pago_Pago,sha256=fCYrYphYY6rUfxOw712y5cyRe104AC3pouqD3bCINFg,175
+pytz/zoneinfo/Pacific/Palau,sha256=aN2HbT0reqwKrtLKDK9M2zb0d0ikdNlTrrntVxdH66o,166
+pytz/zoneinfo/Pacific/Pitcairn,sha256=U4jAUuvsRNoy8XrPa16YpcXCcqHJY0u6JvCNgPEWO1c,188
+pytz/zoneinfo/Pacific/Pohnpei,sha256=M4kTWqaSQaV1AMhyLSvmwoBJF7X9icrILbvQJwp940g,152
+pytz/zoneinfo/Pacific/Ponape,sha256=M4kTWqaSQaV1AMhyLSvmwoBJF7X9icrILbvQJwp940g,152
+pytz/zoneinfo/Pacific/Port_Moresby,sha256=nB36HBWZTdh3TlP0DLFNz1KRQ0aHIfHbp7LC4Urp9fA,172
+pytz/zoneinfo/Pacific/Rarotonga,sha256=wPEsoXbyDnuhfzkgLvUqhSzrMx_FD42uAPluSPMh3Bc,589
+pytz/zoneinfo/Pacific/Saipan,sha256=Ex9znmf6rNfGze6gNpZJCMr1TT4rkl2SnrhecrdJufI,494
+pytz/zoneinfo/Pacific/Samoa,sha256=fCYrYphYY6rUfxOw712y5cyRe104AC3pouqD3bCINFg,175
+pytz/zoneinfo/Pacific/Tahiti,sha256=BRff9G3E-iWKhOWR1Wu02Z0iMgjrwDXV-XNrqItXdTY,151
+pytz/zoneinfo/Pacific/Tarawa,sha256=UyaKimsR8LjgL8Z2g65I0HTvr3tMZuA2wUeBB6_Zp9c,152
+pytz/zoneinfo/Pacific/Tongatapu,sha256=OppBZqTAZib9HY7U9AC-JavO7m6NxPGUtUfPQAl9oBY,358
+pytz/zoneinfo/Pacific/Truk,sha256=nB36HBWZTdh3TlP0DLFNz1KRQ0aHIfHbp7LC4Urp9fA,172
+pytz/zoneinfo/Pacific/Wake,sha256=UyaKimsR8LjgL8Z2g65I0HTvr3tMZuA2wUeBB6_Zp9c,152
+pytz/zoneinfo/Pacific/Wallis,sha256=UyaKimsR8LjgL8Z2g65I0HTvr3tMZuA2wUeBB6_Zp9c,152
+pytz/zoneinfo/Pacific/Yap,sha256=nB36HBWZTdh3TlP0DLFNz1KRQ0aHIfHbp7LC4Urp9fA,172
+pytz/zoneinfo/Poland,sha256=TiLDPbeVF0ckgLVEkaSeDaKZ8wctdJDOl_HE_Wd5rKs,2654
+pytz/zoneinfo/Portugal,sha256=mpUpxGexMhbOBImDLSQs5-GAk7pm7tg4qYW044Kkle0,3497
+pytz/zoneinfo/ROC,sha256=DMmQwOpPql25ue3Nf8vAKKT4em06D1Z9rHbLIitxixk,761
+pytz/zoneinfo/ROK,sha256=LI9LsV3XcJC0l-KoQf8zI-y7rk-du57erS-N2Ptdi7Q,617
+pytz/zoneinfo/Singapore,sha256=XmeVImeqcJ8hJzm7TjAti1nWJAxawOqq7jIzDnHX2hI,401
+pytz/zoneinfo/Turkey,sha256=Jk4wjndDta_uLWc8W1dWdjbavJJbsL5ROTmZboVnGKU,1933
+pytz/zoneinfo/UCT,sha256=i4WEZ5GrLIpUY8g6W-PAQ-JXDXRIQ01BOYlp7Ufj5vI,114
+pytz/zoneinfo/US/Alaska,sha256=oZA1NSPS2BWdymYpnCHFO8BlYVS-ll5KLg2Ez9CbETs,2371
+pytz/zoneinfo/US/Aleutian,sha256=IB1DhwJQAKbhPJ9jHLf8zW5Dad7HIkBS-dhv64E1OlM,2356
+pytz/zoneinfo/US/Arizona,sha256=illz0sYuLL8lIPK0Tkou6dL0Vck_D0W_3rRTOvFYRmQ,360
+pytz/zoneinfo/US/Central,sha256=_roybr6I6sIAF6cYdIxGxoRpoef153Fty48dQ6bm9oY,3592
+pytz/zoneinfo/US/East-Indiana,sha256=kNKy9Kj9ICsiYYfCCbAggzMA7exf-GpGPMxoXocHUyw,1682
+pytz/zoneinfo/US/Eastern,sha256=6e0H177gx2qdRC0JHvHwFmj-58TyYBTAqGixn-bBipU,3552
+pytz/zoneinfo/US/Hawaii,sha256=fwPRv1Jk56sCOi75uZfd_Iy2k2aSQHx3B2K5xUlSPzM,329
+pytz/zoneinfo/US/Indiana-Starke,sha256=CsvZ5BKw2qVav3x_F8CU9taJdDk7jX41Cfsqms6jXV8,2444
+pytz/zoneinfo/US/Michigan,sha256=hecz8yqY2Cj5B61G3gLZdAVZvRgK9l0P90c_gN-uD5g,2230
+pytz/zoneinfo/US/Mountain,sha256=MugZwApDs8NI9TnXANQlUE8guNBowWQY0m-ptpPndck,2460
+pytz/zoneinfo/US/Pacific,sha256=aJd7ua1tGG_vxser02AQpm4wAI3LLTdgh6QcSYYecmg,2852
+pytz/zoneinfo/US/Samoa,sha256=fCYrYphYY6rUfxOw712y5cyRe104AC3pouqD3bCINFg,175
+pytz/zoneinfo/UTC,sha256=i4WEZ5GrLIpUY8g6W-PAQ-JXDXRIQ01BOYlp7Ufj5vI,114
+pytz/zoneinfo/Universal,sha256=i4WEZ5GrLIpUY8g6W-PAQ-JXDXRIQ01BOYlp7Ufj5vI,114
+pytz/zoneinfo/W-SU,sha256=KmkofRcj6T8Ph28PJChm8JVp13uRvef6TZ0GuPzUiDw,1535
+pytz/zoneinfo/WET,sha256=Sc0l03EfVs_aIi17I4KyZJFkwiAHat5BgpjuuFDhgQ0,1905
+pytz/zoneinfo/Zulu,sha256=i4WEZ5GrLIpUY8g6W-PAQ-JXDXRIQ01BOYlp7Ufj5vI,114
+pytz/zoneinfo/iso3166.tab,sha256=oBpdFY8x1GrY5vjMKgbGQYEGgqk5fUYDIPaNVCG2XnE,4791
+pytz/zoneinfo/leapseconds,sha256=WEVzee5hvG-NO8a0UI7PyV-gBPfl1QRKvX5NSEA4wM8,3388
+pytz/zoneinfo/tzdata.zi,sha256=OW1w9BY23DpiWxQ2tIxoA2-4c36UPYRoNQwAMrA1TvM,109468
+pytz/zoneinfo/zone.tab,sha256=qSLfeCWE3tsCDIIQbr71DMkmCUXTIUEgNZgfN-60d-Y,18846
+pytz/zoneinfo/zone1970.tab,sha256=FJErvL9wggoFluO2WceYn8ZQ-nA9A073Lub1x2Pzg40,17582
+pytz/zoneinfo/zonenow.tab,sha256=leQ0PwMcvzC3Kcu2CqFAkC8E1hT809HDXJCSZB1Iw9E,8200
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pytz-2023.4.dist-info/WHEEL b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pytz-2023.4.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..0b18a281107a0448a9980396d9d324ea2aa7a7f8
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pytz-2023.4.dist-info/WHEEL
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.1)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pytz-2023.4.dist-info/top_level.txt b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pytz-2023.4.dist-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..af44f198c687e245aada835efbab2f75ed2c9baf
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pytz-2023.4.dist-info/top_level.txt
@@ -0,0 +1 @@
+pytz
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pytz-2023.4.dist-info/zip-safe b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pytz-2023.4.dist-info/zip-safe
new file mode 100644
index 0000000000000000000000000000000000000000..8b137891791fe96927ad78e64b0aad7bded08bdc
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pytz-2023.4.dist-info/zip-safe
@@ -0,0 +1 @@
+
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/regex-2024.11.6.dist-info/INSTALLER b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/regex-2024.11.6.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/regex-2024.11.6.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/regex-2024.11.6.dist-info/LICENSE.txt b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/regex-2024.11.6.dist-info/LICENSE.txt
new file mode 100644
index 0000000000000000000000000000000000000000..99c19cf844141395a87c34325da3a537f1e95815
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/regex-2024.11.6.dist-info/LICENSE.txt
@@ -0,0 +1,208 @@
+This work was derived from the 're' module of CPython 2.6 and CPython 3.1,
+copyright (c) 1998-2001 by Secret Labs AB and licensed under CNRI's Python 1.6
+license.
+
+All additions and alterations are licensed under the Apache 2.0 License.
+
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright 2020 Matthew Barnett
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/regex-2024.11.6.dist-info/METADATA b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/regex-2024.11.6.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..5d683570a4594106530f7cc58866d97d45e0b396
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/regex-2024.11.6.dist-info/METADATA
@@ -0,0 +1,1060 @@
+Metadata-Version: 2.1
+Name: regex
+Version: 2024.11.6
+Summary: Alternative regular expression module, to replace re.
+Home-page: https://github.com/mrabarnett/mrab-regex
+Author: Matthew Barnett
+Author-email: regex@mrabarnett.plus.com
+License: Apache Software License
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing
+Classifier: Topic :: Text Processing :: General
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+License-File: LICENSE.txt
+
+Introduction
+------------
+
+This regex implementation is backwards-compatible with the standard 're' module, but offers additional functionality.
+
+Python 2
+--------
+
+Python 2 is no longer supported. The last release that supported Python 2 was 2021.11.10.
+
+PyPy
+----
+
+This module is targeted at CPython. It expects that all codepoints are the same width, so it won't behave properly with PyPy outside U+0000..U+007F because PyPy stores strings as UTF-8.
+
+Multithreading
+--------------
+
+The regex module releases the GIL during matching on instances of the built-in (immutable) string classes, enabling other Python threads to run concurrently. It is also possible to force the regex module to release the GIL during matching by calling the matching methods with the keyword argument ``concurrent=True``. The behaviour is undefined if the string changes during matching, so use it *only* when it is guaranteed that that won't happen.
+
+Unicode
+-------
+
+This module supports Unicode 16.0.0. Full Unicode case-folding is supported.
+
+Flags
+-----
+
+There are 2 kinds of flag: scoped and global. Scoped flags can apply to only part of a pattern and can be turned on or off; global flags apply to the entire pattern and can only be turned on.
+
+The scoped flags are: ``ASCII (?a)``, ``FULLCASE (?f)``, ``IGNORECASE (?i)``, ``LOCALE (?L)``, ``MULTILINE (?m)``, ``DOTALL (?s)``, ``UNICODE (?u)``, ``VERBOSE (?x)``, ``WORD (?w)``.
+
+The global flags are: ``BESTMATCH (?b)``, ``ENHANCEMATCH (?e)``, ``POSIX (?p)``, ``REVERSE (?r)``, ``VERSION0 (?V0)``, ``VERSION1 (?V1)``.
+
+If neither the ``ASCII``, ``LOCALE`` nor ``UNICODE`` flag is specified, it will default to ``UNICODE`` if the regex pattern is a Unicode string and ``ASCII`` if it's a bytestring.
+
+The ``ENHANCEMATCH`` flag makes fuzzy matching attempt to improve the fit of the next match that it finds.
+
+The ``BESTMATCH`` flag makes fuzzy matching search for the best match instead of the next match.
+
+Old vs new behaviour
+--------------------
+
+In order to be compatible with the re module, this module has 2 behaviours:
+
+* **Version 0** behaviour (old behaviour, compatible with the re module):
+
+ Please note that the re module's behaviour may change over time, and I'll endeavour to match that behaviour in version 0.
+
+ * Indicated by the ``VERSION0`` flag.
+
+ * Zero-width matches are not handled correctly in the re module before Python 3.7. The behaviour in those earlier versions is:
+
+ * ``.split`` won't split a string at a zero-width match.
+
+ * ``.sub`` will advance by one character after a zero-width match.
+
+ * Inline flags apply to the entire pattern, and they can't be turned off.
+
+ * Only simple sets are supported.
+
+ * Case-insensitive matches in Unicode use simple case-folding by default.
+
+* **Version 1** behaviour (new behaviour, possibly different from the re module):
+
+ * Indicated by the ``VERSION1`` flag.
+
+ * Zero-width matches are handled correctly.
+
+ * Inline flags apply to the end of the group or pattern, and they can be turned off.
+
+ * Nested sets and set operations are supported.
+
+ * Case-insensitive matches in Unicode use full case-folding by default.
+
+If no version is specified, the regex module will default to ``regex.DEFAULT_VERSION``.
+
+Case-insensitive matches in Unicode
+-----------------------------------
+
+The regex module supports both simple and full case-folding for case-insensitive matches in Unicode. Use of full case-folding can be turned on using the ``FULLCASE`` flag. Please note that this flag affects how the ``IGNORECASE`` flag works; the ``FULLCASE`` flag itself does not turn on case-insensitive matching.
+
+Version 0 behaviour: the flag is off by default.
+
+Version 1 behaviour: the flag is on by default.
+
+Nested sets and set operations
+------------------------------
+
+It's not possible to support both simple sets, as used in the re module, and nested sets at the same time because of a difference in the meaning of an unescaped ``"["`` in a set.
+
+For example, the pattern ``[[a-z]--[aeiou]]`` is treated in the version 0 behaviour (simple sets, compatible with the re module) as:
+
+* Set containing "[" and the letters "a" to "z"
+
+* Literal "--"
+
+* Set containing letters "a", "e", "i", "o", "u"
+
+* Literal "]"
+
+but in the version 1 behaviour (nested sets, enhanced behaviour) as:
+
+* Set which is:
+
+ * Set containing the letters "a" to "z"
+
+* but excluding:
+
+ * Set containing the letters "a", "e", "i", "o", "u"
+
+Version 0 behaviour: only simple sets are supported.
+
+Version 1 behaviour: nested sets and set operations are supported.
+
+Notes on named groups
+---------------------
+
+All groups have a group number, starting from 1.
+
+Groups with the same group name will have the same group number, and groups with a different group name will have a different group number.
+
+The same name can be used by more than one group, with later captures 'overwriting' earlier captures. All the captures of the group will be available from the ``captures`` method of the match object.
+
+Group numbers will be reused across different branches of a branch reset, eg. ``(?|(first)|(second))`` has only group 1. If groups have different group names then they will, of course, have different group numbers, eg. ``(?|(?Pfirst)|(?Psecond))`` has group 1 ("foo") and group 2 ("bar").
+
+In the regex ``(\s+)(?|(?P[A-Z]+)|(\w+) (?P[0-9]+)`` there are 2 groups:
+
+* ``(\s+)`` is group 1.
+
+* ``(?P[A-Z]+)`` is group 2, also called "foo".
+
+* ``(\w+)`` is group 2 because of the branch reset.
+
+* ``(?P[0-9]+)`` is group 2 because it's called "foo".
+
+If you want to prevent ``(\w+)`` from being group 2, you need to name it (different name, different group number).
+
+Additional features
+-------------------
+
+The issue numbers relate to the Python bug tracker, except where listed otherwise.
+
+Added ``\p{Horiz_Space}`` and ``\p{Vert_Space}`` (`GitHub issue 477 `_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+``\p{Horiz_Space}`` or ``\p{H}`` matches horizontal whitespace and ``\p{Vert_Space}`` or ``\p{V}`` matches vertical whitespace.
+
+Added support for lookaround in conditional pattern (`Hg issue 163 `_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The test of a conditional pattern can be a lookaround.
+
+.. sourcecode:: python
+
+ >>> regex.match(r'(?(?=\d)\d+|\w+)', '123abc')
+
+ >>> regex.match(r'(?(?=\d)\d+|\w+)', 'abc123')
+
+
+This is not quite the same as putting a lookaround in the first branch of a pair of alternatives.
+
+.. sourcecode:: python
+
+ >>> print(regex.match(r'(?:(?=\d)\d+\b|\w+)', '123abc'))
+
+ >>> print(regex.match(r'(?(?=\d)\d+\b|\w+)', '123abc'))
+ None
+
+In the first example, the lookaround matched, but the remainder of the first branch failed to match, and so the second branch was attempted, whereas in the second example, the lookaround matched, and the first branch failed to match, but the second branch was **not** attempted.
+
+Added POSIX matching (leftmost longest) (`Hg issue 150 `_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The POSIX standard for regex is to return the leftmost longest match. This can be turned on using the ``POSIX`` flag.
+
+.. sourcecode:: python
+
+ >>> # Normal matching.
+ >>> regex.search(r'Mr|Mrs', 'Mrs')
+
+ >>> regex.search(r'one(self)?(selfsufficient)?', 'oneselfsufficient')
+
+ >>> # POSIX matching.
+ >>> regex.search(r'(?p)Mr|Mrs', 'Mrs')
+
+ >>> regex.search(r'(?p)one(self)?(selfsufficient)?', 'oneselfsufficient')
+
+
+Note that it will take longer to find matches because when it finds a match at a certain position, it won't return that immediately, but will keep looking to see if there's another longer match there.
+
+Added ``(?(DEFINE)...)`` (`Hg issue 152 `_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+If there's no group called "DEFINE", then ... will be ignored except that any groups defined within it can be called and that the normal rules for numbering groups still apply.
+
+.. sourcecode:: python
+
+ >>> regex.search(r'(?(DEFINE)(?P\d+)(?P- \w+))(?&quant) (?&item)', '5 elephants')
+
+
+Added ``(*PRUNE)``, ``(*SKIP)`` and ``(*FAIL)`` (`Hg issue 153 `_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+``(*PRUNE)`` discards the backtracking info up to that point. When used in an atomic group or a lookaround, it won't affect the enclosing pattern.
+
+``(*SKIP)`` is similar to ``(*PRUNE)``, except that it also sets where in the text the next attempt to match will start. When used in an atomic group or a lookaround, it won't affect the enclosing pattern.
+
+``(*FAIL)`` causes immediate backtracking. ``(*F)`` is a permitted abbreviation.
+
+Added ``\K`` (`Hg issue 151 `_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Keeps the part of the entire match after the position where ``\K`` occurred; the part before it is discarded.
+
+It does not affect what groups return.
+
+.. sourcecode:: python
+
+ >>> m = regex.search(r'(\w\w\K\w\w\w)', 'abcdef')
+ >>> m[0]
+ 'cde'
+ >>> m[1]
+ 'abcde'
+ >>>
+ >>> m = regex.search(r'(?r)(\w\w\K\w\w\w)', 'abcdef')
+ >>> m[0]
+ 'bc'
+ >>> m[1]
+ 'bcdef'
+
+Added capture subscripting for ``expandf`` and ``subf``/``subfn`` (`Hg issue 133 `_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+You can use subscripting to get the captures of a repeated group.
+
+.. sourcecode:: python
+
+ >>> m = regex.match(r"(\w)+", "abc")
+ >>> m.expandf("{1}")
+ 'c'
+ >>> m.expandf("{1[0]} {1[1]} {1[2]}")
+ 'a b c'
+ >>> m.expandf("{1[-1]} {1[-2]} {1[-3]}")
+ 'c b a'
+ >>>
+ >>> m = regex.match(r"(?P\w)+", "abc")
+ >>> m.expandf("{letter}")
+ 'c'
+ >>> m.expandf("{letter[0]} {letter[1]} {letter[2]}")
+ 'a b c'
+ >>> m.expandf("{letter[-1]} {letter[-2]} {letter[-3]}")
+ 'c b a'
+
+Added support for referring to a group by number using ``(?P=...)``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+This is in addition to the existing ``\g<...>``.
+
+Fixed the handling of locale-sensitive regexes
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The ``LOCALE`` flag is intended for legacy code and has limited support. You're still recommended to use Unicode instead.
+
+Added partial matches (`Hg issue 102 `_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+A partial match is one that matches up to the end of string, but that string has been truncated and you want to know whether a complete match could be possible if the string had not been truncated.
+
+Partial matches are supported by ``match``, ``search``, ``fullmatch`` and ``finditer`` with the ``partial`` keyword argument.
+
+Match objects have a ``partial`` attribute, which is ``True`` if it's a partial match.
+
+For example, if you wanted a user to enter a 4-digit number and check it character by character as it was being entered:
+
+.. sourcecode:: python
+
+ >>> pattern = regex.compile(r'\d{4}')
+
+ >>> # Initially, nothing has been entered:
+ >>> print(pattern.fullmatch('', partial=True))
+
+
+ >>> # An empty string is OK, but it's only a partial match.
+ >>> # The user enters a letter:
+ >>> print(pattern.fullmatch('a', partial=True))
+ None
+ >>> # It'll never match.
+
+ >>> # The user deletes that and enters a digit:
+ >>> print(pattern.fullmatch('1', partial=True))
+
+ >>> # It matches this far, but it's only a partial match.
+
+ >>> # The user enters 2 more digits:
+ >>> print(pattern.fullmatch('123', partial=True))
+
+ >>> # It matches this far, but it's only a partial match.
+
+ >>> # The user enters another digit:
+ >>> print(pattern.fullmatch('1234', partial=True))
+
+ >>> # It's a complete match.
+
+ >>> # If the user enters another digit:
+ >>> print(pattern.fullmatch('12345', partial=True))
+ None
+ >>> # It's no longer a match.
+
+ >>> # This is a partial match:
+ >>> pattern.match('123', partial=True).partial
+ True
+
+ >>> # This is a complete match:
+ >>> pattern.match('1233', partial=True).partial
+ False
+
+``*`` operator not working correctly with sub() (`Hg issue 106 `_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Sometimes it's not clear how zero-width matches should be handled. For example, should ``.*`` match 0 characters directly after matching >0 characters?
+
+.. sourcecode:: python
+
+ >>> regex.sub('.*', 'x', 'test')
+ 'xx'
+ >>> regex.sub('.*?', '|', 'test')
+ '|||||||||'
+
+Added ``capturesdict`` (`Hg issue 86 `_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+``capturesdict`` is a combination of ``groupdict`` and ``captures``:
+
+``groupdict`` returns a dict of the named groups and the last capture of those groups.
+
+``captures`` returns a list of all the captures of a group
+
+``capturesdict`` returns a dict of the named groups and lists of all the captures of those groups.
+
+.. sourcecode:: python
+
+ >>> m = regex.match(r"(?:(?P\w+) (?P\d+)\n)+", "one 1\ntwo 2\nthree 3\n")
+ >>> m.groupdict()
+ {'word': 'three', 'digits': '3'}
+ >>> m.captures("word")
+ ['one', 'two', 'three']
+ >>> m.captures("digits")
+ ['1', '2', '3']
+ >>> m.capturesdict()
+ {'word': ['one', 'two', 'three'], 'digits': ['1', '2', '3']}
+
+Added ``allcaptures`` and ``allspans`` (`Git issue 474 `_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+``allcaptures`` returns a list of all the captures of all the groups.
+
+``allspans`` returns a list of all the spans of the all captures of all the groups.
+
+.. sourcecode:: python
+
+ >>> m = regex.match(r"(?:(?P\w+) (?P\d+)\n)+", "one 1\ntwo 2\nthree 3\n")
+ >>> m.allcaptures()
+ (['one 1\ntwo 2\nthree 3\n'], ['one', 'two', 'three'], ['1', '2', '3'])
+ >>> m.allspans()
+ ([(0, 20)], [(0, 3), (6, 9), (12, 17)], [(4, 5), (10, 11), (18, 19)])
+
+Allow duplicate names of groups (`Hg issue 87 `_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Group names can be duplicated.
+
+.. sourcecode:: python
+
+ >>> # With optional groups:
+ >>>
+ >>> # Both groups capture, the second capture 'overwriting' the first.
+ >>> m = regex.match(r"(?P- \w+)? or (?P
- \w+)?", "first or second")
+ >>> m.group("item")
+ 'second'
+ >>> m.captures("item")
+ ['first', 'second']
+ >>> # Only the second group captures.
+ >>> m = regex.match(r"(?P
- \w+)? or (?P
- \w+)?", " or second")
+ >>> m.group("item")
+ 'second'
+ >>> m.captures("item")
+ ['second']
+ >>> # Only the first group captures.
+ >>> m = regex.match(r"(?P
- \w+)? or (?P
- \w+)?", "first or ")
+ >>> m.group("item")
+ 'first'
+ >>> m.captures("item")
+ ['first']
+ >>>
+ >>> # With mandatory groups:
+ >>>
+ >>> # Both groups capture, the second capture 'overwriting' the first.
+ >>> m = regex.match(r"(?P
- \w*) or (?P
- \w*)?", "first or second")
+ >>> m.group("item")
+ 'second'
+ >>> m.captures("item")
+ ['first', 'second']
+ >>> # Again, both groups capture, the second capture 'overwriting' the first.
+ >>> m = regex.match(r"(?P
- \w*) or (?P
- \w*)", " or second")
+ >>> m.group("item")
+ 'second'
+ >>> m.captures("item")
+ ['', 'second']
+ >>> # And yet again, both groups capture, the second capture 'overwriting' the first.
+ >>> m = regex.match(r"(?P
- \w*) or (?P
- \w*)", "first or ")
+ >>> m.group("item")
+ ''
+ >>> m.captures("item")
+ ['first', '']
+
+Added ``fullmatch`` (`issue #16203
`_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+``fullmatch`` behaves like ``match``, except that it must match all of the string.
+
+.. sourcecode:: python
+
+ >>> print(regex.fullmatch(r"abc", "abc").span())
+ (0, 3)
+ >>> print(regex.fullmatch(r"abc", "abcx"))
+ None
+ >>> print(regex.fullmatch(r"abc", "abcx", endpos=3).span())
+ (0, 3)
+ >>> print(regex.fullmatch(r"abc", "xabcy", pos=1, endpos=4).span())
+ (1, 4)
+ >>>
+ >>> regex.match(r"a.*?", "abcd").group(0)
+ 'a'
+ >>> regex.fullmatch(r"a.*?", "abcd").group(0)
+ 'abcd'
+
+Added ``subf`` and ``subfn``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+``subf`` and ``subfn`` are alternatives to ``sub`` and ``subn`` respectively. When passed a replacement string, they treat it as a format string.
+
+.. sourcecode:: python
+
+ >>> regex.subf(r"(\w+) (\w+)", "{0} => {2} {1}", "foo bar")
+ 'foo bar => bar foo'
+ >>> regex.subf(r"(?P\w+) (?P\w+)", "{word2} {word1}", "foo bar")
+ 'bar foo'
+
+Added ``expandf`` to match object
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+``expandf`` is an alternative to ``expand``. When passed a replacement string, it treats it as a format string.
+
+.. sourcecode:: python
+
+ >>> m = regex.match(r"(\w+) (\w+)", "foo bar")
+ >>> m.expandf("{0} => {2} {1}")
+ 'foo bar => bar foo'
+ >>>
+ >>> m = regex.match(r"(?P\w+) (?P\w+)", "foo bar")
+ >>> m.expandf("{word2} {word1}")
+ 'bar foo'
+
+Detach searched string
+^^^^^^^^^^^^^^^^^^^^^^
+
+A match object contains a reference to the string that was searched, via its ``string`` attribute. The ``detach_string`` method will 'detach' that string, making it available for garbage collection, which might save valuable memory if that string is very large.
+
+.. sourcecode:: python
+
+ >>> m = regex.search(r"\w+", "Hello world")
+ >>> print(m.group())
+ Hello
+ >>> print(m.string)
+ Hello world
+ >>> m.detach_string()
+ >>> print(m.group())
+ Hello
+ >>> print(m.string)
+ None
+
+Recursive patterns (`Hg issue 27 `_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Recursive and repeated patterns are supported.
+
+``(?R)`` or ``(?0)`` tries to match the entire regex recursively. ``(?1)``, ``(?2)``, etc, try to match the relevant group.
+
+``(?&name)`` tries to match the named group.
+
+.. sourcecode:: python
+
+ >>> regex.match(r"(Tarzan|Jane) loves (?1)", "Tarzan loves Jane").groups()
+ ('Tarzan',)
+ >>> regex.match(r"(Tarzan|Jane) loves (?1)", "Jane loves Tarzan").groups()
+ ('Jane',)
+
+ >>> m = regex.search(r"(\w)(?:(?R)|(\w?))\1", "kayak")
+ >>> m.group(0, 1, 2)
+ ('kayak', 'k', None)
+
+The first two examples show how the subpattern within the group is reused, but is _not_ itself a group. In other words, ``"(Tarzan|Jane) loves (?1)"`` is equivalent to ``"(Tarzan|Jane) loves (?:Tarzan|Jane)"``.
+
+It's possible to backtrack into a recursed or repeated group.
+
+You can't call a group if there is more than one group with that group name or group number (``"ambiguous group reference"``).
+
+The alternative forms ``(?P>name)`` and ``(?P&name)`` are also supported.
+
+Full Unicode case-folding is supported
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+In version 1 behaviour, the regex module uses full case-folding when performing case-insensitive matches in Unicode.
+
+.. sourcecode:: python
+
+ >>> regex.match(r"(?iV1)strasse", "stra\N{LATIN SMALL LETTER SHARP S}e").span()
+ (0, 6)
+ >>> regex.match(r"(?iV1)stra\N{LATIN SMALL LETTER SHARP S}e", "STRASSE").span()
+ (0, 7)
+
+In version 0 behaviour, it uses simple case-folding for backward compatibility with the re module.
+
+Approximate "fuzzy" matching (`Hg issue 12 `_, `Hg issue 41 `_, `Hg issue 109 `_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Regex usually attempts an exact match, but sometimes an approximate, or "fuzzy", match is needed, for those cases where the text being searched may contain errors in the form of inserted, deleted or substituted characters.
+
+A fuzzy regex specifies which types of errors are permitted, and, optionally, either the minimum and maximum or only the maximum permitted number of each type. (You cannot specify only a minimum.)
+
+The 3 types of error are:
+
+* Insertion, indicated by "i"
+
+* Deletion, indicated by "d"
+
+* Substitution, indicated by "s"
+
+In addition, "e" indicates any type of error.
+
+The fuzziness of a regex item is specified between "{" and "}" after the item.
+
+Examples:
+
+* ``foo`` match "foo" exactly
+
+* ``(?:foo){i}`` match "foo", permitting insertions
+
+* ``(?:foo){d}`` match "foo", permitting deletions
+
+* ``(?:foo){s}`` match "foo", permitting substitutions
+
+* ``(?:foo){i,s}`` match "foo", permitting insertions and substitutions
+
+* ``(?:foo){e}`` match "foo", permitting errors
+
+If a certain type of error is specified, then any type not specified will **not** be permitted.
+
+In the following examples I'll omit the item and write only the fuzziness:
+
+* ``{d<=3}`` permit at most 3 deletions, but no other types
+
+* ``{i<=1,s<=2}`` permit at most 1 insertion and at most 2 substitutions, but no deletions
+
+* ``{1<=e<=3}`` permit at least 1 and at most 3 errors
+
+* ``{i<=2,d<=2,e<=3}`` permit at most 2 insertions, at most 2 deletions, at most 3 errors in total, but no substitutions
+
+It's also possible to state the costs of each type of error and the maximum permitted total cost.
+
+Examples:
+
+* ``{2i+2d+1s<=4}`` each insertion costs 2, each deletion costs 2, each substitution costs 1, the total cost must not exceed 4
+
+* ``{i<=1,d<=1,s<=1,2i+2d+1s<=4}`` at most 1 insertion, at most 1 deletion, at most 1 substitution; each insertion costs 2, each deletion costs 2, each substitution costs 1, the total cost must not exceed 4
+
+You can also use "<" instead of "<=" if you want an exclusive minimum or maximum.
+
+You can add a test to perform on a character that's substituted or inserted.
+
+Examples:
+
+* ``{s<=2:[a-z]}`` at most 2 substitutions, which must be in the character set ``[a-z]``.
+
+* ``{s<=2,i<=3:\d}`` at most 2 substitutions, at most 3 insertions, which must be digits.
+
+By default, fuzzy matching searches for the first match that meets the given constraints. The ``ENHANCEMATCH`` flag will cause it to attempt to improve the fit (i.e. reduce the number of errors) of the match that it has found.
+
+The ``BESTMATCH`` flag will make it search for the best match instead.
+
+Further examples to note:
+
+* ``regex.search("(dog){e}", "cat and dog")[1]`` returns ``"cat"`` because that matches ``"dog"`` with 3 errors (an unlimited number of errors is permitted).
+
+* ``regex.search("(dog){e<=1}", "cat and dog")[1]`` returns ``" dog"`` (with a leading space) because that matches ``"dog"`` with 1 error, which is within the limit.
+
+* ``regex.search("(?e)(dog){e<=1}", "cat and dog")[1]`` returns ``"dog"`` (without a leading space) because the fuzzy search matches ``" dog"`` with 1 error, which is within the limit, and the ``(?e)`` then it attempts a better fit.
+
+In the first two examples there are perfect matches later in the string, but in neither case is it the first possible match.
+
+The match object has an attribute ``fuzzy_counts`` which gives the total number of substitutions, insertions and deletions.
+
+.. sourcecode:: python
+
+ >>> # A 'raw' fuzzy match:
+ >>> regex.fullmatch(r"(?:cats|cat){e<=1}", "cat").fuzzy_counts
+ (0, 0, 1)
+ >>> # 0 substitutions, 0 insertions, 1 deletion.
+
+ >>> # A better match might be possible if the ENHANCEMATCH flag used:
+ >>> regex.fullmatch(r"(?e)(?:cats|cat){e<=1}", "cat").fuzzy_counts
+ (0, 0, 0)
+ >>> # 0 substitutions, 0 insertions, 0 deletions.
+
+The match object also has an attribute ``fuzzy_changes`` which gives a tuple of the positions of the substitutions, insertions and deletions.
+
+.. sourcecode:: python
+
+ >>> m = regex.search('(fuu){i<=2,d<=2,e<=5}', 'anaconda foo bar')
+ >>> m
+
+ >>> m.fuzzy_changes
+ ([], [7, 8], [10, 11])
+
+What this means is that if the matched part of the string had been:
+
+.. sourcecode:: python
+
+ 'anacondfuuoo bar'
+
+it would've been an exact match.
+
+However, there were insertions at positions 7 and 8:
+
+.. sourcecode:: python
+
+ 'anaconda fuuoo bar'
+ ^^
+
+and deletions at positions 10 and 11:
+
+.. sourcecode:: python
+
+ 'anaconda f~~oo bar'
+ ^^
+
+So the actual string was:
+
+.. sourcecode:: python
+
+ 'anaconda foo bar'
+
+Named lists ``\L`` (`Hg issue 11 `_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+There are occasions where you may want to include a list (actually, a set) of options in a regex.
+
+One way is to build the pattern like this:
+
+.. sourcecode:: python
+
+ >>> p = regex.compile(r"first|second|third|fourth|fifth")
+
+but if the list is large, parsing the resulting regex can take considerable time, and care must also be taken that the strings are properly escaped and properly ordered, for example, "cats" before "cat".
+
+The new alternative is to use a named list:
+
+.. sourcecode:: python
+
+ >>> option_set = ["first", "second", "third", "fourth", "fifth"]
+ >>> p = regex.compile(r"\L", options=option_set)
+
+The order of the items is irrelevant, they are treated as a set. The named lists are available as the ``.named_lists`` attribute of the pattern object :
+
+.. sourcecode:: python
+
+ >>> print(p.named_lists)
+ {'options': frozenset({'third', 'first', 'fifth', 'fourth', 'second'})}
+
+If there are any unused keyword arguments, ``ValueError`` will be raised unless you tell it otherwise:
+
+.. sourcecode:: python
+
+ >>> option_set = ["first", "second", "third", "fourth", "fifth"]
+ >>> p = regex.compile(r"\L", options=option_set, other_options=[])
+ Traceback (most recent call last):
+ File "", line 1, in
+ File "C:\Python310\lib\site-packages\regex\regex.py", line 353, in compile
+ return _compile(pattern, flags, ignore_unused, kwargs, cache_pattern)
+ File "C:\Python310\lib\site-packages\regex\regex.py", line 500, in _compile
+ complain_unused_args()
+ File "C:\Python310\lib\site-packages\regex\regex.py", line 483, in complain_unused_args
+ raise ValueError('unused keyword argument {!a}'.format(any_one))
+ ValueError: unused keyword argument 'other_options'
+ >>> p = regex.compile(r"\L", options=option_set, other_options=[], ignore_unused=True)
+ >>> p = regex.compile(r"\L", options=option_set, other_options=[], ignore_unused=False)
+ Traceback (most recent call last):
+ File "", line 1, in
+ File "C:\Python310\lib\site-packages\regex\regex.py", line 353, in compile
+ return _compile(pattern, flags, ignore_unused, kwargs, cache_pattern)
+ File "C:\Python310\lib\site-packages\regex\regex.py", line 500, in _compile
+ complain_unused_args()
+ File "C:\Python310\lib\site-packages\regex\regex.py", line 483, in complain_unused_args
+ raise ValueError('unused keyword argument {!a}'.format(any_one))
+ ValueError: unused keyword argument 'other_options'
+ >>>
+
+Start and end of word
+^^^^^^^^^^^^^^^^^^^^^
+
+``\m`` matches at the start of a word.
+
+``\M`` matches at the end of a word.
+
+Compare with ``\b``, which matches at the start or end of a word.
+
+Unicode line separators
+^^^^^^^^^^^^^^^^^^^^^^^
+
+Normally the only line separator is ``\n`` (``\x0A``), but if the ``WORD`` flag is turned on then the line separators are ``\x0D\x0A``, ``\x0A``, ``\x0B``, ``\x0C`` and ``\x0D``, plus ``\x85``, ``\u2028`` and ``\u2029`` when working with Unicode.
+
+This affects the regex dot ``"."``, which, with the ``DOTALL`` flag turned off, matches any character except a line separator. It also affects the line anchors ``^`` and ``$`` (in multiline mode).
+
+Set operators
+^^^^^^^^^^^^^
+
+**Version 1 behaviour only**
+
+Set operators have been added, and a set ``[...]`` can include nested sets.
+
+The operators, in order of increasing precedence, are:
+
+* ``||`` for union ("x||y" means "x or y")
+
+* ``~~`` (double tilde) for symmetric difference ("x~~y" means "x or y, but not both")
+
+* ``&&`` for intersection ("x&&y" means "x and y")
+
+* ``--`` (double dash) for difference ("x--y" means "x but not y")
+
+Implicit union, ie, simple juxtaposition like in ``[ab]``, has the highest precedence. Thus, ``[ab&&cd]`` is the same as ``[[a||b]&&[c||d]]``.
+
+Examples:
+
+* ``[ab]`` # Set containing 'a' and 'b'
+
+* ``[a-z]`` # Set containing 'a' .. 'z'
+
+* ``[[a-z]--[qw]]`` # Set containing 'a' .. 'z', but not 'q' or 'w'
+
+* ``[a-z--qw]`` # Same as above
+
+* ``[\p{L}--QW]`` # Set containing all letters except 'Q' and 'W'
+
+* ``[\p{N}--[0-9]]`` # Set containing all numbers except '0' .. '9'
+
+* ``[\p{ASCII}&&\p{Letter}]`` # Set containing all characters which are ASCII and letter
+
+regex.escape (`issue #2650 `_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+regex.escape has an additional keyword parameter ``special_only``. When True, only 'special' regex characters, such as '?', are escaped.
+
+.. sourcecode:: python
+
+ >>> regex.escape("foo!?", special_only=False)
+ 'foo\\!\\?'
+ >>> regex.escape("foo!?", special_only=True)
+ 'foo!\\?'
+
+regex.escape (`Hg issue 249 `_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+regex.escape has an additional keyword parameter ``literal_spaces``. When True, spaces are not escaped.
+
+.. sourcecode:: python
+
+ >>> regex.escape("foo bar!?", literal_spaces=False)
+ 'foo\\ bar!\\?'
+ >>> regex.escape("foo bar!?", literal_spaces=True)
+ 'foo bar!\\?'
+
+Repeated captures (`issue #7132 `_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+A match object has additional methods which return information on all the successful matches of a repeated group. These methods are:
+
+* ``matchobject.captures([group1, ...])``
+
+ * Returns a list of the strings matched in a group or groups. Compare with ``matchobject.group([group1, ...])``.
+
+* ``matchobject.starts([group])``
+
+ * Returns a list of the start positions. Compare with ``matchobject.start([group])``.
+
+* ``matchobject.ends([group])``
+
+ * Returns a list of the end positions. Compare with ``matchobject.end([group])``.
+
+* ``matchobject.spans([group])``
+
+ * Returns a list of the spans. Compare with ``matchobject.span([group])``.
+
+.. sourcecode:: python
+
+ >>> m = regex.search(r"(\w{3})+", "123456789")
+ >>> m.group(1)
+ '789'
+ >>> m.captures(1)
+ ['123', '456', '789']
+ >>> m.start(1)
+ 6
+ >>> m.starts(1)
+ [0, 3, 6]
+ >>> m.end(1)
+ 9
+ >>> m.ends(1)
+ [3, 6, 9]
+ >>> m.span(1)
+ (6, 9)
+ >>> m.spans(1)
+ [(0, 3), (3, 6), (6, 9)]
+
+Atomic grouping ``(?>...)`` (`issue #433030 `_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+If the following pattern subsequently fails, then the subpattern as a whole will fail.
+
+Possessive quantifiers
+^^^^^^^^^^^^^^^^^^^^^^
+
+``(?:...)?+`` ; ``(?:...)*+`` ; ``(?:...)++`` ; ``(?:...){min,max}+``
+
+The subpattern is matched up to 'max' times. If the following pattern subsequently fails, then all the repeated subpatterns will fail as a whole. For example, ``(?:...)++`` is equivalent to ``(?>(?:...)+)``.
+
+Scoped flags (`issue #433028 `_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+``(?flags-flags:...)``
+
+The flags will apply only to the subpattern. Flags can be turned on or off.
+
+Definition of 'word' character (`issue #1693050 `_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The definition of a 'word' character has been expanded for Unicode. It conforms to the Unicode specification at ``http://www.unicode.org/reports/tr29/``.
+
+Variable-length lookbehind
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+A lookbehind can match a variable-length string.
+
+Flags argument for regex.split, regex.sub and regex.subn (`issue #3482 `_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+``regex.split``, ``regex.sub`` and ``regex.subn`` support a 'flags' argument.
+
+Pos and endpos arguments for regex.sub and regex.subn
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+``regex.sub`` and ``regex.subn`` support 'pos' and 'endpos' arguments.
+
+'Overlapped' argument for regex.findall and regex.finditer
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+``regex.findall`` and ``regex.finditer`` support an 'overlapped' flag which permits overlapped matches.
+
+Splititer
+^^^^^^^^^
+
+``regex.splititer`` has been added. It's a generator equivalent of ``regex.split``.
+
+Subscripting match objects for groups
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+A match object accepts access to the groups via subscripting and slicing:
+
+.. sourcecode:: python
+
+ >>> m = regex.search(r"(?P.*?)(?P\d+)(?P.*)", "pqr123stu")
+ >>> print(m["before"])
+ pqr
+ >>> print(len(m))
+ 4
+ >>> print(m[:])
+ ('pqr123stu', 'pqr', '123', 'stu')
+
+Named groups
+^^^^^^^^^^^^
+
+Groups can be named with ``(?...)`` as well as the existing ``(?P...)``.
+
+Group references
+^^^^^^^^^^^^^^^^
+
+Groups can be referenced within a pattern with ``\g``. This also allows there to be more than 99 groups.
+
+Named characters ``\N{name}``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Named characters are supported. Note that only those known by Python's Unicode database will be recognised.
+
+Unicode codepoint properties, including scripts and blocks
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+``\p{property=value}``; ``\P{property=value}``; ``\p{value}`` ; ``\P{value}``
+
+Many Unicode properties are supported, including blocks and scripts. ``\p{property=value}`` or ``\p{property:value}`` matches a character whose property ``property`` has value ``value``. The inverse of ``\p{property=value}`` is ``\P{property=value}`` or ``\p{^property=value}``.
+
+If the short form ``\p{value}`` is used, the properties are checked in the order: ``General_Category``, ``Script``, ``Block``, binary property:
+
+* ``Latin``, the 'Latin' script (``Script=Latin``).
+
+* ``BasicLatin``, the 'BasicLatin' block (``Block=BasicLatin``).
+
+* ``Alphabetic``, the 'Alphabetic' binary property (``Alphabetic=Yes``).
+
+A short form starting with ``Is`` indicates a script or binary property:
+
+* ``IsLatin``, the 'Latin' script (``Script=Latin``).
+
+* ``IsAlphabetic``, the 'Alphabetic' binary property (``Alphabetic=Yes``).
+
+A short form starting with ``In`` indicates a block property:
+
+* ``InBasicLatin``, the 'BasicLatin' block (``Block=BasicLatin``).
+
+POSIX character classes
+^^^^^^^^^^^^^^^^^^^^^^^
+
+``[[:alpha:]]``; ``[[:^alpha:]]``
+
+POSIX character classes are supported. These are normally treated as an alternative form of ``\p{...}``.
+
+The exceptions are ``alnum``, ``digit``, ``punct`` and ``xdigit``, whose definitions are different from those of Unicode.
+
+``[[:alnum:]]`` is equivalent to ``\p{posix_alnum}``.
+
+``[[:digit:]]`` is equivalent to ``\p{posix_digit}``.
+
+``[[:punct:]]`` is equivalent to ``\p{posix_punct}``.
+
+``[[:xdigit:]]`` is equivalent to ``\p{posix_xdigit}``.
+
+Search anchor ``\G``
+^^^^^^^^^^^^^^^^^^^^
+
+A search anchor has been added. It matches at the position where each search started/continued and can be used for contiguous matches or in negative variable-length lookbehinds to limit how far back the lookbehind goes:
+
+.. sourcecode:: python
+
+ >>> regex.findall(r"\w{2}", "abcd ef")
+ ['ab', 'cd', 'ef']
+ >>> regex.findall(r"\G\w{2}", "abcd ef")
+ ['ab', 'cd']
+
+* The search starts at position 0 and matches 'ab'.
+
+* The search continues at position 2 and matches 'cd'.
+
+* The search continues at position 4 and fails to match any letters.
+
+* The anchor stops the search start position from being advanced, so there are no more results.
+
+Reverse searching
+^^^^^^^^^^^^^^^^^
+
+Searches can also work backwards:
+
+.. sourcecode:: python
+
+ >>> regex.findall(r".", "abc")
+ ['a', 'b', 'c']
+ >>> regex.findall(r"(?r).", "abc")
+ ['c', 'b', 'a']
+
+Note that the result of a reverse search is not necessarily the reverse of a forward search:
+
+.. sourcecode:: python
+
+ >>> regex.findall(r"..", "abcde")
+ ['ab', 'cd']
+ >>> regex.findall(r"(?r)..", "abcde")
+ ['de', 'bc']
+
+Matching a single grapheme ``\X``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The grapheme matcher is supported. It conforms to the Unicode specification at ``http://www.unicode.org/reports/tr29/``.
+
+Branch reset ``(?|...|...)``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Group numbers will be reused across the alternatives, but groups with different names will have different group numbers.
+
+.. sourcecode:: python
+
+ >>> regex.match(r"(?|(first)|(second))", "first").groups()
+ ('first',)
+ >>> regex.match(r"(?|(first)|(second))", "second").groups()
+ ('second',)
+
+Note that there is only one group.
+
+Default Unicode word boundary
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The ``WORD`` flag changes the definition of a 'word boundary' to that of a default Unicode word boundary. This applies to ``\b`` and ``\B``.
+
+Timeout
+^^^^^^^
+
+The matching methods and functions support timeouts. The timeout (in seconds) applies to the entire operation:
+
+.. sourcecode:: python
+
+ >>> from time import sleep
+ >>>
+ >>> def fast_replace(m):
+ ... return 'X'
+ ...
+ >>> def slow_replace(m):
+ ... sleep(0.5)
+ ... return 'X'
+ ...
+ >>> regex.sub(r'[a-z]', fast_replace, 'abcde', timeout=2)
+ 'XXXXX'
+ >>> regex.sub(r'[a-z]', slow_replace, 'abcde', timeout=2)
+ Traceback (most recent call last):
+ File "", line 1, in
+ File "C:\Python310\lib\site-packages\regex\regex.py", line 278, in sub
+ return pat.sub(repl, string, count, pos, endpos, concurrent, timeout)
+ TimeoutError: regex timed out
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/regex-2024.11.6.dist-info/RECORD b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/regex-2024.11.6.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..c5baca8cb153d8c46fad0c58af6a072af8db2aec
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/regex-2024.11.6.dist-info/RECORD
@@ -0,0 +1,15 @@
+regex-2024.11.6.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+regex-2024.11.6.dist-info/LICENSE.txt,sha256=v_Ve9M3MjBTOJZ-OirYOJkQYRA1jNfTcE4Jz-9UGFE0,11584
+regex-2024.11.6.dist-info/METADATA,sha256=g01OaInJKSZgaE-sd6S4Bawc-xS2fg0yHRbrU1OXzpg,40487
+regex-2024.11.6.dist-info/RECORD,,
+regex-2024.11.6.dist-info/WHEEL,sha256=mIXbsg-cAyeYqDkjHdCRXNw3PfO3jjESCxdFVt6S9zI,151
+regex-2024.11.6.dist-info/top_level.txt,sha256=aQmiDMhNTF26cCK4_7D-qaVvhbxClG0wyCTnEhkzYBs,6
+regex/__init__.py,sha256=9slNQEb4SCZ9LncNzcQvqmkyxXlcOAF7QwAwigxWjsw,65
+regex/__pycache__/__init__.cpython-312.pyc,,
+regex/__pycache__/_regex_core.cpython-312.pyc,,
+regex/__pycache__/regex.cpython-312.pyc,,
+regex/__pycache__/test_regex.cpython-312.pyc,,
+regex/_regex.cpython-312-x86_64-linux-gnu.so,sha256=NupR53EP-Dniymvj2j7XFQpsxNDWr_VQHQiqBeFJRGI,2605512
+regex/_regex_core.py,sha256=MI8nzE7gBEUTDDrao8aOHg7_QhhDzE07VoKFl_WSxCM,141028
+regex/regex.py,sha256=gzxSPPegvGU13Hl64L5aviFexrkXVvu390FTG5aEEWs,32683
+regex/test_regex.py,sha256=x_FfGHpd7hT0BFQ_jCetdxv7GxdziBZHgsT8X0FVTOM,222040
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/regex-2024.11.6.dist-info/WHEEL b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/regex-2024.11.6.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..940a4a01452c748fd7252671b1f10430c372b161
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/regex-2024.11.6.dist-info/WHEEL
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.3.0)
+Root-Is-Purelib: false
+Tag: cp312-cp312-manylinux_2_17_x86_64
+Tag: cp312-cp312-manylinux2014_x86_64
+
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/regex-2024.11.6.dist-info/top_level.txt b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/regex-2024.11.6.dist-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4f9256d62325c75de027d1cd48f1ff520117413e
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/regex-2024.11.6.dist-info/top_level.txt
@@ -0,0 +1 @@
+regex
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/requests-2.32.3.dist-info/INSTALLER b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/requests-2.32.3.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/requests-2.32.3.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/requests-2.32.3.dist-info/LICENSE b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/requests-2.32.3.dist-info/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..67db8588217f266eb561f75fae738656325deac9
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/requests-2.32.3.dist-info/LICENSE
@@ -0,0 +1,175 @@
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/requests-2.32.3.dist-info/METADATA b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/requests-2.32.3.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..72d9dc5313849bf6c7322781ef6bbe2400d02c45
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/requests-2.32.3.dist-info/METADATA
@@ -0,0 +1,119 @@
+Metadata-Version: 2.1
+Name: requests
+Version: 2.32.3
+Summary: Python HTTP for Humans.
+Home-page: https://requests.readthedocs.io
+Author: Kenneth Reitz
+Author-email: me@kennethreitz.org
+License: Apache-2.0
+Project-URL: Documentation, https://requests.readthedocs.io
+Project-URL: Source, https://github.com/psf/requests
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: charset-normalizer <4,>=2
+Requires-Dist: idna <4,>=2.5
+Requires-Dist: urllib3 <3,>=1.21.1
+Requires-Dist: certifi >=2017.4.17
+Provides-Extra: security
+Provides-Extra: socks
+Requires-Dist: PySocks !=1.5.7,>=1.5.6 ; extra == 'socks'
+Provides-Extra: use_chardet_on_py3
+Requires-Dist: chardet <6,>=3.0.2 ; extra == 'use_chardet_on_py3'
+
+# Requests
+
+**Requests** is a simple, yet elegant, HTTP library.
+
+```python
+>>> import requests
+>>> r = requests.get('https://httpbin.org/basic-auth/user/pass', auth=('user', 'pass'))
+>>> r.status_code
+200
+>>> r.headers['content-type']
+'application/json; charset=utf8'
+>>> r.encoding
+'utf-8'
+>>> r.text
+'{"authenticated": true, ...'
+>>> r.json()
+{'authenticated': True, ...}
+```
+
+Requests allows you to send HTTP/1.1 requests extremely easily. There’s no need to manually add query strings to your URLs, or to form-encode your `PUT` & `POST` data — but nowadays, just use the `json` method!
+
+Requests is one of the most downloaded Python packages today, pulling in around `30M downloads / week`— according to GitHub, Requests is currently [depended upon](https://github.com/psf/requests/network/dependents?package_id=UGFja2FnZS01NzA4OTExNg%3D%3D) by `1,000,000+` repositories. You may certainly put your trust in this code.
+
+[](https://pepy.tech/project/requests)
+[](https://pypi.org/project/requests)
+[](https://github.com/psf/requests/graphs/contributors)
+
+## Installing Requests and Supported Versions
+
+Requests is available on PyPI:
+
+```console
+$ python -m pip install requests
+```
+
+Requests officially supports Python 3.8+.
+
+## Supported Features & Best–Practices
+
+Requests is ready for the demands of building robust and reliable HTTP–speaking applications, for the needs of today.
+
+- Keep-Alive & Connection Pooling
+- International Domains and URLs
+- Sessions with Cookie Persistence
+- Browser-style TLS/SSL Verification
+- Basic & Digest Authentication
+- Familiar `dict`–like Cookies
+- Automatic Content Decompression and Decoding
+- Multi-part File Uploads
+- SOCKS Proxy Support
+- Connection Timeouts
+- Streaming Downloads
+- Automatic honoring of `.netrc`
+- Chunked HTTP Requests
+
+## API Reference and User Guide available on [Read the Docs](https://requests.readthedocs.io)
+
+[](https://requests.readthedocs.io)
+
+## Cloning the repository
+
+When cloning the Requests repository, you may need to add the `-c
+fetch.fsck.badTimezone=ignore` flag to avoid an error about a bad commit (see
+[this issue](https://github.com/psf/requests/issues/2690) for more background):
+
+```shell
+git clone -c fetch.fsck.badTimezone=ignore https://github.com/psf/requests.git
+```
+
+You can also apply this setting to your global Git config:
+
+```shell
+git config --global fetch.fsck.badTimezone ignore
+```
+
+---
+
+[](https://kennethreitz.org) [](https://www.python.org/psf)
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/requests-2.32.3.dist-info/RECORD b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/requests-2.32.3.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..fede80f31a311e60a7e84af6856bc38a43ca9319
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/requests-2.32.3.dist-info/RECORD
@@ -0,0 +1,42 @@
+requests-2.32.3.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+requests-2.32.3.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
+requests-2.32.3.dist-info/METADATA,sha256=ZY7oRUweLnb7jCEnEW9hFWs7IpQbNVnAA4ncpwA4WBo,4610
+requests-2.32.3.dist-info/RECORD,,
+requests-2.32.3.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+requests-2.32.3.dist-info/top_level.txt,sha256=fMSVmHfb5rbGOo6xv-O_tUX6j-WyixssE-SnwcDRxNQ,9
+requests/__init__.py,sha256=4xaAERmPDIBPsa2PsjpU9r06yooK-2mZKHTZAhWRWts,5072
+requests/__pycache__/__init__.cpython-312.pyc,,
+requests/__pycache__/__version__.cpython-312.pyc,,
+requests/__pycache__/_internal_utils.cpython-312.pyc,,
+requests/__pycache__/adapters.cpython-312.pyc,,
+requests/__pycache__/api.cpython-312.pyc,,
+requests/__pycache__/auth.cpython-312.pyc,,
+requests/__pycache__/certs.cpython-312.pyc,,
+requests/__pycache__/compat.cpython-312.pyc,,
+requests/__pycache__/cookies.cpython-312.pyc,,
+requests/__pycache__/exceptions.cpython-312.pyc,,
+requests/__pycache__/help.cpython-312.pyc,,
+requests/__pycache__/hooks.cpython-312.pyc,,
+requests/__pycache__/models.cpython-312.pyc,,
+requests/__pycache__/packages.cpython-312.pyc,,
+requests/__pycache__/sessions.cpython-312.pyc,,
+requests/__pycache__/status_codes.cpython-312.pyc,,
+requests/__pycache__/structures.cpython-312.pyc,,
+requests/__pycache__/utils.cpython-312.pyc,,
+requests/__version__.py,sha256=FVfglgZmNQnmYPXpOohDU58F5EUb_-VnSTaAesS187g,435
+requests/_internal_utils.py,sha256=nMQymr4hs32TqVo5AbCrmcJEhvPUh7xXlluyqwslLiQ,1495
+requests/adapters.py,sha256=KIcecscqam6reOCXRl4DwP4jX8Jcl8sd57ft17KR2cQ,27451
+requests/api.py,sha256=_Zb9Oa7tzVIizTKwFrPjDEY9ejtm_OnSRERnADxGsQs,6449
+requests/auth.py,sha256=kF75tqnLctZ9Mf_hm9TZIj4cQWnN5uxRz8oWsx5wmR0,10186
+requests/certs.py,sha256=Z9Sb410Anv6jUFTyss0jFFhU6xst8ctELqfy8Ev23gw,429
+requests/compat.py,sha256=C5w_DPLSurXPgcdWU78fora0APmbYkX2G89QvH5xzPA,1817
+requests/cookies.py,sha256=bNi-iqEj4NPZ00-ob-rHvzkvObzN3lEpgw3g6paS3Xw,18590
+requests/exceptions.py,sha256=jJPS1UWATs86ShVUaLorTiJb1SaGuoNEWgICJep-VkY,4260
+requests/help.py,sha256=gPX5d_H7Xd88aDABejhqGgl9B1VFRTt5BmiYvL3PzIQ,3875
+requests/hooks.py,sha256=CiuysiHA39V5UfcCBXFIx83IrDpuwfN9RcTUgv28ftQ,733
+requests/models.py,sha256=k42roXzC8u_OagAPQi9U4MkfO7i4r2FdaqvMqstPehc,35418
+requests/packages.py,sha256=_g0gZ681UyAlKHRjH6kanbaoxx2eAb6qzcXiODyTIoc,904
+requests/sessions.py,sha256=ykTI8UWGSltOfH07HKollH7kTBGw4WhiBVaQGmckTw4,30495
+requests/status_codes.py,sha256=iJUAeA25baTdw-6PfD0eF4qhpINDJRJI-yaMqxs4LEI,4322
+requests/structures.py,sha256=-IbmhVz06S-5aPSZuUthZ6-6D9XOjRuTXHOabY041XM,2912
+requests/utils.py,sha256=HiQC6Nq_Da3ktaMiFzQkh-dCk3iQHHKEsYS5kDc-8Cw,33619
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/requests-2.32.3.dist-info/WHEEL b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/requests-2.32.3.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..bab98d675883cc7567a79df485cd7b4f015e376f
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/requests-2.32.3.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.43.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/requests-2.32.3.dist-info/top_level.txt b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/requests-2.32.3.dist-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f2293605cf1b01dca72aad0a15c45b72ed5429a2
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/requests-2.32.3.dist-info/top_level.txt
@@ -0,0 +1 @@
+requests
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/sacrebleu/__init__.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/sacrebleu/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..111f284d188809c06a339ecddfa3fba2b853d25b
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/sacrebleu/__init__.py
@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# Copyright 2017--2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You may not
+# use this file except in compliance with the License. A copy of the License
+# is located at
+#
+# http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is distributed on
+# an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+# express or implied. See the License for the specific language governing
+# permissions and limitations under the License.
+
+__description__ = "Hassle-free computation of shareable, comparable, and reproducible BLEU, chrF, and TER scores"
+
+
+# Backward compatibility functions for old style API access (<= 1.4.10)
+from .compat import (
+ corpus_bleu,
+ corpus_chrf,
+ corpus_ter,
+ raw_corpus_bleu,
+ sentence_bleu,
+ sentence_chrf,
+ sentence_ter,
+)
+from .dataset import DATASETS
+from .metrics import BLEU, CHRF, TER
+from .metrics.helpers import extract_char_ngrams, extract_word_ngrams
+from .utils import (
+ SACREBLEU_DIR,
+ download_test_set,
+ get_available_testsets,
+ get_langpairs_for_testset,
+ get_reference_files,
+ get_source_file,
+ smart_open,
+)
+from .version import __version__
+
+__all__ = [
+ "smart_open",
+ "SACREBLEU_DIR",
+ "download_test_set",
+ "get_source_file",
+ "get_reference_files",
+ "get_available_testsets",
+ "get_langpairs_for_testset",
+ "extract_word_ngrams",
+ "extract_char_ngrams",
+ "DATASETS",
+ "BLEU",
+ "CHRF",
+ "TER",
+ "corpus_bleu",
+ "raw_corpus_bleu",
+ "sentence_bleu",
+ "corpus_chrf",
+ "sentence_chrf",
+ "corpus_ter",
+ "sentence_ter",
+ "__version__",
+]
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/sacrebleu/__main__.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/sacrebleu/__main__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3833741e8076dbac776a383f8e05ce8cafaac92e
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/sacrebleu/__main__.py
@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# Copyright 2017--2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You may not
+# use this file except in compliance with the License. A copy of the License
+# is located at
+#
+# http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is distributed on
+# an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+# express or implied. See the License for the specific language governing
+# permissions and limitations under the License.
+
+"""
+SacreBLEU provides hassle-free computation of shareable, comparable, and reproducible BLEU scores.
+Inspired by Rico Sennrich's `multi-bleu-detok.perl`, it produces the official WMT scores but works with plain text.
+It also knows all the standard test sets and handles downloading, processing, and tokenization for you.
+
+See the [README.md] file for more information.
+"""
+from .sacrebleu import main
+
+if __name__ == '__main__':
+ main()
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/sacrebleu/compat.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/sacrebleu/compat.py
new file mode 100644
index 0000000000000000000000000000000000000000..573596037928ddc5b8c5b8df99202c13f0681943
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/sacrebleu/compat.py
@@ -0,0 +1,205 @@
+from typing import Sequence, Optional
+
+from .metrics import BLEU, CHRF, TER, BLEUScore, CHRFScore, TERScore
+
+
+######################################################################
+# Backward compatibility functions for old style API access (< 1.4.11)
+######################################################################
+def corpus_bleu(hypotheses: Sequence[str],
+ references: Sequence[Sequence[str]],
+ smooth_method='exp',
+ smooth_value=None,
+ force=False,
+ lowercase=False,
+ tokenize=BLEU.TOKENIZER_DEFAULT,
+ use_effective_order=False) -> BLEUScore:
+ """Computes BLEU for a corpus against a single (or multiple) reference(s).
+ This is the main CLI entry point for computing BLEU between a system output
+ and a reference sentence.
+
+ :param hypotheses: A sequence of hypothesis strings.
+ :param references: A sequence of reference documents with document being
+ defined as a sequence of reference strings.
+ :param smooth_method: The smoothing method to use ('floor', 'add-k', 'exp' or 'none')
+ :param smooth_value: The smoothing value for `floor` and `add-k` methods. `None` falls back to default value.
+ :param force: Ignore data that looks already tokenized
+ :param lowercase: Lowercase the data
+ :param tokenize: The tokenizer to use
+ :param use_effective_order: Don't take into account n-gram orders without any match.
+ :return: a `BLEUScore` object
+ """
+ metric = BLEU(
+ lowercase=lowercase, force=force, tokenize=tokenize,
+ smooth_method=smooth_method, smooth_value=smooth_value,
+ effective_order=use_effective_order)
+
+ return metric.corpus_score(hypotheses, references)
+
+
+def raw_corpus_bleu(hypotheses: Sequence[str],
+ references: Sequence[Sequence[str]],
+ smooth_value: Optional[float] = BLEU.SMOOTH_DEFAULTS['floor']) -> BLEUScore:
+ """Computes BLEU for a corpus against a single (or multiple) reference(s).
+ This convenience function assumes a particular set of arguments i.e.
+ it disables tokenization and applies a `floor` smoothing with value `0.1`.
+
+ This convenience call does not apply any tokenization at all,
+ neither to the system output nor the reference. It just computes
+ BLEU on the "raw corpus" (hence the name).
+
+ :param hypotheses: A sequence of hypothesis strings.
+ :param references: A sequence of reference documents with document being
+ defined as a sequence of reference strings.
+ :param smooth_value: The smoothing value for `floor`. If not given, the default of 0.1 is used.
+ :return: Returns a `BLEUScore` object.
+
+ """
+ return corpus_bleu(
+ hypotheses, references, smooth_method='floor',
+ smooth_value=smooth_value, force=True, tokenize='none',
+ use_effective_order=True)
+
+
+def sentence_bleu(hypothesis: str,
+ references: Sequence[str],
+ smooth_method: str = 'exp',
+ smooth_value: Optional[float] = None,
+ lowercase: bool = False,
+ tokenize=BLEU.TOKENIZER_DEFAULT,
+ use_effective_order: bool = True) -> BLEUScore:
+ """
+ Computes BLEU for a single sentence against a single (or multiple) reference(s).
+
+ Disclaimer: Computing BLEU at the sentence level is not its intended use as
+ BLEU is a corpus-level metric.
+
+ :param hypothesis: A single hypothesis string.
+ :param references: A sequence of reference strings.
+ :param smooth_method: The smoothing method to use ('floor', 'add-k', 'exp' or 'none')
+ :param smooth_value: The smoothing value for `floor` and `add-k` methods. `None` falls back to default value.
+ :param lowercase: Lowercase the data
+ :param tokenize: The tokenizer to use
+ :param use_effective_order: Don't take into account n-gram orders without any match.
+ :return: Returns a `BLEUScore` object.
+ """
+ metric = BLEU(
+ lowercase=lowercase, tokenize=tokenize, force=False,
+ smooth_method=smooth_method, smooth_value=smooth_value,
+ effective_order=use_effective_order)
+
+ return metric.sentence_score(hypothesis, references)
+
+
+def corpus_chrf(hypotheses: Sequence[str],
+ references: Sequence[Sequence[str]],
+ char_order: int = CHRF.CHAR_ORDER,
+ word_order: int = CHRF.WORD_ORDER,
+ beta: int = CHRF.BETA,
+ remove_whitespace: bool = True,
+ eps_smoothing: bool = False) -> CHRFScore:
+ """
+ Computes chrF for a corpus against a single (or multiple) reference(s).
+ If `word_order` equals to 2, the metric is referred to as chrF++.
+
+ :param hypotheses: A sequence of hypothesis strings.
+ :param references: A sequence of reference documents with document being
+ defined as a sequence of reference strings.
+ :param char_order: Character n-gram order.
+ :param word_order: Word n-gram order. If equals to 2, the metric is referred to as chrF++.
+ :param beta: Determine the importance of recall w.r.t precision.
+ :param eps_smoothing: If `True`, applies epsilon smoothing similar
+ to reference chrF++.py, NLTK and Moses implementations. Otherwise,
+ it takes into account effective match order similar to sacreBLEU < 2.0.0.
+ :param remove_whitespace: If `True`, removes whitespaces prior to character n-gram extraction.
+ :return: A `CHRFScore` object.
+ """
+ metric = CHRF(
+ char_order=char_order,
+ word_order=word_order,
+ beta=beta,
+ whitespace=not remove_whitespace,
+ eps_smoothing=eps_smoothing)
+ return metric.corpus_score(hypotheses, references)
+
+
+def sentence_chrf(hypothesis: str,
+ references: Sequence[str],
+ char_order: int = CHRF.CHAR_ORDER,
+ word_order: int = CHRF.WORD_ORDER,
+ beta: int = CHRF.BETA,
+ remove_whitespace: bool = True,
+ eps_smoothing: bool = False) -> CHRFScore:
+ """
+ Computes chrF for a single sentence against a single (or multiple) reference(s).
+ If `word_order` equals to 2, the metric is referred to as chrF++.
+
+ :param hypothesis: A single hypothesis string.
+ :param references: A sequence of reference strings.
+ :param char_order: Character n-gram order.
+ :param word_order: Word n-gram order. If equals to 2, the metric is referred to as chrF++.
+ :param beta: Determine the importance of recall w.r.t precision.
+ :param eps_smoothing: If `True`, applies epsilon smoothing similar
+ to reference chrF++.py, NLTK and Moses implementations. Otherwise,
+ it takes into account effective match order similar to sacreBLEU < 2.0.0.
+ :param remove_whitespace: If `True`, removes whitespaces prior to character n-gram extraction.
+ :return: A `CHRFScore` object.
+ """
+ metric = CHRF(
+ char_order=char_order,
+ word_order=word_order,
+ beta=beta,
+ whitespace=not remove_whitespace,
+ eps_smoothing=eps_smoothing)
+ return metric.sentence_score(hypothesis, references)
+
+
+def corpus_ter(hypotheses: Sequence[str],
+ references: Sequence[Sequence[str]],
+ normalized: bool = False,
+ no_punct: bool = False,
+ asian_support: bool = False,
+ case_sensitive: bool = False) -> TERScore:
+ """
+ Computes TER for a corpus against a single (or multiple) reference(s).
+
+ :param hypotheses: A sequence of hypothesis strings.
+ :param references: A sequence of reference documents with document being
+ defined as a sequence of reference strings.
+ :param normalized: Enable character normalization.
+ :param no_punct: Remove punctuation.
+ :param asian_support: Enable special treatment of Asian characters.
+ :param case_sensitive: Enables case-sensitivity.
+ :return: A `TERScore` object.
+ """
+ metric = TER(
+ normalized=normalized,
+ no_punct=no_punct,
+ asian_support=asian_support,
+ case_sensitive=case_sensitive)
+ return metric.corpus_score(hypotheses, references)
+
+
+def sentence_ter(hypothesis: str,
+ references: Sequence[str],
+ normalized: bool = False,
+ no_punct: bool = False,
+ asian_support: bool = False,
+ case_sensitive: bool = False) -> TERScore:
+ """
+ Computes TER for a single hypothesis against a single (or multiple) reference(s).
+
+ :param hypothesis: A single hypothesis string.
+ :param references: A sequence of reference strings.
+ :param normalized: Enable character normalization.
+ :param no_punct: Remove punctuation.
+ :param asian_support: Enable special treatment of Asian characters.
+ :param case_sensitive: Enable case-sensitivity.
+ :return: A `TERScore` object.
+ """
+ metric = TER(
+ normalized=normalized,
+ no_punct=no_punct,
+ asian_support=asian_support,
+ case_sensitive=case_sensitive)
+ return metric.sentence_score(hypothesis, references)
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/sacrebleu/py.typed b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/sacrebleu/py.typed
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/sacrebleu/sacrebleu.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/sacrebleu/sacrebleu.py
new file mode 100644
index 0000000000000000000000000000000000000000..6b7cd9e798e5a8baf3eb9d7e50b056ede59b1e0b
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/sacrebleu/sacrebleu.py
@@ -0,0 +1,576 @@
+#!/usr/bin/env python3
+
+# Copyright 2017--2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You may not
+# use this file except in compliance with the License. A copy of the License
+# is located at
+#
+# http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is distributed on
+# an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+# express or implied. See the License for the specific language governing
+# permissions and limitations under the License.
+
+"""
+SacreBLEU provides hassle-free computation of shareable, comparable, and reproducible BLEU scores.
+Inspired by Rico Sennrich's `multi-bleu-detok.perl`, it produces the official WMT scores but works with plain text.
+It also knows all the standard test sets and handles downloading, processing, and tokenization for you.
+
+See the [README.md] file for more information.
+"""
+
+import io
+import os
+import sys
+import logging
+import pathlib
+import argparse
+from collections import defaultdict
+
+
+# Allows calling the script as a standalone utility
+# See: https://github.com/mjpost/sacrebleu/issues/86
+if __package__ is None and __name__ == '__main__':
+ parent = pathlib.Path(__file__).absolute().parents[1]
+ sys.path.insert(0, str(parent))
+ __package__ = 'sacrebleu'
+
+from .dataset import DATASETS
+from .metrics import METRICS
+from .utils import smart_open, filter_subset, get_langpairs_for_testset, get_available_testsets
+from .utils import print_test_set, print_subset_results, get_reference_files, download_test_set
+from .utils import args_to_dict, sanity_check_lengths, print_results_table, print_single_results
+from .utils import get_available_testsets_for_langpair, Color
+
+from . import __version__ as VERSION
+
+sacrelogger = logging.getLogger('sacrebleu')
+
+try:
+ # SIGPIPE is not available on Windows machines, throwing an exception.
+ from signal import SIGPIPE # type: ignore
+
+ # If SIGPIPE is available, change behaviour to default instead of ignore.
+ from signal import signal, SIG_DFL
+ signal(SIGPIPE, SIG_DFL)
+except ImportError:
+ pass
+
+
+def parse_args():
+ arg_parser = argparse.ArgumentParser(
+ description='sacreBLEU: Hassle-free computation of shareable BLEU scores.\n'
+ 'Quick usage: score your detokenized output against WMT\'14 EN-DE:\n'
+ ' cat output.detok.de | sacrebleu -t wmt14 -l en-de',
+ formatter_class=argparse.RawDescriptionHelpFormatter)
+
+ arg_parser.add_argument('--citation', '--cite', default=False, action='store_true',
+ help='Dump the bibtex citation and quit.')
+ arg_parser.add_argument('--list', default=False, action='store_true',
+ help='Print a list of all available test sets.')
+ arg_parser.add_argument('--test-set', '-t', type=str, default=None,
+ help='The test set to use (see also --list) or a comma-separated list of test sets to be concatenated.')
+ arg_parser.add_argument('--language-pair', '-l', dest='langpair', default=None,
+ help='Source-target language pair (2-char ISO639-1 codes).')
+ arg_parser.add_argument('--origlang', '-ol', dest='origlang', default=None,
+ help='Use a subset of sentences with a given original language (2-char ISO639-1 codes), "non-" prefix means negation.')
+ arg_parser.add_argument('--subset', dest='subset', default=None,
+ help='Use a subset of sentences whose document annotation matches a given regex (see SUBSETS in the source code).')
+ arg_parser.add_argument('--download', type=str, default=None,
+ help='Download a test set and quit.')
+ arg_parser.add_argument('--echo', nargs="+", type=str, default=None,
+ help='Output the source (src), reference (ref), or other available field (docid, ref:A, ref:1 for example) to STDOUT and quit. '
+ 'You can get available fields with options `--list` and `-t`' 'For example: `sacrebleu -t wmt21 --list`. '
+ 'If multiple fields are given, they are outputted with tsv format in the order they are given.'
+ 'You can also use `--echo all` to output all available fields.')
+
+ # I/O related arguments
+ # Multiple input files can be provided for significance testing for example
+ arg_parser.add_argument('--input', '-i', type=str, nargs='*', default=None,
+ help='Read input from file(s) instead of STDIN.')
+ arg_parser.add_argument('refs', nargs='*', default=[],
+ help='Optional list of references. If given, it should preceed the -i/--input argument.')
+ arg_parser.add_argument('--num-refs', '-nr', type=int, default=1,
+ help='Split the reference stream on tabs, and expect this many references. (Default: %(default)s)')
+ arg_parser.add_argument('--encoding', '-e', type=str, default='utf-8',
+ help='Open text files with specified encoding (Default: %(default)s)')
+
+ # Metric selection
+ avail_metrics = [m.lower() for m in METRICS]
+ arg_parser.add_argument('--metrics', '-m', choices=avail_metrics, nargs='+', default=['bleu'],
+ help='Space-delimited list of metrics to compute (Default: bleu)')
+ arg_parser.add_argument('--sentence-level', '-sl', action='store_true', help='Compute metric for each sentence.')
+
+ # BLEU-related arguments
+ # since sacreBLEU had only support for BLEU initially, the argument names
+ # are not prefixed with 'bleu' as in chrF arguments for example.
+ # Let's do that manually here through dest= options, as otherwise
+ # things will get quite hard to maintain when other metrics are added.
+ bleu_args = arg_parser.add_argument_group('BLEU related arguments')
+
+ bleu_args.add_argument('--smooth-method', '-s', choices=METRICS['BLEU'].SMOOTH_DEFAULTS.keys(), default='exp',
+ dest='bleu_smooth_method',
+ help='Smoothing method: exponential decay, floor (increment zero counts), add-k (increment num/denom by k for n>1), or none. (Default: %(default)s)')
+ bleu_args.add_argument('--smooth-value', '-sv', type=float, default=None,
+ dest='bleu_smooth_value',
+ help='The smoothing value. Only valid for floor and add-k. '
+ f"(Defaults: floor: {METRICS['BLEU'].SMOOTH_DEFAULTS['floor']}, "
+ f"add-k: {METRICS['BLEU'].SMOOTH_DEFAULTS['add-k']})")
+ bleu_args.add_argument('--tokenize', '-tok', choices=METRICS['BLEU'].TOKENIZERS, default=None,
+ dest='bleu_tokenize',
+ help='Tokenization method to use for BLEU. If not provided, defaults to `zh` for Chinese, '
+ '`ja-mecab` for Japanese, `ko-mecab` for Korean and `13a` (mteval) otherwise.')
+ bleu_args.add_argument('--lowercase', '-lc', dest='bleu_lowercase', action='store_true', default=False,
+ help='If True, enables case-insensitivity. (Default: %(default)s)')
+ bleu_args.add_argument('--force', default=False, action='store_true',
+ dest='bleu_force', help='Insist that your tokenized input is actually detokenized.')
+
+ # ChrF-related arguments
+ chrf_args = arg_parser.add_argument_group('chrF related arguments')
+ chrf_args.add_argument('--chrf-char-order', '-cc', type=int, default=METRICS['CHRF'].CHAR_ORDER,
+ help='Character n-gram order. (Default: %(default)s)')
+ chrf_args.add_argument('--chrf-word-order', '-cw', type=int, default=METRICS['CHRF'].WORD_ORDER,
+ help='Word n-gram order (Default: %(default)s). If equals to 2, the metric is referred to as chrF++.')
+ chrf_args.add_argument('--chrf-beta', type=int, default=METRICS['CHRF'].BETA,
+ help='Determine the importance of recall w.r.t precision. (Default: %(default)s)')
+ chrf_args.add_argument('--chrf-whitespace', action='store_true', default=False,
+ help='Include whitespaces when extracting character n-grams. (Default: %(default)s)')
+ chrf_args.add_argument('--chrf-lowercase', action='store_true', default=False,
+ help='Enable case-insensitivity. (Default: %(default)s)')
+ chrf_args.add_argument('--chrf-eps-smoothing', action='store_true', default=False,
+ help='Enables epsilon smoothing similar to chrF++.py, NLTK and Moses; instead of effective order smoothing. (Default: %(default)s)')
+
+ # TER related arguments
+ ter_args = arg_parser.add_argument_group("TER related arguments (The defaults replicate TERCOM's behavior)")
+ ter_args.add_argument('--ter-case-sensitive', action='store_true',
+ help='Enables case sensitivity. (Default: %(default)s)')
+ ter_args.add_argument('--ter-asian-support', action='store_true',
+ help='Enables special treatment of Asian characters. (Default: %(default)s)')
+ ter_args.add_argument('--ter-no-punct', action='store_true',
+ help='Removes punctuation. (Default: %(default)s)')
+ ter_args.add_argument('--ter-normalized', action='store_true',
+ help='Applies basic normalization and tokenization. (Default: %(default)s)')
+
+ # Bootstrap resampling for confidence intervals
+ sign_args = arg_parser.add_argument_group('Confidence interval (CI) estimation for single-system evaluation')
+ sign_args.add_argument('--confidence', '-ci', action='store_true',
+ help='Report confidence interval using bootstrap resampling.')
+ sign_args.add_argument('--confidence-n', '-cin', type=int, default=1000,
+ help='Set the number of bootstrap resamples for CI estimation (Default: %(default)s).')
+
+ # Paired significance testing
+ pair_args = arg_parser.add_argument_group('Paired significance testing for multi-system evaluation')
+ pair_args_choice = pair_args.add_mutually_exclusive_group()
+
+ pair_args_choice.add_argument('--paired-ar', '-par', action='store_true',
+ help='Perform paired test using approximate randomization (AR). This option is '
+ 'mutually exclusive with --paired-bs (Default: %(default)s).')
+ pair_args_choice.add_argument('--paired-bs', '-pbs', action='store_true',
+ help='Perform paired test using bootstrap resampling. This option is '
+ 'mutually exclusive with --paired-ar (Default: %(default)s).')
+
+ pair_args.add_argument('--paired-ar-n', '-parn', type=int, default=10000,
+ help='Number of trials for approximate randomization test (Default: %(default)s).')
+
+ pair_args.add_argument('--paired-bs-n', '-pbsn', type=int, default=1000,
+ help='Number of bootstrap resamples for paired bootstrap resampling test (Default: %(default)s).')
+
+ pair_args.add_argument('--paired-jobs', '-j', type=int, default=1,
+ help='If 0, launches as many workers as the number of systems. If > 0, sets the number of workers manually. '
+ 'This feature is currently not supported on Windows.')
+
+ # Reporting related arguments
+ report_args = arg_parser.add_argument_group('Reporting related arguments')
+ report_args.add_argument('--quiet', '-q', default=False, action='store_true',
+ help='Suppress verbose messages.')
+ report_args.add_argument('--short', '-sh', default=False, action='store_true',
+ help='Produce a shorter (less human readable) signature.')
+ report_args.add_argument('--score-only', '-b', default=False, action='store_true',
+ help='Print only the computed score.')
+ report_args.add_argument('--width', '-w', type=int, default=1,
+ help='Floating point width (Default: %(default)s).')
+ report_args.add_argument('--detail', '-d', default=False, action='store_true',
+ help='Print detailed information (split test sets based on origlang).')
+ report_args.add_argument('--no-color', '-nc', action='store_true',
+ help='Disable the occasional use of terminal colors.')
+
+ output_formats = ['json', 'text', 'latex']
+ report_args.add_argument('--format', '-f', default='json', choices=output_formats,
+ help='Set the output format. `latex` is only valid for multi-system mode whereas '
+ '`json` and `text` apply to single-system mode only. This flag is overridden if the '
+ 'SACREBLEU_FORMAT environment variable is set to one of the valid choices (Default: %(default)s).')
+
+ arg_parser.add_argument('--version', '-V', action='version', version='%(prog)s {}'.format(VERSION))
+
+ args = arg_parser.parse_args()
+
+ # Override the format from the environment, if any
+ if 'SACREBLEU_FORMAT' in os.environ:
+ _new_value = os.environ['SACREBLEU_FORMAT'].lower()
+ if _new_value in output_formats:
+ args.format = _new_value
+
+ return args
+
+
+def main():
+ args = parse_args()
+
+ # Is paired test requested?
+ paired_test_mode = args.paired_bs or args.paired_ar
+
+ # Explicitly set the encoding
+ sys.stdin = open(sys.stdin.fileno(), mode='r', encoding='utf-8', buffering=True, newline="\n")
+ sys.stdout = open(sys.stdout.fileno(), mode='w', encoding='utf-8', buffering=True)
+
+ if os.environ.get('NO_COLOR', False) or args.no_color:
+ Color.ENABLE_COLORS = False
+ else:
+ # These should come after all stdout manipulations otherwise cause
+ # issues esp. on Windows
+ import colorama
+ colorama.init()
+
+ if not args.quiet:
+ logging.basicConfig(level=logging.INFO, format='sacreBLEU: %(message)s')
+
+ if args.download:
+ download_test_set(args.download, args.langpair)
+ sys.exit(0)
+
+ if args.list:
+ if args.test_set:
+ for pair in [args.langpair] if args.langpair else get_langpairs_for_testset(args.test_set):
+ fields = DATASETS[args.test_set].fieldnames(pair)
+ print(f'{pair}: {", ".join(fields)}')
+ else:
+ if args.langpair:
+ print(f'The available test sets for {args.langpair} are:')
+ testsets = get_available_testsets_for_langpair(args.langpair)
+ else:
+ print('The available test sets are:')
+ testsets = get_available_testsets()
+ for testset in sorted(testsets):
+ desc = DATASETS[testset].description.strip()
+ print(f'{testset:<30}: {desc}')
+ sys.exit(0)
+
+ if args.sentence_level and len(args.metrics) > 1:
+ sacrelogger.error('Only one metric can be used in sentence-level mode.')
+ sys.exit(1)
+
+ if args.citation:
+ if not args.test_set:
+ sacrelogger.error('I need a test set (-t).')
+ sys.exit(1)
+ for test_set in args.test_set.split(','):
+ if 'citation' not in DATASETS[test_set]:
+ sacrelogger.error(f'No citation found for {test_set}')
+ else:
+ print(DATASETS[test_set].citation)
+ sys.exit(0)
+
+ if args.num_refs != 1 and (args.test_set is not None or len(args.refs) > 1):
+ sacrelogger.error('The --num-refs argument allows you to provide any number of tab-delimited references in a single file.')
+ sacrelogger.error('You can only use it with externally provided references, however (i.e., not with `-t`),')
+ sacrelogger.error('and you cannot then provide multiple reference files.')
+ sys.exit(1)
+
+ if args.test_set is not None:
+ for test_set in args.test_set.split(','):
+ if test_set not in DATASETS:
+ sacrelogger.error(f'Unknown test set {test_set!r}')
+ sacrelogger.error('Please run with --list to see the available test sets.')
+ sys.exit(1)
+
+ if args.test_set is None:
+ if len(args.refs) == 0:
+ sacrelogger.error('If manual references given, make sure to provide them '
+ 'before the -i/--input argument to avoid confusion.')
+ sacrelogger.error('Otherwise, I need a predefined test set (-t) from the following list:')
+ sacrelogger.error(get_available_testsets())
+ sys.exit(1)
+ elif len(args.refs) > 0:
+ sacrelogger.error('I need exactly one of (a) a predefined test set (-t) or (b) a list of references')
+ sys.exit(1)
+ elif args.langpair is None:
+ sacrelogger.error('I need a language pair (-l). Use --list to see available language pairs for this test set.')
+ sys.exit(1)
+ else:
+ for test_set in args.test_set.split(','):
+ langpairs = get_langpairs_for_testset(test_set)
+ if args.langpair not in langpairs:
+ sacrelogger.error(f'No such language pair {args.langpair!r}')
+ sacrelogger.error(f'Available language pairs for {test_set!r} are:')
+ for lp in langpairs:
+ sacrelogger.error(f' > {lp}')
+ sys.exit(1)
+
+ if args.echo:
+ if args.langpair is None or args.test_set is None:
+ sacrelogger.warning("--echo requires a test set (--t) and a language pair (-l)")
+ sys.exit(1)
+ for test_set in args.test_set.split(','):
+ print_test_set(test_set, args.langpair, args.echo, args.origlang, args.subset)
+ sys.exit(0)
+
+ # Hack: inject target language info for BLEU, so that it can
+ # select the tokenizer based on it
+ if args.langpair:
+ args.bleu_trg_lang = args.langpair.split('-')[1]
+
+ if args.test_set is not None and args.bleu_tokenize == 'none':
+ sacrelogger.warning(
+ "You are turning off BLEU's internal tokenizer "
+ "presumably to supply your own tokenized files.")
+ sacrelogger.warning(
+ "Published numbers will not be comparable to other papers.")
+
+ # concat_ref_files is a list of list of reference filenames
+ # (concatenation happens if multiple test sets are given through -t)
+ # Example: [[testset1_refA, testset1_refB], [testset2_refA, testset2_refB]]
+ concat_ref_files = []
+ if args.test_set is None:
+ concat_ref_files.append(args.refs)
+ else:
+ # Multiple test sets can be given
+ for test_set in args.test_set.split(','):
+ ref_files = get_reference_files(test_set, args.langpair)
+ if len(ref_files) == 0:
+ sacrelogger.warning(
+ f'No references found for test set {test_set}/{args.langpair}.')
+ concat_ref_files.append(ref_files)
+
+ #################
+ # Read references
+ #################
+ full_refs = [[] for x in range(max(len(concat_ref_files[0]), args.num_refs))]
+ for ref_files in concat_ref_files:
+ for refno, ref_file in enumerate(ref_files):
+ for lineno, line in enumerate(smart_open(ref_file, encoding=args.encoding), 1):
+ line = line.rstrip()
+ if args.num_refs == 1:
+ full_refs[refno].append(line)
+ else:
+ refs = line.split(sep='\t', maxsplit=args.num_refs - 1)
+ # We are strict in fixed number of references through CLI
+ # But the API supports having variable refs per each segment
+ # by simply having '' or None's as dummy placeholders
+ if len(refs) != args.num_refs:
+ sacrelogger.error(f'FATAL: line {lineno}: expected {args.num_refs} fields, but found {len(refs)}.')
+ sys.exit(17)
+ for refno, ref in enumerate(refs):
+ full_refs[refno].append(ref)
+
+ # Decide on the number of final references, override the argument
+ args.num_refs = len(full_refs)
+
+ # Read hypotheses
+ # Can't tokenize yet as each metric has its own way of tokenizing things
+ full_systems, sys_names = [], []
+
+ if args.input is None:
+ # Read from STDIN
+ inputfh = io.TextIOWrapper(sys.stdin.buffer, encoding=args.encoding)
+
+ # guess the number of systems by looking at the first line
+ fields = inputfh.readline().rstrip().split('\t')
+
+ # Set number of systems
+ num_sys = len(fields)
+
+ # place the first lines already
+ full_systems = [[s] for s in fields]
+
+ # Enumerate the systems
+ sys_names = [f'System {i + 1}' for i in range(num_sys)]
+
+ # Read the rest
+ for line in inputfh:
+ fields = line.rstrip().split('\t')
+ if len(fields) != num_sys:
+ sacrelogger.error('FATAL: the number of tab-delimited fields in the input stream differ across lines.')
+ sys.exit(17)
+ # Place systems into the list
+ for sys_idx, sent in enumerate(fields):
+ full_systems[sys_idx].append(sent.rstrip())
+ else:
+ # Separate files are given for each system output
+ # Ex: --input smt.txt nmt.txt
+ for fname in args.input:
+ sys_name = fname
+
+ if sys_name in sys_names:
+ if paired_test_mode and sys_name == sys_names[0]:
+ # We skip loading a system, if it was already the baseline
+ sacrelogger.info(f'Ignoring {sys_name!r} as it was also given as the baseline.')
+ continue
+ else:
+ # To avoid ambiguities, we fail if two systems have same names
+ sacrelogger.error(f"{sys_name!r} already used to name a system.")
+ sacrelogger.error("Make sure to have a different basename for each system.")
+ sys.exit(1)
+
+ # Read the system
+ lines = []
+ for line in smart_open(fname, encoding=args.encoding):
+ lines.append(line.rstrip())
+ full_systems.append(lines)
+ sys_names.append(sys_name)
+
+ # Set final number of systems
+ num_sys = len(sys_names)
+
+ # Add baseline prefix to the first system for clarity
+ if paired_test_mode:
+ if args.input is None:
+ # STDIN mode, no explicit system names
+ sys_names = ['Baseline'] + [f'System {i + 1}' for i in range(num_sys - 1)]
+ else:
+ # --input mode, we have names for the systems, just change the 1st one
+ sys_names[0] = f'Baseline: {sys_names[0]}'
+
+ if args.sentence_level:
+ if num_sys > 1:
+ sacrelogger.error('Only one system can be evaluated in sentence-level mode.')
+ sys.exit(1)
+ if args.confidence or paired_test_mode:
+ sacrelogger.error('Statistical tests are unavailable in sentence-level mode.')
+ sys.exit(1)
+
+ # >=2.0.0: effective_order is now part of BLEU class. For sentence-BLEU
+ # we now need to explicitly enable it without user's intervention
+ # for backward compatibility.
+ args.bleu_effective_order = True
+
+ if paired_test_mode and num_sys == 1:
+ sacrelogger.error('Paired tests require multiple input systems given to --input (-i).')
+ sys.exit(1)
+
+ if num_sys > 1 and args.confidence:
+ sacrelogger.error('Use paired tests (--paired) for multiple systems.')
+ sys.exit(1)
+
+ # Filter subsets if requested
+ outputs = filter_subset(
+ [*full_systems, *full_refs], args.test_set, args.langpair,
+ args.origlang, args.subset)
+
+ # Unpack systems & references back
+ systems, refs = outputs[:num_sys], outputs[num_sys:]
+
+ # Perform some sanity checks
+ for system in systems:
+ if len(system) == 0:
+ message = f'Test set {args.test_set!r} contains no sentence'
+ if args.origlang is not None or args.subset is not None:
+ message += ' with'
+ if args.origlang:
+ message += f' origlang={args.origlang}'
+ if args.subset:
+ message += f' subset={args.subset}' + args.subset
+ sacrelogger.error(message)
+ sys.exit(1)
+
+ # Check lengths
+ sanity_check_lengths(system, refs, test_set=args.test_set)
+
+ # Create the metrics
+ metrics = {}
+ for name in args.metrics:
+ # Each metric's specific arguments are prefixed with `metricname_`
+ # for grouping. Filter accordingly and strip the prefixes prior to
+ # metric object construction.
+ metric_args = args_to_dict(args, name.lower(), strip_prefix=True)
+
+ # This will cache reference stats for faster re-computation if required
+ metric_args['references'] = refs
+
+ # Make it uppercase for the rest of the code
+ name = name.upper()
+ metrics[name] = METRICS[name](**metric_args)
+
+ # Handle sentence level and quit
+ if args.sentence_level:
+ # one metric and one system in use for sentence-level
+ metric, system = list(metrics.values())[0], systems[0]
+
+ for hypothesis, *references in zip(system, *refs):
+ score = metric.sentence_score(hypothesis, references)
+ sig = metric.get_signature().format(args.short)
+ print(score.format(args.width, args.score_only, sig))
+
+ sys.exit(0)
+
+ if args.detail and args.format == 'json':
+ # The translationese info will interfere with JSON output, disable
+ args.format = 'text'
+
+ ##############################
+ # Corpus level evaluation mode
+ ##############################
+ if num_sys == 1:
+ # Single system evaluation mode
+ results = []
+ for name in sorted(metrics):
+ # compute the score
+ score = metrics[name].corpus_score(
+ system, references=None,
+ n_bootstrap=args.confidence_n if args.confidence else 1)
+ # get the signature
+ sig = metrics[name].get_signature().format(
+ args.short if args.format != 'json' else False)
+ results.append(
+ score.format(args.width, args.score_only, sig, args.format == 'json'))
+
+ print_single_results(results, args)
+
+ # Prints detailed information for translationese effect experiments
+ if args.detail:
+ print_subset_results(metrics, full_systems[0], full_refs, args)
+ else:
+ # Multi-system evaluation mode
+ named_systems = [(sys_names[i], systems[i]) for i in range(num_sys)]
+ sacrelogger.info(f'Found {num_sys} systems.')
+
+ if not paired_test_mode:
+ # Bootstrap resampling or the usual single score computation mode
+ sigs = {}
+ scores = defaultdict(list)
+ scores['System'] = sys_names
+
+ for sys_name, system in named_systems:
+ for name in sorted(metrics):
+ score = metrics[name].corpus_score(system, references=None)
+ sigs[score.name] = metrics[name].get_signature().format(args.short)
+ scores[score.name].append(score.format(args.width, True))
+
+ else:
+ # Paired significance testing mode
+ from .significance import PairedTest
+
+ # Set params
+ test_type = 'bs' if args.paired_bs else 'ar'
+ n_samples = args.paired_bs_n if args.paired_bs else args.paired_ar_n
+
+ ps = PairedTest(named_systems, metrics, references=None,
+ test_type=test_type, n_samples=n_samples,
+ n_jobs=args.paired_jobs)
+
+ # Set back the number of trials
+ args.paired_n = ps.n_samples
+
+ # Run the test
+ sigs, scores = ps()
+
+ # Get signature strings
+ sigs = {k: v.format(args.short) for k, v in sigs.items()}
+
+ # Dump the results
+ print_results_table(scores, sigs, args)
+
+
+if __name__ == '__main__':
+ main()
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/sacrebleu/significance.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/sacrebleu/significance.py
new file mode 100644
index 0000000000000000000000000000000000000000..a9c71d0ab935d0eb195b68126bcad4bdf0facd6e
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/sacrebleu/significance.py
@@ -0,0 +1,435 @@
+import os
+import logging
+import multiprocessing as mp
+from typing import Sequence, Dict, Optional, Tuple, List, Union, Any, Mapping
+
+import numpy as np
+
+from .metrics.base import Metric, Score, Signature
+
+IS_WINDOWS = os.name == 'nt'
+
+
+sacrelogger = logging.getLogger('sacrebleu')
+
+
+class Result:
+ """A container to represent results from a particular statistical
+ significance test.
+ :param score: The floating point score for the system at hand.
+ :param p_value: If exists, represents the p-value when the system at
+ hand is compared to a baseline using a paired test.
+ :param mean: When paired bootstrap test is applied, this represents
+ the true mean score estimated from bootstrap resamples of the system.
+ :param ci: When paired bootstrap test is applied, this represents
+ the 95% confidence interval around the true mean score `sys_mean`.
+ """
+ def __init__(self, score: float, p_value: Optional[float] = None,
+ mean: Optional[float] = None, ci: Optional[float] = None):
+ self.score = score
+ self.p_value = p_value
+ self.mean = mean
+ self.ci = ci
+
+ def __repr__(self):
+ return ','.join([f'{k}={str(v)}' for k, v in self.__dict__.items()])
+
+
+def estimate_ci(scores: np.ndarray) -> Tuple[float, float]:
+ """Takes a list of scores and returns mean and 95% confidence
+ interval around the mean.
+
+ :param scores: A list of floating point scores.
+ :return: A tuple of mean and the 95% CI.
+ """
+ # Sort the scores
+ scores = np.sort(scores)
+ n = len(scores)
+
+ # Get CI bounds (95%, i.e. 1/40 from left)
+ lower_idx = n // 40
+ upper_idx = n - lower_idx - 1
+ lower, upper = scores[lower_idx], scores[upper_idx]
+ ci = 0.5 * (upper - lower)
+ return (scores.mean(), ci)
+
+
+def _bootstrap_resample(stats: List[List[Union[int, float]]],
+ metric: Metric, n_samples: int = 1000) -> Tuple[str, List[Score]]:
+ """Performs bootstrap resampling for a single system to estimate
+ a confidence interval around the true mean.
+ :param stats: A list of statistics extracted from the system's hypotheses.
+ :param metric: The `Metric` instance to be used for score computation.
+ :n_samples: Number of bootstrap resamples to use.
+
+ :return: A tuple of the seed choice as string and the list of `Score`
+ instances for all bootstrap resamples.
+ """
+
+ # Set numpy RNG's seed
+ # If given -> Fix to the given value
+ # If given but =='[Nn]one', don't fix the seed i.e. pull entropy from OS
+ seed = os.environ.get('SACREBLEU_SEED', '12345')
+ _seed = None if seed.lower() == 'none' else int(seed)
+ rng = np.random.default_rng(_seed)
+
+ # The indices that'll produce all bootstrap resamples at once
+ idxs = rng.choice(len(stats), size=(n_samples, len(stats)), replace=True)
+
+ # convert to numpy array. float32 is more efficient
+ stats_np = np.array(stats, dtype='float32')
+
+ # recompute scores for all resamples
+ scores = [
+ metric._compute_score_from_stats(_s.sum(0)) for _s in stats_np[idxs]]
+
+ return str(seed).lower(), scores
+
+
+def _compute_p_value(stats: np.ndarray, real_difference: float) -> float:
+ """Computes the p-value given the sample statistics and the real statistic.
+ :param stats: A numpy array with the sample statistics.
+ :real_difference: The real statistic.
+ :return: The p-value.
+ """
+ # Taken from: significance/StratifiedApproximateRandomizationTest.java
+ # https://github.com/jhclark/multeval.git
+
+ # "the != is important. if we want to score the same system against itself
+ # having a zero difference should not be attributed to chance."
+
+ c = np.sum(stats > real_difference).item()
+
+ # "+1 applies here, though it only matters for small numbers of shufflings,
+ # which we typically never do. it's necessary to ensure the probability of
+ # falsely rejecting the null hypothesis is no greater than the rejection
+ # level of the test (see william and morgan on significance tests)
+ p = (c + 1) / (len(stats) + 1)
+
+ return p
+
+
+def _paired_ar_test(baseline_info: Dict[str, Tuple[np.ndarray, Result]],
+ sys_name: str,
+ hypotheses: Sequence[str],
+ references: Optional[Sequence[Sequence[str]]],
+ metrics: Dict[str, Metric],
+ n_samples: int = 10000,
+ n_ar_confidence: int = -1,
+ seed: Optional[int] = None) -> Tuple[str, Dict[str, Result]]:
+ """Paired two-sided approximate randomization (AR) test for MT evaluation.
+
+ :param baseline_info: A dictionary with `Metric` instances as the keys,
+ that contains sufficient statistics and a `Result` instance for the baseline system.
+ :param sys_name: The name of the system to be evaluated.
+ :param hypotheses: A sequence of string hypotheses for the system.
+ :param references: A sequence of reference documents with document being
+ defined as a sequence of reference strings. If `None`, references
+ will be used through each metric's internal cache.
+ :param metrics: A dictionary of `Metric` instances that will be computed
+ for each system.
+ :param n_samples: The number of AR trials.
+ :param n_ar_confidence: The number of bootstrap resamples to use for
+ confidence estimation. A value of -1 disables confidence estimation.
+ :param seed: The seed value for the RNG. If `None`, the RNG will not be
+ fixed to a particular seed.
+
+ :return: A tuple with first element being the system name and the second
+ being a `Result` namedtuple.
+ """
+ # Seed the RNG
+ rng = np.random.default_rng(seed)
+
+ # Generate indices that'll select stats
+ pos_sel = rng.integers(2, size=(n_samples, len(hypotheses)), dtype=bool)
+
+ # Flip mask to obtain selectors for system hypotheses
+ neg_sel = ~pos_sel
+
+ if n_ar_confidence > 0:
+ # Perform confidence estimation as well
+ bs_idxs = rng.choice(
+ len(hypotheses), size=(n_ar_confidence, len(hypotheses)), replace=True)
+
+ results = {}
+
+ for name, metric in metrics.items():
+ # Use pre-computed match stats for the baseline
+ bl_stats, bl_result = baseline_info[name]
+
+ # Compute system's stats and score
+ sacrelogger.info(f'Computing {name} for {sys_name!r} and extracting sufficient statistics')
+ sys_stats = metric._extract_corpus_statistics(hypotheses, references)
+ sys_score = metric._aggregate_and_compute(sys_stats)
+
+ # original test statistic: absolute difference between baseline and the system
+ diff = abs(bl_result.score - sys_score.score)
+
+ sacrelogger.info(f' > Performing approximate randomization test (# trials: {n_samples})')
+ # get shuffled pseudo systems
+ shuf_a = pos_sel @ bl_stats + neg_sel @ sys_stats
+ shuf_b = neg_sel @ bl_stats + pos_sel @ sys_stats
+
+ # Aggregate trial stats and compute scores for each
+ scores_a = np.array(
+ [metric._aggregate_and_compute(x).score for x in shuf_a[:, None]])
+ scores_b = np.array(
+ [metric._aggregate_and_compute(x).score for x in shuf_b[:, None]])
+
+ # Count the statistical difference and compute the p-value
+ p = _compute_p_value(
+ np.abs(np.array(scores_a) - np.array(scores_b)), diff)
+
+ res = Result(sys_score.score, p)
+
+ if n_ar_confidence > 0:
+ sacrelogger.info(f' > Performing bootstrap resampling for confidence interval (# resamples: {n_ar_confidence})')
+ sys_stats = np.array(sys_stats, dtype='float32')
+ # recompute scores for all resamples
+ sys_scores = np.array([
+ metric._compute_score_from_stats(_s.sum(0)).score for _s in sys_stats[bs_idxs]
+ ])
+ res.mean, res.ci = estimate_ci(sys_scores)
+
+ # Store the result
+ results[name] = res
+
+ return sys_name, results
+
+
+def _paired_bs_test(baseline_info: Dict[str, Tuple[np.ndarray, Result]],
+ sys_name: str,
+ hypotheses: Sequence[str],
+ references: Optional[Sequence[Sequence[str]]],
+ metrics: Dict[str, Metric],
+ n_samples: int = 1000,
+ n_ar_confidence: int = -1,
+ seed: Optional[int] = None) -> Tuple[str, Dict[str, Result]]:
+ """Paired bootstrap resampling test for MT evaluation. This function
+ replicates the behavior of the Moses script called
+ `bootstrap-hypothesis-difference-significance.pl`.
+
+ :param baseline_info: A dictionary with `Metric` instances as the keys,
+ that contains sufficient statistics and a `Result` instance for the baseline system.
+ :param sys_name: The name of the system to be evaluated.
+ :param hypotheses: A sequence of string hypotheses for the system.
+ :param references: A sequence of reference documents with document being
+ defined as a sequence of reference strings. If `None`, references
+ will be used through each metric's internal cache.
+ :param metrics: A dictionary of `Metric` instances that will be computed
+ for each system.
+ :param n_samples: The number of bootstrap resamples.
+ :param n_ar_confidence: This parameter is not used for this function but
+ is there for signature compatibility in the API.
+ :param seed: The seed value for the RNG. If `None`, the RNG will not be
+ fixed to a particular seed.
+
+ :return: A tuple with first element being the system name and the second
+ being a `Result` namedtuple.
+ """
+ # Seed the RNG
+ rng = np.random.default_rng(seed)
+
+ results = {}
+
+ # It takes ~10ms to generated the indices
+ idxs = rng.choice(
+ len(hypotheses), size=(n_samples, len(hypotheses)), replace=True)
+
+ for name, metric in metrics.items():
+ # Use pre-computed match stats for the baseline
+ bl_stats, bl_result = baseline_info[name]
+
+ # Compute system's stats and score
+ sacrelogger.info(f'Computing {name} for {sys_name!r} and extracting sufficient statistics')
+ sys_stats = metric._extract_corpus_statistics(hypotheses, references)
+ sys_score = metric._aggregate_and_compute(sys_stats)
+
+ # Convert to numpy arrays for efficient indexing
+ sys_stats = np.array(sys_stats, dtype='float32')
+ bl_stats = np.array(bl_stats, dtype='float32')
+
+ # original test statistic: absolute difference between baseline and the system
+ diff = abs(bl_result.score - sys_score.score)
+
+ sacrelogger.info(f' > Performing paired bootstrap resampling test (# resamples: {n_samples})')
+ scores_bl = np.array(
+ [metric._compute_score_from_stats(_s.sum(0)).score for _s in bl_stats[idxs]])
+ scores_sys = np.array(
+ [metric._compute_score_from_stats(_s.sum(0)).score for _s in sys_stats[idxs]])
+
+ # Compute CI as well
+ sys_mean, sys_ci = estimate_ci(scores_sys)
+
+ # Compute the statistics
+ sample_diffs = np.abs(scores_sys - scores_bl)
+ stats = sample_diffs - sample_diffs.mean()
+
+ # Count the statistical difference and compute the p-value
+ p = _compute_p_value(stats, diff)
+
+ results[name] = Result(sys_score.score, p, sys_mean, sys_ci)
+
+ return sys_name, results
+
+
+class PairedTest:
+ """This is the manager class that will call the actual standalone implementation
+ for approximate randomization or paired bootstrap resampling, based on the
+ `test_type` argument.
+
+ :param named_systems: A lisf of (system_name, system_hypotheses) tuples on
+ which the test will be applied.
+ :param metrics: A dictionary of `Metric` instances that will be computed
+ for each system.
+ :param references: A sequence of reference documents with document being
+ defined as a sequence of reference strings. If `None`, already cached references
+ will be used through each metric's internal cache.
+ :param test_type: `ar` for approximate randomization, `bs` for paired bootstrap.
+ :param n_samples: The number of AR trials (for `ar`) or bootstrap resamples (for `bs`).
+ The defaults (10000 or 1000 respectively) will be used if 0 is passed.
+ :param n_ar_confidence: If `approximate randomization` is selected, the number
+ of bootstrap resamples to use for confidence estimation. A value of -1 disables
+ confidence estimation. 0 will use the default of 1000.
+ :param n_jobs: If 0, a worker process will be spawned for each system variant.
+ If > 0, the number of workers will be set accordingly. The default of 1
+ does not use multi-processing.
+ """
+ _DEFAULT_SAMPLES = {
+ 'ar': 10000,
+ 'bs': 1000,
+ }
+
+ def __init__(self, named_systems: List[Tuple[str, Sequence[str]]],
+ metrics: Mapping[str, Metric],
+ references: Optional[Sequence[Sequence[str]]],
+ test_type: str = 'ar',
+ n_samples: int = 0,
+ n_ar_confidence: int = -1,
+ n_jobs: int = 1):
+ assert test_type in ('ar', 'bs'), f"Unknown test type {test_type!r}"
+ self.test_type = test_type
+
+ # Set method
+ if self.test_type == 'ar':
+ self._fn = _paired_ar_test
+ elif self.test_type == 'bs':
+ self._fn = _paired_bs_test
+
+ # Set numpy RNG's seed
+ # If given -> Fix to the given value
+ # If given but =='[Nn]one', don't fix the seed i.e. pull entropy from OS
+ seed = os.environ.get('SACREBLEU_SEED', '12345')
+ self._seed = None if seed.lower() == 'none' else int(seed)
+ self.n_jobs = n_jobs
+ self.references = references
+ self.named_systems = named_systems
+
+ # Set the defaults if requested
+ self.n_ar_confidence = n_ar_confidence if n_ar_confidence != 0 else \
+ self._DEFAULT_SAMPLES['bs']
+
+ self.n_samples = n_samples if n_samples > 0 else \
+ self._DEFAULT_SAMPLES[self.test_type]
+
+ # Number of systems (excluding the baseline)
+ self.n_systems = len(named_systems) - 1
+
+ # Decide on number of workers
+ if IS_WINDOWS:
+ sacrelogger.warning('Parallel tests are not supported on Windows.')
+ self.n_jobs = 1
+ elif self.n_jobs == 0:
+ # Decide automatically
+ # Divide by two to ignore hyper-threading
+ n_max_jobs = mp.cpu_count() // 2
+ if n_max_jobs == 0:
+ self.n_jobs = 1
+ else:
+ # Don't use more workers than the number of CPUs
+ self.n_jobs = min(n_max_jobs, self.n_systems)
+
+ self._signatures: Dict[str, Signature] = {}
+ self._baseline_info: Dict[str, Tuple[Any, Result]] = {}
+
+ ##################################################
+ # Pre-compute and cache baseline system statistics
+ ##################################################
+ self.metrics = {}
+
+ bl_name, bl_hyps = self.named_systems[0]
+
+ for name, metric in metrics.items():
+ sacrelogger.info(f'Pre-computing {name} statistics for {bl_name!r}')
+ bl_stats = metric._extract_corpus_statistics(bl_hyps, self.references)
+ bl_score = metric._aggregate_and_compute(bl_stats)
+
+ # Compute CI for the baseline here once
+ confidence_n = self.n_samples if self.test_type == 'bs' \
+ else self.n_ar_confidence
+
+ bl_mean, bl_ci = None, None
+ if confidence_n > 0:
+ _, bl_scores = _bootstrap_resample(bl_stats, metric, confidence_n)
+ bl_mean, bl_ci = estimate_ci(np.array([x.score for x in bl_scores]))
+
+ result = Result(bl_score.score, mean=bl_mean, ci=bl_ci)
+ # Use updated name for the metric
+ self._baseline_info[bl_score.name] = (bl_stats, result)
+ self.metrics[bl_score.name] = metric
+
+ # Update metric signature as well
+ sig = metric.get_signature()
+ sig.update('seed', str(self._seed).lower())
+
+ # Num samples for bs, num trials for AR
+ sig.update(self.test_type, self.n_samples)
+ if self.n_ar_confidence > 0:
+ # Bootstrap is used for AR CI as well
+ sig.update('bs', self.n_ar_confidence)
+ self._signatures[bl_score.name] = sig
+
+ def __call__(self) -> Tuple[Dict[str, Signature], Dict[str, List[Union[str, Result]]]]:
+ """Runs the paired test either on single or multiple worker processes."""
+ tasks = []
+ scores: Dict[str, List[Union[str, Result]]] = {}
+
+ # Add the name column
+ scores['System'] = [ns[0] for ns in self.named_systems]
+
+ # Store baseline results as the first position
+ for metric, (_, result) in self._baseline_info.items():
+ scores[metric] = [result]
+
+ # Prepare list of arguments for each comparison
+ # Skip the baseline (pos: 0)
+ for idx, (name, hyps) in enumerate(self.named_systems[1:]):
+ seed = self._seed if self._seed else None
+
+ tasks.append(
+ (self._baseline_info, name, hyps, self.references,
+ self.metrics, self.n_samples, self.n_ar_confidence, seed))
+
+ # Run the test(s)
+ if self.n_jobs == 1:
+ results = [self._fn(*args) for args in tasks]
+ else:
+ # NOTE: The overhead of worker creation is not negligible
+ # but if you have many systems and TER enabled, this significantly
+ # speeds up the test.
+ # NOTE: This only works on Linux/Mac OS X but not Windows. Windows only
+ # supports `spawn` backend which requires things to be called
+ # from within __main__.
+ sacrelogger.info(f'Launching {self.n_jobs} parallel workers.')
+ with mp.get_context('fork').Pool(self.n_jobs) as pool:
+ jobs = [pool.apply_async(self._fn, args) for args in tasks]
+
+ # wait for completion
+ results = [j.get() for j in jobs]
+
+ # Keep the order deterministic
+ for sys_name, sys_results in results:
+ for metric, _result in sys_results.items():
+ scores[metric].append(_result)
+
+ return self._signatures, scores
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/sacrebleu/utils.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/sacrebleu/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..34d286c48c02f0ba8fcf5fcbba48a3e609582590
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/sacrebleu/utils.py
@@ -0,0 +1,639 @@
+import itertools
+import json
+import os
+import re
+import sys
+import gzip
+import math
+import hashlib
+import logging
+import portalocker
+from collections import defaultdict
+from typing import List, Optional, Sequence, Dict
+from argparse import Namespace
+
+from tabulate import tabulate
+import colorama
+
+
+# Where to store downloaded test sets.
+# Define the environment variable $SACREBLEU, or use the default of ~/.sacrebleu.
+#
+# Querying for a HOME environment variable can result in None (e.g., on Windows)
+# in which case the os.path.join() throws a TypeError. Using expanduser() is
+# a safe way to get the user's home folder.
+USERHOME = os.path.expanduser("~")
+SACREBLEU_DIR = os.environ.get('SACREBLEU', os.path.join(USERHOME, '.sacrebleu'))
+
+sacrelogger = logging.getLogger('sacrebleu')
+
+
+class Color:
+ ENABLE_COLORS = True
+
+ @staticmethod
+ def format(msg: str, color: str) -> str:
+ """Returns a colored version of the given message string.
+
+ :param msg: The string to Color.format.
+ :param color: The color specifier i.e. 'red', 'blue', 'green', etc.
+ :return: A colored version of the string if the output is a terminal.
+ """
+ if not Color.ENABLE_COLORS:
+ return msg
+ _ansi_str = getattr(colorama.Fore, color.upper(), None)
+ if _ansi_str:
+ return f'{_ansi_str}{msg}{colorama.Style.RESET_ALL}'
+
+ return msg
+
+
+def _format_score_lines(scores: dict,
+ width: int = 2,
+ multiline: bool = True) -> Dict[str, List[str]]:
+ """Formats the scores prior to tabulating them."""
+ new_scores = {'System': scores.pop('System')}
+ p_val_break_char = '\n' if multiline else ' '
+ is_bootstrap = False
+
+ def _color_p_value(p: float):
+ msg = f'(p = {p:.4f})'
+ if p > 0.05:
+ return Color.format(msg, 'red')
+ return msg + '*'
+
+ for metric, vals in scores.items():
+ new_vals = []
+
+ for result in vals:
+ if not isinstance(result, str):
+ # Format result instances
+ _str = f'{result.score:.{width}f}'
+ if result.mean is not None:
+ is_bootstrap = True
+ _str += f' ({result.mean:.{width}f} ± {result.ci:.{width}f})'
+ if result.p_value is not None:
+ _str += p_val_break_char + _color_p_value(result.p_value)
+ else:
+ # Already formatted in non paired-test mode
+ _str = result
+
+ new_vals.append(_str)
+
+ if is_bootstrap:
+ # Change titles
+ metric += ' (μ ± 95% CI)'
+
+ new_scores[metric] = new_vals
+
+ return new_scores
+
+
+def print_results_table(results: dict, signatures: dict, args: Namespace):
+ """Prints out a nicely formatted table for multi-system evaluation mode."""
+
+ if args.format == 'json':
+ proper_json = []
+ dict_keys = list(results.keys())
+ for i in range(len(results['System'])):
+ value = {}
+ value['system'] = results['System'][i]
+ # parse metrics
+ for j in range(1, len(dict_keys)):
+ if isinstance(results[dict_keys[j]][i], str):
+ value[dict_keys[j]] = results[dict_keys[j]][i]
+ else:
+ # Values inside object as dict
+ value[dict_keys[j]] = results[dict_keys[j]][i].__dict__
+ proper_json.append(value)
+
+ print(json.dumps(proper_json, indent=4))
+ return
+
+ tablefmt = args.format
+ if tablefmt in ('text'):
+ tablefmt = 'fancy_grid'
+ elif tablefmt == 'latex':
+ # Use booktabs
+ tablefmt = 'latex_booktabs'
+
+ # If paired testing has been given, this'll format the score lines
+ results = _format_score_lines(
+ results, args.width, multiline=tablefmt == 'fancy_grid')
+
+ new_dict = {}
+
+ # Color the column names and the baseline system name and scores
+ has_baseline = False
+ baseline_name = ''
+ for name in results.keys():
+ val = results[name]
+ if val[0].startswith('Baseline:') or has_baseline:
+ if val[0].startswith('Baseline:'):
+ baseline_name = val[0]
+ has_baseline = True
+ val[0] = Color.format(val[0], 'yellow')
+ new_dict[Color.format(name, 'cyan')] = results[name]
+
+ # Finally tabulate
+ table = tabulate(
+ new_dict, headers='keys', tablefmt=tablefmt,
+ colalign=('right', ),
+ stralign='center',
+ numalign='center',
+ floatfmt=f'.{args.width}f')
+
+ print(table)
+ print()
+
+ is_paired = args.paired_bs or args.paired_ar
+
+ if is_paired:
+ test_type = 'bootstrap resampling' if args.paired_bs else 'approximate randomization'
+ n_samples_or_trials = args.paired_bs_n if args.paired_bs else args.paired_ar_n
+ test_sample_type = 'resampling trials' if args.paired_bs else 'trials'
+ msg = f'Paired {test_type} test with {n_samples_or_trials} {test_sample_type}'
+
+ bline = Color.format('baseline', 'yellow')
+ bline_name = Color.format(baseline_name, 'yellow')
+ null_hyp = Color.format('Null hypothesis', 'green')
+ pval_color = Color.format('highlighted in red', 'red')
+
+ # Print fancy header
+ print('-' * len(msg) + '\n' + msg + '\n' + '-' * len(msg))
+ print(f' - Each system is pairwise compared to {bline_name}.')
+ if args.paired_bs:
+ print(' Actual system score / bootstrap estimated true mean / 95% CI are provided for each metric.')
+ else:
+ print(' Actual system score is provided for each metric.')
+ print()
+ print(f' - {null_hyp}: the system and the {bline} translations are essentially')
+ print(f' generated by the same underlying process. For a given system and the {bline},')
+ print(' the p-value is roughly the probability of the absolute score difference (delta)')
+ print(f' or higher occurring due to chance, under the assumption that the {null_hyp.lower()} is correct.')
+ print()
+ print(f' - Assuming a significance threshold of 0.05, the {null_hyp.lower()} can be rejected')
+ print(' for p-values < 0.05 (marked with "*"). This means that the delta is unlikely to be attributed')
+ print(f' to chance, hence the system is significantly "different" than the {bline}.')
+ print(f' Otherwise, the p-values are {pval_color}.')
+ print()
+ print(f' - NOTE: Significance does not tell whether a system is "better" than the {bline} but rather')
+ print(' emphasizes the "difference" of the systems in terms of the replicability of the delta.')
+ print()
+
+ print('-----------------')
+ print('Metric signatures')
+ print('-----------------')
+ for name, sig in signatures.items():
+ print(f' - {name:<10} {sig}')
+
+
+def print_single_results(results: List[str], args: Namespace):
+ """Re-process metric strings to align them nicely."""
+ if args.format == 'json':
+ if len(results) > 1:
+ proper_json = '[\n' + ',\n'.join(results) + '\n]'
+ print(proper_json)
+ else:
+ print(results[0])
+ return
+
+ # Color confidence strings for emphasis
+ if 'μ' in results[0]:
+ color_re = re.compile(r'(\(μ = [0-9\.]+ ± [0-9\.]+\))')
+ for idx in range(len(results)):
+ results[idx] = color_re.sub(
+ lambda m: Color.format(m.group(), 'cyan'), results[idx])
+
+ if len(results) == 1:
+ # Just one system, nothing to align.
+ print(results[0])
+ return
+
+ # Align by '=' character
+ lens = []
+ for line in results:
+ # If not score_only, split lines from '=' for re-alignment
+ try:
+ lens.append(line.index('=') - 1)
+ except ValueError:
+ print(line)
+
+ if len(lens) > 0:
+ w = max(lens)
+ for (_len, line) in zip(lens, results):
+ left, right = line[:_len], line[_len:]
+ print(f'{left:>{w}}{right}')
+
+
+def sanity_check_lengths(system: Sequence[str],
+ refs: Sequence[Sequence[str]],
+ test_set: Optional[str] = None):
+ n_hyps = len(system)
+ if any(len(ref_stream) != n_hyps for ref_stream in refs):
+ sacrelogger.error("System and reference streams have different lengths.")
+ if test_set:
+ sacrelogger.error("This could be an issue with your system output "
+ "or with sacreBLEU's reference database if -t is given.")
+ sacrelogger.error("For the latter, try cleaning out the cache by typing:\n")
+ sacrelogger.error(f" rm -r {SACREBLEU_DIR}/{test_set}\n")
+ sacrelogger.error("The test sets will be re-downloaded the next time you run sacreBLEU.")
+ sys.exit(1)
+
+
+def smart_open(file, mode='rt', encoding='utf-8'):
+ """Convenience function for reading compressed or plain text files.
+ :param file: The file to read.
+ :param mode: The file mode (read, write).
+ :param encoding: The file encoding.
+ """
+ if file.endswith('.gz'):
+ return gzip.open(file, mode=mode, encoding=encoding, newline="\n")
+ return open(file, mode=mode, encoding=encoding, newline="\n")
+
+
+def my_log(num: float) -> float:
+ """
+ Floors the log function
+
+ :param num: the number
+ :return: log(num) floored to a very low number
+ """
+
+ if num == 0.0:
+ return -9999999999
+ return math.log(num)
+
+
+def sum_of_lists(lists):
+ """Aggregates list of numeric lists by summing."""
+ if len(lists) == 1:
+ return lists[0]
+
+ # Preserve datatype
+ size = len(lists[0])
+ init_val = type(lists[0][0])(0.0)
+ total = [init_val] * size
+ for ll in lists:
+ for i in range(size):
+ total[i] += ll[i]
+ return total
+
+
+def args_to_dict(args, prefix: str, strip_prefix: bool = False):
+ """Filters argparse's `Namespace` into dictionary with arguments
+ beginning with the given prefix."""
+ prefix += '_'
+ d = {}
+ for k, v in args.__dict__.items():
+ if k.startswith(prefix):
+ k = k.replace(prefix, '') if strip_prefix else k
+ d[k] = v
+ return d
+
+
+def print_test_set(test_set, langpair, requested_fields, origlang=None, subset=None):
+ """Prints to STDOUT the specified side of the specified test set.
+
+ :param test_set: the test set to print
+ :param langpair: the language pair
+ :param requested_fields: the fields to print
+ :param origlang: print only sentences with a given original language (2-char ISO639-1 code), "non-" prefix means negation
+ :param subset: print only sentences whose document annotation matches a given regex
+ """
+ if test_set not in DATASETS:
+ raise Exception(f"No such test set {test_set}")
+
+ fieldnames = DATASETS[test_set].fieldnames(langpair)
+ all_files = DATASETS[test_set].get_files(langpair)
+
+ if "all" in requested_fields and len(requested_fields) != 1:
+ sacrelogger.error("Cannot use --echo all with other fields")
+ sys.exit(1)
+ elif "all" in requested_fields:
+ requested_fields = fieldnames
+
+ # backwards compatibility: allow "ref" even if not present (choose first)
+ if "ref" in requested_fields and "ref" not in fieldnames:
+ replacement_ref = min([f for f in fieldnames if f.startswith("ref")])
+ requested_fields = [f if f != "ref" else replacement_ref for f in requested_fields]
+
+ files = []
+ for field in requested_fields:
+ if field not in fieldnames:
+ sacrelogger.error(f"No such field {field} in test set {test_set} for language pair {langpair}.")
+ sacrelogger.error(f"available fields for {test_set}/{langpair}: {', '.join(fieldnames)}")
+ if "ref" not in fieldnames:
+ subref = min([f for f in fieldnames if f.startswith("ref")])
+ sacrelogger.error(f"'ref' also allowed for backwards compatibility (will return {subref})")
+ sys.exit(1)
+ index = fieldnames.index(field)
+ files.append(all_files[index])
+
+ streams = [smart_open(file) for file in files]
+ streams = filter_subset(streams, test_set, langpair, origlang, subset)
+ for lines in zip(*streams):
+ print('\t'.join(map(lambda x: x.rstrip(), lines)))
+
+
+def get_source_file(test_set: str, langpair: str) -> str:
+ """
+ Returns the source file for a given testset/langpair.
+ Downloads it first if it is not already local.
+
+ :param test_set: The test set (e.g., "wmt19")
+ :param langpair: The language pair (e.g., "de-en")
+ :return: the path to the requested source file
+ """
+ if test_set not in DATASETS:
+ raise Exception(f"No such test set {test_set}")
+
+ return DATASETS[test_set].get_source_file(langpair)
+
+
+def get_reference_files(test_set: str, langpair: str) -> List[str]:
+ """
+ Returns a list of one or more reference file paths for the given testset/langpair.
+ Downloads the references first if they are not already local.
+
+ :param test_set: The test set (e.g., "wmt19")
+ :param langpair: The language pair (e.g., "de-en")
+ :return: a list of one or more reference file paths
+ """
+ if test_set not in DATASETS:
+ raise Exception(f"No such test set {test_set}")
+ return DATASETS[test_set].get_reference_files(langpair)
+
+
+def get_files(test_set, langpair) -> List[str]:
+ """
+ Returns the path of the source file and all reference files for
+ the provided test set / language pair.
+ Downloads the references first if they are not already local.
+
+ :param test_set: The test set (e.g., "wmt19")
+ :param langpair: The language pair (e.g., "de-en")
+ :return: a list of the source file and all reference files
+ """
+
+ if test_set not in DATASETS:
+ raise Exception(f"No such test set {test_set}")
+ return DATASETS[test_set].get_files(langpair)
+
+
+def extract_tarball(filepath, destdir):
+ sacrelogger.info(f'Extracting {filepath} to {destdir}')
+ if filepath.endswith('.tar.gz') or filepath.endswith('.tgz'):
+ import tarfile
+ with tarfile.open(filepath) as tar:
+ tar.extractall(path=destdir)
+ elif filepath.endswith('.zip'):
+ import zipfile
+ with zipfile.ZipFile(filepath, 'r') as zipfile:
+ zipfile.extractall(path=destdir)
+
+
+def get_md5sum(dest_path):
+ # Check md5sum
+ md5 = hashlib.md5()
+ with open(dest_path, 'rb') as infile:
+ for line in infile:
+ md5.update(line)
+ return md5.hexdigest()
+
+
+def download_file(source_path, dest_path, extract_to=None, expected_md5=None):
+ """Downloading utility.
+
+ Downloads the specified test to the system location specified by the SACREBLEU environment variable.
+
+ :param source_path: the remote uri to download
+ :param dest_path: where to save the file
+ :param extract_to: for tarballs, where to extract to
+ :param expected_md5: the MD5 sum
+ :return: the set of processed file names
+ """
+ import urllib.request
+ import ssl
+
+ outdir = os.path.dirname(dest_path)
+ os.makedirs(outdir, exist_ok=True)
+
+ # Make sure to open in mode "a"
+ lockfile = f"{dest_path}.lock"
+ with portalocker.Lock(lockfile, timeout=60):
+
+ if not os.path.exists(dest_path) or os.path.getsize(dest_path) == 0:
+ sacrelogger.info(f"Downloading {source_path} to {dest_path}")
+
+ try:
+ with urllib.request.urlopen(source_path) as f, open(dest_path, 'wb') as out:
+ out.write(f.read())
+ except ssl.SSLError:
+ sacrelogger.error('An SSL error was encountered in downloading the files. If you\'re on a Mac, '
+ 'you may need to run the "Install Certificates.command" file located in the '
+ '"Python 3" folder, often found under /Applications')
+ sys.exit(1)
+
+ if expected_md5 is not None:
+ cur_md5 = get_md5sum(dest_path)
+ if cur_md5 != expected_md5:
+ sacrelogger.error(f'Fatal: MD5 sum of downloaded file was incorrect (got {cur_md5}, expected {expected_md5}).')
+ sacrelogger.error(f'Please manually delete {dest_path!r} and rerun the command.')
+ sacrelogger.error('If the problem persists, the tarball may have changed, in which case, please contact the SacreBLEU maintainer.')
+ sys.exit(1)
+
+ # Extract the tarball
+ if extract_to is not None:
+ extract_tarball(dest_path, extract_to)
+
+
+def download_test_set(test_set, langpair=None):
+ """Downloads the specified test to the system location specified by the SACREBLEU environment variable.
+
+ :param test_set: the test set to download
+ :param langpair: the language pair (needed for some datasets)
+ :return: the set of processed file names
+ """
+ if test_set not in DATASETS:
+ raise Exception(f"No such test set {test_set}")
+ dataset = DATASETS[test_set]
+ file_paths = dataset.get_files(langpair)
+ return file_paths
+
+
+def get_langpairs_for_testset(testset: str) -> List[str]:
+ """Return a list of language pairs for a given test set."""
+ if testset not in DATASETS:
+ return []
+ return list(DATASETS[testset].langpairs.keys())
+
+
+def get_available_testsets() -> List[str]:
+ """Return a list of available test sets."""
+ return sorted(DATASETS.keys(), reverse=True)
+
+def get_available_testsets_for_langpair(langpair: str) -> List[str]:
+ """Return a list of available test sets for a given language pair"""
+ parts = langpair.split('-')
+ srclang = parts[0]
+ trglang = parts[1]
+
+ testsets = []
+ for dataset in DATASETS.values():
+ if f'{srclang}-{trglang}' in dataset.langpairs \
+ or f'{trglang}-{srclang}' in dataset.langpairs:
+ testsets.append(dataset.name)
+
+ return testsets
+
+
+def get_available_origlangs(test_sets, langpair) -> List[str]:
+ """Return a list of origlang values according to the raw XML/SGM files."""
+ if test_sets is None:
+ return []
+
+ origlangs = set()
+ for test_set in test_sets.split(','):
+ dataset = DATASETS[test_set]
+ rawfile = os.path.join(SACREBLEU_DIR, test_set, 'raw', dataset.langpairs[langpair][0])
+ from .dataset.wmt_xml import WMTXMLDataset
+ if isinstance(dataset, WMTXMLDataset):
+ for origlang in dataset._unwrap_wmt21_or_later(rawfile)['origlang']:
+ origlangs.add(origlang)
+ if rawfile.endswith('.sgm'):
+ with smart_open(rawfile) as fin:
+ for line in fin:
+ if line.startswith(' List[str]:
+ """Return a list of domain values according to the raw XML files and domain/country values from the SGM files."""
+ if test_sets is None:
+ return []
+
+ subsets = set()
+ for test_set in test_sets.split(','):
+ dataset = DATASETS[test_set]
+ from .dataset.wmt_xml import WMTXMLDataset
+ if isinstance(dataset, WMTXMLDataset):
+ rawfile = os.path.join(SACREBLEU_DIR, test_set, 'raw', dataset.langpairs[langpair][0])
+ fields = dataset._unwrap_wmt21_or_later(rawfile)
+ if 'domain' in fields:
+ subsets |= set(fields['domain'])
+ elif test_set in SUBSETS:
+ subsets |= set("country:" + v.split("-")[0] for v in SUBSETS[test_set].values())
+ subsets |= set(v.split("-")[1] for v in SUBSETS[test_set].values())
+ return sorted(list(subsets))
+
+def filter_subset(systems, test_sets, langpair, origlang, subset=None):
+ """Filter sentences with a given origlang (or subset) according to the raw SGM files."""
+ if origlang is None and subset is None:
+ return systems
+ if test_sets is None or langpair is None:
+ raise ValueError('Filtering for --origlang or --subset needs a test (-t) and a language pair (-l).')
+
+ if subset is not None and subset.startswith('country:'):
+ subset = subset[8:]
+
+ re_origlang = re.compile(r'.* origlang="([^"]+)".*\n')
+ re_id = re.compile(r'.* docid="([^"]+)".*\n')
+
+ indices_to_keep = []
+ for test_set in test_sets.split(','):
+ dataset = DATASETS[test_set]
+ rawfile = os.path.join(SACREBLEU_DIR, test_set, 'raw', dataset.langpairs[langpair][0])
+ from .dataset.wmt_xml import WMTXMLDataset
+ if isinstance(dataset, WMTXMLDataset):
+ fields = dataset._unwrap_wmt21_or_later(rawfile)
+ domains = fields['domain'] if 'domain' in fields else itertools.repeat(None)
+ for doc_origlang, doc_domain in zip(fields['origlang'], domains):
+ if origlang is None:
+ include_doc = True
+ else:
+ if origlang.startswith('non-'):
+ include_doc = doc_origlang != origlang[4:]
+ else:
+ include_doc = doc_origlang == origlang
+ if subset is not None and (doc_domain is None or not re.search(subset, doc_domain)):
+ include_doc = False
+ indices_to_keep.append(include_doc)
+ elif rawfile.endswith('.sgm'):
+ doc_to_tags = {}
+ if subset is not None:
+ if test_set not in SUBSETS:
+ raise Exception('No subset annotation available for test set ' + test_set)
+ doc_to_tags = SUBSETS[test_set]
+ with smart_open(rawfile) as fin:
+ include_doc = False
+ for line in fin:
+ if line.startswith('=1.21.6 ; extra == 'numpy'
+Requires-Dist: safetensors[numpy] ; extra == 'torch'
+Requires-Dist: torch>=1.10 ; extra == 'torch'
+Requires-Dist: safetensors[numpy] ; extra == 'tensorflow'
+Requires-Dist: tensorflow>=2.11.0 ; extra == 'tensorflow'
+Requires-Dist: safetensors[numpy] ; extra == 'pinned-tf'
+Requires-Dist: tensorflow==2.18.0 ; extra == 'pinned-tf'
+Requires-Dist: safetensors[numpy] ; extra == 'jax'
+Requires-Dist: flax>=0.6.3 ; extra == 'jax'
+Requires-Dist: jax>=0.3.25 ; extra == 'jax'
+Requires-Dist: jaxlib>=0.3.25 ; extra == 'jax'
+Requires-Dist: mlx>=0.0.9 ; extra == 'mlx'
+Requires-Dist: safetensors[numpy] ; extra == 'paddlepaddle'
+Requires-Dist: paddlepaddle>=2.4.1 ; extra == 'paddlepaddle'
+Requires-Dist: black==22.3 ; extra == 'quality'
+Requires-Dist: click==8.0.4 ; extra == 'quality'
+Requires-Dist: isort>=5.5.4 ; extra == 'quality'
+Requires-Dist: flake8>=3.8.3 ; extra == 'quality'
+Requires-Dist: safetensors[numpy] ; extra == 'testing'
+Requires-Dist: h5py>=3.7.0 ; extra == 'testing'
+Requires-Dist: huggingface-hub>=0.12.1 ; extra == 'testing'
+Requires-Dist: setuptools-rust>=1.5.2 ; extra == 'testing'
+Requires-Dist: pytest>=7.2.0 ; extra == 'testing'
+Requires-Dist: pytest-benchmark>=4.0.0 ; extra == 'testing'
+Requires-Dist: hypothesis>=6.70.2 ; extra == 'testing'
+Requires-Dist: safetensors[torch] ; extra == 'all'
+Requires-Dist: safetensors[numpy] ; extra == 'all'
+Requires-Dist: safetensors[pinned-tf] ; extra == 'all'
+Requires-Dist: safetensors[jax] ; extra == 'all'
+Requires-Dist: safetensors[paddlepaddle] ; extra == 'all'
+Requires-Dist: safetensors[quality] ; extra == 'all'
+Requires-Dist: safetensors[testing] ; extra == 'all'
+Requires-Dist: safetensors[all] ; extra == 'dev'
+Provides-Extra: numpy
+Provides-Extra: torch
+Provides-Extra: tensorflow
+Provides-Extra: pinned-tf
+Provides-Extra: jax
+Provides-Extra: mlx
+Provides-Extra: paddlepaddle
+Provides-Extra: quality
+Provides-Extra: testing
+Provides-Extra: all
+Provides-Extra: dev
+Author-email: Nicolas Patry
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Homepage, https://github.com/huggingface/safetensors
+Project-URL: Source, https://github.com/huggingface/safetensors
+
+## Installation
+
+```
+pip install safetensors
+```
+
+
+## Usage
+
+### Numpy
+
+```python
+from safetensors.numpy import save_file, load_file
+import numpy as np
+
+tensors = {
+ "a": np.zeros((2, 2)),
+ "b": np.zeros((2, 3), dtype=np.uint8)
+}
+
+save_file(tensors, "./model.safetensors")
+
+
+# Now loading
+loaded = load_file("./model.safetensors")
+```
+
+### Torch
+
+```python
+from safetensors.torch import save_file, load_file
+import torch
+
+tensors = {
+ "a": torch.zeros((2, 2)),
+ "b": torch.zeros((2, 3), dtype=torch.uint8)
+}
+
+save_file(tensors, "./model.safetensors")
+
+
+# Now loading
+loaded = load_file("./model.safetensors")
+```
+
+### Developing
+
+```
+# inside ./safetensors/bindings/python
+pip install .[dev]
+```
+Should be enough to install this library locally.
+
+### Testing
+
+```
+# inside ./safetensors/bindings/python
+pip install .[dev]
+pytest -sv tests/
+```
+
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/safetensors-0.5.3.dist-info/RECORD b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/safetensors-0.5.3.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..13fd60e3c3666ef803643eace5142b29ac453312
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/safetensors-0.5.3.dist-info/RECORD
@@ -0,0 +1,21 @@
+safetensors-0.5.3.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+safetensors-0.5.3.dist-info/METADATA,sha256=_n1YE2PtILIEcBYj2o-Q3Yo7mZXpqSkLYWeI2ANWrb8,3823
+safetensors-0.5.3.dist-info/RECORD,,
+safetensors-0.5.3.dist-info/WHEEL,sha256=xmgHfrZnekTnNsVAVJOGui7H8HXfLu85y5KBdcfmlL8,127
+safetensors/__init__.py,sha256=rFhZV2HBVDIijU2xKjg-0viTLETa-yMLMgFC9-47hdc,171
+safetensors/__init__.pyi,sha256=ma6haip709qCi6AZq9kCytNzFB-3eeUXfisqo9Kv458,3756
+safetensors/__pycache__/__init__.cpython-312.pyc,,
+safetensors/__pycache__/flax.cpython-312.pyc,,
+safetensors/__pycache__/mlx.cpython-312.pyc,,
+safetensors/__pycache__/numpy.cpython-312.pyc,,
+safetensors/__pycache__/paddle.cpython-312.pyc,,
+safetensors/__pycache__/tensorflow.cpython-312.pyc,,
+safetensors/__pycache__/torch.cpython-312.pyc,,
+safetensors/_safetensors_rust.abi3.so,sha256=tudr2QIzRPbt7v-5NSeflK2DFry4CFfA2Rz3WhnI9cU,1123056
+safetensors/flax.py,sha256=AuyY2YHxTBy4xeQLxhAyMledHykpz0Qsys13eKiHNYg,3846
+safetensors/mlx.py,sha256=7OTFtbdmGIqLnrjo_36RJRJ7zq1aI6HasvRPLB3d_Gw,3837
+safetensors/numpy.py,sha256=5Z_wSFRxVbsAXpnej2zuqtdYK9K-nqZs1EE_G14C6Ck,4937
+safetensors/paddle.py,sha256=V_RCTXymi2PJAG_jA4-qnfzbYAUB_74VYYXFzhXTLYM,4175
+safetensors/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+safetensors/tensorflow.py,sha256=6XaUBcxm0xL4ulNcvVsllKZ_qJ_rBSlE50rNnECCNYQ,3890
+safetensors/torch.py,sha256=qVvpJJkNmb1FaW9Gj1DllGgqfA1wlDqQRn5DyEIWo90,17822
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/safetensors-0.5.3.dist-info/WHEEL b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/safetensors-0.5.3.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..0db9900e24a302d16e278f7066e777d7f523c077
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/safetensors-0.5.3.dist-info/WHEEL
@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.8.2)
+Root-Is-Purelib: false
+Tag: cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/tabulate-0.9.0.dist-info/INSTALLER b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/tabulate-0.9.0.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/tabulate-0.9.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/tabulate-0.9.0.dist-info/LICENSE b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/tabulate-0.9.0.dist-info/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..81241eca637574fb696620b54200d28a0ff53524
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/tabulate-0.9.0.dist-info/LICENSE
@@ -0,0 +1,20 @@
+Copyright (c) 2011-2020 Sergey Astanin and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/tabulate-0.9.0.dist-info/METADATA b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/tabulate-0.9.0.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..3909a0009159614c1805e56722e8b8d285389796
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/tabulate-0.9.0.dist-info/METADATA
@@ -0,0 +1,1149 @@
+Metadata-Version: 2.1
+Name: tabulate
+Version: 0.9.0
+Summary: Pretty-print tabular data
+Author-email: Sergey Astanin
+License: MIT
+Project-URL: Homepage, https://github.com/astanin/python-tabulate
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: widechars
+Requires-Dist: wcwidth ; extra == 'widechars'
+
+python-tabulate
+===============
+
+Pretty-print tabular data in Python, a library and a command-line
+utility.
+
+The main use cases of the library are:
+
+- printing small tables without hassle: just one function call,
+ formatting is guided by the data itself
+- authoring tabular data for lightweight plain-text markup: multiple
+ output formats suitable for further editing or transformation
+- readable presentation of mixed textual and numeric data: smart
+ column alignment, configurable number formatting, alignment by a
+ decimal point
+
+Installation
+------------
+
+To install the Python library and the command line utility, run:
+
+```shell
+pip install tabulate
+```
+
+The command line utility will be installed as `tabulate` to `bin` on
+Linux (e.g. `/usr/bin`); or as `tabulate.exe` to `Scripts` in your
+Python installation on Windows (e.g. `C:\Python39\Scripts\tabulate.exe`).
+
+You may consider installing the library only for the current user:
+
+```shell
+pip install tabulate --user
+```
+
+In this case the command line utility will be installed to
+`~/.local/bin/tabulate` on Linux and to
+`%APPDATA%\Python\Scripts\tabulate.exe` on Windows.
+
+To install just the library on Unix-like operating systems:
+
+```shell
+TABULATE_INSTALL=lib-only pip install tabulate
+```
+
+On Windows:
+
+```shell
+set TABULATE_INSTALL=lib-only
+pip install tabulate
+```
+
+Build status
+------------
+
+[](https://circleci.com/gh/astanin/python-tabulate/tree/master) [](https://ci.appveyor.com/project/astanin/python-tabulate/branch/master)
+
+Library usage
+-------------
+
+The module provides just one function, `tabulate`, which takes a list of
+lists or another tabular data type as the first argument, and outputs a
+nicely formatted plain-text table:
+
+```pycon
+>>> from tabulate import tabulate
+
+>>> table = [["Sun",696000,1989100000],["Earth",6371,5973.6],
+... ["Moon",1737,73.5],["Mars",3390,641.85]]
+>>> print(tabulate(table))
+----- ------ -------------
+Sun 696000 1.9891e+09
+Earth 6371 5973.6
+Moon 1737 73.5
+Mars 3390 641.85
+----- ------ -------------
+```
+
+The following tabular data types are supported:
+
+- list of lists or another iterable of iterables
+- list or another iterable of dicts (keys as columns)
+- dict of iterables (keys as columns)
+- list of dataclasses (Python 3.7+ only, field names as columns)
+- two-dimensional NumPy array
+- NumPy record arrays (names as columns)
+- pandas.DataFrame
+
+Tabulate is a Python3 library.
+
+### Headers
+
+The second optional argument named `headers` defines a list of column
+headers to be used:
+
+```pycon
+>>> print(tabulate(table, headers=["Planet","R (km)", "mass (x 10^29 kg)"]))
+Planet R (km) mass (x 10^29 kg)
+-------- -------- -------------------
+Sun 696000 1.9891e+09
+Earth 6371 5973.6
+Moon 1737 73.5
+Mars 3390 641.85
+```
+
+If `headers="firstrow"`, then the first row of data is used:
+
+```pycon
+>>> print(tabulate([["Name","Age"],["Alice",24],["Bob",19]],
+... headers="firstrow"))
+Name Age
+------ -----
+Alice 24
+Bob 19
+```
+
+If `headers="keys"`, then the keys of a dictionary/dataframe, or column
+indices are used. It also works for NumPy record arrays and lists of
+dictionaries or named tuples:
+
+```pycon
+>>> print(tabulate({"Name": ["Alice", "Bob"],
+... "Age": [24, 19]}, headers="keys"))
+ Age Name
+----- ------
+ 24 Alice
+ 19 Bob
+```
+
+### Row Indices
+
+By default, only pandas.DataFrame tables have an additional column
+called row index. To add a similar column to any other type of table,
+pass `showindex="always"` or `showindex=True` argument to `tabulate()`.
+To suppress row indices for all types of data, pass `showindex="never"`
+or `showindex=False`. To add a custom row index column, pass
+`showindex=rowIDs`, where `rowIDs` is some iterable:
+
+```pycon
+>>> print(tabulate([["F",24],["M",19]], showindex="always"))
+- - --
+0 F 24
+1 M 19
+- - --
+```
+
+### Table format
+
+There is more than one way to format a table in plain text. The third
+optional argument named `tablefmt` defines how the table is formatted.
+
+Supported table formats are:
+
+- "plain"
+- "simple"
+- "github"
+- "grid"
+- "simple\_grid"
+- "rounded\_grid"
+- "heavy\_grid"
+- "mixed\_grid"
+- "double\_grid"
+- "fancy\_grid"
+- "outline"
+- "simple\_outline"
+- "rounded\_outline"
+- "heavy\_outline"
+- "mixed\_outline"
+- "double\_outline"
+- "fancy\_outline"
+- "pipe"
+- "orgtbl"
+- "asciidoc"
+- "jira"
+- "presto"
+- "pretty"
+- "psql"
+- "rst"
+- "mediawiki"
+- "moinmoin"
+- "youtrack"
+- "html"
+- "unsafehtml"
+- "latex"
+- "latex\_raw"
+- "latex\_booktabs"
+- "latex\_longtable"
+- "textile"
+- "tsv"
+
+`plain` tables do not use any pseudo-graphics to draw lines:
+
+```pycon
+>>> table = [["spam",42],["eggs",451],["bacon",0]]
+>>> headers = ["item", "qty"]
+>>> print(tabulate(table, headers, tablefmt="plain"))
+item qty
+spam 42
+eggs 451
+bacon 0
+```
+
+`simple` is the default format (the default may change in future
+versions). It corresponds to `simple_tables` in [Pandoc Markdown
+extensions](http://johnmacfarlane.net/pandoc/README.html#tables):
+
+```pycon
+>>> print(tabulate(table, headers, tablefmt="simple"))
+item qty
+------ -----
+spam 42
+eggs 451
+bacon 0
+```
+
+`github` follows the conventions of GitHub flavored Markdown. It
+corresponds to the `pipe` format without alignment colons:
+
+```pycon
+>>> print(tabulate(table, headers, tablefmt="github"))
+| item | qty |
+|--------|-------|
+| spam | 42 |
+| eggs | 451 |
+| bacon | 0 |
+```
+
+`grid` is like tables formatted by Emacs'
+[table.el](http://table.sourceforge.net/) package. It corresponds to
+`grid_tables` in Pandoc Markdown extensions:
+
+```pycon
+>>> print(tabulate(table, headers, tablefmt="grid"))
++--------+-------+
+| item | qty |
++========+=======+
+| spam | 42 |
++--------+-------+
+| eggs | 451 |
++--------+-------+
+| bacon | 0 |
++--------+-------+
+```
+
+`simple_grid` draws a grid using single-line box-drawing characters:
+
+ >>> print(tabulate(table, headers, tablefmt="simple_grid"))
+ ┌────────┬───────┐
+ │ item │ qty │
+ ├────────┼───────┤
+ │ spam │ 42 │
+ ├────────┼───────┤
+ │ eggs │ 451 │
+ ├────────┼───────┤
+ │ bacon │ 0 │
+ └────────┴───────┘
+
+`rounded_grid` draws a grid using single-line box-drawing characters with rounded corners:
+
+ >>> print(tabulate(table, headers, tablefmt="rounded_grid"))
+ ╭────────┬───────╮
+ │ item │ qty │
+ ├────────┼───────┤
+ │ spam │ 42 │
+ ├────────┼───────┤
+ │ eggs │ 451 │
+ ├────────┼───────┤
+ │ bacon │ 0 │
+ ╰────────┴───────╯
+
+`heavy_grid` draws a grid using bold (thick) single-line box-drawing characters:
+
+ >>> print(tabulate(table, headers, tablefmt="heavy_grid"))
+ ┏━━━━━━━━┳━━━━━━━┓
+ ┃ item ┃ qty ┃
+ ┣━━━━━━━━╋━━━━━━━┫
+ ┃ spam ┃ 42 ┃
+ ┣━━━━━━━━╋━━━━━━━┫
+ ┃ eggs ┃ 451 ┃
+ ┣━━━━━━━━╋━━━━━━━┫
+ ┃ bacon ┃ 0 ┃
+ ┗━━━━━━━━┻━━━━━━━┛
+
+`mixed_grid` draws a grid using a mix of light (thin) and heavy (thick) lines box-drawing characters:
+
+ >>> print(tabulate(table, headers, tablefmt="mixed_grid"))
+ ┍━━━━━━━━┯━━━━━━━┑
+ │ item │ qty │
+ ┝━━━━━━━━┿━━━━━━━┥
+ │ spam │ 42 │
+ ├────────┼───────┤
+ │ eggs │ 451 │
+ ├────────┼───────┤
+ │ bacon │ 0 │
+ ┕━━━━━━━━┷━━━━━━━┙
+
+`double_grid` draws a grid using double-line box-drawing characters:
+
+ >>> print(tabulate(table, headers, tablefmt="double_grid"))
+ ╔════════╦═══════╗
+ ║ item ║ qty ║
+ ╠════════╬═══════╣
+ ║ spam ║ 42 ║
+ ╠════════╬═══════╣
+ ║ eggs ║ 451 ║
+ ╠════════╬═══════╣
+ ║ bacon ║ 0 ║
+ ╚════════╩═══════╝
+
+`fancy_grid` draws a grid using a mix of single and
+ double-line box-drawing characters:
+
+```pycon
+>>> print(tabulate(table, headers, tablefmt="fancy_grid"))
+╒════════╤═══════╕
+│ item │ qty │
+╞════════╪═══════╡
+│ spam │ 42 │
+├────────┼───────┤
+│ eggs │ 451 │
+├────────┼───────┤
+│ bacon │ 0 │
+╘════════╧═══════╛
+```
+
+`outline` is the same as the `grid` format but doesn't draw lines between rows:
+
+ >>> print(tabulate(table, headers, tablefmt="outline"))
+ +--------+-------+
+ | item | qty |
+ +========+=======+
+ | spam | 42 |
+ | eggs | 451 |
+ | bacon | 0 |
+ +--------+-------+
+
+`simple_outline` is the same as the `simple_grid` format but doesn't draw lines between rows:
+
+ >>> print(tabulate(table, headers, tablefmt="simple_outline"))
+ ┌────────┬───────┐
+ │ item │ qty │
+ ├────────┼───────┤
+ │ spam │ 42 │
+ │ eggs │ 451 │
+ │ bacon │ 0 │
+ └────────┴───────┘
+
+`rounded_outline` is the same as the `rounded_grid` format but doesn't draw lines between rows:
+
+ >>> print(tabulate(table, headers, tablefmt="rounded_outline"))
+ ╭────────┬───────╮
+ │ item │ qty │
+ ├────────┼───────┤
+ │ spam │ 42 │
+ │ eggs │ 451 │
+ │ bacon │ 0 │
+ ╰────────┴───────╯
+
+`heavy_outline` is the same as the `heavy_grid` format but doesn't draw lines between rows:
+
+ >>> print(tabulate(table, headers, tablefmt="heavy_outline"))
+ ┏━━━━━━━━┳━━━━━━━┓
+ ┃ item ┃ qty ┃
+ ┣━━━━━━━━╋━━━━━━━┫
+ ┃ spam ┃ 42 ┃
+ ┃ eggs ┃ 451 ┃
+ ┃ bacon ┃ 0 ┃
+ ┗━━━━━━━━┻━━━━━━━┛
+
+`mixed_outline` is the same as the `mixed_grid` format but doesn't draw lines between rows:
+
+ >>> print(tabulate(table, headers, tablefmt="mixed_outline"))
+ ┍━━━━━━━━┯━━━━━━━┑
+ │ item │ qty │
+ ┝━━━━━━━━┿━━━━━━━┥
+ │ spam │ 42 │
+ │ eggs │ 451 │
+ │ bacon │ 0 │
+ ┕━━━━━━━━┷━━━━━━━┙
+
+`double_outline` is the same as the `double_grid` format but doesn't draw lines between rows:
+
+ >>> print(tabulate(table, headers, tablefmt="double_outline"))
+ ╔════════╦═══════╗
+ ║ item ║ qty ║
+ ╠════════╬═══════╣
+ ║ spam ║ 42 ║
+ ║ eggs ║ 451 ║
+ ║ bacon ║ 0 ║
+ ╚════════╩═══════╝
+
+`fancy_outline` is the same as the `fancy_grid` format but doesn't draw lines between rows:
+
+ >>> print(tabulate(table, headers, tablefmt="fancy_outline"))
+ ╒════════╤═══════╕
+ │ item │ qty │
+ ╞════════╪═══════╡
+ │ spam │ 42 │
+ │ eggs │ 451 │
+ │ bacon │ 0 │
+ ╘════════╧═══════╛
+
+`presto` is like tables formatted by Presto cli:
+
+```pycon
+>>> print(tabulate(table, headers, tablefmt="presto"))
+ item | qty
+--------+-------
+ spam | 42
+ eggs | 451
+ bacon | 0
+```
+
+`pretty` attempts to be close to the format emitted by the PrettyTables
+library:
+
+```pycon
+>>> print(tabulate(table, headers, tablefmt="pretty"))
++-------+-----+
+| item | qty |
++-------+-----+
+| spam | 42 |
+| eggs | 451 |
+| bacon | 0 |
++-------+-----+
+```
+
+`psql` is like tables formatted by Postgres' psql cli:
+
+```pycon
+>>> print(tabulate(table, headers, tablefmt="psql"))
++--------+-------+
+| item | qty |
+|--------+-------|
+| spam | 42 |
+| eggs | 451 |
+| bacon | 0 |
++--------+-------+
+```
+
+`pipe` follows the conventions of [PHP Markdown
+Extra](http://michelf.ca/projects/php-markdown/extra/#table) extension.
+It corresponds to `pipe_tables` in Pandoc. This format uses colons to
+indicate column alignment:
+
+```pycon
+>>> print(tabulate(table, headers, tablefmt="pipe"))
+| item | qty |
+|:-------|------:|
+| spam | 42 |
+| eggs | 451 |
+| bacon | 0 |
+```
+
+`asciidoc` formats data like a simple table of the
+[AsciiDoctor](https://docs.asciidoctor.org/asciidoc/latest/syntax-quick-reference/#tables)
+format:
+
+```pycon
+>>> print(tabulate(table, headers, tablefmt="asciidoc"))
+[cols="8<,7>",options="header"]
+|====
+| item | qty
+| spam | 42
+| eggs | 451
+| bacon | 0
+|====
+```
+
+`orgtbl` follows the conventions of Emacs
+[org-mode](http://orgmode.org/manual/Tables.html), and is editable also
+in the minor orgtbl-mode. Hence its name:
+
+```pycon
+>>> print(tabulate(table, headers, tablefmt="orgtbl"))
+| item | qty |
+|--------+-------|
+| spam | 42 |
+| eggs | 451 |
+| bacon | 0 |
+```
+
+`jira` follows the conventions of Atlassian Jira markup language:
+
+```pycon
+>>> print(tabulate(table, headers, tablefmt="jira"))
+|| item || qty ||
+| spam | 42 |
+| eggs | 451 |
+| bacon | 0 |
+```
+
+`rst` formats data like a simple table of the
+[reStructuredText](http://docutils.sourceforge.net/docs/user/rst/quickref.html#tables)
+format:
+
+```pycon
+>>> print(tabulate(table, headers, tablefmt="rst"))
+====== =====
+item qty
+====== =====
+spam 42
+eggs 451
+bacon 0
+====== =====
+```
+
+`mediawiki` format produces a table markup used in
+[Wikipedia](http://www.mediawiki.org/wiki/Help:Tables) and on other
+MediaWiki-based sites:
+
+ ```pycon
+>>> print(tabulate(table, headers, tablefmt="mediawiki"))
+{| class="wikitable" style="text-align: left;"
+|+
+|-
+! item !! align="right"| qty
+|-
+| spam || align="right"| 42
+|-
+| eggs || align="right"| 451
+|-
+| bacon || align="right"| 0
+|}
+```
+
+`moinmoin` format produces a table markup used in
+[MoinMoin](https://moinmo.in/) wikis:
+
+```pycon
+>>> print(tabulate(table, headers, tablefmt="moinmoin"))
+|| ''' item ''' || ''' quantity ''' ||
+|| spam || 41.999 ||
+|| eggs || 451 ||
+|| bacon || ||
+```
+
+`youtrack` format produces a table markup used in Youtrack tickets:
+
+```pycon
+>>> print(tabulate(table, headers, tablefmt="youtrack"))
+|| item || quantity ||
+| spam | 41.999 |
+| eggs | 451 |
+| bacon | |
+```
+
+`textile` format produces a table markup used in
+[Textile](http://redcloth.org/hobix.com/textile/) format:
+
+```pycon
+>>> print(tabulate(table, headers, tablefmt="textile"))
+|_. item |_. qty |
+|<. spam |>. 42 |
+|<. eggs |>. 451 |
+|<. bacon |>. 0 |
+```
+
+`html` produces standard HTML markup as an html.escape'd str
+with a ._repr_html_ method so that Jupyter Lab and Notebook display the HTML
+and a .str property so that the raw HTML remains accessible.
+`unsafehtml` table format can be used if an unescaped HTML is required:
+
+```pycon
+>>> print(tabulate(table, headers, tablefmt="html"))
+
+
+item qty spam 42 eggs 451 bacon 0
+```
+
+`latex` format creates a `tabular` environment for LaTeX markup,
+replacing special characters like `_` or `\` to their LaTeX
+correspondents:
+
+```pycon
+>>> print(tabulate(table, headers, tablefmt="latex"))
+\begin{tabular}{lr}
+\hline
+ item & qty \\
+\hline
+ spam & 42 \\
+ eggs & 451 \\
+ bacon & 0 \\
+\hline
+\end{tabular}
+```
+
+`latex_raw` behaves like `latex` but does not escape LaTeX commands and
+special characters.
+
+`latex_booktabs` creates a `tabular` environment for LaTeX markup using
+spacing and style from the `booktabs` package.
+
+`latex_longtable` creates a table that can stretch along multiple pages,
+using the `longtable` package.
+
+### Column alignment
+
+`tabulate` is smart about column alignment. It detects columns which
+contain only numbers, and aligns them by a decimal point (or flushes
+them to the right if they appear to be integers). Text columns are
+flushed to the left.
+
+You can override the default alignment with `numalign` and `stralign`
+named arguments. Possible column alignments are: `right`, `center`,
+`left`, `decimal` (only for numbers), and `None` (to disable alignment).
+
+Aligning by a decimal point works best when you need to compare numbers
+at a glance:
+
+```pycon
+>>> print(tabulate([[1.2345],[123.45],[12.345],[12345],[1234.5]]))
+----------
+ 1.2345
+ 123.45
+ 12.345
+12345
+ 1234.5
+----------
+```
+
+Compare this with a more common right alignment:
+
+```pycon
+>>> print(tabulate([[1.2345],[123.45],[12.345],[12345],[1234.5]], numalign="right"))
+------
+1.2345
+123.45
+12.345
+ 12345
+1234.5
+------
+```
+
+For `tabulate`, anything which can be parsed as a number is a number.
+Even numbers represented as strings are aligned properly. This feature
+comes in handy when reading a mixed table of text and numbers from a
+file:
+
+```pycon
+>>> import csv ; from StringIO import StringIO
+>>> table = list(csv.reader(StringIO("spam, 42\neggs, 451\n")))
+>>> table
+[['spam', ' 42'], ['eggs', ' 451']]
+>>> print(tabulate(table))
+---- ----
+spam 42
+eggs 451
+---- ----
+```
+
+To disable this feature use `disable_numparse=True`.
+
+```pycon
+>>> print(tabulate.tabulate([["Ver1", "18.0"], ["Ver2","19.2"]], tablefmt="simple", disable_numparse=True))
+---- ----
+Ver1 18.0
+Ver2 19.2
+---- ----
+```
+
+### Custom column alignment
+
+`tabulate` allows a custom column alignment to override the above. The
+`colalign` argument can be a list or a tuple of `stralign` named
+arguments. Possible column alignments are: `right`, `center`, `left`,
+`decimal` (only for numbers), and `None` (to disable alignment).
+Omitting an alignment uses the default. For example:
+
+```pycon
+>>> print(tabulate([["one", "two"], ["three", "four"]], colalign=("right",))
+----- ----
+ one two
+three four
+----- ----
+```
+
+### Number formatting
+
+`tabulate` allows to define custom number formatting applied to all
+columns of decimal numbers. Use `floatfmt` named argument:
+
+```pycon
+>>> print(tabulate([["pi",3.141593],["e",2.718282]], floatfmt=".4f"))
+-- ------
+pi 3.1416
+e 2.7183
+-- ------
+```
+
+`floatfmt` argument can be a list or a tuple of format strings, one per
+column, in which case every column may have different number formatting:
+
+```pycon
+>>> print(tabulate([[0.12345, 0.12345, 0.12345]], floatfmt=(".1f", ".3f")))
+--- ----- -------
+0.1 0.123 0.12345
+--- ----- -------
+```
+
+`intfmt` works similarly for integers
+
+ >>> print(tabulate([["a",1000],["b",90000]], intfmt=","))
+ - ------
+ a 1,000
+ b 90,000
+ - ------
+
+### Text formatting
+
+By default, `tabulate` removes leading and trailing whitespace from text
+columns. To disable whitespace removal, set the global module-level flag
+`PRESERVE_WHITESPACE`:
+
+```python
+import tabulate
+tabulate.PRESERVE_WHITESPACE = True
+```
+
+### Wide (fullwidth CJK) symbols
+
+To properly align tables which contain wide characters (typically
+fullwidth glyphs from Chinese, Japanese or Korean languages), the user
+should install `wcwidth` library. To install it together with
+`tabulate`:
+
+```shell
+pip install tabulate[widechars]
+```
+
+Wide character support is enabled automatically if `wcwidth` library is
+already installed. To disable wide characters support without
+uninstalling `wcwidth`, set the global module-level flag
+`WIDE_CHARS_MODE`:
+
+```python
+import tabulate
+tabulate.WIDE_CHARS_MODE = False
+```
+
+### Multiline cells
+
+Most table formats support multiline cell text (text containing newline
+characters). The newline characters are honored as line break
+characters.
+
+Multiline cells are supported for data rows and for header rows.
+
+Further automatic line breaks are not inserted. Of course, some output
+formats such as latex or html handle automatic formatting of the cell
+content on their own, but for those that don't, the newline characters
+in the input cell text are the only means to break a line in cell text.
+
+Note that some output formats (e.g. simple, or plain) do not represent
+row delimiters, so that the representation of multiline cells in such
+formats may be ambiguous to the reader.
+
+The following examples of formatted output use the following table with
+a multiline cell, and headers with a multiline cell:
+
+```pycon
+>>> table = [["eggs",451],["more\nspam",42]]
+>>> headers = ["item\nname", "qty"]
+```
+
+`plain` tables:
+
+```pycon
+>>> print(tabulate(table, headers, tablefmt="plain"))
+item qty
+name
+eggs 451
+more 42
+spam
+```
+
+`simple` tables:
+
+```pycon
+>>> print(tabulate(table, headers, tablefmt="simple"))
+item qty
+name
+------ -----
+eggs 451
+more 42
+spam
+```
+
+`grid` tables:
+
+```pycon
+>>> print(tabulate(table, headers, tablefmt="grid"))
++--------+-------+
+| item | qty |
+| name | |
++========+=======+
+| eggs | 451 |
++--------+-------+
+| more | 42 |
+| spam | |
++--------+-------+
+```
+
+`fancy_grid` tables:
+
+```pycon
+>>> print(tabulate(table, headers, tablefmt="fancy_grid"))
+╒════════╤═══════╕
+│ item │ qty │
+│ name │ │
+╞════════╪═══════╡
+│ eggs │ 451 │
+├────────┼───────┤
+│ more │ 42 │
+│ spam │ │
+╘════════╧═══════╛
+```
+
+`pipe` tables:
+
+```pycon
+>>> print(tabulate(table, headers, tablefmt="pipe"))
+| item | qty |
+| name | |
+|:-------|------:|
+| eggs | 451 |
+| more | 42 |
+| spam | |
+```
+
+`orgtbl` tables:
+
+```pycon
+>>> print(tabulate(table, headers, tablefmt="orgtbl"))
+| item | qty |
+| name | |
+|--------+-------|
+| eggs | 451 |
+| more | 42 |
+| spam | |
+```
+
+`jira` tables:
+
+```pycon
+>>> print(tabulate(table, headers, tablefmt="jira"))
+| item | qty |
+| name | |
+|:-------|------:|
+| eggs | 451 |
+| more | 42 |
+| spam | |
+```
+
+`presto` tables:
+
+```pycon
+>>> print(tabulate(table, headers, tablefmt="presto"))
+ item | qty
+ name |
+--------+-------
+ eggs | 451
+ more | 42
+ spam |
+```
+
+`pretty` tables:
+
+```pycon
+>>> print(tabulate(table, headers, tablefmt="pretty"))
++------+-----+
+| item | qty |
+| name | |
++------+-----+
+| eggs | 451 |
+| more | 42 |
+| spam | |
++------+-----+
+```
+
+`psql` tables:
+
+```pycon
+>>> print(tabulate(table, headers, tablefmt="psql"))
++--------+-------+
+| item | qty |
+| name | |
+|--------+-------|
+| eggs | 451 |
+| more | 42 |
+| spam | |
++--------+-------+
+```
+
+`rst` tables:
+
+```pycon
+>>> print(tabulate(table, headers, tablefmt="rst"))
+====== =====
+item qty
+name
+====== =====
+eggs 451
+more 42
+spam
+====== =====
+```
+
+Multiline cells are not well-supported for the other table formats.
+
+### Automating Multilines
+While tabulate supports data passed in with multilines entries explicitly provided,
+it also provides some support to help manage this work internally.
+
+The `maxcolwidths` argument is a list where each entry specifies the max width for
+it's respective column. Any cell that will exceed this will automatically wrap the content.
+To assign the same max width for all columns, a singular int scaler can be used.
+
+Use `None` for any columns where an explicit maximum does not need to be provided,
+and thus no automate multiline wrapping will take place.
+
+The wrapping uses the python standard [textwrap.wrap](https://docs.python.org/3/library/textwrap.html#textwrap.wrap)
+function with default parameters - aside from width.
+
+This example demonstrates usage of automatic multiline wrapping, though typically
+the lines being wrapped would probably be significantly longer than this.
+
+```pycon
+>>> print(tabulate([["John Smith", "Middle Manager"]], headers=["Name", "Title"], tablefmt="grid", maxcolwidths=[None, 8]))
++------------+---------+
+| Name | Title |
++============+=========+
+| John Smith | Middle |
+| | Manager |
++------------+---------+
+```
+
+### Adding Separating lines
+One might want to add one or more separating lines to highlight different sections in a table.
+
+The separating lines will be of the same type as the one defined by the specified formatter as either the
+linebetweenrows, linebelowheader, linebelow, lineabove or just a simple empty line when none is defined for the formatter
+
+
+ >>> from tabulate import tabulate, SEPARATING_LINE
+
+ table = [["Earth",6371],
+ ["Mars",3390],
+ SEPARATING_LINE,
+ ["Moon",1737]]
+ print(tabulate(table, tablefmt="simple"))
+ ----- ----
+ Earth 6371
+ Mars 3390
+ ----- ----
+ Moon 1737
+ ----- ----
+
+### ANSI support
+ANSI escape codes are non-printable byte sequences usually used for terminal operations like setting
+color output or modifying cursor positions. Because multi-byte ANSI sequences are inherently non-printable,
+they can still introduce unwanted extra length to strings. For example:
+
+ >>> len('\033[31mthis text is red\033[0m') # printable length is 16
+ 25
+
+To deal with this, string lengths are calculated after first removing all ANSI escape sequences. This ensures
+that the actual printable length is used for column widths, rather than the byte length. In the final, printable
+table, however, ANSI escape sequences are not removed so the original styling is preserved.
+
+Some terminals support a special grouping of ANSI escape sequences that are intended to display hyperlinks
+much in the same way they are shown in browsers. These are handled just as mentioned before: non-printable
+ANSI escape sequences are removed prior to string length calculation. The only diifference with escaped
+hyperlinks is that column width will be based on the length of the URL _text_ rather than the URL
+itself (terminals would show this text). For example:
+
+ >>> len('\x1b]8;;https://example.com\x1b\\example\x1b]8;;\x1b\\') # display length is 7, showing 'example'
+ 45
+
+
+Usage of the command line utility
+---------------------------------
+
+ Usage: tabulate [options] [FILE ...]
+
+ FILE a filename of the file with tabular data;
+ if "-" or missing, read data from stdin.
+
+ Options:
+
+ -h, --help show this message
+ -1, --header use the first row of data as a table header
+ -o FILE, --output FILE print table to FILE (default: stdout)
+ -s REGEXP, --sep REGEXP use a custom column separator (default: whitespace)
+ -F FPFMT, --float FPFMT floating point number format (default: g)
+ -I INTFMT, --int INTFMT integer point number format (default: "")
+ -f FMT, --format FMT set output table format; supported formats:
+ plain, simple, github, grid, fancy_grid, pipe,
+ orgtbl, rst, mediawiki, html, latex, latex_raw,
+ latex_booktabs, latex_longtable, tsv
+ (default: simple)
+
+Performance considerations
+--------------------------
+
+Such features as decimal point alignment and trying to parse everything
+as a number imply that `tabulate`:
+
+- has to "guess" how to print a particular tabular data type
+- needs to keep the entire table in-memory
+- has to "transpose" the table twice
+- does much more work than it may appear
+
+It may not be suitable for serializing really big tables (but who's
+going to do that, anyway?) or printing tables in performance sensitive
+applications. `tabulate` is about two orders of magnitude slower than
+simply joining lists of values with a tab, comma, or other separator.
+
+At the same time, `tabulate` is comparable to other table
+pretty-printers. Given a 10x10 table (a list of lists) of mixed text and
+numeric data, `tabulate` appears to be slower than `asciitable`, and
+faster than `PrettyTable` and `texttable` The following mini-benchmark
+was run in Python 3.9.13 on Windows 10:
+
+ ================================= ========== ===========
+ Table formatter time, μs rel. time
+ ================================= ========== ===========
+ csv to StringIO 12.5 1.0
+ join with tabs and newlines 14.6 1.2
+ asciitable (0.8.0) 192.0 15.4
+ tabulate (0.9.0) 483.5 38.7
+ tabulate (0.9.0, WIDE_CHARS_MODE) 637.6 51.1
+ PrettyTable (3.4.1) 1080.6 86.6
+ texttable (1.6.4) 1390.3 111.4
+ ================================= ========== ===========
+
+
+Version history
+---------------
+
+The full version history can be found at the [changelog](https://github.com/astanin/python-tabulate/blob/master/CHANGELOG).
+
+How to contribute
+-----------------
+
+Contributions should include tests and an explanation for the changes
+they propose. Documentation (examples, docstrings, README.md) should be
+updated accordingly.
+
+This project uses [pytest](https://docs.pytest.org/) testing
+framework and [tox](https://tox.readthedocs.io/) to automate testing in
+different environments. Add tests to one of the files in the `test/`
+folder.
+
+To run tests on all supported Python versions, make sure all Python
+interpreters, `pytest` and `tox` are installed, then run `tox` in the root
+of the project source tree.
+
+On Linux `tox` expects to find executables like `python3.7`, `python3.8` etc.
+On Windows it looks for `C:\Python37\python.exe`, `C:\Python38\python.exe` etc. respectively.
+
+One way to install all the required versions of the Python interpreter is to use [pyenv](https://github.com/pyenv/pyenv).
+All versions can then be easily installed with something like:
+
+ pyenv install 3.7.12
+ pyenv install 3.8.12
+ ...
+
+Don't forget to change your `PATH` so that `tox` knows how to find all the installed versions. Something like
+
+ export PATH="${PATH}:${HOME}/.pyenv/shims"
+
+To test only some Python environments, use `-e` option. For example, to
+test only against Python 3.7 and Python 3.10, run:
+
+```shell
+tox -e py37,py310
+```
+
+in the root of the project source tree.
+
+To enable NumPy and Pandas tests, run:
+
+```shell
+tox -e py37-extra,py310-extra
+```
+
+(this may take a long time the first time, because NumPy and Pandas will
+have to be installed in the new virtual environments)
+
+To fix code formatting:
+
+```shell
+tox -e lint
+```
+
+See `tox.ini` file to learn how to use to test
+individual Python versions.
+
+Contributors
+------------
+
+Sergey Astanin, Pau Tallada Crespí, Erwin Marsi, Mik Kocikowski, Bill
+Ryder, Zach Dwiel, Frederik Rietdijk, Philipp Bogensberger, Greg
+(anonymous), Stefan Tatschner, Emiel van Miltenburg, Brandon Bennett,
+Amjith Ramanujam, Jan Schulz, Simon Percivall, Javier Santacruz
+López-Cepero, Sam Denton, Alexey Ziyangirov, acaird, Cesar Sanchez,
+naught101, John Vandenberg, Zack Dever, Christian Clauss, Benjamin
+Maier, Andy MacKinlay, Thomas Roten, Jue Wang, Joe King, Samuel Phan,
+Nick Satterly, Daniel Robbins, Dmitry B, Lars Butler, Andreas Maier,
+Dick Marinus, Sébastien Celles, Yago González, Andrew Gaul, Wim Glenn,
+Jean Michel Rouly, Tim Gates, John Vandenberg, Sorin Sbarnea,
+Wes Turner, Andrew Tija, Marco Gorelli, Sean McGinnis, danja100,
+endolith, Dominic Davis-Foster, pavlocat, Daniel Aslau, paulc,
+Felix Yan, Shane Loretz, Frank Busse, Harsh Singh, Derek Weitzel,
+Vladimir Vrzić, 서승우 (chrd5273), Georgy Frolov, Christian Cwienk,
+Bart Broere, Vilhelm Prytz, Alexander Gažo, Hugo van Kemenade,
+jamescooke, Matt Warner, Jérôme Provensal, Kevin Deldycke,
+Kian-Meng Ang, Kevin Patterson, Shodhan Save, cleoold, KOLANICH,
+Vijaya Krishna Kasula, Furcy Pin, Christian Fibich, Shaun Duncan,
+Dimitri Papadopoulos.
+
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/tabulate-0.9.0.dist-info/RECORD b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/tabulate-0.9.0.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..7787732a2e355b8f363b6ed89a680dfa3adb531b
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/tabulate-0.9.0.dist-info/RECORD
@@ -0,0 +1,12 @@
+../../../bin/tabulate,sha256=dBEFzs6YjZY087iZJHuTJ4RWxn8McdHmEhsNzmZJlpo,271
+tabulate-0.9.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+tabulate-0.9.0.dist-info/LICENSE,sha256=zfq1DTfY6tBkaPt2o6uvzQXBZ0nsihjuv6UP1Ix8stI,1080
+tabulate-0.9.0.dist-info/METADATA,sha256=8oAqreJhIJG0WVHyZa8pF0-QwyNvaMyMzetkaUHmKWk,34132
+tabulate-0.9.0.dist-info/RECORD,,
+tabulate-0.9.0.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+tabulate-0.9.0.dist-info/entry_points.txt,sha256=8DmChBYma2n4UqC1VkkKbD5Nu4MrdZasURoeTtG0JVo,44
+tabulate-0.9.0.dist-info/top_level.txt,sha256=qfqkQ2az7LTxUeRePtX8ggmh294Kf1ERdI-11aWqFZU,9
+tabulate/__init__.py,sha256=X3rwoo_NcTuDDJc4hnWUX6jElQsFtY-NGHyQCldS1X0,95290
+tabulate/__pycache__/__init__.cpython-312.pyc,,
+tabulate/__pycache__/version.cpython-312.pyc,,
+tabulate/version.py,sha256=QVVpjnTor93ym-Tb6Y_XtL_6pmQ3MtoNy3Q6I0o3Yqg,181
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/tabulate-0.9.0.dist-info/WHEEL b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/tabulate-0.9.0.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..becc9a66ea739ba941d48a749e248761cc6e658a
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/tabulate-0.9.0.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/tabulate-0.9.0.dist-info/entry_points.txt b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/tabulate-0.9.0.dist-info/entry_points.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1efc880fa41d55743166d009c0a7368ba2493679
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/tabulate-0.9.0.dist-info/entry_points.txt
@@ -0,0 +1,2 @@
+[console_scripts]
+tabulate = tabulate:_main
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/tabulate-0.9.0.dist-info/top_level.txt b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/tabulate-0.9.0.dist-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a5d51591ebf67bc53acb1c8481da364dae742a02
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/tabulate-0.9.0.dist-info/top_level.txt
@@ -0,0 +1 @@
+tabulate
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/tokenizers-0.22.2.dist-info/INSTALLER b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/tokenizers-0.22.2.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/tokenizers-0.22.2.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/tokenizers-0.22.2.dist-info/METADATA b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/tokenizers-0.22.2.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..4bb4912e0688994cd2f122f4278cd577833644a0
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/tokenizers-0.22.2.dist-info/METADATA
@@ -0,0 +1,214 @@
+Metadata-Version: 2.4
+Name: tokenizers
+Version: 0.22.2
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Dist: huggingface-hub>=0.16.4,<2.0
+Requires-Dist: pytest ; extra == 'testing'
+Requires-Dist: pytest-asyncio ; extra == 'testing'
+Requires-Dist: requests ; extra == 'testing'
+Requires-Dist: numpy ; extra == 'testing'
+Requires-Dist: datasets ; extra == 'testing'
+Requires-Dist: ruff ; extra == 'testing'
+Requires-Dist: ty ; extra == 'testing'
+Requires-Dist: sphinx ; extra == 'docs'
+Requires-Dist: sphinx-rtd-theme ; extra == 'docs'
+Requires-Dist: setuptools-rust ; extra == 'docs'
+Requires-Dist: tokenizers[testing] ; extra == 'dev'
+Provides-Extra: testing
+Provides-Extra: docs
+Provides-Extra: dev
+Keywords: NLP,tokenizer,BPE,transformer,deep learning
+Author-email: Nicolas Patry , Anthony Moi
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Homepage, https://github.com/huggingface/tokenizers
+Project-URL: Source, https://github.com/huggingface/tokenizers
+
+
+
+ 
+
+
+
+
+
+# Tokenizers
+
+Provides an implementation of today's most used tokenizers, with a focus on performance and
+versatility.
+
+Bindings over the [Rust](https://github.com/huggingface/tokenizers/tree/master/tokenizers) implementation.
+If you are interested in the High-level design, you can go check it there.
+
+Otherwise, let's dive in!
+
+## Main features:
+
+ - Train new vocabularies and tokenize using 4 pre-made tokenizers (Bert WordPiece and the 3
+ most common BPE versions).
+ - Extremely fast (both training and tokenization), thanks to the Rust implementation. Takes
+ less than 20 seconds to tokenize a GB of text on a server's CPU.
+ - Easy to use, but also extremely versatile.
+ - Designed for research and production.
+ - Normalization comes with alignments tracking. It's always possible to get the part of the
+ original sentence that corresponds to a given token.
+ - Does all the pre-processing: Truncate, Pad, add the special tokens your model needs.
+
+### Installation
+
+#### With pip:
+
+```bash
+pip install tokenizers
+```
+
+#### From sources:
+
+To use this method, you need to have the Rust installed:
+
+```bash
+# Install with:
+curl https://sh.rustup.rs -sSf | sh -s -- -y
+export PATH="$HOME/.cargo/bin:$PATH"
+```
+
+Once Rust is installed, you can compile doing the following
+
+```bash
+git clone https://github.com/huggingface/tokenizers
+cd tokenizers/bindings/python
+
+# Create a virtual env (you can use yours as well)
+python -m venv .env
+source .env/bin/activate
+
+# Install `tokenizers` in the current virtual env
+pip install -e .
+```
+
+### Load a pretrained tokenizer from the Hub
+
+```python
+from tokenizers import Tokenizer
+
+tokenizer = Tokenizer.from_pretrained("bert-base-cased")
+```
+
+### Using the provided Tokenizers
+
+We provide some pre-build tokenizers to cover the most common cases. You can easily load one of
+these using some `vocab.json` and `merges.txt` files:
+
+```python
+from tokenizers import CharBPETokenizer
+
+# Initialize a tokenizer
+vocab = "./path/to/vocab.json"
+merges = "./path/to/merges.txt"
+tokenizer = CharBPETokenizer(vocab, merges)
+
+# And then encode:
+encoded = tokenizer.encode("I can feel the magic, can you?")
+print(encoded.ids)
+print(encoded.tokens)
+```
+
+And you can train them just as simply:
+
+```python
+from tokenizers import CharBPETokenizer
+
+# Initialize a tokenizer
+tokenizer = CharBPETokenizer()
+
+# Then train it!
+tokenizer.train([ "./path/to/files/1.txt", "./path/to/files/2.txt" ])
+
+# Now, let's use it:
+encoded = tokenizer.encode("I can feel the magic, can you?")
+
+# And finally save it somewhere
+tokenizer.save("./path/to/directory/my-bpe.tokenizer.json")
+```
+
+#### Provided Tokenizers
+
+ - `CharBPETokenizer`: The original BPE
+ - `ByteLevelBPETokenizer`: The byte level version of the BPE
+ - `SentencePieceBPETokenizer`: A BPE implementation compatible with the one used by SentencePiece
+ - `BertWordPieceTokenizer`: The famous Bert tokenizer, using WordPiece
+
+All of these can be used and trained as explained above!
+
+### Build your own
+
+Whenever these provided tokenizers don't give you enough freedom, you can build your own tokenizer,
+by putting all the different parts you need together.
+You can check how we implemented the [provided tokenizers](https://github.com/huggingface/tokenizers/tree/master/bindings/python/py_src/tokenizers/implementations) and adapt them easily to your own needs.
+
+#### Building a byte-level BPE
+
+Here is an example showing how to build your own byte-level BPE by putting all the different pieces
+together, and then saving it to a single file:
+
+```python
+from tokenizers import Tokenizer, models, pre_tokenizers, decoders, trainers, processors
+
+# Initialize a tokenizer
+tokenizer = Tokenizer(models.BPE())
+
+# Customize pre-tokenization and decoding
+tokenizer.pre_tokenizer = pre_tokenizers.ByteLevel(add_prefix_space=True)
+tokenizer.decoder = decoders.ByteLevel()
+tokenizer.post_processor = processors.ByteLevel(trim_offsets=True)
+
+# And then train
+trainer = trainers.BpeTrainer(
+ vocab_size=20000,
+ min_frequency=2,
+ initial_alphabet=pre_tokenizers.ByteLevel.alphabet()
+)
+tokenizer.train([
+ "./path/to/dataset/1.txt",
+ "./path/to/dataset/2.txt",
+ "./path/to/dataset/3.txt"
+], trainer=trainer)
+
+# And Save it
+tokenizer.save("byte-level-bpe.tokenizer.json", pretty=True)
+```
+
+Now, when you want to use this tokenizer, this is as simple as:
+
+```python
+from tokenizers import Tokenizer
+
+tokenizer = Tokenizer.from_file("byte-level-bpe.tokenizer.json")
+
+encoded = tokenizer.encode("I can feel the magic, can you?")
+```
+
+### Typing support and `stub.py`
+
+The compiled PyO3 extension does not expose type annotations, so editors and type checkers would otherwise see most objects as `Any`. The `stub.py` helper walks the loaded extension modules, renders `.pyi` stub files (plus minimal forwarding `__init__.py` shims), and formats them so that tools like mypy/pyright can understand the public API. Run `python stub.py` whenever you change the Python-visible surface to keep the generated stubs in sync.
+
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/tokenizers-0.22.2.dist-info/RECORD b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/tokenizers-0.22.2.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..e5cddc66022fc46e93ad9bb941d8086b1f3d0b33
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/tokenizers-0.22.2.dist-info/RECORD
@@ -0,0 +1,46 @@
+tokenizers-0.22.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+tokenizers-0.22.2.dist-info/METADATA,sha256=FaXdr0ifWSt34Kk0wO60a1ETCpQGTKEpIyr9sKOGjvw,7254
+tokenizers-0.22.2.dist-info/RECORD,,
+tokenizers-0.22.2.dist-info/WHEEL,sha256=5mwg5nCvp3YrLxikUrE5E0HBDKerMOoBBb70NjCncME,143
+tokenizers/__init__.py,sha256=FI7LEi8_7gO-mrsf4hPdhfvGkb8q0rQ3_1MVM3gaajo,2639
+tokenizers/__init__.pyi,sha256=MKWF2m4mz7IG1bPTdJ7AjXkQDNzkmQSLMmACQ2VUYJU,55891
+tokenizers/__pycache__/__init__.cpython-312.pyc,,
+tokenizers/decoders/__init__.py,sha256=hfwM6CFUDvlMGGL4-xsaaYz81K9P5rQI5ZL5UHWK8Y4,372
+tokenizers/decoders/__init__.pyi,sha256=T60mFckMbS8YrsonOAPtfvb7VYHUJi9mm47Wd8pT62o,12019
+tokenizers/decoders/__pycache__/__init__.cpython-312.pyc,,
+tokenizers/implementations/__init__.py,sha256=VzAsplaIo7rl4AFO8Miu7ig7MfZjvonwVblZw01zR6M,310
+tokenizers/implementations/__pycache__/__init__.cpython-312.pyc,,
+tokenizers/implementations/__pycache__/base_tokenizer.cpython-312.pyc,,
+tokenizers/implementations/__pycache__/bert_wordpiece.cpython-312.pyc,,
+tokenizers/implementations/__pycache__/byte_level_bpe.cpython-312.pyc,,
+tokenizers/implementations/__pycache__/char_level_bpe.cpython-312.pyc,,
+tokenizers/implementations/__pycache__/sentencepiece_bpe.cpython-312.pyc,,
+tokenizers/implementations/__pycache__/sentencepiece_unigram.cpython-312.pyc,,
+tokenizers/implementations/base_tokenizer.py,sha256=PtQ2TSmoMGlTpL8oc8fDvwJVIY6isWGmps9comzsWjE,15806
+tokenizers/implementations/bert_wordpiece.py,sha256=sKCum0FKPYdSgJFJN8LDerVBoTDRSqyqSdrcm-lvQqI,5520
+tokenizers/implementations/byte_level_bpe.py,sha256=iBepM_z1s5Ky7zFDVrYLc3L5byYrIouk7-k0JGuF10s,4272
+tokenizers/implementations/char_level_bpe.py,sha256=Nag_HFq8Rvcucqi8MhV1-0xtoR0C7FjHOecFVURL7ss,5449
+tokenizers/implementations/sentencepiece_bpe.py,sha256=c08fKf6i92E2RsKgsxy7LzZfYX8-MACHSRG8U_I5ytY,3721
+tokenizers/implementations/sentencepiece_unigram.py,sha256=2RoIfFVpiMkJOtOCskM_VCeCELWaC_bNnds6GvtE0KQ,7630
+tokenizers/models/__init__.py,sha256=eJZ4HTAQZpxnKILNylWaTFqxXy-Ba6OKswWN47feeV8,176
+tokenizers/models/__init__.pyi,sha256=2gZPQR1Z5_krTzLXx-ts5ai7Fz7bTZ0QI1OSJ5MyOuc,19517
+tokenizers/models/__pycache__/__init__.cpython-312.pyc,,
+tokenizers/normalizers/__init__.py,sha256=_06w4cqRItveEgIddYaLMScgkSOkIAMIzYCesb5AA4U,841
+tokenizers/normalizers/__init__.pyi,sha256=6zYmbFtvdF1WhoWQSdEN974mxHjc7ZwJBA0TI2dJk98,25709
+tokenizers/normalizers/__pycache__/__init__.cpython-312.pyc,,
+tokenizers/pre_tokenizers/__init__.py,sha256=KV9-EsAykGENUUzkGWCbv4n6YM6hYa1hfnY-gzBpMNE,598
+tokenizers/pre_tokenizers/__init__.pyi,sha256=_pc34-Kd2N7Nvs7vTHPULBKjm18iJRM9qLOClVHw9n4,31566
+tokenizers/pre_tokenizers/__pycache__/__init__.cpython-312.pyc,,
+tokenizers/processors/__init__.py,sha256=xM2DEKwKtHIumHsszM8AMkq-AlaqvBZFXWgLU8SNhOY,307
+tokenizers/processors/__init__.pyi,sha256=5L5OBZ7SXCg7AEy51jyDHViaCSHG5c7vW4eWjSVQbUs,14348
+tokenizers/processors/__pycache__/__init__.cpython-312.pyc,,
+tokenizers/tokenizers.abi3.so,sha256=wRb88egNRhzgo1wzKXTyWUnoNZQW9Qs9UzcYENLOHMw,10074176
+tokenizers/tokenizers.pyi,sha256=Mq4G5RcxKiVc0FZd_Omi-bT7YQMRc-iDBU_nPCmCZOA,468
+tokenizers/tools/__init__.py,sha256=xG8caB9OHC8cbB01S5vYV14HZxhO6eWbLehsb70ppio,55
+tokenizers/tools/__pycache__/__init__.cpython-312.pyc,,
+tokenizers/tools/__pycache__/visualizer.cpython-312.pyc,,
+tokenizers/tools/visualizer-styles.css,sha256=zAydq1oGWD8QEll4-eyL8Llw0B1sty_hpIE3tYxL02k,4850
+tokenizers/tools/visualizer.py,sha256=jtxka01phNP47uQSocIQFO_DMnL3ZHdwohGVDqqYJPo,14834
+tokenizers/trainers/__init__.py,sha256=UTu22AGcp76IvpW45xLRbJWET04NxPW6NfCb2YYz0EM,248
+tokenizers/trainers/__init__.pyi,sha256=jKtDNXnoX6FWeCTeHz-W62Cj2_JErgYG7h1PReUz1rU,10719
+tokenizers/trainers/__pycache__/__init__.cpython-312.pyc,,
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/tokenizers-0.22.2.dist-info/WHEEL b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/tokenizers-0.22.2.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..323110c9487be1c50bc2f1c4e93b2ddbd7d02233
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/tokenizers-0.22.2.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: maturin (1.10.2)
+Root-Is-Purelib: false
+Tag: cp39-abi3-manylinux_2_17_x86_64
+Tag: cp39-abi3-manylinux2014_x86_64
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/tzdata/__init__.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/tzdata/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..87dba5a778c5983e31e6e777b1821a97f83abade
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/tzdata/__init__.py
@@ -0,0 +1,6 @@
+# IANA versions like 2020a are not valid PEP 440 identifiers; the recommended
+# way to translate the version is to use YYYY.n where `n` is a 0-based index.
+__version__ = "2025.1"
+
+# This exposes the original IANA version number.
+IANA_VERSION = "2025a"
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/tzdata/zones b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/tzdata/zones
new file mode 100644
index 0000000000000000000000000000000000000000..3c4a951d4990e82c545c0cc3a66fcb51d9d0b6e8
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/tzdata/zones
@@ -0,0 +1,597 @@
+Africa/Abidjan
+Africa/Algiers
+Africa/Bissau
+Africa/Cairo
+Africa/Casablanca
+Africa/Ceuta
+Africa/El_Aaiun
+Africa/Johannesburg
+Africa/Juba
+Africa/Khartoum
+Africa/Lagos
+Africa/Maputo
+Africa/Monrovia
+Africa/Nairobi
+Africa/Ndjamena
+Africa/Sao_Tome
+Africa/Tripoli
+Africa/Tunis
+Africa/Windhoek
+America/Adak
+America/Anchorage
+America/Araguaina
+America/Argentina/Buenos_Aires
+America/Argentina/Catamarca
+America/Argentina/Cordoba
+America/Argentina/Jujuy
+America/Argentina/La_Rioja
+America/Argentina/Mendoza
+America/Argentina/Rio_Gallegos
+America/Argentina/Salta
+America/Argentina/San_Juan
+America/Argentina/San_Luis
+America/Argentina/Tucuman
+America/Argentina/Ushuaia
+America/Asuncion
+America/Bahia
+America/Bahia_Banderas
+America/Barbados
+America/Belem
+America/Belize
+America/Boa_Vista
+America/Bogota
+America/Boise
+America/Cambridge_Bay
+America/Campo_Grande
+America/Cancun
+America/Caracas
+America/Cayenne
+America/Chicago
+America/Chihuahua
+America/Ciudad_Juarez
+America/Costa_Rica
+America/Cuiaba
+America/Danmarkshavn
+America/Dawson
+America/Dawson_Creek
+America/Denver
+America/Detroit
+America/Edmonton
+America/Eirunepe
+America/El_Salvador
+America/Fort_Nelson
+America/Fortaleza
+America/Glace_Bay
+America/Goose_Bay
+America/Grand_Turk
+America/Guatemala
+America/Guayaquil
+America/Guyana
+America/Halifax
+America/Havana
+America/Hermosillo
+America/Indiana/Indianapolis
+America/Indiana/Knox
+America/Indiana/Marengo
+America/Indiana/Petersburg
+America/Indiana/Tell_City
+America/Indiana/Vevay
+America/Indiana/Vincennes
+America/Indiana/Winamac
+America/Inuvik
+America/Iqaluit
+America/Jamaica
+America/Juneau
+America/Kentucky/Louisville
+America/Kentucky/Monticello
+America/La_Paz
+America/Lima
+America/Los_Angeles
+America/Maceio
+America/Managua
+America/Manaus
+America/Martinique
+America/Matamoros
+America/Mazatlan
+America/Menominee
+America/Merida
+America/Metlakatla
+America/Mexico_City
+America/Miquelon
+America/Moncton
+America/Monterrey
+America/Montevideo
+America/New_York
+America/Nome
+America/Noronha
+America/North_Dakota/Beulah
+America/North_Dakota/Center
+America/North_Dakota/New_Salem
+America/Nuuk
+America/Ojinaga
+America/Panama
+America/Paramaribo
+America/Phoenix
+America/Port-au-Prince
+America/Porto_Velho
+America/Puerto_Rico
+America/Punta_Arenas
+America/Rankin_Inlet
+America/Recife
+America/Regina
+America/Resolute
+America/Rio_Branco
+America/Santarem
+America/Santiago
+America/Santo_Domingo
+America/Sao_Paulo
+America/Scoresbysund
+America/Sitka
+America/St_Johns
+America/Swift_Current
+America/Tegucigalpa
+America/Thule
+America/Tijuana
+America/Toronto
+America/Vancouver
+America/Whitehorse
+America/Winnipeg
+America/Yakutat
+Antarctica/Casey
+Antarctica/Davis
+Antarctica/Macquarie
+Antarctica/Mawson
+Antarctica/Palmer
+Antarctica/Rothera
+Antarctica/Troll
+Antarctica/Vostok
+Asia/Almaty
+Asia/Amman
+Asia/Anadyr
+Asia/Aqtau
+Asia/Aqtobe
+Asia/Ashgabat
+Asia/Atyrau
+Asia/Baghdad
+Asia/Baku
+Asia/Bangkok
+Asia/Barnaul
+Asia/Beirut
+Asia/Bishkek
+Asia/Chita
+Asia/Colombo
+Asia/Damascus
+Asia/Dhaka
+Asia/Dili
+Asia/Dubai
+Asia/Dushanbe
+Asia/Famagusta
+Asia/Gaza
+Asia/Hebron
+Asia/Ho_Chi_Minh
+Asia/Hong_Kong
+Asia/Hovd
+Asia/Irkutsk
+Asia/Jakarta
+Asia/Jayapura
+Asia/Jerusalem
+Asia/Kabul
+Asia/Kamchatka
+Asia/Karachi
+Asia/Kathmandu
+Asia/Khandyga
+Asia/Kolkata
+Asia/Krasnoyarsk
+Asia/Kuching
+Asia/Macau
+Asia/Magadan
+Asia/Makassar
+Asia/Manila
+Asia/Nicosia
+Asia/Novokuznetsk
+Asia/Novosibirsk
+Asia/Omsk
+Asia/Oral
+Asia/Pontianak
+Asia/Pyongyang
+Asia/Qatar
+Asia/Qostanay
+Asia/Qyzylorda
+Asia/Riyadh
+Asia/Sakhalin
+Asia/Samarkand
+Asia/Seoul
+Asia/Shanghai
+Asia/Singapore
+Asia/Srednekolymsk
+Asia/Taipei
+Asia/Tashkent
+Asia/Tbilisi
+Asia/Tehran
+Asia/Thimphu
+Asia/Tokyo
+Asia/Tomsk
+Asia/Ulaanbaatar
+Asia/Urumqi
+Asia/Ust-Nera
+Asia/Vladivostok
+Asia/Yakutsk
+Asia/Yangon
+Asia/Yekaterinburg
+Asia/Yerevan
+Atlantic/Azores
+Atlantic/Bermuda
+Atlantic/Canary
+Atlantic/Cape_Verde
+Atlantic/Faroe
+Atlantic/Madeira
+Atlantic/South_Georgia
+Atlantic/Stanley
+Australia/Adelaide
+Australia/Brisbane
+Australia/Broken_Hill
+Australia/Darwin
+Australia/Eucla
+Australia/Hobart
+Australia/Lindeman
+Australia/Lord_Howe
+Australia/Melbourne
+Australia/Perth
+Australia/Sydney
+Etc/GMT
+Etc/GMT+1
+Etc/GMT+10
+Etc/GMT+11
+Etc/GMT+12
+Etc/GMT+2
+Etc/GMT+3
+Etc/GMT+4
+Etc/GMT+5
+Etc/GMT+6
+Etc/GMT+7
+Etc/GMT+8
+Etc/GMT+9
+Etc/GMT-1
+Etc/GMT-10
+Etc/GMT-11
+Etc/GMT-12
+Etc/GMT-13
+Etc/GMT-14
+Etc/GMT-2
+Etc/GMT-3
+Etc/GMT-4
+Etc/GMT-5
+Etc/GMT-6
+Etc/GMT-7
+Etc/GMT-8
+Etc/GMT-9
+Etc/UTC
+Europe/Andorra
+Europe/Astrakhan
+Europe/Athens
+Europe/Belgrade
+Europe/Berlin
+Europe/Brussels
+Europe/Bucharest
+Europe/Budapest
+Europe/Chisinau
+Europe/Dublin
+Europe/Gibraltar
+Europe/Helsinki
+Europe/Istanbul
+Europe/Kaliningrad
+Europe/Kirov
+Europe/Kyiv
+Europe/Lisbon
+Europe/London
+Europe/Madrid
+Europe/Malta
+Europe/Minsk
+Europe/Moscow
+Europe/Paris
+Europe/Prague
+Europe/Riga
+Europe/Rome
+Europe/Samara
+Europe/Saratov
+Europe/Simferopol
+Europe/Sofia
+Europe/Tallinn
+Europe/Tirane
+Europe/Ulyanovsk
+Europe/Vienna
+Europe/Vilnius
+Europe/Volgograd
+Europe/Warsaw
+Europe/Zurich
+Factory
+Indian/Chagos
+Indian/Maldives
+Indian/Mauritius
+Pacific/Apia
+Pacific/Auckland
+Pacific/Bougainville
+Pacific/Chatham
+Pacific/Easter
+Pacific/Efate
+Pacific/Fakaofo
+Pacific/Fiji
+Pacific/Galapagos
+Pacific/Gambier
+Pacific/Guadalcanal
+Pacific/Guam
+Pacific/Honolulu
+Pacific/Kanton
+Pacific/Kiritimati
+Pacific/Kosrae
+Pacific/Kwajalein
+Pacific/Marquesas
+Pacific/Nauru
+Pacific/Niue
+Pacific/Norfolk
+Pacific/Noumea
+Pacific/Pago_Pago
+Pacific/Palau
+Pacific/Pitcairn
+Pacific/Port_Moresby
+Pacific/Rarotonga
+Pacific/Tahiti
+Pacific/Tarawa
+Pacific/Tongatapu
+GMT
+Australia/ACT
+Australia/LHI
+Australia/NSW
+Australia/North
+Australia/Queensland
+Australia/South
+Australia/Tasmania
+Australia/Victoria
+Australia/West
+Australia/Yancowinna
+Brazil/Acre
+Brazil/DeNoronha
+Brazil/East
+Brazil/West
+CET
+CST6CDT
+Canada/Atlantic
+Canada/Central
+Canada/Eastern
+Canada/Mountain
+Canada/Newfoundland
+Canada/Pacific
+Canada/Saskatchewan
+Canada/Yukon
+Chile/Continental
+Chile/EasterIsland
+Cuba
+EET
+EST
+EST5EDT
+Egypt
+Eire
+Etc/GMT+0
+Etc/GMT-0
+Etc/GMT0
+Etc/Greenwich
+Etc/UCT
+Etc/Universal
+Etc/Zulu
+GB
+GB-Eire
+GMT+0
+GMT-0
+GMT0
+Greenwich
+Hongkong
+Iceland
+Iran
+Israel
+Jamaica
+Japan
+Kwajalein
+Libya
+MET
+MST
+MST7MDT
+Mexico/BajaNorte
+Mexico/BajaSur
+Mexico/General
+NZ
+NZ-CHAT
+Navajo
+PRC
+Poland
+Portugal
+ROC
+ROK
+Singapore
+Turkey
+UCT
+US/Alaska
+US/Aleutian
+US/Arizona
+US/Central
+US/East-Indiana
+US/Eastern
+US/Hawaii
+US/Indiana-Starke
+US/Michigan
+US/Mountain
+US/Pacific
+US/Samoa
+UTC
+Universal
+W-SU
+Zulu
+America/Buenos_Aires
+America/Catamarca
+America/Cordoba
+America/Indianapolis
+America/Jujuy
+America/Knox_IN
+America/Louisville
+America/Mendoza
+America/Virgin
+Pacific/Samoa
+Africa/Accra
+Africa/Addis_Ababa
+Africa/Asmara
+Africa/Bamako
+Africa/Bangui
+Africa/Banjul
+Africa/Blantyre
+Africa/Brazzaville
+Africa/Bujumbura
+Africa/Conakry
+Africa/Dakar
+Africa/Dar_es_Salaam
+Africa/Djibouti
+Africa/Douala
+Africa/Freetown
+Africa/Gaborone
+Africa/Harare
+Africa/Kampala
+Africa/Kigali
+Africa/Kinshasa
+Africa/Libreville
+Africa/Lome
+Africa/Luanda
+Africa/Lubumbashi
+Africa/Lusaka
+Africa/Malabo
+Africa/Maseru
+Africa/Mbabane
+Africa/Mogadishu
+Africa/Niamey
+Africa/Nouakchott
+Africa/Ouagadougou
+Africa/Porto-Novo
+America/Anguilla
+America/Antigua
+America/Aruba
+America/Atikokan
+America/Blanc-Sablon
+America/Cayman
+America/Creston
+America/Curacao
+America/Dominica
+America/Grenada
+America/Guadeloupe
+America/Kralendijk
+America/Lower_Princes
+America/Marigot
+America/Montserrat
+America/Nassau
+America/Port_of_Spain
+America/St_Barthelemy
+America/St_Kitts
+America/St_Lucia
+America/St_Thomas
+America/St_Vincent
+America/Tortola
+Antarctica/DumontDUrville
+Antarctica/McMurdo
+Antarctica/Syowa
+Arctic/Longyearbyen
+Asia/Aden
+Asia/Bahrain
+Asia/Brunei
+Asia/Kuala_Lumpur
+Asia/Kuwait
+Asia/Muscat
+Asia/Phnom_Penh
+Asia/Vientiane
+Atlantic/Reykjavik
+Atlantic/St_Helena
+Europe/Amsterdam
+Europe/Bratislava
+Europe/Busingen
+Europe/Copenhagen
+Europe/Guernsey
+Europe/Isle_of_Man
+Europe/Jersey
+Europe/Ljubljana
+Europe/Luxembourg
+Europe/Mariehamn
+Europe/Monaco
+Europe/Oslo
+Europe/Podgorica
+Europe/San_Marino
+Europe/Sarajevo
+Europe/Skopje
+Europe/Stockholm
+Europe/Vaduz
+Europe/Vatican
+Europe/Zagreb
+Indian/Antananarivo
+Indian/Christmas
+Indian/Cocos
+Indian/Comoro
+Indian/Kerguelen
+Indian/Mahe
+Indian/Mayotte
+Indian/Reunion
+Pacific/Chuuk
+Pacific/Funafuti
+Pacific/Majuro
+Pacific/Midway
+Pacific/Pohnpei
+Pacific/Saipan
+Pacific/Wake
+Pacific/Wallis
+Africa/Timbuktu
+America/Argentina/ComodRivadavia
+America/Atka
+America/Coral_Harbour
+America/Ensenada
+America/Fort_Wayne
+America/Montreal
+America/Nipigon
+America/Pangnirtung
+America/Porto_Acre
+America/Rainy_River
+America/Rosario
+America/Santa_Isabel
+America/Shiprock
+America/Thunder_Bay
+America/Yellowknife
+Antarctica/South_Pole
+Asia/Choibalsan
+Asia/Chongqing
+Asia/Harbin
+Asia/Kashgar
+Asia/Tel_Aviv
+Atlantic/Jan_Mayen
+Australia/Canberra
+Australia/Currie
+Europe/Belfast
+Europe/Tiraspol
+Europe/Uzhgorod
+Europe/Zaporozhye
+Pacific/Enderbury
+Pacific/Johnston
+Pacific/Yap
+WET
+Africa/Asmera
+America/Godthab
+Asia/Ashkhabad
+Asia/Calcutta
+Asia/Chungking
+Asia/Dacca
+Asia/Istanbul
+Asia/Katmandu
+Asia/Macao
+Asia/Rangoon
+Asia/Saigon
+Asia/Thimbu
+Asia/Ujung_Pandang
+Asia/Ulan_Bator
+Atlantic/Faeroe
+Europe/Kiev
+Europe/Nicosia
+HST
+PST8PDT
+Pacific/Ponape
+Pacific/Truk
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/wheel-0.45.1.dist-info/INSTALLER b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/wheel-0.45.1.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/wheel-0.45.1.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/wheel-0.45.1.dist-info/LICENSE.txt b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/wheel-0.45.1.dist-info/LICENSE.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a31470f14c5978d5fcc3bc173b8399b6c9a6443f
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/wheel-0.45.1.dist-info/LICENSE.txt
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2012 Daniel Holth and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/wheel-0.45.1.dist-info/METADATA b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/wheel-0.45.1.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..f645dcb673aaa7e3e7e054d57af5e8c0992b70e8
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/wheel-0.45.1.dist-info/METADATA
@@ -0,0 +1,66 @@
+Metadata-Version: 2.3
+Name: wheel
+Version: 0.45.1
+Summary: A built-package format for Python
+Keywords: wheel,packaging
+Author-email: Daniel Holth
+Maintainer-email: Alex Grönholm
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: System :: Archiving :: Packaging
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: pytest >= 6.0.0 ; extra == "test"
+Requires-Dist: setuptools >= 65 ; extra == "test"
+Project-URL: Changelog, https://wheel.readthedocs.io/en/stable/news.html
+Project-URL: Documentation, https://wheel.readthedocs.io/
+Project-URL: Issue Tracker, https://github.com/pypa/wheel/issues
+Project-URL: Source, https://github.com/pypa/wheel
+Provides-Extra: test
+
+wheel
+=====
+
+This is a command line tool for manipulating Python wheel files, as defined in
+`PEP 427`_. It contains the following functionality:
+
+* Convert ``.egg`` archives into ``.whl``
+* Unpack wheel archives
+* Repack wheel archives
+* Add or remove tags in existing wheel archives
+
+.. _PEP 427: https://www.python.org/dev/peps/pep-0427/
+
+Historical note
+---------------
+
+This project used to contain the implementation of the setuptools_ ``bdist_wheel``
+command, but as of setuptools v70.1, it no longer needs ``wheel`` installed for that to
+work. Thus, you should install this **only** if you intend to use the ``wheel`` command
+line tool!
+
+.. _setuptools: https://pypi.org/project/setuptools/
+
+Documentation
+-------------
+
+The documentation_ can be found on Read The Docs.
+
+.. _documentation: https://wheel.readthedocs.io/
+
+Code of Conduct
+---------------
+
+Everyone interacting in the wheel project's codebases, issue trackers, chat
+rooms, and mailing lists is expected to follow the `PSF Code of Conduct`_.
+
+.. _PSF Code of Conduct: https://github.com/pypa/.github/blob/main/CODE_OF_CONDUCT.md
+
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/wheel-0.45.1.dist-info/RECORD b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/wheel-0.45.1.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..f3becc6c6c119e0319e5e020e9a6af91049cfdf3
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/wheel-0.45.1.dist-info/RECORD
@@ -0,0 +1,68 @@
+../../../bin/wheel,sha256=Gm4dMjfhVM950bdr6rIfPRIAOjyKc0kPzqab1CtYOFk,270
+wheel-0.45.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+wheel-0.45.1.dist-info/LICENSE.txt,sha256=MMI2GGeRCPPo6h0qZYx8pBe9_IkcmO8aifpP8MmChlQ,1107
+wheel-0.45.1.dist-info/METADATA,sha256=mKz84H7m7jsxJyzeIcTVORiTb0NPMV39KvOIYhGgmjA,2313
+wheel-0.45.1.dist-info/RECORD,,
+wheel-0.45.1.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wheel-0.45.1.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
+wheel-0.45.1.dist-info/entry_points.txt,sha256=rTY1BbkPHhkGMm4Q3F0pIzJBzW2kMxoG1oriffvGdA0,104
+wheel/__init__.py,sha256=mrxMnvdXACur_LWegbUfh5g5ysWZrd63UJn890wvGNk,59
+wheel/__main__.py,sha256=NkMUnuTCGcOkgY0IBLgBCVC_BGGcWORx2K8jYGS12UE,455
+wheel/__pycache__/__init__.cpython-312.pyc,,
+wheel/__pycache__/__main__.cpython-312.pyc,,
+wheel/__pycache__/_bdist_wheel.cpython-312.pyc,,
+wheel/__pycache__/_setuptools_logging.cpython-312.pyc,,
+wheel/__pycache__/bdist_wheel.cpython-312.pyc,,
+wheel/__pycache__/macosx_libfile.cpython-312.pyc,,
+wheel/__pycache__/metadata.cpython-312.pyc,,
+wheel/__pycache__/util.cpython-312.pyc,,
+wheel/__pycache__/wheelfile.cpython-312.pyc,,
+wheel/_bdist_wheel.py,sha256=UghCQjSH_pVfcZh6oRjzSw_TQhcf3anSx1OkiLSL82M,21694
+wheel/_setuptools_logging.py,sha256=-5KC-lne0ilOUWIDfOkqapUWGMFZhuKYDIavIZiB5kM,781
+wheel/bdist_wheel.py,sha256=tpf9WufiSO1RuEMg5oPhIfSG8DMziCZ_4muCKF69Cqo,1107
+wheel/cli/__init__.py,sha256=Npq6_jKi03dhIcRnmbuFhwviVJxwO0tYEnEhWMv9cJo,4402
+wheel/cli/__pycache__/__init__.cpython-312.pyc,,
+wheel/cli/__pycache__/convert.cpython-312.pyc,,
+wheel/cli/__pycache__/pack.cpython-312.pyc,,
+wheel/cli/__pycache__/tags.cpython-312.pyc,,
+wheel/cli/__pycache__/unpack.cpython-312.pyc,,
+wheel/cli/convert.py,sha256=Bi0ntEXb9nTllCxWeTRQ4j-nPs3szWSEKipG_GgnMkQ,12634
+wheel/cli/pack.py,sha256=CAFcHdBVulvsHYJlndKVO7KMI9JqBTZz5ii0PKxxCOs,3103
+wheel/cli/tags.py,sha256=lHw-LaWrkS5Jy_qWcw-6pSjeNM6yAjDnqKI3E5JTTCU,4760
+wheel/cli/unpack.py,sha256=Y_J7ynxPSoFFTT7H0fMgbBlVErwyDGcObgme5MBuz58,1021
+wheel/macosx_libfile.py,sha256=k1x7CE3LPtOVGqj6NXQ1nTGYVPaeRrhVzUG_KPq3zDs,16572
+wheel/metadata.py,sha256=JC4p7jlQZu2bUTAQ2fevkqLjg_X6gnNyRhLn6OUO1tc,6171
+wheel/util.py,sha256=aL7aibHwYUgfc8WlolL5tXdkV4DatbJxZHb1kwHFJAU,423
+wheel/vendored/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wheel/vendored/__pycache__/__init__.cpython-312.pyc,,
+wheel/vendored/packaging/LICENSE,sha256=ytHvW9NA1z4HS6YU0m996spceUDD2MNIUuZcSQlobEg,197
+wheel/vendored/packaging/LICENSE.APACHE,sha256=DVQuDIgE45qn836wDaWnYhSdxoLXgpRRKH4RuTjpRZQ,10174
+wheel/vendored/packaging/LICENSE.BSD,sha256=tw5-m3QvHMb5SLNMFqo5_-zpQZY2S8iP8NIYDwAo-sU,1344
+wheel/vendored/packaging/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wheel/vendored/packaging/__pycache__/__init__.cpython-312.pyc,,
+wheel/vendored/packaging/__pycache__/_elffile.cpython-312.pyc,,
+wheel/vendored/packaging/__pycache__/_manylinux.cpython-312.pyc,,
+wheel/vendored/packaging/__pycache__/_musllinux.cpython-312.pyc,,
+wheel/vendored/packaging/__pycache__/_parser.cpython-312.pyc,,
+wheel/vendored/packaging/__pycache__/_structures.cpython-312.pyc,,
+wheel/vendored/packaging/__pycache__/_tokenizer.cpython-312.pyc,,
+wheel/vendored/packaging/__pycache__/markers.cpython-312.pyc,,
+wheel/vendored/packaging/__pycache__/requirements.cpython-312.pyc,,
+wheel/vendored/packaging/__pycache__/specifiers.cpython-312.pyc,,
+wheel/vendored/packaging/__pycache__/tags.cpython-312.pyc,,
+wheel/vendored/packaging/__pycache__/utils.cpython-312.pyc,,
+wheel/vendored/packaging/__pycache__/version.cpython-312.pyc,,
+wheel/vendored/packaging/_elffile.py,sha256=hbmK8OD6Z7fY6hwinHEUcD1by7czkGiNYu7ShnFEk2k,3266
+wheel/vendored/packaging/_manylinux.py,sha256=P7sdR5_7XBY09LVYYPhHmydMJIIwPXWsh4olk74Uuj4,9588
+wheel/vendored/packaging/_musllinux.py,sha256=z1s8To2hQ0vpn_d-O2i5qxGwEK8WmGlLt3d_26V7NeY,2674
+wheel/vendored/packaging/_parser.py,sha256=4tT4emSl2qTaU7VTQE1Xa9o1jMPCsBezsYBxyNMUN-s,10347
+wheel/vendored/packaging/_structures.py,sha256=q3eVNmbWJGG_S0Dit_S3Ao8qQqz_5PYTXFAKBZe5yr4,1431
+wheel/vendored/packaging/_tokenizer.py,sha256=alCtbwXhOFAmFGZ6BQ-wCTSFoRAJ2z-ysIf7__MTJ_k,5292
+wheel/vendored/packaging/markers.py,sha256=_TSPI1BhJYO7Bp9AzTmHQxIqHEVXaTjmDh9G-w8qzPA,8232
+wheel/vendored/packaging/requirements.py,sha256=dgoBeVprPu2YE6Q8nGfwOPTjATHbRa_ZGLyXhFEln6Q,2933
+wheel/vendored/packaging/specifiers.py,sha256=IWSt0SrLSP72heWhAC8UL0eGvas7XIQHjqiViVfmPKE,39778
+wheel/vendored/packaging/tags.py,sha256=fedHXiOHkBxNZTXotXv8uXPmMFU9ae-TKBujgYHigcA,18950
+wheel/vendored/packaging/utils.py,sha256=XgdmP3yx9-wQEFjO7OvMj9RjEf5JlR5HFFR69v7SQ9E,5268
+wheel/vendored/packaging/version.py,sha256=PFJaYZDxBgyxkfYhH3SQw4qfE9ICCWrTmitvq14y3bs,16234
+wheel/vendored/vendor.txt,sha256=Z2ENjB1i5prfez8CdM1Sdr3c6Zxv2rRRolMpLmBncAE,16
+wheel/wheelfile.py,sha256=USCttNlJwafxt51YYFFKG7jnxz8dfhbyqAZL6jMTA9s,8411
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/wheel-0.45.1.dist-info/REQUESTED b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/wheel-0.45.1.dist-info/REQUESTED
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/wheel-0.45.1.dist-info/WHEEL b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/wheel-0.45.1.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..e3c6feefa22927866e3fd5575379ea972b432aaf
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/wheel-0.45.1.dist-info/WHEEL
@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.10.1
+Root-Is-Purelib: true
+Tag: py3-none-any
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/wheel-0.45.1.dist-info/entry_points.txt b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/wheel-0.45.1.dist-info/entry_points.txt
new file mode 100644
index 0000000000000000000000000000000000000000..06c9f69debd05e53c3b6053a905805e616c61fad
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/wheel-0.45.1.dist-info/entry_points.txt
@@ -0,0 +1,6 @@
+[console_scripts]
+wheel=wheel.cli:main
+
+[distutils.commands]
+bdist_wheel=wheel.bdist_wheel:bdist_wheel
+
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/__init__.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..2ec4f203c7e12941ff807c9def9e35b9ae1ab2bd
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/__init__.py
@@ -0,0 +1,390 @@
+
+from .error import *
+
+from .tokens import *
+from .events import *
+from .nodes import *
+
+from .loader import *
+from .dumper import *
+
+__version__ = '6.0.2'
+try:
+ from .cyaml import *
+ __with_libyaml__ = True
+except ImportError:
+ __with_libyaml__ = False
+
+import io
+
+#------------------------------------------------------------------------------
+# XXX "Warnings control" is now deprecated. Leaving in the API function to not
+# break code that uses it.
+#------------------------------------------------------------------------------
+def warnings(settings=None):
+ if settings is None:
+ return {}
+
+#------------------------------------------------------------------------------
+def scan(stream, Loader=Loader):
+ """
+ Scan a YAML stream and produce scanning tokens.
+ """
+ loader = Loader(stream)
+ try:
+ while loader.check_token():
+ yield loader.get_token()
+ finally:
+ loader.dispose()
+
+def parse(stream, Loader=Loader):
+ """
+ Parse a YAML stream and produce parsing events.
+ """
+ loader = Loader(stream)
+ try:
+ while loader.check_event():
+ yield loader.get_event()
+ finally:
+ loader.dispose()
+
+def compose(stream, Loader=Loader):
+ """
+ Parse the first YAML document in a stream
+ and produce the corresponding representation tree.
+ """
+ loader = Loader(stream)
+ try:
+ return loader.get_single_node()
+ finally:
+ loader.dispose()
+
+def compose_all(stream, Loader=Loader):
+ """
+ Parse all YAML documents in a stream
+ and produce corresponding representation trees.
+ """
+ loader = Loader(stream)
+ try:
+ while loader.check_node():
+ yield loader.get_node()
+ finally:
+ loader.dispose()
+
+def load(stream, Loader):
+ """
+ Parse the first YAML document in a stream
+ and produce the corresponding Python object.
+ """
+ loader = Loader(stream)
+ try:
+ return loader.get_single_data()
+ finally:
+ loader.dispose()
+
+def load_all(stream, Loader):
+ """
+ Parse all YAML documents in a stream
+ and produce corresponding Python objects.
+ """
+ loader = Loader(stream)
+ try:
+ while loader.check_data():
+ yield loader.get_data()
+ finally:
+ loader.dispose()
+
+def full_load(stream):
+ """
+ Parse the first YAML document in a stream
+ and produce the corresponding Python object.
+
+ Resolve all tags except those known to be
+ unsafe on untrusted input.
+ """
+ return load(stream, FullLoader)
+
+def full_load_all(stream):
+ """
+ Parse all YAML documents in a stream
+ and produce corresponding Python objects.
+
+ Resolve all tags except those known to be
+ unsafe on untrusted input.
+ """
+ return load_all(stream, FullLoader)
+
+def safe_load(stream):
+ """
+ Parse the first YAML document in a stream
+ and produce the corresponding Python object.
+
+ Resolve only basic YAML tags. This is known
+ to be safe for untrusted input.
+ """
+ return load(stream, SafeLoader)
+
+def safe_load_all(stream):
+ """
+ Parse all YAML documents in a stream
+ and produce corresponding Python objects.
+
+ Resolve only basic YAML tags. This is known
+ to be safe for untrusted input.
+ """
+ return load_all(stream, SafeLoader)
+
+def unsafe_load(stream):
+ """
+ Parse the first YAML document in a stream
+ and produce the corresponding Python object.
+
+ Resolve all tags, even those known to be
+ unsafe on untrusted input.
+ """
+ return load(stream, UnsafeLoader)
+
+def unsafe_load_all(stream):
+ """
+ Parse all YAML documents in a stream
+ and produce corresponding Python objects.
+
+ Resolve all tags, even those known to be
+ unsafe on untrusted input.
+ """
+ return load_all(stream, UnsafeLoader)
+
+def emit(events, stream=None, Dumper=Dumper,
+ canonical=None, indent=None, width=None,
+ allow_unicode=None, line_break=None):
+ """
+ Emit YAML parsing events into a stream.
+ If stream is None, return the produced string instead.
+ """
+ getvalue = None
+ if stream is None:
+ stream = io.StringIO()
+ getvalue = stream.getvalue
+ dumper = Dumper(stream, canonical=canonical, indent=indent, width=width,
+ allow_unicode=allow_unicode, line_break=line_break)
+ try:
+ for event in events:
+ dumper.emit(event)
+ finally:
+ dumper.dispose()
+ if getvalue:
+ return getvalue()
+
+def serialize_all(nodes, stream=None, Dumper=Dumper,
+ canonical=None, indent=None, width=None,
+ allow_unicode=None, line_break=None,
+ encoding=None, explicit_start=None, explicit_end=None,
+ version=None, tags=None):
+ """
+ Serialize a sequence of representation trees into a YAML stream.
+ If stream is None, return the produced string instead.
+ """
+ getvalue = None
+ if stream is None:
+ if encoding is None:
+ stream = io.StringIO()
+ else:
+ stream = io.BytesIO()
+ getvalue = stream.getvalue
+ dumper = Dumper(stream, canonical=canonical, indent=indent, width=width,
+ allow_unicode=allow_unicode, line_break=line_break,
+ encoding=encoding, version=version, tags=tags,
+ explicit_start=explicit_start, explicit_end=explicit_end)
+ try:
+ dumper.open()
+ for node in nodes:
+ dumper.serialize(node)
+ dumper.close()
+ finally:
+ dumper.dispose()
+ if getvalue:
+ return getvalue()
+
+def serialize(node, stream=None, Dumper=Dumper, **kwds):
+ """
+ Serialize a representation tree into a YAML stream.
+ If stream is None, return the produced string instead.
+ """
+ return serialize_all([node], stream, Dumper=Dumper, **kwds)
+
+def dump_all(documents, stream=None, Dumper=Dumper,
+ default_style=None, default_flow_style=False,
+ canonical=None, indent=None, width=None,
+ allow_unicode=None, line_break=None,
+ encoding=None, explicit_start=None, explicit_end=None,
+ version=None, tags=None, sort_keys=True):
+ """
+ Serialize a sequence of Python objects into a YAML stream.
+ If stream is None, return the produced string instead.
+ """
+ getvalue = None
+ if stream is None:
+ if encoding is None:
+ stream = io.StringIO()
+ else:
+ stream = io.BytesIO()
+ getvalue = stream.getvalue
+ dumper = Dumper(stream, default_style=default_style,
+ default_flow_style=default_flow_style,
+ canonical=canonical, indent=indent, width=width,
+ allow_unicode=allow_unicode, line_break=line_break,
+ encoding=encoding, version=version, tags=tags,
+ explicit_start=explicit_start, explicit_end=explicit_end, sort_keys=sort_keys)
+ try:
+ dumper.open()
+ for data in documents:
+ dumper.represent(data)
+ dumper.close()
+ finally:
+ dumper.dispose()
+ if getvalue:
+ return getvalue()
+
+def dump(data, stream=None, Dumper=Dumper, **kwds):
+ """
+ Serialize a Python object into a YAML stream.
+ If stream is None, return the produced string instead.
+ """
+ return dump_all([data], stream, Dumper=Dumper, **kwds)
+
+def safe_dump_all(documents, stream=None, **kwds):
+ """
+ Serialize a sequence of Python objects into a YAML stream.
+ Produce only basic YAML tags.
+ If stream is None, return the produced string instead.
+ """
+ return dump_all(documents, stream, Dumper=SafeDumper, **kwds)
+
+def safe_dump(data, stream=None, **kwds):
+ """
+ Serialize a Python object into a YAML stream.
+ Produce only basic YAML tags.
+ If stream is None, return the produced string instead.
+ """
+ return dump_all([data], stream, Dumper=SafeDumper, **kwds)
+
+def add_implicit_resolver(tag, regexp, first=None,
+ Loader=None, Dumper=Dumper):
+ """
+ Add an implicit scalar detector.
+ If an implicit scalar value matches the given regexp,
+ the corresponding tag is assigned to the scalar.
+ first is a sequence of possible initial characters or None.
+ """
+ if Loader is None:
+ loader.Loader.add_implicit_resolver(tag, regexp, first)
+ loader.FullLoader.add_implicit_resolver(tag, regexp, first)
+ loader.UnsafeLoader.add_implicit_resolver(tag, regexp, first)
+ else:
+ Loader.add_implicit_resolver(tag, regexp, first)
+ Dumper.add_implicit_resolver(tag, regexp, first)
+
+def add_path_resolver(tag, path, kind=None, Loader=None, Dumper=Dumper):
+ """
+ Add a path based resolver for the given tag.
+ A path is a list of keys that forms a path
+ to a node in the representation tree.
+ Keys can be string values, integers, or None.
+ """
+ if Loader is None:
+ loader.Loader.add_path_resolver(tag, path, kind)
+ loader.FullLoader.add_path_resolver(tag, path, kind)
+ loader.UnsafeLoader.add_path_resolver(tag, path, kind)
+ else:
+ Loader.add_path_resolver(tag, path, kind)
+ Dumper.add_path_resolver(tag, path, kind)
+
+def add_constructor(tag, constructor, Loader=None):
+ """
+ Add a constructor for the given tag.
+ Constructor is a function that accepts a Loader instance
+ and a node object and produces the corresponding Python object.
+ """
+ if Loader is None:
+ loader.Loader.add_constructor(tag, constructor)
+ loader.FullLoader.add_constructor(tag, constructor)
+ loader.UnsafeLoader.add_constructor(tag, constructor)
+ else:
+ Loader.add_constructor(tag, constructor)
+
+def add_multi_constructor(tag_prefix, multi_constructor, Loader=None):
+ """
+ Add a multi-constructor for the given tag prefix.
+ Multi-constructor is called for a node if its tag starts with tag_prefix.
+ Multi-constructor accepts a Loader instance, a tag suffix,
+ and a node object and produces the corresponding Python object.
+ """
+ if Loader is None:
+ loader.Loader.add_multi_constructor(tag_prefix, multi_constructor)
+ loader.FullLoader.add_multi_constructor(tag_prefix, multi_constructor)
+ loader.UnsafeLoader.add_multi_constructor(tag_prefix, multi_constructor)
+ else:
+ Loader.add_multi_constructor(tag_prefix, multi_constructor)
+
+def add_representer(data_type, representer, Dumper=Dumper):
+ """
+ Add a representer for the given type.
+ Representer is a function accepting a Dumper instance
+ and an instance of the given data type
+ and producing the corresponding representation node.
+ """
+ Dumper.add_representer(data_type, representer)
+
+def add_multi_representer(data_type, multi_representer, Dumper=Dumper):
+ """
+ Add a representer for the given type.
+ Multi-representer is a function accepting a Dumper instance
+ and an instance of the given data type or subtype
+ and producing the corresponding representation node.
+ """
+ Dumper.add_multi_representer(data_type, multi_representer)
+
+class YAMLObjectMetaclass(type):
+ """
+ The metaclass for YAMLObject.
+ """
+ def __init__(cls, name, bases, kwds):
+ super(YAMLObjectMetaclass, cls).__init__(name, bases, kwds)
+ if 'yaml_tag' in kwds and kwds['yaml_tag'] is not None:
+ if isinstance(cls.yaml_loader, list):
+ for loader in cls.yaml_loader:
+ loader.add_constructor(cls.yaml_tag, cls.from_yaml)
+ else:
+ cls.yaml_loader.add_constructor(cls.yaml_tag, cls.from_yaml)
+
+ cls.yaml_dumper.add_representer(cls, cls.to_yaml)
+
+class YAMLObject(metaclass=YAMLObjectMetaclass):
+ """
+ An object that can dump itself to a YAML stream
+ and load itself from a YAML stream.
+ """
+
+ __slots__ = () # no direct instantiation, so allow immutable subclasses
+
+ yaml_loader = [Loader, FullLoader, UnsafeLoader]
+ yaml_dumper = Dumper
+
+ yaml_tag = None
+ yaml_flow_style = None
+
+ @classmethod
+ def from_yaml(cls, loader, node):
+ """
+ Convert a representation node to a Python object.
+ """
+ return loader.construct_yaml_object(node, cls)
+
+ @classmethod
+ def to_yaml(cls, dumper, data):
+ """
+ Convert a Python object to a representation node.
+ """
+ return dumper.represent_yaml_object(cls.yaml_tag, data, cls,
+ flow_style=cls.yaml_flow_style)
+
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/composer.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/composer.py
new file mode 100644
index 0000000000000000000000000000000000000000..6d15cb40e3b4198819c91c6f8d8b32807fcf53b2
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/composer.py
@@ -0,0 +1,139 @@
+
+__all__ = ['Composer', 'ComposerError']
+
+from .error import MarkedYAMLError
+from .events import *
+from .nodes import *
+
+class ComposerError(MarkedYAMLError):
+ pass
+
+class Composer:
+
+ def __init__(self):
+ self.anchors = {}
+
+ def check_node(self):
+ # Drop the STREAM-START event.
+ if self.check_event(StreamStartEvent):
+ self.get_event()
+
+ # If there are more documents available?
+ return not self.check_event(StreamEndEvent)
+
+ def get_node(self):
+ # Get the root node of the next document.
+ if not self.check_event(StreamEndEvent):
+ return self.compose_document()
+
+ def get_single_node(self):
+ # Drop the STREAM-START event.
+ self.get_event()
+
+ # Compose a document if the stream is not empty.
+ document = None
+ if not self.check_event(StreamEndEvent):
+ document = self.compose_document()
+
+ # Ensure that the stream contains no more documents.
+ if not self.check_event(StreamEndEvent):
+ event = self.get_event()
+ raise ComposerError("expected a single document in the stream",
+ document.start_mark, "but found another document",
+ event.start_mark)
+
+ # Drop the STREAM-END event.
+ self.get_event()
+
+ return document
+
+ def compose_document(self):
+ # Drop the DOCUMENT-START event.
+ self.get_event()
+
+ # Compose the root node.
+ node = self.compose_node(None, None)
+
+ # Drop the DOCUMENT-END event.
+ self.get_event()
+
+ self.anchors = {}
+ return node
+
+ def compose_node(self, parent, index):
+ if self.check_event(AliasEvent):
+ event = self.get_event()
+ anchor = event.anchor
+ if anchor not in self.anchors:
+ raise ComposerError(None, None, "found undefined alias %r"
+ % anchor, event.start_mark)
+ return self.anchors[anchor]
+ event = self.peek_event()
+ anchor = event.anchor
+ if anchor is not None:
+ if anchor in self.anchors:
+ raise ComposerError("found duplicate anchor %r; first occurrence"
+ % anchor, self.anchors[anchor].start_mark,
+ "second occurrence", event.start_mark)
+ self.descend_resolver(parent, index)
+ if self.check_event(ScalarEvent):
+ node = self.compose_scalar_node(anchor)
+ elif self.check_event(SequenceStartEvent):
+ node = self.compose_sequence_node(anchor)
+ elif self.check_event(MappingStartEvent):
+ node = self.compose_mapping_node(anchor)
+ self.ascend_resolver()
+ return node
+
+ def compose_scalar_node(self, anchor):
+ event = self.get_event()
+ tag = event.tag
+ if tag is None or tag == '!':
+ tag = self.resolve(ScalarNode, event.value, event.implicit)
+ node = ScalarNode(tag, event.value,
+ event.start_mark, event.end_mark, style=event.style)
+ if anchor is not None:
+ self.anchors[anchor] = node
+ return node
+
+ def compose_sequence_node(self, anchor):
+ start_event = self.get_event()
+ tag = start_event.tag
+ if tag is None or tag == '!':
+ tag = self.resolve(SequenceNode, None, start_event.implicit)
+ node = SequenceNode(tag, [],
+ start_event.start_mark, None,
+ flow_style=start_event.flow_style)
+ if anchor is not None:
+ self.anchors[anchor] = node
+ index = 0
+ while not self.check_event(SequenceEndEvent):
+ node.value.append(self.compose_node(node, index))
+ index += 1
+ end_event = self.get_event()
+ node.end_mark = end_event.end_mark
+ return node
+
+ def compose_mapping_node(self, anchor):
+ start_event = self.get_event()
+ tag = start_event.tag
+ if tag is None or tag == '!':
+ tag = self.resolve(MappingNode, None, start_event.implicit)
+ node = MappingNode(tag, [],
+ start_event.start_mark, None,
+ flow_style=start_event.flow_style)
+ if anchor is not None:
+ self.anchors[anchor] = node
+ while not self.check_event(MappingEndEvent):
+ #key_event = self.peek_event()
+ item_key = self.compose_node(node, None)
+ #if item_key in node.value:
+ # raise ComposerError("while composing a mapping", start_event.start_mark,
+ # "found duplicate key", key_event.start_mark)
+ item_value = self.compose_node(node, item_key)
+ #node.value[item_key] = item_value
+ node.value.append((item_key, item_value))
+ end_event = self.get_event()
+ node.end_mark = end_event.end_mark
+ return node
+
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/constructor.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/constructor.py
new file mode 100644
index 0000000000000000000000000000000000000000..619acd3070a4845c653fcf22a626e05158035bc2
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/constructor.py
@@ -0,0 +1,748 @@
+
+__all__ = [
+ 'BaseConstructor',
+ 'SafeConstructor',
+ 'FullConstructor',
+ 'UnsafeConstructor',
+ 'Constructor',
+ 'ConstructorError'
+]
+
+from .error import *
+from .nodes import *
+
+import collections.abc, datetime, base64, binascii, re, sys, types
+
+class ConstructorError(MarkedYAMLError):
+ pass
+
+class BaseConstructor:
+
+ yaml_constructors = {}
+ yaml_multi_constructors = {}
+
+ def __init__(self):
+ self.constructed_objects = {}
+ self.recursive_objects = {}
+ self.state_generators = []
+ self.deep_construct = False
+
+ def check_data(self):
+ # If there are more documents available?
+ return self.check_node()
+
+ def check_state_key(self, key):
+ """Block special attributes/methods from being set in a newly created
+ object, to prevent user-controlled methods from being called during
+ deserialization"""
+ if self.get_state_keys_blacklist_regexp().match(key):
+ raise ConstructorError(None, None,
+ "blacklisted key '%s' in instance state found" % (key,), None)
+
+ def get_data(self):
+ # Construct and return the next document.
+ if self.check_node():
+ return self.construct_document(self.get_node())
+
+ def get_single_data(self):
+ # Ensure that the stream contains a single document and construct it.
+ node = self.get_single_node()
+ if node is not None:
+ return self.construct_document(node)
+ return None
+
+ def construct_document(self, node):
+ data = self.construct_object(node)
+ while self.state_generators:
+ state_generators = self.state_generators
+ self.state_generators = []
+ for generator in state_generators:
+ for dummy in generator:
+ pass
+ self.constructed_objects = {}
+ self.recursive_objects = {}
+ self.deep_construct = False
+ return data
+
+ def construct_object(self, node, deep=False):
+ if node in self.constructed_objects:
+ return self.constructed_objects[node]
+ if deep:
+ old_deep = self.deep_construct
+ self.deep_construct = True
+ if node in self.recursive_objects:
+ raise ConstructorError(None, None,
+ "found unconstructable recursive node", node.start_mark)
+ self.recursive_objects[node] = None
+ constructor = None
+ tag_suffix = None
+ if node.tag in self.yaml_constructors:
+ constructor = self.yaml_constructors[node.tag]
+ else:
+ for tag_prefix in self.yaml_multi_constructors:
+ if tag_prefix is not None and node.tag.startswith(tag_prefix):
+ tag_suffix = node.tag[len(tag_prefix):]
+ constructor = self.yaml_multi_constructors[tag_prefix]
+ break
+ else:
+ if None in self.yaml_multi_constructors:
+ tag_suffix = node.tag
+ constructor = self.yaml_multi_constructors[None]
+ elif None in self.yaml_constructors:
+ constructor = self.yaml_constructors[None]
+ elif isinstance(node, ScalarNode):
+ constructor = self.__class__.construct_scalar
+ elif isinstance(node, SequenceNode):
+ constructor = self.__class__.construct_sequence
+ elif isinstance(node, MappingNode):
+ constructor = self.__class__.construct_mapping
+ if tag_suffix is None:
+ data = constructor(self, node)
+ else:
+ data = constructor(self, tag_suffix, node)
+ if isinstance(data, types.GeneratorType):
+ generator = data
+ data = next(generator)
+ if self.deep_construct:
+ for dummy in generator:
+ pass
+ else:
+ self.state_generators.append(generator)
+ self.constructed_objects[node] = data
+ del self.recursive_objects[node]
+ if deep:
+ self.deep_construct = old_deep
+ return data
+
+ def construct_scalar(self, node):
+ if not isinstance(node, ScalarNode):
+ raise ConstructorError(None, None,
+ "expected a scalar node, but found %s" % node.id,
+ node.start_mark)
+ return node.value
+
+ def construct_sequence(self, node, deep=False):
+ if not isinstance(node, SequenceNode):
+ raise ConstructorError(None, None,
+ "expected a sequence node, but found %s" % node.id,
+ node.start_mark)
+ return [self.construct_object(child, deep=deep)
+ for child in node.value]
+
+ def construct_mapping(self, node, deep=False):
+ if not isinstance(node, MappingNode):
+ raise ConstructorError(None, None,
+ "expected a mapping node, but found %s" % node.id,
+ node.start_mark)
+ mapping = {}
+ for key_node, value_node in node.value:
+ key = self.construct_object(key_node, deep=deep)
+ if not isinstance(key, collections.abc.Hashable):
+ raise ConstructorError("while constructing a mapping", node.start_mark,
+ "found unhashable key", key_node.start_mark)
+ value = self.construct_object(value_node, deep=deep)
+ mapping[key] = value
+ return mapping
+
+ def construct_pairs(self, node, deep=False):
+ if not isinstance(node, MappingNode):
+ raise ConstructorError(None, None,
+ "expected a mapping node, but found %s" % node.id,
+ node.start_mark)
+ pairs = []
+ for key_node, value_node in node.value:
+ key = self.construct_object(key_node, deep=deep)
+ value = self.construct_object(value_node, deep=deep)
+ pairs.append((key, value))
+ return pairs
+
+ @classmethod
+ def add_constructor(cls, tag, constructor):
+ if not 'yaml_constructors' in cls.__dict__:
+ cls.yaml_constructors = cls.yaml_constructors.copy()
+ cls.yaml_constructors[tag] = constructor
+
+ @classmethod
+ def add_multi_constructor(cls, tag_prefix, multi_constructor):
+ if not 'yaml_multi_constructors' in cls.__dict__:
+ cls.yaml_multi_constructors = cls.yaml_multi_constructors.copy()
+ cls.yaml_multi_constructors[tag_prefix] = multi_constructor
+
+class SafeConstructor(BaseConstructor):
+
+ def construct_scalar(self, node):
+ if isinstance(node, MappingNode):
+ for key_node, value_node in node.value:
+ if key_node.tag == 'tag:yaml.org,2002:value':
+ return self.construct_scalar(value_node)
+ return super().construct_scalar(node)
+
+ def flatten_mapping(self, node):
+ merge = []
+ index = 0
+ while index < len(node.value):
+ key_node, value_node = node.value[index]
+ if key_node.tag == 'tag:yaml.org,2002:merge':
+ del node.value[index]
+ if isinstance(value_node, MappingNode):
+ self.flatten_mapping(value_node)
+ merge.extend(value_node.value)
+ elif isinstance(value_node, SequenceNode):
+ submerge = []
+ for subnode in value_node.value:
+ if not isinstance(subnode, MappingNode):
+ raise ConstructorError("while constructing a mapping",
+ node.start_mark,
+ "expected a mapping for merging, but found %s"
+ % subnode.id, subnode.start_mark)
+ self.flatten_mapping(subnode)
+ submerge.append(subnode.value)
+ submerge.reverse()
+ for value in submerge:
+ merge.extend(value)
+ else:
+ raise ConstructorError("while constructing a mapping", node.start_mark,
+ "expected a mapping or list of mappings for merging, but found %s"
+ % value_node.id, value_node.start_mark)
+ elif key_node.tag == 'tag:yaml.org,2002:value':
+ key_node.tag = 'tag:yaml.org,2002:str'
+ index += 1
+ else:
+ index += 1
+ if merge:
+ node.value = merge + node.value
+
+ def construct_mapping(self, node, deep=False):
+ if isinstance(node, MappingNode):
+ self.flatten_mapping(node)
+ return super().construct_mapping(node, deep=deep)
+
+ def construct_yaml_null(self, node):
+ self.construct_scalar(node)
+ return None
+
+ bool_values = {
+ 'yes': True,
+ 'no': False,
+ 'true': True,
+ 'false': False,
+ 'on': True,
+ 'off': False,
+ }
+
+ def construct_yaml_bool(self, node):
+ value = self.construct_scalar(node)
+ return self.bool_values[value.lower()]
+
+ def construct_yaml_int(self, node):
+ value = self.construct_scalar(node)
+ value = value.replace('_', '')
+ sign = +1
+ if value[0] == '-':
+ sign = -1
+ if value[0] in '+-':
+ value = value[1:]
+ if value == '0':
+ return 0
+ elif value.startswith('0b'):
+ return sign*int(value[2:], 2)
+ elif value.startswith('0x'):
+ return sign*int(value[2:], 16)
+ elif value[0] == '0':
+ return sign*int(value, 8)
+ elif ':' in value:
+ digits = [int(part) for part in value.split(':')]
+ digits.reverse()
+ base = 1
+ value = 0
+ for digit in digits:
+ value += digit*base
+ base *= 60
+ return sign*value
+ else:
+ return sign*int(value)
+
+ inf_value = 1e300
+ while inf_value != inf_value*inf_value:
+ inf_value *= inf_value
+ nan_value = -inf_value/inf_value # Trying to make a quiet NaN (like C99).
+
+ def construct_yaml_float(self, node):
+ value = self.construct_scalar(node)
+ value = value.replace('_', '').lower()
+ sign = +1
+ if value[0] == '-':
+ sign = -1
+ if value[0] in '+-':
+ value = value[1:]
+ if value == '.inf':
+ return sign*self.inf_value
+ elif value == '.nan':
+ return self.nan_value
+ elif ':' in value:
+ digits = [float(part) for part in value.split(':')]
+ digits.reverse()
+ base = 1
+ value = 0.0
+ for digit in digits:
+ value += digit*base
+ base *= 60
+ return sign*value
+ else:
+ return sign*float(value)
+
+ def construct_yaml_binary(self, node):
+ try:
+ value = self.construct_scalar(node).encode('ascii')
+ except UnicodeEncodeError as exc:
+ raise ConstructorError(None, None,
+ "failed to convert base64 data into ascii: %s" % exc,
+ node.start_mark)
+ try:
+ if hasattr(base64, 'decodebytes'):
+ return base64.decodebytes(value)
+ else:
+ return base64.decodestring(value)
+ except binascii.Error as exc:
+ raise ConstructorError(None, None,
+ "failed to decode base64 data: %s" % exc, node.start_mark)
+
+ timestamp_regexp = re.compile(
+ r'''^(?P[0-9][0-9][0-9][0-9])
+ -(?P[0-9][0-9]?)
+ -(?P[0-9][0-9]?)
+ (?:(?:[Tt]|[ \t]+)
+ (?P[0-9][0-9]?)
+ :(?P[0-9][0-9])
+ :(?P[0-9][0-9])
+ (?:\.(?P[0-9]*))?
+ (?:[ \t]*(?PZ|(?P[-+])(?P[0-9][0-9]?)
+ (?::(?P[0-9][0-9]))?))?)?$''', re.X)
+
+ def construct_yaml_timestamp(self, node):
+ value = self.construct_scalar(node)
+ match = self.timestamp_regexp.match(node.value)
+ values = match.groupdict()
+ year = int(values['year'])
+ month = int(values['month'])
+ day = int(values['day'])
+ if not values['hour']:
+ return datetime.date(year, month, day)
+ hour = int(values['hour'])
+ minute = int(values['minute'])
+ second = int(values['second'])
+ fraction = 0
+ tzinfo = None
+ if values['fraction']:
+ fraction = values['fraction'][:6]
+ while len(fraction) < 6:
+ fraction += '0'
+ fraction = int(fraction)
+ if values['tz_sign']:
+ tz_hour = int(values['tz_hour'])
+ tz_minute = int(values['tz_minute'] or 0)
+ delta = datetime.timedelta(hours=tz_hour, minutes=tz_minute)
+ if values['tz_sign'] == '-':
+ delta = -delta
+ tzinfo = datetime.timezone(delta)
+ elif values['tz']:
+ tzinfo = datetime.timezone.utc
+ return datetime.datetime(year, month, day, hour, minute, second, fraction,
+ tzinfo=tzinfo)
+
+ def construct_yaml_omap(self, node):
+ # Note: we do not check for duplicate keys, because it's too
+ # CPU-expensive.
+ omap = []
+ yield omap
+ if not isinstance(node, SequenceNode):
+ raise ConstructorError("while constructing an ordered map", node.start_mark,
+ "expected a sequence, but found %s" % node.id, node.start_mark)
+ for subnode in node.value:
+ if not isinstance(subnode, MappingNode):
+ raise ConstructorError("while constructing an ordered map", node.start_mark,
+ "expected a mapping of length 1, but found %s" % subnode.id,
+ subnode.start_mark)
+ if len(subnode.value) != 1:
+ raise ConstructorError("while constructing an ordered map", node.start_mark,
+ "expected a single mapping item, but found %d items" % len(subnode.value),
+ subnode.start_mark)
+ key_node, value_node = subnode.value[0]
+ key = self.construct_object(key_node)
+ value = self.construct_object(value_node)
+ omap.append((key, value))
+
+ def construct_yaml_pairs(self, node):
+ # Note: the same code as `construct_yaml_omap`.
+ pairs = []
+ yield pairs
+ if not isinstance(node, SequenceNode):
+ raise ConstructorError("while constructing pairs", node.start_mark,
+ "expected a sequence, but found %s" % node.id, node.start_mark)
+ for subnode in node.value:
+ if not isinstance(subnode, MappingNode):
+ raise ConstructorError("while constructing pairs", node.start_mark,
+ "expected a mapping of length 1, but found %s" % subnode.id,
+ subnode.start_mark)
+ if len(subnode.value) != 1:
+ raise ConstructorError("while constructing pairs", node.start_mark,
+ "expected a single mapping item, but found %d items" % len(subnode.value),
+ subnode.start_mark)
+ key_node, value_node = subnode.value[0]
+ key = self.construct_object(key_node)
+ value = self.construct_object(value_node)
+ pairs.append((key, value))
+
+ def construct_yaml_set(self, node):
+ data = set()
+ yield data
+ value = self.construct_mapping(node)
+ data.update(value)
+
+ def construct_yaml_str(self, node):
+ return self.construct_scalar(node)
+
+ def construct_yaml_seq(self, node):
+ data = []
+ yield data
+ data.extend(self.construct_sequence(node))
+
+ def construct_yaml_map(self, node):
+ data = {}
+ yield data
+ value = self.construct_mapping(node)
+ data.update(value)
+
+ def construct_yaml_object(self, node, cls):
+ data = cls.__new__(cls)
+ yield data
+ if hasattr(data, '__setstate__'):
+ state = self.construct_mapping(node, deep=True)
+ data.__setstate__(state)
+ else:
+ state = self.construct_mapping(node)
+ data.__dict__.update(state)
+
+ def construct_undefined(self, node):
+ raise ConstructorError(None, None,
+ "could not determine a constructor for the tag %r" % node.tag,
+ node.start_mark)
+
+SafeConstructor.add_constructor(
+ 'tag:yaml.org,2002:null',
+ SafeConstructor.construct_yaml_null)
+
+SafeConstructor.add_constructor(
+ 'tag:yaml.org,2002:bool',
+ SafeConstructor.construct_yaml_bool)
+
+SafeConstructor.add_constructor(
+ 'tag:yaml.org,2002:int',
+ SafeConstructor.construct_yaml_int)
+
+SafeConstructor.add_constructor(
+ 'tag:yaml.org,2002:float',
+ SafeConstructor.construct_yaml_float)
+
+SafeConstructor.add_constructor(
+ 'tag:yaml.org,2002:binary',
+ SafeConstructor.construct_yaml_binary)
+
+SafeConstructor.add_constructor(
+ 'tag:yaml.org,2002:timestamp',
+ SafeConstructor.construct_yaml_timestamp)
+
+SafeConstructor.add_constructor(
+ 'tag:yaml.org,2002:omap',
+ SafeConstructor.construct_yaml_omap)
+
+SafeConstructor.add_constructor(
+ 'tag:yaml.org,2002:pairs',
+ SafeConstructor.construct_yaml_pairs)
+
+SafeConstructor.add_constructor(
+ 'tag:yaml.org,2002:set',
+ SafeConstructor.construct_yaml_set)
+
+SafeConstructor.add_constructor(
+ 'tag:yaml.org,2002:str',
+ SafeConstructor.construct_yaml_str)
+
+SafeConstructor.add_constructor(
+ 'tag:yaml.org,2002:seq',
+ SafeConstructor.construct_yaml_seq)
+
+SafeConstructor.add_constructor(
+ 'tag:yaml.org,2002:map',
+ SafeConstructor.construct_yaml_map)
+
+SafeConstructor.add_constructor(None,
+ SafeConstructor.construct_undefined)
+
+class FullConstructor(SafeConstructor):
+ # 'extend' is blacklisted because it is used by
+ # construct_python_object_apply to add `listitems` to a newly generate
+ # python instance
+ def get_state_keys_blacklist(self):
+ return ['^extend$', '^__.*__$']
+
+ def get_state_keys_blacklist_regexp(self):
+ if not hasattr(self, 'state_keys_blacklist_regexp'):
+ self.state_keys_blacklist_regexp = re.compile('(' + '|'.join(self.get_state_keys_blacklist()) + ')')
+ return self.state_keys_blacklist_regexp
+
+ def construct_python_str(self, node):
+ return self.construct_scalar(node)
+
+ def construct_python_unicode(self, node):
+ return self.construct_scalar(node)
+
+ def construct_python_bytes(self, node):
+ try:
+ value = self.construct_scalar(node).encode('ascii')
+ except UnicodeEncodeError as exc:
+ raise ConstructorError(None, None,
+ "failed to convert base64 data into ascii: %s" % exc,
+ node.start_mark)
+ try:
+ if hasattr(base64, 'decodebytes'):
+ return base64.decodebytes(value)
+ else:
+ return base64.decodestring(value)
+ except binascii.Error as exc:
+ raise ConstructorError(None, None,
+ "failed to decode base64 data: %s" % exc, node.start_mark)
+
+ def construct_python_long(self, node):
+ return self.construct_yaml_int(node)
+
+ def construct_python_complex(self, node):
+ return complex(self.construct_scalar(node))
+
+ def construct_python_tuple(self, node):
+ return tuple(self.construct_sequence(node))
+
+ def find_python_module(self, name, mark, unsafe=False):
+ if not name:
+ raise ConstructorError("while constructing a Python module", mark,
+ "expected non-empty name appended to the tag", mark)
+ if unsafe:
+ try:
+ __import__(name)
+ except ImportError as exc:
+ raise ConstructorError("while constructing a Python module", mark,
+ "cannot find module %r (%s)" % (name, exc), mark)
+ if name not in sys.modules:
+ raise ConstructorError("while constructing a Python module", mark,
+ "module %r is not imported" % name, mark)
+ return sys.modules[name]
+
+ def find_python_name(self, name, mark, unsafe=False):
+ if not name:
+ raise ConstructorError("while constructing a Python object", mark,
+ "expected non-empty name appended to the tag", mark)
+ if '.' in name:
+ module_name, object_name = name.rsplit('.', 1)
+ else:
+ module_name = 'builtins'
+ object_name = name
+ if unsafe:
+ try:
+ __import__(module_name)
+ except ImportError as exc:
+ raise ConstructorError("while constructing a Python object", mark,
+ "cannot find module %r (%s)" % (module_name, exc), mark)
+ if module_name not in sys.modules:
+ raise ConstructorError("while constructing a Python object", mark,
+ "module %r is not imported" % module_name, mark)
+ module = sys.modules[module_name]
+ if not hasattr(module, object_name):
+ raise ConstructorError("while constructing a Python object", mark,
+ "cannot find %r in the module %r"
+ % (object_name, module.__name__), mark)
+ return getattr(module, object_name)
+
+ def construct_python_name(self, suffix, node):
+ value = self.construct_scalar(node)
+ if value:
+ raise ConstructorError("while constructing a Python name", node.start_mark,
+ "expected the empty value, but found %r" % value, node.start_mark)
+ return self.find_python_name(suffix, node.start_mark)
+
+ def construct_python_module(self, suffix, node):
+ value = self.construct_scalar(node)
+ if value:
+ raise ConstructorError("while constructing a Python module", node.start_mark,
+ "expected the empty value, but found %r" % value, node.start_mark)
+ return self.find_python_module(suffix, node.start_mark)
+
+ def make_python_instance(self, suffix, node,
+ args=None, kwds=None, newobj=False, unsafe=False):
+ if not args:
+ args = []
+ if not kwds:
+ kwds = {}
+ cls = self.find_python_name(suffix, node.start_mark)
+ if not (unsafe or isinstance(cls, type)):
+ raise ConstructorError("while constructing a Python instance", node.start_mark,
+ "expected a class, but found %r" % type(cls),
+ node.start_mark)
+ if newobj and isinstance(cls, type):
+ return cls.__new__(cls, *args, **kwds)
+ else:
+ return cls(*args, **kwds)
+
+ def set_python_instance_state(self, instance, state, unsafe=False):
+ if hasattr(instance, '__setstate__'):
+ instance.__setstate__(state)
+ else:
+ slotstate = {}
+ if isinstance(state, tuple) and len(state) == 2:
+ state, slotstate = state
+ if hasattr(instance, '__dict__'):
+ if not unsafe and state:
+ for key in state.keys():
+ self.check_state_key(key)
+ instance.__dict__.update(state)
+ elif state:
+ slotstate.update(state)
+ for key, value in slotstate.items():
+ if not unsafe:
+ self.check_state_key(key)
+ setattr(instance, key, value)
+
+ def construct_python_object(self, suffix, node):
+ # Format:
+ # !!python/object:module.name { ... state ... }
+ instance = self.make_python_instance(suffix, node, newobj=True)
+ yield instance
+ deep = hasattr(instance, '__setstate__')
+ state = self.construct_mapping(node, deep=deep)
+ self.set_python_instance_state(instance, state)
+
+ def construct_python_object_apply(self, suffix, node, newobj=False):
+ # Format:
+ # !!python/object/apply # (or !!python/object/new)
+ # args: [ ... arguments ... ]
+ # kwds: { ... keywords ... }
+ # state: ... state ...
+ # listitems: [ ... listitems ... ]
+ # dictitems: { ... dictitems ... }
+ # or short format:
+ # !!python/object/apply [ ... arguments ... ]
+ # The difference between !!python/object/apply and !!python/object/new
+ # is how an object is created, check make_python_instance for details.
+ if isinstance(node, SequenceNode):
+ args = self.construct_sequence(node, deep=True)
+ kwds = {}
+ state = {}
+ listitems = []
+ dictitems = {}
+ else:
+ value = self.construct_mapping(node, deep=True)
+ args = value.get('args', [])
+ kwds = value.get('kwds', {})
+ state = value.get('state', {})
+ listitems = value.get('listitems', [])
+ dictitems = value.get('dictitems', {})
+ instance = self.make_python_instance(suffix, node, args, kwds, newobj)
+ if state:
+ self.set_python_instance_state(instance, state)
+ if listitems:
+ instance.extend(listitems)
+ if dictitems:
+ for key in dictitems:
+ instance[key] = dictitems[key]
+ return instance
+
+ def construct_python_object_new(self, suffix, node):
+ return self.construct_python_object_apply(suffix, node, newobj=True)
+
+FullConstructor.add_constructor(
+ 'tag:yaml.org,2002:python/none',
+ FullConstructor.construct_yaml_null)
+
+FullConstructor.add_constructor(
+ 'tag:yaml.org,2002:python/bool',
+ FullConstructor.construct_yaml_bool)
+
+FullConstructor.add_constructor(
+ 'tag:yaml.org,2002:python/str',
+ FullConstructor.construct_python_str)
+
+FullConstructor.add_constructor(
+ 'tag:yaml.org,2002:python/unicode',
+ FullConstructor.construct_python_unicode)
+
+FullConstructor.add_constructor(
+ 'tag:yaml.org,2002:python/bytes',
+ FullConstructor.construct_python_bytes)
+
+FullConstructor.add_constructor(
+ 'tag:yaml.org,2002:python/int',
+ FullConstructor.construct_yaml_int)
+
+FullConstructor.add_constructor(
+ 'tag:yaml.org,2002:python/long',
+ FullConstructor.construct_python_long)
+
+FullConstructor.add_constructor(
+ 'tag:yaml.org,2002:python/float',
+ FullConstructor.construct_yaml_float)
+
+FullConstructor.add_constructor(
+ 'tag:yaml.org,2002:python/complex',
+ FullConstructor.construct_python_complex)
+
+FullConstructor.add_constructor(
+ 'tag:yaml.org,2002:python/list',
+ FullConstructor.construct_yaml_seq)
+
+FullConstructor.add_constructor(
+ 'tag:yaml.org,2002:python/tuple',
+ FullConstructor.construct_python_tuple)
+
+FullConstructor.add_constructor(
+ 'tag:yaml.org,2002:python/dict',
+ FullConstructor.construct_yaml_map)
+
+FullConstructor.add_multi_constructor(
+ 'tag:yaml.org,2002:python/name:',
+ FullConstructor.construct_python_name)
+
+class UnsafeConstructor(FullConstructor):
+
+ def find_python_module(self, name, mark):
+ return super(UnsafeConstructor, self).find_python_module(name, mark, unsafe=True)
+
+ def find_python_name(self, name, mark):
+ return super(UnsafeConstructor, self).find_python_name(name, mark, unsafe=True)
+
+ def make_python_instance(self, suffix, node, args=None, kwds=None, newobj=False):
+ return super(UnsafeConstructor, self).make_python_instance(
+ suffix, node, args, kwds, newobj, unsafe=True)
+
+ def set_python_instance_state(self, instance, state):
+ return super(UnsafeConstructor, self).set_python_instance_state(
+ instance, state, unsafe=True)
+
+UnsafeConstructor.add_multi_constructor(
+ 'tag:yaml.org,2002:python/module:',
+ UnsafeConstructor.construct_python_module)
+
+UnsafeConstructor.add_multi_constructor(
+ 'tag:yaml.org,2002:python/object:',
+ UnsafeConstructor.construct_python_object)
+
+UnsafeConstructor.add_multi_constructor(
+ 'tag:yaml.org,2002:python/object/new:',
+ UnsafeConstructor.construct_python_object_new)
+
+UnsafeConstructor.add_multi_constructor(
+ 'tag:yaml.org,2002:python/object/apply:',
+ UnsafeConstructor.construct_python_object_apply)
+
+# Constructor is same as UnsafeConstructor. Need to leave this in place in case
+# people have extended it directly.
+class Constructor(UnsafeConstructor):
+ pass
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/cyaml.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/cyaml.py
new file mode 100644
index 0000000000000000000000000000000000000000..0c21345879b298bb8668201bebe7d289586b17f9
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/cyaml.py
@@ -0,0 +1,101 @@
+
+__all__ = [
+ 'CBaseLoader', 'CSafeLoader', 'CFullLoader', 'CUnsafeLoader', 'CLoader',
+ 'CBaseDumper', 'CSafeDumper', 'CDumper'
+]
+
+from yaml._yaml import CParser, CEmitter
+
+from .constructor import *
+
+from .serializer import *
+from .representer import *
+
+from .resolver import *
+
+class CBaseLoader(CParser, BaseConstructor, BaseResolver):
+
+ def __init__(self, stream):
+ CParser.__init__(self, stream)
+ BaseConstructor.__init__(self)
+ BaseResolver.__init__(self)
+
+class CSafeLoader(CParser, SafeConstructor, Resolver):
+
+ def __init__(self, stream):
+ CParser.__init__(self, stream)
+ SafeConstructor.__init__(self)
+ Resolver.__init__(self)
+
+class CFullLoader(CParser, FullConstructor, Resolver):
+
+ def __init__(self, stream):
+ CParser.__init__(self, stream)
+ FullConstructor.__init__(self)
+ Resolver.__init__(self)
+
+class CUnsafeLoader(CParser, UnsafeConstructor, Resolver):
+
+ def __init__(self, stream):
+ CParser.__init__(self, stream)
+ UnsafeConstructor.__init__(self)
+ Resolver.__init__(self)
+
+class CLoader(CParser, Constructor, Resolver):
+
+ def __init__(self, stream):
+ CParser.__init__(self, stream)
+ Constructor.__init__(self)
+ Resolver.__init__(self)
+
+class CBaseDumper(CEmitter, BaseRepresenter, BaseResolver):
+
+ def __init__(self, stream,
+ default_style=None, default_flow_style=False,
+ canonical=None, indent=None, width=None,
+ allow_unicode=None, line_break=None,
+ encoding=None, explicit_start=None, explicit_end=None,
+ version=None, tags=None, sort_keys=True):
+ CEmitter.__init__(self, stream, canonical=canonical,
+ indent=indent, width=width, encoding=encoding,
+ allow_unicode=allow_unicode, line_break=line_break,
+ explicit_start=explicit_start, explicit_end=explicit_end,
+ version=version, tags=tags)
+ Representer.__init__(self, default_style=default_style,
+ default_flow_style=default_flow_style, sort_keys=sort_keys)
+ Resolver.__init__(self)
+
+class CSafeDumper(CEmitter, SafeRepresenter, Resolver):
+
+ def __init__(self, stream,
+ default_style=None, default_flow_style=False,
+ canonical=None, indent=None, width=None,
+ allow_unicode=None, line_break=None,
+ encoding=None, explicit_start=None, explicit_end=None,
+ version=None, tags=None, sort_keys=True):
+ CEmitter.__init__(self, stream, canonical=canonical,
+ indent=indent, width=width, encoding=encoding,
+ allow_unicode=allow_unicode, line_break=line_break,
+ explicit_start=explicit_start, explicit_end=explicit_end,
+ version=version, tags=tags)
+ SafeRepresenter.__init__(self, default_style=default_style,
+ default_flow_style=default_flow_style, sort_keys=sort_keys)
+ Resolver.__init__(self)
+
+class CDumper(CEmitter, Serializer, Representer, Resolver):
+
+ def __init__(self, stream,
+ default_style=None, default_flow_style=False,
+ canonical=None, indent=None, width=None,
+ allow_unicode=None, line_break=None,
+ encoding=None, explicit_start=None, explicit_end=None,
+ version=None, tags=None, sort_keys=True):
+ CEmitter.__init__(self, stream, canonical=canonical,
+ indent=indent, width=width, encoding=encoding,
+ allow_unicode=allow_unicode, line_break=line_break,
+ explicit_start=explicit_start, explicit_end=explicit_end,
+ version=version, tags=tags)
+ Representer.__init__(self, default_style=default_style,
+ default_flow_style=default_flow_style, sort_keys=sort_keys)
+ Resolver.__init__(self)
+
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/dumper.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/dumper.py
new file mode 100644
index 0000000000000000000000000000000000000000..6aadba551f3836b02f4752277f4b3027073defad
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/dumper.py
@@ -0,0 +1,62 @@
+
+__all__ = ['BaseDumper', 'SafeDumper', 'Dumper']
+
+from .emitter import *
+from .serializer import *
+from .representer import *
+from .resolver import *
+
+class BaseDumper(Emitter, Serializer, BaseRepresenter, BaseResolver):
+
+ def __init__(self, stream,
+ default_style=None, default_flow_style=False,
+ canonical=None, indent=None, width=None,
+ allow_unicode=None, line_break=None,
+ encoding=None, explicit_start=None, explicit_end=None,
+ version=None, tags=None, sort_keys=True):
+ Emitter.__init__(self, stream, canonical=canonical,
+ indent=indent, width=width,
+ allow_unicode=allow_unicode, line_break=line_break)
+ Serializer.__init__(self, encoding=encoding,
+ explicit_start=explicit_start, explicit_end=explicit_end,
+ version=version, tags=tags)
+ Representer.__init__(self, default_style=default_style,
+ default_flow_style=default_flow_style, sort_keys=sort_keys)
+ Resolver.__init__(self)
+
+class SafeDumper(Emitter, Serializer, SafeRepresenter, Resolver):
+
+ def __init__(self, stream,
+ default_style=None, default_flow_style=False,
+ canonical=None, indent=None, width=None,
+ allow_unicode=None, line_break=None,
+ encoding=None, explicit_start=None, explicit_end=None,
+ version=None, tags=None, sort_keys=True):
+ Emitter.__init__(self, stream, canonical=canonical,
+ indent=indent, width=width,
+ allow_unicode=allow_unicode, line_break=line_break)
+ Serializer.__init__(self, encoding=encoding,
+ explicit_start=explicit_start, explicit_end=explicit_end,
+ version=version, tags=tags)
+ SafeRepresenter.__init__(self, default_style=default_style,
+ default_flow_style=default_flow_style, sort_keys=sort_keys)
+ Resolver.__init__(self)
+
+class Dumper(Emitter, Serializer, Representer, Resolver):
+
+ def __init__(self, stream,
+ default_style=None, default_flow_style=False,
+ canonical=None, indent=None, width=None,
+ allow_unicode=None, line_break=None,
+ encoding=None, explicit_start=None, explicit_end=None,
+ version=None, tags=None, sort_keys=True):
+ Emitter.__init__(self, stream, canonical=canonical,
+ indent=indent, width=width,
+ allow_unicode=allow_unicode, line_break=line_break)
+ Serializer.__init__(self, encoding=encoding,
+ explicit_start=explicit_start, explicit_end=explicit_end,
+ version=version, tags=tags)
+ Representer.__init__(self, default_style=default_style,
+ default_flow_style=default_flow_style, sort_keys=sort_keys)
+ Resolver.__init__(self)
+
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/events.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/events.py
new file mode 100644
index 0000000000000000000000000000000000000000..f79ad389cb6c9517e391dcd25534866bc9ccd36a
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/events.py
@@ -0,0 +1,86 @@
+
+# Abstract classes.
+
+class Event(object):
+ def __init__(self, start_mark=None, end_mark=None):
+ self.start_mark = start_mark
+ self.end_mark = end_mark
+ def __repr__(self):
+ attributes = [key for key in ['anchor', 'tag', 'implicit', 'value']
+ if hasattr(self, key)]
+ arguments = ', '.join(['%s=%r' % (key, getattr(self, key))
+ for key in attributes])
+ return '%s(%s)' % (self.__class__.__name__, arguments)
+
+class NodeEvent(Event):
+ def __init__(self, anchor, start_mark=None, end_mark=None):
+ self.anchor = anchor
+ self.start_mark = start_mark
+ self.end_mark = end_mark
+
+class CollectionStartEvent(NodeEvent):
+ def __init__(self, anchor, tag, implicit, start_mark=None, end_mark=None,
+ flow_style=None):
+ self.anchor = anchor
+ self.tag = tag
+ self.implicit = implicit
+ self.start_mark = start_mark
+ self.end_mark = end_mark
+ self.flow_style = flow_style
+
+class CollectionEndEvent(Event):
+ pass
+
+# Implementations.
+
+class StreamStartEvent(Event):
+ def __init__(self, start_mark=None, end_mark=None, encoding=None):
+ self.start_mark = start_mark
+ self.end_mark = end_mark
+ self.encoding = encoding
+
+class StreamEndEvent(Event):
+ pass
+
+class DocumentStartEvent(Event):
+ def __init__(self, start_mark=None, end_mark=None,
+ explicit=None, version=None, tags=None):
+ self.start_mark = start_mark
+ self.end_mark = end_mark
+ self.explicit = explicit
+ self.version = version
+ self.tags = tags
+
+class DocumentEndEvent(Event):
+ def __init__(self, start_mark=None, end_mark=None,
+ explicit=None):
+ self.start_mark = start_mark
+ self.end_mark = end_mark
+ self.explicit = explicit
+
+class AliasEvent(NodeEvent):
+ pass
+
+class ScalarEvent(NodeEvent):
+ def __init__(self, anchor, tag, implicit, value,
+ start_mark=None, end_mark=None, style=None):
+ self.anchor = anchor
+ self.tag = tag
+ self.implicit = implicit
+ self.value = value
+ self.start_mark = start_mark
+ self.end_mark = end_mark
+ self.style = style
+
+class SequenceStartEvent(CollectionStartEvent):
+ pass
+
+class SequenceEndEvent(CollectionEndEvent):
+ pass
+
+class MappingStartEvent(CollectionStartEvent):
+ pass
+
+class MappingEndEvent(CollectionEndEvent):
+ pass
+
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/loader.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/loader.py
new file mode 100644
index 0000000000000000000000000000000000000000..e90c11224c38e559cdf0cb205f0692ebd4fb8681
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/loader.py
@@ -0,0 +1,63 @@
+
+__all__ = ['BaseLoader', 'FullLoader', 'SafeLoader', 'Loader', 'UnsafeLoader']
+
+from .reader import *
+from .scanner import *
+from .parser import *
+from .composer import *
+from .constructor import *
+from .resolver import *
+
+class BaseLoader(Reader, Scanner, Parser, Composer, BaseConstructor, BaseResolver):
+
+ def __init__(self, stream):
+ Reader.__init__(self, stream)
+ Scanner.__init__(self)
+ Parser.__init__(self)
+ Composer.__init__(self)
+ BaseConstructor.__init__(self)
+ BaseResolver.__init__(self)
+
+class FullLoader(Reader, Scanner, Parser, Composer, FullConstructor, Resolver):
+
+ def __init__(self, stream):
+ Reader.__init__(self, stream)
+ Scanner.__init__(self)
+ Parser.__init__(self)
+ Composer.__init__(self)
+ FullConstructor.__init__(self)
+ Resolver.__init__(self)
+
+class SafeLoader(Reader, Scanner, Parser, Composer, SafeConstructor, Resolver):
+
+ def __init__(self, stream):
+ Reader.__init__(self, stream)
+ Scanner.__init__(self)
+ Parser.__init__(self)
+ Composer.__init__(self)
+ SafeConstructor.__init__(self)
+ Resolver.__init__(self)
+
+class Loader(Reader, Scanner, Parser, Composer, Constructor, Resolver):
+
+ def __init__(self, stream):
+ Reader.__init__(self, stream)
+ Scanner.__init__(self)
+ Parser.__init__(self)
+ Composer.__init__(self)
+ Constructor.__init__(self)
+ Resolver.__init__(self)
+
+# UnsafeLoader is the same as Loader (which is and was always unsafe on
+# untrusted input). Use of either Loader or UnsafeLoader should be rare, since
+# FullLoad should be able to load almost all YAML safely. Loader is left intact
+# to ensure backwards compatibility.
+class UnsafeLoader(Reader, Scanner, Parser, Composer, Constructor, Resolver):
+
+ def __init__(self, stream):
+ Reader.__init__(self, stream)
+ Scanner.__init__(self)
+ Parser.__init__(self)
+ Composer.__init__(self)
+ Constructor.__init__(self)
+ Resolver.__init__(self)
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/nodes.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/nodes.py
new file mode 100644
index 0000000000000000000000000000000000000000..c4f070c41e1fb1bc01af27d69329e92dded38908
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/nodes.py
@@ -0,0 +1,49 @@
+
+class Node(object):
+ def __init__(self, tag, value, start_mark, end_mark):
+ self.tag = tag
+ self.value = value
+ self.start_mark = start_mark
+ self.end_mark = end_mark
+ def __repr__(self):
+ value = self.value
+ #if isinstance(value, list):
+ # if len(value) == 0:
+ # value = ''
+ # elif len(value) == 1:
+ # value = '<1 item>'
+ # else:
+ # value = '<%d items>' % len(value)
+ #else:
+ # if len(value) > 75:
+ # value = repr(value[:70]+u' ... ')
+ # else:
+ # value = repr(value)
+ value = repr(value)
+ return '%s(tag=%r, value=%s)' % (self.__class__.__name__, self.tag, value)
+
+class ScalarNode(Node):
+ id = 'scalar'
+ def __init__(self, tag, value,
+ start_mark=None, end_mark=None, style=None):
+ self.tag = tag
+ self.value = value
+ self.start_mark = start_mark
+ self.end_mark = end_mark
+ self.style = style
+
+class CollectionNode(Node):
+ def __init__(self, tag, value,
+ start_mark=None, end_mark=None, flow_style=None):
+ self.tag = tag
+ self.value = value
+ self.start_mark = start_mark
+ self.end_mark = end_mark
+ self.flow_style = flow_style
+
+class SequenceNode(CollectionNode):
+ id = 'sequence'
+
+class MappingNode(CollectionNode):
+ id = 'mapping'
+
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/parser.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/parser.py
new file mode 100644
index 0000000000000000000000000000000000000000..13a5995d292045d0f865a99abf692bd35dc87814
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/parser.py
@@ -0,0 +1,589 @@
+
+# The following YAML grammar is LL(1) and is parsed by a recursive descent
+# parser.
+#
+# stream ::= STREAM-START implicit_document? explicit_document* STREAM-END
+# implicit_document ::= block_node DOCUMENT-END*
+# explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
+# block_node_or_indentless_sequence ::=
+# ALIAS
+# | properties (block_content | indentless_block_sequence)?
+# | block_content
+# | indentless_block_sequence
+# block_node ::= ALIAS
+# | properties block_content?
+# | block_content
+# flow_node ::= ALIAS
+# | properties flow_content?
+# | flow_content
+# properties ::= TAG ANCHOR? | ANCHOR TAG?
+# block_content ::= block_collection | flow_collection | SCALAR
+# flow_content ::= flow_collection | SCALAR
+# block_collection ::= block_sequence | block_mapping
+# flow_collection ::= flow_sequence | flow_mapping
+# block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END
+# indentless_sequence ::= (BLOCK-ENTRY block_node?)+
+# block_mapping ::= BLOCK-MAPPING_START
+# ((KEY block_node_or_indentless_sequence?)?
+# (VALUE block_node_or_indentless_sequence?)?)*
+# BLOCK-END
+# flow_sequence ::= FLOW-SEQUENCE-START
+# (flow_sequence_entry FLOW-ENTRY)*
+# flow_sequence_entry?
+# FLOW-SEQUENCE-END
+# flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+# flow_mapping ::= FLOW-MAPPING-START
+# (flow_mapping_entry FLOW-ENTRY)*
+# flow_mapping_entry?
+# FLOW-MAPPING-END
+# flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+#
+# FIRST sets:
+#
+# stream: { STREAM-START }
+# explicit_document: { DIRECTIVE DOCUMENT-START }
+# implicit_document: FIRST(block_node)
+# block_node: { ALIAS TAG ANCHOR SCALAR BLOCK-SEQUENCE-START BLOCK-MAPPING-START FLOW-SEQUENCE-START FLOW-MAPPING-START }
+# flow_node: { ALIAS ANCHOR TAG SCALAR FLOW-SEQUENCE-START FLOW-MAPPING-START }
+# block_content: { BLOCK-SEQUENCE-START BLOCK-MAPPING-START FLOW-SEQUENCE-START FLOW-MAPPING-START SCALAR }
+# flow_content: { FLOW-SEQUENCE-START FLOW-MAPPING-START SCALAR }
+# block_collection: { BLOCK-SEQUENCE-START BLOCK-MAPPING-START }
+# flow_collection: { FLOW-SEQUENCE-START FLOW-MAPPING-START }
+# block_sequence: { BLOCK-SEQUENCE-START }
+# block_mapping: { BLOCK-MAPPING-START }
+# block_node_or_indentless_sequence: { ALIAS ANCHOR TAG SCALAR BLOCK-SEQUENCE-START BLOCK-MAPPING-START FLOW-SEQUENCE-START FLOW-MAPPING-START BLOCK-ENTRY }
+# indentless_sequence: { ENTRY }
+# flow_collection: { FLOW-SEQUENCE-START FLOW-MAPPING-START }
+# flow_sequence: { FLOW-SEQUENCE-START }
+# flow_mapping: { FLOW-MAPPING-START }
+# flow_sequence_entry: { ALIAS ANCHOR TAG SCALAR FLOW-SEQUENCE-START FLOW-MAPPING-START KEY }
+# flow_mapping_entry: { ALIAS ANCHOR TAG SCALAR FLOW-SEQUENCE-START FLOW-MAPPING-START KEY }
+
+__all__ = ['Parser', 'ParserError']
+
+from .error import MarkedYAMLError
+from .tokens import *
+from .events import *
+from .scanner import *
+
+class ParserError(MarkedYAMLError):
+ pass
+
+class Parser:
+ # Since writing a recursive-descendant parser is a straightforward task, we
+ # do not give many comments here.
+
+ DEFAULT_TAGS = {
+ '!': '!',
+ '!!': 'tag:yaml.org,2002:',
+ }
+
+ def __init__(self):
+ self.current_event = None
+ self.yaml_version = None
+ self.tag_handles = {}
+ self.states = []
+ self.marks = []
+ self.state = self.parse_stream_start
+
+ def dispose(self):
+ # Reset the state attributes (to clear self-references)
+ self.states = []
+ self.state = None
+
+ def check_event(self, *choices):
+ # Check the type of the next event.
+ if self.current_event is None:
+ if self.state:
+ self.current_event = self.state()
+ if self.current_event is not None:
+ if not choices:
+ return True
+ for choice in choices:
+ if isinstance(self.current_event, choice):
+ return True
+ return False
+
+ def peek_event(self):
+ # Get the next event.
+ if self.current_event is None:
+ if self.state:
+ self.current_event = self.state()
+ return self.current_event
+
+ def get_event(self):
+ # Get the next event and proceed further.
+ if self.current_event is None:
+ if self.state:
+ self.current_event = self.state()
+ value = self.current_event
+ self.current_event = None
+ return value
+
+ # stream ::= STREAM-START implicit_document? explicit_document* STREAM-END
+ # implicit_document ::= block_node DOCUMENT-END*
+ # explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
+
+ def parse_stream_start(self):
+
+ # Parse the stream start.
+ token = self.get_token()
+ event = StreamStartEvent(token.start_mark, token.end_mark,
+ encoding=token.encoding)
+
+ # Prepare the next state.
+ self.state = self.parse_implicit_document_start
+
+ return event
+
+ def parse_implicit_document_start(self):
+
+ # Parse an implicit document.
+ if not self.check_token(DirectiveToken, DocumentStartToken,
+ StreamEndToken):
+ self.tag_handles = self.DEFAULT_TAGS
+ token = self.peek_token()
+ start_mark = end_mark = token.start_mark
+ event = DocumentStartEvent(start_mark, end_mark,
+ explicit=False)
+
+ # Prepare the next state.
+ self.states.append(self.parse_document_end)
+ self.state = self.parse_block_node
+
+ return event
+
+ else:
+ return self.parse_document_start()
+
+ def parse_document_start(self):
+
+ # Parse any extra document end indicators.
+ while self.check_token(DocumentEndToken):
+ self.get_token()
+
+ # Parse an explicit document.
+ if not self.check_token(StreamEndToken):
+ token = self.peek_token()
+ start_mark = token.start_mark
+ version, tags = self.process_directives()
+ if not self.check_token(DocumentStartToken):
+ raise ParserError(None, None,
+ "expected '', but found %r"
+ % self.peek_token().id,
+ self.peek_token().start_mark)
+ token = self.get_token()
+ end_mark = token.end_mark
+ event = DocumentStartEvent(start_mark, end_mark,
+ explicit=True, version=version, tags=tags)
+ self.states.append(self.parse_document_end)
+ self.state = self.parse_document_content
+ else:
+ # Parse the end of the stream.
+ token = self.get_token()
+ event = StreamEndEvent(token.start_mark, token.end_mark)
+ assert not self.states
+ assert not self.marks
+ self.state = None
+ return event
+
+ def parse_document_end(self):
+
+ # Parse the document end.
+ token = self.peek_token()
+ start_mark = end_mark = token.start_mark
+ explicit = False
+ if self.check_token(DocumentEndToken):
+ token = self.get_token()
+ end_mark = token.end_mark
+ explicit = True
+ event = DocumentEndEvent(start_mark, end_mark,
+ explicit=explicit)
+
+ # Prepare the next state.
+ self.state = self.parse_document_start
+
+ return event
+
+ def parse_document_content(self):
+ if self.check_token(DirectiveToken,
+ DocumentStartToken, DocumentEndToken, StreamEndToken):
+ event = self.process_empty_scalar(self.peek_token().start_mark)
+ self.state = self.states.pop()
+ return event
+ else:
+ return self.parse_block_node()
+
+ def process_directives(self):
+ self.yaml_version = None
+ self.tag_handles = {}
+ while self.check_token(DirectiveToken):
+ token = self.get_token()
+ if token.name == 'YAML':
+ if self.yaml_version is not None:
+ raise ParserError(None, None,
+ "found duplicate YAML directive", token.start_mark)
+ major, minor = token.value
+ if major != 1:
+ raise ParserError(None, None,
+ "found incompatible YAML document (version 1.* is required)",
+ token.start_mark)
+ self.yaml_version = token.value
+ elif token.name == 'TAG':
+ handle, prefix = token.value
+ if handle in self.tag_handles:
+ raise ParserError(None, None,
+ "duplicate tag handle %r" % handle,
+ token.start_mark)
+ self.tag_handles[handle] = prefix
+ if self.tag_handles:
+ value = self.yaml_version, self.tag_handles.copy()
+ else:
+ value = self.yaml_version, None
+ for key in self.DEFAULT_TAGS:
+ if key not in self.tag_handles:
+ self.tag_handles[key] = self.DEFAULT_TAGS[key]
+ return value
+
+ # block_node_or_indentless_sequence ::= ALIAS
+ # | properties (block_content | indentless_block_sequence)?
+ # | block_content
+ # | indentless_block_sequence
+ # block_node ::= ALIAS
+ # | properties block_content?
+ # | block_content
+ # flow_node ::= ALIAS
+ # | properties flow_content?
+ # | flow_content
+ # properties ::= TAG ANCHOR? | ANCHOR TAG?
+ # block_content ::= block_collection | flow_collection | SCALAR
+ # flow_content ::= flow_collection | SCALAR
+ # block_collection ::= block_sequence | block_mapping
+ # flow_collection ::= flow_sequence | flow_mapping
+
+ def parse_block_node(self):
+ return self.parse_node(block=True)
+
+ def parse_flow_node(self):
+ return self.parse_node()
+
+ def parse_block_node_or_indentless_sequence(self):
+ return self.parse_node(block=True, indentless_sequence=True)
+
+ def parse_node(self, block=False, indentless_sequence=False):
+ if self.check_token(AliasToken):
+ token = self.get_token()
+ event = AliasEvent(token.value, token.start_mark, token.end_mark)
+ self.state = self.states.pop()
+ else:
+ anchor = None
+ tag = None
+ start_mark = end_mark = tag_mark = None
+ if self.check_token(AnchorToken):
+ token = self.get_token()
+ start_mark = token.start_mark
+ end_mark = token.end_mark
+ anchor = token.value
+ if self.check_token(TagToken):
+ token = self.get_token()
+ tag_mark = token.start_mark
+ end_mark = token.end_mark
+ tag = token.value
+ elif self.check_token(TagToken):
+ token = self.get_token()
+ start_mark = tag_mark = token.start_mark
+ end_mark = token.end_mark
+ tag = token.value
+ if self.check_token(AnchorToken):
+ token = self.get_token()
+ end_mark = token.end_mark
+ anchor = token.value
+ if tag is not None:
+ handle, suffix = tag
+ if handle is not None:
+ if handle not in self.tag_handles:
+ raise ParserError("while parsing a node", start_mark,
+ "found undefined tag handle %r" % handle,
+ tag_mark)
+ tag = self.tag_handles[handle]+suffix
+ else:
+ tag = suffix
+ #if tag == '!':
+ # raise ParserError("while parsing a node", start_mark,
+ # "found non-specific tag '!'", tag_mark,
+ # "Please check 'http://pyyaml.org/wiki/YAMLNonSpecificTag' and share your opinion.")
+ if start_mark is None:
+ start_mark = end_mark = self.peek_token().start_mark
+ event = None
+ implicit = (tag is None or tag == '!')
+ if indentless_sequence and self.check_token(BlockEntryToken):
+ end_mark = self.peek_token().end_mark
+ event = SequenceStartEvent(anchor, tag, implicit,
+ start_mark, end_mark)
+ self.state = self.parse_indentless_sequence_entry
+ else:
+ if self.check_token(ScalarToken):
+ token = self.get_token()
+ end_mark = token.end_mark
+ if (token.plain and tag is None) or tag == '!':
+ implicit = (True, False)
+ elif tag is None:
+ implicit = (False, True)
+ else:
+ implicit = (False, False)
+ event = ScalarEvent(anchor, tag, implicit, token.value,
+ start_mark, end_mark, style=token.style)
+ self.state = self.states.pop()
+ elif self.check_token(FlowSequenceStartToken):
+ end_mark = self.peek_token().end_mark
+ event = SequenceStartEvent(anchor, tag, implicit,
+ start_mark, end_mark, flow_style=True)
+ self.state = self.parse_flow_sequence_first_entry
+ elif self.check_token(FlowMappingStartToken):
+ end_mark = self.peek_token().end_mark
+ event = MappingStartEvent(anchor, tag, implicit,
+ start_mark, end_mark, flow_style=True)
+ self.state = self.parse_flow_mapping_first_key
+ elif block and self.check_token(BlockSequenceStartToken):
+ end_mark = self.peek_token().start_mark
+ event = SequenceStartEvent(anchor, tag, implicit,
+ start_mark, end_mark, flow_style=False)
+ self.state = self.parse_block_sequence_first_entry
+ elif block and self.check_token(BlockMappingStartToken):
+ end_mark = self.peek_token().start_mark
+ event = MappingStartEvent(anchor, tag, implicit,
+ start_mark, end_mark, flow_style=False)
+ self.state = self.parse_block_mapping_first_key
+ elif anchor is not None or tag is not None:
+ # Empty scalars are allowed even if a tag or an anchor is
+ # specified.
+ event = ScalarEvent(anchor, tag, (implicit, False), '',
+ start_mark, end_mark)
+ self.state = self.states.pop()
+ else:
+ if block:
+ node = 'block'
+ else:
+ node = 'flow'
+ token = self.peek_token()
+ raise ParserError("while parsing a %s node" % node, start_mark,
+ "expected the node content, but found %r" % token.id,
+ token.start_mark)
+ return event
+
+ # block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END
+
+ def parse_block_sequence_first_entry(self):
+ token = self.get_token()
+ self.marks.append(token.start_mark)
+ return self.parse_block_sequence_entry()
+
+ def parse_block_sequence_entry(self):
+ if self.check_token(BlockEntryToken):
+ token = self.get_token()
+ if not self.check_token(BlockEntryToken, BlockEndToken):
+ self.states.append(self.parse_block_sequence_entry)
+ return self.parse_block_node()
+ else:
+ self.state = self.parse_block_sequence_entry
+ return self.process_empty_scalar(token.end_mark)
+ if not self.check_token(BlockEndToken):
+ token = self.peek_token()
+ raise ParserError("while parsing a block collection", self.marks[-1],
+ "expected , but found %r" % token.id, token.start_mark)
+ token = self.get_token()
+ event = SequenceEndEvent(token.start_mark, token.end_mark)
+ self.state = self.states.pop()
+ self.marks.pop()
+ return event
+
+ # indentless_sequence ::= (BLOCK-ENTRY block_node?)+
+
+ def parse_indentless_sequence_entry(self):
+ if self.check_token(BlockEntryToken):
+ token = self.get_token()
+ if not self.check_token(BlockEntryToken,
+ KeyToken, ValueToken, BlockEndToken):
+ self.states.append(self.parse_indentless_sequence_entry)
+ return self.parse_block_node()
+ else:
+ self.state = self.parse_indentless_sequence_entry
+ return self.process_empty_scalar(token.end_mark)
+ token = self.peek_token()
+ event = SequenceEndEvent(token.start_mark, token.start_mark)
+ self.state = self.states.pop()
+ return event
+
+ # block_mapping ::= BLOCK-MAPPING_START
+ # ((KEY block_node_or_indentless_sequence?)?
+ # (VALUE block_node_or_indentless_sequence?)?)*
+ # BLOCK-END
+
+ def parse_block_mapping_first_key(self):
+ token = self.get_token()
+ self.marks.append(token.start_mark)
+ return self.parse_block_mapping_key()
+
+ def parse_block_mapping_key(self):
+ if self.check_token(KeyToken):
+ token = self.get_token()
+ if not self.check_token(KeyToken, ValueToken, BlockEndToken):
+ self.states.append(self.parse_block_mapping_value)
+ return self.parse_block_node_or_indentless_sequence()
+ else:
+ self.state = self.parse_block_mapping_value
+ return self.process_empty_scalar(token.end_mark)
+ if not self.check_token(BlockEndToken):
+ token = self.peek_token()
+ raise ParserError("while parsing a block mapping", self.marks[-1],
+ "expected , but found %r" % token.id, token.start_mark)
+ token = self.get_token()
+ event = MappingEndEvent(token.start_mark, token.end_mark)
+ self.state = self.states.pop()
+ self.marks.pop()
+ return event
+
+ def parse_block_mapping_value(self):
+ if self.check_token(ValueToken):
+ token = self.get_token()
+ if not self.check_token(KeyToken, ValueToken, BlockEndToken):
+ self.states.append(self.parse_block_mapping_key)
+ return self.parse_block_node_or_indentless_sequence()
+ else:
+ self.state = self.parse_block_mapping_key
+ return self.process_empty_scalar(token.end_mark)
+ else:
+ self.state = self.parse_block_mapping_key
+ token = self.peek_token()
+ return self.process_empty_scalar(token.start_mark)
+
+ # flow_sequence ::= FLOW-SEQUENCE-START
+ # (flow_sequence_entry FLOW-ENTRY)*
+ # flow_sequence_entry?
+ # FLOW-SEQUENCE-END
+ # flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+ #
+ # Note that while production rules for both flow_sequence_entry and
+ # flow_mapping_entry are equal, their interpretations are different.
+ # For `flow_sequence_entry`, the part `KEY flow_node? (VALUE flow_node?)?`
+ # generate an inline mapping (set syntax).
+
+ def parse_flow_sequence_first_entry(self):
+ token = self.get_token()
+ self.marks.append(token.start_mark)
+ return self.parse_flow_sequence_entry(first=True)
+
+ def parse_flow_sequence_entry(self, first=False):
+ if not self.check_token(FlowSequenceEndToken):
+ if not first:
+ if self.check_token(FlowEntryToken):
+ self.get_token()
+ else:
+ token = self.peek_token()
+ raise ParserError("while parsing a flow sequence", self.marks[-1],
+ "expected ',' or ']', but got %r" % token.id, token.start_mark)
+
+ if self.check_token(KeyToken):
+ token = self.peek_token()
+ event = MappingStartEvent(None, None, True,
+ token.start_mark, token.end_mark,
+ flow_style=True)
+ self.state = self.parse_flow_sequence_entry_mapping_key
+ return event
+ elif not self.check_token(FlowSequenceEndToken):
+ self.states.append(self.parse_flow_sequence_entry)
+ return self.parse_flow_node()
+ token = self.get_token()
+ event = SequenceEndEvent(token.start_mark, token.end_mark)
+ self.state = self.states.pop()
+ self.marks.pop()
+ return event
+
+ def parse_flow_sequence_entry_mapping_key(self):
+ token = self.get_token()
+ if not self.check_token(ValueToken,
+ FlowEntryToken, FlowSequenceEndToken):
+ self.states.append(self.parse_flow_sequence_entry_mapping_value)
+ return self.parse_flow_node()
+ else:
+ self.state = self.parse_flow_sequence_entry_mapping_value
+ return self.process_empty_scalar(token.end_mark)
+
+ def parse_flow_sequence_entry_mapping_value(self):
+ if self.check_token(ValueToken):
+ token = self.get_token()
+ if not self.check_token(FlowEntryToken, FlowSequenceEndToken):
+ self.states.append(self.parse_flow_sequence_entry_mapping_end)
+ return self.parse_flow_node()
+ else:
+ self.state = self.parse_flow_sequence_entry_mapping_end
+ return self.process_empty_scalar(token.end_mark)
+ else:
+ self.state = self.parse_flow_sequence_entry_mapping_end
+ token = self.peek_token()
+ return self.process_empty_scalar(token.start_mark)
+
+ def parse_flow_sequence_entry_mapping_end(self):
+ self.state = self.parse_flow_sequence_entry
+ token = self.peek_token()
+ return MappingEndEvent(token.start_mark, token.start_mark)
+
+ # flow_mapping ::= FLOW-MAPPING-START
+ # (flow_mapping_entry FLOW-ENTRY)*
+ # flow_mapping_entry?
+ # FLOW-MAPPING-END
+ # flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+
+ def parse_flow_mapping_first_key(self):
+ token = self.get_token()
+ self.marks.append(token.start_mark)
+ return self.parse_flow_mapping_key(first=True)
+
+ def parse_flow_mapping_key(self, first=False):
+ if not self.check_token(FlowMappingEndToken):
+ if not first:
+ if self.check_token(FlowEntryToken):
+ self.get_token()
+ else:
+ token = self.peek_token()
+ raise ParserError("while parsing a flow mapping", self.marks[-1],
+ "expected ',' or '}', but got %r" % token.id, token.start_mark)
+ if self.check_token(KeyToken):
+ token = self.get_token()
+ if not self.check_token(ValueToken,
+ FlowEntryToken, FlowMappingEndToken):
+ self.states.append(self.parse_flow_mapping_value)
+ return self.parse_flow_node()
+ else:
+ self.state = self.parse_flow_mapping_value
+ return self.process_empty_scalar(token.end_mark)
+ elif not self.check_token(FlowMappingEndToken):
+ self.states.append(self.parse_flow_mapping_empty_value)
+ return self.parse_flow_node()
+ token = self.get_token()
+ event = MappingEndEvent(token.start_mark, token.end_mark)
+ self.state = self.states.pop()
+ self.marks.pop()
+ return event
+
+ def parse_flow_mapping_value(self):
+ if self.check_token(ValueToken):
+ token = self.get_token()
+ if not self.check_token(FlowEntryToken, FlowMappingEndToken):
+ self.states.append(self.parse_flow_mapping_key)
+ return self.parse_flow_node()
+ else:
+ self.state = self.parse_flow_mapping_key
+ return self.process_empty_scalar(token.end_mark)
+ else:
+ self.state = self.parse_flow_mapping_key
+ token = self.peek_token()
+ return self.process_empty_scalar(token.start_mark)
+
+ def parse_flow_mapping_empty_value(self):
+ self.state = self.parse_flow_mapping_key
+ return self.process_empty_scalar(self.peek_token().start_mark)
+
+ def process_empty_scalar(self, mark):
+ return ScalarEvent(None, None, (True, False), '', mark, mark)
+
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/representer.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/representer.py
new file mode 100644
index 0000000000000000000000000000000000000000..808ca06dfbd60c9a23eb079151b74a82ef688749
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/representer.py
@@ -0,0 +1,389 @@
+
+__all__ = ['BaseRepresenter', 'SafeRepresenter', 'Representer',
+ 'RepresenterError']
+
+from .error import *
+from .nodes import *
+
+import datetime, copyreg, types, base64, collections
+
+class RepresenterError(YAMLError):
+ pass
+
+class BaseRepresenter:
+
+ yaml_representers = {}
+ yaml_multi_representers = {}
+
+ def __init__(self, default_style=None, default_flow_style=False, sort_keys=True):
+ self.default_style = default_style
+ self.sort_keys = sort_keys
+ self.default_flow_style = default_flow_style
+ self.represented_objects = {}
+ self.object_keeper = []
+ self.alias_key = None
+
+ def represent(self, data):
+ node = self.represent_data(data)
+ self.serialize(node)
+ self.represented_objects = {}
+ self.object_keeper = []
+ self.alias_key = None
+
+ def represent_data(self, data):
+ if self.ignore_aliases(data):
+ self.alias_key = None
+ else:
+ self.alias_key = id(data)
+ if self.alias_key is not None:
+ if self.alias_key in self.represented_objects:
+ node = self.represented_objects[self.alias_key]
+ #if node is None:
+ # raise RepresenterError("recursive objects are not allowed: %r" % data)
+ return node
+ #self.represented_objects[alias_key] = None
+ self.object_keeper.append(data)
+ data_types = type(data).__mro__
+ if data_types[0] in self.yaml_representers:
+ node = self.yaml_representers[data_types[0]](self, data)
+ else:
+ for data_type in data_types:
+ if data_type in self.yaml_multi_representers:
+ node = self.yaml_multi_representers[data_type](self, data)
+ break
+ else:
+ if None in self.yaml_multi_representers:
+ node = self.yaml_multi_representers[None](self, data)
+ elif None in self.yaml_representers:
+ node = self.yaml_representers[None](self, data)
+ else:
+ node = ScalarNode(None, str(data))
+ #if alias_key is not None:
+ # self.represented_objects[alias_key] = node
+ return node
+
+ @classmethod
+ def add_representer(cls, data_type, representer):
+ if not 'yaml_representers' in cls.__dict__:
+ cls.yaml_representers = cls.yaml_representers.copy()
+ cls.yaml_representers[data_type] = representer
+
+ @classmethod
+ def add_multi_representer(cls, data_type, representer):
+ if not 'yaml_multi_representers' in cls.__dict__:
+ cls.yaml_multi_representers = cls.yaml_multi_representers.copy()
+ cls.yaml_multi_representers[data_type] = representer
+
+ def represent_scalar(self, tag, value, style=None):
+ if style is None:
+ style = self.default_style
+ node = ScalarNode(tag, value, style=style)
+ if self.alias_key is not None:
+ self.represented_objects[self.alias_key] = node
+ return node
+
+ def represent_sequence(self, tag, sequence, flow_style=None):
+ value = []
+ node = SequenceNode(tag, value, flow_style=flow_style)
+ if self.alias_key is not None:
+ self.represented_objects[self.alias_key] = node
+ best_style = True
+ for item in sequence:
+ node_item = self.represent_data(item)
+ if not (isinstance(node_item, ScalarNode) and not node_item.style):
+ best_style = False
+ value.append(node_item)
+ if flow_style is None:
+ if self.default_flow_style is not None:
+ node.flow_style = self.default_flow_style
+ else:
+ node.flow_style = best_style
+ return node
+
+ def represent_mapping(self, tag, mapping, flow_style=None):
+ value = []
+ node = MappingNode(tag, value, flow_style=flow_style)
+ if self.alias_key is not None:
+ self.represented_objects[self.alias_key] = node
+ best_style = True
+ if hasattr(mapping, 'items'):
+ mapping = list(mapping.items())
+ if self.sort_keys:
+ try:
+ mapping = sorted(mapping)
+ except TypeError:
+ pass
+ for item_key, item_value in mapping:
+ node_key = self.represent_data(item_key)
+ node_value = self.represent_data(item_value)
+ if not (isinstance(node_key, ScalarNode) and not node_key.style):
+ best_style = False
+ if not (isinstance(node_value, ScalarNode) and not node_value.style):
+ best_style = False
+ value.append((node_key, node_value))
+ if flow_style is None:
+ if self.default_flow_style is not None:
+ node.flow_style = self.default_flow_style
+ else:
+ node.flow_style = best_style
+ return node
+
+ def ignore_aliases(self, data):
+ return False
+
+class SafeRepresenter(BaseRepresenter):
+
+ def ignore_aliases(self, data):
+ if data is None:
+ return True
+ if isinstance(data, tuple) and data == ():
+ return True
+ if isinstance(data, (str, bytes, bool, int, float)):
+ return True
+
+ def represent_none(self, data):
+ return self.represent_scalar('tag:yaml.org,2002:null', 'null')
+
+ def represent_str(self, data):
+ return self.represent_scalar('tag:yaml.org,2002:str', data)
+
+ def represent_binary(self, data):
+ if hasattr(base64, 'encodebytes'):
+ data = base64.encodebytes(data).decode('ascii')
+ else:
+ data = base64.encodestring(data).decode('ascii')
+ return self.represent_scalar('tag:yaml.org,2002:binary', data, style='|')
+
+ def represent_bool(self, data):
+ if data:
+ value = 'true'
+ else:
+ value = 'false'
+ return self.represent_scalar('tag:yaml.org,2002:bool', value)
+
+ def represent_int(self, data):
+ return self.represent_scalar('tag:yaml.org,2002:int', str(data))
+
+ inf_value = 1e300
+ while repr(inf_value) != repr(inf_value*inf_value):
+ inf_value *= inf_value
+
+ def represent_float(self, data):
+ if data != data or (data == 0.0 and data == 1.0):
+ value = '.nan'
+ elif data == self.inf_value:
+ value = '.inf'
+ elif data == -self.inf_value:
+ value = '-.inf'
+ else:
+ value = repr(data).lower()
+ # Note that in some cases `repr(data)` represents a float number
+ # without the decimal parts. For instance:
+ # >>> repr(1e17)
+ # '1e17'
+ # Unfortunately, this is not a valid float representation according
+ # to the definition of the `!!float` tag. We fix this by adding
+ # '.0' before the 'e' symbol.
+ if '.' not in value and 'e' in value:
+ value = value.replace('e', '.0e', 1)
+ return self.represent_scalar('tag:yaml.org,2002:float', value)
+
+ def represent_list(self, data):
+ #pairs = (len(data) > 0 and isinstance(data, list))
+ #if pairs:
+ # for item in data:
+ # if not isinstance(item, tuple) or len(item) != 2:
+ # pairs = False
+ # break
+ #if not pairs:
+ return self.represent_sequence('tag:yaml.org,2002:seq', data)
+ #value = []
+ #for item_key, item_value in data:
+ # value.append(self.represent_mapping(u'tag:yaml.org,2002:map',
+ # [(item_key, item_value)]))
+ #return SequenceNode(u'tag:yaml.org,2002:pairs', value)
+
+ def represent_dict(self, data):
+ return self.represent_mapping('tag:yaml.org,2002:map', data)
+
+ def represent_set(self, data):
+ value = {}
+ for key in data:
+ value[key] = None
+ return self.represent_mapping('tag:yaml.org,2002:set', value)
+
+ def represent_date(self, data):
+ value = data.isoformat()
+ return self.represent_scalar('tag:yaml.org,2002:timestamp', value)
+
+ def represent_datetime(self, data):
+ value = data.isoformat(' ')
+ return self.represent_scalar('tag:yaml.org,2002:timestamp', value)
+
+ def represent_yaml_object(self, tag, data, cls, flow_style=None):
+ if hasattr(data, '__getstate__'):
+ state = data.__getstate__()
+ else:
+ state = data.__dict__.copy()
+ return self.represent_mapping(tag, state, flow_style=flow_style)
+
+ def represent_undefined(self, data):
+ raise RepresenterError("cannot represent an object", data)
+
+SafeRepresenter.add_representer(type(None),
+ SafeRepresenter.represent_none)
+
+SafeRepresenter.add_representer(str,
+ SafeRepresenter.represent_str)
+
+SafeRepresenter.add_representer(bytes,
+ SafeRepresenter.represent_binary)
+
+SafeRepresenter.add_representer(bool,
+ SafeRepresenter.represent_bool)
+
+SafeRepresenter.add_representer(int,
+ SafeRepresenter.represent_int)
+
+SafeRepresenter.add_representer(float,
+ SafeRepresenter.represent_float)
+
+SafeRepresenter.add_representer(list,
+ SafeRepresenter.represent_list)
+
+SafeRepresenter.add_representer(tuple,
+ SafeRepresenter.represent_list)
+
+SafeRepresenter.add_representer(dict,
+ SafeRepresenter.represent_dict)
+
+SafeRepresenter.add_representer(set,
+ SafeRepresenter.represent_set)
+
+SafeRepresenter.add_representer(datetime.date,
+ SafeRepresenter.represent_date)
+
+SafeRepresenter.add_representer(datetime.datetime,
+ SafeRepresenter.represent_datetime)
+
+SafeRepresenter.add_representer(None,
+ SafeRepresenter.represent_undefined)
+
+class Representer(SafeRepresenter):
+
+ def represent_complex(self, data):
+ if data.imag == 0.0:
+ data = '%r' % data.real
+ elif data.real == 0.0:
+ data = '%rj' % data.imag
+ elif data.imag > 0:
+ data = '%r+%rj' % (data.real, data.imag)
+ else:
+ data = '%r%rj' % (data.real, data.imag)
+ return self.represent_scalar('tag:yaml.org,2002:python/complex', data)
+
+ def represent_tuple(self, data):
+ return self.represent_sequence('tag:yaml.org,2002:python/tuple', data)
+
+ def represent_name(self, data):
+ name = '%s.%s' % (data.__module__, data.__name__)
+ return self.represent_scalar('tag:yaml.org,2002:python/name:'+name, '')
+
+ def represent_module(self, data):
+ return self.represent_scalar(
+ 'tag:yaml.org,2002:python/module:'+data.__name__, '')
+
+ def represent_object(self, data):
+ # We use __reduce__ API to save the data. data.__reduce__ returns
+ # a tuple of length 2-5:
+ # (function, args, state, listitems, dictitems)
+
+ # For reconstructing, we calls function(*args), then set its state,
+ # listitems, and dictitems if they are not None.
+
+ # A special case is when function.__name__ == '__newobj__'. In this
+ # case we create the object with args[0].__new__(*args).
+
+ # Another special case is when __reduce__ returns a string - we don't
+ # support it.
+
+ # We produce a !!python/object, !!python/object/new or
+ # !!python/object/apply node.
+
+ cls = type(data)
+ if cls in copyreg.dispatch_table:
+ reduce = copyreg.dispatch_table[cls](data)
+ elif hasattr(data, '__reduce_ex__'):
+ reduce = data.__reduce_ex__(2)
+ elif hasattr(data, '__reduce__'):
+ reduce = data.__reduce__()
+ else:
+ raise RepresenterError("cannot represent an object", data)
+ reduce = (list(reduce)+[None]*5)[:5]
+ function, args, state, listitems, dictitems = reduce
+ args = list(args)
+ if state is None:
+ state = {}
+ if listitems is not None:
+ listitems = list(listitems)
+ if dictitems is not None:
+ dictitems = dict(dictitems)
+ if function.__name__ == '__newobj__':
+ function = args[0]
+ args = args[1:]
+ tag = 'tag:yaml.org,2002:python/object/new:'
+ newobj = True
+ else:
+ tag = 'tag:yaml.org,2002:python/object/apply:'
+ newobj = False
+ function_name = '%s.%s' % (function.__module__, function.__name__)
+ if not args and not listitems and not dictitems \
+ and isinstance(state, dict) and newobj:
+ return self.represent_mapping(
+ 'tag:yaml.org,2002:python/object:'+function_name, state)
+ if not listitems and not dictitems \
+ and isinstance(state, dict) and not state:
+ return self.represent_sequence(tag+function_name, args)
+ value = {}
+ if args:
+ value['args'] = args
+ if state or not isinstance(state, dict):
+ value['state'] = state
+ if listitems:
+ value['listitems'] = listitems
+ if dictitems:
+ value['dictitems'] = dictitems
+ return self.represent_mapping(tag+function_name, value)
+
+ def represent_ordered_dict(self, data):
+ # Provide uniform representation across different Python versions.
+ data_type = type(data)
+ tag = 'tag:yaml.org,2002:python/object/apply:%s.%s' \
+ % (data_type.__module__, data_type.__name__)
+ items = [[key, value] for key, value in data.items()]
+ return self.represent_sequence(tag, [items])
+
+Representer.add_representer(complex,
+ Representer.represent_complex)
+
+Representer.add_representer(tuple,
+ Representer.represent_tuple)
+
+Representer.add_multi_representer(type,
+ Representer.represent_name)
+
+Representer.add_representer(collections.OrderedDict,
+ Representer.represent_ordered_dict)
+
+Representer.add_representer(types.FunctionType,
+ Representer.represent_name)
+
+Representer.add_representer(types.BuiltinFunctionType,
+ Representer.represent_name)
+
+Representer.add_representer(types.ModuleType,
+ Representer.represent_module)
+
+Representer.add_multi_representer(object,
+ Representer.represent_object)
+
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/resolver.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/resolver.py
new file mode 100644
index 0000000000000000000000000000000000000000..3522bdaaf6358110b608f4e6503b9d314c82d887
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/resolver.py
@@ -0,0 +1,227 @@
+
+__all__ = ['BaseResolver', 'Resolver']
+
+from .error import *
+from .nodes import *
+
+import re
+
+class ResolverError(YAMLError):
+ pass
+
+class BaseResolver:
+
+ DEFAULT_SCALAR_TAG = 'tag:yaml.org,2002:str'
+ DEFAULT_SEQUENCE_TAG = 'tag:yaml.org,2002:seq'
+ DEFAULT_MAPPING_TAG = 'tag:yaml.org,2002:map'
+
+ yaml_implicit_resolvers = {}
+ yaml_path_resolvers = {}
+
+ def __init__(self):
+ self.resolver_exact_paths = []
+ self.resolver_prefix_paths = []
+
+ @classmethod
+ def add_implicit_resolver(cls, tag, regexp, first):
+ if not 'yaml_implicit_resolvers' in cls.__dict__:
+ implicit_resolvers = {}
+ for key in cls.yaml_implicit_resolvers:
+ implicit_resolvers[key] = cls.yaml_implicit_resolvers[key][:]
+ cls.yaml_implicit_resolvers = implicit_resolvers
+ if first is None:
+ first = [None]
+ for ch in first:
+ cls.yaml_implicit_resolvers.setdefault(ch, []).append((tag, regexp))
+
+ @classmethod
+ def add_path_resolver(cls, tag, path, kind=None):
+ # Note: `add_path_resolver` is experimental. The API could be changed.
+ # `new_path` is a pattern that is matched against the path from the
+ # root to the node that is being considered. `node_path` elements are
+ # tuples `(node_check, index_check)`. `node_check` is a node class:
+ # `ScalarNode`, `SequenceNode`, `MappingNode` or `None`. `None`
+ # matches any kind of a node. `index_check` could be `None`, a boolean
+ # value, a string value, or a number. `None` and `False` match against
+ # any _value_ of sequence and mapping nodes. `True` matches against
+ # any _key_ of a mapping node. A string `index_check` matches against
+ # a mapping value that corresponds to a scalar key which content is
+ # equal to the `index_check` value. An integer `index_check` matches
+ # against a sequence value with the index equal to `index_check`.
+ if not 'yaml_path_resolvers' in cls.__dict__:
+ cls.yaml_path_resolvers = cls.yaml_path_resolvers.copy()
+ new_path = []
+ for element in path:
+ if isinstance(element, (list, tuple)):
+ if len(element) == 2:
+ node_check, index_check = element
+ elif len(element) == 1:
+ node_check = element[0]
+ index_check = True
+ else:
+ raise ResolverError("Invalid path element: %s" % element)
+ else:
+ node_check = None
+ index_check = element
+ if node_check is str:
+ node_check = ScalarNode
+ elif node_check is list:
+ node_check = SequenceNode
+ elif node_check is dict:
+ node_check = MappingNode
+ elif node_check not in [ScalarNode, SequenceNode, MappingNode] \
+ and not isinstance(node_check, str) \
+ and node_check is not None:
+ raise ResolverError("Invalid node checker: %s" % node_check)
+ if not isinstance(index_check, (str, int)) \
+ and index_check is not None:
+ raise ResolverError("Invalid index checker: %s" % index_check)
+ new_path.append((node_check, index_check))
+ if kind is str:
+ kind = ScalarNode
+ elif kind is list:
+ kind = SequenceNode
+ elif kind is dict:
+ kind = MappingNode
+ elif kind not in [ScalarNode, SequenceNode, MappingNode] \
+ and kind is not None:
+ raise ResolverError("Invalid node kind: %s" % kind)
+ cls.yaml_path_resolvers[tuple(new_path), kind] = tag
+
+ def descend_resolver(self, current_node, current_index):
+ if not self.yaml_path_resolvers:
+ return
+ exact_paths = {}
+ prefix_paths = []
+ if current_node:
+ depth = len(self.resolver_prefix_paths)
+ for path, kind in self.resolver_prefix_paths[-1]:
+ if self.check_resolver_prefix(depth, path, kind,
+ current_node, current_index):
+ if len(path) > depth:
+ prefix_paths.append((path, kind))
+ else:
+ exact_paths[kind] = self.yaml_path_resolvers[path, kind]
+ else:
+ for path, kind in self.yaml_path_resolvers:
+ if not path:
+ exact_paths[kind] = self.yaml_path_resolvers[path, kind]
+ else:
+ prefix_paths.append((path, kind))
+ self.resolver_exact_paths.append(exact_paths)
+ self.resolver_prefix_paths.append(prefix_paths)
+
+ def ascend_resolver(self):
+ if not self.yaml_path_resolvers:
+ return
+ self.resolver_exact_paths.pop()
+ self.resolver_prefix_paths.pop()
+
+ def check_resolver_prefix(self, depth, path, kind,
+ current_node, current_index):
+ node_check, index_check = path[depth-1]
+ if isinstance(node_check, str):
+ if current_node.tag != node_check:
+ return
+ elif node_check is not None:
+ if not isinstance(current_node, node_check):
+ return
+ if index_check is True and current_index is not None:
+ return
+ if (index_check is False or index_check is None) \
+ and current_index is None:
+ return
+ if isinstance(index_check, str):
+ if not (isinstance(current_index, ScalarNode)
+ and index_check == current_index.value):
+ return
+ elif isinstance(index_check, int) and not isinstance(index_check, bool):
+ if index_check != current_index:
+ return
+ return True
+
+ def resolve(self, kind, value, implicit):
+ if kind is ScalarNode and implicit[0]:
+ if value == '':
+ resolvers = self.yaml_implicit_resolvers.get('', [])
+ else:
+ resolvers = self.yaml_implicit_resolvers.get(value[0], [])
+ wildcard_resolvers = self.yaml_implicit_resolvers.get(None, [])
+ for tag, regexp in resolvers + wildcard_resolvers:
+ if regexp.match(value):
+ return tag
+ implicit = implicit[1]
+ if self.yaml_path_resolvers:
+ exact_paths = self.resolver_exact_paths[-1]
+ if kind in exact_paths:
+ return exact_paths[kind]
+ if None in exact_paths:
+ return exact_paths[None]
+ if kind is ScalarNode:
+ return self.DEFAULT_SCALAR_TAG
+ elif kind is SequenceNode:
+ return self.DEFAULT_SEQUENCE_TAG
+ elif kind is MappingNode:
+ return self.DEFAULT_MAPPING_TAG
+
+class Resolver(BaseResolver):
+ pass
+
+Resolver.add_implicit_resolver(
+ 'tag:yaml.org,2002:bool',
+ re.compile(r'''^(?:yes|Yes|YES|no|No|NO
+ |true|True|TRUE|false|False|FALSE
+ |on|On|ON|off|Off|OFF)$''', re.X),
+ list('yYnNtTfFoO'))
+
+Resolver.add_implicit_resolver(
+ 'tag:yaml.org,2002:float',
+ re.compile(r'''^(?:[-+]?(?:[0-9][0-9_]*)\.[0-9_]*(?:[eE][-+][0-9]+)?
+ |\.[0-9][0-9_]*(?:[eE][-+][0-9]+)?
+ |[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*
+ |[-+]?\.(?:inf|Inf|INF)
+ |\.(?:nan|NaN|NAN))$''', re.X),
+ list('-+0123456789.'))
+
+Resolver.add_implicit_resolver(
+ 'tag:yaml.org,2002:int',
+ re.compile(r'''^(?:[-+]?0b[0-1_]+
+ |[-+]?0[0-7_]+
+ |[-+]?(?:0|[1-9][0-9_]*)
+ |[-+]?0x[0-9a-fA-F_]+
+ |[-+]?[1-9][0-9_]*(?::[0-5]?[0-9])+)$''', re.X),
+ list('-+0123456789'))
+
+Resolver.add_implicit_resolver(
+ 'tag:yaml.org,2002:merge',
+ re.compile(r'^(?:<<)$'),
+ ['<'])
+
+Resolver.add_implicit_resolver(
+ 'tag:yaml.org,2002:null',
+ re.compile(r'''^(?: ~
+ |null|Null|NULL
+ | )$''', re.X),
+ ['~', 'n', 'N', ''])
+
+Resolver.add_implicit_resolver(
+ 'tag:yaml.org,2002:timestamp',
+ re.compile(r'''^(?:[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]
+ |[0-9][0-9][0-9][0-9] -[0-9][0-9]? -[0-9][0-9]?
+ (?:[Tt]|[ \t]+)[0-9][0-9]?
+ :[0-9][0-9] :[0-9][0-9] (?:\.[0-9]*)?
+ (?:[ \t]*(?:Z|[-+][0-9][0-9]?(?::[0-9][0-9])?))?)$''', re.X),
+ list('0123456789'))
+
+Resolver.add_implicit_resolver(
+ 'tag:yaml.org,2002:value',
+ re.compile(r'^(?:=)$'),
+ ['='])
+
+# The following resolver is only for documentation purposes. It cannot work
+# because plain scalars cannot start with '!', '&', or '*'.
+Resolver.add_implicit_resolver(
+ 'tag:yaml.org,2002:yaml',
+ re.compile(r'^(?:!|&|\*)$'),
+ list('!&*'))
+
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/scanner.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/scanner.py
new file mode 100644
index 0000000000000000000000000000000000000000..de925b07f1eaec33c9c305a8a69f9eb7ac5983c5
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/scanner.py
@@ -0,0 +1,1435 @@
+
+# Scanner produces tokens of the following types:
+# STREAM-START
+# STREAM-END
+# DIRECTIVE(name, value)
+# DOCUMENT-START
+# DOCUMENT-END
+# BLOCK-SEQUENCE-START
+# BLOCK-MAPPING-START
+# BLOCK-END
+# FLOW-SEQUENCE-START
+# FLOW-MAPPING-START
+# FLOW-SEQUENCE-END
+# FLOW-MAPPING-END
+# BLOCK-ENTRY
+# FLOW-ENTRY
+# KEY
+# VALUE
+# ALIAS(value)
+# ANCHOR(value)
+# TAG(value)
+# SCALAR(value, plain, style)
+#
+# Read comments in the Scanner code for more details.
+#
+
+__all__ = ['Scanner', 'ScannerError']
+
+from .error import MarkedYAMLError
+from .tokens import *
+
+class ScannerError(MarkedYAMLError):
+ pass
+
+class SimpleKey:
+ # See below simple keys treatment.
+
+ def __init__(self, token_number, required, index, line, column, mark):
+ self.token_number = token_number
+ self.required = required
+ self.index = index
+ self.line = line
+ self.column = column
+ self.mark = mark
+
+class Scanner:
+
+ def __init__(self):
+ """Initialize the scanner."""
+ # It is assumed that Scanner and Reader will have a common descendant.
+ # Reader do the dirty work of checking for BOM and converting the
+ # input data to Unicode. It also adds NUL to the end.
+ #
+ # Reader supports the following methods
+ # self.peek(i=0) # peek the next i-th character
+ # self.prefix(l=1) # peek the next l characters
+ # self.forward(l=1) # read the next l characters and move the pointer.
+
+ # Had we reached the end of the stream?
+ self.done = False
+
+ # The number of unclosed '{' and '['. `flow_level == 0` means block
+ # context.
+ self.flow_level = 0
+
+ # List of processed tokens that are not yet emitted.
+ self.tokens = []
+
+ # Add the STREAM-START token.
+ self.fetch_stream_start()
+
+ # Number of tokens that were emitted through the `get_token` method.
+ self.tokens_taken = 0
+
+ # The current indentation level.
+ self.indent = -1
+
+ # Past indentation levels.
+ self.indents = []
+
+ # Variables related to simple keys treatment.
+
+ # A simple key is a key that is not denoted by the '?' indicator.
+ # Example of simple keys:
+ # ---
+ # block simple key: value
+ # ? not a simple key:
+ # : { flow simple key: value }
+ # We emit the KEY token before all keys, so when we find a potential
+ # simple key, we try to locate the corresponding ':' indicator.
+ # Simple keys should be limited to a single line and 1024 characters.
+
+ # Can a simple key start at the current position? A simple key may
+ # start:
+ # - at the beginning of the line, not counting indentation spaces
+ # (in block context),
+ # - after '{', '[', ',' (in the flow context),
+ # - after '?', ':', '-' (in the block context).
+ # In the block context, this flag also signifies if a block collection
+ # may start at the current position.
+ self.allow_simple_key = True
+
+ # Keep track of possible simple keys. This is a dictionary. The key
+ # is `flow_level`; there can be no more that one possible simple key
+ # for each level. The value is a SimpleKey record:
+ # (token_number, required, index, line, column, mark)
+ # A simple key may start with ALIAS, ANCHOR, TAG, SCALAR(flow),
+ # '[', or '{' tokens.
+ self.possible_simple_keys = {}
+
+ # Public methods.
+
+ def check_token(self, *choices):
+ # Check if the next token is one of the given types.
+ while self.need_more_tokens():
+ self.fetch_more_tokens()
+ if self.tokens:
+ if not choices:
+ return True
+ for choice in choices:
+ if isinstance(self.tokens[0], choice):
+ return True
+ return False
+
+ def peek_token(self):
+ # Return the next token, but do not delete if from the queue.
+ # Return None if no more tokens.
+ while self.need_more_tokens():
+ self.fetch_more_tokens()
+ if self.tokens:
+ return self.tokens[0]
+ else:
+ return None
+
+ def get_token(self):
+ # Return the next token.
+ while self.need_more_tokens():
+ self.fetch_more_tokens()
+ if self.tokens:
+ self.tokens_taken += 1
+ return self.tokens.pop(0)
+
+ # Private methods.
+
+ def need_more_tokens(self):
+ if self.done:
+ return False
+ if not self.tokens:
+ return True
+ # The current token may be a potential simple key, so we
+ # need to look further.
+ self.stale_possible_simple_keys()
+ if self.next_possible_simple_key() == self.tokens_taken:
+ return True
+
+ def fetch_more_tokens(self):
+
+ # Eat whitespaces and comments until we reach the next token.
+ self.scan_to_next_token()
+
+ # Remove obsolete possible simple keys.
+ self.stale_possible_simple_keys()
+
+ # Compare the current indentation and column. It may add some tokens
+ # and decrease the current indentation level.
+ self.unwind_indent(self.column)
+
+ # Peek the next character.
+ ch = self.peek()
+
+ # Is it the end of stream?
+ if ch == '\0':
+ return self.fetch_stream_end()
+
+ # Is it a directive?
+ if ch == '%' and self.check_directive():
+ return self.fetch_directive()
+
+ # Is it the document start?
+ if ch == '-' and self.check_document_start():
+ return self.fetch_document_start()
+
+ # Is it the document end?
+ if ch == '.' and self.check_document_end():
+ return self.fetch_document_end()
+
+ # TODO: support for BOM within a stream.
+ #if ch == '\uFEFF':
+ # return self.fetch_bom() <-- issue BOMToken
+
+ # Note: the order of the following checks is NOT significant.
+
+ # Is it the flow sequence start indicator?
+ if ch == '[':
+ return self.fetch_flow_sequence_start()
+
+ # Is it the flow mapping start indicator?
+ if ch == '{':
+ return self.fetch_flow_mapping_start()
+
+ # Is it the flow sequence end indicator?
+ if ch == ']':
+ return self.fetch_flow_sequence_end()
+
+ # Is it the flow mapping end indicator?
+ if ch == '}':
+ return self.fetch_flow_mapping_end()
+
+ # Is it the flow entry indicator?
+ if ch == ',':
+ return self.fetch_flow_entry()
+
+ # Is it the block entry indicator?
+ if ch == '-' and self.check_block_entry():
+ return self.fetch_block_entry()
+
+ # Is it the key indicator?
+ if ch == '?' and self.check_key():
+ return self.fetch_key()
+
+ # Is it the value indicator?
+ if ch == ':' and self.check_value():
+ return self.fetch_value()
+
+ # Is it an alias?
+ if ch == '*':
+ return self.fetch_alias()
+
+ # Is it an anchor?
+ if ch == '&':
+ return self.fetch_anchor()
+
+ # Is it a tag?
+ if ch == '!':
+ return self.fetch_tag()
+
+ # Is it a literal scalar?
+ if ch == '|' and not self.flow_level:
+ return self.fetch_literal()
+
+ # Is it a folded scalar?
+ if ch == '>' and not self.flow_level:
+ return self.fetch_folded()
+
+ # Is it a single quoted scalar?
+ if ch == '\'':
+ return self.fetch_single()
+
+ # Is it a double quoted scalar?
+ if ch == '\"':
+ return self.fetch_double()
+
+ # It must be a plain scalar then.
+ if self.check_plain():
+ return self.fetch_plain()
+
+ # No? It's an error. Let's produce a nice error message.
+ raise ScannerError("while scanning for the next token", None,
+ "found character %r that cannot start any token" % ch,
+ self.get_mark())
+
+ # Simple keys treatment.
+
+ def next_possible_simple_key(self):
+ # Return the number of the nearest possible simple key. Actually we
+ # don't need to loop through the whole dictionary. We may replace it
+ # with the following code:
+ # if not self.possible_simple_keys:
+ # return None
+ # return self.possible_simple_keys[
+ # min(self.possible_simple_keys.keys())].token_number
+ min_token_number = None
+ for level in self.possible_simple_keys:
+ key = self.possible_simple_keys[level]
+ if min_token_number is None or key.token_number < min_token_number:
+ min_token_number = key.token_number
+ return min_token_number
+
+ def stale_possible_simple_keys(self):
+ # Remove entries that are no longer possible simple keys. According to
+ # the YAML specification, simple keys
+ # - should be limited to a single line,
+ # - should be no longer than 1024 characters.
+ # Disabling this procedure will allow simple keys of any length and
+ # height (may cause problems if indentation is broken though).
+ for level in list(self.possible_simple_keys):
+ key = self.possible_simple_keys[level]
+ if key.line != self.line \
+ or self.index-key.index > 1024:
+ if key.required:
+ raise ScannerError("while scanning a simple key", key.mark,
+ "could not find expected ':'", self.get_mark())
+ del self.possible_simple_keys[level]
+
+ def save_possible_simple_key(self):
+ # The next token may start a simple key. We check if it's possible
+ # and save its position. This function is called for
+ # ALIAS, ANCHOR, TAG, SCALAR(flow), '[', and '{'.
+
+ # Check if a simple key is required at the current position.
+ required = not self.flow_level and self.indent == self.column
+
+ # The next token might be a simple key. Let's save it's number and
+ # position.
+ if self.allow_simple_key:
+ self.remove_possible_simple_key()
+ token_number = self.tokens_taken+len(self.tokens)
+ key = SimpleKey(token_number, required,
+ self.index, self.line, self.column, self.get_mark())
+ self.possible_simple_keys[self.flow_level] = key
+
+ def remove_possible_simple_key(self):
+ # Remove the saved possible key position at the current flow level.
+ if self.flow_level in self.possible_simple_keys:
+ key = self.possible_simple_keys[self.flow_level]
+
+ if key.required:
+ raise ScannerError("while scanning a simple key", key.mark,
+ "could not find expected ':'", self.get_mark())
+
+ del self.possible_simple_keys[self.flow_level]
+
+ # Indentation functions.
+
+ def unwind_indent(self, column):
+
+ ## In flow context, tokens should respect indentation.
+ ## Actually the condition should be `self.indent >= column` according to
+ ## the spec. But this condition will prohibit intuitively correct
+ ## constructions such as
+ ## key : {
+ ## }
+ #if self.flow_level and self.indent > column:
+ # raise ScannerError(None, None,
+ # "invalid indentation or unclosed '[' or '{'",
+ # self.get_mark())
+
+ # In the flow context, indentation is ignored. We make the scanner less
+ # restrictive then specification requires.
+ if self.flow_level:
+ return
+
+ # In block context, we may need to issue the BLOCK-END tokens.
+ while self.indent > column:
+ mark = self.get_mark()
+ self.indent = self.indents.pop()
+ self.tokens.append(BlockEndToken(mark, mark))
+
+ def add_indent(self, column):
+ # Check if we need to increase indentation.
+ if self.indent < column:
+ self.indents.append(self.indent)
+ self.indent = column
+ return True
+ return False
+
+ # Fetchers.
+
+ def fetch_stream_start(self):
+ # We always add STREAM-START as the first token and STREAM-END as the
+ # last token.
+
+ # Read the token.
+ mark = self.get_mark()
+
+ # Add STREAM-START.
+ self.tokens.append(StreamStartToken(mark, mark,
+ encoding=self.encoding))
+
+
+ def fetch_stream_end(self):
+
+ # Set the current indentation to -1.
+ self.unwind_indent(-1)
+
+ # Reset simple keys.
+ self.remove_possible_simple_key()
+ self.allow_simple_key = False
+ self.possible_simple_keys = {}
+
+ # Read the token.
+ mark = self.get_mark()
+
+ # Add STREAM-END.
+ self.tokens.append(StreamEndToken(mark, mark))
+
+ # The steam is finished.
+ self.done = True
+
+ def fetch_directive(self):
+
+ # Set the current indentation to -1.
+ self.unwind_indent(-1)
+
+ # Reset simple keys.
+ self.remove_possible_simple_key()
+ self.allow_simple_key = False
+
+ # Scan and add DIRECTIVE.
+ self.tokens.append(self.scan_directive())
+
+ def fetch_document_start(self):
+ self.fetch_document_indicator(DocumentStartToken)
+
+ def fetch_document_end(self):
+ self.fetch_document_indicator(DocumentEndToken)
+
+ def fetch_document_indicator(self, TokenClass):
+
+ # Set the current indentation to -1.
+ self.unwind_indent(-1)
+
+ # Reset simple keys. Note that there could not be a block collection
+ # after '---'.
+ self.remove_possible_simple_key()
+ self.allow_simple_key = False
+
+ # Add DOCUMENT-START or DOCUMENT-END.
+ start_mark = self.get_mark()
+ self.forward(3)
+ end_mark = self.get_mark()
+ self.tokens.append(TokenClass(start_mark, end_mark))
+
+ def fetch_flow_sequence_start(self):
+ self.fetch_flow_collection_start(FlowSequenceStartToken)
+
+ def fetch_flow_mapping_start(self):
+ self.fetch_flow_collection_start(FlowMappingStartToken)
+
+ def fetch_flow_collection_start(self, TokenClass):
+
+ # '[' and '{' may start a simple key.
+ self.save_possible_simple_key()
+
+ # Increase the flow level.
+ self.flow_level += 1
+
+ # Simple keys are allowed after '[' and '{'.
+ self.allow_simple_key = True
+
+ # Add FLOW-SEQUENCE-START or FLOW-MAPPING-START.
+ start_mark = self.get_mark()
+ self.forward()
+ end_mark = self.get_mark()
+ self.tokens.append(TokenClass(start_mark, end_mark))
+
+ def fetch_flow_sequence_end(self):
+ self.fetch_flow_collection_end(FlowSequenceEndToken)
+
+ def fetch_flow_mapping_end(self):
+ self.fetch_flow_collection_end(FlowMappingEndToken)
+
+ def fetch_flow_collection_end(self, TokenClass):
+
+ # Reset possible simple key on the current level.
+ self.remove_possible_simple_key()
+
+ # Decrease the flow level.
+ self.flow_level -= 1
+
+ # No simple keys after ']' or '}'.
+ self.allow_simple_key = False
+
+ # Add FLOW-SEQUENCE-END or FLOW-MAPPING-END.
+ start_mark = self.get_mark()
+ self.forward()
+ end_mark = self.get_mark()
+ self.tokens.append(TokenClass(start_mark, end_mark))
+
+ def fetch_flow_entry(self):
+
+ # Simple keys are allowed after ','.
+ self.allow_simple_key = True
+
+ # Reset possible simple key on the current level.
+ self.remove_possible_simple_key()
+
+ # Add FLOW-ENTRY.
+ start_mark = self.get_mark()
+ self.forward()
+ end_mark = self.get_mark()
+ self.tokens.append(FlowEntryToken(start_mark, end_mark))
+
+ def fetch_block_entry(self):
+
+ # Block context needs additional checks.
+ if not self.flow_level:
+
+ # Are we allowed to start a new entry?
+ if not self.allow_simple_key:
+ raise ScannerError(None, None,
+ "sequence entries are not allowed here",
+ self.get_mark())
+
+ # We may need to add BLOCK-SEQUENCE-START.
+ if self.add_indent(self.column):
+ mark = self.get_mark()
+ self.tokens.append(BlockSequenceStartToken(mark, mark))
+
+ # It's an error for the block entry to occur in the flow context,
+ # but we let the parser detect this.
+ else:
+ pass
+
+ # Simple keys are allowed after '-'.
+ self.allow_simple_key = True
+
+ # Reset possible simple key on the current level.
+ self.remove_possible_simple_key()
+
+ # Add BLOCK-ENTRY.
+ start_mark = self.get_mark()
+ self.forward()
+ end_mark = self.get_mark()
+ self.tokens.append(BlockEntryToken(start_mark, end_mark))
+
+ def fetch_key(self):
+
+ # Block context needs additional checks.
+ if not self.flow_level:
+
+ # Are we allowed to start a key (not necessary a simple)?
+ if not self.allow_simple_key:
+ raise ScannerError(None, None,
+ "mapping keys are not allowed here",
+ self.get_mark())
+
+ # We may need to add BLOCK-MAPPING-START.
+ if self.add_indent(self.column):
+ mark = self.get_mark()
+ self.tokens.append(BlockMappingStartToken(mark, mark))
+
+ # Simple keys are allowed after '?' in the block context.
+ self.allow_simple_key = not self.flow_level
+
+ # Reset possible simple key on the current level.
+ self.remove_possible_simple_key()
+
+ # Add KEY.
+ start_mark = self.get_mark()
+ self.forward()
+ end_mark = self.get_mark()
+ self.tokens.append(KeyToken(start_mark, end_mark))
+
+ def fetch_value(self):
+
+ # Do we determine a simple key?
+ if self.flow_level in self.possible_simple_keys:
+
+ # Add KEY.
+ key = self.possible_simple_keys[self.flow_level]
+ del self.possible_simple_keys[self.flow_level]
+ self.tokens.insert(key.token_number-self.tokens_taken,
+ KeyToken(key.mark, key.mark))
+
+ # If this key starts a new block mapping, we need to add
+ # BLOCK-MAPPING-START.
+ if not self.flow_level:
+ if self.add_indent(key.column):
+ self.tokens.insert(key.token_number-self.tokens_taken,
+ BlockMappingStartToken(key.mark, key.mark))
+
+ # There cannot be two simple keys one after another.
+ self.allow_simple_key = False
+
+ # It must be a part of a complex key.
+ else:
+
+ # Block context needs additional checks.
+ # (Do we really need them? They will be caught by the parser
+ # anyway.)
+ if not self.flow_level:
+
+ # We are allowed to start a complex value if and only if
+ # we can start a simple key.
+ if not self.allow_simple_key:
+ raise ScannerError(None, None,
+ "mapping values are not allowed here",
+ self.get_mark())
+
+ # If this value starts a new block mapping, we need to add
+ # BLOCK-MAPPING-START. It will be detected as an error later by
+ # the parser.
+ if not self.flow_level:
+ if self.add_indent(self.column):
+ mark = self.get_mark()
+ self.tokens.append(BlockMappingStartToken(mark, mark))
+
+ # Simple keys are allowed after ':' in the block context.
+ self.allow_simple_key = not self.flow_level
+
+ # Reset possible simple key on the current level.
+ self.remove_possible_simple_key()
+
+ # Add VALUE.
+ start_mark = self.get_mark()
+ self.forward()
+ end_mark = self.get_mark()
+ self.tokens.append(ValueToken(start_mark, end_mark))
+
+ def fetch_alias(self):
+
+ # ALIAS could be a simple key.
+ self.save_possible_simple_key()
+
+ # No simple keys after ALIAS.
+ self.allow_simple_key = False
+
+ # Scan and add ALIAS.
+ self.tokens.append(self.scan_anchor(AliasToken))
+
+ def fetch_anchor(self):
+
+ # ANCHOR could start a simple key.
+ self.save_possible_simple_key()
+
+ # No simple keys after ANCHOR.
+ self.allow_simple_key = False
+
+ # Scan and add ANCHOR.
+ self.tokens.append(self.scan_anchor(AnchorToken))
+
+ def fetch_tag(self):
+
+ # TAG could start a simple key.
+ self.save_possible_simple_key()
+
+ # No simple keys after TAG.
+ self.allow_simple_key = False
+
+ # Scan and add TAG.
+ self.tokens.append(self.scan_tag())
+
+ def fetch_literal(self):
+ self.fetch_block_scalar(style='|')
+
+ def fetch_folded(self):
+ self.fetch_block_scalar(style='>')
+
+ def fetch_block_scalar(self, style):
+
+ # A simple key may follow a block scalar.
+ self.allow_simple_key = True
+
+ # Reset possible simple key on the current level.
+ self.remove_possible_simple_key()
+
+ # Scan and add SCALAR.
+ self.tokens.append(self.scan_block_scalar(style))
+
+ def fetch_single(self):
+ self.fetch_flow_scalar(style='\'')
+
+ def fetch_double(self):
+ self.fetch_flow_scalar(style='"')
+
+ def fetch_flow_scalar(self, style):
+
+ # A flow scalar could be a simple key.
+ self.save_possible_simple_key()
+
+ # No simple keys after flow scalars.
+ self.allow_simple_key = False
+
+ # Scan and add SCALAR.
+ self.tokens.append(self.scan_flow_scalar(style))
+
+ def fetch_plain(self):
+
+ # A plain scalar could be a simple key.
+ self.save_possible_simple_key()
+
+ # No simple keys after plain scalars. But note that `scan_plain` will
+ # change this flag if the scan is finished at the beginning of the
+ # line.
+ self.allow_simple_key = False
+
+ # Scan and add SCALAR. May change `allow_simple_key`.
+ self.tokens.append(self.scan_plain())
+
+ # Checkers.
+
+ def check_directive(self):
+
+ # DIRECTIVE: ^ '%' ...
+ # The '%' indicator is already checked.
+ if self.column == 0:
+ return True
+
+ def check_document_start(self):
+
+ # DOCUMENT-START: ^ '---' (' '|'\n')
+ if self.column == 0:
+ if self.prefix(3) == '---' \
+ and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029':
+ return True
+
+ def check_document_end(self):
+
+ # DOCUMENT-END: ^ '...' (' '|'\n')
+ if self.column == 0:
+ if self.prefix(3) == '...' \
+ and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029':
+ return True
+
+ def check_block_entry(self):
+
+ # BLOCK-ENTRY: '-' (' '|'\n')
+ return self.peek(1) in '\0 \t\r\n\x85\u2028\u2029'
+
+ def check_key(self):
+
+ # KEY(flow context): '?'
+ if self.flow_level:
+ return True
+
+ # KEY(block context): '?' (' '|'\n')
+ else:
+ return self.peek(1) in '\0 \t\r\n\x85\u2028\u2029'
+
+ def check_value(self):
+
+ # VALUE(flow context): ':'
+ if self.flow_level:
+ return True
+
+ # VALUE(block context): ':' (' '|'\n')
+ else:
+ return self.peek(1) in '\0 \t\r\n\x85\u2028\u2029'
+
+ def check_plain(self):
+
+ # A plain scalar may start with any non-space character except:
+ # '-', '?', ':', ',', '[', ']', '{', '}',
+ # '#', '&', '*', '!', '|', '>', '\'', '\"',
+ # '%', '@', '`'.
+ #
+ # It may also start with
+ # '-', '?', ':'
+ # if it is followed by a non-space character.
+ #
+ # Note that we limit the last rule to the block context (except the
+ # '-' character) because we want the flow context to be space
+ # independent.
+ ch = self.peek()
+ return ch not in '\0 \t\r\n\x85\u2028\u2029-?:,[]{}#&*!|>\'\"%@`' \
+ or (self.peek(1) not in '\0 \t\r\n\x85\u2028\u2029'
+ and (ch == '-' or (not self.flow_level and ch in '?:')))
+
+ # Scanners.
+
+ def scan_to_next_token(self):
+ # We ignore spaces, line breaks and comments.
+ # If we find a line break in the block context, we set the flag
+ # `allow_simple_key` on.
+ # The byte order mark is stripped if it's the first character in the
+ # stream. We do not yet support BOM inside the stream as the
+ # specification requires. Any such mark will be considered as a part
+ # of the document.
+ #
+ # TODO: We need to make tab handling rules more sane. A good rule is
+ # Tabs cannot precede tokens
+ # BLOCK-SEQUENCE-START, BLOCK-MAPPING-START, BLOCK-END,
+ # KEY(block), VALUE(block), BLOCK-ENTRY
+ # So the checking code is
+ # if :
+ # self.allow_simple_keys = False
+ # We also need to add the check for `allow_simple_keys == True` to
+ # `unwind_indent` before issuing BLOCK-END.
+ # Scanners for block, flow, and plain scalars need to be modified.
+
+ if self.index == 0 and self.peek() == '\uFEFF':
+ self.forward()
+ found = False
+ while not found:
+ while self.peek() == ' ':
+ self.forward()
+ if self.peek() == '#':
+ while self.peek() not in '\0\r\n\x85\u2028\u2029':
+ self.forward()
+ if self.scan_line_break():
+ if not self.flow_level:
+ self.allow_simple_key = True
+ else:
+ found = True
+
+ def scan_directive(self):
+ # See the specification for details.
+ start_mark = self.get_mark()
+ self.forward()
+ name = self.scan_directive_name(start_mark)
+ value = None
+ if name == 'YAML':
+ value = self.scan_yaml_directive_value(start_mark)
+ end_mark = self.get_mark()
+ elif name == 'TAG':
+ value = self.scan_tag_directive_value(start_mark)
+ end_mark = self.get_mark()
+ else:
+ end_mark = self.get_mark()
+ while self.peek() not in '\0\r\n\x85\u2028\u2029':
+ self.forward()
+ self.scan_directive_ignored_line(start_mark)
+ return DirectiveToken(name, value, start_mark, end_mark)
+
+ def scan_directive_name(self, start_mark):
+ # See the specification for details.
+ length = 0
+ ch = self.peek(length)
+ while '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z' \
+ or ch in '-_':
+ length += 1
+ ch = self.peek(length)
+ if not length:
+ raise ScannerError("while scanning a directive", start_mark,
+ "expected alphabetic or numeric character, but found %r"
+ % ch, self.get_mark())
+ value = self.prefix(length)
+ self.forward(length)
+ ch = self.peek()
+ if ch not in '\0 \r\n\x85\u2028\u2029':
+ raise ScannerError("while scanning a directive", start_mark,
+ "expected alphabetic or numeric character, but found %r"
+ % ch, self.get_mark())
+ return value
+
+ def scan_yaml_directive_value(self, start_mark):
+ # See the specification for details.
+ while self.peek() == ' ':
+ self.forward()
+ major = self.scan_yaml_directive_number(start_mark)
+ if self.peek() != '.':
+ raise ScannerError("while scanning a directive", start_mark,
+ "expected a digit or '.', but found %r" % self.peek(),
+ self.get_mark())
+ self.forward()
+ minor = self.scan_yaml_directive_number(start_mark)
+ if self.peek() not in '\0 \r\n\x85\u2028\u2029':
+ raise ScannerError("while scanning a directive", start_mark,
+ "expected a digit or ' ', but found %r" % self.peek(),
+ self.get_mark())
+ return (major, minor)
+
+ def scan_yaml_directive_number(self, start_mark):
+ # See the specification for details.
+ ch = self.peek()
+ if not ('0' <= ch <= '9'):
+ raise ScannerError("while scanning a directive", start_mark,
+ "expected a digit, but found %r" % ch, self.get_mark())
+ length = 0
+ while '0' <= self.peek(length) <= '9':
+ length += 1
+ value = int(self.prefix(length))
+ self.forward(length)
+ return value
+
+ def scan_tag_directive_value(self, start_mark):
+ # See the specification for details.
+ while self.peek() == ' ':
+ self.forward()
+ handle = self.scan_tag_directive_handle(start_mark)
+ while self.peek() == ' ':
+ self.forward()
+ prefix = self.scan_tag_directive_prefix(start_mark)
+ return (handle, prefix)
+
+ def scan_tag_directive_handle(self, start_mark):
+ # See the specification for details.
+ value = self.scan_tag_handle('directive', start_mark)
+ ch = self.peek()
+ if ch != ' ':
+ raise ScannerError("while scanning a directive", start_mark,
+ "expected ' ', but found %r" % ch, self.get_mark())
+ return value
+
+ def scan_tag_directive_prefix(self, start_mark):
+ # See the specification for details.
+ value = self.scan_tag_uri('directive', start_mark)
+ ch = self.peek()
+ if ch not in '\0 \r\n\x85\u2028\u2029':
+ raise ScannerError("while scanning a directive", start_mark,
+ "expected ' ', but found %r" % ch, self.get_mark())
+ return value
+
+ def scan_directive_ignored_line(self, start_mark):
+ # See the specification for details.
+ while self.peek() == ' ':
+ self.forward()
+ if self.peek() == '#':
+ while self.peek() not in '\0\r\n\x85\u2028\u2029':
+ self.forward()
+ ch = self.peek()
+ if ch not in '\0\r\n\x85\u2028\u2029':
+ raise ScannerError("while scanning a directive", start_mark,
+ "expected a comment or a line break, but found %r"
+ % ch, self.get_mark())
+ self.scan_line_break()
+
+ def scan_anchor(self, TokenClass):
+ # The specification does not restrict characters for anchors and
+ # aliases. This may lead to problems, for instance, the document:
+ # [ *alias, value ]
+ # can be interpreted in two ways, as
+ # [ "value" ]
+ # and
+ # [ *alias , "value" ]
+ # Therefore we restrict aliases to numbers and ASCII letters.
+ start_mark = self.get_mark()
+ indicator = self.peek()
+ if indicator == '*':
+ name = 'alias'
+ else:
+ name = 'anchor'
+ self.forward()
+ length = 0
+ ch = self.peek(length)
+ while '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z' \
+ or ch in '-_':
+ length += 1
+ ch = self.peek(length)
+ if not length:
+ raise ScannerError("while scanning an %s" % name, start_mark,
+ "expected alphabetic or numeric character, but found %r"
+ % ch, self.get_mark())
+ value = self.prefix(length)
+ self.forward(length)
+ ch = self.peek()
+ if ch not in '\0 \t\r\n\x85\u2028\u2029?:,]}%@`':
+ raise ScannerError("while scanning an %s" % name, start_mark,
+ "expected alphabetic or numeric character, but found %r"
+ % ch, self.get_mark())
+ end_mark = self.get_mark()
+ return TokenClass(value, start_mark, end_mark)
+
+ def scan_tag(self):
+ # See the specification for details.
+ start_mark = self.get_mark()
+ ch = self.peek(1)
+ if ch == '<':
+ handle = None
+ self.forward(2)
+ suffix = self.scan_tag_uri('tag', start_mark)
+ if self.peek() != '>':
+ raise ScannerError("while parsing a tag", start_mark,
+ "expected '>', but found %r" % self.peek(),
+ self.get_mark())
+ self.forward()
+ elif ch in '\0 \t\r\n\x85\u2028\u2029':
+ handle = None
+ suffix = '!'
+ self.forward()
+ else:
+ length = 1
+ use_handle = False
+ while ch not in '\0 \r\n\x85\u2028\u2029':
+ if ch == '!':
+ use_handle = True
+ break
+ length += 1
+ ch = self.peek(length)
+ handle = '!'
+ if use_handle:
+ handle = self.scan_tag_handle('tag', start_mark)
+ else:
+ handle = '!'
+ self.forward()
+ suffix = self.scan_tag_uri('tag', start_mark)
+ ch = self.peek()
+ if ch not in '\0 \r\n\x85\u2028\u2029':
+ raise ScannerError("while scanning a tag", start_mark,
+ "expected ' ', but found %r" % ch, self.get_mark())
+ value = (handle, suffix)
+ end_mark = self.get_mark()
+ return TagToken(value, start_mark, end_mark)
+
+ def scan_block_scalar(self, style):
+ # See the specification for details.
+
+ if style == '>':
+ folded = True
+ else:
+ folded = False
+
+ chunks = []
+ start_mark = self.get_mark()
+
+ # Scan the header.
+ self.forward()
+ chomping, increment = self.scan_block_scalar_indicators(start_mark)
+ self.scan_block_scalar_ignored_line(start_mark)
+
+ # Determine the indentation level and go to the first non-empty line.
+ min_indent = self.indent+1
+ if min_indent < 1:
+ min_indent = 1
+ if increment is None:
+ breaks, max_indent, end_mark = self.scan_block_scalar_indentation()
+ indent = max(min_indent, max_indent)
+ else:
+ indent = min_indent+increment-1
+ breaks, end_mark = self.scan_block_scalar_breaks(indent)
+ line_break = ''
+
+ # Scan the inner part of the block scalar.
+ while self.column == indent and self.peek() != '\0':
+ chunks.extend(breaks)
+ leading_non_space = self.peek() not in ' \t'
+ length = 0
+ while self.peek(length) not in '\0\r\n\x85\u2028\u2029':
+ length += 1
+ chunks.append(self.prefix(length))
+ self.forward(length)
+ line_break = self.scan_line_break()
+ breaks, end_mark = self.scan_block_scalar_breaks(indent)
+ if self.column == indent and self.peek() != '\0':
+
+ # Unfortunately, folding rules are ambiguous.
+ #
+ # This is the folding according to the specification:
+
+ if folded and line_break == '\n' \
+ and leading_non_space and self.peek() not in ' \t':
+ if not breaks:
+ chunks.append(' ')
+ else:
+ chunks.append(line_break)
+
+ # This is Clark Evans's interpretation (also in the spec
+ # examples):
+ #
+ #if folded and line_break == '\n':
+ # if not breaks:
+ # if self.peek() not in ' \t':
+ # chunks.append(' ')
+ # else:
+ # chunks.append(line_break)
+ #else:
+ # chunks.append(line_break)
+ else:
+ break
+
+ # Chomp the tail.
+ if chomping is not False:
+ chunks.append(line_break)
+ if chomping is True:
+ chunks.extend(breaks)
+
+ # We are done.
+ return ScalarToken(''.join(chunks), False, start_mark, end_mark,
+ style)
+
+ def scan_block_scalar_indicators(self, start_mark):
+ # See the specification for details.
+ chomping = None
+ increment = None
+ ch = self.peek()
+ if ch in '+-':
+ if ch == '+':
+ chomping = True
+ else:
+ chomping = False
+ self.forward()
+ ch = self.peek()
+ if ch in '0123456789':
+ increment = int(ch)
+ if increment == 0:
+ raise ScannerError("while scanning a block scalar", start_mark,
+ "expected indentation indicator in the range 1-9, but found 0",
+ self.get_mark())
+ self.forward()
+ elif ch in '0123456789':
+ increment = int(ch)
+ if increment == 0:
+ raise ScannerError("while scanning a block scalar", start_mark,
+ "expected indentation indicator in the range 1-9, but found 0",
+ self.get_mark())
+ self.forward()
+ ch = self.peek()
+ if ch in '+-':
+ if ch == '+':
+ chomping = True
+ else:
+ chomping = False
+ self.forward()
+ ch = self.peek()
+ if ch not in '\0 \r\n\x85\u2028\u2029':
+ raise ScannerError("while scanning a block scalar", start_mark,
+ "expected chomping or indentation indicators, but found %r"
+ % ch, self.get_mark())
+ return chomping, increment
+
+ def scan_block_scalar_ignored_line(self, start_mark):
+ # See the specification for details.
+ while self.peek() == ' ':
+ self.forward()
+ if self.peek() == '#':
+ while self.peek() not in '\0\r\n\x85\u2028\u2029':
+ self.forward()
+ ch = self.peek()
+ if ch not in '\0\r\n\x85\u2028\u2029':
+ raise ScannerError("while scanning a block scalar", start_mark,
+ "expected a comment or a line break, but found %r" % ch,
+ self.get_mark())
+ self.scan_line_break()
+
+ def scan_block_scalar_indentation(self):
+ # See the specification for details.
+ chunks = []
+ max_indent = 0
+ end_mark = self.get_mark()
+ while self.peek() in ' \r\n\x85\u2028\u2029':
+ if self.peek() != ' ':
+ chunks.append(self.scan_line_break())
+ end_mark = self.get_mark()
+ else:
+ self.forward()
+ if self.column > max_indent:
+ max_indent = self.column
+ return chunks, max_indent, end_mark
+
+ def scan_block_scalar_breaks(self, indent):
+ # See the specification for details.
+ chunks = []
+ end_mark = self.get_mark()
+ while self.column < indent and self.peek() == ' ':
+ self.forward()
+ while self.peek() in '\r\n\x85\u2028\u2029':
+ chunks.append(self.scan_line_break())
+ end_mark = self.get_mark()
+ while self.column < indent and self.peek() == ' ':
+ self.forward()
+ return chunks, end_mark
+
+ def scan_flow_scalar(self, style):
+ # See the specification for details.
+ # Note that we loose indentation rules for quoted scalars. Quoted
+ # scalars don't need to adhere indentation because " and ' clearly
+ # mark the beginning and the end of them. Therefore we are less
+ # restrictive then the specification requires. We only need to check
+ # that document separators are not included in scalars.
+ if style == '"':
+ double = True
+ else:
+ double = False
+ chunks = []
+ start_mark = self.get_mark()
+ quote = self.peek()
+ self.forward()
+ chunks.extend(self.scan_flow_scalar_non_spaces(double, start_mark))
+ while self.peek() != quote:
+ chunks.extend(self.scan_flow_scalar_spaces(double, start_mark))
+ chunks.extend(self.scan_flow_scalar_non_spaces(double, start_mark))
+ self.forward()
+ end_mark = self.get_mark()
+ return ScalarToken(''.join(chunks), False, start_mark, end_mark,
+ style)
+
+ ESCAPE_REPLACEMENTS = {
+ '0': '\0',
+ 'a': '\x07',
+ 'b': '\x08',
+ 't': '\x09',
+ '\t': '\x09',
+ 'n': '\x0A',
+ 'v': '\x0B',
+ 'f': '\x0C',
+ 'r': '\x0D',
+ 'e': '\x1B',
+ ' ': '\x20',
+ '\"': '\"',
+ '\\': '\\',
+ '/': '/',
+ 'N': '\x85',
+ '_': '\xA0',
+ 'L': '\u2028',
+ 'P': '\u2029',
+ }
+
+ ESCAPE_CODES = {
+ 'x': 2,
+ 'u': 4,
+ 'U': 8,
+ }
+
+ def scan_flow_scalar_non_spaces(self, double, start_mark):
+ # See the specification for details.
+ chunks = []
+ while True:
+ length = 0
+ while self.peek(length) not in '\'\"\\\0 \t\r\n\x85\u2028\u2029':
+ length += 1
+ if length:
+ chunks.append(self.prefix(length))
+ self.forward(length)
+ ch = self.peek()
+ if not double and ch == '\'' and self.peek(1) == '\'':
+ chunks.append('\'')
+ self.forward(2)
+ elif (double and ch == '\'') or (not double and ch in '\"\\'):
+ chunks.append(ch)
+ self.forward()
+ elif double and ch == '\\':
+ self.forward()
+ ch = self.peek()
+ if ch in self.ESCAPE_REPLACEMENTS:
+ chunks.append(self.ESCAPE_REPLACEMENTS[ch])
+ self.forward()
+ elif ch in self.ESCAPE_CODES:
+ length = self.ESCAPE_CODES[ch]
+ self.forward()
+ for k in range(length):
+ if self.peek(k) not in '0123456789ABCDEFabcdef':
+ raise ScannerError("while scanning a double-quoted scalar", start_mark,
+ "expected escape sequence of %d hexadecimal numbers, but found %r" %
+ (length, self.peek(k)), self.get_mark())
+ code = int(self.prefix(length), 16)
+ chunks.append(chr(code))
+ self.forward(length)
+ elif ch in '\r\n\x85\u2028\u2029':
+ self.scan_line_break()
+ chunks.extend(self.scan_flow_scalar_breaks(double, start_mark))
+ else:
+ raise ScannerError("while scanning a double-quoted scalar", start_mark,
+ "found unknown escape character %r" % ch, self.get_mark())
+ else:
+ return chunks
+
+ def scan_flow_scalar_spaces(self, double, start_mark):
+ # See the specification for details.
+ chunks = []
+ length = 0
+ while self.peek(length) in ' \t':
+ length += 1
+ whitespaces = self.prefix(length)
+ self.forward(length)
+ ch = self.peek()
+ if ch == '\0':
+ raise ScannerError("while scanning a quoted scalar", start_mark,
+ "found unexpected end of stream", self.get_mark())
+ elif ch in '\r\n\x85\u2028\u2029':
+ line_break = self.scan_line_break()
+ breaks = self.scan_flow_scalar_breaks(double, start_mark)
+ if line_break != '\n':
+ chunks.append(line_break)
+ elif not breaks:
+ chunks.append(' ')
+ chunks.extend(breaks)
+ else:
+ chunks.append(whitespaces)
+ return chunks
+
+ def scan_flow_scalar_breaks(self, double, start_mark):
+ # See the specification for details.
+ chunks = []
+ while True:
+ # Instead of checking indentation, we check for document
+ # separators.
+ prefix = self.prefix(3)
+ if (prefix == '---' or prefix == '...') \
+ and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029':
+ raise ScannerError("while scanning a quoted scalar", start_mark,
+ "found unexpected document separator", self.get_mark())
+ while self.peek() in ' \t':
+ self.forward()
+ if self.peek() in '\r\n\x85\u2028\u2029':
+ chunks.append(self.scan_line_break())
+ else:
+ return chunks
+
+ def scan_plain(self):
+ # See the specification for details.
+ # We add an additional restriction for the flow context:
+ # plain scalars in the flow context cannot contain ',' or '?'.
+ # We also keep track of the `allow_simple_key` flag here.
+ # Indentation rules are loosed for the flow context.
+ chunks = []
+ start_mark = self.get_mark()
+ end_mark = start_mark
+ indent = self.indent+1
+ # We allow zero indentation for scalars, but then we need to check for
+ # document separators at the beginning of the line.
+ #if indent == 0:
+ # indent = 1
+ spaces = []
+ while True:
+ length = 0
+ if self.peek() == '#':
+ break
+ while True:
+ ch = self.peek(length)
+ if ch in '\0 \t\r\n\x85\u2028\u2029' \
+ or (ch == ':' and
+ self.peek(length+1) in '\0 \t\r\n\x85\u2028\u2029'
+ + (u',[]{}' if self.flow_level else u''))\
+ or (self.flow_level and ch in ',?[]{}'):
+ break
+ length += 1
+ if length == 0:
+ break
+ self.allow_simple_key = False
+ chunks.extend(spaces)
+ chunks.append(self.prefix(length))
+ self.forward(length)
+ end_mark = self.get_mark()
+ spaces = self.scan_plain_spaces(indent, start_mark)
+ if not spaces or self.peek() == '#' \
+ or (not self.flow_level and self.column < indent):
+ break
+ return ScalarToken(''.join(chunks), True, start_mark, end_mark)
+
+ def scan_plain_spaces(self, indent, start_mark):
+ # See the specification for details.
+ # The specification is really confusing about tabs in plain scalars.
+ # We just forbid them completely. Do not use tabs in YAML!
+ chunks = []
+ length = 0
+ while self.peek(length) in ' ':
+ length += 1
+ whitespaces = self.prefix(length)
+ self.forward(length)
+ ch = self.peek()
+ if ch in '\r\n\x85\u2028\u2029':
+ line_break = self.scan_line_break()
+ self.allow_simple_key = True
+ prefix = self.prefix(3)
+ if (prefix == '---' or prefix == '...') \
+ and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029':
+ return
+ breaks = []
+ while self.peek() in ' \r\n\x85\u2028\u2029':
+ if self.peek() == ' ':
+ self.forward()
+ else:
+ breaks.append(self.scan_line_break())
+ prefix = self.prefix(3)
+ if (prefix == '---' or prefix == '...') \
+ and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029':
+ return
+ if line_break != '\n':
+ chunks.append(line_break)
+ elif not breaks:
+ chunks.append(' ')
+ chunks.extend(breaks)
+ elif whitespaces:
+ chunks.append(whitespaces)
+ return chunks
+
+ def scan_tag_handle(self, name, start_mark):
+ # See the specification for details.
+ # For some strange reasons, the specification does not allow '_' in
+ # tag handles. I have allowed it anyway.
+ ch = self.peek()
+ if ch != '!':
+ raise ScannerError("while scanning a %s" % name, start_mark,
+ "expected '!', but found %r" % ch, self.get_mark())
+ length = 1
+ ch = self.peek(length)
+ if ch != ' ':
+ while '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z' \
+ or ch in '-_':
+ length += 1
+ ch = self.peek(length)
+ if ch != '!':
+ self.forward(length)
+ raise ScannerError("while scanning a %s" % name, start_mark,
+ "expected '!', but found %r" % ch, self.get_mark())
+ length += 1
+ value = self.prefix(length)
+ self.forward(length)
+ return value
+
+ def scan_tag_uri(self, name, start_mark):
+ # See the specification for details.
+ # Note: we do not check if URI is well-formed.
+ chunks = []
+ length = 0
+ ch = self.peek(length)
+ while '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z' \
+ or ch in '-;/?:@&=+$,_.!~*\'()[]%':
+ if ch == '%':
+ chunks.append(self.prefix(length))
+ self.forward(length)
+ length = 0
+ chunks.append(self.scan_uri_escapes(name, start_mark))
+ else:
+ length += 1
+ ch = self.peek(length)
+ if length:
+ chunks.append(self.prefix(length))
+ self.forward(length)
+ length = 0
+ if not chunks:
+ raise ScannerError("while parsing a %s" % name, start_mark,
+ "expected URI, but found %r" % ch, self.get_mark())
+ return ''.join(chunks)
+
+ def scan_uri_escapes(self, name, start_mark):
+ # See the specification for details.
+ codes = []
+ mark = self.get_mark()
+ while self.peek() == '%':
+ self.forward()
+ for k in range(2):
+ if self.peek(k) not in '0123456789ABCDEFabcdef':
+ raise ScannerError("while scanning a %s" % name, start_mark,
+ "expected URI escape sequence of 2 hexadecimal numbers, but found %r"
+ % self.peek(k), self.get_mark())
+ codes.append(int(self.prefix(2), 16))
+ self.forward(2)
+ try:
+ value = bytes(codes).decode('utf-8')
+ except UnicodeDecodeError as exc:
+ raise ScannerError("while scanning a %s" % name, start_mark, str(exc), mark)
+ return value
+
+ def scan_line_break(self):
+ # Transforms:
+ # '\r\n' : '\n'
+ # '\r' : '\n'
+ # '\n' : '\n'
+ # '\x85' : '\n'
+ # '\u2028' : '\u2028'
+ # '\u2029 : '\u2029'
+ # default : ''
+ ch = self.peek()
+ if ch in '\r\n\x85':
+ if self.prefix(2) == '\r\n':
+ self.forward(2)
+ else:
+ self.forward()
+ return '\n'
+ elif ch in '\u2028\u2029':
+ self.forward()
+ return ch
+ return ''
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/serializer.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/serializer.py
new file mode 100644
index 0000000000000000000000000000000000000000..fe911e67ae7a739abb491fbbc6834b9c37bbda4b
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/serializer.py
@@ -0,0 +1,111 @@
+
+__all__ = ['Serializer', 'SerializerError']
+
+from .error import YAMLError
+from .events import *
+from .nodes import *
+
+class SerializerError(YAMLError):
+ pass
+
+class Serializer:
+
+ ANCHOR_TEMPLATE = 'id%03d'
+
+ def __init__(self, encoding=None,
+ explicit_start=None, explicit_end=None, version=None, tags=None):
+ self.use_encoding = encoding
+ self.use_explicit_start = explicit_start
+ self.use_explicit_end = explicit_end
+ self.use_version = version
+ self.use_tags = tags
+ self.serialized_nodes = {}
+ self.anchors = {}
+ self.last_anchor_id = 0
+ self.closed = None
+
+ def open(self):
+ if self.closed is None:
+ self.emit(StreamStartEvent(encoding=self.use_encoding))
+ self.closed = False
+ elif self.closed:
+ raise SerializerError("serializer is closed")
+ else:
+ raise SerializerError("serializer is already opened")
+
+ def close(self):
+ if self.closed is None:
+ raise SerializerError("serializer is not opened")
+ elif not self.closed:
+ self.emit(StreamEndEvent())
+ self.closed = True
+
+ #def __del__(self):
+ # self.close()
+
+ def serialize(self, node):
+ if self.closed is None:
+ raise SerializerError("serializer is not opened")
+ elif self.closed:
+ raise SerializerError("serializer is closed")
+ self.emit(DocumentStartEvent(explicit=self.use_explicit_start,
+ version=self.use_version, tags=self.use_tags))
+ self.anchor_node(node)
+ self.serialize_node(node, None, None)
+ self.emit(DocumentEndEvent(explicit=self.use_explicit_end))
+ self.serialized_nodes = {}
+ self.anchors = {}
+ self.last_anchor_id = 0
+
+ def anchor_node(self, node):
+ if node in self.anchors:
+ if self.anchors[node] is None:
+ self.anchors[node] = self.generate_anchor(node)
+ else:
+ self.anchors[node] = None
+ if isinstance(node, SequenceNode):
+ for item in node.value:
+ self.anchor_node(item)
+ elif isinstance(node, MappingNode):
+ for key, value in node.value:
+ self.anchor_node(key)
+ self.anchor_node(value)
+
+ def generate_anchor(self, node):
+ self.last_anchor_id += 1
+ return self.ANCHOR_TEMPLATE % self.last_anchor_id
+
+ def serialize_node(self, node, parent, index):
+ alias = self.anchors[node]
+ if node in self.serialized_nodes:
+ self.emit(AliasEvent(alias))
+ else:
+ self.serialized_nodes[node] = True
+ self.descend_resolver(parent, index)
+ if isinstance(node, ScalarNode):
+ detected_tag = self.resolve(ScalarNode, node.value, (True, False))
+ default_tag = self.resolve(ScalarNode, node.value, (False, True))
+ implicit = (node.tag == detected_tag), (node.tag == default_tag)
+ self.emit(ScalarEvent(alias, node.tag, implicit, node.value,
+ style=node.style))
+ elif isinstance(node, SequenceNode):
+ implicit = (node.tag
+ == self.resolve(SequenceNode, node.value, True))
+ self.emit(SequenceStartEvent(alias, node.tag, implicit,
+ flow_style=node.flow_style))
+ index = 0
+ for item in node.value:
+ self.serialize_node(item, node, index)
+ index += 1
+ self.emit(SequenceEndEvent())
+ elif isinstance(node, MappingNode):
+ implicit = (node.tag
+ == self.resolve(MappingNode, node.value, True))
+ self.emit(MappingStartEvent(alias, node.tag, implicit,
+ flow_style=node.flow_style))
+ for key, value in node.value:
+ self.serialize_node(key, node, None)
+ self.serialize_node(value, node, key)
+ self.emit(MappingEndEvent())
+ self.ascend_resolver()
+
diff --git a/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/tokens.py b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/tokens.py
new file mode 100644
index 0000000000000000000000000000000000000000..4d0b48a394ac8c019b401516a12f688df361cf90
--- /dev/null
+++ b/Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/yaml/tokens.py
@@ -0,0 +1,104 @@
+
+class Token(object):
+ def __init__(self, start_mark, end_mark):
+ self.start_mark = start_mark
+ self.end_mark = end_mark
+ def __repr__(self):
+ attributes = [key for key in self.__dict__
+ if not key.endswith('_mark')]
+ attributes.sort()
+ arguments = ', '.join(['%s=%r' % (key, getattr(self, key))
+ for key in attributes])
+ return '%s(%s)' % (self.__class__.__name__, arguments)
+
+#class BOMToken(Token):
+# id = ''
+
+class DirectiveToken(Token):
+ id = ''
+ def __init__(self, name, value, start_mark, end_mark):
+ self.name = name
+ self.value = value
+ self.start_mark = start_mark
+ self.end_mark = end_mark
+
+class DocumentStartToken(Token):
+ id = ''
+
+class DocumentEndToken(Token):
+ id = ''
+
+class StreamStartToken(Token):
+ id = ''
+ def __init__(self, start_mark=None, end_mark=None,
+ encoding=None):
+ self.start_mark = start_mark
+ self.end_mark = end_mark
+ self.encoding = encoding
+
+class StreamEndToken(Token):
+ id = ''
+
+class BlockSequenceStartToken(Token):
+ id = ''
+
+class BlockMappingStartToken(Token):
+ id = ''
+
+class BlockEndToken(Token):
+ id = ''
+
+class FlowSequenceStartToken(Token):
+ id = '['
+
+class FlowMappingStartToken(Token):
+ id = '{'
+
+class FlowSequenceEndToken(Token):
+ id = ']'
+
+class FlowMappingEndToken(Token):
+ id = '}'
+
+class KeyToken(Token):
+ id = '?'
+
+class ValueToken(Token):
+ id = ':'
+
+class BlockEntryToken(Token):
+ id = '-'
+
+class FlowEntryToken(Token):
+ id = ','
+
+class AliasToken(Token):
+ id = ''
+ def __init__(self, value, start_mark, end_mark):
+ self.value = value
+ self.start_mark = start_mark
+ self.end_mark = end_mark
+
+class AnchorToken(Token):
+ id = ''
+ def __init__(self, value, start_mark, end_mark):
+ self.value = value
+ self.start_mark = start_mark
+ self.end_mark = end_mark
+
+class TagToken(Token):
+ id = ''
+ def __init__(self, value, start_mark, end_mark):
+ self.value = value
+ self.start_mark = start_mark
+ self.end_mark = end_mark
+
+class ScalarToken(Token):
+ id = ''
+ def __init__(self, value, plain, start_mark, end_mark, style=None):
+ self.value = value
+ self.plain = plain
+ self.start_mark = start_mark
+ self.end_mark = end_mark
+ self.style = style
+
+ 
+