diff options
| -rw-r--r-- | .gitignore | 1 | ||||
| -rw-r--r-- | python-clinner.spec | 679 | ||||
| -rw-r--r-- | sources | 1 |
3 files changed, 681 insertions, 0 deletions
@@ -0,0 +1 @@ +/clinner-1.12.3.tar.gz diff --git a/python-clinner.spec b/python-clinner.spec new file mode 100644 index 0000000..704dbcd --- /dev/null +++ b/python-clinner.spec @@ -0,0 +1,679 @@ +%global _empty_manifest_terminate_build 0 +Name: python-clinner +Version: 1.12.3 +Release: 1 +Summary: Command Line Interface builder that helps creating an entry point for your application. +License: GPL-3.0+ +URL: https://github.com/PeRDy/clinner +Source0: https://mirrors.nju.edu.cn/pypi/web/packages/7e/56/0eceab162500b96a8c7c231a7aebbd4113d9dbb12c0a8c1ef416fb58e174/clinner-1.12.3.tar.gz +BuildArch: noarch + +Requires: python3-colorlog + +%description +# Clinner +[](https://travis-ci.org/PeRDy/clinner) +[](https://codecov.io/gh/PeRDy/clinner) +[](https://badge.fury.io/py/clinner) + +* **Version:** 1.12.3 +* **Status:** Production/Stable +* **Author:** José Antonio Perdiguero López + +Clinner is a library that provides some useful tools to create command line interfaces for your application + +Check [Clinner docs]. + +## Features +Can **define commands** in multiple way: +* List of shell commands such as `["docker build", "docker push"]`. +* Python functions. +* Python async functions. + +Clinner provides a set of **commands ready to use** like: +* Black. +* Flake8. +* Isort. +* Nosetest. +* Prospector. +* Pytest. +* Sphinx. +* Tox. + +Hooks for **injecting variables** or **add global arguments** to your script. + +## Quick start +Install this package using pip: + +```bash +pip install clinner +``` + +Create a command + +```python +from clinner.command import command + +@command +def foo(*args, **kwargs): + return True +``` + +Create a main file: + +```python +from clinner.run.main import Main + +if __name__ == '__main__': + sys.exit(Main().run()) +``` + +## Commands +Commands are declared using a decorator to register given functions. Commands are functions with the follow parameters: + +1. `func`: Function that will be called when command would be executed. +2. `command_type`: Type of the command, could be a *bash* or *python* command. +3. `args`: Parser arguments for this command. +4. `parser_opts`: Command subparser's keywords, such as description. + +This decorator allows to be used as a common decorator without arguments, where default type (*python*) will be used: + +```python +@command +def foobar(*args, **kwargs): + pass +``` + +Or specifying the type: + +```python +@command(command_type=CommandType.PYTHON) +def foobar(*args, **kwargs): + pass +``` + +But also is possible to provide command line arguments, as expected by argparse.ArgumentParser.add_argument: + +```python +@command(args=((('-f', '--foo'), {'help': 'Foo argument that does nothing'}), # Command argument + (('--bar',), {'action': 'store_true', 'help': 'Bar argument stored as True'})), # Another argument + parser_opts={'title': 'foobar_command', 'help': 'Help for foobar_command'}) # Parser parameters +def foobar(*args, **kwargs): + pass +``` + +All commands will be registered in a command register that can be accessed through ``command.register``. Each entry in +this register is a dictionary with the fields declared at the beginning of this section. + +### Shell command +Example of running `ls -la` shell command. + +```python +@command(command_type=CommandType.SHELL) +def lsla(*args, **kwargs): + return [shlex.split("ls -la")] +``` + +### Python function +Run a python function. + +```python +@command +def foo(*args, **kwargs): + return "foo" +``` + +### Python async function +Run a python async function. + +```python +@command +async def bar(*args, **kwargs): + await asyncio.sleep(1) + return "bar" +``` + +## Main +A main class is defined to ease the creation of command line applications. This class follows the process: + +1. Create a parser using ``argparse.ArgumentParser`` for the application: + + a) Calling all ``add_arguments(parser)`` methods from all super classes, e.g: ``clinner.mixins.HealthCheckMixin``. + + b) Addding a subparser for each command with their specific arguments. + +2. Parse arguments using the argument parser created previously. + +3. Inject variables into environment calling all super classes methods whose name starts with ``inject_``. + +## Examples +Some Clinner examples. + +### Simple Main +Example of a simple main with two defined commands `foo` and `bar`. + +```python +#!/usr/bin/env python +import shlex +import sys + +from clinner.command import command, Type as CommandType +from clinner.run.main import Main + + +@command(command_type=CommandType.SHELL, + args=(('-i', '--input'), + ('-o', '--output')), + parser_opts={'help': 'Foo command'}) +def foo(*args, **kwargs): + """List of foo commands""" + ls_cmd = shlex.split('ls') + wc_cmd = shlex.split('wc') + wc_cmd += [kwargs['input'], kwargs['output']] + + return [ls_cmd, wc_cmd] + + +@command(command_type=CommandType.PYTHON, + parser_opts={'help': 'Bar command'}) +def bar(*args, **kwargs): + """Do a bar.""" + return True + + +if __name__ == '__main__': + sys.exit(Main().run()) +``` + +### Builder Main +Example of main module with build utilities such as unit tests, lint, sphinx doc, tox and dist packaging: + +```python +#!/usr/bin/env python +import sys + +from clinner.run import Main + + +class Build(Main): + commands = ( + 'clinner.run.commands.black.black', + 'clinner.run.commands.flake8.flake8', + 'clinner.run.commands.isort.isort', + 'clinner.run.commands.pytest.pytest', + 'clinner.run.commands.sphinx.sphinx', + 'clinner.run.commands.tox.tox', + ) + + +if __name__ == '__main__': + sys.exit(Build().run()) +``` + +Check [Clinner docs] to see more advanced examples. + +[Clinner docs]: http://clinner.readthedocs.io + + +%package -n python3-clinner +Summary: Command Line Interface builder that helps creating an entry point for your application. +Provides: python-clinner +BuildRequires: python3-devel +BuildRequires: python3-setuptools +BuildRequires: python3-pip +%description -n python3-clinner +# Clinner +[](https://travis-ci.org/PeRDy/clinner) +[](https://codecov.io/gh/PeRDy/clinner) +[](https://badge.fury.io/py/clinner) + +* **Version:** 1.12.3 +* **Status:** Production/Stable +* **Author:** José Antonio Perdiguero López + +Clinner is a library that provides some useful tools to create command line interfaces for your application + +Check [Clinner docs]. + +## Features +Can **define commands** in multiple way: +* List of shell commands such as `["docker build", "docker push"]`. +* Python functions. +* Python async functions. + +Clinner provides a set of **commands ready to use** like: +* Black. +* Flake8. +* Isort. +* Nosetest. +* Prospector. +* Pytest. +* Sphinx. +* Tox. + +Hooks for **injecting variables** or **add global arguments** to your script. + +## Quick start +Install this package using pip: + +```bash +pip install clinner +``` + +Create a command + +```python +from clinner.command import command + +@command +def foo(*args, **kwargs): + return True +``` + +Create a main file: + +```python +from clinner.run.main import Main + +if __name__ == '__main__': + sys.exit(Main().run()) +``` + +## Commands +Commands are declared using a decorator to register given functions. Commands are functions with the follow parameters: + +1. `func`: Function that will be called when command would be executed. +2. `command_type`: Type of the command, could be a *bash* or *python* command. +3. `args`: Parser arguments for this command. +4. `parser_opts`: Command subparser's keywords, such as description. + +This decorator allows to be used as a common decorator without arguments, where default type (*python*) will be used: + +```python +@command +def foobar(*args, **kwargs): + pass +``` + +Or specifying the type: + +```python +@command(command_type=CommandType.PYTHON) +def foobar(*args, **kwargs): + pass +``` + +But also is possible to provide command line arguments, as expected by argparse.ArgumentParser.add_argument: + +```python +@command(args=((('-f', '--foo'), {'help': 'Foo argument that does nothing'}), # Command argument + (('--bar',), {'action': 'store_true', 'help': 'Bar argument stored as True'})), # Another argument + parser_opts={'title': 'foobar_command', 'help': 'Help for foobar_command'}) # Parser parameters +def foobar(*args, **kwargs): + pass +``` + +All commands will be registered in a command register that can be accessed through ``command.register``. Each entry in +this register is a dictionary with the fields declared at the beginning of this section. + +### Shell command +Example of running `ls -la` shell command. + +```python +@command(command_type=CommandType.SHELL) +def lsla(*args, **kwargs): + return [shlex.split("ls -la")] +``` + +### Python function +Run a python function. + +```python +@command +def foo(*args, **kwargs): + return "foo" +``` + +### Python async function +Run a python async function. + +```python +@command +async def bar(*args, **kwargs): + await asyncio.sleep(1) + return "bar" +``` + +## Main +A main class is defined to ease the creation of command line applications. This class follows the process: + +1. Create a parser using ``argparse.ArgumentParser`` for the application: + + a) Calling all ``add_arguments(parser)`` methods from all super classes, e.g: ``clinner.mixins.HealthCheckMixin``. + + b) Addding a subparser for each command with their specific arguments. + +2. Parse arguments using the argument parser created previously. + +3. Inject variables into environment calling all super classes methods whose name starts with ``inject_``. + +## Examples +Some Clinner examples. + +### Simple Main +Example of a simple main with two defined commands `foo` and `bar`. + +```python +#!/usr/bin/env python +import shlex +import sys + +from clinner.command import command, Type as CommandType +from clinner.run.main import Main + + +@command(command_type=CommandType.SHELL, + args=(('-i', '--input'), + ('-o', '--output')), + parser_opts={'help': 'Foo command'}) +def foo(*args, **kwargs): + """List of foo commands""" + ls_cmd = shlex.split('ls') + wc_cmd = shlex.split('wc') + wc_cmd += [kwargs['input'], kwargs['output']] + + return [ls_cmd, wc_cmd] + + +@command(command_type=CommandType.PYTHON, + parser_opts={'help': 'Bar command'}) +def bar(*args, **kwargs): + """Do a bar.""" + return True + + +if __name__ == '__main__': + sys.exit(Main().run()) +``` + +### Builder Main +Example of main module with build utilities such as unit tests, lint, sphinx doc, tox and dist packaging: + +```python +#!/usr/bin/env python +import sys + +from clinner.run import Main + + +class Build(Main): + commands = ( + 'clinner.run.commands.black.black', + 'clinner.run.commands.flake8.flake8', + 'clinner.run.commands.isort.isort', + 'clinner.run.commands.pytest.pytest', + 'clinner.run.commands.sphinx.sphinx', + 'clinner.run.commands.tox.tox', + ) + + +if __name__ == '__main__': + sys.exit(Build().run()) +``` + +Check [Clinner docs] to see more advanced examples. + +[Clinner docs]: http://clinner.readthedocs.io + + +%package help +Summary: Development documents and examples for clinner +Provides: python3-clinner-doc +%description help +# Clinner +[](https://travis-ci.org/PeRDy/clinner) +[](https://codecov.io/gh/PeRDy/clinner) +[](https://badge.fury.io/py/clinner) + +* **Version:** 1.12.3 +* **Status:** Production/Stable +* **Author:** José Antonio Perdiguero López + +Clinner is a library that provides some useful tools to create command line interfaces for your application + +Check [Clinner docs]. + +## Features +Can **define commands** in multiple way: +* List of shell commands such as `["docker build", "docker push"]`. +* Python functions. +* Python async functions. + +Clinner provides a set of **commands ready to use** like: +* Black. +* Flake8. +* Isort. +* Nosetest. +* Prospector. +* Pytest. +* Sphinx. +* Tox. + +Hooks for **injecting variables** or **add global arguments** to your script. + +## Quick start +Install this package using pip: + +```bash +pip install clinner +``` + +Create a command + +```python +from clinner.command import command + +@command +def foo(*args, **kwargs): + return True +``` + +Create a main file: + +```python +from clinner.run.main import Main + +if __name__ == '__main__': + sys.exit(Main().run()) +``` + +## Commands +Commands are declared using a decorator to register given functions. Commands are functions with the follow parameters: + +1. `func`: Function that will be called when command would be executed. +2. `command_type`: Type of the command, could be a *bash* or *python* command. +3. `args`: Parser arguments for this command. +4. `parser_opts`: Command subparser's keywords, such as description. + +This decorator allows to be used as a common decorator without arguments, where default type (*python*) will be used: + +```python +@command +def foobar(*args, **kwargs): + pass +``` + +Or specifying the type: + +```python +@command(command_type=CommandType.PYTHON) +def foobar(*args, **kwargs): + pass +``` + +But also is possible to provide command line arguments, as expected by argparse.ArgumentParser.add_argument: + +```python +@command(args=((('-f', '--foo'), {'help': 'Foo argument that does nothing'}), # Command argument + (('--bar',), {'action': 'store_true', 'help': 'Bar argument stored as True'})), # Another argument + parser_opts={'title': 'foobar_command', 'help': 'Help for foobar_command'}) # Parser parameters +def foobar(*args, **kwargs): + pass +``` + +All commands will be registered in a command register that can be accessed through ``command.register``. Each entry in +this register is a dictionary with the fields declared at the beginning of this section. + +### Shell command +Example of running `ls -la` shell command. + +```python +@command(command_type=CommandType.SHELL) +def lsla(*args, **kwargs): + return [shlex.split("ls -la")] +``` + +### Python function +Run a python function. + +```python +@command +def foo(*args, **kwargs): + return "foo" +``` + +### Python async function +Run a python async function. + +```python +@command +async def bar(*args, **kwargs): + await asyncio.sleep(1) + return "bar" +``` + +## Main +A main class is defined to ease the creation of command line applications. This class follows the process: + +1. Create a parser using ``argparse.ArgumentParser`` for the application: + + a) Calling all ``add_arguments(parser)`` methods from all super classes, e.g: ``clinner.mixins.HealthCheckMixin``. + + b) Addding a subparser for each command with their specific arguments. + +2. Parse arguments using the argument parser created previously. + +3. Inject variables into environment calling all super classes methods whose name starts with ``inject_``. + +## Examples +Some Clinner examples. + +### Simple Main +Example of a simple main with two defined commands `foo` and `bar`. + +```python +#!/usr/bin/env python +import shlex +import sys + +from clinner.command import command, Type as CommandType +from clinner.run.main import Main + + +@command(command_type=CommandType.SHELL, + args=(('-i', '--input'), + ('-o', '--output')), + parser_opts={'help': 'Foo command'}) +def foo(*args, **kwargs): + """List of foo commands""" + ls_cmd = shlex.split('ls') + wc_cmd = shlex.split('wc') + wc_cmd += [kwargs['input'], kwargs['output']] + + return [ls_cmd, wc_cmd] + + +@command(command_type=CommandType.PYTHON, + parser_opts={'help': 'Bar command'}) +def bar(*args, **kwargs): + """Do a bar.""" + return True + + +if __name__ == '__main__': + sys.exit(Main().run()) +``` + +### Builder Main +Example of main module with build utilities such as unit tests, lint, sphinx doc, tox and dist packaging: + +```python +#!/usr/bin/env python +import sys + +from clinner.run import Main + + +class Build(Main): + commands = ( + 'clinner.run.commands.black.black', + 'clinner.run.commands.flake8.flake8', + 'clinner.run.commands.isort.isort', + 'clinner.run.commands.pytest.pytest', + 'clinner.run.commands.sphinx.sphinx', + 'clinner.run.commands.tox.tox', + ) + + +if __name__ == '__main__': + sys.exit(Build().run()) +``` + +Check [Clinner docs] to see more advanced examples. + +[Clinner docs]: http://clinner.readthedocs.io + + +%prep +%autosetup -n clinner-1.12.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-clinner -f filelist.lst +%dir %{python3_sitelib}/* + +%files help -f doclist.lst +%{_docdir}/* + +%changelog +* Fri May 05 2023 Python_Bot <Python_Bot@openeuler.org> - 1.12.3-1 +- Package Spec generated @@ -0,0 +1 @@ +815c10d46662403c2de74e461b892a52 clinner-1.12.3.tar.gz |