

'''simple docstring'''





import re

from flax.core.frozen_dict import freeze
from flax.traverse_util import flatten_dict, unflatten_dict
from jax.experimental import PartitionSpec as P


# Sentinels
UpperCamelCase_    						=       object()

# For specifying empty leaf dict `{}`
UpperCamelCase_    						=       object()






def 				_lowerCAmelCase			(   __magic_name__						:     int   , __magic_name__						:     int						)				->  Optional[int]:
						lowercase :							Optional[Any]    		=tuple((re.compile(x + '''$'''						) for x in qs)						)
						for i in range(len(__magic_name__						) - len(__magic_name__						) + 1						):
												lowercase :							Union[str, Any]    		=[x.match(__magic_name__						) for x, y in zip(__magic_name__   , ks[i:]						)]
												if matches and all(__magic_name__						):
																		return True
						return False






def 				_lowerCAmelCase			(   __magic_name__						:     Dict						)				->  List[str]:
						def replace(__magic_name__						:     Optional[int]   , __magic_name__						:     Optional[Any]						):
												for rule, replacement in rules:
																		if _match(__magic_name__   , __magic_name__						):
																								return replacement
												return val

						return replace






def 				_lowerCAmelCase			(   )				->  int:
						return [
						    # embeddings
						    (("transformer", "wpe", "embedding"), P('''mp'''   , __magic_name__						)),
						    (("transformer", "wte", "embedding"), P('''mp'''   , __magic_name__						)),
						    # atention
						    (("attention", "(q_proj|k_proj|v_proj)", "kernel"), P(__magic_name__   , '''mp'''						)),
						    (("attention", "out_proj", "kernel"), P('''mp'''   , __magic_name__						)),
						    (("attention", "out_proj", "bias"), None),
						    # mlp
						    (("mlp", "c_fc", "kernel"), P(__magic_name__   , '''mp'''						)),
						    (("mlp", "c_fc", "bias"), P('''mp'''						)),
						    (("mlp", "c_proj", "kernel"), P('''mp'''   , __magic_name__						)),
						    (("mlp", "c_proj", "bias"), None),
						    # layer norms
						    ((r"ln_\d+", "bias"), None),
						    ((r"\d+", r"ln_\d+", "scale"), None),
						    (("ln_f", "bias"), None),
						    (("ln_f", "scale"), None),
						]







def 				_lowerCAmelCase			(   __magic_name__						:     str						)				->  int:
						lowercase :							int    		=_get_partition_rules()
						lowercase :							Tuple    		=_replacement_rules(__magic_name__						)
						lowercase :							Any    		={k: _unmatched for k in flatten_dict(__magic_name__						)}
						lowercase :							Any    		={k: replace(__magic_name__   , __magic_name__						) for k, v in initd.items()}
						assert _unmatched not in result.values(), "Incomplete partition spec."
						return freeze(unflatten_dict(__magic_name__						)						)








'''simple docstring'''





import numpy as np
from cva import destroyAllWindows, imread, imshow, waitKey





class 		__SCREAMING_SNAKE_CASE							:







				def __init__(       self     :		Union[str, Any]		,					UpperCAmelCase__     :		Union[str, Any]		,					UpperCAmelCase__     :		int		,					UpperCAmelCase__     :		int   ):
										'''simple docstring'''
										if dst_width < 0 or dst_height < 0:
																raise ValueError('''Destination width/height should be > 0'''   )

										lowercase :							Union[str, Any]    		=img
										lowercase :							Union[str, Any]    		=img.shape[1]
										lowercase :							str    		=img.shape[0]
										lowercase :							Union[str, Any]    		=dst_width
										lowercase :							str    		=dst_height

										lowercase :							str    		=self.src_w / self.dst_w
										lowercase :							Optional[Any]    		=self.src_h / self.dst_h

										lowercase :							int    		=(
										    np.ones((self.dst_h, self.dst_w, 3)		,					np.uinta   ) * 255
										)







				def  lowerCamelCase_	(       self     :		List[Any]   ):
										'''simple docstring'''
										for i in range(self.dst_h   ):
																for j in range(self.dst_w   ):
																						lowercase :							List[Any]    		=self.img[self.get_y(UpperCAmelCase__   )][self.get_x(UpperCAmelCase__   )]







				def  lowerCamelCase_	(       self     :		Tuple		,					UpperCAmelCase__     :		int   ):
										'''simple docstring'''
										return int(self.ratio_x * x   )







				def  lowerCamelCase_	(       self     :		List[Any]		,					UpperCAmelCase__     :		int   ):
										'''simple docstring'''
										return int(self.ratio_y * y   )


if __name__ == "__main__":
							UpperCamelCase_						,   UpperCamelCase_    						=       800, 600
							UpperCamelCase_    						=       imread("""image_data/lena.jpg""", 1)
							UpperCamelCase_    						=       NearestNeighbour(im, dst_w, dst_h)
							n.process()

							imshow(
							    f'''Image resized from: {im.shape[1]}x{im.shape[0]} to {dst_w}x{dst_h}''', n.output
							)
							waitKey(0)
							destroyAllWindows()





