'''simple docstring'''

from __future__ import annotations

from collections.abc import Iterable




class 		SCREAMING_SNAKE_CASE_				:



			"""simple docstring"""






			def __init__(       self							, snake_case_							, snake_case_				):
									snake_case							,				snake_case   :					int							=						float(snake_case_				), float(snake_case_				)



			def __eq__(       self							, snake_case_				):
									return self.x == other.x and self.y == other.y



			def __ne__(       self							, snake_case_				):
									return not self == other



			def __gt__(       self							, snake_case_				):
									if self.x > other.x:
															return True
									elif self.x == other.x:
															return self.y > other.y
									return False



			def __lt__(       self							, snake_case_				):
									return not self > other



			def __ge__(       self							, snake_case_				):
									if self.x > other.x:
															return True
									elif self.x == other.x:
															return self.y >= other.y
									return False



			def __le__(       self							, snake_case_				):
									if self.x < other.x:
															return True
									elif self.x == other.x:
															return self.y <= other.y
									return False



			def __repr__(       self				):
									return F"""({self.x}, {self.y})"""






			def __hash__(       self				):
									return hash(self.x				)







def 					UpperCAmelCase__      (							_lowerCAmelCase						: list[Point] | list[list[float]] | Iterable[list[float]],			)						->		list[Point]:



						"""simple docstring"""

						snake_case   :					list[Point]							=						[]
						if list_of_tuples:
												for p in list_of_tuples:
																		if isinstance(_lowerCAmelCase,			_lowerCAmelCase):
																								points.append(_lowerCAmelCase)
																		else:
																								try:
																														points.append(Point(p[0],			p[1]))
																								except (IndexError, TypeError):
																														print(
																														    f"""Ignoring deformed point {p}. All points"""
																														    " must have at least 2 coordinates.")
						return points


def 					UpperCAmelCase__      (							_lowerCAmelCase						: list[Point] | list[list[float]])						->		list[Point]:



						"""simple docstring"""

						if not hasattr(_lowerCAmelCase,			"__iter__"):
												snake_case   :					Any							=						f"""Expecting an iterable object but got an non-iterable type {points}"""
												raise ValueError(_lowerCAmelCase)

						if not points:
												snake_case   :					Tuple							=						f"""Expecting a list of points but got {points}"""
												raise ValueError(_lowerCAmelCase)

						return _construct_points(_lowerCAmelCase)


def 					UpperCAmelCase__      (							_lowerCAmelCase						: Point,			_lowerCAmelCase						: Point,			_lowerCAmelCase						: Point)						->		float:



						"""simple docstring"""

						snake_case   :					Union[str, Any]							=						(a.x * b.y + b.x * c.y + c.x * a.y) - (a.y * b.x + b.y * c.x + c.y * a.x)
						return det


def 					UpperCAmelCase__      (							_lowerCAmelCase						: list[Point])						->		list[Point]:



						"""simple docstring"""

						snake_case   :					Union[str, Any]							=						sorted(_validate_input(_lowerCAmelCase))
						snake_case   :					Union[str, Any]							=						len(_lowerCAmelCase)
						snake_case   :					Optional[Any]							=						set()

						for i in range(n - 1):
												for j in range(i + 1,			_lowerCAmelCase):
																		snake_case   :					Tuple							=						False
																		snake_case   :					Optional[Any]							=						True
																		for k in range(_lowerCAmelCase):
																								if k != i and k != j:
																														snake_case   :					List[Any]							=						_det(points[i],			points[j],			points[k])

																														if det_k > 0:
																																				snake_case   :					Dict							=						True
																														elif det_k < 0:
																																				snake_case   :					Union[str, Any]							=						True
																														else:
																																				# point[i], point[j], point[k] all lie on a straight line
																																				# if point[k] is to the left of point[i] or it's to the
																																				# right of point[j], then point[i], point[j] cannot be
																																				# part of the convex hull of A
																																				if points[k] < points[i] or points[k] > points[j]:
																																										snake_case   :					List[Any]							=						False
																																										break

																								if points_left_of_ij and points_right_of_ij:
																														snake_case   :					Dict							=						False
																														break

																		if ij_part_of_convex_hull:
																								convex_set.update([points[i], points[j]])

						return sorted(_lowerCAmelCase)


