addftool 0.2.6__py3-none-any.whl → 0.2.8__py3-none-any.whl

addftool/addf_portal.py

@@ -3,6 +3,7 @@ from addftool.process import add_killer_args, killer_main
 from addftool.sync import add_sync_args, sync_main
 from addftool.deploy import add_deploy_args, deploy_main
 from addftool.broadcast_folder import add_broadcast_folder_args, broadcast_folder_main
+from addftool.sleep import add_sleep_args, sleep_main
 
 from addftool.blob import add_blob_args, blob_main
 
@@ -16,6 +17,7 @@ def get_args():
     add_deploy_args(subparsers)
     add_broadcast_folder_args(subparsers)
     add_blob_args(subparsers)
+    add_sleep_args(subparsers)
 
     return parser.parse_args()
 
@@ -32,6 +34,8 @@ def main():
         broadcast_folder_main(args)
     elif args.command == "blob":
         blob_main(args)
+    elif args.command == "sleep":
+        sleep_main(args)
     else:
         print("Unknown command: ", args.command)
 

addftool/broadcast_folder.py

@@ -3,13 +3,20 @@ import time
 import fnmatch
 import subprocess
 import hashlib
+import sys
+import warnings
+try:
+    from addftool.ssh import get_client, get_ssh_config, handle_hosts_outputs
+    from pssh.clients import ParallelSSHClient
+except ImportError:
+    pass
 from concurrent.futures import ThreadPoolExecutor
-
-from fabric import Connection, ThreadingGroup
+import gevent
 
 try:
     import torch
     import torch.distributed as dist
+    import torch.multiprocessing as mp
     from torch.distributed import init_process_group, destroy_process_group
     _torch_is_available = True
 except ImportError:
@@ -29,9 +36,8 @@ def add_args(parser):
 
     parser.add_argument("--md5_verify", action='store_true', default=False,
                         help="whether to verify the md5 of the file after broadcast, default is False.")
-    parser.add_argument("--port", help="the port for torchrun, default is 29501", type=int, default=29501)
-    parser.add_argument("--torchrun_alias", type=str, default="torchrun",
-                        help="the alias of torchrun, default is torchrun. If you use torchrun, please set it to torchrun.")
+    parser.add_argument("--port", help="the port for torch, default is 29501", type=int, default=29501)
+    parser.add_argument("--python_alias", type=str, default="python")
     parser.add_argument("--transfer_ranks_per_node", type=int, default=8,
                         help="the number of ranks per node to transfer the files, default is 8.")
 
@@ -55,28 +61,13 @@ def add_args(parser):
                         help="the blob url to download from, default is empty. " \
                         "Only node-0 will download the files from the blob url, " \
                         "If empty, will transfer the files from the node-0's local folder.")
+
+    parser.add_argument("--worker_args", type=str, default="")
     
     # distributed downloader from blob
     parser.add_argument("folder", help="the folder need to broadcast", type=str)
 
 
-class ConnectionWithCommand(Connection):
-    def __init__(self, host, temp_config_dir, puts, command):
-        super().__init__(host)
-        self.command = command
-        self.puts = puts
-        self.temp_config_dir = temp_config_dir
-
-    def run(self, command, **kwargs):
-        super().run(f"mkdir -p {self.temp_config_dir}", **kwargs)
-        for src, dest in self.puts:
-            self.put(src, remote=dest)
-        print(f"Running command on {self.original_host}: {self.command}")
-        super().run(self.command, **kwargs)
-        if command:
-            super().run(command, **kwargs)
-
-
 def get_ip_via_ssh(hostname):
     if hostname == "localhost":
         return "127.0.0.1"
@@ -150,20 +141,40 @@ def broadcast_folder_main(args):
                 host_list.append(line)
     
     print(f"Find {len(host_list)} hosts in hostfile: {args.hostfile}")
-    connection_list = []
 
     remote_temp_config_dir = "/tmp/broadcast_temp_config_dir"
-
     master_addr = get_ip_via_ssh(host_list[0])
