pybase64 1.4.1__tar.gz → 1.4.2__tar.gz

{pybase64-1.4.1/src/pybase64.egg-info → pybase64-1.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: pybase64
-Version: 1.4.1
+Version: 1.4.2
 Summary: Fast Base64 encoding/decoding
 Home-page: https://github.com/mayeut/pybase64
 Author: Matthieu Darbois
@@ -22,6 +22,7 @@ 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.14
 Requires-Python: >=3.8
 Description-Content-Type: text/x-rst
 License-File: LICENSE
@@ -32,6 +33,7 @@ Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: keywords
 Dynamic: license
+Dynamic: license-file
 Dynamic: project-url
 Dynamic: requires-python
 Dynamic: summary
@@ -159,6 +161,15 @@ Running Python 3.7.2, Apple LLVM version 10.0.0 (clang-1000.11.45.5), Mac OS X 1
 
 Changelog
 =========
+1.4.2
+-----
+- Update base64 library (Windows ARM64 Neon support)
+- Publish Python 3.14 wheels
+- Publish Linux riscv64 wheels
+- Publish Android wheels
+- Publish iOS wheels
+- Publish GraalPy wheels
+
 1.4.1
 -----
 - Publish PyPy 3.11 wheels

{pybase64-1.4.1 → pybase64-1.4.2}/README.rst

@@ -121,6 +121,15 @@ Running Python 3.7.2, Apple LLVM version 10.0.0 (clang-1000.11.45.5), Mac OS X 1
 
 Changelog
 =========
+1.4.2
+-----
+- Update base64 library (Windows ARM64 Neon support)
+- Publish Python 3.14 wheels
+- Publish Linux riscv64 wheels
+- Publish Android wheels
+- Publish iOS wheels
+- Publish GraalPy wheels
+
 1.4.1
 -----
 - Publish PyPy 3.11 wheels

{pybase64-1.4.1 → pybase64-1.4.2}/base64/.github/workflows/test.yml

@@ -62,6 +62,8 @@ jobs:
             platform: "arm64"
           - runner: "ubuntu-22.04-arm"
             platform: "aarch64"
+          - runner: "windows-11-arm"
+            platform: "ARM64"
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -141,7 +143,7 @@ jobs:
     steps:
       - name: Checkout
         uses: actions/checkout@v4
-      - uses: uraimo/run-on-arch-action@v2
+      - uses: uraimo/run-on-arch-action@v3
         with:
           arch: ${{matrix.arch}}
           distro: alpine_latest
@@ -162,7 +164,7 @@ jobs:
     steps:
       - name: Checkout
         uses: actions/checkout@v4
-      - uses: uraimo/run-on-arch-action@v2
+      - uses: uraimo/run-on-arch-action@v3
         with:
           arch: ${{matrix.arch}}
           distro: alpine_latest

{pybase64-1.4.1 → pybase64-1.4.2}/base64/cmake/test-arch.c

@@ -12,7 +12,8 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 // ARM 64-Bit
-#if defined(__aarch64__)
+#if defined(__aarch64__) \
+    || defined(_M_ARM64)
 #error ##arch=arm64##
 
 // ARM 32-Bit

{pybase64-1.4.1 → pybase64-1.4.2}/base64/lib/arch/neon64/codec.c

@@ -8,13 +8,7 @@
 #include "config.h"
 #include "../../env.h"
 
-#ifdef __aarch64__
-#  if (defined(__ARM_NEON__) || defined(__ARM_NEON)) && HAVE_NEON64
-#    define BASE64_USE_NEON64
-#  endif
-#endif
-
-#ifdef BASE64_USE_NEON64
+#if HAVE_NEON64
 #include <arm_neon.h>
 
 // Only enable inline assembly on supported compilers.
@@ -66,7 +60,7 @@ load_64byte_table (const uint8_t *p)
 # include "enc_loop.c"
 #endif
 
-#endif	// BASE64_USE_NEON64
+#endif	// HAVE_NEON64
 
 // Stride size is so large on these NEON 64-bit functions
 // (48 bytes encode, 64 bytes decode) that we inline the
@@ -75,7 +69,7 @@ load_64byte_table (const uint8_t *p)
 void
 base64_stream_encode_neon64 BASE64_ENC_PARAMS
 {
-#ifdef BASE64_USE_NEON64
+#if HAVE_NEON64
 	#include "../generic/enc_head.c"
 	enc_loop_neon64(&s, &slen, &o, &olen);
 	enc_loop_generic_64(&s, &slen, &o, &olen);
@@ -88,7 +82,7 @@ base64_stream_encode_neon64 BASE64_ENC_PARAMS
 int
 base64_stream_decode_neon64 BASE64_DEC_PARAMS
 {
-#ifdef BASE64_USE_NEON64
+#if HAVE_NEON64
 	#include "../generic/dec_head.c"
 	dec_loop_neon64(&s, &slen, &o, &olen);
 	dec_loop_generic_32(&s, &slen, &o, &olen);

{pybase64-1.4.1 → pybase64-1.4.2}/base64/lib/arch/neon64/dec_loop.c

@@ -100,10 +100,10 @@ dec_loop_neon64 (const uint8_t **s, size_t *slen, uint8_t **o, size_t *olen)
 
 		// Check for invalid input, any value larger than 63:
 		const uint8x16_t classified
-			= vcgtq_u8(str.val[0], vdupq_n_u8(63))
-			| vcgtq_u8(str.val[1], vdupq_n_u8(63))
-			| vcgtq_u8(str.val[2], vdupq_n_u8(63))
-			| vcgtq_u8(str.val[3], vdupq_n_u8(63));
+			= vorrq_u8(
+				vorrq_u8(vcgtq_u8(str.val[0], vdupq_n_u8(63)), vcgtq_u8(str.val[1], vdupq_n_u8(63))),
+				vorrq_u8(vcgtq_u8(str.val[2], vdupq_n_u8(63)), vcgtq_u8(str.val[3], vdupq_n_u8(63)))
+			);
 
 		// Check that all bits are zero:
 		if (vmaxvq_u8(classified) != 0U) {
@@ -111,9 +111,9 @@ dec_loop_neon64 (const uint8_t **s, size_t *slen, uint8_t **o, size_t *olen)
 		}
 
 		// Compress four bytes into three:
-		dec.val[0] = vshlq_n_u8(str.val[0], 2) | vshrq_n_u8(str.val[1], 4);
-		dec.val[1] = vshlq_n_u8(str.val[1], 4) | vshrq_n_u8(str.val[2], 2);
-		dec.val[2] = vshlq_n_u8(str.val[2], 6) | str.val[3];
+		dec.val[0] = vorrq_u8(vshlq_n_u8(str.val[0], 2), vshrq_n_u8(str.val[1], 4));
+		dec.val[1] = vorrq_u8(vshlq_n_u8(str.val[1], 4), vshrq_n_u8(str.val[2], 2));
+		dec.val[2] = vorrq_u8(vshlq_n_u8(str.val[2], 6), str.val[3]);
 
 		// Interleave and store decoded result:
 		vst3q_u8((uint8_t *) *o, dec);

{pybase64-1.4.1 → pybase64-1.4.2}/base64/lib/codec_choose.c

@@ -163,13 +163,13 @@ codec_choose_forced (struct codec *codec, int flags)
 static bool
 codec_choose_arm (struct codec *codec)
 {
-#if (defined(__ARM_NEON__) || defined(__ARM_NEON)) && ((defined(__aarch64__) && HAVE_NEON64) || HAVE_NEON32)
+#if HAVE_NEON64 || ((defined(__ARM_NEON__) || defined(__ARM_NEON)) && HAVE_NEON32)
 
 	// Unfortunately there is no portable way to check for NEON
 	// support at runtime from userland in the same way that x86
 	// has cpuid, so just stick to the compile-time configuration:
 
-	#if defined(__aarch64__) && HAVE_NEON64
+	#if HAVE_NEON64
 	codec->enc = base64_stream_encode_neon64;
 	codec->dec = base64_stream_decode_neon64;
 	#else

{pybase64-1.4.1 → pybase64-1.4.2}/pyproject.toml

@@ -3,24 +3,22 @@ requires = ["setuptools"]
 build-backend = "setuptools.build_meta"
 
 [tool.cibuildwheel]
-enable = ["cpython-freethreading", "pypy"]
-test-requires = "-r requirements-test.txt"
-test-command = "pytest {project}/tests"
-test-skip = "*-win_arm64"  # silence warnings for windows ARM64
 build-verbosity = 1
-manylinux-i686-image = "manylinux2014"
-manylinux-pypy_i686-image = "manylinux2014"
-manylinux-x86_64-image = "manylinux_2_28"
-manylinux-pypy_x86_64-image = "manylinux_2_28"
-manylinux-aarch64-image = "manylinux_2_28"
-manylinux-pypy_aarch64-image = "manylinux_2_28"
-manylinux-ppc64le-image = "manylinux_2_28"
-manylinux-s390x-image = "manylinux_2_28"
+enable = ["cpython-experimental-riscv64", "cpython-freethreading", "graalpy", "pypy", "pypy-eol"]
+test-skip = ["gp311_242-win_amd64"]  # https://github.com/oracle/graalpython/issues/490
+test-requires = "-r requirements-test.txt"
+test-sources = ["conftest.py", "pyproject.toml", "tests"]
+test-command = "python -m pytest"
+xbuild-tools = ["cmake"]
 
 [[tool.cibuildwheel.overrides]]
 select = "*-manylinux*"
 environment = { AUDITWHEEL_PLAT="manylinux2014_${AUDITWHEEL_ARCH}" }
 
+[[tool.cibuildwheel.overrides]]
+select = "*-manylinux_riscv64"
+environment = { AUDITWHEEL_PLAT="manylinux_2_31_${AUDITWHEEL_ARCH}" }
+
 [tool.coverage.run]
 branch = true
 omit = [

{pybase64-1.4.1 → pybase64-1.4.2}/setup.py

@@ -72,6 +72,7 @@ def get_cmake_extra_config(plat_name: str | None, build_type: str) -> tuple[bool
     log.info("  CC: %s", os.environ.get("CC", None))
     log.info("  CFLAGS: %s", os.environ.get("CFLAGS", None))
     log.info("  LDFLAGS: %s", os.environ.get("LDFLAGS", None))
+    log.info("  CMAKE_TOOLCHAIN_FILE: %s", os.environ.get("CMAKE_TOOLCHAIN_FILE", None))
     log.info("  sysconfig CC: %s", sysconfig.get_config_var("CC"))
     log.info("  sysconfig CCSHARED: %s", sysconfig.get_config_var("CCSHARED"))
     log.info("  sysconfig CFLAGS: %s", sysconfig.get_config_var("CFLAGS"))
@@ -81,6 +82,8 @@ def get_cmake_extra_config(plat_name: str | None, build_type: str) -> tuple[bool
 
     platform = plat_name or platform
     is_msvc = platform.startswith("win")
+    is_macos = platform.startswith("macosx-")
+    is_ios = platform.startswith("ios-")
 
     if not is_msvc:
         extra_config.append(f"-DCMAKE_BUILD_TYPE={build_type}")
@@ -97,7 +100,7 @@ def get_cmake_extra_config(plat_name: str | None, build_type: str) -> tuple[bool
             extra_config.append("-A Win32")
         if platform == "win-arm64" and machine != "arm64":
             extra_config.append("-A ARM64")
-    elif IS_MACOS:
+    elif is_macos or is_ios:
         known_archs = {
             "arm64",
             "arm64e",
@@ -108,10 +111,18 @@ def get_cmake_extra_config(plat_name: str | None, build_type: str) -> tuple[bool
             "ppc",
             "ppc64",
         }
-        if not platform.startswith("macosx-"):
-            msg = f"Building {platform} is not supported on macOS"
+        if is_macos and not IS_MACOS:
+            msg = f"Building {platform} is only supported on macOS"
             raise ValueError(msg)
-        _, _, platform_arch = platform.split("-")
+        if is_ios:
+            _, min_ver, platform_arch, sdk = platform.split("-")
+            min_ver = os.getenv("IPHONEOS_DEPLOYMENT_TARGET", min_ver)
+            extra_config.append("-DCMAKE_SYSTEM_NAME=iOS")
+            extra_config.append(f"-DCMAKE_OSX_SYSROOT={sdk}")
+        else:
+            _, min_ver, platform_arch = platform.split("-")
+            min_ver = os.getenv("MACOSX_DEPLOYMENT_TARGET", min_ver)
+        extra_config.append(f"-DCMAKE_OSX_DEPLOYMENT_TARGET={min_ver}")
         if platform_arch.startswith(("universal", "fat")):
             msg = f"multiple arch `{platform_arch}` is not supported"
             raise ValueError(msg)
@@ -153,6 +164,7 @@ def base64_build(plat_name: str | None) -> Generator[bool, None, None]:
         "-DBASE64_BUILD_TESTS:BOOL=OFF",
         "-DBASE64_BUILD_CLI:BOOL=OFF",
         "-DCMAKE_POSITION_INDEPENDENT_CODE=ON",
+        "-DBUILD_SHARED_LIBS:BOOL=OFF",
     ]
     if build_dir.exists():
         shutil.rmtree(build_dir)
@@ -243,6 +255,7 @@ setup(
         "Programming Language :: Python :: 3.11",
         "Programming Language :: Python :: 3.12",
         "Programming Language :: Python :: 3.13",
+        "Programming Language :: Python :: 3.14",
     ],
     # Supported python versions
     python_requires=">=3.8",

{pybase64-1.4.1 → pybase64-1.4.2}/src/pybase64/__main__.py

@@ -6,8 +6,9 @@ import sys
 from base64 import b64decode as b64decodeValidate
 from base64 import encodebytes as b64encodebytes
 from collections.abc import Sequence
+from pathlib import Path
 from timeit import default_timer as timer
-from typing import TYPE_CHECKING, Any, BinaryIO, cast
+from typing import TYPE_CHECKING, Any
 
 import pybase64
 
@@ -95,38 +96,20 @@ def bench_one(
     assert decodedcontent == data
 
 
-def readall(file: BinaryIO) -> bytes:
-    if sys.version_info[:2] == (3, 8) and file == cast(BinaryIO, sys.stdin):  # pragma: no cover
-        # Python 3 < 3.9 does not honor the binary flag,
-        # read from the underlying buffer
-        if hasattr(file, "buffer"):
-            return cast(BinaryIO, file.buffer).read()
-        return file.read()
-        # do not close the file
-    try:
-        data = file.read()
-    finally:
-        file.close()
-    return data
+def readall(file: str) -> bytes:
+    if file == "-":
+        return sys.stdin.buffer.read()
+    return Path(file).read_bytes()
 
 
-def writeall(file: BinaryIO, data: bytes) -> None:
-    if file == cast(BinaryIO, sys.stdout):
-        # Python 3 does not honor the binary flag,
-        # write to the underlying buffer
-        if hasattr(file, "buffer"):
-            file.buffer.write(data)
-        else:
-            file.write(data)  # pragma: no cover
-        # do not close the file
+def writeall(file: str, data: bytes) -> None:
+    if file == "-":
+        sys.stdout.buffer.write(data)
     else:
-        try:
-            file.write(data)
-        finally:
-            file.close()
+        Path(file).write_bytes(data)
 
 
-def benchmark(duration: float, input: BinaryIO) -> None:
+def benchmark(duration: float, input: str) -> None:
     print(__package__ + " " + pybase64.get_version())
     data = readall(input)
     for altchars in [None, b"-_"]:
@@ -152,13 +135,13 @@ def benchmark(duration: float, input: BinaryIO) -> None:
             )
 
 
-def encode(input: BinaryIO, altchars: bytes | None, output: BinaryIO) -> None:
+def encode(input: str, altchars: bytes | None, output: str) -> None:
     data = readall(input)
     data = pybase64.b64encode(data, altchars)
     writeall(output, data)
 
 
-def decode(input: BinaryIO, altchars: bytes | None, validate: bool, output: BinaryIO) -> None:
+def decode(input: str, altchars: bytes | None, validate: bool, output: str) -> None:
     data = readall(input)
     data = pybase64.b64decode(data, altchars, validate)
     writeall(output, data)
@@ -192,6 +175,15 @@ class LicenseAction(argparse.Action):
         parser.exit()
 
 
+def check_file(value: str, is_input: bool) -> str:
+    if value == "-":
+        return value
+    path = Path(value)
+    if is_input:
+        return str(path.resolve(strict=True))
+    return str(path.parent.resolve(strict=True) / path.name)
+
+
 def main(argv: Sequence[str] | None = None) -> None:
     # main parser
     parser = argparse.ArgumentParser(
@@ -217,15 +209,16 @@ def main(argv: Sequence[str] | None = None) -> None:
         default=1.0,
         help="expected duration for a single encode or decode test",
     )
+    benchmark_parser.register("type", "input file", lambda s: check_file(s, True))
     benchmark_parser.add_argument(
-        "input", type=argparse.FileType("rb"), help="input file used for the benchmark"
+        "input", type="input file", 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"
-    )
+    encode_parser.register("type", "input file", lambda s: check_file(s, True))
+    encode_parser.register("type", "output file", lambda s: check_file(s, False))
+    encode_parser.add_argument("input", type="input file", help="input file to be encoded")
     group = encode_parser.add_mutually_exclusive_group()
     group.add_argument(
         "-u",
@@ -245,16 +238,16 @@ def main(argv: Sequence[str] | None = None) -> None:
         "-o",
         "--output",
         dest="output",
-        type=argparse.FileType("wb"),
-        default=sys.stdout,
+        type="output file",
+        default="-",
         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"
-    )
+    decode_parser.register("type", "input file", lambda s: check_file(s, True))
+    decode_parser.register("type", "output file", lambda s: check_file(s, False))
+    decode_parser.add_argument("input", type="input file", help="input file to be decoded")
     group = decode_parser.add_mutually_exclusive_group()
     group.add_argument(
         "-u",
@@ -274,8 +267,8 @@ def main(argv: Sequence[str] | None = None) -> None:
         "-o",
         "--output",
         dest="output",
-        type=argparse.FileType("wb"),
-        default=sys.stdout,
+        type="output file",
+        default="-",
         help="decoded output file (default to stdout)",
     )
     decode_parser.add_argument(

{pybase64-1.4.1 → pybase64-1.4.2}/src/pybase64/_version.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-_version = "1.4.1"
+_version = "1.4.2"

{pybase64-1.4.1 → pybase64-1.4.2/src/pybase64.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: pybase64
-Version: 1.4.1
+Version: 1.4.2
 Summary: Fast Base64 encoding/decoding
 Home-page: https://github.com/mayeut/pybase64
 Author: Matthieu Darbois
@@ -22,6 +22,7 @@ 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.14
 Requires-Python: >=3.8
 Description-Content-Type: text/x-rst
 License-File: LICENSE
@@ -32,6 +33,7 @@ Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: keywords
 Dynamic: license
+Dynamic: license-file
 Dynamic: project-url
 Dynamic: requires-python
 Dynamic: summary
@@ -159,6 +161,15 @@ Running Python 3.7.2, Apple LLVM version 10.0.0 (clang-1000.11.45.5), Mac OS X 1
 
 Changelog
 =========
+1.4.2
+-----
+- Update base64 library (Windows ARM64 Neon support)
+- Publish Python 3.14 wheels
+- Publish Linux riscv64 wheels
+- Publish Android wheels
+- Publish iOS wheels
+- Publish GraalPy wheels
+
 1.4.1
 -----
 - Publish PyPy 3.11 wheels

{pybase64-1.4.1 → pybase64-1.4.2}/tests/test_main.py

@@ -138,8 +138,11 @@ def test_decode(
     assert captured.out == b"hello world !/?\n"
 
 
+@pytest.mark.skipif(
+    sys.platform.startswith(("android", "emscripten", "ios")), reason="subprocess not supported"
+)
 def test_subprocess() -> None:
-    import subprocess
+    import subprocess  # noqa: PLC0415
 
     process = subprocess.Popen(
         [sys.executable, "-m", "pybase64", "encode", "-"],

{pybase64-1.4.1 → pybase64-1.4.2}/tests/test_pybase64.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import base64
+import sys
 from base64 import encodebytes as b64encodebytes
 from binascii import Error as BinAsciiError
 from collections.abc import Callable
@@ -384,6 +385,8 @@ def test_invalid_data_dec_skip(
 ) -> None:
     utils.unused_args(exception, simd)  # simd is a parameter in order to control the order of tests
     test = dfn(vector, altchars)
+    if sys.implementation.name == "graalpy" and vector.startswith((b"A@@@=F", b"A@@=@")):
+        pytest.xfail(reason="graalpy fails decoding those entries")  # pragma: no cover
     base = base64.b64decode(vector, altchars)
     assert test == base