diff options
Diffstat (limited to 'python-polidoro-argument.spec')
| -rw-r--r-- | python-polidoro-argument.spec | 564 |
1 files changed, 564 insertions, 0 deletions
diff --git a/python-polidoro-argument.spec b/python-polidoro-argument.spec new file mode 100644 index 0000000..a988fd9 --- /dev/null +++ b/python-polidoro-argument.spec @@ -0,0 +1,564 @@ +%global _empty_manifest_terminate_build 0 +Name: python-polidoro-argument +Version: 4.1.0 +Release: 1 +Summary: Package to create command line arguments for Python. +License: unlicense +URL: https://github.com/heitorpolidoro/polidoro-argument +Source0: https://mirrors.nju.edu.cn/pypi/web/packages/36/dc/c8af0d34dfa62643146cd1971c871cc44f996bdb488d46651c4db796768e/polidoro-argument-4.1.0.tar.gz +BuildArch: noarch + + +%description +# Polidoro Argument +[](https://github.com/heitorpolidoro/polidoro-argument/actions/workflows/test.yml) +[](https://github.com/heitorpolidoro/polidoro-argument/actions/workflows/python-publish.yml) +[](https://github.com/heitorpolidoro/polidoro-argument/actions/workflows/python-lint.yml) + +[](https://coveralls.io/github/heitorpolidoro/polidoro-argument?branch=master) +[](https://sonarcloud.io/summary/new_code?id=heitorpolidoro_polidoro-argument) + +[](https://github.com/heitorpolidoro/polidoro-argument/releases/latest) + + + + + + +Package to simplify creating command line arguments for scripts in Python. + +#### How to use: + +- Decorate the method you want to create an argument from with `@Argument`. +- Decorate the method you want to call from command line with `@Command`. +- Create a `PolidoroArgumentParser` +- Call `parser.parse_args()` + +All keywords arguments to `@Argument` and `@Command` are the same as in [argparse.ArgumentParser.add_argument](https://docs.python.org/3.7/library/argparse.html#the-add-argument-method) except for 'action' and 'nargs'. +'action' is a custom Action created to run the decorated method and 'nargs' is the number of parameters in the decorated method. + +###### Examples: +foo.py +```python + +from polidoro_argument import Argument, PolidoroArgumentParser + +@Argument +def bar(): + print('hi') + +PolidoroArgumentParser().parse_args() +# OR +parser = PolidoroArgumentParser() +parser.parse_args() +``` +Result: +```bash +$ python foo.py --bar +hi +``` + +You can pass argument to the method + +```python +from polidoro_argument import Argument + +@Argument +def bar(baz=None): + print(baz) +``` +```bash +$ python foo.py --bar Hello +Hello +``` +To create commands + +```python +from polidoro_argument import Command + + +@Command +def command(): + print('this is a command') +``` +```bash +$ python foo.py command +this is a command +``` +With arguments + +```python +from polidoro_argument import Command + + +@Command +def command_with_arg(arg, arg1=None): + print('this the command arg: %s, arg1: %s' % (arg, arg1)) +``` +```bash +$ python foo.py command_with_arg Hello +this the command arg: Hello, arg1: None +$ python foo.py command_with_arg Hello --arg1 World +this the command arg: Hello, arg1: World +``` +Using a Class +```python +from polidoro_argument import Argument, Command + +class ClassCommand: + @staticmethod + @Argument + def argument_in_class(): + print('argument_in_class called') + + @staticmethod + @Command + def command_in_class(arg='Oi'): + print('command_in_class called. arg=%s' % arg) +``` +```bash +$ python foo.py classcommand --argument_in_class +argument_in_class called +$ python foo.py classcommand command_in_class +command_in_class called. arg=Oi +$ python foo.py classcommand command_in_class --arg=Ola +command_in_class called. arg=Ola +``` +Undefined number of arguments + +```python +from polidoro_argument import Argument + + +@Argument +def argument(*args, **kwargs): + print(args, kwargs) + + +@Argument +def command(*args, **kwargs): + print(args, kwargs) +``` +```bash +$ python foo.py --argument arg1 arg2 kwarg1=1 kwarg2 2 # without '--' in kwargs +('arg1', 'arg2') {'kwarg1': 1, 'kwarg2: 2'} +$ python foo.py command arg1 arg2 --kwarg1=1 --kwarg2 2 # with '--' in kwargs +('arg1', 'arg2') {'kwarg1': 1, 'kwarg2: 2'} + +``` +Default Command + +It's possible to define a _default command_ to be called when no argument is passed to a command or there is some unrecognized arguments + +```python +from polidoro_argument import Command + + +class Bar(object): + help = 'cli help' + description = 'description' + + @staticmethod + @Command + def default_command(*remainder): + if remainder: + print('with remainders:', *remainder) + else: + print('without remainders') +``` +```bash +$ python foo.py bar +without remainders +$ python foo.py bar r1 r2 r3 +with remainders: r1 r2 r3 +``` + + + + +%package -n python3-polidoro-argument +Summary: Package to create command line arguments for Python. +Provides: python-polidoro-argument +BuildRequires: python3-devel +BuildRequires: python3-setuptools +BuildRequires: python3-pip +%description -n python3-polidoro-argument +# Polidoro Argument +[](https://github.com/heitorpolidoro/polidoro-argument/actions/workflows/test.yml) +[](https://github.com/heitorpolidoro/polidoro-argument/actions/workflows/python-publish.yml) +[](https://github.com/heitorpolidoro/polidoro-argument/actions/workflows/python-lint.yml) + +[](https://coveralls.io/github/heitorpolidoro/polidoro-argument?branch=master) +[](https://sonarcloud.io/summary/new_code?id=heitorpolidoro_polidoro-argument) + +[](https://github.com/heitorpolidoro/polidoro-argument/releases/latest) + + + + + + +Package to simplify creating command line arguments for scripts in Python. + +#### How to use: + +- Decorate the method you want to create an argument from with `@Argument`. +- Decorate the method you want to call from command line with `@Command`. +- Create a `PolidoroArgumentParser` +- Call `parser.parse_args()` + +All keywords arguments to `@Argument` and `@Command` are the same as in [argparse.ArgumentParser.add_argument](https://docs.python.org/3.7/library/argparse.html#the-add-argument-method) except for 'action' and 'nargs'. +'action' is a custom Action created to run the decorated method and 'nargs' is the number of parameters in the decorated method. + +###### Examples: +foo.py +```python + +from polidoro_argument import Argument, PolidoroArgumentParser + +@Argument +def bar(): + print('hi') + +PolidoroArgumentParser().parse_args() +# OR +parser = PolidoroArgumentParser() +parser.parse_args() +``` +Result: +```bash +$ python foo.py --bar +hi +``` + +You can pass argument to the method + +```python +from polidoro_argument import Argument + +@Argument +def bar(baz=None): + print(baz) +``` +```bash +$ python foo.py --bar Hello +Hello +``` +To create commands + +```python +from polidoro_argument import Command + + +@Command +def command(): + print('this is a command') +``` +```bash +$ python foo.py command +this is a command +``` +With arguments + +```python +from polidoro_argument import Command + + +@Command +def command_with_arg(arg, arg1=None): + print('this the command arg: %s, arg1: %s' % (arg, arg1)) +``` +```bash +$ python foo.py command_with_arg Hello +this the command arg: Hello, arg1: None +$ python foo.py command_with_arg Hello --arg1 World +this the command arg: Hello, arg1: World +``` +Using a Class +```python +from polidoro_argument import Argument, Command + +class ClassCommand: + @staticmethod + @Argument + def argument_in_class(): + print('argument_in_class called') + + @staticmethod + @Command + def command_in_class(arg='Oi'): + print('command_in_class called. arg=%s' % arg) +``` +```bash +$ python foo.py classcommand --argument_in_class +argument_in_class called +$ python foo.py classcommand command_in_class +command_in_class called. arg=Oi +$ python foo.py classcommand command_in_class --arg=Ola +command_in_class called. arg=Ola +``` +Undefined number of arguments + +```python +from polidoro_argument import Argument + + +@Argument +def argument(*args, **kwargs): + print(args, kwargs) + + +@Argument +def command(*args, **kwargs): + print(args, kwargs) +``` +```bash +$ python foo.py --argument arg1 arg2 kwarg1=1 kwarg2 2 # without '--' in kwargs +('arg1', 'arg2') {'kwarg1': 1, 'kwarg2: 2'} +$ python foo.py command arg1 arg2 --kwarg1=1 --kwarg2 2 # with '--' in kwargs +('arg1', 'arg2') {'kwarg1': 1, 'kwarg2: 2'} + +``` +Default Command + +It's possible to define a _default command_ to be called when no argument is passed to a command or there is some unrecognized arguments + +```python +from polidoro_argument import Command + + +class Bar(object): + help = 'cli help' + description = 'description' + + @staticmethod + @Command + def default_command(*remainder): + if remainder: + print('with remainders:', *remainder) + else: + print('without remainders') +``` +```bash +$ python foo.py bar +without remainders +$ python foo.py bar r1 r2 r3 +with remainders: r1 r2 r3 +``` + + + + +%package help +Summary: Development documents and examples for polidoro-argument +Provides: python3-polidoro-argument-doc +%description help +# Polidoro Argument +[](https://github.com/heitorpolidoro/polidoro-argument/actions/workflows/test.yml) +[](https://github.com/heitorpolidoro/polidoro-argument/actions/workflows/python-publish.yml) +[](https://github.com/heitorpolidoro/polidoro-argument/actions/workflows/python-lint.yml) + +[](https://coveralls.io/github/heitorpolidoro/polidoro-argument?branch=master) +[](https://sonarcloud.io/summary/new_code?id=heitorpolidoro_polidoro-argument) + +[](https://github.com/heitorpolidoro/polidoro-argument/releases/latest) + + + + + + +Package to simplify creating command line arguments for scripts in Python. + +#### How to use: + +- Decorate the method you want to create an argument from with `@Argument`. +- Decorate the method you want to call from command line with `@Command`. +- Create a `PolidoroArgumentParser` +- Call `parser.parse_args()` + +All keywords arguments to `@Argument` and `@Command` are the same as in [argparse.ArgumentParser.add_argument](https://docs.python.org/3.7/library/argparse.html#the-add-argument-method) except for 'action' and 'nargs'. +'action' is a custom Action created to run the decorated method and 'nargs' is the number of parameters in the decorated method. + +###### Examples: +foo.py +```python + +from polidoro_argument import Argument, PolidoroArgumentParser + +@Argument +def bar(): + print('hi') + +PolidoroArgumentParser().parse_args() +# OR +parser = PolidoroArgumentParser() +parser.parse_args() +``` +Result: +```bash +$ python foo.py --bar +hi +``` + +You can pass argument to the method + +```python +from polidoro_argument import Argument + +@Argument +def bar(baz=None): + print(baz) +``` +```bash +$ python foo.py --bar Hello +Hello +``` +To create commands + +```python +from polidoro_argument import Command + + +@Command +def command(): + print('this is a command') +``` +```bash +$ python foo.py command +this is a command +``` +With arguments + +```python +from polidoro_argument import Command + + +@Command +def command_with_arg(arg, arg1=None): + print('this the command arg: %s, arg1: %s' % (arg, arg1)) +``` +```bash +$ python foo.py command_with_arg Hello +this the command arg: Hello, arg1: None +$ python foo.py command_with_arg Hello --arg1 World +this the command arg: Hello, arg1: World +``` +Using a Class +```python +from polidoro_argument import Argument, Command + +class ClassCommand: + @staticmethod + @Argument + def argument_in_class(): + print('argument_in_class called') + + @staticmethod + @Command + def command_in_class(arg='Oi'): + print('command_in_class called. arg=%s' % arg) +``` +```bash +$ python foo.py classcommand --argument_in_class +argument_in_class called +$ python foo.py classcommand command_in_class +command_in_class called. arg=Oi +$ python foo.py classcommand command_in_class --arg=Ola +command_in_class called. arg=Ola +``` +Undefined number of arguments + +```python +from polidoro_argument import Argument + + +@Argument +def argument(*args, **kwargs): + print(args, kwargs) + + +@Argument +def command(*args, **kwargs): + print(args, kwargs) +``` +```bash +$ python foo.py --argument arg1 arg2 kwarg1=1 kwarg2 2 # without '--' in kwargs +('arg1', 'arg2') {'kwarg1': 1, 'kwarg2: 2'} +$ python foo.py command arg1 arg2 --kwarg1=1 --kwarg2 2 # with '--' in kwargs +('arg1', 'arg2') {'kwarg1': 1, 'kwarg2: 2'} + +``` +Default Command + +It's possible to define a _default command_ to be called when no argument is passed to a command or there is some unrecognized arguments + +```python +from polidoro_argument import Command + + +class Bar(object): + help = 'cli help' + description = 'description' + + @staticmethod + @Command + def default_command(*remainder): + if remainder: + print('with remainders:', *remainder) + else: + print('without remainders') +``` +```bash +$ python foo.py bar +without remainders +$ python foo.py bar r1 r2 r3 +with remainders: r1 r2 r3 +``` + + + + +%prep +%autosetup -n polidoro-argument-4.1.0 + +%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-polidoro-argument -f filelist.lst +%dir %{python3_sitelib}/* + +%files help -f doclist.lst +%{_docdir}/* + +%changelog +* Mon May 15 2023 Python_Bot <Python_Bot@openeuler.org> - 4.1.0-1 +- Package Spec generated |