




"""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							):
    lowercase__						 =				MODEL_FOR_MASKED_LM_MAPPING
    lowercase__						 =				TF_MODEL_FOR_MASKED_LM_MAPPING




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




     '''simple docstring'''

     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 							__magic_name__							(   self						:	Tuple				)				->							int:




     '''simple docstring'''

     A__	=    pipeline(task="fill-mask"     ,			model="sshleifer/tiny-distilroberta-base"     ,			top_k=2     ,			framework="tf"				)
     A__	=    unmasker("My name is <mask>"				)
     self.assertEqual(
         nested_simplify(snake_case_     ,			decimals=6				)     ,			[
             {"sequence": "My name is grouped", "score": 2.1e-05, "token": 38_015, "token_str": " grouped"},
             {"sequence": "My name is accuser", "score": 2.1e-05, "token": 25_506, "token_str": " accuser"},
         ]     ,			)

     A__	=    unmasker("The largest city in France is <mask>"				)
     self.assertEqual(
         nested_simplify(snake_case_     ,			decimals=6				)     ,			[
             {
                 "sequence": "The largest city in France is grouped",
                 "score": 2.1e-05,
                 "token": 38_015,
                 "token_str": " grouped",
             },
             {
                 "sequence": "The largest city in France is accuser",
                 "score": 2.1e-05,
                 "token": 25_506,
                 "token_str": " accuser",
             },
         ]     ,			)

     A__	=    unmasker("My name is <mask>"     ,			targets=[" Patrick", " Clara", " Teven"]     ,			top_k=3				)
     self.assertEqual(
         nested_simplify(snake_case_     ,			decimals=6				)     ,			[
             {"sequence": "My name is Clara", "score": 2e-05, "token": 13_606, "token_str": " Clara"},
             {"sequence": "My name is Patrick", "score": 2e-05, "token": 3_499, "token_str": " Patrick"},
             {"sequence": "My name is Te", "score": 1.9e-05, "token": 2_941, "token_str": " Te"},
         ]     ,			)




    @require_torch
    def 							__magic_name__							(   self						:	Optional[int]				)				->							Optional[Any]:




     '''simple docstring'''

     A__	=    pipeline(task="fill-mask"     ,			model="sshleifer/tiny-distilroberta-base"     ,			top_k=2     ,			framework="pt"				)

     A__	=    unmasker("My name is <mask>"				)
     self.assertEqual(
         nested_simplify(snake_case_     ,			decimals=6				)     ,			[
             {"sequence": "My name is Maul", "score": 2.2e-05, "token": 35_676, "token_str": " Maul"},
             {"sequence": "My name isELS", "score": 2.2e-05, "token": 16_416, "token_str": "ELS"},
         ]     ,			)

     A__	=    unmasker("The largest city in France is <mask>"				)
     self.assertEqual(
         nested_simplify(snake_case_     ,			decimals=6				)     ,			[
             {
                 "sequence": "The largest city in France is Maul",
                 "score": 2.2e-05,
                 "token": 35_676,
                 "token_str": " Maul",
             },
             {"sequence": "The largest city in France isELS", "score": 2.2e-05, "token": 16_416, "token_str": "ELS"},
         ]     ,			)

     A__	=    unmasker("My name is <mask>"     ,			targets=[" Patrick", " Clara", " Teven"]     ,			top_k=3				)
     self.assertEqual(
         nested_simplify(snake_case_     ,			decimals=6				)     ,			[
             {"sequence": "My name is Patrick", "score": 2.1e-05, "token": 3_499, "token_str": " Patrick"},
             {"sequence": "My name is Te", "score": 2e-05, "token": 2_941, "token_str": " Te"},
             {"sequence": "My name is Clara", "score": 2e-05, "token": 13_606, "token_str": " Clara"},
         ]     ,			)

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

     self.assertEqual(
         nested_simplify(snake_case_     ,			decimals=6				)     ,			[
             [
                 {
                     "score": 2.2e-05,
                     "token": 35_676,
                     "token_str": " Maul",
                     "sequence": "<s>My name is Maul<mask></s>",
                 },
                 {"score": 2.2e-05, "token": 16_416, "token_str": "ELS", "sequence": "<s>My name isELS<mask></s>"},
             ],
             [
                 {
                     "score": 2.2e-05,
                     "token": 35_676,
                     "token_str": " Maul",
                     "sequence": "<s>My name is<mask> Maul</s>",
                 },
                 {"score": 2.2e-05, "token": 16_416, "token_str": "ELS", "sequence": "<s>My name is<mask>ELS</s>"},
             ],
         ]     ,			)




    @require_torch_gpu
    def 							__magic_name__							(   self						:	int				)				->							int:




     '''simple docstring'''

     A__	=    pipeline("fill-mask"     ,			model="hf-internal-testing/tiny-random-distilbert"     ,			device=0     ,			framework="pt"				)

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

     A__	=    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(snake_case_     ,			snake_case_				)




    @slow
    @require_torch
    def 							__magic_name__							(   self						:	str				)				->							Optional[Any]:




     '''simple docstring'''

     A__	=    pipeline(task="fill-mask"     ,			model="distilroberta-base"     ,			top_k=2     ,			framework="pt"				)
     self.run_large_test(snake_case_				)




    @slow
    @require_tf
    def 							__magic_name__							(   self						:	List[str]				)				->							List[str]:




     '''simple docstring'''

     A__	=    pipeline(task="fill-mask"     ,			model="distilroberta-base"     ,			top_k=2     ,			framework="tf"				)
     self.run_large_test(snake_case_				)




    def 							__magic_name__							(   self						:	Tuple     ,			snake_case_						:	List[Any]				)				->							Optional[int]:




     '''simple docstring'''

     A__	=    unmasker("My name is <mask>"				)
     self.assertEqual(
         nested_simplify(snake_case_				)     ,			[
             {"sequence": "My name is John", "score": 0.008, "token": 610, "token_str": " John"},
             {"sequence": "My name is Chris", "score": 0.007, "token": 1_573, "token_str": " Chris"},
         ]     ,			)
     A__	=    unmasker("The largest city in France is <mask>"				)
     self.assertEqual(
         nested_simplify(snake_case_				)     ,			[
             {
                 "sequence": "The largest city in France is Paris",
                 "score": 0.251,
                 "token": 2_201,
                 "token_str": " Paris",
             },
             {
                 "sequence": "The largest city in France is Lyon",
                 "score": 0.214,
                 "token": 12_790,
                 "token_str": " Lyon",
             },
         ]     ,			)

     A__	=    unmasker("My name is <mask>"     ,			targets=[" Patrick", " Clara", " Teven"]     ,			top_k=3				)
     self.assertEqual(
         nested_simplify(snake_case_				)     ,			[
             {"sequence": "My name is Patrick", "score": 0.005, "token": 3_499, "token_str": " Patrick"},
             {"sequence": "My name is Clara", "score": 0.000, "token": 13_606, "token_str": " Clara"},
             {"sequence": "My name is Te", "score": 0.000, "token": 2_941, "token_str": " Te"},
         ]     ,			)




    @require_torch
    def 							__magic_name__							(   self						:	Union[str, Any]				)				->							List[str]:




     '''simple docstring'''

     A__	=    pipeline(task="fill-mask"     ,			model="sshleifer/tiny-distilroberta-base"     ,			framework="pt"				)
     A__	=    None
     A__	=    None
     self.run_pipeline_test(snake_case_     ,			[]				)




    @require_tf
    def 							__magic_name__							(   self						:	int				)				->							int:




     '''simple docstring'''

     A__	=    pipeline(task="fill-mask"     ,			model="sshleifer/tiny-distilroberta-base"     ,			framework="tf"				)
     A__	=    None
     A__	=    None
     self.run_pipeline_test(snake_case_     ,			[]				)




    def 							__magic_name__							(   self						:	Optional[int]     ,			snake_case_						:	Tuple     ,			snake_case_						:	Optional[int]     ,			snake_case_						:	Any				)				->							int:




     '''simple docstring'''

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

     A__	=    FillMaskPipeline(model=snake_case_     ,			tokenizer=snake_case_				)
     A__	=    [
         F"""This is another {tokenizer.mask_token} test""",
     ]
     return fill_masker, examples




    def 							__magic_name__							(   self						:	Tuple     ,			snake_case_						:	str     ,			snake_case_						:	Tuple				)				->							Optional[int]:




     '''simple docstring'''

     A__	=    fill_masker.tokenizer
     A__	=    fill_masker.model

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

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

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

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

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




    def 							__magic_name__							(   self						:	Dict     ,			snake_case_						:	Tuple     ,			snake_case_						:	Any				)				->							List[str]:




     '''simple docstring'''

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

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

     # Score equivalence
     A__	=    fill_masker(F"""This is a {tokenizer.mask_token}"""     ,			targets=snake_case_				)
     A__	=    [top_mask["token_str"] for top_mask in outputs]
     A__	=    [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(snake_case_				) == set(snake_case_				):
      A__	=    fill_masker(F"""This is a {tokenizer.mask_token}"""     ,			targets=snake_case_				)
      A__	=    [top_mask["score"] for top_mask in unmasked_targets]
      self.assertEqual(nested_simplify(snake_case_				)     ,			nested_simplify(snake_case_				)				)

     # Raises with invalid
     with self.assertRaises(snake_case_				):
      A__	=    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(snake_case_				):
       A__	=    fill_masker(F"""This is a {tokenizer.mask_token}"""     ,			targets=[""]				)
      with self.assertRaises(snake_case_				):
       A__	=    fill_masker(F"""This is a {tokenizer.mask_token}"""     ,			targets=""				)




    def 							__magic_name__							(   self						:	Dict     ,			snake_case_						:	Optional[int]     ,			snake_case_						:	Union[str, Any]				)				->							str:




     '''simple docstring'''

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

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




    def 							__magic_name__							(   self						:	Union[str, Any]     ,			snake_case_						:	Optional[Any]     ,			snake_case_						:	Optional[Any]				)				->							int:




     '''simple docstring'''

     A__	=    tokenizer.get_vocab()
     A__	=    FillMaskPipeline(model=snake_case_     ,			tokenizer=snake_case_				)

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

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




    def 							__magic_name__							(   self						:	Optional[int]     ,			snake_case_						:	str     ,			snake_case_						:	str				)				->							Dict:




     '''simple docstring'''

     A__	=    FillMaskPipeline(model=snake_case_     ,			tokenizer=snake_case_				)
     A__	=    tokenizer.get_vocab()
     # String duplicates + id duplicates
     A__	=    sorted(vocab.keys()				)[:3]
     A__	=    [targets[0], targets[1], targets[0], targets[2], targets[1]]
     A__	=    fill_masker(F"""My name is {tokenizer.mask_token}"""     ,			targets=snake_case_     ,			top_k=10				)

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




    def 							__magic_name__							(   self						:	Tuple     ,			snake_case_						:	Dict     ,			snake_case_						:	Union[str, Any]				)				->							Optional[int]:




     '''simple docstring'''

     A__	=    FillMaskPipeline(model=snake_case_     ,			tokenizer=snake_case_				)

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











"""simple docstring"""



import re

from flax.core.frozen_dict import freeze
from flax.traverse_util import flatten_dict, unflatten_dict
from jax.experimental import PartitionSpec as P


# Sentinels
SCREAMING_SNAKE_CASE    =	object()

# For specifying empty leaf dict `{}`
SCREAMING_SNAKE_CASE    =	object()







def   _SCREAMING_SNAKE_CASE       (							lowercase_      ,			lowercase_						)						->		List[Any]:
 A__	=    tuple((re.compile(x + "$"						) for x in qs)						)
 for i in range(len(lowercase_						) - len(lowercase_						) + 1						):
  A__	=    [x.match(lowercase_						) for x, y in zip(lowercase_      ,			ks[i:]						)]
  if matches and all(lowercase_						):
   return True
 return False







def   _SCREAMING_SNAKE_CASE       (							lowercase_						)						->		Optional[int]:
 def replace(lowercase_      ,			lowercase_						):
  for rule, replacement in rules:
   if _match(lowercase_      ,			lowercase_						):
    return replacement
  return val

 return replace







def   _SCREAMING_SNAKE_CASE       (							)						->		List[str]:
 return [
     # embeddings
     (("transformer", "wpe", "embedding"), P("mp"      ,			lowercase_						)),
     (("transformer", "wte", "embedding"), P("mp"      ,			lowercase_						)),
     # atention
     (("attention", "(q_proj|k_proj|v_proj)", "kernel"), P(lowercase_      ,			"mp"						)),
     (("attention", "out_proj", "kernel"), P("mp"      ,			lowercase_						)),
     (("attention", "out_proj", "bias"), None),
     # mlp
     (("mlp", "c_fc", "kernel"), P(lowercase_      ,			"mp"						)),
     (("mlp", "c_fc", "bias"), P("mp"						)),
     (("mlp", "c_proj", "kernel"), P("mp"      ,			lowercase_						)),
     (("mlp", "c_proj", "bias"), None),
     # layer norms
     ((r"ln_\d+", "bias"), None),
     ((r"\d+", r"ln_\d+", "scale"), None),
     (("ln_f", "bias"), None),
     (("ln_f", "scale"), None),
 ]







def   _SCREAMING_SNAKE_CASE       (							lowercase_						)						->		int:
 A__	=    _get_partition_rules()
 A__	=    _replacement_rules(lowercase_						)
 A__	=    {k: _unmatched for k in flatten_dict(lowercase_						)}
 A__	=    {k: replace(lowercase_      ,			lowercase_						) for k, v in initd.items()}
 assert _unmatched not in result.values(), "Incomplete partition spec."
 return freeze(unflatten_dict(lowercase_						)						)





