diff options
| -rw-r--r-- | .gitignore | 1 | ||||
| -rw-r--r-- | python-charmonium-async-subprocess.spec | 141 | ||||
| -rw-r--r-- | sources | 1 |
3 files changed, 143 insertions, 0 deletions
@@ -0,0 +1 @@ +/charmonium.async_subprocess-0.1.7.tar.gz diff --git a/python-charmonium-async-subprocess.spec b/python-charmonium-async-subprocess.spec new file mode 100644 index 0000000..85a3b23 --- /dev/null +++ b/python-charmonium-async-subprocess.spec @@ -0,0 +1,141 @@ +%global _empty_manifest_terminate_build 0 +Name: python-charmonium.async-subprocess +Version: 0.1.7 +Release: 1 +Summary: async clone of subprocess.run +License: MIT +URL: https://github.com/charmoniumQ/charmonium.async_subprocess.git +Source0: https://mirrors.nju.edu.cn/pypi/web/packages/9d/59/071c6aa5f44b4f8adc1e75dd61db41bcc8c31ffadf9ed8f39e873f9113e3/charmonium.async_subprocess-0.1.7.tar.gz +BuildArch: noarch + + +%description +See the documentation of the main function:: + async def run( + args: Sequence[StrBytes], + cwd: Optional[Path] = None, + env: Optional[Union[Mapping[StrBytes, StrBytes]]] = None, + env_override: Optional[Mapping[StrBytes, StrBytes]] = None, + capture_output: bool = False, + check: bool = False, + text: Optional[bool] = None, + ) -> subprocess.CompletedProcess: + """An async clone of `subprocess.run`. + Suppose you have Python script that orchestrates shell commands, + but it's too slow, and you've identified commands which can run in + parallel. You could use `threading`, but that has GIL problems, or + `multiprocess`, which has a high startup-cost per worker. You are + already spinning off subprocesses, which the OS will run + concurrently, so why not use async/await programming to express + concurrency in a single thread? + Note this function does not permit you to communicate + asynchronously, just to run commands asynchronously. + This function supports a subset of the signature of + `subprocess.run`, that I will expand based on need. If you need + some functionality, submit an issue or PR. + """ + +%package -n python3-charmonium.async-subprocess +Summary: async clone of subprocess.run +Provides: python-charmonium.async-subprocess +BuildRequires: python3-devel +BuildRequires: python3-setuptools +BuildRequires: python3-pip +%description -n python3-charmonium.async-subprocess +See the documentation of the main function:: + async def run( + args: Sequence[StrBytes], + cwd: Optional[Path] = None, + env: Optional[Union[Mapping[StrBytes, StrBytes]]] = None, + env_override: Optional[Mapping[StrBytes, StrBytes]] = None, + capture_output: bool = False, + check: bool = False, + text: Optional[bool] = None, + ) -> subprocess.CompletedProcess: + """An async clone of `subprocess.run`. + Suppose you have Python script that orchestrates shell commands, + but it's too slow, and you've identified commands which can run in + parallel. You could use `threading`, but that has GIL problems, or + `multiprocess`, which has a high startup-cost per worker. You are + already spinning off subprocesses, which the OS will run + concurrently, so why not use async/await programming to express + concurrency in a single thread? + Note this function does not permit you to communicate + asynchronously, just to run commands asynchronously. + This function supports a subset of the signature of + `subprocess.run`, that I will expand based on need. If you need + some functionality, submit an issue or PR. + """ + +%package help +Summary: Development documents and examples for charmonium.async-subprocess +Provides: python3-charmonium.async-subprocess-doc +%description help +See the documentation of the main function:: + async def run( + args: Sequence[StrBytes], + cwd: Optional[Path] = None, + env: Optional[Union[Mapping[StrBytes, StrBytes]]] = None, + env_override: Optional[Mapping[StrBytes, StrBytes]] = None, + capture_output: bool = False, + check: bool = False, + text: Optional[bool] = None, + ) -> subprocess.CompletedProcess: + """An async clone of `subprocess.run`. + Suppose you have Python script that orchestrates shell commands, + but it's too slow, and you've identified commands which can run in + parallel. You could use `threading`, but that has GIL problems, or + `multiprocess`, which has a high startup-cost per worker. You are + already spinning off subprocesses, which the OS will run + concurrently, so why not use async/await programming to express + concurrency in a single thread? + Note this function does not permit you to communicate + asynchronously, just to run commands asynchronously. + This function supports a subset of the signature of + `subprocess.run`, that I will expand based on need. If you need + some functionality, submit an issue or PR. + """ + +%prep +%autosetup -n charmonium.async-subprocess-0.1.7 + +%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-charmonium.async-subprocess -f filelist.lst +%dir %{python3_sitelib}/* + +%files help -f doclist.lst +%{_docdir}/* + +%changelog +* Thu May 18 2023 Python_Bot <Python_Bot@openeuler.org> - 0.1.7-1 +- Package Spec generated @@ -0,0 +1 @@ +fbb8ed3c861a8fd3ce20b8a93f9b1947 charmonium.async_subprocess-0.1.7.tar.gz |