




'''simple docstring'''
import argparse
import datetime





def 			lowerCamelCase(							SCREAMING_SNAKE_CASE_     )		->		str:
			A_									= {
			    '0': 'Sunday',
			    '1': 'Monday',
			    '2': 'Tuesday',
			    '3': 'Wednesday',
			    '4': 'Thursday',
			    '5': 'Friday',
			    '6': 'Saturday',
			}

			A_									= {0: 1, 1: 2, 2: 3, 3: 4, 4: 5, 5: 6, 6: 0}

			# Validate
			if not 0 < len(_UpperCAmelCase     ) < 11:
						raise ValueError('Must be 10 characters long'     )

			# Get month
			A_									= int(date_input[0] + date_input[1]     )
			# Validate
			if not 0 < m < 13:
						raise ValueError('Month must be between 1 - 12'     )

			A_									= date_input[2]
			# Validate
			if sep_a not in ["-", "/"]:
						raise ValueError('Date separator must be \'-\' or \'/\''     )

			# Get day
			A_									= int(date_input[3] + date_input[4]     )
			# Validate
			if not 0 < d < 32:
						raise ValueError('Date must be between 1 - 31'     )

			# Get second separator
			A_									= date_input[5]
			# Validate
			if sep_a not in ["-", "/"]:
						raise ValueError('Date separator must be \'-\' or \'/\''     )

			# Get year
			A_									= int(date_input[6] + date_input[7] + date_input[8] + date_input[9]     )
			# Arbitrary year range
			if not 45 < y < 8500:
						raise ValueError(
						    'Year out of range. There has to be some sort of limit...right?'     )

			# Get datetime obj for validation
			A_									= datetime.date(int(_UpperCAmelCase     )       ,int(_UpperCAmelCase     )       ,int(_UpperCAmelCase     )     )

			# Start math
			if m <= 2:
						A_									= y - 1
						A_									= m + 12
			# maths var
			A_									= int(str(_UpperCAmelCase     )[:2]     )
			A_									= int(str(_UpperCAmelCase     )[2:]     )
			A_									= int(2.6 * m - 5.39     )
			A_									= int(c / 4     )
			A_									= int(k / 4     )
			A_									= int(d + k     )
			A_									= int(t + u + v + x     )
			A_									= int(z - (2 * c)     )
			A_									= round(w % 7     )
			# End math

			# Validate math
			if f != convert_datetime_days[dt_ck.weekday()]:
						raise AssertionError('The date was evaluated incorrectly. Contact developer.'     )

			# Response
			A_									= F'Your date {date_input}, is a {days[str(_UpperCAmelCase     )]}!'
			return response


if __name__ == "__main__":
							import doctest

							doctest.testmod()
							_SCREAMING_SNAKE_CASE			=						argparse.ArgumentParser(
							    description=(
							        "Find out what day of the week nearly any date is or was. Enter "
							        "date as a string in the mm-dd-yyyy or mm/dd/yyyy format"
							    )
							)
							parser.add_argument(
							    "date_input", type=str, help="Date as a string (mm-dd-yyyy or mm/dd/yyyy)"
							)
							_SCREAMING_SNAKE_CASE			=						parser.parse_args()
							zeller(args.date_input)











import gc
import unittest

from diffusers import FlaxControlNetModel, FlaxStableDiffusionControlNetPipeline
from diffusers.utils import is_flax_available, load_image, slow
from diffusers.utils.testing_utils import require_flax


if is_flax_available():
    import jax
    import jax.numpy as jnp
    from flax.jax_utils import replicate
    from flax.training.common_utils import shard

