diff options
| -rw-r--r-- | .gitignore | 1 | ||||
| -rw-r--r-- | python-blake3.spec | 338 | ||||
| -rw-r--r-- | sources | 1 |
3 files changed, 340 insertions, 0 deletions
@@ -0,0 +1 @@ +/blake3-0.3.3.tar.gz diff --git a/python-blake3.spec b/python-blake3.spec new file mode 100644 index 0000000..b1679bb --- /dev/null +++ b/python-blake3.spec @@ -0,0 +1,338 @@ +%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 [](https://github.com/oconnor663/blake3-py/actions) [](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 [](https://github.com/oconnor663/blake3-py/actions) [](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 [](https://github.com/oconnor663/blake3-py/actions) [](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 <Python_Bot@openeuler.org> - 0.3.3-1 +- Package Spec generated @@ -0,0 +1 @@ +5477d22e9d8ae8e805f1f1d6303cd3f7 blake3-0.3.3.tar.gz |