ton/ImageUtils
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

update

Browse Source
This commit is contained in:
ton
2023-10-05 00:01:27 +07:00
parent 1541297f6d
commit 4a987d90c5
12169 changed files with 502 additions and 2656459 deletions
Download Patch File Download Diff File Expand all files Collapse all files

119
.CondaPkg/env/Lib/site-packages/pybase64/__init__.py vendored
View File

@@ -1,119 +0,0 @@
from typing import Any
from ._version import __version__
try:
__PYBASE64_SETUP__ # type: ignore
except NameError:
__PYBASE64_SETUP__ = False
# Only go on if not in setup.py
if not __PYBASE64_SETUP__:
from ._license import _license
try:
from ._pybase64 import ( # noqa: F401
_get_simd_path,
b64decode,
b64decode_as_bytearray,
b64encode,
b64encode_as_string,
encodebytes,
)
_has_extension = True
except ImportError:
from ._fallback import ( # noqa: F401
_get_simd_path,
b64decode,
b64decode_as_bytearray,
b64encode,
b64encode_as_string,
encodebytes,
)
_has_extension = False
def get_license_text() -> str:
"""Returns pybase64 license information as a :class:`str` object.
The result includes libbase64 license information as well.
"""
return _license
def get_version() -> str:
"""Returns pybase64 version as a :class:`str` object.
The result reports if the C extension is used or not.
e.g. `1.0.0 (C extension active - AVX2)`
"""
if _has_extension:
simd_flag = _get_simd_path()
if simd_flag == 0:
simd_name = "No SIMD"
elif simd_flag == 4:
simd_name = "SSSE3"
elif simd_flag == 8:
simd_name = "SSE41"
elif simd_flag == 16:
simd_name = "SSE42"
elif simd_flag == 32:
simd_name = "AVX"
elif simd_flag == 64:
simd_name = "AVX2"
else: # pragma: no branch
simd_name = "Unknown" # pragma: no cover
return __version__ + " (C extension active - " + simd_name + ")"
return __version__ + " (C extension inactive)"
def standard_b64encode(s: Any) -> bytes:
"""Encode bytes using the standard Base64 alphabet.
Argument ``s`` is a :term:`bytes-like object` to encode.
The result is returned as a :class:`bytes` object.
"""
return b64encode(s)
def standard_b64decode(s: Any) -> bytes:
"""Decode bytes encoded with the standard Base64 alphabet.
Argument ``s`` is a :term:`bytes-like object` or ASCII string to
decode.
The result is returned as a :class:`bytes` object.
A :exc:`binascii.Error` is raised if the input is incorrectly padded.
Characters that are not in the standard alphabet are discarded prior
to the padding check.
"""
return b64decode(s)
def urlsafe_b64encode(s: Any) -> bytes:
"""Encode bytes using the URL- and filesystem-safe Base64 alphabet.
Argument ``s`` is a :term:`bytes-like object` to encode.
The result is returned as a :class:`bytes` object.
The alphabet uses '-' instead of '+' and '_' instead of '/'.
"""
return b64encode(s, b"-_")
def urlsafe_b64decode(s: Any) -> bytes:
"""Decode bytes using the URL- and filesystem-safe Base64 alphabet.
Argument ``s`` is a :term:`bytes-like object` or ASCII string to
decode.
The result is returned as a :class:`bytes` object.
A :exc:`binascii.Error` is raised if the input is incorrectly padded.
Characters that are not in the URL-safe base-64 alphabet, and are not
a plus '+' or slash '/', are discarded prior to the padding check.
The alphabet uses '-' instead of '+' and '_' instead of '/'.
"""
return b64decode(s, b"-_")

285
.CondaPkg/env/Lib/site-packages/pybase64/__main__.py vendored
View File

