



import random
import unittest

import numpy as np

from diffusers import (
    DPMSolverMultistepScheduler,
    EulerAncestralDiscreteScheduler,
    EulerDiscreteScheduler,
    LMSDiscreteScheduler,
    OnnxStableDiffusionImgaImgPipeline,
    PNDMScheduler,
)
from diffusers.utils import floats_tensor
from diffusers.utils.testing_utils import (
    is_onnx_available,
    load_image,
    nightly,
    require_onnxruntime,
    require_torch_gpu,
)

from ..test_pipelines_onnx_common import OnnxPipelineTesterMixin


if is_onnx_available():
  import onnxruntime as ort



class  __lowerCAmelCase     (	_lowercase  ,	unittest.TestCase   ):
 lowerCAmelCase__       					=  '''hf-internal-testing/tiny-random-OnnxStableDiffusionPipeline'''




 def        lowerCamelCase      (						self	,				__UpperCAmelCase=0				):



    '''simple docstring'''
    __lowerCamelCase													=     floats_tensor((1, 3, 128, 128)	,				rng=random.Random(A_				)				)
    __lowerCamelCase													=     np.random.RandomState(A_				)
    __lowerCamelCase													=     {
        '''prompt''': '''A painting of a squirrel eating a burger''',
        '''image''': image,
        '''generator''': generator,
        '''num_inference_steps''': 3,
        '''strength''': 0.75,
        '''guidance_scale''': 7.5,
        '''output_type''': '''numpy''',
    }
    return inputs




 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    __lowerCamelCase													=     OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint	,				provider='''CPUExecutionProvider'''				)
    pipe.set_progress_bar_config(disable=A_				)

    __lowerCamelCase													=     self.get_dummy_inputs()
    __lowerCamelCase													=     pipe(**A_				).images
    __lowerCamelCase													=     image[0, -3:, -3:, -1].flatten()

    assert image.shape == (1, 128, 128, 3)
    __lowerCamelCase													=     np.array([0.69_643, 0.58_484, 0.50_314, 0.58_760, 0.55_368, 0.59_643, 0.51_529, 0.41_217, 0.49_087]				)
    assert np.abs(image_slice - expected_slice				).max() < 1E-1




 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    __lowerCamelCase													=     OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint	,				provider='''CPUExecutionProvider'''				)
    __lowerCamelCase													=     PNDMScheduler.from_config(pipe.scheduler.config	,				skip_prk_steps=A_				)
    pipe.set_progress_bar_config(disable=A_				)

    __lowerCamelCase													=     self.get_dummy_inputs()
    __lowerCamelCase													=     pipe(**A_				).images
    __lowerCamelCase													=     image[0, -3:, -3:, -1]

    assert image.shape == (1, 128, 128, 3)
    __lowerCamelCase													=     np.array([0.61_737, 0.54_642, 0.53_183, 0.54_465, 0.52_742, 0.60_525, 0.49_969, 0.40_655, 0.48_154]				)

    assert np.abs(image_slice.flatten() - expected_slice				).max() < 1E-1




 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    __lowerCamelCase													=     OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint	,				provider='''CPUExecutionProvider'''				)
    __lowerCamelCase													=     LMSDiscreteScheduler.from_config(pipe.scheduler.config				)
    pipe.set_progress_bar_config(disable=A_				)

    # warmup pass to apply optimizations
    __lowerCamelCase													=     pipe(**self.get_dummy_inputs()				)

    __lowerCamelCase													=     self.get_dummy_inputs()
    __lowerCamelCase													=     pipe(**A_				).images
    __lowerCamelCase													=     image[0, -3:, -3:, -1]

    assert image.shape == (1, 128, 128, 3)
    __lowerCamelCase													=     np.array([0.52_761, 0.59_977, 0.49_033, 0.49_619, 0.54_282, 0.50_311, 0.47_600, 0.40_918, 0.45_203]				)

    assert np.abs(image_slice.flatten() - expected_slice				).max() < 1E-1




 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    __lowerCamelCase													=     OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint	,				provider='''CPUExecutionProvider'''				)
    __lowerCamelCase													=     EulerDiscreteScheduler.from_config(pipe.scheduler.config				)
    pipe.set_progress_bar_config(disable=A_				)

    __lowerCamelCase													=     self.get_dummy_inputs()
    __lowerCamelCase													=     pipe(**A_				).images
    __lowerCamelCase													=     image[0, -3:, -3:, -1]

    assert image.shape == (1, 128, 128, 3)
    __lowerCamelCase													=     np.array([0.52_911, 0.60_004, 0.49_229, 0.49_805, 0.54_502, 0.50_680, 0.47_777, 0.41_028, 0.45_304]				)

    assert np.abs(image_slice.flatten() - expected_slice				).max() < 1E-1




 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    __lowerCamelCase													=     OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint	,				provider='''CPUExecutionProvider'''				)
    __lowerCamelCase													=     EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config				)
    pipe.set_progress_bar_config(disable=A_				)

    __lowerCamelCase													=     self.get_dummy_inputs()
    __lowerCamelCase													=     pipe(**A_				).images
    __lowerCamelCase													=     image[0, -3:, -3:, -1]

    assert image.shape == (1, 128, 128, 3)
    __lowerCamelCase													=     np.array([0.52_911, 0.60_004, 0.49_229, 0.49_805, 0.54_502, 0.50_680, 0.47_777, 0.41_028, 0.45_304]				)

    assert np.abs(image_slice.flatten() - expected_slice				).max() < 1E-1




 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    __lowerCamelCase													=     OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint	,				provider='''CPUExecutionProvider'''				)
    __lowerCamelCase													=     DPMSolverMultistepScheduler.from_config(pipe.scheduler.config				)
    pipe.set_progress_bar_config(disable=A_				)

    __lowerCamelCase													=     self.get_dummy_inputs()
    __lowerCamelCase													=     pipe(**A_				).images
    __lowerCamelCase													=     image[0, -3:, -3:, -1]

    assert image.shape == (1, 128, 128, 3)
    __lowerCamelCase													=     np.array([0.65_331, 0.58_277, 0.48_204, 0.56_059, 0.53_665, 0.56_235, 0.50_969, 0.40_009, 0.46_552]				)

    assert np.abs(image_slice.flatten() - expected_slice				).max() < 1E-1



