"""simple docstring"""




import os
import shutil
from pathlib import Path
from typing import Optional, Union

import numpy as np
from huggingface_hub import hf_hub_download

from ..utils import ONNX_EXTERNAL_WEIGHTS_NAME, ONNX_WEIGHTS_NAME, is_onnx_available, logging


if is_onnx_available():
			import onnxruntime as ort


__lowerCAmelCase     :				Dict    				=    logging.get_logger(__name__)

__lowerCAmelCase     :				Dict    				=    {
    "tensor(bool)": np.bool_,
    "tensor(int8)": np.inta,
    "tensor(uint8)": np.uinta,
    "tensor(int16)": np.intaa,
    "tensor(uint16)": np.uintaa,
    "tensor(int32)": np.intaa,
    "tensor(uint32)": np.uintaa,
    "tensor(int64)": np.intaa,
    "tensor(uint64)": np.uintaa,
    "tensor(float16)": np.floataa,
    "tensor(float)": np.floataa,
    "tensor(double)": np.floataa,
}

class    a_   :




					def __init__(						self    :  int	,    snake_case__    :  List[Any]=None	,    **snake_case__    :  List[Any]  ):
							logger.info("""`diffusers.OnnxRuntimeModel` is experimental and might change in the future."""  )
							lowerCAmelCase__   = model
							lowerCAmelCase__   = kwargs.get("""model_save_dir"""	,    snake_case__  )
							lowerCAmelCase__   = kwargs.get("""latest_model_name"""	,    snake_case__  )




					def __call__(						self    :  int	,    **snake_case__    :  List[Any]  ):
							lowerCAmelCase__   = {k: np.array(snake_case__  ) for k, v in kwargs.items()}
							return self.model.run(snake_case__	,    snake_case__  )




					@staticmethod
					def     _SCREAMING_SNAKE_CASE    (						snake_case__    :  Union[str, Path]	,    snake_case__    :  List[Any]=None	,    snake_case__    :  int=None  ):
							if provider is None:
									logger.info("""No onnxruntime provider specified, using CPUExecutionProvider"""  )
									lowerCAmelCase__   = """CPUExecutionProvider"""

							return ort.InferenceSession(snake_case__	,    providers=[provider]	,    sess_options=snake_case__  )




					def     _SCREAMING_SNAKE_CASE    (						self    :  Tuple	,    snake_case__    :  Union[str, Path]	,    snake_case__    :  Optional[str] = None	,    **snake_case__    :  Union[str, Any]  ):
							lowerCAmelCase__   = file_name if file_name is not None else ONNX_WEIGHTS_NAME

							lowerCAmelCase__   = self.model_save_dir.joinpath(self.latest_model_name  )
							lowerCAmelCase__   = Path(snake_case__  ).joinpath(snake_case__  )
							try:
									shutil.copyfile(snake_case__	,    snake_case__  )
							except shutil.SameFileError:
									pass

							# copy external weights (for models >2GB)
							lowerCAmelCase__   = self.model_save_dir.joinpath(snake_case__  )
							if src_path.exists():
									lowerCAmelCase__   = Path(snake_case__  ).joinpath(snake_case__  )
									try:
											shutil.copyfile(snake_case__	,    snake_case__  )
									except shutil.SameFileError:
											pass




					def     _SCREAMING_SNAKE_CASE    (						self    :  int	,    snake_case__    :  Union[str, os.PathLike]	,    **snake_case__    :  Optional[Any]	,    ):
							if os.path.isfile(snake_case__  ):
									logger.error(F"""Provided path ({save_directory}) should be a directory, not a file"""  )
									return

							os.makedirs(snake_case__	,    exist_ok=snake_case__  )

							# saving model weights/files
							self._save_pretrained(snake_case__	,    **snake_case__  )




					@classmethod
					def     _SCREAMING_SNAKE_CASE    (						cls    :  int	,    snake_case__    :  Union[str, Path]	,    snake_case__    :  Optional[Union[bool, str, None]] = None	,    snake_case__    :  Optional[Union[str, None]] = None	,    snake_case__    :  bool = False	,    snake_case__    :  Optional[str] = None	,    snake_case__    :  Optional[str] = None	,    snake_case__    :  Optional[str] = None	,    snake_case__    :  Optional["ort.SessionOptions"] = None	,    **snake_case__    :  Union[str, Any]	,    ):
							lowerCAmelCase__   = file_name if file_name is not None else ONNX_WEIGHTS_NAME
							# load model from local directory
							if os.path.isdir(snake_case__  ):
									lowerCAmelCase__   = OnnxRuntimeModel.load_model(
									    os.path.join(snake_case__	,    snake_case__  )	,    provider=snake_case__	,    sess_options=snake_case__  )
									lowerCAmelCase__   = Path(snake_case__  )
							# load model from hub
							else:
									# download model
									lowerCAmelCase__   = hf_hub_download(
									    repo_id=snake_case__	,    filename=snake_case__	,    use_auth_token=snake_case__	,    revision=snake_case__	,    cache_dir=snake_case__	,    force_download=snake_case__	,    )
									lowerCAmelCase__   = Path(snake_case__  ).parent
									lowerCAmelCase__   = Path(snake_case__  ).name
									lowerCAmelCase__   = OnnxRuntimeModel.load_model(snake_case__	,    provider=snake_case__	,    sess_options=snake_case__  )
							return cls(model=snake_case__	,    **snake_case__  )




					@classmethod
					def     _SCREAMING_SNAKE_CASE    (						cls    :  int	,    snake_case__    :  Union[str, Path]	,    snake_case__    :  bool = True	,    snake_case__    :  Optional[str] = None	,    snake_case__    :  Optional[str] = None	,    **snake_case__    :  Optional[Any]	,    ):
							lowerCAmelCase__   = None
							if len(str(snake_case__  ).split("""@"""  )  ) == 2:
									lowerCAmelCase__ ,       lowerCAmelCase__   = model_id.split("""@"""  )

							return cls._from_pretrained(
							    model_id=snake_case__	,    revision=snake_case__	,    cache_dir=snake_case__	,    force_download=snake_case__	,    use_auth_token=snake_case__	,    **snake_case__	,    )





"""simple docstring"""




from itertools import permutations







def 				_UpperCAmelCase		(							lowerCamelCase__  ):





		"""simple docstring"""




		if num[3] % 2 != 0:
				return False

		if (num[2] + num[3] + num[4]) % 3 != 0:
				return False

		if num[5] % 5 != 0:
				return False

		lowerCAmelCase__   = [7, 11, 13, 17]
		for i, test in enumerate(lowerCamelCase__  ):
				if (num[i + 4] * 100 + num[i + 5] * 10 + num[i + 6]) % test != 0:
						return False
		return True







def 				_UpperCAmelCase		(							lowerCamelCase__ = 10  ):





		"""simple docstring"""




		return sum(
		    int("""""".join(map(lowerCamelCase__      ,	lowerCamelCase__  )  )  )
		    for num in permutations(range(lowerCamelCase__  )  )
		    if is_substring_divisible(lowerCamelCase__  )  )


if __name__ == "__main__":
			print(F"{solution() = }")




