






'''simple docstring'''







import argparse
import json
import os

import tensorstore as ts
import torch
from flax import serialization
from flax.traverse_util import flatten_dict, unflatten_dict
from tensorflow.io import gfile

from transformers.modeling_utils import dtype_byte_size
from transformers.models.switch_transformers.convert_switch_transformers_original_flax_checkpoint_to_pytorch import (
    rename_keys,
)
from transformers.utils import WEIGHTS_INDEX_NAME, WEIGHTS_NAME
from transformers.utils.hub import convert_file_size_to_int
def 						A__			(				__lowerCAmelCase		:			Tuple   ,    __lowerCAmelCase		:			int						):
						if flax_key_tuple[-1] == "kernel" and flax_tensor.ndim == 3:
												# expert layer
												lowerCamelCase__         =  flax_key_tuple[:-1] + ("""weight""",)
												lowerCamelCase__         =  torch.permute(__lowerCAmelCase   ,    (0, 2, 1)						)
						elif flax_key_tuple[-1] == "kernel" and ".".join(__lowerCAmelCase						):
												# linear layer
												lowerCamelCase__         =  flax_key_tuple[:-1] + ("""weight""",)
												lowerCamelCase__         =  flax_tensor.T
						elif flax_key_tuple[-1] in ["scale", "embedding"]:
												lowerCamelCase__         =  flax_key_tuple[:-1] + ("""weight""",)

						return flax_key_tuple, flax_tensor
def 						A__			(				__lowerCAmelCase		:			Tuple   ,    __lowerCAmelCase		:			int   ,    __lowerCAmelCase		:			Union[str, Any]						):
						if "metadata" in layer:
												lowerCamelCase__         =  layer.split("""metadata"""						)
												lowerCamelCase__         =  """""".join(split_layer[0]						)[:-1]
												lowerCamelCase__         =  [tuple(("""metadata""" + split_layer[1]).split("""/"""						)						)]
						elif "kvstore" in layer:
												lowerCamelCase__         =  layer.split("""kvstore"""						)
												lowerCamelCase__         =  """""".join(split_layer[0]						)[:-1]
												lowerCamelCase__         =  [tuple(("""kvstore""" + split_layer[1]).split("""/"""						)						)]

						else:
												lowerCamelCase__         =  layer.split("""/"""						)
												lowerCamelCase__         =  """/""".join(split_layer[:-1]						)
												lowerCamelCase__         =  (split_layer[-1],)

						if "kvstore/path" in layer:
												lowerCamelCase__         =  F'''{switch_checkpoint_path}/{checkpoint_info[layer]}'''
						elif "kvstore/driver" in layer:
												lowerCamelCase__         =  """file"""
						else:
												lowerCamelCase__         =  checkpoint_info[layer]

						return curr_real_layer_name, split_layer, content
def 						A__			(				__lowerCAmelCase		:			str   ,    __lowerCAmelCase		:			Tuple						):
						lowerCamelCase__         =  rename_keys(__lowerCAmelCase						)
						lowerCamelCase__         =  {}
						for k, v in current_block.items():
												lowerCamelCase__         =  v
						lowerCamelCase__         =  new_current_block
						torch.save(__lowerCAmelCase   ,    __lowerCAmelCase						)