@nightly
@require_onnxruntime
@require_torch_gpu
class  __lowerCAmelCase     (	unittest.TestCase   ):




 @property
 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    return (
        "CUDAExecutionProvider",
        {
            "gpu_mem_limit": "15000000000",  # 15GB
            "arena_extend_strategy": "kSameAsRequested",
        },
    )




 @property
 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    __lowerCamelCase													=     ort.SessionOptions()
    __lowerCamelCase													=     False
    return options




 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    __lowerCamelCase													=     load_image(
        '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
        '''/img2img/sketch-mountains-input.jpg'''				)
    __lowerCamelCase													=     init_image.resize((768, 512)				)
    # using the PNDM scheduler by default
    __lowerCamelCase													=     OnnxStableDiffusionImgaImgPipeline.from_pretrained(
        '''CompVis/stable-diffusion-v1-4'''	,				revision='''onnx'''	,				safety_checker=A_	,				feature_extractor=A_	,				provider=self.gpu_provider	,				sess_options=self.gpu_options	,				)
    pipe.set_progress_bar_config(disable=A_				)

    __lowerCamelCase													=     '''A fantasy landscape, trending on artstation'''

    __lowerCamelCase													=     np.random.RandomState(0				)
    __lowerCamelCase													=     pipe(
        prompt=A_	,				image=A_	,				strength=0.75	,				guidance_scale=7.5	,				num_inference_steps=10	,				generator=A_	,				output_type='''np'''	,				)
    __lowerCamelCase													=     output.images
    __lowerCamelCase													=     images[0, 255:258, 383:386, -1]

    assert images.shape == (1, 512, 768, 3)
    __lowerCamelCase													=     np.array([0.4_909, 0.5_059, 0.5_372, 0.4_623, 0.4_876, 0.5_049, 0.4_820, 0.4_956, 0.5_019]				)
    # TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues

    assert np.abs(image_slice.flatten() - expected_slice				).max() < 2E-2




 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    __lowerCamelCase													=     load_image(
        '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
        '''/img2img/sketch-mountains-input.jpg'''				)
    __lowerCamelCase													=     init_image.resize((768, 512)				)
    __lowerCamelCase													=     LMSDiscreteScheduler.from_pretrained(
        '''runwayml/stable-diffusion-v1-5'''	,				subfolder='''scheduler'''	,				revision='''onnx'''				)
    __lowerCamelCase													=     OnnxStableDiffusionImgaImgPipeline.from_pretrained(
        '''runwayml/stable-diffusion-v1-5'''	,				revision='''onnx'''	,				scheduler=A_	,				safety_checker=A_	,				feature_extractor=A_	,				provider=self.gpu_provider	,				sess_options=self.gpu_options	,				)
    pipe.set_progress_bar_config(disable=A_				)

    __lowerCamelCase													=     '''A fantasy landscape, trending on artstation'''

    __lowerCamelCase													=     np.random.RandomState(0				)
    __lowerCamelCase													=     pipe(
        prompt=A_	,				image=A_	,				strength=0.75	,				guidance_scale=7.5	,				num_inference_steps=20	,				generator=A_	,				output_type='''np'''	,				)
    __lowerCamelCase													=     output.images
    __lowerCamelCase													=     images[0, 255:258, 383:386, -1]

    assert images.shape == (1, 512, 768, 3)
    __lowerCamelCase													=     np.array([0.8_043, 0.926, 0.9_581, 0.8_119, 0.8_954, 0.913, 0.7_209, 0.7_463, 0.7_431]				)
    # TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues

    assert np.abs(image_slice.flatten() - expected_slice				).max() < 2E-2