def 					UpperCAmelCase__      (							_lowerCAmelCase						: list[Point])						->		list[Point]:



						"""simple docstring"""

						snake_case   :					Tuple							=						sorted(_validate_input(_lowerCAmelCase))
						snake_case   :					Tuple							=						len(_lowerCAmelCase)

						# divide all the points into an upper hull and a lower hull
						# the left most point and the right most point are definitely
						# members of the convex hull by definition.
						# use these two anchors to divide all the points into two hulls,
						# an upper hull and a lower hull.

						# all points to the left (above) the line joining the extreme points belong to the
						# upper hull
						# all points to the right (below) the line joining the extreme points below to the
						# lower hull
						# ignore all points on the line joining the extreme points since they cannot be
						# part of the convex hull

						snake_case   :					Tuple							=						points[0]
						snake_case   :					List[str]							=						points[n - 1]

						snake_case   :					Dict							=						{left_most_point, right_most_point}
						snake_case   :					List[Any]							=						[]
						snake_case   :					Optional[int]							=						[]

						for i in range(1,			n - 1):
												snake_case   :					str							=						_det(_lowerCAmelCase,			_lowerCAmelCase,			points[i])

												if det > 0:
																		upper_hull.append(points[i])
												elif det < 0:
																		lower_hull.append(points[i])

						_construct_hull(_lowerCAmelCase,			_lowerCAmelCase,			_lowerCAmelCase,			_lowerCAmelCase)
						_construct_hull(_lowerCAmelCase,			_lowerCAmelCase,			_lowerCAmelCase,			_lowerCAmelCase)

						return sorted(_lowerCAmelCase)


def 					UpperCAmelCase__      (							_lowerCAmelCase						: list[Point],			_lowerCAmelCase						: Point,			_lowerCAmelCase						: Point,			_lowerCAmelCase						: set[Point])						->		None:



						"""simple docstring"""

						if points:
												snake_case   :					int							=						None
												snake_case   :					str							=						float("-inf")
												snake_case   :					Optional[int]							=						[]

												for p in points:
																		snake_case   :					int							=						_det(_lowerCAmelCase,			_lowerCAmelCase,			_lowerCAmelCase)

																		if det > 0:
																								candidate_points.append(_lowerCAmelCase)

																								if det > extreme_point_distance:
																														snake_case   :					Union[str, Any]							=						det
																														snake_case   :					str							=						p

												if extreme_point:
																		_construct_hull(_lowerCAmelCase,			_lowerCAmelCase,			_lowerCAmelCase,			_lowerCAmelCase)
																		convex_set.add(_lowerCAmelCase)
																		_construct_hull(_lowerCAmelCase,			_lowerCAmelCase,			_lowerCAmelCase,			_lowerCAmelCase)


def 					UpperCAmelCase__      (							_lowerCAmelCase						: list[Point])						->		list[Point]:



						"""simple docstring"""

						snake_case   :					List[str]							=						sorted(_validate_input(_lowerCAmelCase))
						snake_case   :					List[str]							=						len(_lowerCAmelCase)

						snake_case   :					Tuple							=						points[:2]
						for i in range(2,			_lowerCAmelCase):
												snake_case   :					Dict							=						_det(convex_hull[1],			convex_hull[0],			points[i])
												if det > 0:
																		convex_hull.insert(0,			points[i])
																		break
												elif det < 0:
																		convex_hull.append(points[i])
																		break
												else:
																		snake_case   :					Union[str, Any]							=						points[i]
						i += 1

						for j in range(_lowerCAmelCase,			_lowerCAmelCase):
												if (
												    _det(convex_hull[0],			convex_hull[-1],			points[j]) > 0
												    and _det(convex_hull[-1],			convex_hull[0],			points[1]) < 0
												):
																		# The point lies within the convex hull
																		continue

												convex_hull.insert(0,			points[j])
												convex_hull.append(points[j])
												while _det(convex_hull[0],			convex_hull[1],			convex_hull[2]) >= 0:
																		del convex_hull[1]
												while _det(convex_hull[-1],			convex_hull[-2],			convex_hull[-3]) <= 0:
																		del convex_hull[-2]

    # `convex_hull` is contains the convex hull in circular order
						return sorted(convex_hull[1:] if len(_lowerCAmelCase) > 3 else convex_hull)


