xinference 1.10.0__py3-none-any.whl → 1.11.0__py3-none-any.whl

xinference/thirdparty/indextts/vqvae/xtts_dvae.py

@@ -0,0 +1,395 @@
+import functools
+from math import sqrt
+
+import torch
+import torch.distributed as distributed
+import torch.nn as nn
+import torch.nn.functional as F
+import torchaudio
+from einops import rearrange
+
+
+def default(val, d):
+    return val if val is not None else d
+
+
+def eval_decorator(fn):
+    def inner(model, *args, **kwargs):
+        was_training = model.training
+        model.eval()
+        out = fn(model, *args, **kwargs)
+        model.train(was_training)
+        return out
+
+    return inner
+
+
+def dvae_wav_to_mel(
+    wav, mel_norms_file="../experiments/clips_mel_norms.pth", mel_norms=None, device=torch.device("cpu")
+):
+    mel_stft = torchaudio.transforms.MelSpectrogram(
+        n_fft=1024,
+        hop_length=256,
+        win_length=1024,
+        power=2,
+        normalized=False,
+        sample_rate=22050,
+        f_min=0,
+        f_max=8000,
+        n_mels=80,
+        norm="slaney",
+    ).to(device)
+    wav = wav.to(device)
+    mel = mel_stft(wav)
+    mel = torch.log(torch.clamp(mel, min=1e-5))
+    if mel_norms is None:
+        mel_norms = torch.load(mel_norms_file, map_location=device)
+    mel = mel / mel_norms.unsqueeze(0).unsqueeze(-1)
+    return mel
+
+
+class Quantize(nn.Module):
+    def __init__(self, dim, n_embed, decay=0.99, eps=1e-5, balancing_heuristic=False, new_return_order=False):
+        super().__init__()
+
+        self.dim = dim
+        self.n_embed = n_embed
+        self.decay = decay
+        self.eps = eps
+
+        self.balancing_heuristic = balancing_heuristic
+        self.codes = None
+        self.max_codes = 64000
+        self.codes_full = False
+        self.new_return_order = new_return_order
+
+        embed = torch.randn(dim, n_embed)
+        self.register_buffer("embed", embed)
+        self.register_buffer("cluster_size", torch.zeros(n_embed))
+        self.register_buffer("embed_avg", embed.clone())
+
+    def forward(self, input, return_soft_codes=False):
+        if self.balancing_heuristic and self.codes_full:
+            h = torch.histc(self.codes, bins=self.n_embed, min=0, max=self.n_embed) / len(self.codes)
+            mask = torch.logical_or(h > 0.9, h < 0.01).unsqueeze(1)
+            ep = self.embed.permute(1, 0)
+            ea = self.embed_avg.permute(1, 0)
+            rand_embed = torch.randn_like(ep) * mask
+            self.embed = (ep * ~mask + rand_embed).permute(1, 0)
+            self.embed_avg = (ea * ~mask + rand_embed).permute(1, 0)
+            self.cluster_size = self.cluster_size * ~mask.squeeze()
+            if torch.any(mask):
+                print(f"Reset {torch.sum(mask)} embedding codes.")
+                self.codes = None
+                self.codes_full = False
+
+        flatten = input.reshape(-1, self.dim)
+        dist = flatten.pow(2).sum(1, keepdim=True) - 2 * flatten @ self.embed + self.embed.pow(2).sum(0, keepdim=True)
+        soft_codes = -dist
+        _, embed_ind = soft_codes.max(1)
+        embed_onehot = F.one_hot(embed_ind, self.n_embed).type(flatten.dtype)
+        embed_ind = embed_ind.view(*input.shape[:-1])
+        quantize = self.embed_code(embed_ind)
+
+        if self.balancing_heuristic:
+            if self.codes is None:
+                self.codes = embed_ind.flatten()
+            else:
+                self.codes = torch.cat([self.codes, embed_ind.flatten()])
+                if len(self.codes) > self.max_codes:
+                    self.codes = self.codes[-self.max_codes :]
+                    self.codes_full = True
+
+        if self.training:
+            embed_onehot_sum = embed_onehot.sum(0)
+            embed_sum = flatten.transpose(0, 1) @ embed_onehot
+
+            if distributed.is_initialized() and distributed.get_world_size() > 1:
+                distributed.all_reduce(embed_onehot_sum)
+                distributed.all_reduce(embed_sum)
+
+            self.cluster_size.data.mul_(self.decay).add_(embed_onehot_sum, alpha=1 - self.decay)
+            self.embed_avg.data.mul_(self.decay).add_(embed_sum, alpha=1 - self.decay)
+            n = self.cluster_size.sum()
+            cluster_size = (self.cluster_size + self.eps) / (n + self.n_embed * self.eps) * n
+            embed_normalized = self.embed_avg / cluster_size.unsqueeze(0)
+            self.embed.data.copy_(embed_normalized)
+
+        diff = (quantize.detach() - input).pow(2).mean()
+        quantize = input + (quantize - input).detach()
+
+        if return_soft_codes:
+            return quantize, diff, embed_ind, soft_codes.view(input.shape[:-1] + (-1,))
+        elif self.new_return_order:
+            return quantize, embed_ind, diff
+        else:
+            return quantize, diff, embed_ind
+
+    def embed_code(self, embed_id):
+        return F.embedding(embed_id, self.embed.transpose(0, 1))
+
+
+# Fits a soft-discretized input to a normal-PDF across the specified dimension.
+# In other words, attempts to force the discretization function to have a mean equal utilization across all discrete
+# values with the specified expected variance.
+class DiscretizationLoss(nn.Module):
+    def __init__(self, discrete_bins, dim, expected_variance, store_past=0):
+        super().__init__()
+        self.discrete_bins = discrete_bins
+        self.dim = dim
+        self.dist = torch.distributions.Normal(0, scale=expected_variance)
+        if store_past > 0:
+            self.record_past = True
+            self.register_buffer("accumulator_index", torch.zeros(1, dtype=torch.long, device="cpu"))
+            self.register_buffer("accumulator_filled", torch.zeros(1, dtype=torch.long, device="cpu"))
+            self.register_buffer("accumulator", torch.zeros(store_past, discrete_bins))
+        else:
+            self.record_past = False
+
+    def forward(self, x):
+        other_dims = set(range(len(x.shape))) - set([self.dim])
+        averaged = x.sum(dim=tuple(other_dims)) / x.sum()
+        averaged = averaged - averaged.mean()
+
+        if self.record_past:
+            acc_count = self.accumulator.shape[0]
+            avg = averaged.detach().clone()
+            if self.accumulator_filled > 0:
+                averaged = torch.mean(self.accumulator, dim=0) * (acc_count - 1) / acc_count + averaged / acc_count
+
+            # Also push averaged into the accumulator.
+            self.accumulator[self.accumulator_index] = avg
+            self.accumulator_index += 1
+            if self.accumulator_index >= acc_count:
+                self.accumulator_index *= 0
+                if self.accumulator_filled <= 0:
+                    self.accumulator_filled += 1
+
+        return torch.sum(-self.dist.log_prob(averaged))
+
+
+class ResBlock(nn.Module):
+    def __init__(self, chan, conv, activation):
+        super().__init__()
+        self.net = nn.Sequential(
+            conv(chan, chan, 3, padding=1),
+            activation(),
+            conv(chan, chan, 3, padding=1),
+            activation(),
+            conv(chan, chan, 1),
+        )
+
+    def forward(self, x):
+        return self.net(x) + x
+
+
+class UpsampledConv(nn.Module):
+    def __init__(self, conv, *args, **kwargs):
+        super().__init__()
+        assert "stride" in kwargs.keys()
+        self.stride = kwargs["stride"]
+        del kwargs["stride"]
+        self.conv = conv(*args, **kwargs)
+
+    def forward(self, x):
+        up = nn.functional.interpolate(x, scale_factor=self.stride, mode="nearest")
+        return self.conv(up)
+
+
+# DiscreteVAE partially derived from lucidrains DALLE implementation
+# Credit: https://github.com/lucidrains/DALLE-pytorch
+class DiscreteVAE(nn.Module):
+    def __init__(
+        self,
+        positional_dims=2,
+        num_tokens=512,
+        codebook_dim=512,
+        num_layers=3,
+        num_resnet_blocks=0,
+        hidden_dim=64,
+        channels=3,
+        stride=2,
+        kernel_size=4,
+        use_transposed_convs=True,
+        encoder_norm=False,
+        activation="relu",
+        smooth_l1_loss=False,
+        straight_through=False,
+        normalization=None,  # ((0.5,) * 3, (0.5,) * 3),
+        record_codes=False,
+        discretization_loss_averaging_steps=100,
+        lr_quantizer_args={},
+    ):
+        super().__init__()
+        has_resblocks = num_resnet_blocks > 0
+
+        self.num_tokens = num_tokens
+        self.num_layers = num_layers
+        self.straight_through = straight_through
+        self.positional_dims = positional_dims
+        self.discrete_loss = DiscretizationLoss(
+            num_tokens, 2, 1 / (num_tokens * 2), discretization_loss_averaging_steps
+        )
+
+        assert positional_dims > 0 and positional_dims < 3  # This VAE only supports 1d and 2d inputs for now.
+        if positional_dims == 2:
+            conv = nn.Conv2d
+            conv_transpose = nn.ConvTranspose2d
+        else:
+            conv = nn.Conv1d
+            conv_transpose = nn.ConvTranspose1d
+        if not use_transposed_convs:
+            conv_transpose = functools.partial(UpsampledConv, conv)
+
+        if activation == "relu":
+            act = nn.ReLU
+        elif activation == "silu":
+            act = nn.SiLU
+        else:
+            assert NotImplementedError()
+
+        enc_layers = []
+        dec_layers = []
+
+        if num_layers > 0:
+            enc_chans = [hidden_dim * 2**i for i in range(num_layers)]
+            dec_chans = list(reversed(enc_chans))
+
+            enc_chans = [channels, *enc_chans]
+
+            dec_init_chan = codebook_dim if not has_resblocks else dec_chans[0]
+            dec_chans = [dec_init_chan, *dec_chans]
+
+            enc_chans_io, dec_chans_io = map(lambda t: list(zip(t[:-1], t[1:])), (enc_chans, dec_chans))
+
+            pad = (kernel_size - 1) // 2
+            for (enc_in, enc_out), (dec_in, dec_out) in zip(enc_chans_io, dec_chans_io):
+                enc_layers.append(nn.Sequential(conv(enc_in, enc_out, kernel_size, stride=stride, padding=pad), act()))
+                if encoder_norm:
+                    enc_layers.append(nn.GroupNorm(8, enc_out))
+                dec_layers.append(
+                    nn.Sequential(conv_transpose(dec_in, dec_out, kernel_size, stride=stride, padding=pad), act())
+                )
+            dec_out_chans = dec_chans[-1]
+            innermost_dim = dec_chans[0]
+        else:
+            enc_layers.append(nn.Sequential(conv(channels, hidden_dim, 1), act()))
+            dec_out_chans = hidden_dim
+            innermost_dim = hidden_dim
+
+        for _ in range(num_resnet_blocks):
+            dec_layers.insert(0, ResBlock(innermost_dim, conv, act))
+            enc_layers.append(ResBlock(innermost_dim, conv, act))
+
+        if num_resnet_blocks > 0:
+            dec_layers.insert(0, conv(codebook_dim, innermost_dim, 1))
+
+        enc_layers.append(conv(innermost_dim, codebook_dim, 1))
+        dec_layers.append(conv(dec_out_chans, channels, 1))
+
+        self.encoder = nn.Sequential(*enc_layers)
+        self.decoder = nn.Sequential(*dec_layers)
+
+        self.loss_fn = F.smooth_l1_loss if smooth_l1_loss else F.mse_loss
+        self.codebook = Quantize(codebook_dim, num_tokens, new_return_order=True)
+
+        # take care of normalization within class
+        self.normalization = normalization
+        self.record_codes = record_codes
+        if record_codes:
+            self.codes = torch.zeros((1228800,), dtype=torch.long)
+            self.code_ind = 0
+            self.total_codes = 0
+        self.internal_step = 0
+
+    def norm(self, images):
+        if not self.normalization is not None:
+            return images
+
+        means, stds = map(lambda t: torch.as_tensor(t).to(images), self.normalization)
+        arrange = "c -> () c () ()" if self.positional_dims == 2 else "c -> () c ()"
+        means, stds = map(lambda t: rearrange(t, arrange), (means, stds))
+        images = images.clone()
+        images.sub_(means).div_(stds)
+        return images
+
+    def get_debug_values(self, step, __):
+        if self.record_codes and self.total_codes > 0:
+            # Report annealing schedule
+            return {"histogram_codes": self.codes[: self.total_codes]}
+        else:
+            return {}
+
+    @torch.no_grad()
+    @eval_decorator
+    def get_codebook_indices(self, images):
+        img = self.norm(images)
+        logits = self.encoder(img).permute((0, 2, 3, 1) if len(img.shape) == 4 else (0, 2, 1))
+        sampled, codes, _ = self.codebook(logits)
+        self.log_codes(codes)
+        return codes
+
+    def decode(self, img_seq):
+        self.log_codes(img_seq)
+        if hasattr(self.codebook, "embed_code"):
+            image_embeds = self.codebook.embed_code(img_seq)
+        else:
+            image_embeds = F.embedding(img_seq, self.codebook.codebook)
+        b, n, d = image_embeds.shape
+
+        kwargs = {}
+        if self.positional_dims == 1:
+            arrange = "b n d -> b d n"
+        else:
+            h = w = int(sqrt(n))
+            arrange = "b (h w) d -> b d h w"
+            kwargs = {"h": h, "w": w}
+        image_embeds = rearrange(image_embeds, arrange, **kwargs)
+        images = [image_embeds]
+        for layer in self.decoder:
+            images.append(layer(images[-1]))
+        return images[-1], images[-2]
+
+    def infer(self, img):
+        img = self.norm(img)
+        logits = self.encoder(img).permute((0, 2, 3, 1) if len(img.shape) == 4 else (0, 2, 1))
+        sampled, codes, commitment_loss = self.codebook(logits)
+        return self.decode(codes)
+
+    # Note: This module is not meant to be run in forward() except while training. It has special logic which performs
+    # evaluation using quantized values when it detects that it is being run in eval() mode, which will be substantially
+    # more lossy (but useful for determining network performance).
+    def forward(self, img):
+        img = self.norm(img)
+        logits = self.encoder(img).permute((0, 2, 3, 1) if len(img.shape) == 4 else (0, 2, 1))
+        sampled, codes, commitment_loss = self.codebook(logits)
+        sampled = sampled.permute((0, 3, 1, 2) if len(img.shape) == 4 else (0, 2, 1))
+
+        if self.training:
+            out = sampled
+            for d in self.decoder:
+                out = d(out)
+            self.log_codes(codes)
+        else:
+            # This is non-differentiable, but gives a better idea of how the network is actually performing.
+            out, _ = self.decode(codes)
+
+        # reconstruction loss
+        out = out[..., :img.shape[-1]]
+        recon_loss = self.loss_fn(img, out, reduction="mean")
+        ssim_loss = torch.zeros(size=(1,)).cuda()
+
+        return recon_loss, ssim_loss, commitment_loss, out
+
+    def log_codes(self, codes):
+        # This is so we can debug the distribution of codes being learned.
+        if self.record_codes and self.internal_step % 10 == 0:
+            codes = codes.flatten()
+            l = codes.shape[0]
+            i = self.code_ind if (self.codes.shape[0] - self.code_ind) > l else self.codes.shape[0] - l
+            self.codes[i : i + l] = codes.cpu()
+            self.code_ind = self.code_ind + l
+            if self.code_ind >= self.codes.shape[0]:
+                self.code_ind = 0
+            self.total_codes += 1
+        self.internal_step += 1