import os
import unicodedata
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


a_			=					logging.get_logger(__name__)
a_			=					{"""vocab_file""": """spiece.model"""}

a_			=					{
    """vocab_file""": {
        """albert-base-v1""": """https://huggingface.co/albert-base-v1/resolve/main/spiece.model""",
        """albert-large-v1""": """https://huggingface.co/albert-large-v1/resolve/main/spiece.model""",
        """albert-xlarge-v1""": """https://huggingface.co/albert-xlarge-v1/resolve/main/spiece.model""",
        """albert-xxlarge-v1""": """https://huggingface.co/albert-xxlarge-v1/resolve/main/spiece.model""",
        """albert-base-v2""": """https://huggingface.co/albert-base-v2/resolve/main/spiece.model""",
        """albert-large-v2""": """https://huggingface.co/albert-large-v2/resolve/main/spiece.model""",
        """albert-xlarge-v2""": """https://huggingface.co/albert-xlarge-v2/resolve/main/spiece.model""",
        """albert-xxlarge-v2""": """https://huggingface.co/albert-xxlarge-v2/resolve/main/spiece.model""",
    }
}

a_			=					{
    """albert-base-v1""": 512,
    """albert-large-v1""": 512,
    """albert-xlarge-v1""": 512,
    """albert-xxlarge-v1""": 512,
    """albert-base-v2""": 512,
    """albert-large-v2""": 512,
    """albert-xlarge-v2""": 512,
    """albert-xxlarge-v2""": 512,
}

a_			=					"""▁"""



