


'''simple docstring'''




import numpy as np
import torch
from imwatermark import WatermarkEncoder


# Copied from https://github.com/Stability-AI/generative-models/blob/613af104c6b85184091d42d374fef420eddb356d/scripts/demo/streamlit_helpers.py#L66
_a   :   Dict												=   0B10_11_00_11_11_10_11_00_10_01_00_00_01_11_10_11_10_11_00_01_10_01_11_10
# bin(x)[2:] gives bits of x as str, use int to convert them to 0/1
_a   :   Tuple												=   [int(bit) for bit in bin(WATERMARK_MESSAGE)[2:]]




class 			_lowercase :
   def __init__(						self       :      List[Any]      ) ->							int:
        __snake_case           =						WATERMARK_BITS
        __snake_case           =						WatermarkEncoder()

        self.encoder.set_watermark('bits'       ,   self.watermark      )





   def a  (						self       :      Tuple       ,   SCREAMING_SNAKE_CASE_       :      torch.FloatTensor      ) ->							Dict:
        # can't encode images that are smaller than 256
        if images.shape[-1] < 256:
             return images

        __snake_case           =						(255 * (images / 2 + 0.5)).cpu().permute(0       ,   2       ,   3       ,   1      ).float().numpy()

        __snake_case           =						[self.encoder.encode(SCREAMING_SNAKE_CASE_       ,   'dwtDct'      ) for image in images]

        __snake_case           =						torch.from_numpy(np.array(SCREAMING_SNAKE_CASE_      )      ).permute(0       ,   3       ,   1       ,   2      )

        __snake_case           =						torch.clamp(2 * (images / 255 - 0.5)       ,   min=-1.0       ,   max=1.0      )
        return images





"""simple docstring"""


import pytest

from datasets.utils.sharding import _distribute_shards, _number_of_shards_in_gen_kwargs, _split_gen_kwargs






@pytest.mark.parametrize(
    """kwargs, expected""" ,[
        ({"""num_shards""": 0, """max_num_jobs""": 1}, []),
        ({"""num_shards""": 10, """max_num_jobs""": 1}, [range(10		)]),
        ({"""num_shards""": 10, """max_num_jobs""": 10}, [range(lowercase ,i + 1		) for i in range(10		)]),
        ({"""num_shards""": 1, """max_num_jobs""": 10}, [range(1		)]),
        ({"""num_shards""": 10, """max_num_jobs""": 3}, [range(0 ,4		), range(4 ,7		), range(7 ,10		)]),
        ({"""num_shards""": 3, """max_num_jobs""": 10}, [range(0 ,1		), range(1 ,2		), range(2 ,3		)]),
    ] ,)
def      __UpperCAmelCase       (      lowercase ,lowercase		):







  """simple docstring"""
  _UpperCAmelCase    			=   _distribute_shards(**lowercase		)
  assert out == expected






@pytest.mark.parametrize(
    """gen_kwargs, max_num_jobs, expected""" ,[
        ({"""foo""": 0}, 10, [{"""foo""": 0}]),
        ({"""shards""": [0, 1, 2, 3]}, 1, [{"""shards""": [0, 1, 2, 3]}]),
        ({"""shards""": [0, 1, 2, 3]}, 4, [{"""shards""": [0]}, {"""shards""": [1]}, {"""shards""": [2]}, {"""shards""": [3]}]),
        ({"""shards""": [0, 1]}, 4, [{"""shards""": [0]}, {"""shards""": [1]}]),
        ({"""shards""": [0, 1, 2, 3]}, 2, [{"""shards""": [0, 1]}, {"""shards""": [2, 3]}]),
    ] ,)
def      __UpperCAmelCase       (      lowercase ,lowercase ,lowercase		):







  """simple docstring"""
  _UpperCAmelCase    			=   _split_gen_kwargs(lowercase ,lowercase		)
  assert out == expected






@pytest.mark.parametrize(
    """gen_kwargs, expected""" ,[
        ({"""foo""": 0}, 1),
        ({"""shards""": [0]}, 1),
        ({"""shards""": [0, 1, 2, 3]}, 4),
        ({"""shards""": [0, 1, 2, 3], """foo""": 0}, 4),
        ({"""shards""": [0, 1, 2, 3], """other""": (0, 1)}, 4),
        ({"""shards""": [0, 1, 2, 3], """shards2""": [0, 1]}, RuntimeError),
    ] ,)
def      __UpperCAmelCase       (      lowercase ,lowercase		):







  """simple docstring"""
  if expected is RuntimeError:
    with pytest.raises(lowercase		):
      _number_of_shards_in_gen_kwargs(lowercase		)
  else:
    _UpperCAmelCase    			=   _number_of_shards_in_gen_kwargs(lowercase		)
    assert out == expected