xinference/thirdparty/melo/text/chinese_mix.py

@@ -209,13 +209,13 @@ def _g2p_v2(segments):
     for text in segments:
         assert spliter not in text
         # replace all english words
-        text = re.sub('([a-zA-Z\s]+)', lambda x: f'{spliter}{x.group(1)}{spliter}', text)
+        text = re.sub(r'([a-zA-Z\s]+)', lambda x: f'{spliter}{x.group(1)}{spliter}', text)
         texts = text.split(spliter)
         texts = [t for t in texts if len(t) > 0]
 
         
         for text in texts:
-            if re.match('[a-zA-Z\s]+', text):
+            if re.match(r'[a-zA-Z\s]+', text):
                 # english
                 tokenized_en = tokenizer.tokenize(text)
                 phones_en, tones_en, word2ph_en = g2p_en(text=None, pad_start_end=False, tokenized=tokenized_en)

xinference/types.py

@@ -47,6 +47,15 @@ class ImageList(TypedDict):
     data: List[Image]
 
 
+class ImageEditRequest(TypedDict, total=False):
+    image: Union[Union[str, bytes], List[Union[str, bytes]]]
+    mask: Optional[Union[str, bytes]]
+    prompt: str
+    n: int
+    size: Optional[str]
+    response_format: str
+
+
 class SDAPIResult(TypedDict):
     images: List[str]
     parameters: dict

