1 # 2 import os 3 import subprocess 4 import importlib.util 5 import sys,json 6 import urllib 7 import hashlib 8 import datetime
58 print(f"Installing {package}...")
59 # 清华源 -i https://pypi.tuna.tsinghua.edu.cn/simple
60 command = f'"{python}" -m pip install {package}'
61
62 result = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True, env=os.environ)
63
64 if result.returncode != 0:
65 print(f"Couldn't install\nCommand: {command}\nError code: {result.returncode}")
124 return base64_str 125 126 def calculate_md5(string): 127 encoded_string = string.encode() 128 md5_hash = hashlib.md5(encoded_string).hexdigest() 129 return md5_hash 130 131
512 raise RuntimeError(f"Ports {http_port + 1} to {http_port + 10} are all in use.")
513
514 if address == '':
515 address = '127.0.0.1'
516 if address=='0.0.0.0':
517 address = '127.0.0.1'
518
519 if verbose:
833 @routes.post('/mixlab/re_start')
834 def re_start(request):
835 try:
836 sys.stdout.close_log()
837 except Exception as e:
838 pass
839 return os.execv(sys.executable, [sys.executable] + sys.argv)
840
841
835 try: 836 sys.stdout.close_log() 837 except Exception as e: 838 pass 839 return os.execv(sys.executable, [sys.executable] + sys.argv) 840 841 842
16 return spec is not None 17 18 19 def get_unique_hash(string): 20 hash_object = hashlib.sha1(string.encode()) 21 unique_hash = hash_object.hexdigest() 22 return unique_hash 23
22 return unique_hash 23 24 def generate_random_string(length): 25 letters = string.ascii_letters + string.digits 26 return ''.join(random.choice(letters) for _ in range(length)) 27 28 class AnyType(str): 29 """A special class that is always equal in not equal comparisons. Credit to pythongosssss"""
61 def ZhipuAI_client(key):
62
63 try:
64 if is_installed('zhipuai')==False:
65 import subprocess
66
67 # 安装
68 print('#pip install zhipuai')
66
67 # 安装
68 print('#pip install zhipuai')
69
70 result = subprocess.run([sys.executable, '-s', '-m', 'pip', 'install', 'zhipuai'], capture_output=True, text=True)
71
72 #检查命令执行结果
73 if result.returncode == 0:
118
119 def llama_cpp_client(file_name):
120 try:
121 if is_installed('llama_cpp')==False:
122 import subprocess
123
124 # 安装
125 print('#pip install llama-cpp-python')
123
124 # 安装
125 print('#pip install llama-cpp-python')
126
127 result = subprocess.run([sys.executable, '-s', '-m', 'pip',
128 'install',
129 'llama-cpp-python',
130 '--extra-index-url',
131 'https://abetlen.github.io/llama-cpp-python/whl/cu121'
132 ], capture_output=True, text=True)
133
134 #检查命令执行结果
135 if result.returncode == 0:
135 if result.returncode == 0:
136 print("#install success")
137 from llama_cpp import Llama
138
139 subprocess.run([sys.executable, '-s', '-m', 'pip',
140 'install',
141 'llama-cpp-python[server]'
142 ], capture_output=True, text=True)
143
144 else:
145 print("#install error")
26
27
28 try:
29 if is_installed('clip_interrogator')==False:
30 import subprocess
31
32 # 安装
33 print('#pip install clip-interrogator==0.6.0')
31
32 # 安装
33 print('#pip install clip-interrogator==0.6.0')
34
35 result = subprocess.run([sys.executable, '-s', '-m', 'pip', 'install', 'clip-interrogator==0.6.0'], capture_output=True, text=True)
36
37 #检查命令执行结果
38 if result.returncode == 0:
141 draw.rectangle([(x, y), (x+w, y+h)], outline=color,width=width) 142 143 def generate_random_string(length): 144 letters = string.ascii_letters + string.digits 145 return ''.join(random.choice(letters) for _ in range(length)) 146 147 def padding_rectangle(grid, padding): 148 x, y, w, h = grid
608 pixels = image.load() 609 for i in range(width): 610 for j in range(height): 611 # 随机生成噪声值 612 noise_r = random.randint(-noise_level, noise_level) 613 noise_g = random.randint(-noise_level, noise_level) 614 noise_b = random.randint(-noise_level, noise_level) 615
609 for i in range(width): 610 for j in range(height): 611 # 随机生成噪声值 612 noise_r = random.randint(-noise_level, noise_level) 613 noise_g = random.randint(-noise_level, noise_level) 614 noise_b = random.randint(-noise_level, noise_level) 615 616 # 像素值加上噪声值，并限制在0-255的范围内
610 for j in range(height): 611 # 随机生成噪声值 612 noise_r = random.randint(-noise_level, noise_level) 613 noise_g = random.randint(-noise_level, noise_level) 614 noise_b = random.randint(-noise_level, noise_level) 615 616 # 像素值加上噪声值，并限制在0-255的范围内 617 r = max(0, min(pixels[i, j][0] + noise_r, 255))
17 return False
18 return spec is not None
19
20 if is_installed('simple_lama_inpainting')==False:
21 import subprocess
22 from packaging import version
23
24 if version.parse(torch.__version__)>=version.parse('2.1'):
24 if version.parse(torch.__version__)>=version.parse('2.1'):
25 # 安装
26 print('#pip install simple_lama_inpainting')
27
28 result = subprocess.run([sys.executable, '-s', '-m', 'pip', 'install', 'simple_lama_inpainting'], capture_output=True, text=True)
29
30 #检查命令执行结果
31 if result.returncode == 0:
73 class PreviewMask_(SaveImage):
74 def __init__(self):
75 self.output_dir = folder_paths.get_temp_directory()
76 self.type = "temp"
77 self.prefix_append =''.join(random.choice("abcdehijklmnopqrstupvxyzfg") for x in range(5))
78 self.compress_level = 4
79
80 @classmethod
507
508
509 try:
510 if is_installed('rembg')==False:
511 import subprocess
512
513 # 安装
514 print('#pip install rembg[gpu]')
512
513 # 安装
514 print('#pip install rembg[gpu]')
515
516 result = subprocess.run([sys.executable, '-s', '-m', 'pip', 'install', 'rembg[gpu]'], capture_output=True, text=True)
517
518 #检查命令执行结果
519 if result.returncode == 0:
46
47
48 try:
49 if is_installed('sentencepiece')==False:
50 import subprocess
51
52 # 安装
53 print('#pip install sentencepiece')
51
52 # 安装
53 print('#pip install sentencepiece')
54
55 result = subprocess.run([sys.executable, '-s', '-m', 'pip', 'install', 'sentencepiece'], capture_output=True, text=True)
56
57 #检查命令执行结果
58 if result.returncode == 0 and is_installed('sentencepiece'):
90 91 def text_generate(text_pipe,input,seed=None): 92 93 if seed==None: 94 seed = random.randint(100, 1000000) 95 96 set_seed(seed) 97
95 96 set_seed(seed) 97 98 for count in range(6): 99 sequences = text_pipe(input, max_length=random.randint(60, 90), num_return_sequences=8) 100 list = [] 101 for sequence in sequences: 102 line = sequence['generated_text'].strip()
242 result = int(n)
243 # print(result)
244
245 if random_number=='enable' and result>0:
246 result= random.randint(1, max_num)
247 return {"ui": {"text": [text],"num":[result]}, "result": (result,)}
248
249
1 import os 2 import hashlib 3 import json 4 import subprocess 5 import shutil 6 import re 7 import time,math 8 import numpy as np
142 def generate_folder_name(directory,video_path): 143 # Get the directory and filename from the video path 144 _, filename = os.path.split(video_path) 145 # Generate a random string of lowercase letters and digits 146 random_string = ''.join(random.choices(string.ascii_lowercase + string.digits, k=8)) 147 # Create the folder name by combining the random string and the filename 148 folder_name = random_string + '_' + filename 149 # Create the full folder path by joining the directory and the folder name
236 '-shortest', 237 output_path 238 ] 239 240 subprocess.run(command, check=True) 241 return output_path 242 243
647 with open(metadata_path, "w") as f:
648 f.write(";FFMETADATA1\n")
649 f.write(metadata)
650 args = args[:1] + ["-i", metadata_path] + args[1:] + [file_path]
651 with subprocess.Popen(args, stdin=subprocess.PIPE, env=env) as proc:
652 for frame in frames:
653 proc.stdin.write(frame.tobytes())
654
768 print(f"Using fallback file for extremely long metadata: {len(metadata_args[1])}/{max_arg_length}")
769 self.save_with_tempfile(args, metadata_args[1], file_path, frames, env)
770 else:
771 try:
772 with subprocess.Popen(args + metadata_args + [file_path],
773 stdin=subprocess.PIPE, env=env) as proc:
774 for frame in frames:
775 proc.stdin.write(frame.tobytes())
776 except FileNotFoundError as e:
20 # 将 NumPy 数组转换为字节数据 21 byte_data = np_array.tobytes() 22 23 # 计算哈希值 24 hash_value = hashlib.md5(byte_data).hexdigest() 25 26 return hash_value 27
28 29 cfg: Config 30 31 def configure(self) -> None: 32 assert self.cfg.feature_reduction in ["concat", "mean"] 33 self.chunk_size = 0 34 35 def set_chunk_size(self, chunk_size: int):
32 assert self.cfg.feature_reduction in ["concat", "mean"] 33 self.chunk_size = 0 34 35 def set_chunk_size(self, chunk_size: int): 36 assert ( 37 chunk_size >= 0 38 ), "chunk_size must be a non-negative integer (0 for no chunking)." 39 self.chunk_size = chunk_size 40 41 def query_triplane(
33 ) 34 35 def detokenize(self, tokens: torch.Tensor) -> torch.Tensor: 36 batch_size, Ct, Nt = tokens.shape 37 assert Nt == self.cfg.plane_size**2 * 3 38 assert Ct == self.cfg.num_channels 39 return rearrange( 40 tokens,
34 35 def detokenize(self, tokens: torch.Tensor) -> torch.Tensor: 36 batch_size, Ct, Nt = tokens.shape 37 assert Nt == self.cfg.plane_size**2 * 3 38 assert Ct == self.cfg.num_channels 39 return rearrange( 40 tokens, 41 "B Ct (Np Hp Wp) -> B Np Ct Hp Wp",
425 426 Returns: 427 `torch.Tensor`: The normalized encoder hidden states. 428 """ 429 assert ( 430 self.norm_cross is not None 431 ), "self.norm_cross must be defined to call self.norm_encoder_hidden_states" 432 433 if isinstance(self.norm_cross, nn.LayerNorm): 434 encoder_hidden_states = self.norm_cross(encoder_hidden_states)
441 encoder_hidden_states = encoder_hidden_states.transpose(1, 2) 442 encoder_hidden_states = self.norm_cross(encoder_hidden_states) 443 encoder_hidden_states = encoder_hidden_states.transpose(1, 2) 444 else: 445 assert False 446 447 return encoder_hidden_states 448
90 ): 91 super().__init__() 92 self.only_cross_attention = only_cross_attention 93 94 assert norm_type == "layer_norm" 95 96 # Define 3 blocks. Each block has its own normalization layer. 97 # 1. Self-Attn
158 for arg in list(args) + list(kwargs.values()): 159 if isinstance(arg, torch.Tensor): 160 B = arg.shape[0] 161 break 162 assert ( 163 B is not None 164 ), "No tensor found in args or kwargs, cannot determine batch size." 165 out = defaultdict(list) 166 out_type = None 167 # max(1, B) to support B == 0
226 inp_scale = (0, 1) 227 if tgt_scale is None: 228 tgt_scale = (0, 1) 229 if isinstance(tgt_scale, torch.FloatTensor): 230 assert dat.shape[-1] == tgt_scale.shape[-1] 231 dat = (dat - inp_scale[0]) / (inp_scale[1] - inp_scale[0]) 232 dat = dat * (tgt_scale[1] - tgt_scale[0]) + tgt_scale[0] 233 return dat
278 fx, fy = focal, focal 279 cx, cy = W / 2, H / 2 280 else: 281 fx, fy = focal 282 assert principal is not None 283 cx, cy = principal 284 285 i, j = torch.meshgrid(
302 keepdim=False, 303 normalize=False, 304 ) -> Tuple[torch.FloatTensor, torch.FloatTensor]: 305 # Rotate ray directions from camera coordinate to the world coordinate 306 assert directions.shape[-1] == 3 307 308 if directions.ndim == 2: # (N_rays, 3) 309 if c2w.ndim == 2: # (4, 4)
307 308 if directions.ndim == 2: # (N_rays, 3) 309 if c2w.ndim == 2: # (4, 4) 310 c2w = c2w[None, :, :] 311 assert c2w.ndim == 3 # (N_rays, 4, 4) or (1, 4, 4) 312 rays_d = (directions[:, None, :] * c2w[:, :3, :3]).sum(-1) # (N_rays, 3) 313 rays_o = c2w[:, :3, 3].expand(rays_d.shape) 314 elif directions.ndim == 3: # (H, W, 3)
311 assert c2w.ndim == 3 # (N_rays, 4, 4) or (1, 4, 4) 312 rays_d = (directions[:, None, :] * c2w[:, :3, :3]).sum(-1) # (N_rays, 3) 313 rays_o = c2w[:, :3, 3].expand(rays_d.shape) 314 elif directions.ndim == 3: # (H, W, 3) 315 assert c2w.ndim in [2, 3] 316 if c2w.ndim == 2: # (4, 4) 317 rays_d = (directions[:, :, None, :] * c2w[None, None, :3, :3]).sum( 318 -1
323 -1 324 ) # (B, H, W, 3) 325 rays_o = c2w[:, None, None, :3, 3].expand(rays_d.shape) 326 elif directions.ndim == 4: # (B, H, W, 3) 327 assert c2w.ndim == 3 # (B, 4, 4) 328 rays_d = (directions[:, :, :, None, :] * c2w[:, None, None, :3, :3]).sum( 329 -1 330 ) # (B, H, W, 3)
418 image: PIL.Image.Image, 419 ratio: float, 420 ) -> PIL.Image.Image: 421 image = np.array(image) 422 assert image.shape[-1] == 4 423 alpha = np.where(image[..., 3] > 0) 424 y1, y2, x1, x2 = ( 425 alpha[0].min(),