class  __lowerCAmelCase     (	lowerCAmelCase__   ):
 lowerCAmelCase__       					=  VOCAB_FILES_NAMES
 lowerCAmelCase__       					=  PRETRAINED_VOCAB_FILES_MAP
 lowerCAmelCase__       					=  PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES




 def __init__(						self	,				__UpperCAmelCase	,				__UpperCAmelCase=True	,				__UpperCAmelCase=True	,				__UpperCAmelCase=False	,				__UpperCAmelCase="[CLS]"	,				__UpperCAmelCase="[SEP]"	,				__UpperCAmelCase="<unk>"	,				__UpperCAmelCase="[SEP]"	,				__UpperCAmelCase="<pad>"	,				__UpperCAmelCase="[CLS]"	,				__UpperCAmelCase="[MASK]"	,				__UpperCAmelCase = None	,				**__UpperCAmelCase	,				):



    '''simple docstring'''
    # Mask token behave like a normal word, i.e. include the space before it and
    # is included in the raw text, there should be a match in a non-normalized sentence.
    __lowerCamelCase													=    (
        AddedToken(__UpperCAmelCase	,				lstrip=__UpperCAmelCase	,				rstrip=__UpperCAmelCase	,				normalized=__UpperCAmelCase				)
        if isinstance(__UpperCAmelCase	,				__UpperCAmelCase				)
        else mask_token
    )

    __lowerCamelCase													=    {} if sp_model_kwargs is None else sp_model_kwargs

    super().__init__(
        do_lower_case=__UpperCAmelCase	,				remove_space=__UpperCAmelCase	,				keep_accents=__UpperCAmelCase	,				bos_token=__UpperCAmelCase	,				eos_token=__UpperCAmelCase	,				unk_token=__UpperCAmelCase	,				sep_token=__UpperCAmelCase	,				pad_token=__UpperCAmelCase	,				cls_token=__UpperCAmelCase	,				mask_token=__UpperCAmelCase	,				sp_model_kwargs=self.sp_model_kwargs	,				**__UpperCAmelCase	,				)

    __lowerCamelCase													=    do_lower_case
    __lowerCamelCase													=    remove_space
    __lowerCamelCase													=    keep_accents
    __lowerCamelCase													=    vocab_file

    __lowerCamelCase													=    spm.SentencePieceProcessor(**self.sp_model_kwargs				)
    self.sp_model.Load(__UpperCAmelCase				)




 @property
 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    return len(self.sp_model				)




 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    __lowerCamelCase													=    {self.convert_ids_to_tokens(__UpperCAmelCase				): i for i in range(self.vocab_size				)}
    vocab.update(self.added_tokens_encoder				)
    return vocab




 def __getstate__(						self				):



    '''simple docstring'''
    __lowerCamelCase													=    self.__dict__.copy()
    __lowerCamelCase													=    None
    return state




 def __setstate__(						self	,				__UpperCAmelCase				):



    '''simple docstring'''
    __lowerCamelCase													=    d

    # for backward compatibility
    if not hasattr(self	,				'''sp_model_kwargs'''				):
       __lowerCamelCase													=    {}

    __lowerCamelCase													=    spm.SentencePieceProcessor(**self.sp_model_kwargs				)
    self.sp_model.Load(self.vocab_file				)




 def        lowerCamelCase      (						self	,				__UpperCAmelCase				):



    '''simple docstring'''
    if self.remove_space:
       __lowerCamelCase													=    ''' '''.join(inputs.strip().split()				)
    else:
       __lowerCamelCase													=    inputs
    __lowerCamelCase													=    outputs.replace('''``'''	,				'''"'''				).replace('''\'\''''	,				'''"'''				)

    if not self.keep_accents:
       __lowerCamelCase													=    unicodedata.normalize('''NFKD'''	,				__UpperCAmelCase				)
       __lowerCamelCase													=    ''''''.join([c for c in outputs if not unicodedata.combining(__UpperCAmelCase				)]				)
    if self.do_lower_case:
       __lowerCamelCase													=    outputs.lower()

    return outputs




 def        lowerCamelCase      (						self	,				__UpperCAmelCase				):



    '''simple docstring'''
    __lowerCamelCase													=    self.preprocess_text(__UpperCAmelCase				)
    __lowerCamelCase													=    self.sp_model.encode(__UpperCAmelCase	,				out_type=__UpperCAmelCase				)
    __lowerCamelCase													=    []
    for piece in pieces:
       if len(__UpperCAmelCase				) > 1 and piece[-1] == str(''','''				) and piece[-2].isdigit():
          __lowerCamelCase													=    self.sp_model.EncodeAsPieces(piece[:-1].replace(__UpperCAmelCase	,				''''''				)				)
          if piece[0] != SPIECE_UNDERLINE and cur_pieces[0][0] == SPIECE_UNDERLINE:
             if len(cur_pieces[0]				) == 1:
                __lowerCamelCase													=    cur_pieces[1:]
             else:
                __lowerCamelCase													=    cur_pieces[0][1:]
          cur_pieces.append(piece[-1]				)
          new_pieces.extend(__UpperCAmelCase				)
       else:
          new_pieces.append(__UpperCAmelCase				)

    return new_pieces




 def        lowerCamelCase      (						self	,				__UpperCAmelCase				):



    '''simple docstring'''
    return self.sp_model.PieceToId(__UpperCAmelCase				)




 def        lowerCamelCase      (						self	,				__UpperCAmelCase				):



    '''simple docstring'''
    return self.sp_model.IdToPiece(__UpperCAmelCase				)




 def        lowerCamelCase      (						self	,				__UpperCAmelCase				):



    '''simple docstring'''
    __lowerCamelCase													=    []
    __lowerCamelCase													=    ''''''
    __lowerCamelCase													=    False
    for token in tokens:
       # make sure that special tokens are not decoded using sentencepiece model
       if token in self.all_special_tokens:
          if not prev_is_special:
             out_string += " "
          out_string += self.sp_model.decode(__UpperCAmelCase				) + token
          __lowerCamelCase													=    True
          __lowerCamelCase													=    []
       else:
          current_sub_tokens.append(__UpperCAmelCase				)
          __lowerCamelCase													=    False
    out_string += self.sp_model.decode(__UpperCAmelCase				)
    return out_string.strip()




 def        lowerCamelCase      (						self	,				__UpperCAmelCase	,				__UpperCAmelCase = None				):



    '''simple docstring'''
    __lowerCamelCase													=    [self.sep_token_id]
    __lowerCamelCase													=    [self.cls_token_id]
    if token_ids_a is None:
       return cls + token_ids_a + sep
    return cls + token_ids_a + sep + token_ids_a + sep




 def        lowerCamelCase      (						self	,				__UpperCAmelCase	,				__UpperCAmelCase = None	,				__UpperCAmelCase = False				):



    '''simple docstring'''

    if already_has_special_tokens:
       return super().get_special_tokens_mask(
           token_ids_a=__UpperCAmelCase	,				token_ids_a=__UpperCAmelCase	,				already_has_special_tokens=__UpperCAmelCase				)

    if token_ids_a is not None:
       return [1] + ([0] * len(__UpperCAmelCase				)) + [1] + ([0] * len(__UpperCAmelCase				)) + [1]
    return [1] + ([0] * len(__UpperCAmelCase				)) + [1]




 def        lowerCamelCase      (						self	,				__UpperCAmelCase	,				__UpperCAmelCase = None				):



    '''simple docstring'''
    __lowerCamelCase													=    [self.sep_token_id]
    __lowerCamelCase													=    [self.cls_token_id]

    if token_ids_a is None:
       return len(cls + token_ids_a + sep				) * [0]
    return len(cls + token_ids_a + sep				) * [0] + len(token_ids_a + sep				) * [1]




 def        lowerCamelCase      (						self	,				__UpperCAmelCase	,				__UpperCAmelCase = None				):



    '''simple docstring'''
    if not os.path.isdir(__UpperCAmelCase				):
       logger.error(F"""Vocabulary path ({save_directory}) should be a directory"""				)
       return
    __lowerCamelCase													=    os.path.join(
        __UpperCAmelCase	,				(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file''']				)

    if os.path.abspath(self.vocab_file				) != os.path.abspath(__UpperCAmelCase				) and os.path.isfile(self.vocab_file				):
       copyfile(self.vocab_file	,				__UpperCAmelCase				)
    elif not os.path.isfile(self.vocab_file				):
       with open(__UpperCAmelCase	,				'''wb'''				) as fi:
          __lowerCamelCase													=    self.sp_model.serialized_model_proto()
          fi.write(__UpperCAmelCase				)

    return (out_vocab_file,)






