





'''simple docstring'''

import json
import os
import shutil
import sys
import tempfile
import unittest
import unittest.mock as mock
from pathlib import Path

from huggingface_hub import HfFolder, delete_repo
from requests.exceptions import HTTPError

from transformers import AutoConfig, BertConfig, GPTaConfig
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import TOKEN, USER, is_staging_test


sys.path.append(str(Path(__file__).parent.parent / 'utils'))

from test_module.custom_configuration import CustomConfig  # noqa E402


lowercase__						:      List[str]	=    {
    'return_dict': False,
    'output_hidden_states': True,
    'output_attentions': True,
    'torchscript': True,
    'torch_dtype': 'float16',
    'use_bfloat16': True,
    'tf_legacy_loss': True,
    'pruned_heads': {'a': 1},
    'tie_word_embeddings': False,
    'is_decoder': True,
    'cross_attention_hidden_size': 1_28,
    'add_cross_attention': True,
    'tie_encoder_decoder': True,
    'max_length': 50,
    'min_length': 3,
    'do_sample': True,
    'early_stopping': True,
    'num_beams': 3,
    'num_beam_groups': 3,
    'diversity_penalty': 0.5,
    'temperature': 2.0,
    'top_k': 10,
    'top_p': 0.7,
    'typical_p': 0.2,
    'repetition_penalty': 0.8,
    'length_penalty': 0.8,
    'no_repeat_ngram_size': 5,
    'encoder_no_repeat_ngram_size': 5,
    'bad_words_ids': [1, 2, 3],
    'num_return_sequences': 3,
    'chunk_size_feed_forward': 5,
    'output_scores': True,
    'return_dict_in_generate': True,
    'forced_bos_token_id': 2,
    'forced_eos_token_id': 3,
    'remove_invalid_values': True,
    'architectures': ['BertModel'],
    'finetuning_task': 'translation',
    'id2label': {0: 'label'},
    'label2id': {'label': '0'},
    'tokenizer_class': 'BertTokenizerFast',
    'prefix': 'prefix',
    'bos_token_id': 6,
    'pad_token_id': 7,
    'eos_token_id': 8,
    'sep_token_id': 9,
    'decoder_start_token_id': 10,
    'exponential_decay_length_penalty': (5, 1.01),
    'suppress_tokens': [0, 1],
    'begin_suppress_tokens': 2,
    'task_specific_params': {'translation': 'some_params'},
    'problem_type': 'regression',
}
@is_staging_test
class     __lowerCAmelCase					(   unittest.TestCase			):






       """simple docstring"""





       @classmethod
       def snake_case__						(							cls       :		Optional[int]					)   ->					Dict:

            '''simple docstring'''




            _UpperCamelCase       =	TOKEN
            HfFolder.save_token(lowerCAmelCase__					)





       @classmethod
       def snake_case__						(							cls       :		str					)   ->					Optional[Any]:

            '''simple docstring'''




            try:
                 delete_repo(token=cls._token	,			repo_id='''test-config'''					)
            except HTTPError:
                 pass

            try:
                 delete_repo(token=cls._token	,			repo_id='''valid_org/test-config-org'''					)
            except HTTPError:
                 pass

            try:
                 delete_repo(token=cls._token	,			repo_id='''test-dynamic-config'''					)
            except HTTPError:
                 pass





       def snake_case__						(							self       :		Any					)   ->					int:

            '''simple docstring'''




            _UpperCamelCase       =	BertConfig(
                vocab_size=99	,			hidden_size=32	,			num_hidden_layers=5	,			num_attention_heads=4	,			intermediate_size=37					)
            config.push_to_hub('''test-config'''	,			use_auth_token=self._token					)

            _UpperCamelCase       =	BertConfig.from_pretrained(f"""{USER}/test-config"""					)
            for k, v in config.to_dict().items():
                 if k != "transformers_version":
                      self.assertEqual(lowerCAmelCase__	,			getattr(lowerCAmelCase__	,			lowerCAmelCase__					)					)

        # Reset repo
            delete_repo(token=self._token	,			repo_id='''test-config'''					)

            # Push to hub via save_pretrained
            with tempfile.TemporaryDirectory() as tmp_dir:
                 config.save_pretrained(lowerCAmelCase__	,			repo_id='''test-config'''	,			push_to_hub=lowerCAmelCase__	,			use_auth_token=self._token					)

            _UpperCamelCase       =	BertConfig.from_pretrained(f"""{USER}/test-config"""					)
            for k, v in config.to_dict().items():
                 if k != "transformers_version":
                      self.assertEqual(lowerCAmelCase__	,			getattr(lowerCAmelCase__	,			lowerCAmelCase__					)					)





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

            '''simple docstring'''




            _UpperCamelCase       =	BertConfig(
                vocab_size=99	,			hidden_size=32	,			num_hidden_layers=5	,			num_attention_heads=4	,			intermediate_size=37					)
            config.push_to_hub('''valid_org/test-config-org'''	,			use_auth_token=self._token					)

            _UpperCamelCase       =	BertConfig.from_pretrained('''valid_org/test-config-org'''					)
            for k, v in config.to_dict().items():
                 if k != "transformers_version":
                      self.assertEqual(lowerCAmelCase__	,			getattr(lowerCAmelCase__	,			lowerCAmelCase__					)					)

        # Reset repo
            delete_repo(token=self._token	,			repo_id='''valid_org/test-config-org'''					)

            # Push to hub via save_pretrained
            with tempfile.TemporaryDirectory() as tmp_dir:
                 config.save_pretrained(
                     lowerCAmelCase__	,			repo_id='''valid_org/test-config-org'''	,			push_to_hub=lowerCAmelCase__	,			use_auth_token=self._token					)

            _UpperCamelCase       =	BertConfig.from_pretrained('''valid_org/test-config-org'''					)
            for k, v in config.to_dict().items():
                 if k != "transformers_version":
                      self.assertEqual(lowerCAmelCase__	,			getattr(lowerCAmelCase__	,			lowerCAmelCase__					)					)







       def snake_case__						(							self       :		Any					)   ->					Dict:

            '''simple docstring'''




            CustomConfig.register_for_auto_class()
            _UpperCamelCase       =	CustomConfig(attribute=42					)

            config.push_to_hub('''test-dynamic-config'''	,			use_auth_token=self._token					)

            # This has added the proper auto_map field to the config
            self.assertDictEqual(config.auto_map	,			{'''AutoConfig''': '''custom_configuration.CustomConfig'''}					)

            _UpperCamelCase       =	AutoConfig.from_pretrained(f"""{USER}/test-dynamic-config"""	,			trust_remote_code=lowerCAmelCase__					)
            # Can't make an isinstance check because the new_config is from the FakeConfig class of a dynamic module
            self.assertEqual(new_config.__class__.__name__	,			'''CustomConfig'''					)
            self.assertEqual(new_config.attribute	,			42					)

