





'''simple docstring'''

from pickle import UnpicklingError

import jax
import jax.numpy as jnp
import numpy as np
from flax.serialization import from_bytes
from flax.traverse_util import flatten_dict

from ..utils import logging


_UpperCAmelCase						:      Any	=    logging.get_logger(__name__)







def  a__    (    lowercase :					Any, lowercase :					int				)		->		int:





     """simple docstring"""

     try:
          with open(UpperCAmelCase_, '''rb'''				) as flax_state_f:
               _UpperCamelCase       =	from_bytes(UpperCAmelCase_, flax_state_f.read()				)
     except UnpicklingError as e:
          try:
               with open(UpperCAmelCase_				) as f:
                    if f.read().startswith('''version'''				):
                         raise OSError(
                             '''You seem to have cloned a repository without having git-lfs installed. Please'''
                             ''' install git-lfs and run `git lfs install` followed by `git lfs pull` in the'''
                             ''' folder you cloned.'''				)
                    else:
                         raise ValueError from e
          except (UnicodeDecodeError, ValueError):
               raise EnvironmentError(F"""Unable to convert {model_file} to Flax deserializable object. """				)

     return load_flax_weights_in_pytorch_model(UpperCAmelCase_, UpperCAmelCase_				)







def  a__    (    lowercase :					Union[str, Any], lowercase :					str				)		->		Dict:





     """simple docstring"""

     try:
          import torch  # noqa: F401
     except ImportError:
          logger.error(
              '''Loading Flax weights in PyTorch requires both PyTorch and Flax to be installed. Please see'''
              ''' https://pytorch.org/ and https://flax.readthedocs.io/en/latest/installation.html for installation'''
              ''' instructions.'''				)
          raise

     # check if we have bf16 weights
     _UpperCamelCase       =	flatten_dict(jax.tree_util.tree_map(lambda lowercase				: x.dtype == jnp.bfloataa, UpperCAmelCase_				)				).values()
     if any(UpperCAmelCase_				):
          # convert all weights to fp32 if they are bf16 since torch.from_numpy can-not handle bf16

          # and bf16 is not fully supported in PT yet.
          logger.warning(
              '''Found ``bfloat16`` weights in Flax model. Casting all ``bfloat16`` weights to ``float32`` '''
              '''before loading those in PyTorch model.'''				)
          _UpperCamelCase       =	jax.tree_util.tree_map(
              lambda lowercase				: params.astype(np.floataa				) if params.dtype == jnp.bfloataa else params, UpperCAmelCase_				)

     _UpperCamelCase       =	''''''

     _UpperCamelCase       =	flatten_dict(UpperCAmelCase_, sep='''.'''				)
     _UpperCamelCase       =	pt_model.state_dict()

     # keep track of unexpected & missing keys
     _UpperCamelCase       =	[]
     _UpperCamelCase       =	set(pt_model_dict.keys()				)

     for flax_key_tuple, flax_tensor in flax_state_dict.items():
          _UpperCamelCase       =	flax_key_tuple.split('''.'''				)

          if flax_key_tuple_array[-1] == "kernel" and flax_tensor.ndim == 4:
               _UpperCamelCase       =	flax_key_tuple_array[:-1] + ['''weight''']
               _UpperCamelCase       =	jnp.transpose(UpperCAmelCase_, (3, 2, 0, 1)				)
          elif flax_key_tuple_array[-1] == "kernel":
               _UpperCamelCase       =	flax_key_tuple_array[:-1] + ['''weight''']
               _UpperCamelCase       =	flax_tensor.T
          elif flax_key_tuple_array[-1] == "scale":
               _UpperCamelCase       =	flax_key_tuple_array[:-1] + ['''weight''']

          if "time_embedding" not in flax_key_tuple_array:
               for i, flax_key_tuple_string in enumerate(UpperCAmelCase_				):
                    _UpperCamelCase       =	(
                        flax_key_tuple_string.replace('''_0''', '''.0'''				)
                        .replace('''_1''', '''.1'''				)
                        .replace('''_2''', '''.2'''				)
                        .replace('''_3''', '''.3'''				)
                        .replace('''_4''', '''.4'''				)
                        .replace('''_5''', '''.5'''				)
                        .replace('''_6''', '''.6'''				)
                        .replace('''_7''', '''.7'''				)
                        .replace('''_8''', '''.8'''				)
                        .replace('''_9''', '''.9'''				)
                    )

          _UpperCamelCase       =	'''.'''.join(UpperCAmelCase_				)

          if flax_key in pt_model_dict:
               if flax_tensor.shape != pt_model_dict[flax_key].shape:
                    raise ValueError(
                        F"""Flax checkpoint seems to be incorrect. Weight {flax_key_tuple} was expected """
                        F"""to be of shape {pt_model_dict[flax_key].shape}, but is {flax_tensor.shape}."""				)
               else:
                    # add weight to pytorch dict
                    _UpperCamelCase       =	np.asarray(UpperCAmelCase_				) if not isinstance(UpperCAmelCase_, np.ndarray				) else flax_tensor
                    _UpperCamelCase       =	torch.from_numpy(UpperCAmelCase_				)
                    # remove from missing keys
                    missing_keys.remove(UpperCAmelCase_				)
          else:
               # weight is not expected by PyTorch model
               unexpected_keys.append(UpperCAmelCase_				)

     pt_model.load_state_dict(UpperCAmelCase_				)

     # re-transform missing_keys to list
     _UpperCamelCase       =	list(UpperCAmelCase_				)

     if len(UpperCAmelCase_				) > 0:
          logger.warning(
              '''Some weights of the Flax model were not used when initializing the PyTorch model'''
              F""" {pt_model.__class__.__name__}: {unexpected_keys}\n- This IS expected if you are initializing"""
              F""" {pt_model.__class__.__name__} from a Flax model trained on another task or with another architecture"""
              ''' (e.g. initializing a BertForSequenceClassification model from a FlaxBertForPreTraining model).\n- This'''
              F""" IS NOT expected if you are initializing {pt_model.__class__.__name__} from a Flax model that you expect"""
              ''' to be exactly identical (e.g. initializing a BertForSequenceClassification model from a'''
              ''' FlaxBertForSequenceClassification model).'''				)
     if len(UpperCAmelCase_				) > 0:
          logger.warning(
              F"""Some weights of {pt_model.__class__.__name__} were not initialized from the Flax model and are newly"""
              F""" initialized: {missing_keys}\nYou should probably TRAIN this model on a down-stream task to be able to"""
              ''' use it for predictions and inference.'''				)

     return pt_model