def 					UpperCAmelCase__      (							)						->		Any:



						"""simple docstring"""

						snake_case   :					List[Any]							=						[
						    (0, 3),
						    (2, 2),
						    (1, 1),
						    (2, 1),
						    (3, 0),
						    (0, 0),
						    (3, 3),
						    (2, -1),
						    (2, -4),
						    (1, -3),
						]
						# the convex set of points is
						# [(0, 0), (0, 3), (1, -3), (2, -4), (3, 0), (3, 3)]
						snake_case   :					Any							=						convex_hull_bf(_lowerCAmelCase)

						snake_case   :					Tuple							=						convex_hull_recursive(_lowerCAmelCase)
						assert results_bf == results_recursive

						snake_case   :					int							=						convex_hull_melkman(_lowerCAmelCase)
						assert results_bf == results_melkman

						print(_lowerCAmelCase)


if __name__ == "__main__":
						main()






'''simple docstring'''

import argparse
import json
import os.path
from collections import OrderedDict

import numpy as np
import requests
import torch
from flax.training.checkpoints import restore_checkpoint
from huggingface_hub import hf_hub_download

from transformers import VivitConfig, VivitForVideoClassification, VivitImageProcessor
from transformers.image_utils import PILImageResampling


def 					UpperCAmelCase__      (							_lowerCAmelCase						: Optional[Any])						->		List[Any]:



						"""simple docstring"""

						snake_case   :					List[str]							=						"https://storage.googleapis.com/scenic-bucket/vivit/kinetics_400/vivit_base_16x2_unfactorized/checkpoint"

						with open(_lowerCAmelCase,			"wb") as f:
												with requests.get(_lowerCAmelCase,			stream=_lowerCAmelCase) as req:
																		for chunk in req.iter_content(chunk_size=2048):
																								f.write(_lowerCAmelCase)


def 					UpperCAmelCase__      (							)						->		VivitConfig:



						"""simple docstring"""

						snake_case   :					Any							=						VivitConfig()

						snake_case   :					Optional[int]							=						400
						snake_case   :					Tuple							=						"huggingface/label-files"
						snake_case   :					Tuple							=						"kinetics400-id2label.json"

						snake_case   :					str							=						json.load(open(hf_hub_download(_lowerCAmelCase,			_lowerCAmelCase,			repo_type="dataset"),			"r"))
						snake_case   :					Optional[int]							=						{int(_lowerCAmelCase): v for k, v in idalabel.items()}
						snake_case   :					Union[str, Any]							=						idalabel
						snake_case   :					Tuple							=						{v: k for k, v in idalabel.items()}
						return config


def 					UpperCAmelCase__      (							)						->		int:



						"""simple docstring"""

						snake_case   :					List[Any]							=						hf_hub_download(
						    repo_id="hf-internal-testing/spaghetti-video",			filename="eating_spaghetti_32_frames.npy",			repo_type="dataset")
						snake_case   :					int							=						np.load(_lowerCAmelCase)
						return list(_lowerCAmelCase)


def 					UpperCAmelCase__      (							_lowerCAmelCase						: np.ndarray)						->		str:



						"""simple docstring"""

						if np.ndim(_lowerCAmelCase) == 2:
												return transform_attention_bias(_lowerCAmelCase)

						elif np.ndim(_lowerCAmelCase) == 3:
												return transform_attention_kernel(_lowerCAmelCase)

						else:
												raise Exception(f"""Invalid number of dimesions: {np.ndim(_lowerCAmelCase)}""")


