automatic import of python-blake3

3 files changed, 340 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
index e69de29..a9030ba 100644
--- a/.gitignore
+++ b/.gitignore
@@ -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 [![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 <Python_Bot@openeuler.org> - 0.3.3-1
+- Package Spec generated
diff --git a/sources b/sources
new file mode 100644
index 0000000..591a15e
--- /dev/null
+++ b/sources
@@ -0,0 +1 @@
+5477d22e9d8ae8e805f1f1d6303cd3f7  blake3-0.3.3.tar.gz