'''simple docstring'''

import argparse
import json
import os
import sys
import tempfile
import unittest
from argparse import Namespace
from dataclasses import dataclass, field
from enum import Enum
from pathlib import Path
from typing import List, Literal, Optional

import yaml

from transformers import HfArgumentParser, TrainingArguments
from transformers.hf_argparser import make_choice_type_function, string_to_bool


# Since Python 3.10, we can use the builtin `|` operator for Union types
# See PEP 604: https://peps.python.org/pep-0604
lowercase__						:      List[str]	=    sys.version_info >= (3, 10)







def  a__    (    lowercase :					Dict=None, lowercase :					List[str]=None				)		->		List[Any]:





     """simple docstring"""

     return field(default_factory=lambda: default, metadata=lowercase				)
@dataclass
class     __lowerCAmelCase					:






       """simple docstring"""
       _snake_case     :					int
       _snake_case     :					float
       _snake_case     :					str
       _snake_case     :					bool

@dataclass
class     __lowerCAmelCase					:






       """simple docstring"""
       _snake_case     :					int						    =   4_2
       _snake_case     :					str						    =   field(default='toto'						,						metadata={'help': 'help message'}			)

@dataclass
class     __lowerCAmelCase					:






       """simple docstring"""
       _snake_case     :					bool						    =   False
       _snake_case     :					bool						    =   True
       _snake_case     :					Optional[bool]						    =   None