@@ -1,285 +0,0 @@
import argparse
import base64
import sys
from base64 import b64decode as b64decodeValidate
from base64 import encodebytes as b64encodebytes
from timeit import default_timer as timer
import pybase64
def bench_one(duration, data, enc, dec, encbytes, altchars=None, validate=False):
duration = duration / 2.0
if not validate and altchars is None:
number = 0
time = timer()
while True:
encodedcontent = encbytes(data)
number += 1
if timer() - time > duration:
break
iter = number
time = timer()
while iter > 0:
encodedcontent = encbytes(data)
iter -= 1
time = timer() - time
print(
"{:<32s} {:9.3f} MB/s ({:,d} bytes -> {:,d} bytes)".format(
encbytes.__module__ + "." + encbytes.__name__ + ":",
((number * len(data)) / (1024.0 * 1024.0)) / time,
len(data),
len(encodedcontent),
)
)
number = 0
time = timer()
while True:
encodedcontent = enc(data, altchars=altchars)
number += 1
if timer() - time > duration:
break
iter = number
time = timer()
while iter > 0:
encodedcontent = enc(data, altchars=altchars)
iter -= 1
time = timer() - time
print(
"{:<32s} {:9.3f} MB/s ({:,d} bytes -> {:,d} bytes)".format(
enc.__module__ + "." + enc.__name__ + ":",
((number * len(data)) / (1024.0 * 1024.0)) / time,
len(data),
len(encodedcontent),
)
)
number = 0
time = timer()
while True:
decodedcontent = dec(encodedcontent, altchars=altchars, validate=validate)
number += 1
if timer() - time > duration:
break
iter = number
time = timer()
while iter > 0:
decodedcontent = dec(encodedcontent, altchars=altchars, validate=validate)
iter -= 1
time = timer() - time
print(
"{0:<32s} {1:9.3f} MB/s ({3:,d} bytes -> {2:,d} bytes)".format(
dec.__module__ + "." + dec.__name__ + ":",
((number * len(data)) / (1024.0 * 1024.0)) / time,
len(data),
len(encodedcontent),
)
)
assert decodedcontent == data
def readall(file):
if file == sys.stdin:
if hasattr(file, "buffer"):
# Python 3 does not honor the binary flag,
# read from the underlying buffer
return file.buffer.read()
else:
return file.read()
# do not close the file
else:
try:
return file.read()
finally:
file.close()
def writeall(file, data):
if file == sys.stdout:
if hasattr(file, "buffer"):
# Python 3 does not honor the binary flag,
# write to the underlying buffer
file.buffer.write(data)
else:
file.write(data)
# do not close the file
else:
try:
file.write(data)
finally:
file.close()
def benchmark(args):
print(__package__ + " " + pybase64.get_version())
data = readall(args.input)
for altchars in [None, b"-_"]:
for validate in [False, True]:
print(
"bench: altchars={:s}, validate={:s}".format(
repr(altchars), repr(validate)
)
)
bench_one(
args.duration,
data,
pybase64.b64encode,
pybase64.b64decode,
pybase64.encodebytes,
altchars,
validate,
)
bench_one(
args.duration,
data,
base64.b64encode,
b64decodeValidate,
b64encodebytes,
altchars,
validate,
)
def encode(args):
data = readall(args.input)
data = pybase64.b64encode(data, args.altchars)
writeall(args.output, data)
def decode(args):
data = readall(args.input)
data = pybase64.b64decode(data, args.altchars, args.validate)
writeall(args.output, data)
class LicenseAction(argparse.Action):
def __init__(
self,
option_strings,
license=None,
dest=argparse.SUPPRESS,
default=argparse.SUPPRESS,
help="show license information and exit",
):
super().__init__(
option_strings=option_strings,
dest=dest,
default=default,
nargs=0,
help=help,
)
self.license = license
def __call__(self, parser, namespace, values, option_string=None):
print(self.license)
parser.exit()
def main(args=None):
# main parser
parser = argparse.ArgumentParser(
prog=__package__, description=__package__ + " command-line tool."
)
parser.add_argument(
"-V",
"--version",
action="version",
version=__package__ + " " + pybase64.get_version(),
)
parser.add_argument(
"--license", action=LicenseAction, license=pybase64.get_license_text()
)
# create sub-parsers
subparsers = parser.add_subparsers(help="tool help")
# benchmark parser
benchmark_parser = subparsers.add_parser("benchmark", help="-h for usage")
benchmark_parser.add_argument(
"-d",
"--duration",
metavar="D",
dest="duration",
type=float,
default=1.0,
help="expected duration for a single encode or decode test",
)
benchmark_parser.add_argument(
"input", type=argparse.FileType("rb"), help="input file used for the benchmark"
)
benchmark_parser.set_defaults(func=benchmark)
# encode parser
encode_parser = subparsers.add_parser("encode", help="-h for usage")
encode_parser.add_argument(
"input", type=argparse.FileType("rb"), help="input file to be encoded"
)
group = encode_parser.add_mutually_exclusive_group()
group.add_argument(
"-u",
"--url",
action="store_const",
const=b"-_",
dest="altchars",
help="use URL encoding",
)
group.add_argument(
"-a",
"--altchars",
dest="altchars",
help="use alternative characters for encoding",
)
encode_parser.add_argument(
"-o",
"--output",
dest="output",
type=argparse.FileType("wb"),
default=sys.stdout,
help="encoded output file (default to stdout)",
)
encode_parser.set_defaults(func=encode)
# decode parser
decode_parser = subparsers.add_parser("decode", help="-h for usage")
decode_parser.add_argument(
"input", type=argparse.FileType("rb"), help="input file to be decoded"
)
group = decode_parser.add_mutually_exclusive_group()
group.add_argument(
"-u",
"--url",
action="store_const",
const=b"-_",
dest="altchars",
help="use URL decoding",
)
group.add_argument(
"-a",
"--altchars",
dest="altchars",
help="use alternative characters for decoding",
)
decode_parser.add_argument(
"-o",
"--output",
dest="output",
type=argparse.FileType("wb"),
default=sys.stdout,
help="decoded output file (default to stdout)",
)
decode_parser.add_argument(
"--no-validation",
dest="validate",
action="store_false",
help="disable validation of the input data",
)
decode_parser.set_defaults(func=decode)
# ready, parse
if args is None:
args = sys.argv[1:]
if len(args) == 0:
args = ["-h"]
args = parser.parse_args(args=args)
args.func(args)
if __name__ == "__main__":
main()

BIN
.CondaPkg/env/Lib/site-packages/pybase64/__pycache__/__init__.cpython-311.pyc vendored
View File

Binary file not shown.

BIN
.CondaPkg/env/Lib/site-packages/pybase64/__pycache__/__main__.cpython-311.pyc vendored
View File

