valentina/scripts/deploy.py
Roman Telezhynskyi d7be594820 Fix cleaning mask.
2024-04-15 15:46:18 +03:00

245 lines
9.6 KiB
Python

import argparse
import datetime
import os
import pathlib
import re
import shutil
import sys
import py7zr
import dropbox
from dropbox import DropboxOAuth2FlowNoRedirect
from dropbox.exceptions import ApiError, AuthError
from dropbox.files import WriteMode
APP_KEY = "v33m5tjz020h7uy"
def run_auth():
"""
Use to generate a refresh token
"""
auth_flow = DropboxOAuth2FlowNoRedirect(APP_KEY, use_pkce=True, token_access_type='offline')
authorize_url = auth_flow.start()
print(f"1. Go to: {authorize_url}")
print("2. Click \"Allow\" (you might have to log in first).")
print("3. Copy the authorization code.")
auth_code = input("Enter the authorization code here: ").strip()
try:
oauth_result = auth_flow.finish(auth_code)
except Exception as e:
print(f'Error: {e}')
exit(1)
print(f"Refresh token: {oauth_result.refresh_token}")
def run_pack(source, destination):
"""
Pack folder. Automatically fills arguments for shutil.make_archive.
:param source: path to source root directory. Example: '/path/to/folder/'
:param destination: path to resulting zip archive. The path must include a format suffix.
Example: '/path/to/folder.zip'
"""
base = os.path.basename(destination)
name = base.split('.')[0]
formats = {
".zip": "zip",
".tar.xz": "xztar",
".7z": "7zip"
}
suffix = ''.join(pathlib.Path(base).suffixes)
archive_from = pathlib.Path(source).parent
archive_to = os.path.basename(source.strip(os.sep))
print(source, destination, archive_from)
format = formats.get(suffix)
if format:
if format == "7zip":
with py7zr.SevenZipFile(f"{name}{suffix}", 'w') as archive:
archive.writeall(source, arcname=os.path.basename(source))
else:
shutil.make_archive(name, format, archive_from, archive_to)
shutil.move(f'{name}{suffix}', destination)
else:
print("Unsupported archive format.")
def run_upload(refresh_token, file, path):
with dropbox.Dropbox(oauth2_refresh_token=refresh_token, app_key=APP_KEY) as dbx:
# Check that the access token is valid
try:
dbx.users_get_current_account()
except AuthError:
sys.exit("ERROR: Invalid access token; try re-generating an "
"access token from the app console on the web.")
print(f"Uploading {file} to Dropbox as {path}...")
try:
with open(file, "rb") as f:
dbx.files_upload(f.read(), path, mode=WriteMode('overwrite'))
except ApiError as err:
# This checks for the specific error where a user doesn't have
# enough Dropbox space quota to upload this file
if (err.error.is_path() and
err.error.get_path().reason.is_insufficient_space()):
sys.exit("ERROR: Cannot deploy; insufficient space.")
elif err.user_message_text:
print(err.user_message_text)
sys.exit()
else:
print(err)
sys.exit()
print("Successfully uploaded")
def folder_mod_time(dbx, folder):
folder_mod_times = []
entries = dbx.files_list_folder(folder.path_display)
# Loop through each item in the folder list
for result in entries.entries:
# Check if the item is a file
if isinstance(result, dropbox.files.FileMetadata):
# Get the parent folder path of the file
parent_folder_path = result.path_display.rsplit('/', 1)[0]
# Get the modification time of the file
file_mod_time = result.client_modified
# Add the file modification time to the dictionary for the parent folder
folder_mod_times.append(file_mod_time)
folder_mod_times.append(datetime.datetime(1900, 1, 1, 0, 0, 0))
# Compute the maximum modification time across all files in each folder
max_mod_time = max(folder_mod_times)
return max_mod_time
# Define a function to delete a file or folder recursively
def delete_file_or_folder(dbx, item):
try:
# Check if the path is a file
if isinstance(item, dropbox.files.FileMetadata):
dbx.files_delete_v2(item.path_display)
print(f"Deleted file: {item.path_display}")
# Check if the path is a folder
elif isinstance(item, dropbox.files.FolderMetadata):
# Recursively delete all files and subfolders inside the folder
for entry in dbx.files_list_folder(item.path_display).entries:
delete_file_or_folder(dbx, entry)
# Delete the folder itself
dbx.files_delete_v2(item.path_display)
print(f"Deleted folder: {item.path_display}")
except dropbox.exceptions.ApiError as e:
print(f"Error deleting {item.path_display}: {e}")
def run_clean(refresh_token):
with dropbox.Dropbox(oauth2_refresh_token=refresh_token, app_key=APP_KEY) as dbx:
# Check that the access token is valid
try:
dbx.users_get_current_account()
except AuthError:
sys.exit("ERROR: Invalid access token; try re-generating an "
"access token from the app console on the web.")
clean_folders = ["/0.7.x/Mac OS X", "/0.7.x/Windows", "/0.7.x/Linux"]
arhive_types = [r'^valentina-Windows10\+-mingw-x64-Qt.*-develop-[a-f0-9]{40}\.exe$',
r'^valentina-Windows7\+-mingw-x86-Qt.*-develop-[a-f0-9]{40}\.exe$',
r'^valentina-Windows10\+-msvc-x64-Qt.*-develop-[a-f0-9]{40}\.exe$',
r'^valentina-Windows7\+-msvc-x86-Qt.*-develop-[a-f0-9]{40}\.exe$',
r'^valentina-portable-Windows10\+-mingw-x64-Qt.*-develop-[a-f0-9]{40}\.7z$',
r'^valentina-portable-Windows7\+-mingw-x86-Qt.*-develop-[a-f0-9]{40}\.7z$',
r'^valentina-portable-Windows10\+-msvc-x64-Qt.*-develop-[a-f0-9]{40}\.7z$',
r'^valentina-portable-Windows7\+-msvc-x86-Qt.*-develop-[a-f0-9]{40}\.7z$',
r'^valentina-macOS_12.4\+-Qt.*-x64-develop-[a-f0-9]{40}\.dmg$',
r'^valentina-macOS_12.4\+-Qt.*-x64-develop-multibundle-[a-f0-9]{40}\.dmg$',
r'^valentina-macOS_12\+-Qt.*-x64-develop-[a-f0-9]{40}\.dmg$',
r'^valentina-macOS_12\+-Qt.*-x64-develop-multibundle-[a-f0-9]{40}\.dmg$',
r'^valentina-macOS_10.13\+-Qt.*-x64-develop-[a-f0-9]{40}\.dmg$',
r'^valentina-macOS_10.13\+-Qt.*-x64-develop-multibundle-[a-f0-9]{40}\.dmg$',
r'^valentina-macOS.*\+-Qt.*-arm.*-develop-[a-f0-9]{40}\.dmg$',
r'^valentina-macOS.*\+-Qt.*-arm.*-develop-multibundle-[a-f0-9]{40}\.dmg$',
r'^valentina-Linux-x86_64-develop-[a-f0-9]{40}\.AppImage$']
item_types = {}
for path in clean_folders:
result = dbx.files_list_folder(path)
for entry in result.entries:
for archive_type in arhive_types:
if re.search(archive_type, entry.name):
if archive_type not in item_types:
item_types[archive_type] = []
item_types[archive_type].append(entry)
break
# Keep only the first two files of each type
to_delete = []
for items in item_types.values():
# Separate files and folders
files = [item for item in items if isinstance(item, dropbox.files.FileMetadata)]
folders = [item for item in items if isinstance(item, dropbox.files.FolderMetadata)]
# Sort files by modification time
files = sorted(files, key=lambda f: f.client_modified)
# Sort folders by last modified time on server
folders = sorted(folders, key=lambda f: folder_mod_time(dbx, f))
# Keep only the first two items of each type
to_delete += files[:-2] + folders[:-2]
# Delete the remaining items
for item in to_delete:
delete_file_or_folder(dbx, item)
def parse_args(args=None):
parser = argparse.ArgumentParser(prog='app')
cmds = parser.add_subparsers(help='commands')
def cmd(name, **kw):
p = cmds.add_parser(name, **kw)
p.set_defaults(cmd=name)
p.arg = lambda *a, **kw: p.add_argument(*a, **kw) and p
p.exe = lambda f: p.set_defaults(exe=f) and p
# global options
# p.arg('-s', '--settings', help='application settings')
return p
cmd('auth', help='Authorize application') \
.exe(lambda _: (
run_auth()
))
cmd('pack', help='Compress folder') \
.arg('source', type=str, help='Path to folder or file') \
.arg('destination', type=str, help='Path to resulting zip archive') \
.exe(lambda a: (
run_pack(a.source, a.destination)
))
cmd('upload', help='Upload file with override') \
.arg('refresh_token', type=str, help='Refresh token') \
.arg('file', type=str, help='Path to file') \
.arg('path', type=str, help='Path on disk') \
.exe(lambda a: (
run_upload(a.refresh_token, a.file, a.path)
))
cmd('clean', help='Clean stale artifacts') \
.arg('refresh_token', type=str, help='Refresh token') \
.exe(lambda a: (
run_clean(a.refresh_token)
))
args = parser.parse_args(args)
if not hasattr(args, 'exe'):
parser.print_usage()
else:
args.exe(args)
if __name__ == '__main__':
parse_args()