class     __lowerCAmelCase					(   __magic_name__			):






       """simple docstring"""
       _snake_case     :					str						    =   'titi'
       _snake_case     :					Union[str, Any]						    =   'toto'

class     __lowerCAmelCase					(   __magic_name__			):






       """simple docstring"""
       _snake_case     :					str						    =   'titi'
       _snake_case     :					Union[str, Any]						    =   'toto'
       _snake_case     :					Any						    =   4_2

@dataclass
class     __lowerCAmelCase					:






       """simple docstring"""
       _snake_case     :					BasicEnum						    =   "toto"





       def snake_case__						(							self       :		List[Any]					)   ->					List[Any]:

            '''simple docstring'''




            _UpperCamelCase       =	BasicEnum(self.foo					)

@dataclass
class     __lowerCAmelCase					:






       """simple docstring"""
       _snake_case     :					MixedTypeEnum						    =   "toto"





       def snake_case__						(							self       :		Dict					)   ->					Union[str, Any]:

            '''simple docstring'''




            _UpperCamelCase       =	MixedTypeEnum(self.foo					)

@dataclass
class     __lowerCAmelCase					:






       """simple docstring"""
       _snake_case     :					Optional[int]						    =   None
       _snake_case     :					Optional[float]						    =   field(default=__magic_name__						,						metadata={'help': 'help message'}			)
       _snake_case     :					Optional[str]						    =   None
       _snake_case     :					Optional[List[str]]						    =   list_field(default=[]			)
       _snake_case     :					Optional[List[int]]						    =   list_field(default=[]			)

@dataclass
class     __lowerCAmelCase					:






       """simple docstring"""
       _snake_case     :					List[int]						    =   list_field(default=[]			)
       _snake_case     :					List[int]						    =   list_field(default=[1, 2, 3]			)
       _snake_case     :					List[str]						    =   list_field(default=['Hallo', 'Bonjour', 'Hello']			)
       _snake_case     :					List[float]						    =   list_field(default=[0.1, 0.2, 0.3]			)

@dataclass
class     __lowerCAmelCase					:






       """simple docstring"""
       _snake_case     :					List[int]						    =   field()
       _snake_case     :					str						    =   field()
       _snake_case     :					BasicEnum						    =   field()





       def snake_case__						(							self       :		str					)   ->					Any:

            '''simple docstring'''




            _UpperCamelCase       =	BasicEnum(self.required_enum					)

@dataclass
class     __lowerCAmelCase					:






       """simple docstring"""
       _snake_case     :					int
       _snake_case     :					"BasicEnum"						    =   field()
       _snake_case     :					"Optional[bool]"						    =   None
       _snake_case     :					"str"						    =   field(default='toto'						,						metadata={'help': 'help message'}			)
       _snake_case     :					"List[str]"						    =   list_field(default=['Hallo', 'Bonjour', 'Hello']			)


if is_python_no_less_than_3_10:
   @dataclass
   class     __lowerCAmelCase					:






          """simple docstring"""
          _snake_case     :					bool						    =   False
          _snake_case     :					bool						    =   True
          _snake_case     :					bool | None						    =   None

   @dataclass
   class     __lowerCAmelCase					:






          """simple docstring"""
          _snake_case     :					int | None						    =   None
          _snake_case     :					float | None						    =   field(default=__magic_name__						,						metadata={'help': 'help message'}			)
          _snake_case     :					str | None						    =   None
          _snake_case     :					list[str] | None						    =   list_field(default=[]			)
          _snake_case     :					list[int] | None						    =   list_field(default=[]			)