Binary file not shown.

BIN
.CondaPkg/env/Lib/site-packages/pybase64/__pycache__/_fallback.cpython-311.pyc vendored
View File

Binary file not shown.

BIN
.CondaPkg/env/Lib/site-packages/pybase64/__pycache__/_license.cpython-311.pyc vendored
View File

Binary file not shown.

BIN
.CondaPkg/env/Lib/site-packages/pybase64/__pycache__/_version.cpython-311.pyc vendored
View File

Binary file not shown.

151
.CondaPkg/env/Lib/site-packages/pybase64/_fallback.py vendored
View File

@@ -1,151 +0,0 @@
from base64 import b64decode as builtin_decode
from base64 import b64encode as builtin_encode
from base64 import encodebytes as builtin_encodebytes
from binascii import Error as BinAsciiError
from typing import Any, Optional, Union
__all__ = [
"_get_simd_path",
"b64decode",
"b64encode",
"b64encode_as_string",
"encodebytes",
]
_bytes_types = (bytes, bytearray) # Types acceptable as binary data
def _get_simd_path() -> Optional[int]:
return None
def _get_bytes(s: Any) -> Union[bytes, bytearray]:
if isinstance(s, str):
try:
return s.encode("ascii")
except UnicodeEncodeError:
raise ValueError("string argument should contain only ASCII " "characters")
if isinstance(s, _bytes_types):
return s
try:
return memoryview(s).tobytes()
except TypeError:
raise TypeError(
"argument should be a bytes-like object or ASCII "
"string, not %r" % s.__class__.__name__
)
def b64decode(s: Any, altchars: Any = None, validate: bool = False) -> bytes:
"""Decode bytes encoded with the standard Base64 alphabet.
Argument ``s`` is a :term:`bytes-like object` or ASCII string to
decode.
Optional ``altchars`` must be a :term:`bytes-like object` or ASCII
string of length 2 which specifies the alternative alphabet used instead
of the '+' and '/' characters.
If ``validate`` is ``False`` (the default), characters that are neither in
the normal base-64 alphabet nor the alternative alphabet are discarded
prior to the padding check.
If ``validate`` is ``True``, these non-alphabet characters in the input
result in a :exc:`binascii.Error`.
The result is returned as a :class:`bytes` object.
A :exc:`binascii.Error` is raised if ``s`` is incorrectly padded.
"""
if validate:
if len(s) % 4 != 0:
raise BinAsciiError("Incorrect padding")
s = _get_bytes(s)
if altchars is not None:
altchars = _get_bytes(altchars)
assert len(altchars) == 2, repr(altchars)
map = bytes.maketrans(altchars, b"+/")
s = s.translate(map)
try:
result = builtin_decode(s, altchars, validate=False)
except TypeError as e:
raise BinAsciiError(str(e))
# check length of result vs length of input
padding = 0
if len(s) > 1 and s[-2] in (b"=", 61):
padding = padding + 1
if len(s) > 0 and s[-1] in (b"=", 61):
padding = padding + 1
if 3 * (len(s) / 4) - padding != len(result):
raise BinAsciiError("Non-base64 digit found")
return result
return builtin_decode(s, altchars, validate=False)
def b64decode_as_bytearray(
s: Any, altchars: Any = None, validate: bool = False
) -> bytearray:
"""Decode bytes encoded with the standard Base64 alphabet.
Argument ``s`` is a :term:`bytes-like object` or ASCII string to
decode.
Optional ``altchars`` must be a :term:`bytes-like object` or ASCII
string of length 2 which specifies the alternative alphabet used instead
of the '+' and '/' characters.
If ``validate`` is ``False`` (the default), characters that are neither in
the normal base-64 alphabet nor the alternative alphabet are discarded
prior to the padding check.
If ``validate`` is ``True``, these non-alphabet characters in the input
result in a :exc:`binascii.Error`.
The result is returned as a :class:`bytearray` object.
A :exc:`binascii.Error` is raised if ``s`` is incorrectly padded.
"""
return bytearray(b64decode(s, altchars=altchars, validate=validate))
def b64encode(s: Any, altchars: Any = None) -> bytes:
"""Encode bytes using the standard Base64 alphabet.
Argument ``s`` is a :term:`bytes-like object` to encode.
Optional ``altchars`` must be a byte string of length 2 which specifies
an alternative alphabet for the '+' and '/' characters. This allows an
application to e.g. generate url or filesystem safe Base64 strings.
The result is returned as a :class:`bytes` object.
"""
if altchars is not None:
altchars = _get_bytes(altchars)
assert len(altchars) == 2, repr(altchars)
return builtin_encode(s, altchars)
def b64encode_as_string(s: Any, altchars: Any = None) -> str:
"""Encode bytes using the standard Base64 alphabet.
Argument ``s`` is a :term:`bytes-like object` to encode.
Optional ``altchars`` must be a byte string of length 2 which specifies
an alternative alphabet for the '+' and '/' characters. This allows an
application to e.g. generate url or filesystem safe Base64 strings.
The result is returned as a :class:`str` object.
"""
return b64encode(s, altchars).decode("ascii")
def encodebytes(s: Any) -> bytes:
"""Encode bytes into a bytes object with newlines (b'\n') inserted after
every 76 bytes of output, and ensuring that there is a trailing newline,
as per :rfc:`2045` (MIME).
Argument ``s`` is a :term:`bytes-like object` to encode.
The result is returned as a :class:`bytes` object.
"""
return builtin_encodebytes(s)