@slow
@require_flax
class   lowerCAmelCase				(   unittest.TestCase     ):
 def 	A_      ( self    : Any      )     ->      int:
     # clean up the VRAM after each test
     super().tearDown()
     gc.collect()
 def 	A_      ( self    : Optional[Any]      )     ->      Optional[int]:
     lowerCamelCase__					,				lowerCamelCase__       : str   					=						FlaxControlNetModel.from_pretrained(
         'lllyasviel/sd-controlnet-canny'     ,	from_pt=UpperCAmelCase     ,	dtype=jnp.bfloataa      )
     lowerCamelCase__					,				lowerCamelCase__       : int   					=						FlaxStableDiffusionControlNetPipeline.from_pretrained(
         'runwayml/stable-diffusion-v1-5'     ,	controlnet=UpperCAmelCase     ,	from_pt=UpperCAmelCase     ,	dtype=jnp.bfloataa      )
     lowerCamelCase__       : int   					=						controlnet_params

     lowerCamelCase__       : Any   					=						'bird'
     lowerCamelCase__       : Dict   					=						jax.device_count()
     lowerCamelCase__       : Any   					=						pipe.prepare_text_inputs([prompts] * num_samples      )

     lowerCamelCase__       : Optional[Any]   					=						load_image(
         'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png'      )
     lowerCamelCase__       : Tuple   					=						pipe.prepare_image_inputs([canny_image] * num_samples      )

     lowerCamelCase__       : List[str]   					=						jax.random.PRNGKey(0      )
     lowerCamelCase__       : Optional[int]   					=						jax.random.split(UpperCAmelCase     ,	jax.device_count()      )

     lowerCamelCase__       : List[Any]   					=						replicate(UpperCAmelCase      )
     lowerCamelCase__       : Dict   					=						shard(UpperCAmelCase      )
     lowerCamelCase__       : Any   					=						shard(UpperCAmelCase      )

     lowerCamelCase__       : Any   					=						pipe(
         prompt_ids=UpperCAmelCase     ,	image=UpperCAmelCase     ,	params=UpperCAmelCase     ,	prng_seed=UpperCAmelCase     ,	num_inference_steps=50     ,	jit=UpperCAmelCase     ,	).images
     assert images.shape == (jax.device_count(), 1, 768, 512, 3)

     lowerCamelCase__       : Dict   					=						images.reshape((images.shape[0] * images.shape[1],) + images.shape[-3:]      )
     lowerCamelCase__       : List[str]   					=						images[0, 253:256, 253:256, -1]

     lowerCamelCase__       : Tuple   					=						jnp.asarray(jax.device_get(image_slice.flatten()      )      )
     lowerCamelCase__       : Tuple   					=						jnp.array(
         [0.1_6_7_9_6_9, 0.1_1_6_6_9_9, 0.0_8_1_5_4_3, 0.1_5_4_2_9_7, 0.1_3_2_8_1_2, 0.1_0_8_8_8_7, 0.1_6_9_9_2_2, 0.1_6_9_9_2_2, 0.2_0_5_0_7_8]      )
     print(F"""output_slice: {output_slice}"""      )
     assert jnp.abs(output_slice - expected_slice      ).max() < 1e-2







 def 	A_      ( self    : List[str]      )     ->      Union[str, Any]:
     lowerCamelCase__					,				lowerCamelCase__       : Dict   					=						FlaxControlNetModel.from_pretrained(
         'lllyasviel/sd-controlnet-openpose'     ,	from_pt=UpperCAmelCase     ,	dtype=jnp.bfloataa      )
     lowerCamelCase__					,				lowerCamelCase__       : Optional[Any]   					=						FlaxStableDiffusionControlNetPipeline.from_pretrained(
         'runwayml/stable-diffusion-v1-5'     ,	controlnet=UpperCAmelCase     ,	from_pt=UpperCAmelCase     ,	dtype=jnp.bfloataa      )
     lowerCamelCase__       : Optional[int]   					=						controlnet_params

     lowerCamelCase__       : Any   					=						'Chef in the kitchen'
     lowerCamelCase__       : str   					=						jax.device_count()
     lowerCamelCase__       : Union[str, Any]   					=						pipe.prepare_text_inputs([prompts] * num_samples      )

     lowerCamelCase__       : Tuple   					=						load_image(
         'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/pose.png'      )
     lowerCamelCase__       : List[str]   					=						pipe.prepare_image_inputs([pose_image] * num_samples      )

     lowerCamelCase__       : Tuple   					=						jax.random.PRNGKey(0      )
     lowerCamelCase__       : List[str]   					=						jax.random.split(UpperCAmelCase     ,	jax.device_count()      )

     lowerCamelCase__       : Dict   					=						replicate(UpperCAmelCase      )
     lowerCamelCase__       : List[str]   					=						shard(UpperCAmelCase      )
     lowerCamelCase__       : Tuple   					=						shard(UpperCAmelCase      )

     lowerCamelCase__       : Union[str, Any]   					=						pipe(
         prompt_ids=UpperCAmelCase     ,	image=UpperCAmelCase     ,	params=UpperCAmelCase     ,	prng_seed=UpperCAmelCase     ,	num_inference_steps=50     ,	jit=UpperCAmelCase     ,	).images
     assert images.shape == (jax.device_count(), 1, 768, 512, 3)

     lowerCamelCase__       : Dict   					=						images.reshape((images.shape[0] * images.shape[1],) + images.shape[-3:]      )
     lowerCamelCase__       : int   					=						images[0, 253:256, 253:256, -1]

     lowerCamelCase__       : Optional[int]   					=						jnp.asarray(jax.device_get(image_slice.flatten()      )      )
     lowerCamelCase__       : int   					=						jnp.array(
         [[0.2_7_1_4_8_4, 0.2_6_1_7_1_9, 0.2_7_5_3_9_1, 0.2_7_7_3_4_4, 0.2_7_9_2_9_7, 0.2_9_1_0_1_6, 0.2_9_4_9_2_2, 0.3_0_2_7_3_4, 0.3_0_2_7_3_4]]      )
     print(F"""output_slice: {output_slice}"""      )
     assert jnp.abs(output_slice - expected_slice      ).max() < 1e-2





