






import pickle
import shutil
import tempfile
import unittest

from transformers import SPIECE_UNDERLINE, XGLMTokenizer, XGLMTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


lowerCamelCase__							=     get_tests_dir("""fixtures/test_sentencepiece.model""")




@require_sentencepiece
@require_tokenizers
class 			snake_case__   (							lowercase_	,    unittest.TestCase):

       '''simple docstring'''
       lowerCamelCase							:				List[Any] 				= XGLMTokenizer
       lowerCamelCase							:				int 				= XGLMTokenizerFast
       lowerCamelCase							:				Tuple 				= True
       lowerCamelCase							:				Optional[Any] 				= True



       def 					__lowercase						(							self    ) ->      int:






            '''simple docstring'''





            super().setUp()

            # We have a SentencePiece fixture for testing
            __snake_case			:Any          =						XGLMTokenizer(a__			,						keep_accents=a__    )
            tokenizer.save_pretrained(self.tmpdirname    )



       def 					__lowercase						(							self    ) ->      Optional[int]:






            '''simple docstring'''





            __snake_case			:Dict          =						"""<pad>"""
            __snake_case			:Union[str, Any]          =						1

            self.assertEqual(self.get_tokenizer()._convert_token_to_id(a__    )			,						a__    )
            self.assertEqual(self.get_tokenizer()._convert_id_to_token(a__    )			,						a__    )



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






            '''simple docstring'''





            __snake_case			:Any          =						list(self.get_tokenizer().get_vocab().keys()    )

            self.assertEqual(vocab_keys[0]			,						"""<s>"""    )
            self.assertEqual(vocab_keys[1]			,						"""<pad>"""    )
            self.assertEqual(len(a__    )			,						10_08    )



       def 					__lowercase						(							self    ) ->      Tuple:






            '''simple docstring'''





            self.assertEqual(self.get_tokenizer().vocab_size			,						10_08    )



       def 					__lowercase						(							self    ) ->      Dict:






            '''simple docstring'''





            __snake_case			:Tuple          =						XGLMTokenizer(a__			,						keep_accents=a__    )

            __snake_case			:Optional[int]          =						tokenizer.tokenize("""This is a test"""    )
            self.assertListEqual(a__			,						["""▁This""", """▁is""", """▁a""", """▁t""", """est"""]    )

            self.assertListEqual(
                tokenizer.convert_tokens_to_ids(a__    )			,						[value + tokenizer.fairseq_offset for value in [2_85, 46, 10, 1_70, 3_82]]			,						)

            __snake_case			:List[Any]          =						tokenizer.tokenize("""I was born in 92000, and this is falsé."""    )
            self.assertListEqual(
                a__			,						[
                    SPIECE_UNDERLINE + """I""",
                    SPIECE_UNDERLINE + """was""",
                    SPIECE_UNDERLINE + """b""",
                    """or""",
                    """n""",
                    SPIECE_UNDERLINE + """in""",
                    SPIECE_UNDERLINE + """""",
                    """9""",
                    """2""",
                    """0""",
                    """0""",
                    """0""",
                    """,""",
                    SPIECE_UNDERLINE + """and""",
                    SPIECE_UNDERLINE + """this""",
                    SPIECE_UNDERLINE + """is""",
                    SPIECE_UNDERLINE + """f""",
                    """al""",
                    """s""",
                    """é""",
                    """.""",
                ]			,						)
            __snake_case			:str          =						tokenizer.convert_tokens_to_ids(a__    )
            self.assertListEqual(
                a__			,						[
                    value + tokenizer.fairseq_offset
                    for value in [8, 21, 84, 55, 24, 19, 7, 2, 6_02, 3_47, 3_47, 3_47, 3, 12, 66, 46, 72, 80, 6, 2, 4]
                ]			,						)

            __snake_case			:str          =						tokenizer.convert_ids_to_tokens(a__    )
            self.assertListEqual(
                a__			,						[
                    SPIECE_UNDERLINE + """I""",
                    SPIECE_UNDERLINE + """was""",
                    SPIECE_UNDERLINE + """b""",
                    """or""",
                    """n""",
                    SPIECE_UNDERLINE + """in""",
                    SPIECE_UNDERLINE + """""",
                    """<unk>""",
                    """2""",
                    """0""",
                    """0""",
                    """0""",
                    """,""",
                    SPIECE_UNDERLINE + """and""",
                    SPIECE_UNDERLINE + """this""",
                    SPIECE_UNDERLINE + """is""",
                    SPIECE_UNDERLINE + """f""",
                    """al""",
                    """s""",
                    """<unk>""",
                    """.""",
                ]			,						)



       @cached_property
       def 					__lowercase						(							self    ) ->      int:






            '''simple docstring'''





            return XGLMTokenizer.from_pretrained("""facebook/xglm-564M"""    )



       def 					__lowercase						(							self    ) ->      Optional[int]:






            '''simple docstring'''





            with tempfile.NamedTemporaryFile() as f:
                 shutil.copyfile(a__			,						f.name    )
                 __snake_case			:Union[str, Any]          =						XGLMTokenizer(f.name			,						keep_accents=a__    )
                 __snake_case			:Dict          =						pickle.dumps(a__    )
            pickle.loads(a__    )



       def 					__lowercase						(							self    ) ->      int:






            '''simple docstring'''





            if not self.test_rust_tokenizer:
                 return

            __snake_case			:str          =						self.get_tokenizer()
            __snake_case			:str          =						self.get_rust_tokenizer()

            __snake_case			:Tuple          =						"""I was born in 92000, and this is falsé."""

            __snake_case			:Optional[Any]          =						tokenizer.tokenize(a__    )
            __snake_case			:Union[str, Any]          =						rust_tokenizer.tokenize(a__    )
            self.assertListEqual(a__			,						a__    )

            __snake_case			:Union[str, Any]          =						tokenizer.encode(a__			,						add_special_tokens=a__    )
            __snake_case			:Tuple          =						rust_tokenizer.encode(a__			,						add_special_tokens=a__    )
            self.assertListEqual(a__			,						a__    )

            __snake_case			:Tuple          =						self.get_rust_tokenizer()
            __snake_case			:List[str]          =						tokenizer.encode(a__    )
            __snake_case			:Any          =						rust_tokenizer.encode(a__    )
            self.assertListEqual(a__			,						a__    )



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






            '''simple docstring'''





            __snake_case			:List[Any]          =						"""Hello World!"""
            __snake_case			:Dict          =						[2, 3_12_27, 44_47, 35]

            self.assertListEqual(a__			,						self.big_tokenizer.encode(a__    )    )



       @slow
       def 					__lowercase						(							self    ) ->      Optional[Any]:






            '''simple docstring'''





            __snake_case			:Tuple          =						(
                """This is a very long text with a lot of weird characters, such as: . , ~ ? ( ) \" [ ] ! : - . Also we will"""
                """ add words that should not exsist and be tokenized to unk, such as saoneuhaoesuth"""
            )
            # fmt: off
            __snake_case			:Tuple          =						[2, 10_18, 67, 11, 19_88, 26_17, 56_31, 2_78, 11, 34_07, 48, 7_16_30, 2_80_85, 4, 32_34, 1_57, 13, 6, 5, 6, 4, 35_26, 7_68, 15, 6_59, 57, 2_98, 39_83, 8_64, 1_29, 21, 6, 5, 1_36_75, 3_77, 6_52, 75_80, 1_03_41, 1_55, 28_17, 4_22, 16_66, 7, 16_74, 53, 1_13, 20_22_77, 1_78_92, 33, 60, 87, 4, 32_34, 1_57, 61, 26_67, 5_23_76, 19, 88, 23, 7_35]
            # fmt: on

            self.assertListEqual(a__			,						self.big_tokenizer.encode(a__    )    )



       @slow
       def 					__lowercase						(							self    ) ->      str:






            '''simple docstring'''





            __snake_case			:Tuple          =						{
                """input_ids""": [[2, 10_88_25, 11_63, 15, 8_80_10, 4_73, 1_58_98, 1_57, 1_36_72, 18_57, 3_12, 8, 23_80_21, 11_63, 53, 1_36_72, 18_57, 3_12, 8, 5_32_83, 18_23_96, 8, 1_85_66, 16, 3_67_33, 41_01, 8, 2_30, 24_40_17, 12_25_53, 7, 15, 13_25_97, 4, 2_93, 1_25_11, 76_10, 4, 34_14, 13_25_97, 9, 4, 3_23_61, 3_62, 4, 7_34, 2_85_12, 3_25_69, 18, 4, 3_23_61, 2_60_96, 1_49_82, 73, 1_87_15, 2_14_33, 23_52_61, 15, 4_92, 1_24_27, 16, 53, 1_87_15, 2_14_33, 6_54_54, 15, 2_36_59, 5_63, 16, 2_78, 5_97, 28_43, 5_95, 79_31, 18_23_96, 6_41_86, 22, 8_86, 5_95, 13_29_81, 53, 2_55_40, 34_49, 4_39_82, 3_99_01, 59_51, 8_78, 3_30, 4, 2_76_94, 8_02_69, 3_12, 53, 65_17, 1_17_80, 6_11, 2_04_08, 5], [2, 6, 13_25_97, 67, 4_28_97, 33, 5_92, 8, 16_37_29, 2_55_40, 3_61, 13_69_97, 10_95_14, 17_32_30, 7, 5_01, 60, 10_29_13, 1_96, 56_31, 2_35, 6_32_43, 4_73, 6, 23_17_57, 74, 52_77, 79_05, 53, 30_95, 3_73_17, 22, 4_54, 18_38_74, 5], [2, 2_68, 3_12_98, 4_65_30, 6, 13_29_35, 4_38_31, 7, 5_97, 32, 24, 36_88, 98_65, 5]],
                """attention_mask""": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]
            }  # noqa: E501
            # fmt: on

            self.tokenizer_integration_test_util(
                expected_encoding=a__			,						model_name="""facebook/xglm-564M"""			,						padding=a__			,						)