class     __lowerCAmelCase					(   unittest.TestCase			):






       """simple docstring"""





       def snake_case__						(							self       :		str					)   ->					str:

            '''simple docstring'''




            _UpperCamelCase       =	GPTaConfig()

            # attempt to modify each of int/float/bool/str config records and verify they were updated
            _UpperCamelCase       =	c.n_embd + 1  # int
            _UpperCamelCase       =	c.resid_pdrop + 1.0  # float
            _UpperCamelCase       =	not c.scale_attn_weights  # bool
            _UpperCamelCase       =	c.summary_type + '''foo'''  # str
            c.update_from_string(
                f"""n_embd={n_embd},resid_pdrop={resid_pdrop},scale_attn_weights={scale_attn_weights},summary_type={summary_type}"""					)
            self.assertEqual(lowerCAmelCase__	,			c.n_embd	,			'''mismatch for key: n_embd'''					)
            self.assertEqual(lowerCAmelCase__	,			c.resid_pdrop	,			'''mismatch for key: resid_pdrop'''					)
            self.assertEqual(lowerCAmelCase__	,			c.scale_attn_weights	,			'''mismatch for key: scale_attn_weights'''					)
            self.assertEqual(lowerCAmelCase__	,			c.summary_type	,			'''mismatch for key: summary_type'''					)





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

            '''simple docstring'''




            _UpperCamelCase       =	PretrainedConfig()
            _UpperCamelCase       =	[key for key in base_config.__dict__ if key not in config_common_kwargs]
            # If this part of the test fails, you have arguments to addin config_common_kwargs above.
            self.assertListEqual(
                lowerCAmelCase__	,			['''is_encoder_decoder''', '''_name_or_path''', '''_commit_hash''', '''transformers_version''']					)
            _UpperCamelCase       =	[key for key, value in config_common_kwargs.items() if value == getattr(lowerCAmelCase__	,			lowerCAmelCase__					)]
            if len(lowerCAmelCase__					) > 0:
                 raise ValueError(
                     '''The following keys are set with the default values in'''
                     ''' `test_configuration_common.config_common_kwargs` pick another value for them:'''
                     f""" {', '.join(lowerCAmelCase__					)}."""					)





       def snake_case__						(							self       :		Tuple					)   ->					int:

            '''simple docstring'''




            with self.assertRaises(lowerCAmelCase__					):
                 # config is in subfolder, the following should not work without specifying the subfolder
                 _UpperCamelCase       =	BertConfig.from_pretrained('''hf-internal-testing/tiny-random-bert-subfolder'''					)

            _UpperCamelCase       =	BertConfig.from_pretrained('''hf-internal-testing/tiny-random-bert-subfolder'''	,			subfolder='''bert'''					)

            self.assertIsNotNone(lowerCAmelCase__					)





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

            '''simple docstring'''




            _UpperCamelCase       =	mock.Mock()
            _UpperCamelCase       =	500
            _UpperCamelCase       =	{}
            _UpperCamelCase       =	HTTPError
            _UpperCamelCase       =	{}

            # Download this model to make sure it's in the cache.
            _UpperCamelCase       =	BertConfig.from_pretrained('''hf-internal-testing/tiny-random-bert'''					)

            # Under the mock environment we get a 500 error when trying to reach the model.
            with mock.patch('''requests.Session.request'''	,			return_value=lowerCAmelCase__					) as mock_head:
                 _UpperCamelCase       =	BertConfig.from_pretrained('''hf-internal-testing/tiny-random-bert'''					)
                 # This check we did call the fake head request
                 mock_head.assert_called()





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

            '''simple docstring'''




            _UpperCamelCase       =	BertConfig.from_pretrained(
                '''https://huggingface.co/hf-internal-testing/tiny-random-bert/resolve/main/config.json'''					)





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

            '''simple docstring'''




            _UpperCamelCase       =	AutoConfig.from_pretrained('''bert-base-cased'''					)
            _UpperCamelCase       =	['''config.4.0.0.json''']

            with tempfile.TemporaryDirectory() as tmp_dir:
                 configuration.save_pretrained(lowerCAmelCase__					)
                 _UpperCamelCase       =	2
                 json.dump(configuration.to_dict()	,			open(os.path.join(lowerCAmelCase__	,			'''config.4.0.0.json'''					)	,			'''w'''					)					)

                 # This should pick the new configuration file as the version of Transformers is > 4.0.0
                 _UpperCamelCase       =	AutoConfig.from_pretrained(lowerCAmelCase__					)
                 self.assertEqual(new_configuration.hidden_size	,			2					)

                 # Will need to be adjusted if we reach v42 and this test is still here.
                 # Should pick the old configuration file as the version of Transformers is < 4.42.0
                 _UpperCamelCase       =	['''config.42.0.0.json''']
                 _UpperCamelCase       =	768
                 configuration.save_pretrained(lowerCAmelCase__					)
                 shutil.move(os.path.join(lowerCAmelCase__	,			'''config.4.0.0.json'''					)	,			os.path.join(lowerCAmelCase__	,			'''config.42.0.0.json'''					)					)
                 _UpperCamelCase       =	AutoConfig.from_pretrained(lowerCAmelCase__					)
                 self.assertEqual(new_configuration.hidden_size	,			768					)







       def snake_case__						(							self       :		str					)   ->					Dict:

            '''simple docstring'''




            _UpperCamelCase       =	'''hf-internal-testing/test-two-configs'''

            import transformers as new_transformers

            _UpperCamelCase       =	'''v4.0.0'''
            _UpperCamelCase   ,    _UpperCamelCase       =	new_transformers.models.auto.AutoConfig.from_pretrained(
                lowerCAmelCase__	,			return_unused_kwargs=lowerCAmelCase__					)
            self.assertEqual(new_configuration.hidden_size	,			2					)
            # This checks `_configuration_file` ia not kept in the kwargs by mistake.
            self.assertDictEqual(lowerCAmelCase__	,			{}					)

            # Testing an older version by monkey-patching the version in the module it's used.
            import transformers as old_transformers

            _UpperCamelCase       =	'''v3.0.0'''
            _UpperCamelCase       =	old_transformers.models.auto.AutoConfig.from_pretrained(lowerCAmelCase__					)
            self.assertEqual(old_configuration.hidden_size	,			768					)