def 						A__			(				__lowerCAmelCase		:			Dict   ,    __lowerCAmelCase		:			Optional[Any]   ,    __lowerCAmelCase		:			Union[str, Any]   ,    __lowerCAmelCase		:			List[str]   ,    __lowerCAmelCase		:			str = WEIGHTS_NAME						):
						lowerCamelCase__         =  convert_file_size_to_int(__lowerCAmelCase						)
						lowerCamelCase__         =  []
						lowerCamelCase__         =  {}
						lowerCamelCase__         =  0
						lowerCamelCase__         =  0

						os.makedirs(__lowerCAmelCase   ,    exist_ok=__lowerCAmelCase						)
						with gfile.GFile(switch_checkpoint_path + """/checkpoint"""   ,    """rb"""						) as fp:
												lowerCamelCase__         =  serialization.msgpack_restore(fp.read()						)["""optimizer"""]["""target"""]
												lowerCamelCase__         =  flatten_dict(__lowerCAmelCase   ,    sep="""/"""						)

						lowerCamelCase__         =  {}
						for layer in checkpoint_info.keys():
												lowerCamelCase__       ,			lowerCamelCase__       ,			lowerCamelCase__         =  get_key_and_tensorstore_dict(
												    __lowerCAmelCase   ,    __lowerCAmelCase   ,    __lowerCAmelCase						)
												if curr_real_layer_name in all_layers:
																		lowerCamelCase__         =  content
												else:
																		lowerCamelCase__         =  {split_layer[-1]: content}

						for key in all_layers.keys():
												# open tensorstore file
												lowerCamelCase__         =  ts.open(unflatten_dict(all_layers[key]						)						).result().read().result()
												lowerCamelCase__         =  torch.tensor(__lowerCAmelCase						)
												lowerCamelCase__         =  raw_weights.numel() * dtype_byte_size(raw_weights.dtype						)

												# use the renaming pattern from the small conversion scripts
												lowerCamelCase__       ,			lowerCamelCase__         =  rename_base_flax_keys(tuple(key.split("""/"""						)						)   ,    __lowerCAmelCase						)
												lowerCamelCase__         =  """/""".join(__lowerCAmelCase						)

												# If this weight is going to tip up over the maximal size, we split.
												if current_block_size + weight_size > max_shard_size:
																		lowerCamelCase__         =  os.path.join(
																		    __lowerCAmelCase   ,    weights_name.replace(""".bin"""   ,    F'''-{len(__lowerCAmelCase						)+1:05d}-of-???.bin'''						)						)
																		rename_and_save_block(__lowerCAmelCase   ,    __lowerCAmelCase						)
																		sharded_state_dicts.append(current_block.keys()						)
																		del current_block
																		lowerCamelCase__         =  {}
																		lowerCamelCase__         =  0

												lowerCamelCase__         =  raw_weights.to(getattr(__lowerCAmelCase   ,    __lowerCAmelCase						)						)
												current_block_size += weight_size
												total_size += weight_size

						# Add the last block
						lowerCamelCase__         =  os.path.join(__lowerCAmelCase   ,    weights_name.replace(""".bin"""   ,    F'''-{len(__lowerCAmelCase						)+1:05d}-of-???.bin'''						)						)
						rename_and_save_block(__lowerCAmelCase   ,    __lowerCAmelCase						)
						sharded_state_dicts.append(current_block.keys()						)

						# If we only have one shard, we return it
						if len(__lowerCAmelCase						) == 1:
												return {weights_name: sharded_state_dicts[0]}, None

						# Otherwise, let's build the index
						lowerCamelCase__         =  {}
						lowerCamelCase__         =  {}
						for idx, shard in enumerate(__lowerCAmelCase						):
												lowerCamelCase__         =  weights_name.replace(
												    """.bin"""   ,    F'''-{idx+1:05d}-of-{len(__lowerCAmelCase						):05d}.bin'''						)  # len(sharded_state_dicts):05d}
												lowerCamelCase__         =  os.path.join(__lowerCAmelCase   ,    weights_name.replace(""".bin"""   ,    F'''-{idx+1:05d}-of-???.bin'''						)						)
												os.rename(__lowerCAmelCase   ,    os.path.join(__lowerCAmelCase   ,    __lowerCAmelCase						)						)
												lowerCamelCase__         =  shard
												for key in shard:
																		lowerCamelCase__         =  shard_file

    # Add the metadata
						lowerCamelCase__         =  {"""total_size""": total_size}
						lowerCamelCase__         =  {"""metadata""": metadata, """weight_map""": weight_map}

						with open(os.path.join(__lowerCAmelCase   ,    __lowerCAmelCase						)   ,    """w"""   ,    encoding="""utf-8"""						) as f:
												lowerCamelCase__         =  json.dumps(__lowerCAmelCase   ,    indent=2   ,    sort_keys=__lowerCAmelCase						) + """\n"""
												f.write(__lowerCAmelCase						)

						return metadata, index