61
.CondaPkg/env/Lib/site-packages/pybase64/_license.py vendored
View File

@@ -1,61 +0,0 @@
_license = """pybase64
===============================================================================
BSD 2-Clause License
Copyright (c) 2017-2019, Matthieu Darbois
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.
===============================================================================
libbase64
===============================================================================
Copyright (c) 2005-2007, Nick Galbreath
Copyright (c) 2013-2019, Alfred Klomp
Copyright (c) 2015-2017, Wojciech Mula
Copyright (c) 2016-2017, Matthieu Darbois
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.
==========================================================================""" \
+ "====="

BIN
.CondaPkg/env/Lib/site-packages/pybase64/_pybase64.cp311-win_amd64.pyd vendored
View File

Binary file not shown.

1
.CondaPkg/env/Lib/site-packages/pybase64/_version.py vendored
View File

@@ -1 +0,0 @@
__version__ = "1.2.3"

0
.CondaPkg/env/Lib/site-packages/pybase64/distutils/__init__.py vendored
View File

BIN
.CondaPkg/env/Lib/site-packages/pybase64/distutils/__pycache__/__init__.cpython-311.pyc vendored
View File

Binary file not shown.

BIN
.CondaPkg/env/Lib/site-packages/pybase64/distutils/__pycache__/ccompilercapabilities.cpython-311.pyc vendored
View File

Binary file not shown.

210
.CondaPkg/env/Lib/site-packages/pybase64/distutils/ccompilercapabilities.py vendored
View File

@@ -1,210 +0,0 @@
import os
import shutil
import sys
import tempfile
from contextlib import contextmanager
from distutils import log
from distutils.errors import CompileError, LinkError
__all__ = ["CCompilerCapabilities"]
@contextmanager
def chdir(path):
cwd = os.getcwd()
os.chdir(path)
try:
yield
finally:
os.chdir(cwd)
@contextmanager
def mkdtemp(suffix):
path = tempfile.mkdtemp(suffix)
try:
with chdir(path):
yield path
finally:
shutil.rmtree(path)
@contextmanager
def output(is_quiet):
if is_quiet: # pragma: no branch
devnull = open(os.devnull, "w")
oldstderr = os.dup(sys.stderr.fileno())
oldstdout = os.dup(sys.stdout.fileno())
os.dup2(devnull.fileno(), sys.stderr.fileno())
os.dup2(devnull.fileno(), sys.stdout.fileno())
try:
yield
finally:
if is_quiet: # pragma: no branch
os.dup2(oldstderr, sys.stderr.fileno())
os.dup2(oldstdout, sys.stdout.fileno())
devnull.close()
class CCompilerCapabilities:
SIMD_SSSE3 = 0
SIMD_SSE41 = 1
SIMD_SSE42 = 2
SIMD_AVX = 3
SIMD_AVX2 = 4
SIMD_NEON32 = 5
SIMD_NEON64 = 6
def __init__(self, compiler):
self.__capabilities = {}
self.__cflags = []
if compiler.compiler_type == "msvc":
self.__cflags = ["/WX", "/Od"] # pragma: no cover
else:
self.__cflags = ["-O0"]
self.__get_capabilities(compiler)
def __has_simd_support(self, compiler, flags, define, include, content):
quiet = True
with mkdtemp("pybase64simdtest") as dname:
fname = os.path.join(dname, "simd.c")
with open(fname, "w") as f:
f.write("""#include <%s>\n""" % include)
f.write(
"""\
int main (int argc, char **argv) {
%s
}
"""
% content
)
with output(quiet):
for flag in flags:
lflags = []
if not len(flag) == 0:
lflags = [flag]
try:
objects = compiler.compile(
["simd.c"],
output_dir=dname,
extra_postargs=lflags + self.__cflags,
)
except CompileError:
continue
try:
compiler.link_shared_lib(objects, "a.out", output_dir=dname)
except (LinkError, TypeError): # pragma: no cover
continue # pragma: no cover
return {"support": True, "flags": lflags + define}
return {"support": False, "flags": []}
def __get_capabilities(self, compiler):
log.info("getting compiler simd support")
self.__capabilities[CCompilerCapabilities.SIMD_SSSE3] = self.__has_simd_support(
compiler,
["", "-mssse3"],
["-D__SSSE3__"],
"tmmintrin.h",
"__m128i t = _mm_loadu_si128((const __m128i*)argv[0]);"
"t = _mm_shuffle_epi8(t, t);"
"return _mm_cvtsi128_si32(t);",
)
log.info(
"SSSE3: %s"
% str(self.__capabilities[CCompilerCapabilities.SIMD_SSSE3]["support"])
)
self.__capabilities[CCompilerCapabilities.SIMD_SSE41] = self.__has_simd_support(
compiler,
["", "-msse4.1"],
["-D__SSE4_1__"],
"smmintrin.h",
"__m128i t = _mm_loadu_si128((const __m128i*)argv[0]);"
"t = _mm_mpsadbw_epu8(t, t, 1);"
"return _mm_cvtsi128_si32(t);",
)
log.info(
"SSE41: %s"
% str(self.__capabilities[CCompilerCapabilities.SIMD_SSE41]["support"])
)
self.__capabilities[CCompilerCapabilities.SIMD_SSE42] = self.__has_simd_support(
compiler,
["", "-msse4.2"],
["-D__SSE4_2__"],
"nmmintrin.h",
"__m128i t = _mm_loadu_si128((const __m128i*)argv[0]);"
"return _mm_cmpistra(t, t, 0);",
)
log.info(
"SSE42: %s"
% str(self.__capabilities[CCompilerCapabilities.SIMD_SSE42]["support"])
)
self.__capabilities[CCompilerCapabilities.SIMD_AVX] = self.__has_simd_support(
compiler,
["", "-mavx", "/arch:AVX"],
["-D__AVX__"],
"immintrin.h",
"__m256i y = _mm256_loadu_si256((const __m256i*)argv[0]);"
"return _mm256_testz_si256(y, y);",
)
log.info(
"AVX: %s"
% str(self.__capabilities[CCompilerCapabilities.SIMD_AVX]["support"])
)
self.__capabilities[CCompilerCapabilities.SIMD_AVX2] = self.__has_simd_support(
compiler,
["", "-mavx2", "/arch:AVX2"],
["-D__AVX2__"],
"immintrin.h",
"__m256i y = _mm256_loadu_si256((const __m256i*)argv[0]);"
"y = _mm256_i32gather_epi32((int const*)argv[1], y, 2);"
"return _mm_cvtsi128_si32(_mm256_castsi256_si128(y));",
)
log.info(
"AVX2: %s"
% str(self.__capabilities[CCompilerCapabilities.SIMD_AVX2]["support"])
)
self.__capabilities[
CCompilerCapabilities.SIMD_NEON64
] = self.__has_simd_support(
compiler,
[""],
[],
"arm_neon.h",
"uint8x16_t t = vdupq_n_u8(1);"
"uint8x16x4_t t4 = {"
" .val[0]=t, .val[1]=t, .val[2]=t, .val[3]=t};"
"uint8x16_t o = vqtbx4q_u8(t, t4, t);"
"return vgetq_lane_s32(vreinterpretq_s32_u8(o), 0);",
)
log.info(
"NEON64: %s"
% str(self.__capabilities[CCompilerCapabilities.SIMD_NEON64]["support"])
)
self.__capabilities[
CCompilerCapabilities.SIMD_NEON32
] = self.__has_simd_support(
compiler,
[""],
[],
"arm_neon.h",
"uint8x16_t t = vdupq_n_u8(1);"
"return vgetq_lane_s32(vreinterpretq_s32_u8(t), 0);",
)
self.__capabilities[CCompilerCapabilities.SIMD_NEON32][
"support"
] &= not self.__capabilities[CCompilerCapabilities.SIMD_NEON64]["support"]
log.info(
"NEON32: %s"
% str(self.__capabilities[CCompilerCapabilities.SIMD_NEON32]["support"])
)
def has(self, what):
if what not in self.__capabilities:
return False
return self.__capabilities[what]["support"]
def flags(self, what):
if not self.has(what): # pragma: no branch
return self.__capabilities[666]["flags"] # pragma: no cover
return self.__capabilities[what]["flags"]