'''simple docstring'''

def  a__    (    lowercase :					int, lowercase :					int, lowercase :					list[list[int]]				)		->		int:





     """simple docstring"""

     def update_area_of_max_square(lowercase :					int, lowercase :					int				) -> int:
          # BASE CASE
          if row >= rows or col >= cols:
               return 0

          _UpperCamelCase       =	update_area_of_max_square(lowercase, col + 1				)
          _UpperCamelCase       =	update_area_of_max_square(row + 1, col + 1				)
          _UpperCamelCase       =	update_area_of_max_square(row + 1, lowercase				)

          if mat[row][col]:
               _UpperCamelCase       =	1 + min([right, diagonal, down]				)
               _UpperCamelCase       =	max(largest_square_area[0], lowercase				)
               return sub_problem_sol
          else:
               return 0

     _UpperCamelCase       =	[0]
     update_area_of_max_square(0, 0				)
     return largest_square_area[0]







def  a__    (    lowercase :					int, lowercase :					int, lowercase :					list[list[int]]				)		->		int:





     """simple docstring"""

     def update_area_of_max_square_using_dp_array(
         lowercase :					int, lowercase :					int, lowercase :					list[list[int]]				) -> int:
          if row >= rows or col >= cols:
               return 0
          if dp_array[row][col] != -1:
               return dp_array[row][col]

          _UpperCamelCase       =	update_area_of_max_square_using_dp_array(lowercase, col + 1, lowercase				)
          _UpperCamelCase       =	update_area_of_max_square_using_dp_array(row + 1, col + 1, lowercase				)
          _UpperCamelCase       =	update_area_of_max_square_using_dp_array(row + 1, lowercase, lowercase				)

          if mat[row][col]:
               _UpperCamelCase       =	1 + min([right, diagonal, down]				)
               _UpperCamelCase       =	max(largest_square_area[0], lowercase				)
               _UpperCamelCase       =	sub_problem_sol
               return sub_problem_sol
          else:
               return 0

     _UpperCamelCase       =	[0]
     _UpperCamelCase       =	[[-1] * cols for _ in range(lowercase				)]
     update_area_of_max_square_using_dp_array(0, 0, lowercase				)

     return largest_square_area[0]







