





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
_lowerCAmelCase							:					Union[str, Any]		    =		sys.version_info >= (3, 10)

def    __snake_case  (    _lowerCAmelCase       :       List[Any]=None , _lowerCAmelCase       :       Any=None		)       ->  int:
   return field(default_factory=lambda: default , metadata=lowerCAmelCase__		)


@dataclass
class     __magic_name__     :





     """simple docstring"""



     __UpperCamelCase    			=   42
     __UpperCamelCase    			=   42
     __UpperCamelCase    			=   42
     __UpperCamelCase    			=   42




@dataclass
class     __magic_name__     :





     """simple docstring"""



     __UpperCamelCase    			=   42
     __UpperCamelCase    			=   field(default='''toto'''			, metadata={'''help''': '''help message'''}							)




@dataclass
class     __magic_name__     :





     """simple docstring"""



     __UpperCamelCase    			=   False
     __UpperCamelCase    			=   True
     __UpperCamelCase    			=   None




class     __magic_name__     (							lowercase_							):





     """simple docstring"""



     __UpperCamelCase    			=   '''titi'''
     __UpperCamelCase    			=   '''toto'''




class     __magic_name__     (							lowercase_							):





     """simple docstring"""



     __UpperCamelCase    			=   '''titi'''
     __UpperCamelCase    			=   '''toto'''
     __UpperCamelCase    			=   42




@dataclass
class     __magic_name__     :





     """simple docstring"""



     __UpperCamelCase    			=   '''toto'''



     def   SCREAMING_SNAKE_CASE						(							self				:Optional[Any]     ):





        '''simple docstring'''




        A_    : List[str]								=	BasicEnum(self.foo     )




@dataclass
class     __magic_name__     :





     """simple docstring"""



     __UpperCamelCase    			=   '''toto'''



     def   SCREAMING_SNAKE_CASE						(							self				:Tuple     ):





        '''simple docstring'''




        A_    : List[Any]								=	MixedTypeEnum(self.foo     )




@dataclass
class     __magic_name__     :





     """simple docstring"""



     __UpperCamelCase    			=   None
     __UpperCamelCase    			=   field(default=lowercase_			, metadata={'''help''': '''help message'''}							)
     __UpperCamelCase    			=   None
     __UpperCamelCase    			=   list_field(default=[]							)
     __UpperCamelCase    			=   list_field(default=[]							)




@dataclass
class     __magic_name__     :





     """simple docstring"""



     __UpperCamelCase    			=   list_field(default=[]							)
     __UpperCamelCase    			=   list_field(default=[1, 2, 3]							)
     __UpperCamelCase    			=   list_field(default=['''Hallo''', '''Bonjour''', '''Hello''']							)
     __UpperCamelCase    			=   list_field(default=[0.1, 0.2, 0.3]							)




@dataclass
class     __magic_name__     :





     """simple docstring"""



     __UpperCamelCase    			=   field()
     __UpperCamelCase    			=   field()
     __UpperCamelCase    			=   field()



     def   SCREAMING_SNAKE_CASE						(							self				:Tuple     ):





        '''simple docstring'''




        A_    : int								=	BasicEnum(self.required_enum     )




@dataclass
class     __magic_name__     :





     """simple docstring"""



     __UpperCamelCase    			=   42
     __UpperCamelCase    			=   field()
     __UpperCamelCase    			=   None
     __UpperCamelCase    			=   field(default='''toto'''			, metadata={'''help''': '''help message'''}							)
     __UpperCamelCase    			=   list_field(default=['''Hallo''', '''Bonjour''', '''Hello''']							)


if is_python_no_less_than_3_10:


 @dataclass
 class     __magic_name__     :





      """simple docstring"""



      __UpperCamelCase    			=   False
      __UpperCamelCase    			=   True
      __UpperCamelCase    			=   None




 @dataclass
 class     __magic_name__     :





      """simple docstring"""



      __UpperCamelCase    			=   None
      __UpperCamelCase    			=   field(default=lowercase_			, metadata={'''help''': '''help message'''}							)
      __UpperCamelCase    			=   None
      __UpperCamelCase    			=   list_field(default=[]							)
      __UpperCamelCase    			=   list_field(default=[]							)





