diff options
Diffstat (limited to 'python-smart-arg.spec')
| -rw-r--r-- | python-smart-arg.spec | 465 |
1 files changed, 465 insertions, 0 deletions
diff --git a/python-smart-arg.spec b/python-smart-arg.spec new file mode 100644 index 0000000..dd39b9a --- /dev/null +++ b/python-smart-arg.spec @@ -0,0 +1,465 @@ +%global _empty_manifest_terminate_build 0 +Name: python-smart-arg +Version: 1.1.2 +Release: 1 +Summary: Argument class <=> Human friendly cli +License: BSD-2-CLAUSE +URL: https://smart-arg.readthedocs.io +Source0: https://mirrors.nju.edu.cn/pypi/web/packages/e6/a5/dbe281299d40a574071a5704d73775970c3d148bd55cf69dd9d475bcafe0/smart-arg-1.1.2.tar.gz +BuildArch: noarch + + +%description +# Smart Argument Suite (`smart-arg`) + +[](https://GitHub.com/linkedin/smart-arg/tags/) +[](https://pypi.python.org/pypi/smart-arg/) + +Smart Argument Suite (`smart-arg`) is a slim and handy Python library that helps one work safely and conveniently +with the arguments that are represented by an immutable argument container class' fields +([`NamedTuple`](https://docs.python.org/3.7/library/typing.html?highlight=namedtuple#typing.NamedTuple) or +[`dataclass`](https://docs.python.org/3.7/library/dataclasses.html#dataclasses.dataclass) out-of-box), +and passed through command-line interfaces. + +`smart-arg` promotes arguments type-safety, enables IDEs' code autocompletion and type hints +functionalities, and helps one produce correct code. + + + +## Quick start + +The [`smart-arg`](https://pypi.org/project/smart-arg/) package is available through `pip`. +```shell +pip3 install smart-arg +``` + +Users can bring or define, if not already, their argument container class -- a `NamedTuple` or `dataclass`, +and then annotate it with `smart-arg` decorator `@arg_suite` in their Python scripts. + +Now an argument container class instance, e.g. `my_arg` of `MyArg` class, once created, is ready to be serialized by the `smart-arg` API -- +`my_arg.__to_argv__()` to a sequence of strings, passed through the command-line interface +and then deserialized back to an instance again by `my_arg = MyArg.__from_argv__(sys.argv[1:])`. + +```python +import sys +from typing import NamedTuple, List, Tuple, Dict, Optional +from smart_arg import arg_suite + + +# Define the argument container class +@arg_suite +class MyArg(NamedTuple): + """ + MyArg is smart! (docstring goes to description) + """ + nn: List[int] # Comments go to argparse help + a_tuple: Tuple[str, int] # a random tuple argument + encoder: str # Text encoder type + h_param: Dict[str, int] # Hyperparameters + batch_size: Optional[int] = None + adp: bool = True # bool is a bit tricky + embedding_dim: int = 100 # Size of embedding vector + lr: float = 1e-3 # Learning rate + + +def cli_interfaced_job_scheduler(): + """ + This is to be called by the job scheduler to set up the job launching command, + i.e., producer side of the Python job arguments + """ + # Create the argument container instance + my_arg = MyArg(nn=[3], a_tuple=("str", 1), encoder='lstm', h_param={}, adp=False) # The patched argument container class requires keyword arguments to instantiate the class + + # Serialize the argument to command-line representation + argv = my_arg.__to_argv__() + cli = 'my_job.py ' + ' '.join(argv) + # Schedule the job with command line `cli` + print(f"Executing job:\n{cli}") + # Executing job: + # my_job.py --nn 3 --a_tuple str 1 --encoder lstm --h_param --batch_size None --adp False --embedding_dim 100 --lr 0.001 + + +def my_job(my_arg: MyArg): + """ + This is the actual job defined by the input argument my_arg, + i.e., consumer side of the Python job arguments + """ + print(my_arg) + # MyArg(nn=[3], a_tuple=('str', 1), encoder='lstm', h_param={}, batch_size=None, adp=False, embedding_dim=100, lr=0.001) + + # `my_arg` can be used in later script with a typed manner, which help of IDEs (type hints and auto completion) + # ... + print(f"My network has {len(my_arg.nn)} layers with sizes of {my_arg.nn}.") + # My network has 1 layers with sizes of [3]. + + +# my_job.py +if __name__ == '__main__': + # Deserialize the command-line representation of the argument back to a container instance + arg_deserialized: MyArg = MyArg.__from_argv__(sys.argv[1:]) # Equivalent to `MyArg(None)`, one positional arg required to indicate the arg is a command-line representation. + my_job(arg_deserialized) +``` + +```shell-session +> python my_job.py -h +usage: my_job.py [-h] --nn [int [int ...]] --a_tuple str int --encoder str + --h_param [str:int [str:int ...]] [--batch_size int] + [--adp {True,False}] [--embedding_dim int] [--lr float] + +MyArg is smart! (docstring goes to description) + +optional arguments: + -h, --help show this help message and exit + --nn [int [int ...]] (List[int], required) Comments go to argparse help + --a_tuple str int (Tuple[str, int], required) a random tuple argument + --encoder str (str, required) Text encoder type + --h_param [str:int [str:int ...]] + (Dict[str, int], required) Hyperparameters + --batch_size int (Optional[int], default: None) + --adp {True,False} (bool, default: True) bool is a bit tricky + --embedding_dim int (int, default: 100) Size of embedding vector + --lr float (float, default: 0.001) Learning rate + +``` +## Promoted practices +* Focus on defining the arguments diligently, and let the `smart-arg` + (backed by [argparse.ArgumentParser](https://docs.python.org/3/library/argparse.html#argumentparser-objects)) + work its magic around command-line interface. +* Always work directly with argument container class instances when possible, even if you only need to generate the command-line representation. +* Stick to the default behavior and the basic features, think twice before using any of the [advanced features](https://smart-arg.readthedocs.io/en/latest/advanced.html#advanced-usages). + + +## More detail +For more features and implementation detail, please refer to the [documentation](https://smart-arg.readthedocs.io/). + +## Contributing + +Please read [CONTRIBUTING.md](CONTRIBUTING.md) for details on our code of conduct, and the process for submitting pull requests to us. + +## License + +This project is licensed under the BSD 2-CLAUSE LICENSE - see the [LICENSE.md](LICENSE.md) file for details + + + + +%package -n python3-smart-arg +Summary: Argument class <=> Human friendly cli +Provides: python-smart-arg +BuildRequires: python3-devel +BuildRequires: python3-setuptools +BuildRequires: python3-pip +%description -n python3-smart-arg +# Smart Argument Suite (`smart-arg`) + +[](https://GitHub.com/linkedin/smart-arg/tags/) +[](https://pypi.python.org/pypi/smart-arg/) + +Smart Argument Suite (`smart-arg`) is a slim and handy Python library that helps one work safely and conveniently +with the arguments that are represented by an immutable argument container class' fields +([`NamedTuple`](https://docs.python.org/3.7/library/typing.html?highlight=namedtuple#typing.NamedTuple) or +[`dataclass`](https://docs.python.org/3.7/library/dataclasses.html#dataclasses.dataclass) out-of-box), +and passed through command-line interfaces. + +`smart-arg` promotes arguments type-safety, enables IDEs' code autocompletion and type hints +functionalities, and helps one produce correct code. + + + +## Quick start + +The [`smart-arg`](https://pypi.org/project/smart-arg/) package is available through `pip`. +```shell +pip3 install smart-arg +``` + +Users can bring or define, if not already, their argument container class -- a `NamedTuple` or `dataclass`, +and then annotate it with `smart-arg` decorator `@arg_suite` in their Python scripts. + +Now an argument container class instance, e.g. `my_arg` of `MyArg` class, once created, is ready to be serialized by the `smart-arg` API -- +`my_arg.__to_argv__()` to a sequence of strings, passed through the command-line interface +and then deserialized back to an instance again by `my_arg = MyArg.__from_argv__(sys.argv[1:])`. + +```python +import sys +from typing import NamedTuple, List, Tuple, Dict, Optional +from smart_arg import arg_suite + + +# Define the argument container class +@arg_suite +class MyArg(NamedTuple): + """ + MyArg is smart! (docstring goes to description) + """ + nn: List[int] # Comments go to argparse help + a_tuple: Tuple[str, int] # a random tuple argument + encoder: str # Text encoder type + h_param: Dict[str, int] # Hyperparameters + batch_size: Optional[int] = None + adp: bool = True # bool is a bit tricky + embedding_dim: int = 100 # Size of embedding vector + lr: float = 1e-3 # Learning rate + + +def cli_interfaced_job_scheduler(): + """ + This is to be called by the job scheduler to set up the job launching command, + i.e., producer side of the Python job arguments + """ + # Create the argument container instance + my_arg = MyArg(nn=[3], a_tuple=("str", 1), encoder='lstm', h_param={}, adp=False) # The patched argument container class requires keyword arguments to instantiate the class + + # Serialize the argument to command-line representation + argv = my_arg.__to_argv__() + cli = 'my_job.py ' + ' '.join(argv) + # Schedule the job with command line `cli` + print(f"Executing job:\n{cli}") + # Executing job: + # my_job.py --nn 3 --a_tuple str 1 --encoder lstm --h_param --batch_size None --adp False --embedding_dim 100 --lr 0.001 + + +def my_job(my_arg: MyArg): + """ + This is the actual job defined by the input argument my_arg, + i.e., consumer side of the Python job arguments + """ + print(my_arg) + # MyArg(nn=[3], a_tuple=('str', 1), encoder='lstm', h_param={}, batch_size=None, adp=False, embedding_dim=100, lr=0.001) + + # `my_arg` can be used in later script with a typed manner, which help of IDEs (type hints and auto completion) + # ... + print(f"My network has {len(my_arg.nn)} layers with sizes of {my_arg.nn}.") + # My network has 1 layers with sizes of [3]. + + +# my_job.py +if __name__ == '__main__': + # Deserialize the command-line representation of the argument back to a container instance + arg_deserialized: MyArg = MyArg.__from_argv__(sys.argv[1:]) # Equivalent to `MyArg(None)`, one positional arg required to indicate the arg is a command-line representation. + my_job(arg_deserialized) +``` + +```shell-session +> python my_job.py -h +usage: my_job.py [-h] --nn [int [int ...]] --a_tuple str int --encoder str + --h_param [str:int [str:int ...]] [--batch_size int] + [--adp {True,False}] [--embedding_dim int] [--lr float] + +MyArg is smart! (docstring goes to description) + +optional arguments: + -h, --help show this help message and exit + --nn [int [int ...]] (List[int], required) Comments go to argparse help + --a_tuple str int (Tuple[str, int], required) a random tuple argument + --encoder str (str, required) Text encoder type + --h_param [str:int [str:int ...]] + (Dict[str, int], required) Hyperparameters + --batch_size int (Optional[int], default: None) + --adp {True,False} (bool, default: True) bool is a bit tricky + --embedding_dim int (int, default: 100) Size of embedding vector + --lr float (float, default: 0.001) Learning rate + +``` +## Promoted practices +* Focus on defining the arguments diligently, and let the `smart-arg` + (backed by [argparse.ArgumentParser](https://docs.python.org/3/library/argparse.html#argumentparser-objects)) + work its magic around command-line interface. +* Always work directly with argument container class instances when possible, even if you only need to generate the command-line representation. +* Stick to the default behavior and the basic features, think twice before using any of the [advanced features](https://smart-arg.readthedocs.io/en/latest/advanced.html#advanced-usages). + + +## More detail +For more features and implementation detail, please refer to the [documentation](https://smart-arg.readthedocs.io/). + +## Contributing + +Please read [CONTRIBUTING.md](CONTRIBUTING.md) for details on our code of conduct, and the process for submitting pull requests to us. + +## License + +This project is licensed under the BSD 2-CLAUSE LICENSE - see the [LICENSE.md](LICENSE.md) file for details + + + + +%package help +Summary: Development documents and examples for smart-arg +Provides: python3-smart-arg-doc +%description help +# Smart Argument Suite (`smart-arg`) + +[](https://GitHub.com/linkedin/smart-arg/tags/) +[](https://pypi.python.org/pypi/smart-arg/) + +Smart Argument Suite (`smart-arg`) is a slim and handy Python library that helps one work safely and conveniently +with the arguments that are represented by an immutable argument container class' fields +([`NamedTuple`](https://docs.python.org/3.7/library/typing.html?highlight=namedtuple#typing.NamedTuple) or +[`dataclass`](https://docs.python.org/3.7/library/dataclasses.html#dataclasses.dataclass) out-of-box), +and passed through command-line interfaces. + +`smart-arg` promotes arguments type-safety, enables IDEs' code autocompletion and type hints +functionalities, and helps one produce correct code. + + + +## Quick start + +The [`smart-arg`](https://pypi.org/project/smart-arg/) package is available through `pip`. +```shell +pip3 install smart-arg +``` + +Users can bring or define, if not already, their argument container class -- a `NamedTuple` or `dataclass`, +and then annotate it with `smart-arg` decorator `@arg_suite` in their Python scripts. + +Now an argument container class instance, e.g. `my_arg` of `MyArg` class, once created, is ready to be serialized by the `smart-arg` API -- +`my_arg.__to_argv__()` to a sequence of strings, passed through the command-line interface +and then deserialized back to an instance again by `my_arg = MyArg.__from_argv__(sys.argv[1:])`. + +```python +import sys +from typing import NamedTuple, List, Tuple, Dict, Optional +from smart_arg import arg_suite + + +# Define the argument container class +@arg_suite +class MyArg(NamedTuple): + """ + MyArg is smart! (docstring goes to description) + """ + nn: List[int] # Comments go to argparse help + a_tuple: Tuple[str, int] # a random tuple argument + encoder: str # Text encoder type + h_param: Dict[str, int] # Hyperparameters + batch_size: Optional[int] = None + adp: bool = True # bool is a bit tricky + embedding_dim: int = 100 # Size of embedding vector + lr: float = 1e-3 # Learning rate + + +def cli_interfaced_job_scheduler(): + """ + This is to be called by the job scheduler to set up the job launching command, + i.e., producer side of the Python job arguments + """ + # Create the argument container instance + my_arg = MyArg(nn=[3], a_tuple=("str", 1), encoder='lstm', h_param={}, adp=False) # The patched argument container class requires keyword arguments to instantiate the class + + # Serialize the argument to command-line representation + argv = my_arg.__to_argv__() + cli = 'my_job.py ' + ' '.join(argv) + # Schedule the job with command line `cli` + print(f"Executing job:\n{cli}") + # Executing job: + # my_job.py --nn 3 --a_tuple str 1 --encoder lstm --h_param --batch_size None --adp False --embedding_dim 100 --lr 0.001 + + +def my_job(my_arg: MyArg): + """ + This is the actual job defined by the input argument my_arg, + i.e., consumer side of the Python job arguments + """ + print(my_arg) + # MyArg(nn=[3], a_tuple=('str', 1), encoder='lstm', h_param={}, batch_size=None, adp=False, embedding_dim=100, lr=0.001) + + # `my_arg` can be used in later script with a typed manner, which help of IDEs (type hints and auto completion) + # ... + print(f"My network has {len(my_arg.nn)} layers with sizes of {my_arg.nn}.") + # My network has 1 layers with sizes of [3]. + + +# my_job.py +if __name__ == '__main__': + # Deserialize the command-line representation of the argument back to a container instance + arg_deserialized: MyArg = MyArg.__from_argv__(sys.argv[1:]) # Equivalent to `MyArg(None)`, one positional arg required to indicate the arg is a command-line representation. + my_job(arg_deserialized) +``` + +```shell-session +> python my_job.py -h +usage: my_job.py [-h] --nn [int [int ...]] --a_tuple str int --encoder str + --h_param [str:int [str:int ...]] [--batch_size int] + [--adp {True,False}] [--embedding_dim int] [--lr float] + +MyArg is smart! (docstring goes to description) + +optional arguments: + -h, --help show this help message and exit + --nn [int [int ...]] (List[int], required) Comments go to argparse help + --a_tuple str int (Tuple[str, int], required) a random tuple argument + --encoder str (str, required) Text encoder type + --h_param [str:int [str:int ...]] + (Dict[str, int], required) Hyperparameters + --batch_size int (Optional[int], default: None) + --adp {True,False} (bool, default: True) bool is a bit tricky + --embedding_dim int (int, default: 100) Size of embedding vector + --lr float (float, default: 0.001) Learning rate + +``` +## Promoted practices +* Focus on defining the arguments diligently, and let the `smart-arg` + (backed by [argparse.ArgumentParser](https://docs.python.org/3/library/argparse.html#argumentparser-objects)) + work its magic around command-line interface. +* Always work directly with argument container class instances when possible, even if you only need to generate the command-line representation. +* Stick to the default behavior and the basic features, think twice before using any of the [advanced features](https://smart-arg.readthedocs.io/en/latest/advanced.html#advanced-usages). + + +## More detail +For more features and implementation detail, please refer to the [documentation](https://smart-arg.readthedocs.io/). + +## Contributing + +Please read [CONTRIBUTING.md](CONTRIBUTING.md) for details on our code of conduct, and the process for submitting pull requests to us. + +## License + +This project is licensed under the BSD 2-CLAUSE LICENSE - see the [LICENSE.md](LICENSE.md) file for details + + + + +%prep +%autosetup -n smart-arg-1.1.2 + +%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-smart-arg -f filelist.lst +%dir %{python3_sitelib}/* + +%files help -f doclist.lst +%{_docdir}/* + +%changelog +* Fri May 05 2023 Python_Bot <Python_Bot@openeuler.org> - 1.1.2-1 +- Package Spec generated |