



# flake8: noqa
# Lint as: python3

from typing import Dict, List, Optional, Type

from .. import config
from ..utils import logging
from .formatting import (
    ArrowFormatter,
    CustomFormatter,
    Formatter,
    PandasFormatter,
    PythonFormatter,
    TensorFormatter,
    format_table,
    query_table,
)
from .np_formatter import NumpyFormatter


a      :  Any			     =			logging.get_logger(__name__)

a      :  Dict[Optional[str], Type[Formatter]]			     =			{}
a      :  Dict[Optional[str], str]			     =			{}
a      :  Dict[Optional[str], Exception]			     =			{}







def  lowerCAmelCase_	(lowerCAmelCase__:		type		,						lowerCAmelCase__:		Optional[str]		,						lowerCAmelCase__:		Optional[List[str]] = None		,						):





			"""simple docstring"""


			UpperCAmelCase_:		Any							      =     aliases if aliases is not None else []
			if format_type in _FORMAT_TYPES:
						logger.warning(
						    F'Overwriting format type \'{format_type}\' ({_FORMAT_TYPES[format_type].__name__} -> {formatter_cls.__name__})'  )
			UpperCAmelCase_:		Optional[Any]							      =     formatter_cls
			for alias in set(aliases + [format_type]  ):
						if alias in _FORMAT_TYPES_ALIASES:
									logger.warning(
									    F'Overwriting format type alias \'{alias}\' ({_FORMAT_TYPES_ALIASES[alias]} -> {format_type})'  )
						UpperCAmelCase_:		List[str]							      =     format_type







def  lowerCAmelCase_	(lowerCAmelCase__:		Exception		,						lowerCAmelCase__:		Optional[str]		,						lowerCAmelCase__:		Optional[List[str]] = None  ):





			"""simple docstring"""


			UpperCAmelCase_:		Optional[int]							      =     aliases if aliases is not None else []
			for alias in set(aliases + [format_type]  ):
						UpperCAmelCase_:		Optional[int]							      =     unavailable_error


# Here we define all the available formatting functions that can be used by `Dataset.set_format`
_register_formatter(PythonFormatter, None, aliases=['python'])
_register_formatter(ArrowFormatter, 'arrow', aliases=['pa', 'pyarrow'])
_register_formatter(NumpyFormatter, 'numpy', aliases=['np'])
_register_formatter(PandasFormatter, 'pandas', aliases=['pd'])
_register_formatter(CustomFormatter, 'custom')

if config.TORCH_AVAILABLE:
	from .torch_formatter import TorchFormatter

	_register_formatter(TorchFormatter, 'torch', aliases=['pt', 'pytorch'])
else:
	a      :  str			     =			ValueError('PyTorch needs to be installed to be able to return PyTorch tensors.')
	_register_unavailable_formatter(_torch_error, 'torch', aliases=['pt', 'pytorch'])

if config.TF_AVAILABLE:
	from .tf_formatter import TFFormatter

	_register_formatter(TFFormatter, 'tensorflow', aliases=['tf'])
else:
	a      :  Optional[int]			     =			ValueError('Tensorflow needs to be installed to be able to return Tensorflow tensors.')
	_register_unavailable_formatter(_tf_error, 'tensorflow', aliases=['tf'])

if config.JAX_AVAILABLE:
	from .jax_formatter import JaxFormatter

	_register_formatter(JaxFormatter, 'jax', aliases=[])
else:
	a      :  Optional[int]			     =			ValueError('JAX needs to be installed to be able to return JAX arrays.')
	_register_unavailable_formatter(_jax_error, 'jax', aliases=[])







def  lowerCAmelCase_	(lowerCAmelCase__:		Optional[str]  ):





			"""simple docstring"""


			if format_type in _FORMAT_TYPES_ALIASES:
						return _FORMAT_TYPES_ALIASES[format_type]
			else:
						return format_type







def  lowerCAmelCase_	(lowerCAmelCase__:		Optional[str]		,						**lowerCAmelCase__:		List[Any]  ):





			"""simple docstring"""


			UpperCAmelCase_:		List[str]							      =     get_format_type_from_alias(lowerCAmelCase__  )
			if format_type in _FORMAT_TYPES:
						return _FORMAT_TYPES[format_type](**lowerCAmelCase__  )
			if format_type in _FORMAT_TYPES_ALIASES_UNAVAILABLE:
						raise _FORMAT_TYPES_ALIASES_UNAVAILABLE[format_type]
			else:
						raise ValueError(
						    F'Return type should be None or selected in {list(type for type in _FORMAT_TYPES.keys() if type != None  )}, but got \'{format_type}\''  )











import numpy as np
import torch
import torch.nn as nn
from transformers import CLIPConfig, CLIPVisionModelWithProjection, PreTrainedModel

from ...utils import logging


a      :  Union[str, Any]			     =			logging.get_logger(__name__)







class 				_a				(   _lowerCAmelCase					):
			A      		=	CLIPConfig

			A      		=	['''CLIPEncoderLayer''']

			def __init__(self,   SCREAMING_SNAKE_CASE_					)       ->   Optional[Any]:
						super().__init__(SCREAMING_SNAKE_CASE_					)

						UpperCAmelCase_:		Tuple							      =     CLIPVisionModelWithProjection(config.vision_config					)

						UpperCAmelCase_:		Tuple							      =     nn.Linear(config.vision_config.projection_dim,   1					)
						UpperCAmelCase_:		Tuple							      =     nn.Linear(config.vision_config.projection_dim,   1					)

			@torch.no_grad()
			def      __snake_case       (self,   SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_=0.5,   SCREAMING_SNAKE_CASE_=0.5					)       ->   Tuple:
						UpperCAmelCase_:		Optional[Any]							      =     self.vision_model(SCREAMING_SNAKE_CASE_					)[0]

						UpperCAmelCase_:		List[str]							      =     self.p_head(SCREAMING_SNAKE_CASE_					)
						UpperCAmelCase_:		Any							      =     nsfw_detected.flatten()
						UpperCAmelCase_:		List[Any]							      =     nsfw_detected > p_threshold
						UpperCAmelCase_:		Any							      =     nsfw_detected.tolist()

						if any(SCREAMING_SNAKE_CASE_					):
									logger.warning(
									    """Potential NSFW content was detected in one or more images. A black image will be returned instead."""
									    """ Try again with a different prompt and/or seed."""					)

						for idx, nsfw_detected_ in enumerate(SCREAMING_SNAKE_CASE_					):
									if nsfw_detected_:
												UpperCAmelCase_:		Tuple							      =     np.zeros(images[idx].shape					)

						UpperCAmelCase_:		str							      =     self.w_head(SCREAMING_SNAKE_CASE_					)
						UpperCAmelCase_:		List[Any]							      =     watermark_detected.flatten()
						UpperCAmelCase_:		Tuple							      =     watermark_detected > w_threshold
						UpperCAmelCase_:		int							      =     watermark_detected.tolist()

						if any(SCREAMING_SNAKE_CASE_					):
									logger.warning(
									    """Potential watermarked content was detected in one or more images. A black image will be returned instead."""
									    """ Try again with a different prompt and/or seed."""					)

						for idx, watermark_detected_ in enumerate(SCREAMING_SNAKE_CASE_					):
									if watermark_detected_:
												UpperCAmelCase_:		Any							      =     np.zeros(images[idx].shape					)

						return images, nsfw_detected, watermark_detected