def  a__    (    lowercase :					int, lowercase :					int, lowercase :					list[list[int]]				)		->		int:





     """simple docstring"""

     _UpperCamelCase       =	[[0] * (cols + 1) for _ in range(rows + 1				)]
     _UpperCamelCase       =	0
     for row in range(rows - 1, -1, -1				):
          for col in range(cols - 1, -1, -1				):
               _UpperCamelCase       =	dp_array[row][col + 1]
               _UpperCamelCase       =	dp_array[row + 1][col + 1]
               _UpperCamelCase       =	dp_array[row + 1][col]

               if mat[row][col] == 1:
                    _UpperCamelCase       =	1 + min(lowercase, lowercase, lowercase				)
                    _UpperCamelCase       =	max(dp_array[row][col], lowercase				)
               else:
                    _UpperCamelCase       =	0

     return largest_square_area







def  a__    (    lowercase :					int, lowercase :					int, lowercase :					list[list[int]]				)		->		int:





     """simple docstring"""

     _UpperCamelCase       =	[0] * (cols + 1)
     _UpperCamelCase       =	[0] * (cols + 1)
     _UpperCamelCase       =	0
     for row in range(rows - 1, -1, -1				):
          for col in range(cols - 1, -1, -1				):
               _UpperCamelCase       =	current_row[col + 1]
               _UpperCamelCase       =	next_row[col + 1]
               _UpperCamelCase       =	next_row[col]

               if mat[row][col] == 1:
                    _UpperCamelCase       =	1 + min(lowercase, lowercase, lowercase				)
                    _UpperCamelCase       =	max(current_row[col], lowercase				)
               else:
                    _UpperCamelCase       =	0
          _UpperCamelCase       =	current_row

     return largest_square_area


if __name__ == "__main__":
   import doctest

   doctest.testmod()
   print(largest_square_area_in_matrix_bottom_up(2, 2, [[1, 1], [1, 1]]))



