%global _empty_manifest_terminate_build 0
Name: python-qaviton-package-manager
Version: 2019.10.22.14.18.9.619355
Release: 1
Summary: a package manager for git projects with private repositories
License: apache-2.0
URL: https://github.com/qaviton/qaviton_package_manager
Source0: https://mirrors.nju.edu.cn/pypi/web/packages/c7/19/1e7e10406e2ba940624c7b2e0f060f0f5fdc244485883bf3b1c685c27381/qaviton_package_manager-2019.10.22.14.18.9.619355.tar.gz
BuildArch: noarch
Requires: python3-packaging
Requires: python3-pip
Requires: python3-requests
Requires: python3-psutil
Requires: python3-cryptography
Requires: python3-setuptools
Requires: python3-qaviton-helpers
Requires: python3-qaviton-handlers
Requires: python3-qaviton-processes
Requires: python3-qaviton-pip
Requires: python3-qaviton-git
%description
Qaviton Package Manager (qpm)
is a package management tool integrated with git.
to enable management of packages both public & private,
from git repositories, in addition to the standard package manager.
Replace redundant packaging systems using qpm:
Package everything using git tags:
```
>qpm --build
|
branch: dev
|
branch: tests
|
[tag 2019.9.1]
|
[tag 2019.9.2]
|
branch: release/latest
>qpm --install "git+https://url/owner/project.git@release/latest#egg=package:>=2019.9.2"
| | | | | | | |
qaviton install vcs+protocol://project_url @branch #egg=package (optional)
package method type directory pep-440 pep-508
manager path :version_specifier
```
## Installation
```sh
pip install --upgrade qaviton_package_manager
```
### Requirements
- git 2.16+
- Python 3.6+
## Features
* CI CD workflow ✓
* managing private+public packages ✓
* managing nested private packages ✓
* cli + scripting ✓
* pip capabilities ✓
* git capabilities ✓
* pypi capabilities ✓
* automatic builds ✓
* secure credentials ✓
* cross-platform ✓
* nested/multiple packages ✗
* pip -e installs ✗ (coming soon)
* docker build ✗ (but can be used with the run function)
* docker push ✗ (but can be used with the run function)
## Usage
#### creating a manager:
```
(venv) windows> qpm ^
--create ^
--url "https://github.com/owner/project.git" ^
--username "user1" ^
--password "pass@#$" ^
--email "awsome@qaviton.com" ^
--pypi_user "supasayajin" ^
--pypi_pass "final space"
```
```bash
(venv) bash$ qpm \
--create \
--url "https://github.com/owner/project.git" \
--username "user1" \
--password "pass@#$" \
--email "awsome@qaviton.com" \
--pypi_user "supasayajin" \
--pypi_pass "final space" \
/
```
this should leave you with the following project structure:
```
project/
├ package/
│ └ __init__.py # with __author__, __version__, __author_email__, __description__, __url__, __license__
├ tests/
│ └ __init__.py
├ .gitignore
├ LICENSE
├ README.md
├ requirements.txt
├ requirements-test.txt
├ setup.py
└ package.py # ignored by .gitignore
```
now let's build a package:
```python
# package.py
from qaviton_package_manager import Manager
from qaviton_package_manager import decypt
# if this is not secure enough, you can add cache_timeout=3600
# and store credentials in memory
# manager = Manager(cache_timeout=3600)
# and we need to insert the credentials in run time: > python package.py --username "x" --password "z"
manager = Manager(**decypt(
key=b'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx==',
token=b'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx==',
))
if __name__ == "__main__":
# running with lambdas will protect you from processes getting stuck
manager.run(
lambda: manager.update(), # pip install -r requirements.txt --upgrade
lambda: manager.update_test(), # pip install -r requirements-test.txt --upgrade
lambda: manager.test(), # python -m pytest --junitxml=test_report.xml tests
lambda: manager.build(), # git commit, tag & push (internal logic is more complicated)
lambda: manager.upload(), # upload to pypi
)
```
make sure you have at list 1 passing test for your package
```python
# tests/my_package_test.py
def test_with_100p_coverage():
print("testing my package!\nPASS")
```
```bash
# we can now create a package
python package.py
```
#### CLI:
we can call any method and send any parameter to the manager through cli:
```bash
# release a version if all tests pass
qpm --username "" --password "" --update --update_test --test --build --upload
# build a stable version if all tests pass
qpm --username "" --password "" --update --update_test --test --build "stable/latest"
# install cachetools using pip and save the requirement in requirements.txt
qpm --install cachetools
# cache credentials in memory
qpm --username "" --password "" --cache_timeout "-1"
# using the system & python to execute tests
qpm --test "system" "echo success" --test "python" "-c" "print(\"py success\");"
```
#### CLI shortcuts:
we can call any method and send any parameter to the manager through cli:
```bash
# install cachetools using pip and save the requirement in requirements.txt
qpm i cachetools
# uninstall cachetools using pip and remove the requirement in requirements.txt
qpm un cachetools
# build a stable version
qpm b "stable/latest"
# run tests
qpm t
# upload to pypi
qpm up
# install cachetools using pip and save the requirement in requirements.txt
qpm install cachetools
# build package
qpm build "stable/latest"
# upload to pypi
qpm upload
```
#### Script:
```python
# ci_cd.py
from qaviton_processes import run, escape, python
from package import manager
from datetime import datetime
d = datetime.utcnow()
docker_url = manager.vars['docker_url']
docker_user = manager.vars['docker_user']
docker_pass = manager.vars['docker_pass']
docker_email = manager.vars['docker_email']
SSH_PRIVATE_KEY = manager.kwargs['SSH_PRIVATE_KEY']
docker_tag = manager.kwargs['docker_tag']
branch_build = "ci_cd/latest"
dev_branch = "dev"
manager.run(
lambda: manager.should_build(from_branch=dev_branch, to_branch=branch_build),
lambda: manager.install(),
lambda: manager.install_test(),
lambda: manager.test.pytest("tests/ci_cd"),
lambda: manager.build(to_branch=branch_build, version=f'{d.year}.{d.month}.{d.day}'),
# docker distribute
lambda: run(f"docker login --username=\"{escape(docker_user)}\" --password=\"{escape(docker_pass)}\" --email=\"{escape(docker_email)}\" \"{escape(docker_url)}\""),
lambda: run(f"docker build --force-rm -t test-multi-stage-builds --build-arg SSH_PRIVATE_KEY=\"{escape(SSH_PRIVATE_KEY)}\" ."),
lambda: run(f"docker tag {docker_tag} yourhubusername/verse_gapminder:firsttry"),
lambda: run("docker push yourhubusername/verse_gapminder"),
# deploy script
lambda: python("deploy.py")
)
```
```python
# schedualer.py
from time import time, sleep
from datetime import datetime, timedelta
from qaviton_processes import python_code_async
d = datetime.utcnow()
date = datetime(year=d.year, month=d.month, day=d.day, hour=22)
delta = timedelta(days=1)
# build a package once a day at 22pm
while True:
python_code_async('import ci_cd')
date += delta
sleep(date.timestamp()-time())
```
## warnings
* this manager is meant for automated ci cd purposes
and should not be used instead of regular git commit/push/merge.
make sure to avoid using it on unstable branches
to avoid failed packaging requests or potential data loss.
we recommend using it from a CI CD dedicated branch.
* the manager defaults to encrypted credentials,
if encrypted credentials on the disk are not secure enough,
please make sure to enable caching, to store credentials in memory
%package -n python3-qaviton-package-manager
Summary: a package manager for git projects with private repositories
Provides: python-qaviton-package-manager
BuildRequires: python3-devel
BuildRequires: python3-setuptools
BuildRequires: python3-pip
%description -n python3-qaviton-package-manager
Qaviton Package Manager (qpm)
is a package management tool integrated with git.
to enable management of packages both public & private,
from git repositories, in addition to the standard package manager.
Replace redundant packaging systems using qpm:
Package everything using git tags:
```
>qpm --build
|
branch: dev
|
branch: tests
|
[tag 2019.9.1]
|
[tag 2019.9.2]
|
branch: release/latest
>qpm --install "git+https://url/owner/project.git@release/latest#egg=package:>=2019.9.2"
| | | | | | | |
qaviton install vcs+protocol://project_url @branch #egg=package (optional)
package method type directory pep-440 pep-508
manager path :version_specifier
```
## Installation
```sh
pip install --upgrade qaviton_package_manager
```
### Requirements
- git 2.16+
- Python 3.6+
## Features
* CI CD workflow ✓
* managing private+public packages ✓
* managing nested private packages ✓
* cli + scripting ✓
* pip capabilities ✓
* git capabilities ✓
* pypi capabilities ✓
* automatic builds ✓
* secure credentials ✓
* cross-platform ✓
* nested/multiple packages ✗
* pip -e installs ✗ (coming soon)
* docker build ✗ (but can be used with the run function)
* docker push ✗ (but can be used with the run function)
## Usage
#### creating a manager:
```
(venv) windows> qpm ^
--create ^
--url "https://github.com/owner/project.git" ^
--username "user1" ^
--password "pass@#$" ^
--email "awsome@qaviton.com" ^
--pypi_user "supasayajin" ^
--pypi_pass "final space"
```
```bash
(venv) bash$ qpm \
--create \
--url "https://github.com/owner/project.git" \
--username "user1" \
--password "pass@#$" \
--email "awsome@qaviton.com" \
--pypi_user "supasayajin" \
--pypi_pass "final space" \
/
```
this should leave you with the following project structure:
```
project/
├ package/
│ └ __init__.py # with __author__, __version__, __author_email__, __description__, __url__, __license__
├ tests/
│ └ __init__.py
├ .gitignore
├ LICENSE
├ README.md
├ requirements.txt
├ requirements-test.txt
├ setup.py
└ package.py # ignored by .gitignore
```
now let's build a package:
```python
# package.py
from qaviton_package_manager import Manager
from qaviton_package_manager import decypt
# if this is not secure enough, you can add cache_timeout=3600
# and store credentials in memory
# manager = Manager(cache_timeout=3600)
# and we need to insert the credentials in run time: > python package.py --username "x" --password "z"
manager = Manager(**decypt(
key=b'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx==',
token=b'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx==',
))
if __name__ == "__main__":
# running with lambdas will protect you from processes getting stuck
manager.run(
lambda: manager.update(), # pip install -r requirements.txt --upgrade
lambda: manager.update_test(), # pip install -r requirements-test.txt --upgrade
lambda: manager.test(), # python -m pytest --junitxml=test_report.xml tests
lambda: manager.build(), # git commit, tag & push (internal logic is more complicated)
lambda: manager.upload(), # upload to pypi
)
```
make sure you have at list 1 passing test for your package
```python
# tests/my_package_test.py
def test_with_100p_coverage():
print("testing my package!\nPASS")
```
```bash
# we can now create a package
python package.py
```
#### CLI:
we can call any method and send any parameter to the manager through cli:
```bash
# release a version if all tests pass
qpm --username "" --password "" --update --update_test --test --build --upload
# build a stable version if all tests pass
qpm --username "" --password "" --update --update_test --test --build "stable/latest"
# install cachetools using pip and save the requirement in requirements.txt
qpm --install cachetools
# cache credentials in memory
qpm --username "" --password "" --cache_timeout "-1"
# using the system & python to execute tests
qpm --test "system" "echo success" --test "python" "-c" "print(\"py success\");"
```
#### CLI shortcuts:
we can call any method and send any parameter to the manager through cli:
```bash
# install cachetools using pip and save the requirement in requirements.txt
qpm i cachetools
# uninstall cachetools using pip and remove the requirement in requirements.txt
qpm un cachetools
# build a stable version
qpm b "stable/latest"
# run tests
qpm t
# upload to pypi
qpm up
# install cachetools using pip and save the requirement in requirements.txt
qpm install cachetools
# build package
qpm build "stable/latest"
# upload to pypi
qpm upload
```
#### Script:
```python
# ci_cd.py
from qaviton_processes import run, escape, python
from package import manager
from datetime import datetime
d = datetime.utcnow()
docker_url = manager.vars['docker_url']
docker_user = manager.vars['docker_user']
docker_pass = manager.vars['docker_pass']
docker_email = manager.vars['docker_email']
SSH_PRIVATE_KEY = manager.kwargs['SSH_PRIVATE_KEY']
docker_tag = manager.kwargs['docker_tag']
branch_build = "ci_cd/latest"
dev_branch = "dev"
manager.run(
lambda: manager.should_build(from_branch=dev_branch, to_branch=branch_build),
lambda: manager.install(),
lambda: manager.install_test(),
lambda: manager.test.pytest("tests/ci_cd"),
lambda: manager.build(to_branch=branch_build, version=f'{d.year}.{d.month}.{d.day}'),
# docker distribute
lambda: run(f"docker login --username=\"{escape(docker_user)}\" --password=\"{escape(docker_pass)}\" --email=\"{escape(docker_email)}\" \"{escape(docker_url)}\""),
lambda: run(f"docker build --force-rm -t test-multi-stage-builds --build-arg SSH_PRIVATE_KEY=\"{escape(SSH_PRIVATE_KEY)}\" ."),
lambda: run(f"docker tag {docker_tag} yourhubusername/verse_gapminder:firsttry"),
lambda: run("docker push yourhubusername/verse_gapminder"),
# deploy script
lambda: python("deploy.py")
)
```
```python
# schedualer.py
from time import time, sleep
from datetime import datetime, timedelta
from qaviton_processes import python_code_async
d = datetime.utcnow()
date = datetime(year=d.year, month=d.month, day=d.day, hour=22)
delta = timedelta(days=1)
# build a package once a day at 22pm
while True:
python_code_async('import ci_cd')
date += delta
sleep(date.timestamp()-time())
```
## warnings
* this manager is meant for automated ci cd purposes
and should not be used instead of regular git commit/push/merge.
make sure to avoid using it on unstable branches
to avoid failed packaging requests or potential data loss.
we recommend using it from a CI CD dedicated branch.
* the manager defaults to encrypted credentials,
if encrypted credentials on the disk are not secure enough,
please make sure to enable caching, to store credentials in memory
%package help
Summary: Development documents and examples for qaviton-package-manager
Provides: python3-qaviton-package-manager-doc
%description help
Qaviton Package Manager (qpm)
is a package management tool integrated with git.
to enable management of packages both public & private,
from git repositories, in addition to the standard package manager.
Replace redundant packaging systems using qpm:
Package everything using git tags:
```
>qpm --build
|
branch: dev
|
branch: tests
|
[tag 2019.9.1]
|
[tag 2019.9.2]
|
branch: release/latest
>qpm --install "git+https://url/owner/project.git@release/latest#egg=package:>=2019.9.2"
| | | | | | | |
qaviton install vcs+protocol://project_url @branch #egg=package (optional)
package method type directory pep-440 pep-508
manager path :version_specifier
```
## Installation
```sh
pip install --upgrade qaviton_package_manager
```
### Requirements
- git 2.16+
- Python 3.6+
## Features
* CI CD workflow ✓
* managing private+public packages ✓
* managing nested private packages ✓
* cli + scripting ✓
* pip capabilities ✓
* git capabilities ✓
* pypi capabilities ✓
* automatic builds ✓
* secure credentials ✓
* cross-platform ✓
* nested/multiple packages ✗
* pip -e installs ✗ (coming soon)
* docker build ✗ (but can be used with the run function)
* docker push ✗ (but can be used with the run function)
## Usage
#### creating a manager:
```
(venv) windows> qpm ^
--create ^
--url "https://github.com/owner/project.git" ^
--username "user1" ^
--password "pass@#$" ^
--email "awsome@qaviton.com" ^
--pypi_user "supasayajin" ^
--pypi_pass "final space"
```
```bash
(venv) bash$ qpm \
--create \
--url "https://github.com/owner/project.git" \
--username "user1" \
--password "pass@#$" \
--email "awsome@qaviton.com" \
--pypi_user "supasayajin" \
--pypi_pass "final space" \
/
```
this should leave you with the following project structure:
```
project/
├ package/
│ └ __init__.py # with __author__, __version__, __author_email__, __description__, __url__, __license__
├ tests/
│ └ __init__.py
├ .gitignore
├ LICENSE
├ README.md
├ requirements.txt
├ requirements-test.txt
├ setup.py
└ package.py # ignored by .gitignore
```
now let's build a package:
```python
# package.py
from qaviton_package_manager import Manager
from qaviton_package_manager import decypt
# if this is not secure enough, you can add cache_timeout=3600
# and store credentials in memory
# manager = Manager(cache_timeout=3600)
# and we need to insert the credentials in run time: > python package.py --username "x" --password "z"
manager = Manager(**decypt(
key=b'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx==',
token=b'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx==',
))
if __name__ == "__main__":
# running with lambdas will protect you from processes getting stuck
manager.run(
lambda: manager.update(), # pip install -r requirements.txt --upgrade
lambda: manager.update_test(), # pip install -r requirements-test.txt --upgrade
lambda: manager.test(), # python -m pytest --junitxml=test_report.xml tests
lambda: manager.build(), # git commit, tag & push (internal logic is more complicated)
lambda: manager.upload(), # upload to pypi
)
```
make sure you have at list 1 passing test for your package
```python
# tests/my_package_test.py
def test_with_100p_coverage():
print("testing my package!\nPASS")
```
```bash
# we can now create a package
python package.py
```
#### CLI:
we can call any method and send any parameter to the manager through cli:
```bash
# release a version if all tests pass
qpm --username "" --password "" --update --update_test --test --build --upload
# build a stable version if all tests pass
qpm --username "" --password "" --update --update_test --test --build "stable/latest"
# install cachetools using pip and save the requirement in requirements.txt
qpm --install cachetools
# cache credentials in memory
qpm --username "" --password "" --cache_timeout "-1"
# using the system & python to execute tests
qpm --test "system" "echo success" --test "python" "-c" "print(\"py success\");"
```
#### CLI shortcuts:
we can call any method and send any parameter to the manager through cli:
```bash
# install cachetools using pip and save the requirement in requirements.txt
qpm i cachetools
# uninstall cachetools using pip and remove the requirement in requirements.txt
qpm un cachetools
# build a stable version
qpm b "stable/latest"
# run tests
qpm t
# upload to pypi
qpm up
# install cachetools using pip and save the requirement in requirements.txt
qpm install cachetools
# build package
qpm build "stable/latest"
# upload to pypi
qpm upload
```
#### Script:
```python
# ci_cd.py
from qaviton_processes import run, escape, python
from package import manager
from datetime import datetime
d = datetime.utcnow()
docker_url = manager.vars['docker_url']
docker_user = manager.vars['docker_user']
docker_pass = manager.vars['docker_pass']
docker_email = manager.vars['docker_email']
SSH_PRIVATE_KEY = manager.kwargs['SSH_PRIVATE_KEY']
docker_tag = manager.kwargs['docker_tag']
branch_build = "ci_cd/latest"
dev_branch = "dev"
manager.run(
lambda: manager.should_build(from_branch=dev_branch, to_branch=branch_build),
lambda: manager.install(),
lambda: manager.install_test(),
lambda: manager.test.pytest("tests/ci_cd"),
lambda: manager.build(to_branch=branch_build, version=f'{d.year}.{d.month}.{d.day}'),
# docker distribute
lambda: run(f"docker login --username=\"{escape(docker_user)}\" --password=\"{escape(docker_pass)}\" --email=\"{escape(docker_email)}\" \"{escape(docker_url)}\""),
lambda: run(f"docker build --force-rm -t test-multi-stage-builds --build-arg SSH_PRIVATE_KEY=\"{escape(SSH_PRIVATE_KEY)}\" ."),
lambda: run(f"docker tag {docker_tag} yourhubusername/verse_gapminder:firsttry"),
lambda: run("docker push yourhubusername/verse_gapminder"),
# deploy script
lambda: python("deploy.py")
)
```
```python
# schedualer.py
from time import time, sleep
from datetime import datetime, timedelta
from qaviton_processes import python_code_async
d = datetime.utcnow()
date = datetime(year=d.year, month=d.month, day=d.day, hour=22)
delta = timedelta(days=1)
# build a package once a day at 22pm
while True:
python_code_async('import ci_cd')
date += delta
sleep(date.timestamp()-time())
```
## warnings
* this manager is meant for automated ci cd purposes
and should not be used instead of regular git commit/push/merge.
make sure to avoid using it on unstable branches
to avoid failed packaging requests or potential data loss.
we recommend using it from a CI CD dedicated branch.
* the manager defaults to encrypted credentials,
if encrypted credentials on the disk are not secure enough,
please make sure to enable caching, to store credentials in memory
%prep
%autosetup -n qaviton-package-manager-2019.10.22.14.18.9.619355
%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-qaviton-package-manager -f filelist.lst
%dir %{python3_sitelib}/*
%files help -f doclist.lst
%{_docdir}/*
%changelog
* Wed May 17 2023 Python_Bot <Python_Bot@openeuler.org> - 2019.10.22.14.18.9.619355-1
- Package Spec generated