

from queue import Queue
from typing import TYPE_CHECKING, Optional


if TYPE_CHECKING:
					from ..models.auto import AutoTokenizer







class 				lowercase       :




				def 					a							(      self   ,     snake_case ):
											raise NotImplementedError()




				def 					a							(      self ):
											raise NotImplementedError()







class 				lowercase       ( lowercase_    ):




				def __init__(      self   ,     snake_case   ,     snake_case = False   ,     **snake_case ):
											snake_case_           =					tokenizer
											snake_case_           =					skip_prompt
											snake_case_           =					decode_kwargs

											# variables used in the streaming process
											snake_case_           =					[]
											snake_case_           =					0
											snake_case_           =					True




				def 					a							(      self   ,     snake_case ):
											if len(value.shape ) > 1 and value.shape[0] > 1:
																		raise ValueError('TextStreamer only supports batch size 1' )
											elif len(value.shape ) > 1:
																		snake_case_           =					value[0]

											if self.skip_prompt and self.next_tokens_are_prompt:
																		snake_case_           =					False
																		return

											# Add the new token to the cache and decodes the entire thing.
											self.token_cache.extend(value.tolist() )
											snake_case_           =					self.tokenizer.decode(self.token_cache   ,     **self.decode_kwargs )

											# After the symbol for a new line, we flush the cache.
											if text.endswith('\n' ):
																		snake_case_           =					text[self.print_len :]
																		snake_case_           =					[]
																		snake_case_           =					0
											# If the last token is a CJK character, we print the characters.
											elif len(snake_case ) > 0 and self._is_chinese_char(ord(text[-1] ) ):
																		snake_case_           =					text[self.print_len :]
																		self.print_len += len(snake_case )
											# Otherwise, prints until the last space char (simple heuristic to avoid printing incomplete words,
											# which may change with the subsequent token -- there are probably smarter ways to do this!)
											else:
																		snake_case_           =					text[self.print_len : text.rfind(' ' ) + 1]
																		self.print_len += len(snake_case )

											self.on_finalized_text(snake_case )




				def 					a							(      self ):
											# Flush the cache, if it exists
											if len(self.token_cache ) > 0:
																		snake_case_           =					self.tokenizer.decode(self.token_cache   ,     **self.decode_kwargs )
																		snake_case_           =					text[self.print_len :]
																		snake_case_           =					[]
																		snake_case_           =					0
											else:
																		snake_case_           =					''

											snake_case_           =					True
											self.on_finalized_text(snake_case   ,     stream_end=snake_case )




				def 					a							(      self   ,     snake_case   ,     snake_case = False ):
											print(snake_case   ,     flush=snake_case   ,     end='' if not stream_end else None )




				def 					a							(      self   ,     snake_case ):
											# This defines a "chinese character" as anything in the CJK Unicode block:
											#   https://en.wikipedia.org/wiki/CJK_Unified_Ideographs_(Unicode_block)
											#
											# Note that the CJK Unicode block is NOT all Japanese and Korean characters,
											# despite its name. The modern Korean Hangul alphabet is a different block,
											# as is Japanese Hiragana and Katakana. Those alphabets are used to write
											# space-separated words, so they are not treated specially and handled
											# like the all of the other languages.
											if (
											    (cp >= 0x4E00 and cp <= 0x9FFF)
											    or (cp >= 0x3400 and cp <= 0x4DBF)  #
											    or (cp >= 0x20000 and cp <= 0x2A6DF)  #
											    or (cp >= 0x2A700 and cp <= 0x2B73F)  #
											    or (cp >= 0x2B740 and cp <= 0x2B81F)  #
											    or (cp >= 0x2B820 and cp <= 0x2CEAF)  #
											    or (cp >= 0xF900 and cp <= 0xFAFF)
											    or (cp >= 0x2F800 and cp <= 0x2FA1F)  #
											):  #
																		return True

											return False







class 				lowercase       ( lowercase_    ):




				def __init__(      self   ,     snake_case   ,     snake_case = False   ,     snake_case = None   ,     **snake_case ):
											super().__init__(snake_case   ,     snake_case   ,     **snake_case )
											snake_case_           =					Queue()
											snake_case_           =					None
											snake_case_           =					timeout




				def 					a							(      self   ,     snake_case   ,     snake_case = False ):
											self.text_queue.put(snake_case   ,     timeout=self.timeout )
											if stream_end:
																		self.text_queue.put(self.stop_signal   ,     timeout=self.timeout )




				def __iter__(      self ):
											return self




				def 					a							(      self ):
											snake_case_           =					self.text_queue.get(timeout=self.timeout )
											if value == self.stop_signal:
																		raise StopIteration()
											else:
																		return value







from dataclasses import dataclass
from typing import List, Optional, Union

import numpy as np
import PIL

from ...utils import BaseOutput, OptionalDependencyNotAvailable, is_torch_available, is_transformers_available
from .timesteps import (
    fastaa_timesteps,
    smartaa_timesteps,
    smartaa_timesteps,
    smartaaa_timesteps,
    smartaaa_timesteps,
    superaa_timesteps,
    superaa_timesteps,
    superaaa_timesteps,
)







@dataclass
class 				lowercase       ( lowercase_    ):
				__SCREAMING_SNAKE_CASE      :				Union[List[PIL.Image.Image], np.ndarray]
				__SCREAMING_SNAKE_CASE      :				Optional[List[bool]]
				__SCREAMING_SNAKE_CASE      :				Optional[List[bool]]


try:
					if not (is_transformers_available() and is_torch_available()):
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					from ...utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
					from .pipeline_if import IFPipeline
					from .pipeline_if_imgaimg import IFImgaImgPipeline
					from .pipeline_if_imgaimg_superresolution import IFImgaImgSuperResolutionPipeline
					from .pipeline_if_inpainting import IFInpaintingPipeline
					from .pipeline_if_inpainting_superresolution import IFInpaintingSuperResolutionPipeline
					from .pipeline_if_superresolution import IFSuperResolutionPipeline
					from .safety_checker import IFSafetyChecker
					from .watermark import IFWatermarker