def 					UpperCAmelCase__      (							_lowerCAmelCase						: np.ndarray)						->		Optional[Any]:



						"""simple docstring"""

						return current.flatten()


def 					UpperCAmelCase__      (							_lowerCAmelCase						: np.ndarray)						->		List[Any]:



						"""simple docstring"""

						return np.reshape(_lowerCAmelCase,			(current.shape[0], current.shape[1] * current.shape[2])).T


def 					UpperCAmelCase__      (							_lowerCAmelCase						: np.ndarray)						->		Optional[Any]:



						"""simple docstring"""

						return np.reshape(_lowerCAmelCase,			(current.shape[0] * current.shape[1], current.shape[2])).T


def 					UpperCAmelCase__      (							_lowerCAmelCase						: Union[str, Any],			_lowerCAmelCase						: List[Any])						->		Union[str, Any]:



						"""simple docstring"""

						snake_case   :					Union[str, Any]							=						state_dict["optimizer"]["target"]["Transformer"][f"""encoderblock_{i}"""]

						snake_case   :					Any							=						f"""encoder.layer.{i}."""
						snake_case   :					Optional[Any]							=						{
						    prefix + "intermediate.dense.bias": state["MlpBlock_0"]["Dense_0"]["bias"],
						    prefix + "intermediate.dense.weight": np.transpose(state["MlpBlock_0"]["Dense_0"]["kernel"]),
						    prefix + "output.dense.bias": state["MlpBlock_0"]["Dense_1"]["bias"],
						    prefix + "output.dense.weight": np.transpose(state["MlpBlock_0"]["Dense_1"]["kernel"]),
						    prefix + "layernorm_before.bias": state["LayerNorm_0"]["bias"],
						    prefix + "layernorm_before.weight": state["LayerNorm_0"]["scale"],
						    prefix + "layernorm_after.bias": state["LayerNorm_1"]["bias"],
						    prefix + "layernorm_after.weight": state["LayerNorm_1"]["scale"],
						    prefix
						    + "attention.attention.query.bias": transform_attention(
						        state["MultiHeadDotProductAttention_0"]["query"]["bias"]),
						    prefix
						    + "attention.attention.query.weight": transform_attention(
						        state["MultiHeadDotProductAttention_0"]["query"]["kernel"]),
						    prefix
						    + "attention.attention.key.bias": transform_attention(state["MultiHeadDotProductAttention_0"]["key"]["bias"]),
						    prefix
						    + "attention.attention.key.weight": transform_attention(
						        state["MultiHeadDotProductAttention_0"]["key"]["kernel"]),
						    prefix
						    + "attention.attention.value.bias": transform_attention(
						        state["MultiHeadDotProductAttention_0"]["value"]["bias"]),
						    prefix
						    + "attention.attention.value.weight": transform_attention(
						        state["MultiHeadDotProductAttention_0"]["value"]["kernel"]),
						    prefix + "attention.output.dense.bias": state["MultiHeadDotProductAttention_0"]["out"]["bias"],
						    prefix
						    + "attention.output.dense.weight": transform_attention_output_weight(
						        state["MultiHeadDotProductAttention_0"]["out"]["kernel"]),
						}

						return new_state


def 					UpperCAmelCase__      (							_lowerCAmelCase						: List[Any])						->		List[Any]:



						"""simple docstring"""

						return sum([1 if "encoderblock_" in k else 0 for k in state_dict["optimizer"]["target"]["Transformer"].keys()])