0
.CondaPkg/env/Lib/site-packages/pybase64/tests/__init__.py vendored
View File

BIN
.CondaPkg/env/Lib/site-packages/pybase64/tests/__pycache__/__init__.cpython-311.pyc vendored
View File

Binary file not shown.

BIN
.CondaPkg/env/Lib/site-packages/pybase64/tests/__pycache__/test_main.cpython-311.pyc vendored
View File

Binary file not shown.

BIN
.CondaPkg/env/Lib/site-packages/pybase64/tests/__pycache__/test_pybase64.cpython-311.pyc vendored
View File

Binary file not shown.

148
.CondaPkg/env/Lib/site-packages/pybase64/tests/test_main.py vendored
View File

@@ -1,148 +0,0 @@
import os
import re
import sys
import pytest
import pybase64
from pybase64.__main__ import main
@pytest.fixture
def emptyfile(tmpdir):
_file = os.path.join(tmpdir.strpath, "empty")
with open(_file, "wb"):
pass
yield _file
os.remove(_file)
@pytest.fixture
def hellofile(tmpdir):
_file = os.path.join(tmpdir.strpath, "helloworld")
with open(_file, "wb") as f:
f.write(b"hello world !/?\n")
yield _file
os.remove(_file)
def idfn_test_help(args):
if len(args) == 0:
return "(empty)"
return " ".join(args)
@pytest.mark.parametrize(
"args",
[
[],
["-h"],
["benchmark", "-h"],
["encode", "-h"],
["decode", "-h"],
],
ids=idfn_test_help,
)
def test_help(capsys, args):
if len(args) == 2:
usage = f"usage: pybase64 {args[0]} [-h]"
else:
usage = "usage: pybase64 [-h]"
with pytest.raises(SystemExit) as exit_info:
main(args)
captured = capsys.readouterr()
assert captured.err == ""
assert captured.out.startswith(usage)
assert exit_info.value.code == 0
def test_version(capsys):
with pytest.raises(SystemExit) as exit_info:
main(["-V"])
captured = capsys.readouterr()
assert captured.err == ""
assert captured.out.startswith("pybase64 " + pybase64.__version__)
assert exit_info.value.code == 0
def test_license(capsys):
restr = "\n".join(
x + "\n[=]+\n.*Copyright.*\n[=]+\n" for x in ["pybase64", "libbase64"]
)
regex = re.compile("^" + restr + "$", re.DOTALL)
with pytest.raises(SystemExit) as exit_info:
main(["--license"])
captured = capsys.readouterr()
assert captured.err == ""
assert regex.match(captured.out)
assert exit_info.value.code == 0
def test_benchmark(capsys, emptyfile):
main(["benchmark", "-d", "0.005", emptyfile])
captured = capsys.readouterr()
assert captured.err == ""
assert captured.out != ""
@pytest.mark.parametrize(
"args,expect",
[
([], b"aGVsbG8gd29ybGQgIS8/Cg=="),
(["-u"], b"aGVsbG8gd29ybGQgIS8_Cg=="),
(["-a", ":,"], b"aGVsbG8gd29ybGQgIS8,Cg=="),
],
ids=["0", "1", "2"],
)
def test_encode(capsysbinary, hellofile, args, expect):
main(["encode"] + args + [hellofile])
captured = capsysbinary.readouterr()
assert captured.err == b""
assert captured.out == expect
def test_encode_ouputfile(capsys, emptyfile, hellofile):
main(["encode", "-o", hellofile, emptyfile])
captured = capsys.readouterr()
assert captured.err == ""
assert captured.out == ""
with open(hellofile, "rb") as f:
data = f.read()
assert data == b""
@pytest.mark.parametrize(
"args,b64string",
[
[[], b"aGVsbG8gd29ybGQgIS8/Cg=="],
[["-u"], b"aGVsbG8gd29ybGQgIS8_Cg=="],
[["-a", ":,"], b"aGVsbG8gd29ybGQgIS8,Cg=="],
[["--no-validation"], b"aGVsbG8gd29yb GQgIS8/Cg==\n"],
],
ids=["0", "1", "2", "3"],
)
def test_decode(capsysbinary, tmpdir, args, b64string):
iname = os.path.join(tmpdir.strpath, "in")
with open(iname, "wb") as f:
f.write(b64string)
main(["decode"] + args + [iname])
captured = capsysbinary.readouterr()
assert captured.err == b""
assert captured.out == b"hello world !/?\n"
def test_subprocess():
import subprocess
process = subprocess.Popen(
[sys.executable, "-m", "pybase64", "encode", "-"],
bufsize=4096,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
)
out, err = process.communicate()
process.wait()
assert process.returncode == 0
assert out == b""
assert err == b""

