





"""simple docstring"""




import os
import pickle
import unittest

from transformers import AutoTokenizer
from transformers.models.bert.tokenization_bert import BertTokenizer
from transformers.models.bert_japanese.tokenization_bert_japanese import (
    VOCAB_FILES_NAMES,
    BertJapaneseTokenizer,
    CharacterTokenizer,
    JumanppTokenizer,
    MecabTokenizer,
    SudachiTokenizer,
    WordpieceTokenizer,
)
from transformers.testing_utils import custom_tokenizers, require_jumanpp, require_sudachi

from ...test_tokenization_common import TokenizerTesterMixin

@custom_tokenizers
class  _UpperCAmelCase  (   UpperCAmelCase__			,   unittest.TestCase		):



      '''simple docstring'''
      lowercase_      : List[str]	    =   BertJapaneseTokenizer
      lowercase_      : Optional[Any]	    =   False
      lowercase_      : Tuple	    =   True

      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        super().setUp()

        A_  :       Optional[Any]										=  [
            '[UNK]',
            '[CLS]',
            '[SEP]',
            'こんにちは',
            'こん',
            'にちは',
            'ばんは',
            '##こん',
            '##にちは',
            '##ばんは',
            '世界',
            '##世界',
            '、',
            '##、',
            '。',
            '##。',
        ]

        A_  :       Optional[Any]										=  os.path.join(self.tmpdirname					,      VOCAB_FILES_NAMES['vocab_file']  )
        with open(self.vocab_file					,      'w'					,      encoding='utf-8'  ) as vocab_writer:
          vocab_writer.write(''.join([x + '\n' for x in vocab_tokens]  )  )

      def 					lowerCamelCase_			(     self					,      snake_case_  ):

        """simple docstring"""

        A_  :       List[Any]										=  'こんにちは、世界。 \nこんばんは、世界。'
        A_  :       List[str]										=  'こんにちは 、 世界 。 こんばんは 、 世界 。'
        return input_text, output_text

      def 					lowerCamelCase_			(     self					,      snake_case_  ):

        """simple docstring"""

        A_						,       A_  :       Dict										=  self.get_input_output_texts(snake_case_  )
        A_  :       Dict										=  tokenizer.encode(snake_case_					,      add_special_tokens=snake_case_  )
        A_  :       List[str]										=  tokenizer.decode(snake_case_					,      clean_up_tokenization_spaces=snake_case_  )
        return text, ids

      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        pass  # TODO add if relevant

      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        pass  # TODO add if relevant

      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        pass  # TODO add if relevant

      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        A_  :       str										=  self.tokenizer_class(self.vocab_file  )

        A_  :       int										=  tokenizer.tokenize('こんにちは、世界。\nこんばんは、世界。'  )
        self.assertListEqual(snake_case_					,      ['こんにちは', '、', '世界', '。', 'こん', '##ばんは', '、', '世界', '。']  )
        self.assertListEqual(tokenizer.convert_tokens_to_ids(snake_case_  )					,      [3, 1_2, 1_0, 1_4, 4, 9, 1_2, 1_0, 1_4]  )

      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        A_  :       int										=  self.tokenizer_class(self.vocab_file					,      word_tokenizer_type='mecab'  )
        self.assertIsNotNone(snake_case_  )

        A_  :       List[str]										=  'こんにちは、世界。\nこんばんは、世界。'
        A_  :       str										=  tokenizer.tokenize(snake_case_  )
        self.assertListEqual(snake_case_					,      ['こんにちは', '、', '世界', '。', 'こん', '##ばんは', '、', '世界', '。']  )
        self.assertListEqual(tokenizer.convert_tokens_to_ids(snake_case_  )					,      [3, 1_2, 1_0, 1_4, 4, 9, 1_2, 1_0, 1_4]  )

        A_  :       Optional[Any]										=  os.path.join(self.tmpdirname					,      'tokenizer.bin'  )
        with open(snake_case_					,      'wb'  ) as handle:
          pickle.dump(snake_case_					,      snake_case_  )

        with open(snake_case_					,      'rb'  ) as handle:
          A_  :       Optional[int]										=  pickle.load(snake_case_  )

        A_  :       Optional[Any]										=  tokenizer_new.tokenize(snake_case_  )

        self.assertListEqual(snake_case_					,      snake_case_  )

      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        A_  :       Optional[Any]										=  MecabTokenizer(mecab_dic='ipadic'  )

        self.assertListEqual(
            tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '  )					,      ['アップルストア', 'で', 'iPhone', '8', 'が', '発売', 'さ', 'れ', 'た', '。']					,      )

      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        try:
          A_  :       Dict										=  MecabTokenizer(mecab_dic='unidic_lite'  )
        except ModuleNotFoundError:
          return

        self.assertListEqual(
            tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '  )					,      ['アップル', 'ストア', 'で', 'iPhone', '8', 'が', '発売', 'さ', 'れ', 'た', '。']					,      )

      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        try:
          A_  :       Optional[Any]										=  MecabTokenizer(mecab_dic='unidic'  )
        except ModuleNotFoundError:
          return

        self.assertListEqual(
            tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '  )					,      ['アップル', 'ストア', 'で', 'iPhone', '8', 'が', '発売', 'さ', 'れ', 'た', '。']					,      )

      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        A_  :       Optional[Any]										=  MecabTokenizer(do_lower_case=snake_case_					,      mecab_dic='ipadic'  )

        self.assertListEqual(
            tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '  )					,      ['アップルストア', 'で', 'iphone', '8', 'が', '発売', 'さ', 'れ', 'た', '。']					,      )

      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        try:
          A_  :       str										=  MecabTokenizer(
              do_lower_case=snake_case_					,      normalize_text=snake_case_					,      mecab_option='-d /usr/local/lib/mecab/dic/jumandic'  )
        except RuntimeError:
          # if dict doesn't exist in the system, previous code raises this error.
          return

        self.assertListEqual(
            tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '  )					,      ['ｱｯﾌﾟﾙストア', 'で', 'iPhone', '８', 'が', '発売', 'さ', 'れた', '\u3000', '。']					,      )

      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        A_  :       str										=  MecabTokenizer(normalize_text=snake_case_					,      mecab_dic='ipadic'  )

        self.assertListEqual(
            tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '  )					,      ['ｱｯﾌﾟﾙストア', 'で', 'iPhone', '８', 'が', '発売', 'さ', 'れ', 'た', '　', '。']					,      )

      @require_sudachi
      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        A_  :       Union[str, Any]										=  self.tokenizer_class(self.vocab_file					,      word_tokenizer_type='sudachi'  )
        self.assertIsNotNone(snake_case_  )

        A_  :       Union[str, Any]										=  'こんにちは、世界。\nこんばんは、世界。'
        A_  :       List[Any]										=  tokenizer.tokenize(snake_case_  )
        self.assertListEqual(snake_case_					,      ['こんにちは', '、', '世界', '。', 'こん', '##ばんは', '、', '世界', '。']  )
        self.assertListEqual(tokenizer.convert_tokens_to_ids(snake_case_  )					,      [3, 1_2, 1_0, 1_4, 4, 9, 1_2, 1_0, 1_4]  )

        A_  :       Any										=  os.path.join(self.tmpdirname					,      'tokenizer.bin'  )
        with open(snake_case_					,      'wb'  ) as handle:
          pickle.dump(snake_case_					,      snake_case_  )

        with open(snake_case_					,      'rb'  ) as handle:
          A_  :       Any										=  pickle.load(snake_case_  )

        A_  :       Dict										=  tokenizer_new.tokenize(snake_case_  )

        self.assertListEqual(snake_case_					,      snake_case_  )

      @require_sudachi
      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        A_  :       Optional[Any]										=  SudachiTokenizer(sudachi_dict_type='core'  )

        self.assertListEqual(
            tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '  )					,      [' ', '\t', 'アップル', 'ストア', 'で', 'iPhone', '8', ' ', 'が', ' ', ' ', '\n ', '発売', 'さ', 'れ', 'た', ' ', '。', ' ', ' ']					,      )

      @require_sudachi
      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        A_  :       List[str]										=  SudachiTokenizer(sudachi_dict_type='core'					,      sudachi_split_mode='A'  )

        self.assertListEqual(tokenizer.tokenize('外国人参政権'  )					,      ['外国', '人', '参政', '権']  )

      @require_sudachi
      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        A_  :       Union[str, Any]										=  SudachiTokenizer(sudachi_dict_type='core'					,      sudachi_split_mode='B'  )

        self.assertListEqual(tokenizer.tokenize('外国人参政権'  )					,      ['外国人', '参政権']  )

      @require_sudachi
      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        A_  :       int										=  SudachiTokenizer(sudachi_dict_type='core'					,      sudachi_split_mode='C'  )

        self.assertListEqual(tokenizer.tokenize('外国人参政権'  )					,      ['外国人参政権']  )

      @require_sudachi
      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        A_  :       List[Any]										=  SudachiTokenizer(do_lower_case=snake_case_					,      sudachi_dict_type='core'  )

        self.assertListEqual(
            tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '  )					,      [' ', '\t', 'アップル', 'ストア', 'で', 'iphone', '8', ' ', 'が', ' ', ' ', '\n ', '発売', 'さ', 'れ', 'た', ' ', '。', ' ', ' ']					,      )

      @require_sudachi
      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        A_  :       Optional[Any]										=  SudachiTokenizer(normalize_text=snake_case_					,      sudachi_dict_type='core'  )

        self.assertListEqual(
            tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '  )					,      [' ', '\t', 'ｱｯﾌﾟﾙ', 'ストア', 'で', 'iPhone', '８', ' ', 'が', ' ', ' ', '\n ', '発売', 'さ', 'れ', 'た', '\u3000', '。', ' ', ' ']					,      )

      @require_sudachi
      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        A_  :       Any										=  SudachiTokenizer(trim_whitespace=snake_case_					,      sudachi_dict_type='core'  )

        self.assertListEqual(
            tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '  )					,      ['アップル', 'ストア', 'で', 'iPhone', '8', 'が', '発売', 'さ', 'れ', 'た', '。']					,      )

      @require_jumanpp
      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        A_  :       List[str]										=  self.tokenizer_class(self.vocab_file					,      word_tokenizer_type='jumanpp'  )
        self.assertIsNotNone(snake_case_  )

        A_  :       Tuple										=  'こんにちは、世界。\nこんばんは、世界。'
        A_  :       int										=  tokenizer.tokenize(snake_case_  )
        self.assertListEqual(snake_case_					,      ['こんにちは', '、', '世界', '。', 'こん', '##ばんは', '、', '世界', '。']  )
        self.assertListEqual(tokenizer.convert_tokens_to_ids(snake_case_  )					,      [3, 1_2, 1_0, 1_4, 4, 9, 1_2, 1_0, 1_4]  )

        A_  :       Optional[Any]										=  os.path.join(self.tmpdirname					,      'tokenizer.bin'  )
        with open(snake_case_					,      'wb'  ) as handle:
          pickle.dump(snake_case_					,      snake_case_  )

        with open(snake_case_					,      'rb'  ) as handle:
          A_  :       Optional[int]										=  pickle.load(snake_case_  )

        A_  :       Optional[Any]										=  tokenizer_new.tokenize(snake_case_  )

        self.assertListEqual(snake_case_					,      snake_case_  )

      @require_jumanpp
      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        A_  :       Union[str, Any]										=  JumanppTokenizer()

        self.assertListEqual(
            tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '  )					,      ['アップル', 'ストア', 'で', 'iPhone', '8', '\u3000', 'が', '\u3000', '\u3000', '\u3000', '発売', 'さ', 'れた', '\u3000', '。']					,      )

      @require_jumanpp
      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        A_  :       Tuple										=  JumanppTokenizer(do_lower_case=snake_case_  )

        self.assertListEqual(
            tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '  )					,      ['アップル', 'ストア', 'で', 'iphone', '8', '\u3000', 'が', '\u3000', '\u3000', '\u3000', '発売', 'さ', 'れた', '\u3000', '。']					,      )

      @require_jumanpp
      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        A_  :       Optional[int]										=  JumanppTokenizer(normalize_text=snake_case_  )

        self.assertListEqual(
            tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '  )					,      ['ｱ', 'ｯ', 'ﾌ', 'ﾟ', 'ﾙ', 'ストア', 'で', 'iPhone', '８', '\u3000', 'が', '\u3000', '\u3000', '\u3000', '発売', 'さ', 'れた', '\u3000', '。']					,      )

      @require_jumanpp
      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        A_  :       Union[str, Any]										=  JumanppTokenizer(trim_whitespace=snake_case_  )

        self.assertListEqual(
            tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '  )					,      ['アップル', 'ストア', 'で', 'iPhone', '8', 'が', '発売', 'さ', 'れた', '。']					,      )

      @require_jumanpp
      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        A_  :       str										=  JumanppTokenizer()

        self.assertListEqual(
            tokenizer.tokenize('ありがとうございますm(_ _)ｍ見つけるのが大変です。'  )					,      ['ありがとう', 'ございます', 'm(_ _)m', '見つける', 'の', 'が', '大変です', '。']					,      )

      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        A_  :       str										=  ['[UNK]', '[CLS]', '[SEP]', 'こんにちは', 'こん', 'にちは', 'ばんは', '##こん', '##にちは', '##ばんは']

        A_  :       Any										=  {}
        for i, token in enumerate(snake_case_  ):
          A_  :       Optional[Any]										=  i
        A_  :       List[Any]										=  WordpieceTokenizer(vocab=snake_case_					,      unk_token='[UNK]'  )

        self.assertListEqual(tokenizer.tokenize(''  )					,      []  )

        self.assertListEqual(tokenizer.tokenize('こんにちは'  )					,      ['こんにちは']  )

        self.assertListEqual(tokenizer.tokenize('こんばんは'  )					,      ['こん', '##ばんは']  )

        self.assertListEqual(tokenizer.tokenize('こんばんは こんばんにちは こんにちは'  )					,      ['こん', '##ばんは', '[UNK]', 'こんにちは']  )

      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        A_  :       str										=  BertJapaneseTokenizer.from_pretrained('nlp-waseda/roberta-base-japanese-with-auto-jumanpp'  )
        A_  :       Optional[Any]										=  tokenizer.subword_tokenizer

        A_  :       Optional[int]										=  subword_tokenizer.tokenize('国境 の 長い トンネル を 抜ける と 雪国 であった 。'  )
        self.assertListEqual(snake_case_					,      ['▁国境', '▁の', '▁長い', '▁トンネル', '▁を', '▁抜ける', '▁と', '▁雪', '国', '▁であった', '▁。']  )

        A_  :       int										=  subword_tokenizer.tokenize('こんばんは こんばん にち は こんにちは'  )
        self.assertListEqual(snake_case_					,      ['▁こん', 'ばん', 'は', '▁こん', 'ばん', '▁に', 'ち', '▁は', '▁こんにちは']  )

      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        A_  :       Optional[Any]										=  self.tokenizer_class.from_pretrained('cl-tohoku/bert-base-japanese'  )

        A_  :       Dict										=  tokenizer.encode('ありがとう。'					,      add_special_tokens=snake_case_  )
        A_  :       Optional[Any]										=  tokenizer.encode('どういたしまして。'					,      add_special_tokens=snake_case_  )

        A_  :       Any										=  tokenizer.build_inputs_with_special_tokens(snake_case_  )
        A_  :       Dict										=  tokenizer.build_inputs_with_special_tokens(snake_case_					,      snake_case_  )

        # 2 is for "[CLS]", 3 is for "[SEP]"
        assert encoded_sentence == [2] + text + [3]
        assert encoded_pair == [2] + text + [3] + text_a + [3]


@custom_tokenizers
class  _UpperCAmelCase  (   UpperCAmelCase__			,   unittest.TestCase		):



      '''simple docstring'''
      lowercase_      : Optional[Any]	    =   BertJapaneseTokenizer
      lowercase_      : List[str]	    =   False

      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        super().setUp()

        A_  :       Dict										=  ['[UNK]', '[CLS]', '[SEP]', 'こ', 'ん', 'に', 'ち', 'は', 'ば', '世', '界', '、', '。']

        A_  :       Union[str, Any]										=  os.path.join(self.tmpdirname					,      VOCAB_FILES_NAMES['vocab_file']  )
        with open(self.vocab_file					,      'w'					,      encoding='utf-8'  ) as vocab_writer:
          vocab_writer.write(''.join([x + '\n' for x in vocab_tokens]  )  )

      def 					lowerCamelCase_			(     self					,      **snake_case_  ):

        """simple docstring"""

        return BertJapaneseTokenizer.from_pretrained(self.tmpdirname					,      subword_tokenizer_type='character'					,      **snake_case_  )

      def 					lowerCamelCase_			(     self					,      snake_case_  ):

        """simple docstring"""

        A_  :       Any										=  'こんにちは、世界。 \nこんばんは、世界。'
        A_  :       List[Any]										=  'こ ん に ち は 、 世 界 。 こ ん ば ん は 、 世 界 。'
        return input_text, output_text

      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        pass  # TODO add if relevant

      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        pass  # TODO add if relevant

      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        pass  # TODO add if relevant

      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        A_  :       List[str]										=  self.tokenizer_class(self.vocab_file					,      subword_tokenizer_type='character'  )

        A_  :       List[str]										=  tokenizer.tokenize('こんにちは、世界。 \nこんばんは、世界。'  )
        self.assertListEqual(
            snake_case_					,      ['こ', 'ん', 'に', 'ち', 'は', '、', '世', '界', '。', 'こ', 'ん', 'ば', 'ん', 'は', '、', '世', '界', '。']  )
        self.assertListEqual(
            tokenizer.convert_tokens_to_ids(snake_case_  )					,      [3, 4, 5, 6, 7, 1_1, 9, 1_0, 1_2, 3, 4, 8, 4, 7, 1_1, 9, 1_0, 1_2]  )

      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        A_  :       List[Any]										=  ['[UNK]', '[CLS]', '[SEP]', 'こ', 'ん', 'に', 'ち', 'は', 'ば', '世', '界', '、', '。']

        A_  :       List[str]										=  {}
        for i, token in enumerate(snake_case_  ):
          A_  :       List[Any]										=  i
        A_  :       Dict										=  CharacterTokenizer(vocab=snake_case_					,      unk_token='[UNK]'  )

        self.assertListEqual(tokenizer.tokenize(''  )					,      []  )

        self.assertListEqual(tokenizer.tokenize('こんにちは'  )					,      ['こ', 'ん', 'に', 'ち', 'は']  )

        self.assertListEqual(tokenizer.tokenize('こんにちほ'  )					,      ['こ', 'ん', 'に', 'ち', '[UNK]']  )

      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        A_  :       str										=  self.tokenizer_class.from_pretrained('cl-tohoku/bert-base-japanese-char'  )

        A_  :       Union[str, Any]										=  tokenizer.encode('ありがとう。'					,      add_special_tokens=snake_case_  )
        A_  :       Tuple										=  tokenizer.encode('どういたしまして。'					,      add_special_tokens=snake_case_  )

        A_  :       Optional[Any]										=  tokenizer.build_inputs_with_special_tokens(snake_case_  )
        A_  :       List[str]										=  tokenizer.build_inputs_with_special_tokens(snake_case_					,      snake_case_  )

        # 2 is for "[CLS]", 3 is for "[SEP]"
        assert encoded_sentence == [2] + text + [3]
        assert encoded_pair == [2] + text + [3] + text_a + [3]


@custom_tokenizers
class  _UpperCAmelCase  (   unittest.TestCase		):



      '''simple docstring'''

      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        A_  :       Any										=  'cl-tohoku/bert-base-japanese'
        A_  :       List[Any]										=  AutoTokenizer.from_pretrained(snake_case_  )
        self.assertIsInstance(snake_case_					,      snake_case_  )


class  _UpperCAmelCase  (   unittest.TestCase		):



      '''simple docstring'''

      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        A_  :       str										=  'cl-tohoku/bert-base-japanese'
        with self.assertLogs('transformers'					,      level='WARNING'  ) as cm:
          BertTokenizer.from_pretrained(snake_case_  )
          self.assertTrue(
              cm.records[0].message.startswith(
                  'The tokenizer class you load from this checkpoint is not the same type as the class this function'
                  ' is called from.'  )  )
        A_  :       List[str]										=  'bert-base-cased'
        with self.assertLogs('transformers'					,      level='WARNING'  ) as cm:
          BertJapaneseTokenizer.from_pretrained(snake_case_  )
          self.assertTrue(
              cm.records[0].message.startswith(
                  'The tokenizer class you load from this checkpoint is not the same type as the class this function'
                  ' is called from.'  )  )






"""simple docstring"""




import torch

from diffusers import DiffusionPipeline

class  _UpperCAmelCase  (   UpperCAmelCase__		):



      '''simple docstring'''

      def __init__(     self					,      snake_case_					,      snake_case_  ):

        """simple docstring"""

        super().__init__()

        self.register_modules(unet=snake_case_					,      scheduler=snake_case_  )

      def __call__(     self  ):

        """simple docstring"""

        A_  :       Optional[Any]										=  torch.randn(
            (1, self.unet.config.in_channels, self.unet.config.sample_size, self.unet.config.sample_size)					,      )
        A_  :       List[str]										=  1

        A_  :       List[str]										=  self.unet(snake_case_					,      snake_case_  ).sample
        A_  :       Optional[int]										=  self.scheduler.step(snake_case_					,      snake_case_					,      snake_case_  ).prev_sample

        A_  :       List[Any]										=  scheduler_output - scheduler_output + torch.ones_like(snake_case_  )

        return result