1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
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.aliyun.com/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 Jun 08 2023 Python_Bot <Python_Bot@openeuler.org> - 0.1.7-1
- Package Spec generated
|
