automatic import of python-partialwrap

3 files changed, 313 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
index e69de29..7d61469 100644
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1 @@
+/partialwrap-1.7.tar.gz
diff --git a/python-partialwrap.spec b/python-partialwrap.spec
new file mode 100644
index 0000000..33f2da7
--- /dev/null
+++ b/python-partialwrap.spec
@@ -0,0 +1,311 @@
+%global _empty_manifest_terminate_build 0
+Name:		python-partialwrap
+Version:	1.7
+Release:	1
+Summary:	partialwrap: A small Python library providing wrappers for external executables and Python functions so that they can easily be partialised with Pythons functools.partial
+License:	MIT
+URL:		https://github.com/mcuntz/partialwrap
+Source0:	https://mirrors.nju.edu.cn/pypi/web/packages/31/fa/aeb2582f9f4fed29e5cbdb2ecf292f9881fcbddfacacd3e3177800fb3c25/partialwrap-1.7.tar.gz
+BuildArch:	noarch
+
+Requires:	python3-numpy
+Requires:	python3-numpy
+Requires:	python3-scipy
+Requires:	python3-emcee
+Requires:	python3-numpydoc
+Requires:	python3-jinja2
+Requires:	python3-sphinx
+Requires:	python3-sphinx-rtd-theme
+Requires:	python3-coverage[toml]
+Requires:	python3-pytest
+Requires:	python3-pytest-cov
+
+%description
+*partialwrap* provides wrapper functions to work with external executables:
+`partialwrap.exe_wrapper` and `partialwrap.exe_mask_wrapper`.
+*partialwrap* writes the sampled parameter sets into files that can be read by
+the external program. The program writes its result to a file that will then be
+read by *partialwrap* in return. This means *partialwrap* needs to have a
+function `parameterwriter` that writes the parameter file `parameterfile` needed
+by the executable `exe`. It then needs to have a function `outputreader` for
+reading the output file `outputfile` of the external executable `exe`.
+Consider for simplicity an external Python program (e.g. `rastrigin1.py`) that
+calculates the Rastrigin function with `a = 10` and `b = 2*pi`, reading in an
+arbitrary number of parameters `x_i` from a `parameterfile = params.txt` and
+writing its output into an `outputfile = out.txt`:
+```python
+    # File: rastrigin1.py
+    # Rastrigin function a=10, b=2*pi
+    import numpy as np
+    def rastrigin1(x):
+        return 10.*len(x) + np.sum(x**2 - 10.*np.cos(2.*np.pi*x))
+    # read parameters
+    from partialwrap import standard_parameter_reader
+    x = standard_parameter_reader('params.txt')
+    # calc function
+    y = rastrigin1(x)
+    # write output file
+    with open('out.txt', 'w') as ff:
+        print(y, file=ff)
+```
+This program can be called on the command line with:
+```bash
+    python rastrigin1.py
+```
+The external program can be used with Python's `functools.partial` and the
+wrapper function `partialwrap.exe_wrapper`:
+```python
+    from functools import partial
+    from partialwrap import exe_wrapper, standard_parameter_writer, standard_output_reader
+    rastrigin_exe  = ['python3', 'rastrigin1.py']
+    parameterfile  = 'params.txt'
+    outputfile     = 'out.txt'
+    rastrigin_wrap = partial(exe_wrapper, rastrigin_exe,
+                             parameterfile, standard_parameter_writer,
+                             outputfile, standard_output_reader, {})
+    x0  = [0.1, 0.2, 0.3]
+    res = opt.minimize(rastrigin_wrap, x0, method='BFGS')
+```
+`partialwrap.standard_parameter_reader` and
+`partialwrap.standard_parameter_writer` are convenience functions that read and
+write one parameter per line in a file without a header. The function
+`partialwrap.standard_output_reader` simply reads one value from a file without
+header. The empty dictionary at the end is explained in the
+[userguide](https://partialwrap.readthedocs.io/en/latest/userguide.html).
+One can easily imagine to replace the Python program `rastrigin1.py` by any
+compiled executable from C, Fortran or alike. See the
+[userguide](https://partialwrap.readthedocs.io/en/latest/userguide.html) for
+details.
+## Installation
+The easiest way to install is via `pip`:
+```bash
+    pip install partialwrap
+```
+See the [installation instructions](http://partialwrap.readthedocs.io/en/latest/install.html)
+in the [documentation](http://partialwrap.readthedocs.io) for more information.
+## Requirements:
+- [NumPy](https://www.numpy.org)
+## License
+*partialwrap* is distributed under the MIT License.  
+See the [LICENSE](https://github.com/mcuntz/partialwrap/LICENSE) file for details.
+Copyright (c) 2016-2021 Matthias Cuntz
+The project structure is based on a
+[template](https://github.com/MuellerSeb/template) provided by [Sebastian
+Müller](https://github.com/MuellerSeb).
+## Contributing to partialwrap
+Users are welcome to submit bug reports, feature requests, and code
+contributions to this project through GitHub.
+More information is available in the
+[Contributing](http://partialwrap.readthedocs.org/en/latest/contributing.html)
+guidelines.
+
+%package -n python3-partialwrap
+Summary:	partialwrap: A small Python library providing wrappers for external executables and Python functions so that they can easily be partialised with Pythons functools.partial
+Provides:	python-partialwrap
+BuildRequires:	python3-devel
+BuildRequires:	python3-setuptools
+BuildRequires:	python3-pip
+%description -n python3-partialwrap
+*partialwrap* provides wrapper functions to work with external executables:
+`partialwrap.exe_wrapper` and `partialwrap.exe_mask_wrapper`.
+*partialwrap* writes the sampled parameter sets into files that can be read by
+the external program. The program writes its result to a file that will then be
+read by *partialwrap* in return. This means *partialwrap* needs to have a
+function `parameterwriter` that writes the parameter file `parameterfile` needed
+by the executable `exe`. It then needs to have a function `outputreader` for
+reading the output file `outputfile` of the external executable `exe`.
+Consider for simplicity an external Python program (e.g. `rastrigin1.py`) that
+calculates the Rastrigin function with `a = 10` and `b = 2*pi`, reading in an
+arbitrary number of parameters `x_i` from a `parameterfile = params.txt` and
+writing its output into an `outputfile = out.txt`:
+```python
+    # File: rastrigin1.py
+    # Rastrigin function a=10, b=2*pi
+    import numpy as np
+    def rastrigin1(x):
+        return 10.*len(x) + np.sum(x**2 - 10.*np.cos(2.*np.pi*x))
+    # read parameters
+    from partialwrap import standard_parameter_reader
+    x = standard_parameter_reader('params.txt')
+    # calc function
+    y = rastrigin1(x)
+    # write output file
+    with open('out.txt', 'w') as ff:
+        print(y, file=ff)
+```
+This program can be called on the command line with:
+```bash
+    python rastrigin1.py
+```
+The external program can be used with Python's `functools.partial` and the
+wrapper function `partialwrap.exe_wrapper`:
+```python
+    from functools import partial
+    from partialwrap import exe_wrapper, standard_parameter_writer, standard_output_reader
+    rastrigin_exe  = ['python3', 'rastrigin1.py']
+    parameterfile  = 'params.txt'
+    outputfile     = 'out.txt'
+    rastrigin_wrap = partial(exe_wrapper, rastrigin_exe,
+                             parameterfile, standard_parameter_writer,
+                             outputfile, standard_output_reader, {})
+    x0  = [0.1, 0.2, 0.3]
+    res = opt.minimize(rastrigin_wrap, x0, method='BFGS')
+```
+`partialwrap.standard_parameter_reader` and
+`partialwrap.standard_parameter_writer` are convenience functions that read and
+write one parameter per line in a file without a header. The function
+`partialwrap.standard_output_reader` simply reads one value from a file without
+header. The empty dictionary at the end is explained in the
+[userguide](https://partialwrap.readthedocs.io/en/latest/userguide.html).
+One can easily imagine to replace the Python program `rastrigin1.py` by any
+compiled executable from C, Fortran or alike. See the
+[userguide](https://partialwrap.readthedocs.io/en/latest/userguide.html) for
+details.
+## Installation
+The easiest way to install is via `pip`:
+```bash
+    pip install partialwrap
+```
+See the [installation instructions](http://partialwrap.readthedocs.io/en/latest/install.html)
+in the [documentation](http://partialwrap.readthedocs.io) for more information.
+## Requirements:
+- [NumPy](https://www.numpy.org)
+## License
+*partialwrap* is distributed under the MIT License.  
+See the [LICENSE](https://github.com/mcuntz/partialwrap/LICENSE) file for details.
+Copyright (c) 2016-2021 Matthias Cuntz
+The project structure is based on a
+[template](https://github.com/MuellerSeb/template) provided by [Sebastian
+Müller](https://github.com/MuellerSeb).
+## Contributing to partialwrap
+Users are welcome to submit bug reports, feature requests, and code
+contributions to this project through GitHub.
+More information is available in the
+[Contributing](http://partialwrap.readthedocs.org/en/latest/contributing.html)
+guidelines.
+
+%package help
+Summary:	Development documents and examples for partialwrap
+Provides:	python3-partialwrap-doc
+%description help
+*partialwrap* provides wrapper functions to work with external executables:
+`partialwrap.exe_wrapper` and `partialwrap.exe_mask_wrapper`.
+*partialwrap* writes the sampled parameter sets into files that can be read by
+the external program. The program writes its result to a file that will then be
+read by *partialwrap* in return. This means *partialwrap* needs to have a
+function `parameterwriter` that writes the parameter file `parameterfile` needed
+by the executable `exe`. It then needs to have a function `outputreader` for
+reading the output file `outputfile` of the external executable `exe`.
+Consider for simplicity an external Python program (e.g. `rastrigin1.py`) that
+calculates the Rastrigin function with `a = 10` and `b = 2*pi`, reading in an
+arbitrary number of parameters `x_i` from a `parameterfile = params.txt` and
+writing its output into an `outputfile = out.txt`:
+```python
+    # File: rastrigin1.py
+    # Rastrigin function a=10, b=2*pi
+    import numpy as np
+    def rastrigin1(x):
+        return 10.*len(x) + np.sum(x**2 - 10.*np.cos(2.*np.pi*x))
+    # read parameters
+    from partialwrap import standard_parameter_reader
+    x = standard_parameter_reader('params.txt')
+    # calc function
+    y = rastrigin1(x)
+    # write output file
+    with open('out.txt', 'w') as ff:
+        print(y, file=ff)
+```
+This program can be called on the command line with:
+```bash
+    python rastrigin1.py
+```
+The external program can be used with Python's `functools.partial` and the
+wrapper function `partialwrap.exe_wrapper`:
+```python
+    from functools import partial
+    from partialwrap import exe_wrapper, standard_parameter_writer, standard_output_reader
+    rastrigin_exe  = ['python3', 'rastrigin1.py']
+    parameterfile  = 'params.txt'
+    outputfile     = 'out.txt'
+    rastrigin_wrap = partial(exe_wrapper, rastrigin_exe,
+                             parameterfile, standard_parameter_writer,
+                             outputfile, standard_output_reader, {})
+    x0  = [0.1, 0.2, 0.3]
+    res = opt.minimize(rastrigin_wrap, x0, method='BFGS')
+```
+`partialwrap.standard_parameter_reader` and
+`partialwrap.standard_parameter_writer` are convenience functions that read and
+write one parameter per line in a file without a header. The function
+`partialwrap.standard_output_reader` simply reads one value from a file without
+header. The empty dictionary at the end is explained in the
+[userguide](https://partialwrap.readthedocs.io/en/latest/userguide.html).
+One can easily imagine to replace the Python program `rastrigin1.py` by any
+compiled executable from C, Fortran or alike. See the
+[userguide](https://partialwrap.readthedocs.io/en/latest/userguide.html) for
+details.
+## Installation
+The easiest way to install is via `pip`:
+```bash
+    pip install partialwrap
+```
+See the [installation instructions](http://partialwrap.readthedocs.io/en/latest/install.html)
+in the [documentation](http://partialwrap.readthedocs.io) for more information.
+## Requirements:
+- [NumPy](https://www.numpy.org)
+## License
+*partialwrap* is distributed under the MIT License.  
+See the [LICENSE](https://github.com/mcuntz/partialwrap/LICENSE) file for details.
+Copyright (c) 2016-2021 Matthias Cuntz
+The project structure is based on a
+[template](https://github.com/MuellerSeb/template) provided by [Sebastian
+Müller](https://github.com/MuellerSeb).
+## Contributing to partialwrap
+Users are welcome to submit bug reports, feature requests, and code
+contributions to this project through GitHub.
+More information is available in the
+[Contributing](http://partialwrap.readthedocs.org/en/latest/contributing.html)
+guidelines.
+
+%prep
+%autosetup -n partialwrap-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-partialwrap -f filelist.lst
+%dir %{python3_sitelib}/*
+
+%files help -f doclist.lst
+%{_docdir}/*
+
+%changelog
+* Wed May 31 2023 Python_Bot <Python_Bot@openeuler.org> - 1.7-1
+- Package Spec generated
diff --git a/sources b/sources
new file mode 100644
index 0000000..bae13d7
--- /dev/null
+++ b/sources
@@ -0,0 +1 @@
+11d72f4511504c0ba4ae86f4ede367a3  partialwrap-1.7.tar.gz