if __name__ == "__main__":
							UpperCamelCase    :      List[Any]  			=		argparse.ArgumentParser()
							# Required parameters
							parser.add_argument(
							    '--switch_t5x_checkpoint_path',
							    default='/mnt/disks/disk_switch/original_checkpoints/switch-xxl-128/checkpoint_634600',
							    type=str,
							    required=False,
							    help='Path to a directory containing a folder per layer. Follows the original Google format.',
							)
							parser.add_argument('--max_shard_size', default='10GB', required=False, help='Max shard size')
							parser.add_argument('--dtype', default='bfloat16', type=str, required=False, help='dtype of the saved model')
							parser.add_argument(
							    '--pytorch_dump_folder_path',
							    default='/mnt/disks/disk_switch/original_checkpoints/switch-xxl-128-converted',
							    type=str,
							    required=False,
							    help='Path to the output pytorch model.',
							)
							UpperCamelCase    :      Dict  			=		parser.parse_args()
							shard_on_the_fly(
							    args.switch_tax_checkpoint_path,
							    args.pytorch_dump_folder_path,
							    args.max_shard_size,
							    args.dtype,
							)





def 						A__			(				):
						from transformers import SwitchTransformersConfig, SwitchTransformersForConditionalGeneration, TaTokenizer

						lowerCamelCase__         =  SwitchTransformersConfig.from_pretrained("""google/switch-base-8"""						)
						config.save_pretrained("""/home/arthur_huggingface_co/transformers/switch_converted"""						)
						lowerCamelCase__         =  SwitchTransformersForConditionalGeneration.from_pretrained(
						    """/home/arthur_huggingface_co/transformers/switch_converted"""   ,    device_map="""auto"""						)

						lowerCamelCase__         =  TaTokenizer.from_pretrained("""t5-small"""						)
						lowerCamelCase__         =  """A <extra_id_0> walks into a bar a orders a <extra_id_1> with <extra_id_2> pinch of <extra_id_3>."""

						lowerCamelCase__         =  tokenizer(__lowerCAmelCase   ,    return_tensors="""pt"""						).input_ids
						lowerCamelCase__         =  model.generate(__lowerCAmelCase   ,    decoder_start_token_id=0						)
						print(tokenizer.decode(out[0]						)						)









'''simple docstring'''







from __future__ import annotations

import math
def 						A__			(				__lowerCAmelCase		:			int						):

						if 1 < number < 4:
												# 2 and 3 are primes
												return True
						elif number < 2 or number % 2 == 0 or number % 3 == 0:
												# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
												return False

						# All primes number are in format of 6k +/- 1
						for i in range(5   ,    int(math.sqrt(__lowerCAmelCase						) + 1						)   ,    6						):
												if number % i == 0 or number % (i + 2) == 0:
																		return False
						return True


UpperCamelCase    :      str  			=		[num for num in range(3, 10_00_01, 2) if not is_prime(num)]
def 						A__			(				__lowerCAmelCase		:			int						):
						if not isinstance(__lowerCAmelCase   ,    __lowerCAmelCase						):
												raise ValueError("""n must be an integer"""						)
						if n <= 0:
												raise ValueError("""n must be >= 0"""						)

						lowerCamelCase__         =  []
						for num in range(len(__lowerCAmelCase						)						):
												lowerCamelCase__         =  0
												while 2 * i * i <= odd_composites[num]:
																		lowerCamelCase__         =  odd_composites[num] - 2 * i * i
																		if is_prime(__lowerCAmelCase						):
																								break
																		i += 1
												else:
																		list_nums.append(odd_composites[num]						)
																		if len(__lowerCAmelCase						) == n:
																								return list_nums

						return []
def 						A__			(				):
						return compute_nums(1						)[0]


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

