


"""simple docstring"""






from math import factorial, pi






def 					snake_case__       (		__lowerCamelCase    :   int							,		__lowerCamelCase    :   int = 30     ):
			"""simple docstring"""

			if not isinstance(_A							,		(int, float)     ):
						raise ValueError('''maclaurin_sin() requires either an int or float for theta'''     )

			if not isinstance(_A							,		_A     ) or accuracy <= 0:
						raise ValueError('''maclaurin_sin() requires a positive int for accuracy'''     )

			lowerCamelCase__		:		Dict		     =float(_A     )
			lowerCamelCase__		:		List[Any]		     =theta // (2 * pi)
			theta -= 2 * div * pi
			return sum(
			    (-1) ** r * theta ** (2 * r + 1) / factorial(2 * r + 1     ) for r in range(_A     )     )






def 					snake_case__       (		__lowerCamelCase    :   Optional[int]							,		__lowerCamelCase    :   str = 30     ):
			"""simple docstring"""

			if not isinstance(_A							,		(int, float)     ):
						raise ValueError('''maclaurin_cos() requires either an int or float for theta'''     )

			if not isinstance(_A							,		_A     ) or accuracy <= 0:
						raise ValueError('''maclaurin_cos() requires a positive int for accuracy'''     )

			lowerCamelCase__		:		int		     =float(_A     )
			lowerCamelCase__		:		str		     =theta // (2 * pi)
			theta -= 2 * div * pi
			return sum((-1) ** r * theta ** (2 * r) / factorial(2 * r     ) for r in range(_A     )     )


if __name__ == "__main__":
		import doctest

		doctest.testmod()

		print(maclaurin_sin(1_0))
		print(maclaurin_sin(-1_0))
		print(maclaurin_sin(1_0, 1_5))
		print(maclaurin_sin(-1_0, 1_5))

		print(maclaurin_cos(5))
		print(maclaurin_cos(-5))
		print(maclaurin_cos(1_0, 1_5))
		print(maclaurin_cos(-1_0, 1_5))









"""simple docstring"""






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

from ...utils import logging


_lowercase			:			int										=						logging.get_logger(__name__)

class 	__SCREAMING_SNAKE_CASE     (				lowerCAmelCase_       ):


					'''simple docstring'''





					_a             =							CLIPConfig

					_a             =							['CLIPEncoderLayer']



					def __init__(	self							:  int,  lowerCamelCase							:  CLIPConfig					)-> List[Any]:
								super().__init__(lowerCamelCase					)

								lowerCamelCase__		:		Dict		     =CLIPVisionModelWithProjection(config.vision_config					)

								lowerCamelCase__		:		Dict		     =nn.Linear(config.vision_config.projection_dim,  1					)
								lowerCamelCase__		:		Union[str, Any]		     =nn.Linear(config.vision_config.projection_dim,  1					)




					@torch.no_grad()
					def 		snake_case	(	self							:  Dict,  lowerCamelCase							:  Optional[Any],  lowerCamelCase							:  List[str],  lowerCamelCase							:  List[Any]=0.5,  lowerCamelCase							:  Optional[Any]=0.5					)-> Optional[int]:
								lowerCamelCase__		:		Dict		     =self.vision_model(lowerCamelCase					)[0]

								lowerCamelCase__		:		List[Any]		     =self.p_head(lowerCamelCase					)
								lowerCamelCase__		:		Optional[Any]		     =nsfw_detected.flatten()
								lowerCamelCase__		:		Any		     =nsfw_detected > p_threshold
								lowerCamelCase__		:		Optional[Any]		     =nsfw_detected.tolist()

								if any(lowerCamelCase					):
											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(lowerCamelCase					):
											if nsfw_detected_:
														lowerCamelCase__		:		Tuple		     =np.zeros(images[idx].shape					)

								lowerCamelCase__		:		str		     =self.w_head(lowerCamelCase					)
								lowerCamelCase__		:		List[str]		     =watermark_detected.flatten()
								lowerCamelCase__		:		Optional[Any]		     =watermark_detected > w_threshold
								lowerCamelCase__		:		int		     =watermark_detected.tolist()

								if any(lowerCamelCase					):
											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(lowerCamelCase					):
											if watermark_detected_:
														lowerCamelCase__		:		Optional[int]		     =np.zeros(images[idx].shape					)

								return images, nsfw_detected, watermark_detected




