%global _empty_manifest_terminate_build 0 Name: python-blake3 Version: 0.3.3 Release: 1 Summary: Python bindings for the Rust blake3 crate License: CC0-1.0 OR Apache-2.0 URL: https://github.com/oconnor663/blake3-py Source0: https://mirrors.nju.edu.cn/pypi/web/packages/7e/88/271fc900d7e8f091601c01412f3eafb62c62a9ce98091a24a822b4c392c1/blake3-0.3.3.tar.gz %description # blake3-py [![Actions Status](https://github.com/oconnor663/blake3-py/workflows/tests/badge.svg)](https://github.com/oconnor663/blake3-py/actions) [![PyPI version](https://badge.fury.io/py/blake3.svg)](https://pypi.python.org/pypi/blake3) Python bindings for the [official Rust implementation of BLAKE3](https://github.com/BLAKE3-team/BLAKE3), based on [PyO3](https://github.com/PyO3/pyo3). These bindings expose all the features of BLAKE3, including extendable output, keying, and multithreading. The basic API matches that of Python's standard [`hashlib`](https://docs.python.org/3/library/hashlib.html) module. ## Examples ```python from blake3 import blake3 # Hash some input all at once. The input can be bytes, a bytearray, or a memoryview. hash1 = blake3(b"foobarbaz").digest() # Hash the same input incrementally. hasher = blake3() hasher.update(b"foo") hasher.update(b"bar") hasher.update(b"baz") hash2 = hasher.digest() assert hash1 == hash2 # Hexadecimal output. print("The hash of 'hello world' is", blake3(b"hello world").hexdigest()) # Use the keyed hashing mode, which takes a 32-byte key. import secrets random_key = secrets.token_bytes(32) message = b"a message to authenticate" mac = blake3(message, key=random_key).digest() # Use the key derivation mode, which takes a context string. Context strings # should be hardcoded, globally unique, and application-specific. context = "blake3-py 2020-03-04 11:13:10 example context" key_material = b"usually at least 32 random bytes, not a password" derived_key = blake3(key_material, derive_key_context=context).digest() # Extendable output. The default digest size is 32 bytes. extended = blake3(b"foo").digest(length=100) assert extended[:32] == blake3(b"foo").digest() assert extended[75:100] == blake3(b"foo").digest(length=25, seek=75) # Hash a large input using multiple threads. Note that this can be slower for # inputs shorter than ~1 MB, and it's a good idea to benchmark it for your use # case on your platform. large_input = bytearray(1_000_000) hash_single = blake3(large_input).digest() hash_two = blake3(large_input, max_threads=2).digest() hash_many = blake3(large_input, max_threads=blake3.AUTO).digest() assert hash_single == hash_two == hash_many # Copy a hasher that has already accepted some input. hasher1 = blake3(b"foo") hasher2 = hasher1.copy() hasher1.update(b"bar") hasher2.update(b"baz") assert hasher1.digest() == blake3(b"foobar").digest() assert hasher2.digest() == blake3(b"foobaz").digest() ``` ## Installation ``` pip install blake3 ``` As usual with Pip, you might need to use `sudo` or the `--user` flag with the command above, depending on how you installed Python on your system. There are binary wheels [available on PyPI](https://pypi.org/project/blake3/#files) for most environments. But if you're building the source distribution, or if a binary wheel isn't available for your environment, you'll need to [install the Rust toolchain](https://rustup.rs). ## C Bindings Experimental bindings for the official BLAKE3 C implementation are available in the [`c_impl`](c_impl) directory. These will probably not be published on PyPI, and most applications should prefer the Rust-based bindings. But if you can't depend on the Rust toolchain, and you're on some platform that this project doesn't provide binary wheels for, the C-based bindings might be an alternative. %package -n python3-blake3 Summary: Python bindings for the Rust blake3 crate Provides: python-blake3 BuildRequires: python3-devel BuildRequires: python3-setuptools BuildRequires: python3-pip BuildRequires: python3-cffi BuildRequires: gcc BuildRequires: gdb %description -n python3-blake3 # blake3-py [![Actions Status](https://github.com/oconnor663/blake3-py/workflows/tests/badge.svg)](https://github.com/oconnor663/blake3-py/actions) [![PyPI version](https://badge.fury.io/py/blake3.svg)](https://pypi.python.org/pypi/blake3) Python bindings for the [official Rust implementation of BLAKE3](https://github.com/BLAKE3-team/BLAKE3), based on [PyO3](https://github.com/PyO3/pyo3). These bindings expose all the features of BLAKE3, including extendable output, keying, and multithreading. The basic API matches that of Python's standard [`hashlib`](https://docs.python.org/3/library/hashlib.html) module. ## Examples ```python from blake3 import blake3 # Hash some input all at once. The input can be bytes, a bytearray, or a memoryview. hash1 = blake3(b"foobarbaz").digest() # Hash the same input incrementally. hasher = blake3() hasher.update(b"foo") hasher.update(b"bar") hasher.update(b"baz") hash2 = hasher.digest() assert hash1 == hash2 # Hexadecimal output. print("The hash of 'hello world' is", blake3(b"hello world").hexdigest()) # Use the keyed hashing mode, which takes a 32-byte key. import secrets random_key = secrets.token_bytes(32) message = b"a message to authenticate" mac = blake3(message, key=random_key).digest() # Use the key derivation mode, which takes a context string. Context strings # should be hardcoded, globally unique, and application-specific. context = "blake3-py 2020-03-04 11:13:10 example context" key_material = b"usually at least 32 random bytes, not a password" derived_key = blake3(key_material, derive_key_context=context).digest() # Extendable output. The default digest size is 32 bytes. extended = blake3(b"foo").digest(length=100) assert extended[:32] == blake3(b"foo").digest() assert extended[75:100] == blake3(b"foo").digest(length=25, seek=75) # Hash a large input using multiple threads. Note that this can be slower for # inputs shorter than ~1 MB, and it's a good idea to benchmark it for your use # case on your platform. large_input = bytearray(1_000_000) hash_single = blake3(large_input).digest() hash_two = blake3(large_input, max_threads=2).digest() hash_many = blake3(large_input, max_threads=blake3.AUTO).digest() assert hash_single == hash_two == hash_many # Copy a hasher that has already accepted some input. hasher1 = blake3(b"foo") hasher2 = hasher1.copy() hasher1.update(b"bar") hasher2.update(b"baz") assert hasher1.digest() == blake3(b"foobar").digest() assert hasher2.digest() == blake3(b"foobaz").digest() ``` ## Installation ``` pip install blake3 ``` As usual with Pip, you might need to use `sudo` or the `--user` flag with the command above, depending on how you installed Python on your system. There are binary wheels [available on PyPI](https://pypi.org/project/blake3/#files) for most environments. But if you're building the source distribution, or if a binary wheel isn't available for your environment, you'll need to [install the Rust toolchain](https://rustup.rs). ## C Bindings Experimental bindings for the official BLAKE3 C implementation are available in the [`c_impl`](c_impl) directory. These will probably not be published on PyPI, and most applications should prefer the Rust-based bindings. But if you can't depend on the Rust toolchain, and you're on some platform that this project doesn't provide binary wheels for, the C-based bindings might be an alternative. %package help Summary: Development documents and examples for blake3 Provides: python3-blake3-doc %description help # blake3-py [![Actions Status](https://github.com/oconnor663/blake3-py/workflows/tests/badge.svg)](https://github.com/oconnor663/blake3-py/actions) [![PyPI version](https://badge.fury.io/py/blake3.svg)](https://pypi.python.org/pypi/blake3) Python bindings for the [official Rust implementation of BLAKE3](https://github.com/BLAKE3-team/BLAKE3), based on [PyO3](https://github.com/PyO3/pyo3). These bindings expose all the features of BLAKE3, including extendable output, keying, and multithreading. The basic API matches that of Python's standard [`hashlib`](https://docs.python.org/3/library/hashlib.html) module. ## Examples ```python from blake3 import blake3 # Hash some input all at once. The input can be bytes, a bytearray, or a memoryview. hash1 = blake3(b"foobarbaz").digest() # Hash the same input incrementally. hasher = blake3() hasher.update(b"foo") hasher.update(b"bar") hasher.update(b"baz") hash2 = hasher.digest() assert hash1 == hash2 # Hexadecimal output. print("The hash of 'hello world' is", blake3(b"hello world").hexdigest()) # Use the keyed hashing mode, which takes a 32-byte key. import secrets random_key = secrets.token_bytes(32) message = b"a message to authenticate" mac = blake3(message, key=random_key).digest() # Use the key derivation mode, which takes a context string. Context strings # should be hardcoded, globally unique, and application-specific. context = "blake3-py 2020-03-04 11:13:10 example context" key_material = b"usually at least 32 random bytes, not a password" derived_key = blake3(key_material, derive_key_context=context).digest() # Extendable output. The default digest size is 32 bytes. extended = blake3(b"foo").digest(length=100) assert extended[:32] == blake3(b"foo").digest() assert extended[75:100] == blake3(b"foo").digest(length=25, seek=75) # Hash a large input using multiple threads. Note that this can be slower for # inputs shorter than ~1 MB, and it's a good idea to benchmark it for your use # case on your platform. large_input = bytearray(1_000_000) hash_single = blake3(large_input).digest() hash_two = blake3(large_input, max_threads=2).digest() hash_many = blake3(large_input, max_threads=blake3.AUTO).digest() assert hash_single == hash_two == hash_many # Copy a hasher that has already accepted some input. hasher1 = blake3(b"foo") hasher2 = hasher1.copy() hasher1.update(b"bar") hasher2.update(b"baz") assert hasher1.digest() == blake3(b"foobar").digest() assert hasher2.digest() == blake3(b"foobaz").digest() ``` ## Installation ``` pip install blake3 ``` As usual with Pip, you might need to use `sudo` or the `--user` flag with the command above, depending on how you installed Python on your system. There are binary wheels [available on PyPI](https://pypi.org/project/blake3/#files) for most environments. But if you're building the source distribution, or if a binary wheel isn't available for your environment, you'll need to [install the Rust toolchain](https://rustup.rs). ## C Bindings Experimental bindings for the official BLAKE3 C implementation are available in the [`c_impl`](c_impl) directory. These will probably not be published on PyPI, and most applications should prefer the Rust-based bindings. But if you can't depend on the Rust toolchain, and you're on some platform that this project doesn't provide binary wheels for, the C-based bindings might be an alternative. %prep %autosetup -n blake3-0.3.3 %build %py3_build %install %py3_install install -d -m755 %{buildroot}/%{_pkgdocdir} if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi pushd %{buildroot} if [ -d usr/lib ]; then find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst fi if [ -d usr/lib64 ]; then find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst fi if [ -d usr/bin ]; then find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst fi if [ -d usr/sbin ]; then find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst fi touch doclist.lst if [ -d usr/share/man ]; then find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst fi popd mv %{buildroot}/filelist.lst . mv %{buildroot}/doclist.lst . %files -n python3-blake3 -f filelist.lst %dir %{python3_sitearch}/* %files help -f doclist.lst %{_docdir}/* %changelog * Tue Apr 11 2023 Python_Bot - 0.3.3-1 - Package Spec generated