+    
+    user_ssh_config, systen_ssh_config = get_ssh_config()
+    not_successed_hosts = host_list[:]
+    for try_count in range(3):
+        client = get_client(not_successed_hosts, user_ssh_configs=user_ssh_config, system_ssh_configs=systen_ssh_config)
+        mkdir_cmds = client.run_command(f"mkdir -p {remote_temp_config_dir}", stop_on_errors=False)
+        client.join(mkdir_cmds, timeout=10)
+        assert isinstance(client, ParallelSSHClient), "Failed to create ParallelSSHClient"
+        cmds = client.scp_send(__file__, os.path.join(remote_temp_config_dir, "broadcast_folder.py"))
+        gevent.joinall(cmds, raise_error=False, timeout=10)
+        resend_hosts = []
+        for host, cmd in zip(not_successed_hosts, cmds):
+            if cmd.exception:
+                print(f"Failed to copy file to {host}: {cmd.exception}")
+                resend_hosts.append(host)
+        
+        if len(resend_hosts) == 0:
+            break
+        not_successed_hosts = resend_hosts
+    
+    if len(resend_hosts) > 0:
+        print(f"Failed to copy file to {len(resend_hosts)} hosts: {resend_hosts}")
+        sys.exit(1)
 
+    host_commands = []
     for i, host in enumerate(host_list):
-        put_commands = []
-        put_commands.append((__file__, os.path.join(remote_temp_config_dir, "broadcast.py")))
-        commnads = "NCCL_IB_DISABLE=0 OPENBLAS_NUM_THREADS=1 MKL_NUM_THREADS=1 OMP_NUM_THREADS=1 "
+        commnads = "PYTHONUNBUFFERED=1 NCCL_IB_DISABLE=0 OPENBLAS_NUM_THREADS=1 MKL_NUM_THREADS=1 OMP_NUM_THREADS=1 "
         if os.environ.get("SAS_TOKEN") is not None and i == 0:
             commnads += f"SAS_TOKEN=\"{os.environ['SAS_TOKEN']}\" "
-        commnads += f"{args.torchrun_alias} --nproc_per_node={args.transfer_ranks_per_node} --nnodes={len(host_list)} --node_rank={i} --master_addr={master_addr} --master_port={args.port}"
-        commnads += f" {remote_temp_config_dir}/broadcast.py {args.folder} --tool {args.tool} --transfer_ranks_per_node {args.transfer_ranks_per_node} "
+        commnads += f"{args.python_alias} {remote_temp_config_dir}/broadcast_folder.py {args.folder} --tool {args.tool} --transfer_ranks_per_node {args.transfer_ranks_per_node} "
+        commnads += f" --worker_args {master_addr}_{args.port}_{len(host_list)}_{args.transfer_ranks_per_node}_{i} "
         if args.contain_md5_files:
             commnads += " --contain_md5_files"
         if args.include_string:
@@ -174,11 +185,20 @@ def broadcast_folder_main(args):
             commnads += f" --from_blob_url {args.from_blob_url}"
         if args.md5_verify:
             commnads += " --md5_verify"
-        
-        connection_list.append(ConnectionWithCommand(host, remote_temp_config_dir, put_commands, commnads))
+        host_commands.append(commnads)
+        print(f"Run command on {host}: {commnads}")
+
+    client = get_client(host_list, user_ssh_configs=user_ssh_config, system_ssh_configs=systen_ssh_config)
+    if True:
+        cmds = client.run_command("%s", host_args=host_commands, stop_on_errors=False)
+        handle_hosts_outputs(cmds)
+        for host, cmd in zip(host_list, cmds):
+            if cmd.exception or cmd.exit_code != 0:
+                print(f"Failed to run command on {host}: {cmd.exception}, EXIT CODE: {cmd.exit_code}")
+                sys.exit(1)
+            print(f"Command on {host} finished with exit code {cmd.exit_code}")
     
