



"""simple docstring"""
import unittest
from pathlib import Path
from tempfile import TemporaryDirectory
from unittest.mock import Mock, patch

import diffusers.utils.hub_utils
class 							lowerCamelCase    (     unittest.TestCase							):






					'''simple docstring'''





					@patch("""diffusers.utils.hub_utils.get_full_repo_name"""		)
					def   lowerCAmelCase_							(			self:				int		,	snake_case:				Mock		)  ->      None:
											snake_case_					:Tuple		=     """full_repo_name"""
											with TemporaryDirectory() as tmpdir:
																	# Dummy args values
																	snake_case_					:Union[str, Any]		=     Mock()
																	snake_case_					:List[Any]		=     tmpdir
																	snake_case_					:Union[str, Any]		=     0
																	snake_case_					:List[str]		=     """hub_token"""
																	snake_case_					:int		=     """dataset_name"""
																	snake_case_					:Optional[int]		=     0.0_1
																	snake_case_					:int		=     100_000
																	snake_case_					:Tuple		=     10_000
																	snake_case_					:Optional[int]		=     0.0_1
																	snake_case_					:int		=     0.0_2
																	snake_case_					:Tuple		=     0.0_3
																	snake_case_					:Optional[int]		=     0.0_0_0_5
																	snake_case_					:Tuple		=     0.0_0_0_0_0_1
																	snake_case_					:str		=     1
																	snake_case_					:int		=     10
																	snake_case_					:Optional[int]		=     0.0_0_1
																	snake_case_					:Dict		=     0.1
																	snake_case_					:int		=     0.2
																	snake_case_					:List[Any]		=     True

																	# Model card mush be rendered and saved
																	diffusers.utils.hub_utils.create_model_card(snake_case		,	model_name="""model_name"""		)
																	self.assertTrue((Path(snake_case		) / """README.md""").is_file()		)


"""simple docstring"""







from typing import List

import PIL
import torch
from PIL import Image

from ...configuration_utils import ConfigMixin
from ...models.modeling_utils import ModelMixin
from ...utils import PIL_INTERPOLATION






class      __a      (       lowerCAmelCase_					,						lowerCAmelCase_      ):







       def __init__(       self		):



          '''simple docstring'''

          super().__init__()

          self.register_buffer("watermark_image"				,torch.zeros((62, 62, 4)		)		)
          _UpperCAmelCase 						=       None







       def  _snake_case      (       self				,lowerCamelCase_				,lowerCamelCase_=None		):



          '''simple docstring'''

          _UpperCAmelCase 						=       images[0].height
          _UpperCAmelCase 						=       images[0].width

          _UpperCAmelCase 						=       sample_size or h

          _UpperCAmelCase 						=       min(h / sample_size				,w / sample_size		)
          _UpperCAmelCase						,				_UpperCAmelCase 						=       (int(h / coef		), int(w / coef		)) if coef < 1 else (h, w)

          _UpperCAmelCase						,				_UpperCAmelCase 						=       1024**2, img_w * img_h
          _UpperCAmelCase 						=       (Sa / Sa) ** 0.5
          _UpperCAmelCase						,				_UpperCAmelCase						,				_UpperCAmelCase 						=       int(K * 62		), img_w - int(14 * K		), img_h - int(14 * K		)

          if self.watermark_image_as_pil is None:
             _UpperCAmelCase 						=       self.watermark_image.to(torch.uinta		).cpu().numpy()
             _UpperCAmelCase 						=       Image.fromarray(lowerCamelCase_				,mode="RGBA"		)
             _UpperCAmelCase 						=       watermark_image

          _UpperCAmelCase 						=       self.watermark_image_as_pil.resize(
              (wm_size, wm_size)				,PIL_INTERPOLATION["bicubic"]				,reducing_gap=lowerCamelCase_		)

          for pil_img in images:
             pil_img.paste(lowerCamelCase_				,box=(wm_x - wm_size, wm_y - wm_size, wm_x, wm_y)				,mask=wm_img.split()[-1]		)

          return images