class     __magic_name__     (							unittest.TestCase							):





     """simple docstring"""



     def   SCREAMING_SNAKE_CASE						(							self				:str	,					snake_case				:argparse.ArgumentParser	,					snake_case				:argparse.ArgumentParser     ):





        '''simple docstring'''




        self.assertEqual(len(a._actions     )	,					len(b._actions     )     )
        for x, y in zip(a._actions	,					b._actions     ):
           A_    : Tuple								=	{k: v for k, v in vars(SCREAMING_SNAKE_CASE_     ).items() if k != 'container'}
           A_    : List[str]								=	{k: v for k, v in vars(SCREAMING_SNAKE_CASE_     ).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"	,					SCREAMING_SNAKE_CASE_     ) and yy.get("choices"	,					SCREAMING_SNAKE_CASE_     ):
              for expected_choice in yy["choices"] + xx["choices"]:
                 self.assertEqual(xx["type"](SCREAMING_SNAKE_CASE_     )	,					yy["type"](SCREAMING_SNAKE_CASE_     )     )
              del xx["type"], yy["type"]

           self.assertEqual(SCREAMING_SNAKE_CASE_	,					SCREAMING_SNAKE_CASE_     )



     def   SCREAMING_SNAKE_CASE						(							self				:Optional[Any]     ):





        '''simple docstring'''




        A_    : int								=	HfArgumentParser(SCREAMING_SNAKE_CASE_     )

        A_    : Tuple								=	argparse.ArgumentParser()
        expected.add_argument("--foo"	,					type=SCREAMING_SNAKE_CASE_	,					required=SCREAMING_SNAKE_CASE_     )
        expected.add_argument("--bar"	,					type=SCREAMING_SNAKE_CASE_	,					required=SCREAMING_SNAKE_CASE_     )
        expected.add_argument("--baz"	,					type=SCREAMING_SNAKE_CASE_	,					required=SCREAMING_SNAKE_CASE_     )
        expected.add_argument("--flag"	,					type=SCREAMING_SNAKE_CASE_	,					default=SCREAMING_SNAKE_CASE_	,					const=SCREAMING_SNAKE_CASE_	,					nargs="?"     )
        self.argparsersEqual(SCREAMING_SNAKE_CASE_	,					SCREAMING_SNAKE_CASE_     )

        A_    : List[str]								=	['--foo', '1', '--baz', 'quux', '--bar', '0.5']
        (A_)    : Tuple								=	parser.parse_args_into_dataclasses(SCREAMING_SNAKE_CASE_	,					look_for_args_file=SCREAMING_SNAKE_CASE_     )
        self.assertFalse(example.flag     )



     def   SCREAMING_SNAKE_CASE						(							self				:Any     ):





        '''simple docstring'''




        A_    : Optional[Any]								=	HfArgumentParser(SCREAMING_SNAKE_CASE_     )

        A_    : Union[str, Any]								=	argparse.ArgumentParser()
        expected.add_argument("--foo"	,					default=42	,					type=SCREAMING_SNAKE_CASE_     )
        expected.add_argument("--baz"	,					default="toto"	,					type=SCREAMING_SNAKE_CASE_	,					help="help message"     )
        self.argparsersEqual(SCREAMING_SNAKE_CASE_	,					SCREAMING_SNAKE_CASE_     )



     def   SCREAMING_SNAKE_CASE						(							self				:Optional[int]     ):





        '''simple docstring'''




        A_    : Dict								=	argparse.ArgumentParser()
        expected.add_argument("--foo"	,					type=SCREAMING_SNAKE_CASE_	,					default=SCREAMING_SNAKE_CASE_	,					const=SCREAMING_SNAKE_CASE_	,					nargs="?"     )
        expected.add_argument("--baz"	,					type=SCREAMING_SNAKE_CASE_	,					default=SCREAMING_SNAKE_CASE_	,					const=SCREAMING_SNAKE_CASE_	,					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=SCREAMING_SNAKE_CASE_	,					dest="baz"     )
        expected.add_argument("--opt"	,					type=SCREAMING_SNAKE_CASE_	,					default=SCREAMING_SNAKE_CASE_     )

        A_    : Optional[Any]								=	[WithDefaultBoolExample]
        if is_python_no_less_than_3_10:
           dataclass_types.append(SCREAMING_SNAKE_CASE_     )

        for dataclass_type in dataclass_types:
           A_    : List[Any]								=	HfArgumentParser(SCREAMING_SNAKE_CASE_     )
           self.argparsersEqual(SCREAMING_SNAKE_CASE_	,					SCREAMING_SNAKE_CASE_     )

           A_    : List[str]								=	parser.parse_args([]     )
           self.assertEqual(SCREAMING_SNAKE_CASE_	,					Namespace(foo=SCREAMING_SNAKE_CASE_	,					baz=SCREAMING_SNAKE_CASE_	,					opt=SCREAMING_SNAKE_CASE_     )     )

           A_    : Optional[Any]								=	parser.parse_args(["--foo", "--no_baz"]     )
           self.assertEqual(SCREAMING_SNAKE_CASE_	,					Namespace(foo=SCREAMING_SNAKE_CASE_	,					baz=SCREAMING_SNAKE_CASE_	,					opt=SCREAMING_SNAKE_CASE_     )     )

           A_    : Dict								=	parser.parse_args(["--foo", "--baz"]     )
           self.assertEqual(SCREAMING_SNAKE_CASE_	,					Namespace(foo=SCREAMING_SNAKE_CASE_	,					baz=SCREAMING_SNAKE_CASE_	,					opt=SCREAMING_SNAKE_CASE_     )     )

           A_    : Union[str, Any]								=	parser.parse_args(["--foo", "True", "--baz", "True", "--opt", "True"]     )
           self.assertEqual(SCREAMING_SNAKE_CASE_	,					Namespace(foo=SCREAMING_SNAKE_CASE_	,					baz=SCREAMING_SNAKE_CASE_	,					opt=SCREAMING_SNAKE_CASE_     )     )

           A_    : Optional[Any]								=	parser.parse_args(["--foo", "False", "--baz", "False", "--opt", "False"]     )
           self.assertEqual(SCREAMING_SNAKE_CASE_	,					Namespace(foo=SCREAMING_SNAKE_CASE_	,					baz=SCREAMING_SNAKE_CASE_	,					opt=SCREAMING_SNAKE_CASE_     )     )



     def   SCREAMING_SNAKE_CASE						(							self				:Tuple     ):





        '''simple docstring'''




        A_    : Any								=	HfArgumentParser(SCREAMING_SNAKE_CASE_     )

        A_    : Any								=	argparse.ArgumentParser()
        expected.add_argument(
            "--foo"	,					default="toto"	,					choices=["titi", "toto", 42]	,					type=make_choice_type_function(["titi", "toto", 42]     )	,					)
        self.argparsersEqual(SCREAMING_SNAKE_CASE_	,					SCREAMING_SNAKE_CASE_     )

        A_    : Union[str, Any]								=	parser.parse_args([]     )
        self.assertEqual(args.foo	,					"toto"     )
        A_    : Dict								=	parser.parse_args_into_dataclasses([]     )[0]
        self.assertEqual(enum_ex.foo	,					MixedTypeEnum.toto     )

        A_    : Optional[int]								=	parser.parse_args(["--foo", "titi"]     )
        self.assertEqual(args.foo	,					"titi"     )
        A_    : List[str]								=	parser.parse_args_into_dataclasses(["--foo", "titi"]     )[0]
        self.assertEqual(enum_ex.foo	,					MixedTypeEnum.titi     )

        A_    : Optional[Any]								=	parser.parse_args(["--foo", "42"]     )
        self.assertEqual(args.foo	,					42     )
        A_    : int								=	parser.parse_args_into_dataclasses(["--foo", "42"]     )[0]
        self.assertEqual(enum_ex.foo	,					MixedTypeEnum.fourtytwo     )



     def   SCREAMING_SNAKE_CASE						(							self				:List[Any]     ):





        '''simple docstring'''




        @dataclass
        class     __magic_name__     :





             """simple docstring"""



             __UpperCamelCase    			=   '''toto'''




        A_    : Optional[Any]								=	HfArgumentParser(SCREAMING_SNAKE_CASE_     )

        A_    : Optional[int]								=	argparse.ArgumentParser()
        expected.add_argument(
            "--foo"	,					default="toto"	,					choices=("titi", "toto", 42)	,					type=make_choice_type_function(["titi", "toto", 42]     )	,					)
        self.argparsersEqual(SCREAMING_SNAKE_CASE_	,					SCREAMING_SNAKE_CASE_     )

        A_    : Dict								=	parser.parse_args([]     )
        self.assertEqual(args.foo	,					"toto"     )

        A_    : Optional[Any]								=	parser.parse_args(["--foo", "titi"]     )
        self.assertEqual(args.foo	,					"titi"     )

        A_    : Optional[int]								=	parser.parse_args(["--foo", "42"]     )
        self.assertEqual(args.foo	,					42     )



     def   SCREAMING_SNAKE_CASE						(							self				:Optional[int]     ):





        '''simple docstring'''




        A_    : Optional[int]								=	HfArgumentParser(SCREAMING_SNAKE_CASE_     )

        A_    : str								=	argparse.ArgumentParser()
        expected.add_argument("--foo_int"	,					nargs="+"	,					default=[]	,					type=SCREAMING_SNAKE_CASE_     )
        expected.add_argument("--bar_int"	,					nargs="+"	,					default=[1, 2, 3]	,					type=SCREAMING_SNAKE_CASE_     )
        expected.add_argument("--foo_str"	,					nargs="+"	,					default=["Hallo", "Bonjour", "Hello"]	,					type=SCREAMING_SNAKE_CASE_     )
        expected.add_argument("--foo_float"	,					nargs="+"	,					default=[0.1, 0.2, 0.3]	,					type=SCREAMING_SNAKE_CASE_     )

        self.argparsersEqual(SCREAMING_SNAKE_CASE_	,					SCREAMING_SNAKE_CASE_     )

        A_    : List[str]								=	parser.parse_args([]     )
        self.assertEqual(
            SCREAMING_SNAKE_CASE_	,					Namespace(foo_int=[]	,					bar_int=[1, 2, 3]	,					foo_str=["Hallo", "Bonjour", "Hello"]	,					foo_float=[0.1, 0.2, 0.3]     )	,					)

        A_    : Any								=	parser.parse_args("--foo_int 1 --bar_int 2 3 --foo_str a b c --foo_float 0.1 0.7".split()     )
        self.assertEqual(SCREAMING_SNAKE_CASE_	,					Namespace(foo_int=[1]	,					bar_int=[2, 3]	,					foo_str=["a", "b", "c"]	,					foo_float=[0.1, 0.7]     )     )



     def   SCREAMING_SNAKE_CASE						(							self				:str     ):





        '''simple docstring'''




        A_    : int								=	argparse.ArgumentParser()
        expected.add_argument("--foo"	,					default=SCREAMING_SNAKE_CASE_	,					type=SCREAMING_SNAKE_CASE_     )
        expected.add_argument("--bar"	,					default=SCREAMING_SNAKE_CASE_	,					type=SCREAMING_SNAKE_CASE_	,					help="help message"     )
        expected.add_argument("--baz"	,					default=SCREAMING_SNAKE_CASE_	,					type=SCREAMING_SNAKE_CASE_     )
        expected.add_argument("--ces"	,					nargs="+"	,					default=[]	,					type=SCREAMING_SNAKE_CASE_     )
        expected.add_argument("--des"	,					nargs="+"	,					default=[]	,					type=SCREAMING_SNAKE_CASE_     )

        A_    : Tuple								=	[OptionalExample]
        if is_python_no_less_than_3_10:
           dataclass_types.append(SCREAMING_SNAKE_CASE_     )

        for dataclass_type in dataclass_types:
           A_    : List[str]								=	HfArgumentParser(SCREAMING_SNAKE_CASE_     )

           self.argparsersEqual(SCREAMING_SNAKE_CASE_	,					SCREAMING_SNAKE_CASE_     )

           A_    : int								=	parser.parse_args([]     )
           self.assertEqual(SCREAMING_SNAKE_CASE_	,					Namespace(foo=SCREAMING_SNAKE_CASE_	,					bar=SCREAMING_SNAKE_CASE_	,					baz=SCREAMING_SNAKE_CASE_	,					ces=[]	,					des=[]     )     )

           A_    : Union[str, Any]								=	parser.parse_args("--foo 12 --bar 3.14 --baz 42 --ces a b c --des 1 2 3".split()     )
           self.assertEqual(SCREAMING_SNAKE_CASE_	,					Namespace(foo=12	,					bar=3.14	,					baz="42"	,					ces=["a", "b", "c"]	,					des=[1, 2, 3]     )     )



     def   SCREAMING_SNAKE_CASE						(							self				:str     ):





        '''simple docstring'''




        A_    : int								=	HfArgumentParser(SCREAMING_SNAKE_CASE_     )

        A_    : List[Any]								=	argparse.ArgumentParser()
        expected.add_argument("--required_list"	,					nargs="+"	,					type=SCREAMING_SNAKE_CASE_	,					required=SCREAMING_SNAKE_CASE_     )
        expected.add_argument("--required_str"	,					type=SCREAMING_SNAKE_CASE_	,					required=SCREAMING_SNAKE_CASE_     )
        expected.add_argument(
            "--required_enum"	,					type=make_choice_type_function(["titi", "toto"]     )	,					choices=["titi", "toto"]	,					required=SCREAMING_SNAKE_CASE_	,					)
        self.argparsersEqual(SCREAMING_SNAKE_CASE_	,					SCREAMING_SNAKE_CASE_     )



     def   SCREAMING_SNAKE_CASE						(							self				:int     ):





        '''simple docstring'''




        A_    : Optional[Any]								=	HfArgumentParser(SCREAMING_SNAKE_CASE_     )

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



     def   SCREAMING_SNAKE_CASE						(							self				:List[Any]     ):





        '''simple docstring'''




        A_    : Optional[int]								=	HfArgumentParser(SCREAMING_SNAKE_CASE_     )

        A_    : List[Any]								=	{
            'foo': 12,
            'bar': 3.14,
            'baz': '42',
            'flag': True,
        }

        A_    : Optional[Any]								=	parser.parse_dict(SCREAMING_SNAKE_CASE_     )[0]
        A_    : Union[str, Any]								=	BasicExample(**SCREAMING_SNAKE_CASE_     )
        self.assertEqual(SCREAMING_SNAKE_CASE_	,					SCREAMING_SNAKE_CASE_     )



     def   SCREAMING_SNAKE_CASE						(							self				:int     ):





        '''simple docstring'''




        A_    : Union[str, Any]								=	HfArgumentParser(SCREAMING_SNAKE_CASE_     )

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

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



     def   SCREAMING_SNAKE_CASE						(							self				:List[Any]     ):





        '''simple docstring'''




        A_    : Dict								=	HfArgumentParser(SCREAMING_SNAKE_CASE_     )

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

        A_    : Tuple								=	BasicExample(**SCREAMING_SNAKE_CASE_     )
        self.assertEqual(SCREAMING_SNAKE_CASE_	,					SCREAMING_SNAKE_CASE_     )



     def   SCREAMING_SNAKE_CASE						(							self				:List[str]     ):





        '''simple docstring'''




        A_    : Tuple								=	HfArgumentParser(SCREAMING_SNAKE_CASE_     )

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





     def   SCREAMING_SNAKE_CASE						(							self				:int     ):





        '''simple docstring'''




        A_    : Dict								=	HfArgumentParser(SCREAMING_SNAKE_CASE_     )
        self.assertIsNotNone(SCREAMING_SNAKE_CASE_     )





"""simple docstring"""







import re

def 				UpperCamelCase_    (    lowerCAmelCase__      :				str						)						->   list:

  """simple docstring"""




  return [char.split() for char in re.split(R'[^ a-z A-Z 0-9 \s]'    ,   str_						)]

def 				UpperCamelCase_    (    lowerCAmelCase__      :				str						)						->   str:

  """simple docstring"""




  lowerCAmelCase_   :				str								= split_input(str_						)
  return "".join(
      [''.join([char.capitalize() for char in sub_str]						) for sub_str in string_split]						)

def 				UpperCamelCase_    (    lowerCAmelCase__      :				str    ,   lowerCAmelCase__      :				bool    ,   lowerCAmelCase__      :				str						)						->   str:

  """simple docstring"""




  try:
    lowerCAmelCase_   :				int								= split_input(lowerCAmelCase__						)
    if upper:
      lowerCAmelCase_   :				Optional[int]								= ''.join(
          [
              separator.join([char.upper() for char in sub_str]						)
              for sub_str in string_split
          ]						)
    else:
      lowerCAmelCase_   :				Any								= ''.join(
          [
              separator.join([char.lower() for char in sub_str]						)
              for sub_str in string_split
          ]						)
    return res_str
  except IndexError:
    return "not valid string"

def 				UpperCamelCase_    (    lowerCAmelCase__      :				str						)						->   str:

  """simple docstring"""




  return to_simple_case(lowerCAmelCase__						)

def 				UpperCamelCase_    (    lowerCAmelCase__      :				str						)						->   str:

  """simple docstring"""




  try:
    lowerCAmelCase_   :				Dict								= to_simple_case(lowerCAmelCase__						)
    return res_str[0].lower() + res_str[1:]
  except IndexError:
    return "not valid string"

def 				UpperCamelCase_    (    lowerCAmelCase__      :				str    ,   lowerCAmelCase__      :				bool						)						->   str:

  """simple docstring"""




  return to_complex_case(lowerCAmelCase__    ,   lowerCAmelCase__    ,   '_'						)

def 				UpperCamelCase_    (    lowerCAmelCase__      :				str    ,   lowerCAmelCase__      :				bool						)						->   str:

  """simple docstring"""




  return to_complex_case(lowerCAmelCase__    ,   lowerCAmelCase__    ,   '-'						)


if __name__ == "__main__":
     __import__("""doctest""").testmod()