-    group = ThreadingGroup.from_connections(connection_list)
-    group.run('echo "Hello"', hide=False)
+    print(f"All nodes finished broadcasting files")
 
 
 def download_files_from_blob(queue, blob_url, sas_token, folder, download_files, node_rank):
@@ -259,16 +279,14 @@ def broadcast_file_from_rank(rank, file_path, from_rank, device, file_size, max_
                 raise ValueError(f"MD5 verification failed for {file_path}: {file_md5} != {src_md5_str}")
 
 
-def broadcast_folder_worker(args):
+def broadcast_folder_worker(local_rank, node_rank, world_size, master_addr, master_port, args):
     assert args.tool in ["torch_nccl"], f"tool {args.tool} is not supported"
     if not _torch_is_available:
         raise ImportError("Torch is not available. Please install torch to use this feature.")
     start_time = time.time()
 
-    init_process_group(backend='nccl')
-    global_rank = int(os.environ['RANK'])
-    local_rank = int(os.environ['LOCAL_RANK'])
-    world_size = int(os.environ['WORLD_SIZE'])
+    global_rank = local_rank + node_rank * args.transfer_ranks_per_node
+    init_process_group(backend='nccl', init_method=f"tcp://{master_addr}:{master_port}", rank=global_rank, world_size=world_size)
     num_nodes = world_size // args.transfer_ranks_per_node
     worker_rank = local_rank
 
@@ -291,11 +309,15 @@ def broadcast_folder_worker(args):
     if global_rank == 0:
         print(f"Init {len(workers_groups)} worker groups")
 
-    print(f"rank {global_rank} start broadcast worker, args = {args}, nccl init time: {time.time() - start_time:.2f}s")
-    
+    if global_rank == 0:
+        print(f"rank {global_rank} start broadcast worker, args = {args}, nccl init time: {time.time() - start_time:.2f}s")
+    else:
+        print(f"rank {global_rank} nccl init time: {time.time() - start_time:.2f}s")
+
     file_size_dict = {}
     
     if global_rank == 0:
+        warnings.filterwarnings("ignore", category=UserWarning, message="The given buffer is not writable, and PyTorch does not support non-writable tensors.")
         # Parse include and exclude patterns
         include_patterns = [p.strip() for p in args.include_string.split(";") if p.strip()]
         exclude_patterns = [p.strip() for p in args.exclude_string.split(";") if p.strip()]
@@ -397,6 +419,23 @@ def broadcast_folder_worker(args):
     print(f"Rank {global_rank} finished broadcasting all files, time taken: {time.time() - start_time:.2f}s")
 
 
+def broadcast_node_main(args):
+    if not _torch_is_available:
+        raise ImportError("Torch is not available. Please install torch to use this feature.")
+    parts = args.worker_args.split("_")
+    master_addr = parts[0]
+    master_port = int(parts[1])
+    num_nodes = int(parts[2])
+    num_ranks_per_node = int(parts[3])
+    node_rank = int(parts[4])
+    world_size = num_nodes * num_ranks_per_node
+    
+    mp.spawn(
+        broadcast_folder_worker, nprocs=num_ranks_per_node, join=True, 
+        args=(node_rank, world_size, master_addr, master_port, args), 
+    )
+
+
 if __name__ == "__main__":
     import argparse
 
@@ -406,4 +445,4 @@ if __name__ == "__main__":
     if args.hostfile:
         broadcast_folder_main(args)
     else:
-        broadcast_folder_worker(args)
+        broadcast_node_main(args)

addftool/sleep.py

@@ -0,0 +1,218 @@
+import time
+import subprocess
+import sys
+import multiprocessing as mp
+
+try:
+    import torch
+except ImportError:
+    print("PyTorch is not installed. Please install it to run this script.")
+    sys.exit(1)
+
+
+def get_gpu_stats(device_id):
+    """获取指定GPU的利用率和显存使用情况"""
+    try:
+        cmd = f"nvidia-smi --id={device_id} --query-gpu=utilization.gpu,memory.used --format=csv,noheader,nounits"
+        result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
+        
+        if result.returncode != 0:
+            print(f"Error running nvidia-smi for GPU {device_id}")
+            return None, None
+        
+        # 解析输出
+        output = result.stdout.strip()
+        if output:
+            parts = output.split(',')
+            if len(parts) == 2:
+                gpu_util = int(parts[0])  # GPU利用率百分比
+                memory_used = int(parts[1])  # 显存使用量(MB)
+                return gpu_util, memory_used
+        
+        return None, None
+    except Exception as e:
+        print(f"Error getting GPU stats for device {device_id}: {e}")
+        return None, None
+
+def check_gpu_occupied(device_id, util_threshold=20, memory_threshold=2048):
+    """检查GPU是否被其他进程占用
+    
+    Args:
+        device_id: GPU设备ID
+        util_threshold: GPU利用率阈值(默认20%)
+        memory_threshold: 显存使用阈值(默认2048MB = 2GB)
+    
+    Returns:
+        bool: True表示GPU被占用，False表示GPU空闲
+    """
+    gpu_util, memory_used = get_gpu_stats(device_id)
+    
+    if gpu_util is None or memory_used is None:
+        # 获取失败时保守处理
+        return True
+    
+    # 判断是否被占用
+    is_occupied = gpu_util > util_threshold or (memory_threshold > 0 and memory_used > memory_threshold)
+    
+    if is_occupied:
+        print(f"GPU {device_id}: Util={gpu_util}%, Memory={memory_used}MB - Occupied")
+    
+    return is_occupied
+
+def check_all_gpus(num_gpus, util_threshold=20, memory_threshold=-1):
+    """检查所有GPU是否被占用"""
+    for device_id in range(num_gpus):
+        if check_gpu_occupied(device_id, util_threshold, memory_threshold):
+            return True, device_id
+    return False, -1
+
+def get_all_gpu_status(num_gpus):
+    """获取所有GPU的状态信息"""
+    print("\nGPU Status:")
+    print("-" * 50)
+    for device_id in range(num_gpus):
+        gpu_util, memory_used = get_gpu_stats(device_id)
+        if gpu_util is not None and memory_used is not None:
+            status = "Available" if (gpu_util <= 20 and memory_used <= 2048) else "Occupied"
+            print(f"GPU {device_id}: Util={gpu_util:3d}%, Memory={memory_used:5d}MB - {status}")
+        else:
+            print(f"GPU {device_id}: Unable to get stats")
+    print("-" * 50)
+
+def matrix_multiply_worker(matrix_size=8192, time_duration=4.0, sleep_duration=1.0, util_threshold=20, memory_threshold=-1):
+    # 获取GPU数量
+    num_gpus = torch.cuda.device_count()
+    if num_gpus == 0:
+        print("No GPUs available!")
+        return
+
+    matrices = {}
+    # print(f"Creating {matrix_size}x{matrix_size} matrices on all GPUs...")
+    for device_id in range(num_gpus):
+        device = torch.device(f'cuda:{device_id}')
+        matrices[device_id] = {
+            'a': torch.randn(matrix_size, matrix_size, device=device, dtype=torch.float32),
+            'b': torch.randn(matrix_size, matrix_size, device=device, dtype=torch.float32)
+        }
+
+    # 主循环
+    while True:
+        try:
+            # 检查所有GPU是否被占用
+            has_occupied_gpu, occupied_gpu = check_all_gpus(num_gpus, util_threshold, memory_threshold)
+            if has_occupied_gpu:
+                break
+
+            start_time = time.time()
+            perform_count = 0
+            while True:
+                # 在所有GPU上同时执行矩阵乘法
+                results = {}
+                for device_id in range(num_gpus):
+                    results[device_id] = torch.matmul(matrices[device_id]['a'], matrices[device_id]['b'])
+                
+                perform_count += 1
+
+                if perform_count % 10 == 0:
+                    for device_id in range(num_gpus):
+                        torch.cuda.synchronize(device_id)
+                
+                torch.cuda.synchronize()  # 确保所有GPU操作完成
+                elapsed_time = time.time() - start_time
+                if elapsed_time > time_duration:
+                    break
+
+            # 清理内存
+            
+            time.sleep(sleep_duration)
+            
+        except KeyboardInterrupt:
+            print("\nKeyboardInterrupt received, stopping...")
+            stop_flag = True
+            exit(0)
+        except Exception as e:
+            print(f"\nError occurred: {e}")
+            # 尝试清理内存
+            try:
+                for device_id in range(num_gpus):
+                    torch.cuda.set_device(device_id)
+                    torch.cuda.empty_cache()
+            except:
+                pass
+            time.sleep(5)
+    
+def sleep_main(args):
+    # 设置多进程启动方法
+    mp.set_start_method('spawn', force=True)
+
+    num_gpus = torch.cuda.device_count()
+    if num_gpus == 0:
+        print("No GPUs available!")
+        exit(1)
+        
+    # 显示初始GPU状态
+    get_all_gpu_status(num_gpus)
+
+    current_process = None
+    
+    # 主循环
+    while True:
+        try:
+            # 检查所有GPU是否被占用
+            has_occupied_gpu, occupied_gpu = check_all_gpus(num_gpus, util_threshold=args.util_threshold, memory_threshold=args.memory_threshold)
+            
+            if has_occupied_gpu:
+                # 休眠60秒
+                print("Holding for 60 seconds...")
+                time.sleep(60)
+                
+            else:
+                # GPU空闲，启动矩阵乘法进程
+                current_process = mp.Process(
+                    target=matrix_multiply_worker,
+                    args=(args.matrix_size, args.time_duration, args.sleep_duration, args.util_threshold, args.memory_threshold), 
+                )
+                current_process.start()
+                current_process.join()
+            
+        except KeyboardInterrupt:
+            print("\nKeyboardInterrupt received, stopping...")
+            stop_flag = True
+            break
+        except Exception as e:
+            print(f"\nError occurred: {e}")
+            time.sleep(5)
+
+    print("\nProgram stopped")
+
+
+def add_sleep_args(subparsers):
+    sleep_parser = subparsers.add_parser('sleep', help='Sleep for a while and check GPU status')
+    add_args(sleep_parser)
+
+
+def add_args(parser):
+    parser.add_argument('--matrix_size', type=int, default=8192, help='Size of the matrices to multiply')
+    parser.add_argument('--time_duration', type=float, default=4.0, help='Duration to perform matrix multiplication')
+    parser.add_argument('--sleep_duration', type=float, default=1.0, help='Duration to sleep between checks')
+
+    parser.add_argument('--util_threshold', type=int, default=20, help='GPU utilization threshold to consider it occupied')
+    parser.add_argument('--memory_threshold', type=int, default=-1, help='Memory usage threshold (in GB) to consider it occupied, set to -1 to disable')
+
+
+if __name__ == "__main__":
+    import argparse
+    parser = argparse.ArgumentParser(description='Sleep and check GPU status')
+    add_args(parser)
+    args = parser.parse_args()
+    while True:
+        try:
+            sleep_main(args)
+        except KeyboardInterrupt:
+            print("\nKeyboardInterrupt received, exiting...")
+            sys.exit(0)
+        except Exception as e:
+            print(f"\nUnexpected error: {e}")
+            print("Restarting the program in 5 seconds...")
+            time.sleep(5)
+            continue

addftool/ssh/__init__.py

@@ -0,0 +1,128 @@
+import re
+import os
+from pssh.clients import ParallelSSHClient
+from pssh.config import HostConfig
+import gevent
+
+
+def get_host_config(hostname, configs):
+    """Get configuration for a specific host from all configs."""
+    host_config = {}
+    
+    # Check for exact hostname match
+    if hostname in configs:
+        host_config.update(configs[hostname])
+    
+    # Check for wildcard matches
+    for pattern, config in configs.items():
+        if '*' in pattern or '?' in pattern:
+            # Convert SSH glob pattern to regex pattern
+            regex_pattern = pattern.replace('.', '\\.').replace('*', '.*').replace('?', '.')
+            if re.match(f"^{regex_pattern}$", hostname):
+                host_config.update(config)
+    
+    return host_config
+
+
+def parse_ssh_config_file(file_path):
+    """Parse SSH config file into a dictionary of host configurations."""
+    host_configs = {}
+    current_host = None
+    
+    if not os.path.exists(file_path):
+        return host_configs
+
+    try:
+        with open(file_path, 'r') as f:
+            for line in f:
+                line = line.strip()
+                if not line or line.startswith('#'):
+                    continue
+                    
+                if line.lower().startswith('host ') and not line.lower().startswith('host *'):
+                    hosts = line.split()[1:]
+                    for host in hosts:
+                        current_host = host
+                        if current_host not in host_configs:
+                            host_configs[current_host] = {}
+                elif current_host and ' ' in line:
+                    key, value = line.split(None, 1)
+                    host_configs[current_host][key.lower()] = value
+    except Exception as e:
+        print(f"Error reading {file_path}: {e}")
+    
+    return host_configs
+
+
+def get_ssh_config():
+    user_config_path = os.path.expanduser("~/.ssh/config")
+    system_config_path = "/etc/ssh/ssh_config"
+    
+    user_configs = parse_ssh_config_file(user_config_path)
+    system_configs = parse_ssh_config_file(system_config_path)
+    return user_configs, system_configs
+
+
+def get_client(hosts, user_ssh_configs=None, system_ssh_configs=None):
+    if user_ssh_configs is None or system_ssh_configs is None:
+        user_ssh_configs, system_ssh_configs = get_ssh_config()
+
+    to_connect = []
+    for hostname in hosts:
+        host_ssh_config = get_host_config(hostname, user_ssh_configs)
+        if not host_ssh_config:
+            host_ssh_config = get_host_config(hostname, system_ssh_configs)
+        
+        if host_ssh_config:
+            host_config = HostConfig(
+                user=host_ssh_config.get('user', os.getenv('USER', 'root')),
+                port=int(host_ssh_config.get('port', 22)),
+                private_key=host_ssh_config.get('identityfile', None),
+            )
+            host_name = host_ssh_config.get('hostname', hostname)
+            to_connect.append((host_name, host_config))
+        else:
+            print(f"No config found for host {hostname}")
+
+    # Create a ParallelSSHClient with the list of hosts
+    client = ParallelSSHClient([host[0] for host in to_connect], host_config=[host[1] for host in to_connect])
+    return client
+
+
+def handle_stream(host, stream_in, stream_name, print_call=None):
+    if print_call is None:
+        print_call = print
+    try:
+        if stream_in:
+            for line in stream_in:
+                prefix = " ERROR" if stream_name == "stderr" else ""
+                print_call(f"[{host}]{prefix}: {line}")
+                gevent.sleep(0)  # 让出控制权
+    except Exception as e:
+        print(f"[{host}] {stream_name} Exception: {e}")
+
+
+def _stdout_log(line):
+    """Log the output line."""
+    print(line)
+
+
+def _stderr_log(line):
+    """Log the error line."""
+    print("ERROR: " + line)
+
+
+def handle_hosts_outputs(hosts_outputs, out_log=None, err_log=None):
+    """Handle the outputs from the SSH command execution."""
+    if out_log is None:
+        out_log = _stdout_log
+    if err_log is None:
+        err_log = _stderr_log
+    jobs = []
+    for output in hosts_outputs:
+        host_name = output.host
+        if output:
+            jobs.append(gevent.spawn(handle_stream, host_name, output.stdout, "stdout", out_log))
+            jobs.append(gevent.spawn(handle_stream, host_name, output.stderr, "stderr", err_log))
+
+    gevent.joinall(jobs, raise_error=False)

{addftool-0.2.6.dist-info → addftool-0.2.8.dist-info}/METADATA

@@ -1,8 +1,11 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: addftool
-Version: 0.2.6
+Version: 0.2.8
 Requires-Dist: cryptography
 Requires-Dist: requests
 Requires-Dist: PyYAML
 Requires-Dist: psutil
 Requires-Dist: fabric
+Requires-Dist: gevent
+Requires-Dist: parallel-ssh
+

{addftool-0.2.6.dist-info → addftool-0.2.8.dist-info}/RECORD

@@ -1,7 +1,8 @@
 addftool/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-addftool/addf_portal.py,sha256=6XjwGs5m2mRVDWVvCPOiqn1NlxDcGBTQ9Kr_0g5RsJc,1130
+addftool/addf_portal.py,sha256=vc8opPzValNFPwJne5C5LbZvgcJ0eMBJSWDSiM23OPM,1274
 addftool/blob.py,sha256=y1HZaDBUNeXicVytvwpRXwufvvrgxR33ruBlYpxnSa4,9453
-addftool/broadcast_folder.py,sha256=X9tvvMT7cCDbfKqE7hUGaFbBOHIecIgD8xcT34Bqb_8,17708
+addftool/broadcast_folder.py,sha256=GQBuSL8Ch537V_fSBHesWyqT3KRYry68pbYOKy2bDj4,19619
+addftool/sleep.py,sha256=FA1fTUI47eQq-9nBtXElkS7SZMunP_5tLiIBuFNSM6w,7823
 addftool/sync.py,sha256=ZpYxbM8uiPFrV7ODmOaM7asVPCWaxBixA-arVc-1kfs,14045
 addftool/tool.py,sha256=FmxRY3-pP0_Z0zCUAngjmEMmPUruMftg_iUlB1t2TnQ,2001
 addftool/util.py,sha256=zlNLu8Be8cGIpNRqBw8_0q7nFxWlsJ9cToN62ohjdXE,2335
@@ -11,9 +12,9 @@ addftool/deploy/ssh_server.py,sha256=7glpJJNROskpqPkeYrTc2MbVzRendUZLv-ZgPs6HCq8
 addftool/deploy/vscode_server.py,sha256=tLtSvlcK2fEOaw6udWt8dNELVhwv9F59hF5DJJ-1Nak,2666
 addftool/process/__init__.py,sha256=Dze8OrcyjQlAbPrjE_h8bMi8W4b3OJyZOjTucPrkJvM,3721
 addftool/process/utils.py,sha256=JldxnwanLJOgxaPgmCJh7SeBRaaj5rFxWWxh1hpsvbA,2609
-addftool/ssh/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-addftool-0.2.6.dist-info/METADATA,sha256=CpZiyO1Tfsuy53kGEJbCAKk0s9PBYvtVMynKEHQWZnE,170
-addftool-0.2.6.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
-addftool-0.2.6.dist-info/entry_points.txt,sha256=9lkmuWMInwUAtev8w8poNkNd7iML9Bjd5CBCFVxg2b8,111
-addftool-0.2.6.dist-info/top_level.txt,sha256=jqj56-plrBbyzY0tIxB6wPzjAA8kte4hUlajyyQygN4,9
-addftool-0.2.6.dist-info/RECORD,,
+addftool/ssh/__init__.py,sha256=h5_rCO0A6q2Yw9vFguQZZp_ApAJsT1dcnKnbKKZ0cDM,4409
+addftool-0.2.8.dist-info/METADATA,sha256=rxu5Oy4lH7lQF99Z8gzz5QuoGxnZ739h0OBNhr_0NA0,221
+addftool-0.2.8.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
+addftool-0.2.8.dist-info/entry_points.txt,sha256=9lkmuWMInwUAtev8w8poNkNd7iML9Bjd5CBCFVxg2b8,111
+addftool-0.2.8.dist-info/top_level.txt,sha256=jqj56-plrBbyzY0tIxB6wPzjAA8kte4hUlajyyQygN4,9
+addftool-0.2.8.dist-info/RECORD,,

{addftool-0.2.6.dist-info → addftool-0.2.8.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (79.0.0)
+Generator: setuptools (75.3.2)
 Root-Is-Purelib: true
 Tag: py3-none-any