936 lines
36 KiB
Python
936 lines
36 KiB
Python
# coding: utf-8
|
||
# -------------------------------------------------------------------
|
||
# YakPanel
|
||
# -------------------------------------------------------------------
|
||
# Copyright (c) 2014-2099 YakPanel(www.yakpanel.com) All rights reserved.
|
||
# -------------------------------------------------------------------
|
||
# Author: yakpanel
|
||
# -------------------------------------------------------------------
|
||
# py virtual environment manager
|
||
# ------------------------------
|
||
import copy
|
||
import json
|
||
import os
|
||
import re
|
||
import shutil
|
||
import sys
|
||
import tarfile
|
||
import threading
|
||
import time
|
||
from platform import machine
|
||
|
||
import requests
|
||
import traceback
|
||
import subprocess
|
||
import argparse
|
||
from typing import Optional, Tuple, List, Union, Dict, TextIO
|
||
from xml.etree import cElementTree
|
||
|
||
os.chdir("/www/server/panel")
|
||
if "class/" not in sys.path:
|
||
sys.path.insert(0, "class/")
|
||
if "/www/server/panel" not in sys.path:
|
||
sys.path.insert(0, "/www/server/panel")
|
||
|
||
from mod.project.python.pyenv_tool import EnvironmentManager
|
||
|
||
import public
|
||
|
||
|
||
class _VmSTD:
|
||
out = sys.stdout
|
||
err = sys.stderr
|
||
|
||
|
||
_vm_std = _VmSTD()
|
||
|
||
|
||
def is_aarch64() -> bool:
|
||
_arch = machine().lower()
|
||
if _arch in ("aarch64", "arm64"):
|
||
return True
|
||
return False
|
||
|
||
|
||
def parse_version_to_list(version: str) -> Tuple[int, int, int]:
|
||
tmp = version.split(".")
|
||
if len(tmp) == 1:
|
||
return int(tmp[0]), 0, 0
|
||
elif len(tmp) == 2:
|
||
return int(tmp[0]), int(tmp[1]), 0
|
||
else:
|
||
return int(tmp[0]), int(tmp[1]), int(tmp[2])
|
||
|
||
|
||
def _get_index_of_python(url_list: List[str], timeout=10) -> Optional[Dict]:
|
||
winner: Dict = {}
|
||
done_event = threading.Event()
|
||
lock = threading.Lock() # 并发访问winner
|
||
|
||
def get_result(test_url):
|
||
try:
|
||
response = requests.get(test_url, timeout=timeout)
|
||
text = response.text
|
||
if not text:
|
||
return
|
||
with lock:
|
||
# Only record the first successful response
|
||
if not winner:
|
||
winner["data"] = text
|
||
winner["time"] = time.time()
|
||
winner["url"] = test_url
|
||
done_event.set()
|
||
except Exception:
|
||
pass
|
||
|
||
for url in url_list:
|
||
threading.Thread(target=get_result, args=(url,), daemon=True).start()
|
||
# 阻塞直到第一个成功响应或所有线程超时
|
||
done_event.wait(timeout=timeout)
|
||
return winner if winner else None
|
||
|
||
|
||
def get_index_of_python() -> Optional[Dict]:
|
||
url_list = [
|
||
"https://repo.huaweicloud.com/python/", # China mirror (Huawei Cloud)
|
||
"https://npmmirror.com/mirrors/python/", # China mirror (Aliyun)
|
||
"https://www.python.org/ftp/python/", # Official (官方国际)
|
||
"https://mirrors.dotsrc.org/python/", # Europe mirror (欧洲)
|
||
]
|
||
print(public.lang("Checking network status......"), file=_vm_std.out, flush=True)
|
||
res = _get_index_of_python(url_list, timeout=10)
|
||
if res is None:
|
||
res = _get_index_of_python(url_list, timeout=60)
|
||
if res is None:
|
||
print(
|
||
public.lang("Unable to connect to network, querying CPython interpreter version......"),
|
||
file=_vm_std.out,
|
||
flush=True
|
||
)
|
||
return res
|
||
|
||
|
||
def get_index_of_pypy_python() -> Optional[Dict]:
|
||
url_list = [
|
||
"https://buildbot.pypy.org/mirror/", # PyPy build mirror
|
||
"https://downloads.python.org/pypy/", # Official (international)
|
||
]
|
||
print(public.lang("Checking network status......"), file=_vm_std.out, flush=True)
|
||
res = _get_index_of_python(url_list, timeout=10)
|
||
if res is None:
|
||
res = _get_index_of_python(url_list, timeout=60)
|
||
if res is None:
|
||
print(
|
||
public.lang("Unable to connect to network, querying PyPy interpreter version......"),
|
||
file=_vm_std.out,
|
||
flush=True
|
||
)
|
||
return res
|
||
|
||
|
||
class PythonVersion:
|
||
def __init__(self, v: str, is_pypy: bool = False, filename: str = None):
|
||
self.version = v
|
||
self.is_pypy = is_pypy
|
||
self.bt_python_path = "/www/server/pyporject_evn/versions"
|
||
self.bt_pypy_path = "/www/server/pyporject_evn/pypy_versions"
|
||
self._file_name = filename.strip() if isinstance(filename, str) else None
|
||
|
||
self._ver_t = None
|
||
if not os.path.exists(self.bt_python_path):
|
||
os.makedirs(self.bt_python_path)
|
||
|
||
if not os.path.exists(self.bt_pypy_path):
|
||
os.makedirs(self.bt_pypy_path)
|
||
|
||
@property
|
||
def ver_t(self) -> Tuple[int, int, int]:
|
||
if self._ver_t is not None:
|
||
return self._ver_t
|
||
self._ver_t = parse_version_to_list(self.version)
|
||
return self._ver_t
|
||
|
||
@property
|
||
def installed(self) -> bool:
|
||
if self.is_pypy:
|
||
return os.path.exists(self.bt_pypy_path + "/" + self.version)
|
||
return os.path.exists(self.bt_python_path + "/" + self.version)
|
||
|
||
@staticmethod
|
||
def check(file) -> bool:
|
||
print(public.lang("[2/3] Verifying source file......"), file=_vm_std.out, flush=True)
|
||
if not os.path.exists(file):
|
||
print(public.lang("File does not exist, cannot verify"), file=_vm_std.out, flush=True)
|
||
return False
|
||
if os.path.getsize(file) < 1024 * 1024 * 10:
|
||
print(public.lang("File content is incomplete"), file=_vm_std.out, flush=True)
|
||
os.remove(file)
|
||
return False
|
||
return True
|
||
|
||
@property
|
||
def file_name(self) -> str:
|
||
if self._file_name:
|
||
return self._file_name
|
||
if self.is_pypy and not self._file_name:
|
||
raise Exception(public.lang("No file name"))
|
||
return "Python-{}.tar.xz".format(self.version)
|
||
|
||
@staticmethod
|
||
def _download_file(dst, url):
|
||
print(url, file=_vm_std.out, flush=True)
|
||
response = requests.get(url, stream=True, headers={
|
||
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36 Edg/121.0.0.0"
|
||
})
|
||
total_size = int(response.headers.get('content-length', 0))
|
||
print(
|
||
public.lang("Source file size to download: %.2fM") % (total_size / (1024 * 1024)),
|
||
file=_vm_std.out,
|
||
flush=True
|
||
)
|
||
if total_size == 0:
|
||
print(public.lang("File download error!"), file=_vm_std.out, flush=True)
|
||
downloaded_size = 0
|
||
block_size = 1024 * 1024
|
||
with open(dst, 'wb') as f:
|
||
for data in response.iter_content(block_size):
|
||
f.write(data)
|
||
downloaded_size += len(data)
|
||
progress = (downloaded_size / total_size) * 100
|
||
print(
|
||
public.lang("Downloading....") + "\t %.2f%% completed" % progress,
|
||
end='\r',
|
||
flush=True,
|
||
file=_vm_std.out
|
||
)
|
||
response.close()
|
||
|
||
def download(self, base_url) -> bool:
|
||
if self.is_pypy:
|
||
cache_dir = os.path.join(self.bt_pypy_path, "cached")
|
||
else:
|
||
cache_dir = os.path.join(self.bt_python_path, "cached")
|
||
if not os.path.exists(cache_dir):
|
||
os.makedirs(cache_dir)
|
||
dst = os.path.join(cache_dir, self.file_name)
|
||
if os.path.exists(dst) and os.path.getsize(dst) > 1024 * 1024 * 10:
|
||
print(public.lang("[1/3] Using cached source file......"), file=_vm_std.out, flush=True)
|
||
return self.check(dst)
|
||
|
||
print(public.lang("[1/3] Downloading source file......"), file=_vm_std.out, flush=True)
|
||
print(public.lang("Downloading source file......"), file=_vm_std.out, flush=True)
|
||
down_url = "{}{}/{}".format(base_url, self.version, self.file_name)
|
||
if self.is_pypy:
|
||
down_url = "{}{}".format(base_url, self.file_name)
|
||
self._download_file(dst, down_url)
|
||
print(public.lang("Download completed"), file=_vm_std.out, flush=True)
|
||
return self.check(dst)
|
||
|
||
def _install(self, extended_args='') -> bool:
|
||
if self.is_pypy:
|
||
return self._install_pypy()
|
||
print(public.lang("[3/3] Extracting and installing....."), file=_vm_std.out, flush=True)
|
||
install_sh = "{}/script/install_python.sh".format(public.get_panel_path())
|
||
check_openssl_args, extended_args = self._parse_extended_args(extended_args)
|
||
sh_str = "bash {} {} {} '{}'".format(
|
||
install_sh,
|
||
self.version,
|
||
check_openssl_args,
|
||
extended_args
|
||
)
|
||
p = subprocess.Popen(sh_str, stdout=_vm_std.out, stderr=_vm_std.out, shell=True)
|
||
p.wait()
|
||
if not os.path.exists(self.bt_python_path + "/" + self.version):
|
||
return False
|
||
self.install_pip_tool(self.bt_python_path + "/" + self.version)
|
||
return True
|
||
|
||
@staticmethod
|
||
def _parse_extended_args(extended_args) -> Tuple[str, str]:
|
||
rep_openssl = re.compile(r"--with-openssl=(?P<path>\S+)")
|
||
res = rep_openssl.search(extended_args)
|
||
if res:
|
||
path = res.group("path")
|
||
if os.path.exists(path):
|
||
return "not_check_openssl", extended_args
|
||
else:
|
||
extended_args = extended_args.replace(res.group(), "")
|
||
return "check_openssl", extended_args
|
||
return "check_openssl", extended_args
|
||
|
||
def _install_pypy(self) -> bool:
|
||
print(public.lang("[3/3] Extracting and installing....."), file=_vm_std.out, flush=True)
|
||
cache_dir = os.path.join(self.bt_pypy_path, "cached")
|
||
d_file = os.path.join(cache_dir, self.file_name)
|
||
tar = tarfile.open(d_file, "r|bz2")
|
||
tar.extractall(self.bt_pypy_path)
|
||
tar.close()
|
||
os.renames(self.bt_pypy_path + "/" + self.file_name[:-8], self.bt_pypy_path + "/" + self.version)
|
||
if not os.path.exists(self.bt_pypy_path + "/" + self.version):
|
||
return False
|
||
public.writeFile("{}/{}/is_pypy.pl".format(self.bt_pypy_path, self.version), "")
|
||
self.install_pip_tool(self.bt_pypy_path + "/" + self.version)
|
||
return True
|
||
|
||
def install_pip_tool(self, python_path):
|
||
print(public.lang("Installing pip tool....."), file=_vm_std.out, flush=True)
|
||
python_bin = "{}/bin/python3".format(python_path)
|
||
pip_bin = "{}/bin/pip3".format(python_path)
|
||
if not os.path.exists(python_bin):
|
||
python_bin = "{}/bin/python".format(python_path)
|
||
pip_bin = "{}/bin/pip".format(python_path)
|
||
|
||
if self._ver_t[:2] < (3, 4):
|
||
_ver = "{}.{}".format(*self._ver_t[:2])
|
||
if self._ver_t[:2] in ((3, 1), (3, 0)):
|
||
_ver = "3.2"
|
||
|
||
cache_dir = os.path.join(self.bt_python_path, "cached")
|
||
if not os.path.exists(cache_dir):
|
||
os.makedirs(cache_dir)
|
||
get_pip_file = os.path.join(cache_dir, "get-pip{}.py".format(_ver))
|
||
if not os.path.exists(get_pip_file):
|
||
url = "{}/install/plugin/pythonmamager/pip/get-pip{}.py".format(public.get_url(), _ver)
|
||
self._download_file(get_pip_file, url)
|
||
|
||
shutil.copyfile(get_pip_file, os.path.join(python_path, "get-pip.py"))
|
||
|
||
sh_str = "{} {}".format(python_bin, os.path.join(python_path, "get-pip.py"))
|
||
p = subprocess.Popen(sh_str, stdout=_vm_std.out, stderr=_vm_std.out, shell=True)
|
||
p.wait()
|
||
print(public.lang("pip tool installation finished"), file=_vm_std.out, flush=True)
|
||
else:
|
||
sh_str = "{} -m ensurepip".format(python_bin)
|
||
p = subprocess.Popen(sh_str, stdout=_vm_std.out, stderr=_vm_std.out, shell=True)
|
||
p.wait()
|
||
print(public.lang("pip tool installation finished"), file=_vm_std.out, flush=True)
|
||
|
||
if not os.path.exists(pip_bin):
|
||
print(public.lang("pip tool installation failed!!!!"), file=_vm_std.out, flush=True)
|
||
else:
|
||
self.update_pip_tool(pip_bin)
|
||
|
||
@staticmethod
|
||
def update_pip_tool(pip_bin: str):
|
||
update_str = "{} install --upgrade pip setuptools".format(pip_bin)
|
||
p = subprocess.Popen(update_str, stdout=_vm_std.out, stderr=_vm_std.out, shell=True)
|
||
p.wait()
|
||
|
||
def install(self, base_url, extended_args='') -> Tuple[bool, str]:
|
||
print(public.lang("Start installing......"), file=_vm_std.out, flush=True)
|
||
if not self.is_pypy:
|
||
dst = os.path.join(self.bt_python_path, self.version)
|
||
else:
|
||
dst = os.path.join(self.bt_pypy_path, self.version)
|
||
if os.path.isdir(dst):
|
||
return True, public.lang("Already installed")
|
||
# download file
|
||
if not self.download(base_url):
|
||
return False, public.lang("File download and verification failed!")
|
||
# install python
|
||
if not self._install(extended_args):
|
||
return False, public.lang("Extraction and installation failed!")
|
||
print(public.lang("Installation completed!"), file=_vm_std.out, flush=True)
|
||
home_path = self.bt_python_path + "/" + self.version
|
||
if self.is_pypy:
|
||
home_path = self.bt_pypy_path + "/" + self.version
|
||
|
||
bin_path = "{}/bin/python".format(home_path)
|
||
if not os.path.exists(bin_path):
|
||
bin_path = "{}/bin/python3".format(home_path)
|
||
if not os.path.exists(bin_path):
|
||
print(public.lang("Python installation failed!"))
|
||
return False, public.lang("Python installation failed!")
|
||
|
||
if bin_path == "{}/bin/python3".format(home_path):
|
||
os.symlink(os.path.realpath(bin_path), "{}/bin/python".format(home_path))
|
||
elif bin_path == "{}/bin/python".format(home_path) and not os.path.exists("{}/bin/python3".format(home_path)):
|
||
os.symlink(os.path.realpath(bin_path), "{}/bin/python3".format(home_path))
|
||
|
||
EnvironmentManager.add_python_env("system", bin_path)
|
||
return True, ""
|
||
|
||
@staticmethod
|
||
def parse_version(version: str) -> Tuple[bool, str]:
|
||
v_rep = re.compile(r"(?P<target>\d+\.\d{1,2}(\.\d{1,2})?)")
|
||
v_res = v_rep.search(version)
|
||
if v_res:
|
||
v = v_res.group("target")
|
||
return True, v
|
||
else:
|
||
return False, ""
|
||
|
||
|
||
class _PyCommandManager(object):
|
||
_FORMAT_DATA = """
|
||
# Start-Python-Env command line environment settings
|
||
export PATH="{}${{PATH}}"
|
||
# End-Python-Env
|
||
"""
|
||
|
||
@staticmethod
|
||
def check_use():
|
||
out, _ = public.ExecShell("lsattr /etc/profile")
|
||
return out.find("--i") == -1
|
||
|
||
def set_python_env(self, python_path: str) -> Tuple[bool, str]:
|
||
if python_path is None:
|
||
python_path = "" # 清除设置
|
||
else:
|
||
python_path = python_path + ":"
|
||
|
||
if not self.check_use():
|
||
return False, public.lang("System hardening appears to be enabled, operation not allowed")
|
||
try:
|
||
rep = re.compile(r'# +Start-Python-Env[^\n]*\n(export +PATH=".*")\n# +End-Python-Env')
|
||
profile_data = public.readFile("/etc/profile")
|
||
if not isinstance(profile_data, str):
|
||
return False, public.lang("Configuration file load error")
|
||
tmp_res = rep.search(profile_data)
|
||
if tmp_res is not None:
|
||
new_profile_data = rep.sub(self._FORMAT_DATA.format(python_path).strip("\n"), profile_data, 1)
|
||
else:
|
||
new_profile_data = profile_data + self._FORMAT_DATA.format(python_path)
|
||
public.writeFile("/etc/profile", new_profile_data)
|
||
return True, public.lang("Configuration set successfully")
|
||
except:
|
||
return False, public.lang("Setting error")
|
||
|
||
@staticmethod
|
||
def get_python_env() -> Optional[str]:
|
||
profile_data = public.readFile("/etc/profile")
|
||
if not isinstance(profile_data, str):
|
||
return None
|
||
rep = re.compile(r'# +Start-Python-Env[^\n]*\n(export +PATH="(?P<target>.*)")\n# +End-Python-Env')
|
||
tmp_res = rep.search(profile_data)
|
||
if tmp_res is None:
|
||
return None
|
||
path_data = tmp_res.group("target")
|
||
python_path = path_data.split(":")[0].strip()
|
||
if os.path.exists(python_path):
|
||
return python_path
|
||
return None
|
||
|
||
|
||
class PYVM(object):
|
||
bt_python_path = "/www/server/pyporject_evn/versions"
|
||
bt_pypy_path = "/www/server/pyporject_evn/pypy_versions"
|
||
_c_py_version_default = (
|
||
"2.7.18", "3.0.1", "3.1.5", "3.2.6", "3.3.7", "3.4.10", "3.5.10", "3.6.15", "3.7.17", "3.8.19",
|
||
"3.9.19", "3.10.14", "3.11.9", "3.12.3"
|
||
)
|
||
|
||
_pypy_version_default = (
|
||
("3.10.14", "pypy3.10-v7.3.16-linux64.tar.bz2"),
|
||
("3.9.19", "pypy3.10-v7.3.16-linux64.tar.bz2"),
|
||
("3.8.16", "pypy3.8-v7.3.11-linux64.tar.bz2"),
|
||
("3.7.13", "pypy3.7-v7.3.9-linux64.tar.bz2"),
|
||
("3.6.12", "pypy3.6-v7.3.3-linux64.tar.bz2"),
|
||
("2.7.18", "pypy2.7-v7.3.16-linux64.tar.bz2"),
|
||
)
|
||
|
||
def __init__(self, use_shell=False):
|
||
if not os.path.exists(self.bt_python_path):
|
||
os.makedirs(self.bt_python_path)
|
||
if not os.path.exists(self.bt_pypy_path):
|
||
os.makedirs(self.bt_pypy_path)
|
||
self.use_shell = use_shell
|
||
self._cpy_base_url = None
|
||
self._pypy_base_url = None
|
||
self.stable_versions: Optional[List[PythonVersion]] = None
|
||
self._py_cmd_mgr = _PyCommandManager()
|
||
self.is_pypy = False
|
||
self.async_version = False
|
||
|
||
def now_python_path(self) -> Optional[str]:
|
||
return self._py_cmd_mgr.get_python_env()
|
||
|
||
def set_python_path(self, python_path) -> Tuple[bool, str]:
|
||
return self._py_cmd_mgr.set_python_env(python_path)
|
||
|
||
@staticmethod
|
||
def check_use():
|
||
res = os.popen("lsattr /etc/profile")
|
||
return res.read().find("--i--") == -1
|
||
|
||
@property
|
||
def base_url(self):
|
||
if self.is_pypy:
|
||
if self._pypy_base_url is not None:
|
||
return self._pypy_base_url
|
||
res = get_index_of_pypy_python()
|
||
if res is not None:
|
||
self._pypy_base_url = res["url"]
|
||
return self._pypy_base_url
|
||
else:
|
||
if self._cpy_base_url is not None:
|
||
return self._cpy_base_url
|
||
res = get_index_of_python()
|
||
if res is not None:
|
||
self._cpy_base_url = res["url"]
|
||
return self._cpy_base_url
|
||
return None
|
||
|
||
# 获取版本
|
||
def get_py_version(self, force=False):
|
||
if isinstance(self.stable_versions, list) and len(self.stable_versions) > 1:
|
||
return self.stable_versions
|
||
if not force:
|
||
self.stable_versions = self._get_versions_by_local()
|
||
|
||
if not force and self.async_version and not self.stable_versions:
|
||
self._async_get_versions()
|
||
if self.is_pypy:
|
||
self.stable_versions = [
|
||
PythonVersion(v, is_pypy=True, filename=f) for v, f in self._pypy_version_default
|
||
]
|
||
return self.stable_versions
|
||
self.stable_versions = [PythonVersion(i, is_pypy=False) for i in self._c_py_version_default]
|
||
return self.stable_versions
|
||
|
||
if not self.stable_versions:
|
||
if self.use_shell:
|
||
print(
|
||
public.lang("No local record file found, requesting Python version data from cloud,"
|
||
" this may take a while, please wait"),
|
||
file=_vm_std.out
|
||
)
|
||
self.stable_versions, err = self._get_versions_by_cloud()
|
||
# 缓存数据到本地
|
||
if isinstance(self.stable_versions, list) and len(self.stable_versions) > 1:
|
||
self._save_cached(self.stable_versions)
|
||
else:
|
||
print(err, file=_vm_std.out)
|
||
|
||
if force and not self.stable_versions:
|
||
self.stable_versions = self._get_versions_by_local()
|
||
|
||
if not self.stable_versions:
|
||
self.stable_versions = []
|
||
|
||
return self.stable_versions
|
||
|
||
def _async_get_versions(self):
|
||
pyvm_mgr = copy.deepcopy(self)
|
||
|
||
def get_versions():
|
||
pyvm_mgr.async_version = False
|
||
pyvm_mgr.get_py_version(force=True)
|
||
|
||
task = threading.Thread(target=get_versions)
|
||
task.start()
|
||
|
||
def _get_versions_by_local(self) -> [Optional[List[PythonVersion]]]:
|
||
"""
|
||
获取本地稳定版本的缓存数据
|
||
"""
|
||
local_path = "/www/server/panel/data/pyvm"
|
||
if not os.path.exists(local_path):
|
||
os.makedirs(local_path)
|
||
return None
|
||
stable_file = os.path.join(local_path, "stable_versions.txt")
|
||
if self.is_pypy:
|
||
stable_file = os.path.join(local_path, "pypy_versions.txt")
|
||
if not os.path.isfile(stable_file):
|
||
return None
|
||
with open(stable_file, "r") as f:
|
||
if self.is_pypy:
|
||
stable_versions = []
|
||
for line in f.readlines():
|
||
v, filename = line.split("|")
|
||
stable_versions.append(PythonVersion(v, is_pypy=True, filename=filename))
|
||
else:
|
||
stable_versions = [PythonVersion(line.strip()) for line in f.readlines()]
|
||
|
||
return stable_versions
|
||
|
||
def _get_versions_by_cloud(self) -> Tuple[Optional[List[PythonVersion]], Optional[str]]:
|
||
"""
|
||
获取云端支持的稳定版本 排除2.7的稳定版本以外的其他版本
|
||
"""
|
||
if self.is_pypy:
|
||
return self._get_pypy_versions_by_cloud()
|
||
|
||
res = get_index_of_python()
|
||
if res is None:
|
||
return None, public.lang("Unable to connect to cloud, please check network connection")
|
||
self._base_url: str = res["url"]
|
||
data_txt: str = res["data"]
|
||
|
||
try:
|
||
stable_go_versions = self.__parser_xml(data_txt)
|
||
return stable_go_versions, None
|
||
except:
|
||
traceback.print_exc(file=_vm_std.err)
|
||
return None, public.lang("Parse error")
|
||
|
||
def _get_pypy_versions_by_cloud(self) -> Tuple[Optional[List[PythonVersion]], Optional[str]]:
|
||
"""
|
||
获取云端支持的稳定版本 排除2.7的稳定版本以外的其他版本
|
||
"""
|
||
|
||
if self.base_url is None:
|
||
return None, public.lang("Unable to connect to cloud, please check network connection")
|
||
try:
|
||
stable_versions = []
|
||
ver_json = json.loads(requests.get(self.base_url + "versions.json").text)
|
||
arch = 'aarch64' if is_aarch64() else "x64"
|
||
for i in ver_json:
|
||
if i["stable"] is True and i["latest_pypy"] is True:
|
||
for file in i["files"]:
|
||
if file["arch"] == arch and file["platform"] == "linux":
|
||
stable_versions.append(
|
||
PythonVersion(i["python_version"], is_pypy=True, filename=file["filename"])
|
||
)
|
||
return stable_versions, None
|
||
except:
|
||
traceback.print_exc(file=_vm_std.err)
|
||
return None, public.lang("Parse error")
|
||
|
||
def __parser_xml(self, data_txt: str) -> List[PythonVersion]:
|
||
res_list = []
|
||
# 只取pre部分
|
||
start = data_txt.rfind("<pre>")
|
||
end = data_txt.rfind("</pre>") + len("</pre>")
|
||
if not start > 0 or not end > 0:
|
||
return res_list
|
||
data_txt = data_txt[start:end] # 去除hr标签导致的错误
|
||
last_2 = {
|
||
"data": (2, 0, 0),
|
||
"version": None,
|
||
}
|
||
|
||
root = cElementTree.fromstring(data_txt)
|
||
for data in root.findall("./a"):
|
||
v_str = data.text
|
||
if v_str.startswith("2."):
|
||
ver = v_str.strip("/")
|
||
t_version = parse_version_to_list(ver)
|
||
if t_version > last_2["data"]:
|
||
last_2["data"] = t_version
|
||
last_2["version"] = ver
|
||
continue
|
||
if v_str.startswith("3."):
|
||
p_v = PythonVersion(v_str.strip("/"))
|
||
res_list.append(p_v)
|
||
continue
|
||
|
||
if last_2["version"]:
|
||
res_list.insert(0, PythonVersion(last_2["version"]))
|
||
|
||
res_list.sort(key=lambda x: x.ver_t)
|
||
|
||
need_remove = []
|
||
for ver in res_list[::-1]:
|
||
if not self.test_last_version_is_stable(ver):
|
||
need_remove.append(ver)
|
||
else:
|
||
break
|
||
for ver in need_remove:
|
||
res_list.remove(ver)
|
||
|
||
return res_list
|
||
|
||
# 检查最新的版本是否有正式发布版本包
|
||
def test_last_version_is_stable(self, ver: PythonVersion) -> bool:
|
||
response = requests.get("{}{}/".format(self.base_url, ver.version), timeout=10)
|
||
data = response.text
|
||
if data.find(ver.file_name) != -1:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def _save_cached(self, stable_go_versions: List[PythonVersion]) -> None:
|
||
local_path = "/www/server/panel/data/pyvm"
|
||
if not os.path.exists(local_path):
|
||
os.makedirs(local_path)
|
||
|
||
if self.is_pypy:
|
||
with open(os.path.join(local_path, "pypy_versions.txt"), "w") as f:
|
||
for py_v in stable_go_versions:
|
||
f.write(py_v.version + "|" + py_v.file_name + "\n")
|
||
return
|
||
|
||
with open(os.path.join(local_path, "stable_versions.txt"), "w") as f:
|
||
for py_v in stable_go_versions:
|
||
f.write(py_v.version + "\n")
|
||
|
||
@staticmethod
|
||
def del_cached():
|
||
local_path = "/www/server/panel/data/pyvm"
|
||
stable_file = os.path.join(local_path, "stable_versions.txt")
|
||
pypy_file = os.path.join(local_path, "pypy_versions.txt")
|
||
if os.path.isfile(stable_file):
|
||
os.remove(stable_file)
|
||
if os.path.isfile(pypy_file):
|
||
os.remove(pypy_file)
|
||
|
||
def api_ls(self) -> Tuple[List[str], List[str]]:
|
||
return [i.strip() for i in os.listdir(self.bt_python_path) if i.startswith("2") or i.startswith("3")], \
|
||
[i.strip() for i in os.listdir(self.bt_pypy_path) if i.startswith("2") or i.startswith("3")]
|
||
|
||
def cmd_ls(self) -> None:
|
||
cpy_versions, pypy_versions = self.api_ls()
|
||
versions = pypy_versions if self.is_pypy else cpy_versions
|
||
if not versions:
|
||
print(public.lang("No Python interpreter version is installed"))
|
||
return
|
||
print("version: ")
|
||
for i in versions:
|
||
print(" " + i)
|
||
|
||
def api_ls_remote(self, is_all: bool, force=False) -> Tuple[Optional[List[PythonVersion]], Optional[str]]:
|
||
self.get_py_version(force)
|
||
self.stable_versions.sort(key=lambda k: k.ver_t, reverse=True)
|
||
if is_all:
|
||
return self.stable_versions, None
|
||
res_new = []
|
||
tow_list = [0, 0]
|
||
for i in self.stable_versions:
|
||
if i.ver_t[:2] != tow_list:
|
||
res_new.append(i)
|
||
tow_list = i.ver_t[:2]
|
||
|
||
return res_new, None
|
||
|
||
def cmd_ls_remote(self, is_all: bool) -> None:
|
||
stable, err = self.api_ls_remote(is_all)
|
||
cpy_installed, pypy_install = self.api_ls()
|
||
installed = pypy_install if self.is_pypy else cpy_installed
|
||
if err:
|
||
print(public.lang("An error occurred while fetching version information"), file=sys.stderr)
|
||
print(err, file=sys.stderr)
|
||
print("Stable Version:")
|
||
for i in stable:
|
||
if i.version in installed:
|
||
i.version += " <- installed"
|
||
print(" " + i.version)
|
||
|
||
def _get_version(self, version) -> Union[PythonVersion, str]:
|
||
stable, err = self.api_ls_remote(True)
|
||
if err:
|
||
if self.use_shell:
|
||
print(public.lang("An error occurred while fetching version information"), file=_vm_std.err)
|
||
print(err, file=_vm_std.err)
|
||
return err
|
||
for i in stable:
|
||
if i.version == version:
|
||
return i
|
||
|
||
if self.use_shell:
|
||
print(public.lang("Corresponding version not found"), file=_vm_std.err)
|
||
return public.lang("Corresponding version not found")
|
||
|
||
def re_install_pip_tools(self, version, python_path):
|
||
py_v = self._get_version(version)
|
||
if isinstance(py_v, str):
|
||
return False, py_v
|
||
if not py_v.installed:
|
||
return False, public.lang("Version not installed")
|
||
if not self.is_pypy:
|
||
public.ExecShell("rm -rf {}/bin/pip*".format(python_path))
|
||
public.ExecShell(
|
||
"rm -rf {}/lib/python{}.{}/site-packages/pip*".format(python_path, py_v.ver_t[0], py_v.ver_t[1]))
|
||
else:
|
||
public.ExecShell("rm -rf {}/bin/pip*".format(python_path))
|
||
public.ExecShell(
|
||
"rm -rf {}/lib/pypy{}.{}/site-packages/pip*".format(python_path, py_v.ver_t[0], py_v.ver_t[1])
|
||
)
|
||
|
||
py_v.install_pip_tool(python_path)
|
||
|
||
def api_install(self, version) -> Tuple[bool, str]:
|
||
py_v = self._get_version(version)
|
||
if isinstance(py_v, str):
|
||
return False, py_v
|
||
if self.base_url is None:
|
||
return False, public.lang("Internet connect error, please check")
|
||
return py_v.install(self.base_url)
|
||
|
||
def cmd_install(self, version, extended_args='') -> None:
|
||
py_v = self._get_version(version)
|
||
if isinstance(py_v, str):
|
||
pass
|
||
if self.base_url is None:
|
||
print("Internet connect error, please check", file=sys.stderr)
|
||
return
|
||
_, err = py_v.install(self.base_url, extended_args)
|
||
if err:
|
||
print(err, file=sys.stderr)
|
||
|
||
def api_uninstall(self, version: str) -> Tuple[bool, str]:
|
||
if not self.is_pypy:
|
||
py_path = self.bt_python_path + "/" + version
|
||
else:
|
||
py_path = self.bt_pypy_path + "/" + version
|
||
if os.path.exists(py_path):
|
||
import shutil
|
||
shutil.rmtree(py_path)
|
||
return True, public.lang("Uninstall completed")
|
||
|
||
def cmd_uninstall(self, version: str) -> None:
|
||
_, msg = self.api_uninstall(version)
|
||
print(msg, file=sys.stdout)
|
||
return
|
||
|
||
@staticmethod
|
||
def set_std(out: TextIO, err: TextIO) -> None:
|
||
_vm_std.out = out
|
||
_vm_std.err = err
|
||
|
||
@staticmethod
|
||
def _serializer_of_list(s: list, installed: List[str]) -> List[Dict]:
|
||
return [{
|
||
"version": v.version,
|
||
"type": "stable",
|
||
"installed": True if v.version in installed else False
|
||
} for v in s]
|
||
|
||
def python_versions(self, refresh=False):
|
||
res = {
|
||
'status': True,
|
||
'cpy_installed': [],
|
||
'pypy_installed': [],
|
||
'sdk': {
|
||
"all": [],
|
||
"streamline": [],
|
||
"pypy": [],
|
||
},
|
||
'use': self.now_python_path(),
|
||
'command_path': None,
|
||
}
|
||
sdk = res["sdk"]
|
||
old_type = self.is_pypy
|
||
cpy_installed, pypy_installed = self.api_ls()
|
||
cpy_installed.sort(key=lambda x: int(x.split(".")[1]), reverse=True)
|
||
res['cpy_installed'] = cpy_installed
|
||
pypy_installed.sort(key=lambda x: int(x.split(".")[1]), reverse=True)
|
||
res['pypy_installed'] = pypy_installed
|
||
cpy_command_path = [
|
||
{
|
||
"python_path": os.path.join(self.bt_python_path, i, "bin"),
|
||
"type": "version",
|
||
"version": i,
|
||
"is_pypy": False,
|
||
} for i in cpy_installed
|
||
]
|
||
pypy_command_path = [
|
||
{
|
||
"python_path": os.path.join(self.bt_pypy_path, i, "bin"),
|
||
"type": "version",
|
||
"version": i,
|
||
"is_pypy": True,
|
||
} for i in pypy_installed
|
||
]
|
||
res["command_path"] = cpy_command_path + pypy_command_path
|
||
|
||
# cpy
|
||
self.is_pypy = False
|
||
self.get_py_version(refresh)
|
||
self.stable_versions.sort(key=lambda k: k.ver_t, reverse=True)
|
||
if not self.stable_versions:
|
||
sdk["all"] = sdk["streamline"] = [
|
||
{"version": v, "type": "stable", "installed": True} for v in cpy_installed
|
||
]
|
||
else:
|
||
sdk["all"] = self._serializer_of_list(self.stable_versions, cpy_installed)
|
||
res_new = []
|
||
tow_list = [0, 0]
|
||
for i in self.stable_versions:
|
||
if i.ver_t[:2] != tow_list:
|
||
res_new.append(i)
|
||
tow_list = i.ver_t[:2]
|
||
sdk["streamline"] = self._serializer_of_list(res_new, cpy_installed)
|
||
for i in sdk["streamline"]:
|
||
if i.get("version") in cpy_installed:
|
||
cpy_installed.remove(i.get("version", ""))
|
||
if set(cpy_installed):
|
||
for i in set(cpy_installed):
|
||
sdk["streamline"].insert(0, {
|
||
"version": i,
|
||
"type": "stable",
|
||
"installed": True
|
||
})
|
||
|
||
# pypy
|
||
self.is_pypy = True
|
||
self.stable_versions = []
|
||
self.get_py_version(refresh)
|
||
self.stable_versions.sort(key=lambda k: k.ver_t, reverse=True)
|
||
if not self.stable_versions:
|
||
sdk["pypy"] = [
|
||
{"version": v, "type": "stable", "installed": True} for v in pypy_installed
|
||
]
|
||
else:
|
||
sdk["pypy"] = self._serializer_of_list(self.stable_versions, pypy_installed)
|
||
|
||
self.stable_versions = None
|
||
self.is_pypy = old_type
|
||
|
||
return res
|
||
|
||
|
||
if __name__ == '__main__':
|
||
parser = argparse.ArgumentParser(description='pyvm Python解释器版本管理器')
|
||
parser.add_argument('-pypy', action='store_true', help='管理PyPy解释器')
|
||
# 添加子命令
|
||
subparsers = parser.add_subparsers(title='operation', dest='command')
|
||
# 添加ls子命令
|
||
subparsers.add_parser('ls', help='展示已安装的Python解释器版本')
|
||
subparsers.add_parser('clear_cache', help='清除版本缓存')
|
||
# 添加ls子命令
|
||
parser_ls_r = subparsers.add_parser('ls-remote', help='展示可安装Python解释器版本，默认只展示每个版本中较新的版本')
|
||
parser_ls_r.add_argument('-a', action='store_true', help='展示可以安装的所有Python解释器版本')
|
||
# 添加install子命令
|
||
parser_install = subparsers.add_parser('install', help='安装指定版本')
|
||
parser_install.add_argument('version', type=str, help='要安装的Python版本，例如3.10.0')
|
||
parser_install.add_argument(
|
||
'--extend', type=str, default='',
|
||
help="传递给Python编译的额外选项，用单引号包围多个选项，如'--disable-ipv6 --enable-loadable-sqlite-extensions'"
|
||
)
|
||
|
||
# 添加uninstall子命令
|
||
parser_uninstall = subparsers.add_parser('uninstall', help='卸载并删除指定版本')
|
||
parser_uninstall.add_argument('uninstall_param', type=str, help='完整的版本号')
|
||
# 添加install_pip子命令
|
||
parser_uninstall = subparsers.add_parser('install_pip', help='卸载并删除指定版本')
|
||
parser_uninstall.add_argument('install_pip_param', type=str, help='完整的版本号')
|
||
|
||
input_args = parser.parse_args()
|
||
pyvm = PYVM()
|
||
if isinstance(pyvm, str):
|
||
print(pyvm, file=sys.stderr)
|
||
exit(1)
|
||
if input_args.pypy:
|
||
pyvm.is_pypy = True
|
||
pyvm.use_shell = True
|
||
if input_args.command == 'clear_cache':
|
||
pyvm.del_cached()
|
||
elif input_args.command == 'ls':
|
||
pyvm.cmd_ls()
|
||
elif input_args.command == "ls-remote":
|
||
_is_all = True if input_args.a else False
|
||
pyvm.cmd_ls_remote(_is_all)
|
||
elif input_args.command == "install":
|
||
extended = input_args.extend
|
||
_flag, _v = PythonVersion.parse_version(input_args.version)
|
||
if _flag:
|
||
pyvm.cmd_install(_v, extended)
|
||
else:
|
||
print(public.lang("Version parameter error, should be in the format 1.xx.xx"), file=sys.stderr)
|
||
elif input_args.command == "uninstall":
|
||
_flag, _v = PythonVersion.parse_version(input_args.uninstall_param)
|
||
if _flag:
|
||
pyvm.cmd_uninstall(_v)
|
||
else:
|
||
print(public.lang("Version parameter error, should be in the format 1.xx.xx"), file=sys.stderr)
|
||
elif input_args.command == "install_pip":
|
||
_flag, _v = PythonVersion.parse_version(input_args.install_pip_param)
|
||
if _flag:
|
||
pyvm.re_install_pip_tools(_v, pyvm.bt_python_path + "/" + _v)
|
||
else:
|
||
print(public.lang("Version parameter error, should be in the format 1.xx.xx"), file=sys.stderr)
|
||
else:
|
||
print(public.lang("Use pyvm -h to view operation commands"), file=sys.stderr)
|
||
|