def 					UpperCAmelCase__      (							_lowerCAmelCase						: List[Any],			_lowerCAmelCase						: List[Any]=False)						->		List[Any]:



						"""simple docstring"""

						snake_case   :					Dict							=						get_n_layers(_lowerCAmelCase)

						snake_case   :					Tuple							=						OrderedDict()

						snake_case   :					List[str]							=						state_dict["optimizer"]["target"]["Transformer"]["encoder_norm"]["bias"]
						snake_case   :					List[str]							=						state_dict["optimizer"]["target"]["Transformer"]["encoder_norm"]["scale"]

						snake_case   :					Tuple							=						np.transpose(
						    state_dict["optimizer"]["target"]["embedding"]["kernel"],			(4, 3, 0, 1, 2))
						snake_case   :					Optional[Any]							=						state_dict["optimizer"]["target"]["embedding"]["bias"]

						snake_case   :					List[Any]							=						state_dict["optimizer"]["target"]["cls"]
						snake_case   :					Tuple							=						state_dict["optimizer"]["target"]["Transformer"]["posembed_input"][
						    "pos_embedding"
						]

						for i in range(_lowerCAmelCase):
												new_state.update(transform_state_encoder_block(_lowerCAmelCase,			_lowerCAmelCase))

						if classification_head:
												snake_case   :					Tuple							=						{"vivit." + k: v for k, v in new_state.items()}
												snake_case   :					Union[str, Any]							=						np.transpose(state_dict["optimizer"]["target"]["output_projection"]["kernel"])
												snake_case   :					Optional[Any]							=						np.transpose(state_dict["optimizer"]["target"]["output_projection"]["bias"])

						return {k: torch.tensor(_lowerCAmelCase) for k, v in new_state.items()}


def 					UpperCAmelCase__      (							)						->		VivitImageProcessor:



						"""simple docstring"""

						snake_case   :					int							=						VivitImageProcessor()

						assert extractor.do_resize is True
						assert extractor.size == {"shortest_edge": 256}
						assert extractor.do_center_crop is True
						assert extractor.crop_size == {"width": 224, "height": 224}
						assert extractor.resample == PILImageResampling.BILINEAR

						# here: https://github.com/deepmind/dmvr/blob/master/dmvr/modalities.py
						# one can seen that add_image has default values for normalization_mean and normalization_std set to 0 and 1
						# which effectively means no normalization (and ViViT does not overwrite those when calling this func)
						assert extractor.do_normalize is False
						assert extractor.do_rescale is True
						assert extractor.rescale_factor == 1 / 255

						# zero-centering = True in original implementation
						assert extractor.do_zero_centering is True

						return extractor


def 					UpperCAmelCase__      (							_lowerCAmelCase						: str)						->		Union[str, Any]:



						"""simple docstring"""

						snake_case   :					str							=						"checkpoint"

						if not os.path.exists(_lowerCAmelCase):
												download_checkpoint(_lowerCAmelCase)

						snake_case   :					Union[str, Any]							=						restore_checkpoint(_lowerCAmelCase,			_lowerCAmelCase)
						snake_case   :					Optional[Any]							=						transform_state(_lowerCAmelCase,			classification_head=_lowerCAmelCase)

						snake_case   :					List[Any]							=						get_vivit_config()

						assert config.image_size == 224
						assert config.num_frames == 32

						snake_case   :					Union[str, Any]							=						VivitForVideoClassification(_lowerCAmelCase)
						model.load_state_dict(_lowerCAmelCase)
						model.eval()

						snake_case   :					Any							=						get_processor()

						snake_case   :					Dict							=						prepare_video()
						snake_case   :					Union[str, Any]							=						extractor(_lowerCAmelCase,			return_tensors="pt")

						snake_case   :					Tuple							=						model(**_lowerCAmelCase)

						snake_case   :					Any							=						torch.Size([1, 400])
						snake_case   :					int							=						torch.tensor([-1.0543, 2.0764, -0.2104, 0.4439, -0.9658])

						assert outputs.logits.shape == expected_shape
						assert torch.allclose(outputs.logits[0, :5],			_lowerCAmelCase,			atol=1E-4), outputs.logits[0, :5]

						model.save_pretrained(_lowerCAmelCase)
						extractor.save_pretrained(_lowerCAmelCase)


if __name__ == "__main__":
						A_        =   argparse.ArgumentParser()

						parser.add_argument("--output_model_name", "-o", type=str, help="Output path for the converted HuggingFace model")

						A_        =   parser.parse_args()
						convert(args.output_model_name)





