"""simple docstring"""


import gc
import unittest

from transformers import MODEL_FOR_MASKED_LM_MAPPING, TF_MODEL_FOR_MASKED_LM_MAPPING, FillMaskPipeline, pipeline
from transformers.pipelines import PipelineException
from transformers.testing_utils import (
    is_pipeline_test,
    is_torch_available,
    nested_simplify,
    require_tf,
    require_torch,
    require_torch_gpu,
    slow,
)

from .test_pipelines_common import ANY






@is_pipeline_test
class   __UpperCAmelCase		(      unittest.TestCase      ):
				A__ :  Optional[Any]    				=			MODEL_FOR_MASKED_LM_MAPPING
				A__ :  List[Any]    				=			TF_MODEL_FOR_MASKED_LM_MAPPING

				def 						_a      ( self ):
										super().tearDown()
										# clean-up as much as possible GPU memory occupied by PyTorch
										gc.collect()
										if is_torch_available():
																import torch

																torch.cuda.empty_cache()

				@require_tf
				def 						_a      ( self ):
										lowerCamelCase__   =pipeline(task="fill-mask"      ,					model="sshleifer/tiny-distilroberta-base"      ,					top_k=2      ,					framework="tf" )
										lowerCamelCase__   =unmasker("My name is <mask>" )
										self.assertEqual(
										    nested_simplify(_lowerCamelCase      ,					decimals=6 )      ,					[
										        {"sequence": "My name is grouped", "score": 2.1E-05, "token": 38015, "token_str": " grouped"},
										        {"sequence": "My name is accuser", "score": 2.1E-05, "token": 25506, "token_str": " accuser"},
										    ]      ,					)

										lowerCamelCase__   =unmasker("The largest city in France is <mask>" )
										self.assertEqual(
										    nested_simplify(_lowerCamelCase      ,					decimals=6 )      ,					[
										        {
										            "sequence": "The largest city in France is grouped",
										            "score": 2.1E-05,
										            "token": 38015,
										            "token_str": " grouped",
										        },
										        {
										            "sequence": "The largest city in France is accuser",
										            "score": 2.1E-05,
										            "token": 25506,
										            "token_str": " accuser",
										        },
										    ]      ,					)

										lowerCamelCase__   =unmasker("My name is <mask>"      ,					targets=[" Patrick", " Clara", " Teven"]      ,					top_k=3 )
										self.assertEqual(
										    nested_simplify(_lowerCamelCase      ,					decimals=6 )      ,					[
										        {"sequence": "My name is Clara", "score": 2E-05, "token": 13606, "token_str": " Clara"},
										        {"sequence": "My name is Patrick", "score": 2E-05, "token": 3499, "token_str": " Patrick"},
										        {"sequence": "My name is Te", "score": 1.9E-05, "token": 2941, "token_str": " Te"},
										    ]      ,					)

				@require_torch
				def 						_a      ( self ):
										lowerCamelCase__   =pipeline(task="fill-mask"      ,					model="sshleifer/tiny-distilroberta-base"      ,					top_k=2      ,					framework="pt" )

										lowerCamelCase__   =unmasker("My name is <mask>" )
										self.assertEqual(
										    nested_simplify(_lowerCamelCase      ,					decimals=6 )      ,					[
										        {"sequence": "My name is Maul", "score": 2.2E-05, "token": 35676, "token_str": " Maul"},
										        {"sequence": "My name isELS", "score": 2.2E-05, "token": 16416, "token_str": "ELS"},
										    ]      ,					)

										lowerCamelCase__   =unmasker("The largest city in France is <mask>" )
										self.assertEqual(
										    nested_simplify(_lowerCamelCase      ,					decimals=6 )      ,					[
										        {
										            "sequence": "The largest city in France is Maul",
										            "score": 2.2E-05,
										            "token": 35676,
										            "token_str": " Maul",
										        },
										        {"sequence": "The largest city in France isELS", "score": 2.2E-05, "token": 16416, "token_str": "ELS"},
										    ]      ,					)

										lowerCamelCase__   =unmasker("My name is <mask>"      ,					targets=[" Patrick", " Clara", " Teven"]      ,					top_k=3 )
										self.assertEqual(
										    nested_simplify(_lowerCamelCase      ,					decimals=6 )      ,					[
										        {"sequence": "My name is Patrick", "score": 2.1E-05, "token": 3499, "token_str": " Patrick"},
										        {"sequence": "My name is Te", "score": 2E-05, "token": 2941, "token_str": " Te"},
										        {"sequence": "My name is Clara", "score": 2E-05, "token": 13606, "token_str": " Clara"},
										    ]      ,					)

										lowerCamelCase__   =unmasker("My name is <mask> <mask>"      ,					top_k=2 )

										self.assertEqual(
										    nested_simplify(_lowerCamelCase      ,					decimals=6 )      ,					[
										        [
										            {
										                "score": 2.2E-05,
										                "token": 35676,
										                "token_str": " Maul",
										                "sequence": "<s>My name is Maul<mask></s>",
										            },
										            {"score": 2.2E-05, "token": 16416, "token_str": "ELS", "sequence": "<s>My name isELS<mask></s>"},
										        ],
										        [
										            {
										                "score": 2.2E-05,
										                "token": 35676,
										                "token_str": " Maul",
										                "sequence": "<s>My name is<mask> Maul</s>",
										            },
										            {"score": 2.2E-05, "token": 16416, "token_str": "ELS", "sequence": "<s>My name is<mask>ELS</s>"},
										        ],
										    ]      ,					)

				@require_torch_gpu
				def 						_a      ( self ):
										lowerCamelCase__   =pipeline("fill-mask"      ,					model="hf-internal-testing/tiny-random-distilbert"      ,					device=0      ,					framework="pt" )

										# convert model to fp16
										pipe.model.half()

										lowerCamelCase__   =pipe("Paris is the [MASK] of France." )
										# We actually don't care about the result, we just want to make sure
										# it works, meaning the float16 tensor got casted back to float32
										# for postprocessing.
										self.assertIsInstance(_lowerCamelCase      ,					_lowerCamelCase )

				@slow
				@require_torch
				def 						_a      ( self ):
										lowerCamelCase__   =pipeline(task="fill-mask"      ,					model="distilroberta-base"      ,					top_k=2      ,					framework="pt" )
										self.run_large_test(_lowerCamelCase )

				@slow
				@require_tf
				def 						_a      ( self ):
										lowerCamelCase__   =pipeline(task="fill-mask"      ,					model="distilroberta-base"      ,					top_k=2      ,					framework="tf" )
										self.run_large_test(_lowerCamelCase )

				def 						_a      ( self      ,					_lowerCamelCase ):
										lowerCamelCase__   =unmasker("My name is <mask>" )
										self.assertEqual(
										    nested_simplify(_lowerCamelCase )      ,					[
										        {"sequence": "My name is John", "score": 0.0_0_8, "token": 610, "token_str": " John"},
										        {"sequence": "My name is Chris", "score": 0.0_0_7, "token": 1573, "token_str": " Chris"},
										    ]      ,					)
										lowerCamelCase__   =unmasker("The largest city in France is <mask>" )
										self.assertEqual(
										    nested_simplify(_lowerCamelCase )      ,					[
										        {
										            "sequence": "The largest city in France is Paris",
										            "score": 0.2_5_1,
										            "token": 2201,
										            "token_str": " Paris",
										        },
										        {
										            "sequence": "The largest city in France is Lyon",
										            "score": 0.2_1_4,
										            "token": 12790,
										            "token_str": " Lyon",
										        },
										    ]      ,					)

										lowerCamelCase__   =unmasker("My name is <mask>"      ,					targets=[" Patrick", " Clara", " Teven"]      ,					top_k=3 )
										self.assertEqual(
										    nested_simplify(_lowerCamelCase )      ,					[
										        {"sequence": "My name is Patrick", "score": 0.0_0_5, "token": 3499, "token_str": " Patrick"},
										        {"sequence": "My name is Clara", "score": 0.0_0_0, "token": 13606, "token_str": " Clara"},
										        {"sequence": "My name is Te", "score": 0.0_0_0, "token": 2941, "token_str": " Te"},
										    ]      ,					)

				@require_torch
				def 						_a      ( self ):
										lowerCamelCase__   =pipeline(task="fill-mask"      ,					model="sshleifer/tiny-distilroberta-base"      ,					framework="pt" )
										lowerCamelCase__   =None
										lowerCamelCase__   =None
										self.run_pipeline_test(_lowerCamelCase      ,					[] )

				@require_tf
				def 						_a      ( self ):
										lowerCamelCase__   =pipeline(task="fill-mask"      ,					model="sshleifer/tiny-distilroberta-base"      ,					framework="tf" )
										lowerCamelCase__   =None
										lowerCamelCase__   =None
										self.run_pipeline_test(_lowerCamelCase      ,					[] )

				def 						_a      ( self      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase ):
										if tokenizer is None or tokenizer.mask_token_id is None:
																self.skipTest("The provided tokenizer has no mask token, (probably reformer or wav2vec2)" )

										lowerCamelCase__   =FillMaskPipeline(model=_lowerCamelCase      ,					tokenizer=_lowerCamelCase )
										lowerCamelCase__   =[
										    F'''This is another {tokenizer.mask_token} test''',
										]
										return fill_masker, examples

				def 						_a      ( self      ,					_lowerCamelCase      ,					_lowerCamelCase ):
										lowerCamelCase__   =fill_masker.tokenizer
										lowerCamelCase__   =fill_masker.model

										lowerCamelCase__   =fill_masker(
										    F'''This is a {tokenizer.mask_token}'''      ,					)
										self.assertEqual(
										    _lowerCamelCase      ,					[
										        {"sequence": ANY(_lowerCamelCase ), "score": ANY(_lowerCamelCase ), "token": ANY(_lowerCamelCase ), "token_str": ANY(_lowerCamelCase )},
										        {"sequence": ANY(_lowerCamelCase ), "score": ANY(_lowerCamelCase ), "token": ANY(_lowerCamelCase ), "token_str": ANY(_lowerCamelCase )},
										        {"sequence": ANY(_lowerCamelCase ), "score": ANY(_lowerCamelCase ), "token": ANY(_lowerCamelCase ), "token_str": ANY(_lowerCamelCase )},
										        {"sequence": ANY(_lowerCamelCase ), "score": ANY(_lowerCamelCase ), "token": ANY(_lowerCamelCase ), "token_str": ANY(_lowerCamelCase )},
										        {"sequence": ANY(_lowerCamelCase ), "score": ANY(_lowerCamelCase ), "token": ANY(_lowerCamelCase ), "token_str": ANY(_lowerCamelCase )},
										    ]      ,					)

										lowerCamelCase__   =fill_masker([F'''This is a {tokenizer.mask_token}'''] )
										self.assertEqual(
										    _lowerCamelCase      ,					[
										        {"sequence": ANY(_lowerCamelCase ), "score": ANY(_lowerCamelCase ), "token": ANY(_lowerCamelCase ), "token_str": ANY(_lowerCamelCase )},
										        {"sequence": ANY(_lowerCamelCase ), "score": ANY(_lowerCamelCase ), "token": ANY(_lowerCamelCase ), "token_str": ANY(_lowerCamelCase )},
										        {"sequence": ANY(_lowerCamelCase ), "score": ANY(_lowerCamelCase ), "token": ANY(_lowerCamelCase ), "token_str": ANY(_lowerCamelCase )},
										        {"sequence": ANY(_lowerCamelCase ), "score": ANY(_lowerCamelCase ), "token": ANY(_lowerCamelCase ), "token_str": ANY(_lowerCamelCase )},
										        {"sequence": ANY(_lowerCamelCase ), "score": ANY(_lowerCamelCase ), "token": ANY(_lowerCamelCase ), "token_str": ANY(_lowerCamelCase )},
										    ]      ,					)

										lowerCamelCase__   =fill_masker([F'''This is a {tokenizer.mask_token}''', F'''Another {tokenizer.mask_token} great test.'''] )
										self.assertEqual(
										    _lowerCamelCase      ,					[
										        [
										            {"sequence": ANY(_lowerCamelCase ), "score": ANY(_lowerCamelCase ), "token": ANY(_lowerCamelCase ), "token_str": ANY(_lowerCamelCase )},
										            {"sequence": ANY(_lowerCamelCase ), "score": ANY(_lowerCamelCase ), "token": ANY(_lowerCamelCase ), "token_str": ANY(_lowerCamelCase )},
										            {"sequence": ANY(_lowerCamelCase ), "score": ANY(_lowerCamelCase ), "token": ANY(_lowerCamelCase ), "token_str": ANY(_lowerCamelCase )},
										            {"sequence": ANY(_lowerCamelCase ), "score": ANY(_lowerCamelCase ), "token": ANY(_lowerCamelCase ), "token_str": ANY(_lowerCamelCase )},
										            {"sequence": ANY(_lowerCamelCase ), "score": ANY(_lowerCamelCase ), "token": ANY(_lowerCamelCase ), "token_str": ANY(_lowerCamelCase )},
										        ],
										        [
										            {"sequence": ANY(_lowerCamelCase ), "score": ANY(_lowerCamelCase ), "token": ANY(_lowerCamelCase ), "token_str": ANY(_lowerCamelCase )},
										            {"sequence": ANY(_lowerCamelCase ), "score": ANY(_lowerCamelCase ), "token": ANY(_lowerCamelCase ), "token_str": ANY(_lowerCamelCase )},
										            {"sequence": ANY(_lowerCamelCase ), "score": ANY(_lowerCamelCase ), "token": ANY(_lowerCamelCase ), "token_str": ANY(_lowerCamelCase )},
										            {"sequence": ANY(_lowerCamelCase ), "score": ANY(_lowerCamelCase ), "token": ANY(_lowerCamelCase ), "token_str": ANY(_lowerCamelCase )},
										            {"sequence": ANY(_lowerCamelCase ), "score": ANY(_lowerCamelCase ), "token": ANY(_lowerCamelCase ), "token_str": ANY(_lowerCamelCase )},
										        ],
										    ]      ,					)

										with self.assertRaises(_lowerCamelCase ):
																fill_masker([None] )
										# No mask_token is not supported
										with self.assertRaises(_lowerCamelCase ):
																fill_masker("This is" )

										self.run_test_top_k(_lowerCamelCase      ,					_lowerCamelCase )
										self.run_test_targets(_lowerCamelCase      ,					_lowerCamelCase )
										self.run_test_top_k_targets(_lowerCamelCase      ,					_lowerCamelCase )
										self.fill_mask_with_duplicate_targets_and_top_k(_lowerCamelCase      ,					_lowerCamelCase )
										self.fill_mask_with_multiple_masks(_lowerCamelCase      ,					_lowerCamelCase )

				def 						_a      ( self      ,					_lowerCamelCase      ,					_lowerCamelCase ):
										lowerCamelCase__   =tokenizer.get_vocab()
										lowerCamelCase__   =sorted(vocab.keys() )[:2]
										# Pipeline argument
										lowerCamelCase__   =FillMaskPipeline(model=_lowerCamelCase      ,					tokenizer=_lowerCamelCase      ,					targets=_lowerCamelCase )
										lowerCamelCase__   =fill_masker(F'''This is a {tokenizer.mask_token}''' )
										self.assertEqual(
										    _lowerCamelCase      ,					[
										        {"sequence": ANY(_lowerCamelCase ), "score": ANY(_lowerCamelCase ), "token": ANY(_lowerCamelCase ), "token_str": ANY(_lowerCamelCase )},
										        {"sequence": ANY(_lowerCamelCase ), "score": ANY(_lowerCamelCase ), "token": ANY(_lowerCamelCase ), "token_str": ANY(_lowerCamelCase )},
										    ]      ,					)
										lowerCamelCase__   ={vocab[el] for el in targets}
										self.assertEqual({el["token"] for el in outputs}      ,					_lowerCamelCase )
										lowerCamelCase__   =[tokenizer.decode([x] ) for x in target_ids]
										self.assertEqual({el["token_str"] for el in outputs}      ,					set(_lowerCamelCase ) )

										# Call argument
										lowerCamelCase__   =FillMaskPipeline(model=_lowerCamelCase      ,					tokenizer=_lowerCamelCase )
										lowerCamelCase__   =fill_masker(F'''This is a {tokenizer.mask_token}'''      ,					targets=_lowerCamelCase )
										self.assertEqual(
										    _lowerCamelCase      ,					[
										        {"sequence": ANY(_lowerCamelCase ), "score": ANY(_lowerCamelCase ), "token": ANY(_lowerCamelCase ), "token_str": ANY(_lowerCamelCase )},
										        {"sequence": ANY(_lowerCamelCase ), "score": ANY(_lowerCamelCase ), "token": ANY(_lowerCamelCase ), "token_str": ANY(_lowerCamelCase )},
										    ]      ,					)
										lowerCamelCase__   ={vocab[el] for el in targets}
										self.assertEqual({el["token"] for el in outputs}      ,					_lowerCamelCase )
										lowerCamelCase__   =[tokenizer.decode([x] ) for x in target_ids]
										self.assertEqual({el["token_str"] for el in outputs}      ,					set(_lowerCamelCase ) )

										# Score equivalence
										lowerCamelCase__   =fill_masker(F'''This is a {tokenizer.mask_token}'''      ,					targets=_lowerCamelCase )
										lowerCamelCase__   =[top_mask["token_str"] for top_mask in outputs]
										lowerCamelCase__   =[top_mask["score"] for top_mask in outputs]

										# For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`.
										if set(_lowerCamelCase ) == set(_lowerCamelCase ):
																lowerCamelCase__   =fill_masker(F'''This is a {tokenizer.mask_token}'''      ,					targets=_lowerCamelCase )
																lowerCamelCase__   =[top_mask["score"] for top_mask in unmasked_targets]
																self.assertEqual(nested_simplify(_lowerCamelCase )      ,					nested_simplify(_lowerCamelCase ) )

										# Raises with invalid
										with self.assertRaises(_lowerCamelCase ):
																lowerCamelCase__   =fill_masker(F'''This is a {tokenizer.mask_token}'''      ,					targets=[] )
										# For some tokenizers, `""` is actually in the vocabulary and the expected error won't raised
										if "" not in tokenizer.get_vocab():
																with self.assertRaises(_lowerCamelCase ):
																						lowerCamelCase__   =fill_masker(F'''This is a {tokenizer.mask_token}'''      ,					targets=[""] )
																with self.assertRaises(_lowerCamelCase ):
																						lowerCamelCase__   =fill_masker(F'''This is a {tokenizer.mask_token}'''      ,					targets="" )

				def 						_a      ( self      ,					_lowerCamelCase      ,					_lowerCamelCase ):
										lowerCamelCase__   =FillMaskPipeline(model=_lowerCamelCase      ,					tokenizer=_lowerCamelCase      ,					top_k=2 )
										lowerCamelCase__   =fill_masker(F'''This is a {tokenizer.mask_token}''' )
										self.assertEqual(
										    _lowerCamelCase      ,					[
										        {"sequence": ANY(_lowerCamelCase ), "score": ANY(_lowerCamelCase ), "token": ANY(_lowerCamelCase ), "token_str": ANY(_lowerCamelCase )},
										        {"sequence": ANY(_lowerCamelCase ), "score": ANY(_lowerCamelCase ), "token": ANY(_lowerCamelCase ), "token_str": ANY(_lowerCamelCase )},
										    ]      ,					)

										lowerCamelCase__   =FillMaskPipeline(model=_lowerCamelCase      ,					tokenizer=_lowerCamelCase )
										lowerCamelCase__   =fill_masker(F'''This is a {tokenizer.mask_token}'''      ,					top_k=2 )
										self.assertEqual(
										    _lowerCamelCase      ,					[
										        {"sequence": ANY(_lowerCamelCase ), "score": ANY(_lowerCamelCase ), "token": ANY(_lowerCamelCase ), "token_str": ANY(_lowerCamelCase )},
										        {"sequence": ANY(_lowerCamelCase ), "score": ANY(_lowerCamelCase ), "token": ANY(_lowerCamelCase ), "token_str": ANY(_lowerCamelCase )},
										    ]      ,					)
										self.assertEqual(nested_simplify(_lowerCamelCase )      ,					nested_simplify(_lowerCamelCase ) )

				def 						_a      ( self      ,					_lowerCamelCase      ,					_lowerCamelCase ):
										lowerCamelCase__   =tokenizer.get_vocab()
										lowerCamelCase__   =FillMaskPipeline(model=_lowerCamelCase      ,					tokenizer=_lowerCamelCase )

										# top_k=2, ntargets=3
										lowerCamelCase__   =sorted(vocab.keys() )[:3]
										lowerCamelCase__   =fill_masker(F'''This is a {tokenizer.mask_token}'''      ,					top_k=2      ,					targets=_lowerCamelCase )

										# If we use the most probably targets, and filter differently, we should still
										# have the same results
										lowerCamelCase__   =[el["token_str"] for el in sorted(_lowerCamelCase      ,					key=lambda _lowerCamelCase : x["score"]      ,					reverse=_lowerCamelCase )]
										# For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`.
										if set(_lowerCamelCase ).issubset(_lowerCamelCase ):
																lowerCamelCase__   =fill_masker(F'''This is a {tokenizer.mask_token}'''      ,					top_k=3      ,					targets=_lowerCamelCase )
																# They should yield exactly the same result
																self.assertEqual(nested_simplify(_lowerCamelCase )      ,					nested_simplify(_lowerCamelCase ) )

				def 						_a      ( self      ,					_lowerCamelCase      ,					_lowerCamelCase ):
										lowerCamelCase__   =FillMaskPipeline(model=_lowerCamelCase      ,					tokenizer=_lowerCamelCase )
										lowerCamelCase__   =tokenizer.get_vocab()
										# String duplicates + id duplicates
										lowerCamelCase__   =sorted(vocab.keys() )[:3]
										lowerCamelCase__   =[targets[0], targets[1], targets[0], targets[2], targets[1]]
										lowerCamelCase__   =fill_masker(F'''My name is {tokenizer.mask_token}'''      ,					targets=_lowerCamelCase      ,					top_k=10 )

										# The target list contains duplicates, so we can't output more
										# than them
										self.assertEqual(len(_lowerCamelCase )      ,					3 )






				def 						_a      ( self      ,					_lowerCamelCase      ,					_lowerCamelCase ):
										lowerCamelCase__   =FillMaskPipeline(model=_lowerCamelCase      ,					tokenizer=_lowerCamelCase )

										lowerCamelCase__   =fill_masker(
										    F'''This is a {tokenizer.mask_token} {tokenizer.mask_token} {tokenizer.mask_token}'''      ,					top_k=2 )
										self.assertEqual(
										    _lowerCamelCase      ,					[
										        [
										            {"sequence": ANY(_lowerCamelCase ), "score": ANY(_lowerCamelCase ), "token": ANY(_lowerCamelCase ), "token_str": ANY(_lowerCamelCase )},
										            {"sequence": ANY(_lowerCamelCase ), "score": ANY(_lowerCamelCase ), "token": ANY(_lowerCamelCase ), "token_str": ANY(_lowerCamelCase )},
										        ],
										        [
										            {"sequence": ANY(_lowerCamelCase ), "score": ANY(_lowerCamelCase ), "token": ANY(_lowerCamelCase ), "token_str": ANY(_lowerCamelCase )},
										            {"sequence": ANY(_lowerCamelCase ), "score": ANY(_lowerCamelCase ), "token": ANY(_lowerCamelCase ), "token_str": ANY(_lowerCamelCase )},
										        ],
										        [
										            {"sequence": ANY(_lowerCamelCase ), "score": ANY(_lowerCamelCase ), "token": ANY(_lowerCamelCase ), "token_str": ANY(_lowerCamelCase )},
										            {"sequence": ANY(_lowerCamelCase ), "score": ANY(_lowerCamelCase ), "token": ANY(_lowerCamelCase ), "token_str": ANY(_lowerCamelCase )},
										        ],
										    ]      ,					)



"""simple docstring"""


import os
from distutils.util import strtobool





def      lowerCamelCase_					(   __lowerCAmelCase  ,       __lowerCAmelCase							)				->   Union[str, Any]:




						'''simple docstring'''



						for e in env_keys:
												lowerCamelCase__   =int(os.environ.get(__lowerCAmelCase  ,       -1							)							)
												if val >= 0:
																		return val
						return default





def      lowerCamelCase_					(   __lowerCAmelCase  ,       __lowerCAmelCase=False							)				->   List[str]:




						'''simple docstring'''



						lowerCamelCase__   =os.environ.get(__lowerCAmelCase  ,       str(__lowerCAmelCase							)							)
						return strtobool(__lowerCAmelCase							) == 1  # As its name indicates `strtobool` actually returns an int...





def      lowerCamelCase_					(   __lowerCAmelCase  ,       __lowerCAmelCase="no"							)				->   Union[str, Any]:




						'''simple docstring'''



						lowerCamelCase__   =os.environ.get(__lowerCAmelCase  ,       str(__lowerCAmelCase							)							)
						return value


