



'''simple docstring'''






# 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


UpperCamelCase__:  Any				      =     logging.get_logger(__name__)

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


def 					snake_case_	(   _lowerCAmelCase    :		type  , _lowerCAmelCase    :		Optional[str]  , _lowerCAmelCase    :		Optional[List[str]] = None  , ) ->  List[Any]:
							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 					snake_case_	(   _lowerCAmelCase    :		Exception  , _lowerCAmelCase    :		Optional[str]  , _lowerCAmelCase    :		Optional[List[str]] = None    ) ->  Any:
							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:
						UpperCamelCase__:  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:
						UpperCamelCase__:  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:
						UpperCamelCase__:  Optional[int]				      =     ValueError("JAX needs to be installed to be able to return JAX arrays.")
						_register_unavailable_formatter(_jax_error, "jax", aliases=[])


def 					snake_case_	(   _lowerCAmelCase    :		Optional[str]    ) ->  List[Any]:


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




def 					snake_case_	(   _lowerCAmelCase    :		Optional[str]  , **_lowerCAmelCase    :		List[Any]    ) ->  Any:
							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