from __future__ import annotations

lowerCamelCase__							=     list[list[int]]

# assigning initial values to the grid
lowerCamelCase__							=     [
    [3, 0, 6, 5, 0, 8, 4, 0, 0],
    [5, 2, 0, 0, 0, 0, 0, 0, 0],
    [0, 8, 7, 0, 0, 0, 0, 3, 1],
    [0, 0, 3, 0, 1, 0, 0, 8, 0],
    [9, 0, 0, 8, 6, 3, 0, 0, 5],
    [0, 5, 0, 0, 9, 0, 6, 0, 0],
    [1, 3, 0, 0, 0, 0, 2, 5, 0],
    [0, 0, 0, 0, 0, 0, 0, 7, 4],
    [0, 0, 5, 2, 0, 6, 3, 0, 0],
]

# a grid with no solution
lowerCamelCase__							=     [
    [5, 0, 6, 5, 0, 8, 4, 0, 3],
    [5, 2, 0, 0, 0, 0, 0, 0, 2],
    [1, 8, 7, 0, 0, 0, 0, 3, 1],
    [0, 0, 3, 0, 1, 0, 0, 8, 0],
    [9, 0, 0, 8, 6, 3, 0, 0, 5],
    [0, 5, 0, 0, 9, 0, 6, 0, 0],
    [1, 3, 0, 0, 0, 0, 2, 5, 0],
    [0, 0, 0, 0, 0, 0, 0, 7, 4],
    [0, 0, 5, 2, 0, 6, 3, 0, 0],
]






