automatic import of python-qaviton-package-manager

3 files changed, 700 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
index e69de29..020b488 100644
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1 @@
+/qaviton_package_manager-2019.10.22.14.18.9.619355.tar.gz
diff --git a/python-qaviton-package-manager.spec b/python-qaviton-package-manager.spec
new file mode 100644
index 0000000..f519895
--- /dev/null
+++ b/python-qaviton-package-manager.spec
@@ -0,0 +1,698 @@
+%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
+```  
+![simply_install](https://github.com/qaviton/qaviton_package_manager/blob/master/images/simply_install.JPG?raw=true)  
+## 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
+```  
+![shortcuts_api](https://github.com/qaviton/qaviton_package_manager/blob/master/images/shortcuts_api.JPG?raw=true)  
+#### 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
+```  
+![simply_install](https://github.com/qaviton/qaviton_package_manager/blob/master/images/simply_install.JPG?raw=true)  
+## 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
+```  
+![shortcuts_api](https://github.com/qaviton/qaviton_package_manager/blob/master/images/shortcuts_api.JPG?raw=true)  
+#### 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
+```  
+![simply_install](https://github.com/qaviton/qaviton_package_manager/blob/master/images/simply_install.JPG?raw=true)  
+## 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
+```  
+![shortcuts_api](https://github.com/qaviton/qaviton_package_manager/blob/master/images/shortcuts_api.JPG?raw=true)  
+#### 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
diff --git a/sources b/sources
new file mode 100644
index 0000000..b2ddc0e
--- /dev/null
+++ b/sources
@@ -0,0 +1 @@
+8b4930fbca9f17ea1e45ff62899ceb8b  qaviton_package_manager-2019.10.22.14.18.9.619355.tar.gz