455
.CondaPkg/env/Lib/site-packages/pybase64/tests/test_pybase64.py vendored
View File

@@ -1,455 +0,0 @@
import base64
from base64 import encodebytes as b64encodebytes
from binascii import Error as BinAsciiError
import pytest
import pybase64
try:
from pybase64._pybase64 import (
_get_simd_flags_compile,
_get_simd_flags_runtime,
_get_simd_path,
_set_simd_path,
)
_has_extension = True
except ImportError:
_has_extension = False
STD = 0
URL = 1
ALT1 = 2
ALT2 = 3
ALT3 = 4
name_lut = ["standard", "urlsafe", "alternative", "alternative2", "alternative3"]
altchars_lut = [b"+/", b"-_", b"@&", b"+,", b";/"]
enc_helper_lut = [
pybase64.standard_b64encode,
pybase64.urlsafe_b64encode,
None,
None,
None,
]
ref_enc_helper_lut = [
pybase64.standard_b64encode,
pybase64.urlsafe_b64encode,
None,
None,
None,
]
dec_helper_lut = [
pybase64.standard_b64decode,
pybase64.urlsafe_b64decode,
None,
None,
None,
]
ref_dec_helper_lut = [
base64.standard_b64decode,
base64.urlsafe_b64decode,
None,
None,
None,
]
std = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/A"
std = std * (32 * 16)
std_len_minus_12 = len(std) - 12
test_vectors_b64_list = [
# rfc4648 test vectors
b"",
b"Zg==",
b"Zm8=",
b"Zm9v",
b"Zm9vYg==",
b"Zm9vYmE=",
b"Zm9vYmFy",
# custom test vectors
std[std_len_minus_12:],
std,
std[:72],
std[:76],
std[:80],
std[:148],
std[:152],
std[:156],
]
test_vectors_b64 = []
for altchars in altchars_lut:
trans = bytes.maketrans(b"+/", altchars)
test_vectors_b64.append(
[vector.translate(trans) for vector in test_vectors_b64_list]
)
test_vectors_bin = []
for altchars in altchars_lut:
test_vectors_bin.append(
[base64.b64decode(vector, altchars) for vector in test_vectors_b64_list]
)
compile_flags = [0]
runtime_flags = 0
if _has_extension:
runtime_flags = _get_simd_flags_runtime()
flags = _get_simd_flags_compile()
for i in range(31):
if flags & (1 << i):
compile_flags += [(1 << i)]
def get_simd_name(simd_id):
simd_name = None
if _has_extension:
simd_flag = compile_flags[simd_id]
if simd_flag == 0:
simd_name = "c"
elif simd_flag == 4:
simd_name = "ssse3"
elif simd_flag == 8:
simd_name = "sse41"
elif simd_flag == 16:
simd_name = "sse42"
elif simd_flag == 32:
simd_name = "avx"
elif simd_flag == 64:
simd_name = "avx2"
else: # pragma: no branch
simd_name = "unk" # pragma: no cover
else:
simd_name = "py"
return simd_name
def simd_setup(simd_id):
if _has_extension:
flag = compile_flags[simd_id]
if flag != 0 and not flag & runtime_flags: # pragma: no branch
pytest.skip("SIMD extension not available") # pragma: no cover
_set_simd_path(flag)
assert _get_simd_path() == flag
else:
assert 0 == simd_id
param_vector = pytest.mark.parametrize("vector_id", range(len(test_vectors_bin[0])))
param_validate = pytest.mark.parametrize(
"validate", [False, True], ids=["novalidate", "validate"]
)
param_altchars = pytest.mark.parametrize(
"altchars_id", [STD, URL, ALT1, ALT2, ALT3], ids=lambda x: name_lut[x]
)
param_altchars_helper = pytest.mark.parametrize(
"altchars_id", [STD, URL], ids=lambda x: name_lut[x]
)
param_simd = pytest.mark.parametrize(
"simd", range(len(compile_flags)), ids=lambda x: get_simd_name(x), indirect=True
)
param_encode_functions = pytest.mark.parametrize(
"efn, ecast",
[
(pybase64.b64encode, lambda x: x),
(pybase64.b64encode_as_string, lambda x: x.encode("ascii")),
],
)
param_decode_functions = pytest.mark.parametrize(
"dfn, dcast",
[
(pybase64.b64decode, lambda x: x),
(pybase64.b64decode_as_bytearray, lambda x: bytes(x)),
],
)
@pytest.fixture
def simd(request):
simd_setup(request.param)
return request.param
@param_simd
def test_version(simd):
assert pybase64.get_version().startswith(pybase64.__version__)
@param_simd
@param_vector
@param_altchars_helper
def test_enc_helper(altchars_id, vector_id, simd):
vector = test_vectors_bin[altchars_id][vector_id]
test = enc_helper_lut[altchars_id](vector)
base = ref_enc_helper_lut[altchars_id](vector)
assert test == base
@param_simd
@param_vector
@param_altchars_helper
def test_dec_helper(altchars_id, vector_id, simd):
vector = test_vectors_b64[altchars_id][vector_id]
test = dec_helper_lut[altchars_id](vector)
base = ref_dec_helper_lut[altchars_id](vector)
assert test == base
@param_simd
@param_vector
@param_altchars_helper
def test_dec_helper_unicode(altchars_id, vector_id, simd):
vector = test_vectors_b64[altchars_id][vector_id]
test = dec_helper_lut[altchars_id](str(vector, "utf-8"))
base = ref_dec_helper_lut[altchars_id](str(vector, "utf-8"))
assert test == base
@param_simd
@param_vector
@param_altchars_helper
def test_rnd_helper(altchars_id, vector_id, simd):
vector = test_vectors_b64[altchars_id][vector_id]
test = dec_helper_lut[altchars_id](vector)
test = enc_helper_lut[altchars_id](test)
assert test == vector
@param_simd
@param_vector
@param_altchars_helper
def test_rnd_helper_unicode(altchars_id, vector_id, simd):
vector = test_vectors_b64[altchars_id][vector_id]
test = dec_helper_lut[altchars_id](str(vector, "utf-8"))
test = enc_helper_lut[altchars_id](test)
assert test == vector
@param_simd
@param_vector
def test_encbytes(vector_id, simd):
vector = test_vectors_bin[STD][vector_id]
test = pybase64.encodebytes(vector)
base = b64encodebytes(vector)
assert test == base
@param_simd
@param_vector
@param_altchars
@param_encode_functions
def test_enc(efn, ecast, altchars_id, vector_id, simd):
vector = test_vectors_bin[altchars_id][vector_id]
altchars = altchars_lut[altchars_id]
test = ecast(efn(vector, altchars))
base = base64.b64encode(vector, altchars)
assert test == base
@param_simd
@param_vector
@param_altchars
@param_validate
@param_decode_functions
def test_dec(dfn, dcast, altchars_id, vector_id, validate, simd):
vector = test_vectors_b64[altchars_id][vector_id]
altchars = altchars_lut[altchars_id]
if validate:
base = base64.b64decode(vector, altchars, validate)
else:
base = base64.b64decode(vector, altchars)
test = dcast(dfn(vector, altchars, validate))
assert test == base
@param_simd
@param_vector
@param_altchars
@param_validate
@param_decode_functions
def test_dec_unicode(dfn, dcast, altchars_id, vector_id, validate, simd):
vector = test_vectors_b64[altchars_id][vector_id]
vector = str(vector, "utf-8")
altchars = altchars_lut[altchars_id]
if altchars_id == STD:
altchars = None
else:
altchars = str(altchars, "utf-8")
if validate:
base = base64.b64decode(vector, altchars, validate)
else:
base = base64.b64decode(vector, altchars)
test = dcast(dfn(vector, altchars, validate))
assert test == base
@param_simd
@param_vector
@param_altchars
@param_validate
@param_encode_functions
@param_decode_functions
def test_rnd(dfn, dcast, efn, ecast, altchars_id, vector_id, validate, simd):
vector = test_vectors_b64[altchars_id][vector_id]
altchars = altchars_lut[altchars_id]
test = dcast(dfn(vector, altchars, validate))
test = ecast(efn(test, altchars))
assert test == vector
@param_simd
@param_vector
@param_altchars
@param_validate
@param_encode_functions
@param_decode_functions
def test_rnd_unicode(dfn, dcast, efn, ecast, altchars_id, vector_id, validate, simd):
vector = test_vectors_b64[altchars_id][vector_id]
altchars = altchars_lut[altchars_id]
test = dcast(dfn(str(vector, "utf-8"), altchars, validate))
test = ecast(efn(test, altchars))
assert test == vector
@param_simd
@param_vector
@param_altchars
@param_validate
@param_decode_functions
def test_invalid_padding_dec(dfn, dcast, altchars_id, vector_id, validate, simd):
vector = test_vectors_b64[altchars_id][vector_id][1:]
if len(vector) > 0:
altchars = altchars_lut[altchars_id]
with pytest.raises(BinAsciiError):
dfn(vector, altchars, validate)
params_invalid_altchars = [
[b"", AssertionError],
[b"-", AssertionError],
[b"-__", AssertionError],
[3.0, TypeError],
["-€", ValueError],
]
params_invalid_altchars = pytest.mark.parametrize(
"altchars,exception",
params_invalid_altchars,
ids=[str(i) for i in range(len(params_invalid_altchars))],
)
@param_simd
@params_invalid_altchars
@param_encode_functions
def test_invalid_altchars_enc(efn, ecast, altchars, exception, simd):
with pytest.raises(exception):
efn(b"ABCD", altchars)
@param_simd
@params_invalid_altchars
@param_decode_functions
def test_invalid_altchars_dec(dfn, dcast, altchars, exception, simd):
with pytest.raises(exception):
dfn(b"ABCD", altchars)
@param_simd
@params_invalid_altchars
@param_decode_functions
def test_invalid_altchars_dec_validate(dfn, dcast, altchars, exception, simd):
with pytest.raises(exception):
dfn(b"ABCD", altchars, True)
params_invalid_data_novalidate = [
[b"A@@@@FG", None, BinAsciiError],
["ABC€", None, ValueError],
[3.0, None, TypeError],
]
params_invalid_data_validate = [
[b"\x00\x00\x00\x00", None, BinAsciiError],
[b"A@@@@FGHIJKLMNOPQRSTUVWXYZabcdef", b"-_", BinAsciiError],
[b"A@@@=FGHIJKLMNOPQRSTUVWXYZabcdef", b"-_", BinAsciiError],
[b"A@@=@FGHIJKLMNOPQRSTUVWXYZabcdef", b"-_", BinAsciiError],
[b"A@@@@FGHIJKLMNOPQRSTUVWXYZabcde@=", b"-_", BinAsciiError],
[b"A@@@@FGHIJKLMNOPQRSTUVWXYZabcd@==", b"-_", BinAsciiError],
[b"A@@@@FGH" * 10000, b"-_", BinAsciiError],
# [std, b'-_', BinAsciiError], TODO does no fail with base64 module
]
params_invalid_data_all = pytest.mark.parametrize(
"vector,altchars,exception",
params_invalid_data_novalidate + params_invalid_data_validate,
ids=[
str(i)
for i in range(
len(params_invalid_data_novalidate) + len(params_invalid_data_validate)
)
],
)
params_invalid_data_novalidate = pytest.mark.parametrize(
"vector,altchars,exception",
params_invalid_data_novalidate,
ids=[str(i) for i in range(len(params_invalid_data_novalidate))],
)
params_invalid_data_validate = pytest.mark.parametrize(
"vector,altchars,exception",
params_invalid_data_validate,
ids=[str(i) for i in range(len(params_invalid_data_validate))],
)
@param_simd
@params_invalid_data_novalidate
@param_decode_functions
def test_invalid_data_dec(dfn, dcast, vector, altchars, exception, simd):
with pytest.raises(exception):
dfn(vector, altchars)
@param_simd
@params_invalid_data_validate
@param_decode_functions
def test_invalid_data_dec_skip(dfn, dcast, vector, altchars, exception, simd):
test = dcast(dfn(vector, altchars))
base = base64.b64decode(vector, altchars)
assert test == base
@param_simd
@params_invalid_data_all
@param_decode_functions
def test_invalid_data_dec_validate(dfn, dcast, vector, altchars, exception, simd):
with pytest.raises(exception):
dfn(vector, altchars, True)
@param_encode_functions
def test_invalid_data_enc_0(efn, ecast):
with pytest.raises(TypeError):
efn("this is a test")
@param_encode_functions
def test_invalid_args_enc_0(efn, ecast):
with pytest.raises(TypeError):
efn()
@param_decode_functions
def test_invalid_args_dec_0(dfn, dcast):
with pytest.raises(TypeError):
dfn()