def   UpperCamelCase  (       snake_case__     :   Matrix	,snake_case__     :   int	,snake_case__     :   int	,snake_case__     :   int  ):




     '''simple docstring'''






     for i in range(9  ):
          if grid[row][i] == n or grid[i][column] == n:
               return False

     for i in range(3  ):
          for j in range(3  ):
               if grid[(row - row % 3) + i][(column - column % 3) + j] == n:
                    return False

     return True






def   UpperCamelCase  (       snake_case__     :   Matrix  ):




     '''simple docstring'''






     for i in range(9  ):
          for j in range(9  ):
               if grid[i][j] == 0:
                    return i, j
     return None






def   UpperCamelCase  (       snake_case__     :   Matrix  ):




     '''simple docstring'''






     if location := find_empty_location(snake_case__  ):
          __snake_case       , __snake_case			:Optional[int]          =						location
     else:
          # If the location is ``None``, then the grid is solved.
          return grid

     for digit in range(1	,10  ):
          if is_safe(snake_case__	,snake_case__	,snake_case__	,snake_case__  ):
               __snake_case			:Union[str, Any]          =						digit

               if sudoku(snake_case__  ) is not None:
                    return grid

               __snake_case			:Tuple          =						0

     return None






def   UpperCamelCase  (       snake_case__     :   Matrix  ):




     '''simple docstring'''






     for row in grid:
          for cell in row:
               print(snake_case__	,end=""" """  )
          print()


if __name__ == "__main__":
     # make a copy of grid so that you can compare with the unmodified grid
     for example_grid in (initial_grid, no_solution):
          print("""\nExample grid:\n""" + """=""" * 20)
          print_solution(example_grid)
          print("""\nExample grid solution:""")
          lowerCamelCase__							=     sudoku(example_grid)
          if solution is not None:
               print_solution(solution)
          else:
               print("""Cannot find a solution.""")