xinference/ui/gradio/media_interface.py

@@ -217,7 +217,7 @@ class MediaInterface:
         def image_generate_image(
             prompt: str,
             negative_prompt: str,
-            image: PIL.Image.Image,
+            images: Optional[List[PIL.Image.Image]],
             n: int,
             size_width: int,
             size_height: int,
@@ -250,8 +250,21 @@ class MediaInterface:
                 kwargs["strength"] = strength
             sampler_name = None if sampler_name == "default" else sampler_name
 
-            bio = io.BytesIO()
-            image.save(bio, format="png")
+            # Handle single image or multiple images
+            if images is None:
+                raise ValueError("Please upload at least one image")
+
+            # Process uploaded files to get PIL images
+            processed_images = process_uploaded_files(images)
+            if processed_images is None:
+                raise ValueError("Please upload at least one image")
+
+            # Convert all images to bytes
+            image_bytes_list = []
+            for img in processed_images:
+                bio = io.BytesIO()
+                img.save(bio, format="png")
+                image_bytes_list.append(bio.getvalue())
 
             response = None
             exc = None
@@ -265,7 +278,7 @@ class MediaInterface:
                         prompt=prompt,
                         negative_prompt=negative_prompt,
                         n=n,
-                        image=bio.getvalue(),
+                        image=image_bytes_list,
                         size=size,
                         response_format="b64_json",
                         num_inference_steps=num_inference_steps,
@@ -300,7 +313,7 @@ class MediaInterface:
 
             return images
 
-        with gr.Blocks() as image2image_inteface:
+        with gr.Blocks() as image2image_interface:
             with gr.Column():
                 with gr.Row():
                     with gr.Column(scale=10):
@@ -341,16 +354,61 @@ class MediaInterface:
 
                 with gr.Row():
                     with gr.Column(scale=1):
-                        uploaded_image = gr.Image(type="pil", label="Upload Image")
+                        gr.Markdown("### Upload Images")
+                        gr.Markdown(
+                            "*Multiple images supported for image-to-image generation*"
+                        )
+                        uploaded_images = gr.File(
+                            file_count="multiple",
+                            file_types=["image"],
+                            label="Upload Images",
+                        )
+                        image_preview = gr.Gallery(label="Image Preview", height=300)
                     with gr.Column(scale=1):
                         output_gallery = gr.Gallery()
 
+            # Function to handle file uploads and convert to PIL images
+            def process_uploaded_files(files):
+                if files is None:
+                    return None
+
+                images = []
+                for file_info in files:
+                    if isinstance(file_info, dict) and "name" in file_info:
+                        # Handle file info format from gradio
+                        file_path = file_info["name"]
+                        try:
+                            img = PIL.Image.open(file_path)
+                            images.append(img)
+                        except Exception as e:
+                            logger.warning(f"Failed to load image {file_path}: {e}")
+                    elif hasattr(file_info, "name"):
+                        # Handle file object
+                        try:
+                            img = PIL.Image.open(file_info.name)
+                            images.append(img)
+                        except Exception as e:
+                            logger.warning(
+                                f"Failed to load image {file_info.name}: {e}"
+                            )
+
+                return images if images else None
+
+            # Update gallery when files are uploaded
+            def update_gallery(files):
+                images = process_uploaded_files(files)
+                return images if images else []
+
+            uploaded_images.change(
+                update_gallery, inputs=[uploaded_images], outputs=[image_preview]
+            )
+
             generate_button.click(
                 image_generate_image,
                 inputs=[
                     prompt,
                     negative_prompt,
-                    uploaded_image,
+                    uploaded_images,
                     n,
                     size_width,
                     size_height,
@@ -362,7 +420,7 @@ class MediaInterface:
                 ],
                 outputs=output_gallery,
             )
-        return image2image_inteface
+        return image2image_interface
 
     def inpainting_interface(self) -> "gr.Blocks":
         from ...model.image.stable_diffusion.core import SAMPLING_METHODS

xinference/ui/web/ui/build/asset-manifest.json

@@ -1,14 +1,14 @@
 {
   "files": {
-    "main.css": "./static/css/main.013f296b.css",
-    "main.js": "./static/js/main.1086c759.js",
+    "main.css": "./static/css/main.5ea97072.css",
+    "main.js": "./static/js/main.45e78536.js",
     "static/media/icon.webp": "./static/media/icon.4603d52c63041e5dfbfd.webp",
     "index.html": "./index.html",
-    "main.013f296b.css.map": "./static/css/main.013f296b.css.map",
-    "main.1086c759.js.map": "./static/js/main.1086c759.js.map"
+    "main.5ea97072.css.map": "./static/css/main.5ea97072.css.map",
+    "main.45e78536.js.map": "./static/js/main.45e78536.js.map"
   },
   "entrypoints": [
-    "static/css/main.013f296b.css",
-    "static/js/main.1086c759.js"
+    "static/css/main.5ea97072.css",
+    "static/js/main.45e78536.js"
   ]
 }

xinference/ui/web/ui/build/index.html

@@ -1 +1 @@
-<!doctype html><html lang="en"><head><meta charset="utf-8"/><link rel="icon" href="./favicon.svg"/><meta name="viewport" content="width=device-width,initial-scale=1"/><meta name="theme-color" content="#000000"/><meta name="description" content="Web site created using create-react-app"/><link rel="apple-touch-icon" href="./logo192.png"/><link rel="manifest" href="./manifest.json"/><title>Xinference</title><script defer="defer" src="./static/js/main.1086c759.js"></script><link href="./static/css/main.013f296b.css" rel="stylesheet"></head><body><noscript>You need to enable JavaScript to run this app.</noscript><div id="root"></div></body></html>
+<!doctype html><html lang="en"><head><meta charset="utf-8"/><link rel="icon" href="./favicon.svg"/><meta name="viewport" content="width=device-width,initial-scale=1"/><meta name="theme-color" content="#000000"/><meta name="description" content="Web site created using create-react-app"/><link rel="apple-touch-icon" href="./logo192.png"/><link rel="manifest" href="./manifest.json"/><title>Xinference</title><script defer="defer" src="./static/js/main.45e78536.js"></script><link href="./static/css/main.5ea97072.css" rel="stylesheet"></head><body><noscript>You need to enable JavaScript to run this app.</noscript><div id="root"></div></body></html>

xinference/ui/web/ui/build/static/css/main.5ea97072.css

@@ -0,0 +1,2 @@
+.container{border-radius:20px!important;cursor:pointer;display:block}.container,.descriptionCard{height:300px;position:relative;width:300px}.descriptionCard{border-radius:20px;flex-direction:column;left:-1px;padding:20px;top:-1px}.cardTitle,.descriptionCard{display:flex;justify-content:space-between}.iconButtonBox{align-items:center;display:flex}.drawerCard{display:flex;flex-direction:column;min-height:100%;min-width:350px;overflow-y:scroll;padding:20px 80px 100px;position:relative;width:60vw}.pasteText{color:#1976d2;cursor:pointer;font-size:18px!important;margin-inline:10px}.pasteText:hover{color:#1976d2b3}.copyToCommandLine{color:#1976d2;cursor:pointer;font-size:16px!important}.copyToCommandLine:hover{color:#1976d2b3}.css-1be5mm1-MuiLinearProgress-root-MuiMobileStepper-progress,.css-r5rjnf-MuiLinearProgress-root-MuiMobileStepper-progress{width:100%!important}.pathBox{cursor:pointer;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;width:160px}.pathBox2{width:300px}.empty{color:#555;font-size:20px;left:50%;position:absolute;top:30%;-webkit-transform:translate(-50%);transform:translate(-50%)}.deleteDialog{align-items:center;display:flex}.warningIcon{color:#ed6c02;margin-right:10px}.textHighlight .MuiInputBase-input,.textHighlight .MuiSelect-select{color:#1976d2}.formBox{max-height:80vh;max-width:50vw;min-width:50vw;overflow:auto;padding:40px 20px 0 0;position:relative;transition:all .4s ease-in-out}.broaden{max-width:100%;min-width:100%;padding-right:0}.show-json{align-items:center;display:flex;right:60px;top:90px}.icon,.show-json{position:absolute}.icon{cursor:pointer;margin-left:20px;right:-40px}.icon:hover{color:#1976d2}.arrow{font-size:24px!important}.jsonBox{min-height:80vh;position:relative;transition:all .4s ease-in-out;width:100%}.hide{overflow:hidden;-webkit-transform:translate(30vw);transform:translate(30vw);width:0}.checkboxWrapper{align-items:center;display:flex;flex-wrap:wrap;width:100%}.jsonBox-header{align-items:center;display:flex;justify-content:space-between}.jsonBox-title{font-weight:700;line-height:40px}.textarea{background-color:initial;border:1px solid #ddd;border-radius:5px;color:#666;height:calc(100% - 40px);padding:5px 10px;resize:none;width:100%}.addBtn{margin-left:20px!important}.item{border:1px solid #ddd;border-radius:10px;margin:10px 50px 0;overflow:hidden;padding:20px;position:relative}.item:hover .deleteBtn{-webkit-transform:translateX(-50px);transform:translateX(-50px)}.deleteBtn{background-color:#1976d2;border-radius:25px;height:50px;line-height:70px;position:absolute;right:20px;text-align:center;top:calc(50% - 25px);-webkit-transform:translateX(80px);transform:translateX(80px);transition:all .3s ease-in-out;width:50px}.deleteBtn:hover{box-shadow:0 0 10px #aaa;cursor:pointer}.deleteIcon{color:#fff;font-size:28px!important}.chat_template_box{align-items:start;display:flex;gap:10px}.chat_template_test{width:30%}.chat_template_test_mainBox{border:1px solid #ccc;border-radius:4px;height:137px;overflow:scroll;padding:10px}.chat_template_test_tip{color:rgba(0,0,0,.6);font-size:10px;margin:4px 14px 0}.test_res_box{border:1px solid #ddd;border-radius:4px;margin-top:5px;min-height:55px;padding:10px}.css-19qh8xo-MuiInputBase-input-MuiOutlinedInput-input.Mui-disabled{-webkit-text-fill-color:#000!important}
+/*# sourceMappingURL=main.5ea97072.css.map*/

xinference/ui/web/ui/build/static/css/main.5ea97072.css.map

@@ -0,0 +1 @@
+{"version":3,"file":"static/css/main.5ea97072.css","mappings":"AAAA,WAME,4BAA8B,CAD9B,cAAe,CAJf,aAMF,CACA,4BAJE,YAAa,CAFb,iBAAkB,CAClB,WAgBF,CAXA,iBAUE,kBAAmB,CARnB,qBAAsB,CAItB,SAAU,CAGV,YAAa,CAJb,QAMF,CACA,4BAXE,YAAa,CAEb,6BAYF,CACA,eAEE,kBAAmB,CADnB,YAEF,CACA,YAEE,YAAa,CACb,qBAAsB,CAEtB,eAAgB,CAEhB,eAAgB,CAChB,iBAAkB,CAJlB,uBAAwB,CAHxB,iBAAkB,CAKlB,UAGF,CACA,WAEE,aAAc,CACd,cAAe,CAFf,wBAA0B,CAG1B,kBACF,CACA,iBACE,eACF,CACA,mBAEE,aAAc,CACd,cAAe,CAFf,wBAGF,CACA,yBACE,eACF,CAIA,2HACE,oBACF,CACA,SAEE,cAAe,CACf,eAAgB,CAEhB,sBAAuB,CADvB,kBAAmB,CAHnB,WAKF,CACA,UACE,WACF,CACA,OAKE,UAAW,CADX,cAAe,CAFf,QAAS,CADT,iBAAkB,CAElB,OAAQ,CAGR,iCAA6B,CAA7B,yBACF,CACA,cAEE,kBAAmB,CADnB,YAEF,CACA,aAEE,aAAuB,CADvB,iBAEF,CAIA,oEACE,aACF,CC5FA,SAIE,eAAgB,CAFhB,cAAe,CACf,cAAe,CAEf,aAAc,CACd,qBAAsB,CALtB,iBAAkB,CAMlB,8BACF,CAEA,SACE,cAAe,CACf,cAAe,CACf,eACF,CAEA,WAEE,kBAAmB,CADnB,YAAa,CAIb,UAAW,CADX,QAEF,CAEA,iBALE,iBAUF,CALA,MAGE,cAAe,CACf,gBAAiB,CAFjB,WAGF,CAEA,YACE,aACF,CAEA,OACE,wBACF,CAEA,SAEE,eAAgB,CADhB,iBAAkB,CAGlB,8BAAgC,CADhC,UAEF,CAEA,MAGE,eAAgB,CADhB,iCAA6B,CAA7B,yBAA6B,CAD7B,OAGF,CAEA,iBAGE,kBAAmB,CAFnB,YAAa,CACb,cAAe,CAEf,UACF,CAEA,gBAGE,kBAAmB,CAFnB,YAAa,CACb,6BAEF,CAEA,eAEE,eAAgB,CADhB,gBAEF,CAEA,UAQE,wBAA6B,CAJ7B,qBAAsB,CACtB,iBAAkB,CAElB,UAAW,CALX,wBAAyB,CACzB,gBAAiB,CAGjB,WAAY,CALZ,UAQF,CAEA,QACE,0BACF,CAEA,MAEE,qBAAsB,CAGtB,kBAAmB,CAFnB,kBAAmB,CAGnB,eAAgB,CAFhB,YAAa,CAHb,iBAMF,CAEA,uBACE,mCAA4B,CAA5B,2BACF,CAEA,WAUE,wBAAyB,CADzB,kBAAmB,CAJnB,WAAY,CAGZ,gBAAiB,CAPjB,iBAAkB,CAClB,UAAW,CAKX,iBAAkB,CAJlB,oBAAqB,CAGrB,kCAA2B,CAA3B,0BAA2B,CAK3B,8BAAgC,CAPhC,UAQF,CAEA,iBAEE,wBAAyB,CADzB,cAEF,CAEA,YAEE,UAAW,CADX,wBAEF,CAEA,mBAEE,iBAAkB,CADlB,YAAa,CAEb,QACF,CAEA,oBACE,SACF,CAEA,4BAGE,qBAAsB,CACtB,iBAAkB,CAHlB,YAAa,CAIb,eAAgB,CAHhB,YAIF,CAEA,wBAGE,oBAAyB,CAFzB,cAAe,CACf,iBAEF,CAEA,cACE,qBAAsB,CAItB,iBAAkB,CADlB,cAAe,CAFf,eAAgB,CAChB,YAGF,CAEA,oEACE,sCACF","sources":["scenes/launch_model/styles/modelCardStyle.css","scenes/register_model/styles/registerModelStyle.css"],"sourcesContent":[".container {\n  display: block;\n  position: relative;\n  width: 300px;\n  height: 300px;\n  cursor: pointer;\n  border-radius: 20px !important;\n}\n.descriptionCard {\n  display: flex;\n  flex-direction: column;\n  justify-content: space-between;\n  position: relative;\n  top: -1px;\n  left: -1px;\n  width: 300px;\n  height: 300px;\n  padding: 20px;\n  border-radius: 20px;\n}\n.cardTitle {\n  display: flex;\n  justify-content: space-between;\n}\n.iconButtonBox {\n  display: flex;\n  align-items: center;\n}\n.drawerCard {\n  position: relative;\n  display: flex;\n  flex-direction: column;\n  padding: 20px 80px 100px;\n  min-height: 100%;\n  width: 60vw;\n  min-width: 350px;\n  overflow-y: scroll;\n}\n.pasteText {\n  font-size: 18px !important;\n  color: #1976d2;\n  cursor: pointer;\n  margin-inline: 10px;\n}\n.pasteText:hover {\n  color: #1976d2b3;\n}\n.copyToCommandLine {\n  font-size: 16px !important;\n  color: #1976d2;\n  cursor: pointer;\n}\n.copyToCommandLine:hover {\n  color: #1976d2b3;\n}\n.css-1be5mm1-MuiLinearProgress-root-MuiMobileStepper-progress {\n  width: 100% !important;\n}\n.css-r5rjnf-MuiLinearProgress-root-MuiMobileStepper-progress {\n  width: 100% !important;\n}\n.pathBox {\n  width: 160px;\n  cursor: pointer;\n  overflow: hidden;\n  white-space: nowrap;\n  text-overflow: ellipsis;\n}\n.pathBox2 {\n  width: 300px;\n}\n.empty {\n  position: absolute;\n  left: 50%;\n  top: 30%;\n  font-size: 20px;\n  color: #555;\n  transform: translate(-50%, 0);\n}\n.deleteDialog {\n  display: flex;\n  align-items: center;\n}\n.warningIcon {\n  margin-right: 10px;\n  color: rgb(237, 108, 2);\n}\n.textHighlight .MuiSelect-select {\n  color: #1976d2;\n}\n.textHighlight .MuiInputBase-input {\n  color: #1976d2;\n}\n",".formBox {\n  position: relative;\n  max-width: 50vw;\n  min-width: 50vw;\n  max-height: 80vh;\n  overflow: auto;\n  padding: 40px 20px 0 0;\n  transition: all 0.4s ease-in-out;\n}\n\n.broaden {\n  max-width: 100%;\n  min-width: 100%;\n  padding-right: 0;\n}\n\n.show-json {\n  display: flex;\n  align-items: center;\n  position: absolute;\n  top: 90px;\n  right: 60px;\n}\n\n.icon {\n  position: absolute;\n  right: -40px;\n  cursor: pointer;\n  margin-left: 20px;\n}\n\n.icon:hover {\n  color: #1976d2;\n}\n\n.arrow {\n  font-size: 24px !important;\n}\n\n.jsonBox {\n  position: relative;\n  min-height: 80vh;\n  width: 100%;\n  transition: all 0.4s ease-in-out;\n}\n\n.hide {\n  width: 0;\n  transform: translate(30vw, 0);\n  overflow: hidden;\n}\n\n.checkboxWrapper {\n  display: flex;\n  flex-wrap: wrap;\n  align-items: center;\n  width: 100%;\n}\n\n.jsonBox-header {\n  display: flex;\n  justify-content: space-between;\n  align-items: center;\n}\n\n.jsonBox-title {\n  line-height: 40px;\n  font-weight: 700;\n}\n\n.textarea {\n  width: 100%;\n  height: calc(100% - 40px);\n  padding: 5px 10px;\n  border: 1px solid #ddd;\n  border-radius: 5px;\n  resize: none;\n  color: #666;\n  background-color: transparent;\n}\n\n.addBtn {\n  margin-left: 20px !important;\n}\n\n.item {\n  position: relative;\n  border: 1px solid #ddd;\n  margin: 10px 50px 0;\n  padding: 20px;\n  border-radius: 10px;\n  overflow: hidden;\n}\n\n.item:hover .deleteBtn {\n  transform: translateX(-50px);\n}\n\n.deleteBtn {\n  position: absolute;\n  right: 20px;\n  top: calc(50% - 25px);\n  width: 50px;\n  height: 50px;\n  transform: translateX(80px);\n  text-align: center;\n  line-height: 70px;\n  border-radius: 25px;\n  background-color: #1976d2;\n  transition: all 0.3s ease-in-out;\n}\n\n.deleteBtn:hover {\n  cursor: pointer;\n  box-shadow: 0 0 10px #aaa;\n}\n\n.deleteIcon {\n  font-size: 28px !important;\n  color: #fff;\n}\n\n.chat_template_box {\n  display: flex;\n  align-items: start;\n  gap: 10px;\n}\n\n.chat_template_test {\n  width: 30%;\n}\n\n.chat_template_test_mainBox {\n  height: 137px;\n  padding: 10px;\n  border: 1px solid #ccc;\n  border-radius: 4px;\n  overflow: scroll;\n}\n\n.chat_template_test_tip {\n  font-size: 10px;\n  margin: 4px 14px 0;\n  color: rgba(0, 0, 0, 0.6);\n}\n\n.test_res_box {\n  border: 1px solid #ddd;\n  min-height: 55px;\n  padding: 10px;\n  margin-top: 5px;\n  border-radius: 4px;\n}\n\n.css-19qh8xo-MuiInputBase-input-MuiOutlinedInput-input.Mui-disabled {\n  -webkit-text-fill-color: #000 !important;\n}\n"],"names":[],"sourceRoot":""}