class     __lowerCAmelCase					(   unittest.TestCase			):






       """simple docstring"""





       def snake_case__						(							self       :		Optional[Any]	,			lowerCAmelCase__       :		argparse.ArgumentParser	,			lowerCAmelCase__       :		argparse.ArgumentParser					)   ->					str:

            '''simple docstring'''




            self.assertEqual(len(a._actions					)	,			len(b._actions					)					)
            for x, y in zip(a._actions	,			b._actions					):
                 _UpperCamelCase       =	{k: v for k, v in vars(lowerCAmelCase__					).items() if k != '''container'''}
                 _UpperCamelCase       =	{k: v for k, v in vars(lowerCAmelCase__					).items() if k != '''container'''}

                 # Choices with mixed type have custom function as "type"
                 # So we need to compare results directly for equality
                 if xx.get('''choices'''	,			lowerCAmelCase__					) and yy.get('''choices'''	,			lowerCAmelCase__					):
                      for expected_choice in yy["choices"] + xx["choices"]:
                           self.assertEqual(xx['''type'''](lowerCAmelCase__					)	,			yy['''type'''](lowerCAmelCase__					)					)
                      del xx["type"], yy["type"]

                 self.assertEqual(lowerCAmelCase__	,			lowerCAmelCase__					)





       def snake_case__						(							self       :		Dict					)   ->					List[Any]:

            '''simple docstring'''




            _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)

            _UpperCamelCase       =	argparse.ArgumentParser()
            expected.add_argument('''--foo'''	,			type=lowerCAmelCase__	,			required=lowerCAmelCase__					)
            expected.add_argument('''--bar'''	,			type=lowerCAmelCase__	,			required=lowerCAmelCase__					)
            expected.add_argument('''--baz'''	,			type=lowerCAmelCase__	,			required=lowerCAmelCase__					)
            expected.add_argument('''--flag'''	,			type=lowerCAmelCase__	,			default=lowerCAmelCase__	,			const=lowerCAmelCase__	,			nargs='''?'''					)
            self.argparsersEqual(lowerCAmelCase__	,			lowerCAmelCase__					)

            _UpperCamelCase       =	['''--foo''', '''1''', '''--baz''', '''quux''', '''--bar''', '''0.5''']
            ((_UpperCamelCase)   ,    )       =	parser.parse_args_into_dataclasses(lowerCAmelCase__	,			look_for_args_file=lowerCAmelCase__					)
            self.assertFalse(example.flag					)





       def snake_case__						(							self       :		int					)   ->					Any:

            '''simple docstring'''




            _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)

            _UpperCamelCase       =	argparse.ArgumentParser()
            expected.add_argument('''--foo'''	,			default=42	,			type=lowerCAmelCase__					)
            expected.add_argument('''--baz'''	,			default='''toto'''	,			type=lowerCAmelCase__	,			help='''help message'''					)
            self.argparsersEqual(lowerCAmelCase__	,			lowerCAmelCase__					)





       def snake_case__						(							self       :		Tuple					)   ->					Optional[Any]:

            '''simple docstring'''




            _UpperCamelCase       =	argparse.ArgumentParser()
            expected.add_argument('''--foo'''	,			type=lowerCAmelCase__	,			default=lowerCAmelCase__	,			const=lowerCAmelCase__	,			nargs='''?'''					)
            expected.add_argument('''--baz'''	,			type=lowerCAmelCase__	,			default=lowerCAmelCase__	,			const=lowerCAmelCase__	,			nargs='''?'''					)
            # A boolean no_* argument always has to come after its "default: True" regular counter-part
            # and its default must be set to False
            expected.add_argument('''--no_baz'''	,			action='''store_false'''	,			default=lowerCAmelCase__	,			dest='''baz'''					)
            expected.add_argument('''--opt'''	,			type=lowerCAmelCase__	,			default=lowerCAmelCase__					)

            _UpperCamelCase       =	[WithDefaultBoolExample]
            if is_python_no_less_than_3_10:
                 dataclass_types.append(lowerCAmelCase__					)

            for dataclass_type in dataclass_types:
                 _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)
                 self.argparsersEqual(lowerCAmelCase__	,			lowerCAmelCase__					)

                 _UpperCamelCase       =	parser.parse_args([]					)
                 self.assertEqual(lowerCAmelCase__	,			Namespace(foo=lowerCAmelCase__	,			baz=lowerCAmelCase__	,			opt=lowerCAmelCase__					)					)

                 _UpperCamelCase       =	parser.parse_args(['''--foo''', '''--no_baz''']					)
                 self.assertEqual(lowerCAmelCase__	,			Namespace(foo=lowerCAmelCase__	,			baz=lowerCAmelCase__	,			opt=lowerCAmelCase__					)					)

                 _UpperCamelCase       =	parser.parse_args(['''--foo''', '''--baz''']					)
                 self.assertEqual(lowerCAmelCase__	,			Namespace(foo=lowerCAmelCase__	,			baz=lowerCAmelCase__	,			opt=lowerCAmelCase__					)					)

                 _UpperCamelCase       =	parser.parse_args(['''--foo''', '''True''', '''--baz''', '''True''', '''--opt''', '''True''']					)
                 self.assertEqual(lowerCAmelCase__	,			Namespace(foo=lowerCAmelCase__	,			baz=lowerCAmelCase__	,			opt=lowerCAmelCase__					)					)

                 _UpperCamelCase       =	parser.parse_args(['''--foo''', '''False''', '''--baz''', '''False''', '''--opt''', '''False''']					)
                 self.assertEqual(lowerCAmelCase__	,			Namespace(foo=lowerCAmelCase__	,			baz=lowerCAmelCase__	,			opt=lowerCAmelCase__					)					)





       def snake_case__						(							self       :		Union[str, Any]					)   ->					Optional[Any]:

            '''simple docstring'''




            _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)

            _UpperCamelCase       =	argparse.ArgumentParser()
            expected.add_argument(
                '''--foo'''	,			default='''toto'''	,			choices=['''titi''', '''toto''', 42]	,			type=make_choice_type_function(['''titi''', '''toto''', 42]					)	,			)
            self.argparsersEqual(lowerCAmelCase__	,			lowerCAmelCase__					)

            _UpperCamelCase       =	parser.parse_args([]					)
            self.assertEqual(args.foo	,			'''toto'''					)
            _UpperCamelCase       =	parser.parse_args_into_dataclasses([]					)[0]
            self.assertEqual(enum_ex.foo	,			MixedTypeEnum.toto					)

            _UpperCamelCase       =	parser.parse_args(['''--foo''', '''titi''']					)
            self.assertEqual(args.foo	,			'''titi'''					)
            _UpperCamelCase       =	parser.parse_args_into_dataclasses(['''--foo''', '''titi''']					)[0]
            self.assertEqual(enum_ex.foo	,			MixedTypeEnum.titi					)

            _UpperCamelCase       =	parser.parse_args(['''--foo''', '''42''']					)
            self.assertEqual(args.foo	,			42					)
            _UpperCamelCase       =	parser.parse_args_into_dataclasses(['''--foo''', '''42''']					)[0]
            self.assertEqual(enum_ex.foo	,			MixedTypeEnum.fourtytwo					)





       def snake_case__						(							self       :		Any					)   ->					List[Any]:

            '''simple docstring'''




            @dataclass
            class     __lowerCAmelCase					:






                   """simple docstring"""
                   _snake_case     :					Literal["titi", "toto", 4_2]						    =   "toto"

            _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)

            _UpperCamelCase       =	argparse.ArgumentParser()
            expected.add_argument(
                '''--foo'''	,			default='''toto'''	,			choices=('''titi''', '''toto''', 42)	,			type=make_choice_type_function(['''titi''', '''toto''', 42]					)	,			)
            self.argparsersEqual(lowerCAmelCase__	,			lowerCAmelCase__					)

            _UpperCamelCase       =	parser.parse_args([]					)
            self.assertEqual(args.foo	,			'''toto'''					)

            _UpperCamelCase       =	parser.parse_args(['''--foo''', '''titi''']					)
            self.assertEqual(args.foo	,			'''titi'''					)

            _UpperCamelCase       =	parser.parse_args(['''--foo''', '''42''']					)
            self.assertEqual(args.foo	,			42					)





       def snake_case__						(							self       :		int					)   ->					Union[str, Any]:

            '''simple docstring'''




            _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)

            _UpperCamelCase       =	argparse.ArgumentParser()
            expected.add_argument('''--foo_int'''	,			nargs='''+'''	,			default=[]	,			type=lowerCAmelCase__					)
            expected.add_argument('''--bar_int'''	,			nargs='''+'''	,			default=[1, 2, 3]	,			type=lowerCAmelCase__					)
            expected.add_argument('''--foo_str'''	,			nargs='''+'''	,			default=['''Hallo''', '''Bonjour''', '''Hello''']	,			type=lowerCAmelCase__					)
            expected.add_argument('''--foo_float'''	,			nargs='''+'''	,			default=[0.1, 0.2, 0.3]	,			type=lowerCAmelCase__					)

            self.argparsersEqual(lowerCAmelCase__	,			lowerCAmelCase__					)

            _UpperCamelCase       =	parser.parse_args([]					)
            self.assertEqual(
                lowerCAmelCase__	,			Namespace(foo_int=[]	,			bar_int=[1, 2, 3]	,			foo_str=['''Hallo''', '''Bonjour''', '''Hello''']	,			foo_float=[0.1, 0.2, 0.3]					)	,			)

            _UpperCamelCase       =	parser.parse_args('''--foo_int 1 --bar_int 2 3 --foo_str a b c --foo_float 0.1 0.7'''.split()					)
            self.assertEqual(lowerCAmelCase__	,			Namespace(foo_int=[1]	,			bar_int=[2, 3]	,			foo_str=['''a''', '''b''', '''c''']	,			foo_float=[0.1, 0.7]					)					)





       def snake_case__						(							self       :		List[str]					)   ->					Tuple:

            '''simple docstring'''




            _UpperCamelCase       =	argparse.ArgumentParser()
            expected.add_argument('''--foo'''	,			default=lowerCAmelCase__	,			type=lowerCAmelCase__					)
            expected.add_argument('''--bar'''	,			default=lowerCAmelCase__	,			type=lowerCAmelCase__	,			help='''help message'''					)
            expected.add_argument('''--baz'''	,			default=lowerCAmelCase__	,			type=lowerCAmelCase__					)
            expected.add_argument('''--ces'''	,			nargs='''+'''	,			default=[]	,			type=lowerCAmelCase__					)
            expected.add_argument('''--des'''	,			nargs='''+'''	,			default=[]	,			type=lowerCAmelCase__					)

            _UpperCamelCase       =	[OptionalExample]
            if is_python_no_less_than_3_10:
                 dataclass_types.append(lowerCAmelCase__					)

            for dataclass_type in dataclass_types:
                 _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)

                 self.argparsersEqual(lowerCAmelCase__	,			lowerCAmelCase__					)

                 _UpperCamelCase       =	parser.parse_args([]					)
                 self.assertEqual(lowerCAmelCase__	,			Namespace(foo=lowerCAmelCase__	,			bar=lowerCAmelCase__	,			baz=lowerCAmelCase__	,			ces=[]	,			des=[]					)					)

                 _UpperCamelCase       =	parser.parse_args('''--foo 12 --bar 3.14 --baz 42 --ces a b c --des 1 2 3'''.split()					)
                 self.assertEqual(lowerCAmelCase__	,			Namespace(foo=12	,			bar=3.14	,			baz='''42'''	,			ces=['''a''', '''b''', '''c''']	,			des=[1, 2, 3]					)					)





       def snake_case__						(							self       :		Any					)   ->					int:

            '''simple docstring'''




            _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)

            _UpperCamelCase       =	argparse.ArgumentParser()
            expected.add_argument('''--required_list'''	,			nargs='''+'''	,			type=lowerCAmelCase__	,			required=lowerCAmelCase__					)
            expected.add_argument('''--required_str'''	,			type=lowerCAmelCase__	,			required=lowerCAmelCase__					)
            expected.add_argument(
                '''--required_enum'''	,			type=make_choice_type_function(['''titi''', '''toto''']					)	,			choices=['''titi''', '''toto''']	,			required=lowerCAmelCase__	,			)
            self.argparsersEqual(lowerCAmelCase__	,			lowerCAmelCase__					)





       def snake_case__						(							self       :		Any					)   ->					int:

            '''simple docstring'''




            _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)

            _UpperCamelCase       =	argparse.ArgumentParser()
            expected.add_argument('''--foo'''	,			type=lowerCAmelCase__	,			required=lowerCAmelCase__					)
            expected.add_argument(
                '''--required_enum'''	,			type=make_choice_type_function(['''titi''', '''toto''']					)	,			choices=['''titi''', '''toto''']	,			required=lowerCAmelCase__	,			)
            expected.add_argument('''--opt'''	,			type=lowerCAmelCase__	,			default=lowerCAmelCase__					)
            expected.add_argument('''--baz'''	,			default='''toto'''	,			type=lowerCAmelCase__	,			help='''help message'''					)
            expected.add_argument('''--foo_str'''	,			nargs='''+'''	,			default=['''Hallo''', '''Bonjour''', '''Hello''']	,			type=lowerCAmelCase__					)
            self.argparsersEqual(lowerCAmelCase__	,			lowerCAmelCase__					)





       def snake_case__						(							self       :		int					)   ->					Optional[Any]:

            '''simple docstring'''




            _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)

            _UpperCamelCase       =	{
                '''foo''': 12,
                '''bar''': 3.14,
                '''baz''': '''42''',
                '''flag''': True,
            }

            _UpperCamelCase       =	parser.parse_dict(lowerCAmelCase__					)[0]
            _UpperCamelCase       =	BasicExample(**lowerCAmelCase__					)
            self.assertEqual(lowerCAmelCase__	,			lowerCAmelCase__					)





       def snake_case__						(							self       :		Any					)   ->					Tuple:

            '''simple docstring'''




            _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)

            _UpperCamelCase       =	{
                '''foo''': 12,
                '''bar''': 3.14,
                '''baz''': '''42''',
                '''flag''': True,
                '''extra''': 42,
            }

            self.assertRaises(lowerCAmelCase__	,			parser.parse_dict	,			lowerCAmelCase__	,			allow_extra_keys=lowerCAmelCase__					)





       def snake_case__						(							self       :		str					)   ->					Tuple:

            '''simple docstring'''




            _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)

            _UpperCamelCase       =	{
                '''foo''': 12,
                '''bar''': 3.14,
                '''baz''': '''42''',
                '''flag''': True,
            }
            with tempfile.TemporaryDirectory() as tmp_dir:
                 _UpperCamelCase       =	os.path.join(lowerCAmelCase__	,			'''temp_json'''					)
                 os.mkdir(lowerCAmelCase__					)
                 with open(temp_local_path + '''.json'''	,			'''w+'''					) as f:
                      json.dump(lowerCAmelCase__	,			lowerCAmelCase__					)
                 _UpperCamelCase       =	parser.parse_yaml_file(Path(temp_local_path + '''.json'''					)					)[0]

            _UpperCamelCase       =	BasicExample(**lowerCAmelCase__					)
            self.assertEqual(lowerCAmelCase__	,			lowerCAmelCase__					)





       def snake_case__						(							self       :		Optional[Any]					)   ->					Optional[int]:

            '''simple docstring'''




            _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)

            _UpperCamelCase       =	{
                '''foo''': 12,
                '''bar''': 3.14,
                '''baz''': '''42''',
                '''flag''': True,
            }
            with tempfile.TemporaryDirectory() as tmp_dir:
                 _UpperCamelCase       =	os.path.join(lowerCAmelCase__	,			'''temp_yaml'''					)
                 os.mkdir(lowerCAmelCase__					)
                 with open(temp_local_path + '''.yaml'''	,			'''w+'''					) as f:
                      yaml.dump(lowerCAmelCase__	,			lowerCAmelCase__					)
                 _UpperCamelCase       =	parser.parse_yaml_file(Path(temp_local_path + '''.yaml'''					)					)[0]
            _UpperCamelCase       =	BasicExample(**lowerCAmelCase__					)
            self.assertEqual(lowerCAmelCase__	,			lowerCAmelCase__					)







       def snake_case__						(							self       :		str					)   ->					str:

            '''simple docstring'''




            _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)
            self.assertIsNotNone(lowerCAmelCase__					)



