





import os
import re
import shutil
import sys
import tempfile
import unittest

import black


_UpperCAmelCase             =							os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
sys.path.append(os.path.join(git_repo_path, 'utils'))

import check_copies  # noqa: E402


# This is the reference code that will be used in the tests.
# If BertLMPredictionHead is changed in modeling_bert.py, this code needs to be manually updated.
_UpperCAmelCase             =							'    def __init__(self, config):\n        super().__init__()\n        self.transform = BertPredictionHeadTransform(config)\n\n        # The output weights are the same as the input embeddings, but there is\n        # an output-only bias for each token.\n        self.decoder = nn.Linear(config.hidden_size, config.vocab_size, bias=False)\n\n        self.bias = nn.Parameter(torch.zeros(config.vocab_size))\n\n        # Need a link between the two variables so that the bias is correctly resized with `resize_token_embeddings`\n        self.decoder.bias = self.bias\n\n    def forward(self, hidden_states):\n        hidden_states = self.transform(hidden_states)\n        hidden_states = self.decoder(hidden_states)\n        return hidden_states\n'






class        snake_case_    (		unittest.TestCase						):






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






   '''simple docstring'''

   __lowerCAmelCase					:	int      =       tempfile.mkdtemp()
   os.makedirs(os.path.join(self.transformer_dir       ,  """models/bert/"""      )      )
   __lowerCAmelCase					:	List[Any]      =       self.transformer_dir
   shutil.copy(
       os.path.join(_snake_case       ,  """src/transformers/models/bert/modeling_bert.py"""      )       ,  os.path.join(self.transformer_dir       ,  """models/bert/modeling_bert.py"""      )       ,  )






  def 				UpperCAmelCase__						(							self			:					Dict      )->List[Any]:






   '''simple docstring'''

   __lowerCAmelCase					:	List[str]      =       """src/transformers"""
   shutil.rmtree(self.transformer_dir      )






  def 				UpperCAmelCase__						(							self			:					Union[str, Any]       ,  _snake_case			:					Optional[int]       ,  _snake_case			:					List[str]       ,  _snake_case			:					int       ,  _snake_case			:					Tuple=None      )->Dict:






   '''simple docstring'''

   __lowerCAmelCase					:	Dict      =       comment + F'''\nclass {class_name}(nn.Module):\n''' + class_code
   if overwrite_result is not None:
    __lowerCAmelCase					:	Dict      =       comment + F'''\nclass {class_name}(nn.Module):\n''' + overwrite_result
   __lowerCAmelCase					:	int      =       black.Mode(target_versions={black.TargetVersion.PYaa}       ,  line_length=119      )
   __lowerCAmelCase					:	Dict      =       black.format_str(_snake_case       ,  mode=_snake_case      )
   __lowerCAmelCase					:	List[str]      =       os.path.join(self.transformer_dir       ,  """new_code.py"""      )
   with open(_snake_case       ,  """w"""       ,  newline="""\n"""      ) as f:
    f.write(_snake_case      )
   if overwrite_result is None:
    self.assertTrue(len(check_copies.is_copy_consistent(_snake_case      )      ) == 0      )
   else:
    check_copies.is_copy_consistent(f.name       ,  overwrite=_snake_case      )
    with open(_snake_case       ,  """r"""      ) as f:
     self.assertTrue(f.read()       ,  _snake_case      )






  def 				UpperCAmelCase__						(							self			:					str      )->Optional[int]:






   '''simple docstring'''

   __lowerCAmelCase					:	Optional[Any]      =       check_copies.find_code_in_transformers("""models.bert.modeling_bert.BertLMPredictionHead"""      )
   self.assertEqual(_snake_case       ,  _snake_case      )






  def 				UpperCAmelCase__						(							self			:					Optional[Any]      )->List[str]:






   '''simple docstring'''

   self.check_copy_consistency(
       """# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead"""       ,  """BertLMPredictionHead"""       ,  REFERENCE_CODE + """\n"""       ,  )

   # With no empty line at the end
   self.check_copy_consistency(
       """# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead"""       ,  """BertLMPredictionHead"""       ,  _snake_case       ,  )

   # Copy consistency with rename
   self.check_copy_consistency(
       """# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead with Bert->TestModel"""       ,  """TestModelLMPredictionHead"""       ,  re.sub("""Bert"""       ,  """TestModel"""       ,  _snake_case      )       ,  )

   # Copy consistency with a really long name
   __lowerCAmelCase					:	str      =       """TestModelWithAReallyLongNameBecauseSomePeopleLikeThatForSomeReason"""
   self.check_copy_consistency(
       F'''# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead with Bert->{long_class_name}'''       ,  F'''{long_class_name}LMPredictionHead'''       ,  re.sub("""Bert"""       ,  _snake_case       ,  _snake_case      )       ,  )

   # Copy consistency with overwrite
   self.check_copy_consistency(
       """# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead with Bert->TestModel"""       ,  """TestModelLMPredictionHead"""       ,  _snake_case       ,  overwrite_result=re.sub("""Bert"""       ,  """TestModel"""       ,  _snake_case      )       ,  )






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






   '''simple docstring'''

   __lowerCAmelCase					:	str      =       check_copies.LOCALIZED_READMES["""README_zh-hans.md"""]

   __lowerCAmelCase					:	Dict      =       (
       """1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (from Google Research and the"""
       """ Toyota Technological Institute at Chicago) released with the paper [ALBERT: A Lite BERT for"""
       """ Self-supervised Learning of Language Representations](https://arxiv.org/abs/1909.11942), by Zhenzhong"""
       """ Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut.\n1."""
       """ **[DistilBERT](https://huggingface.co/transformers/model_doc/distilbert.html)** (from HuggingFace),"""
       """ released together with the paper [DistilBERT, a distilled version of BERT: smaller, faster, cheaper and"""
       """ lighter](https://arxiv.org/abs/1910.01108) by Victor Sanh, Lysandre Debut and Thomas Wolf. The same"""
       """ method has been applied to compress GPT2 into"""
       """ [DistilGPT2](https://github.com/huggingface/transformers/tree/main/examples/distillation), RoBERTa into"""
       """ [DistilRoBERTa](https://github.com/huggingface/transformers/tree/main/examples/distillation),"""
       """ Multilingual BERT into"""
       """ [DistilmBERT](https://github.com/huggingface/transformers/tree/main/examples/distillation) and a German"""
       """ version of DistilBERT.\n1. **[ELECTRA](https://huggingface.co/transformers/model_doc/electra.html)**"""
       """ (from Google Research/Stanford University) released with the paper [ELECTRA: Pre-training text encoders"""
       """ as discriminators rather than generators](https://arxiv.org/abs/2003.10555) by Kevin Clark, Minh-Thang"""
       """ Luong, Quoc V. Le, Christopher D. Manning."""
   )
   __lowerCAmelCase					:	Union[str, Any]      =       (
       """1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (来自 Google Research and the"""
       """ Toyota Technological Institute at Chicago) 伴随论文 [ALBERT: A Lite BERT for Self-supervised Learning of"""
       """ Language Representations](https://arxiv.org/abs/1909.11942), 由 Zhenzhong Lan, Mingda Chen, Sebastian"""
       """ Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut 发布。\n"""
   )
   __lowerCAmelCase					:	Dict      =       (
       """1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (来自 Google Research and the"""
       """ Toyota Technological Institute at Chicago) 伴随论文 [ALBERT: A Lite BERT for Self-supervised Learning of"""
       """ Language Representations](https://arxiv.org/abs/1909.11942), 由 Zhenzhong Lan, Mingda Chen, Sebastian"""
       """ Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut 发布。\n1."""
       """ **[DistilBERT](https://huggingface.co/transformers/model_doc/distilbert.html)** (来自 HuggingFace) 伴随论文"""
       """ [DistilBERT, a distilled version of BERT: smaller, faster, cheaper and"""
       """ lighter](https://arxiv.org/abs/1910.01108) 由 Victor Sanh, Lysandre Debut and Thomas Wolf 发布。 The same"""
       """ method has been applied to compress GPT2 into"""
       """ [DistilGPT2](https://github.com/huggingface/transformers/tree/main/examples/distillation), RoBERTa into"""
       """ [DistilRoBERTa](https://github.com/huggingface/transformers/tree/main/examples/distillation),"""
       """ Multilingual BERT into"""
       """ [DistilmBERT](https://github.com/huggingface/transformers/tree/main/examples/distillation) and a German"""
       """ version of DistilBERT.\n1. **[ELECTRA](https://huggingface.co/transformers/model_doc/electra.html)** (来自"""
       """ Google Research/Stanford University) 伴随论文 [ELECTRA: Pre-training text encoders as discriminators rather"""
       """ than generators](https://arxiv.org/abs/2003.10555) 由 Kevin Clark, Minh-Thang Luong, Quoc V. Le,"""
       """ Christopher D. Manning 发布。\n"""
   )

   __lowerCAmelCase ,					__lowerCAmelCase					:	Dict      =       check_copies.convert_to_localized_md(
       _snake_case       ,  _snake_case       ,  localized_readme["""format_model_list"""]      )

   self.assertFalse(_snake_case      )
   self.assertEqual(_snake_case       ,  _snake_case      )

   __lowerCAmelCase ,					__lowerCAmelCase					:	Tuple      =       check_copies.convert_to_localized_md(
       _snake_case       ,  _snake_case       ,  localized_readme["""format_model_list"""]      )

   # Check whether the number of models is equal to README.md after conversion.
   self.assertTrue(_snake_case      )

   __lowerCAmelCase					:	Tuple      =       (
       """1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (from Google Research and the"""
       """ Toyota Technological Institute at Chicago) released with the paper [ALBERT: A Lite BERT for"""
       """ Self-supervised Learning of Language Representations](https://arxiv.org/abs/1909.11942), by Zhenzhong"""
       """ Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut."""
   )
   __lowerCAmelCase					:	Dict      =       (
       """1. **[ALBERT](https://huggingface.co/transformers/main/model_doc/albert.html)** (来自 Google Research and"""
       """ the Toyota Technological Institute at Chicago) 伴随论文 [ALBERT: A Lite BERT for Self-supervised Learning of"""
       """ Language Representations](https://arxiv.org/abs/1909.11942), 由 Zhenzhong Lan, Mingda Chen, Sebastian"""
       """ Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut 发布。\n"""
   )
   __lowerCAmelCase					:	Optional[int]      =       (
       """1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (来自 Google Research and the"""
       """ Toyota Technological Institute at Chicago) 伴随论文 [ALBERT: A Lite BERT for Self-supervised Learning of"""
       """ Language Representations](https://arxiv.org/abs/1909.11942), 由 Zhenzhong Lan, Mingda Chen, Sebastian"""
       """ Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut 发布。\n"""
   )

   __lowerCAmelCase ,					__lowerCAmelCase					:	int      =       check_copies.convert_to_localized_md(
       _snake_case       ,  _snake_case       ,  localized_readme["""format_model_list"""]      )

   # Check if the model link is synchronized.
   self.assertEqual(_snake_case       ,  _snake_case      )






from __future__ import annotations

import time

import numpy as np

_UpperCAmelCase             =							[8, 5, 9, 7]
_UpperCAmelCase             =							[
    [2, 0, 1, 1],
    [0, 1, 2, 1],
    [4, 0, 0, 3],
    [0, 2, 1, 0],
    [1, 0, 3, 0],
]
_UpperCAmelCase             =							[
    [3, 2, 1, 4],
    [0, 2, 5, 2],
    [5, 1, 0, 5],
    [1, 5, 3, 0],
    [3, 0, 3, 3],
]






class        snake_case_    :






  def __init__(							self			:					Union[str, Any]       ,  _snake_case			:					list[int]       ,  _snake_case			:					list[list[int]]       ,  _snake_case			:					list[list[int]]       ,  )->None:






   '''simple docstring'''

   __lowerCAmelCase					:	str      =       claim_vector
   __lowerCAmelCase					:	List[Any]      =       allocated_resources_table
   __lowerCAmelCase					:	str      =       maximum_claim_table






  def 				UpperCAmelCase__						(							self			:					Tuple      )->list[int]:






   '''simple docstring'''

   return [
       sum(p_item[i] for p_item in self.__allocated_resources_table      )
       for i in range(len(self.__allocated_resources_table[0]      )      )
   ]






  def 				UpperCAmelCase__						(							self			:					int      )->list[int]:






   '''simple docstring'''

   return np.array(self.__claim_vector      ) - np.array(
       self.__processes_resource_summation()      )






  def 				UpperCAmelCase__						(							self			:					Optional[int]      )->list[list[int]]:






   '''simple docstring'''

   return [
       list(np.array(self.__maximum_claim_table[i]      ) - np.array(_snake_case      )      )
       for i, allocated_resource in enumerate(self.__allocated_resources_table      )
   ]






  def 				UpperCAmelCase__						(							self			:					Union[str, Any]      )->dict[int, list[int]]:






   '''simple docstring'''

   return {self.__need().index(_snake_case      ): i for i in self.__need()}






  def 				UpperCAmelCase__						(							self			:					Dict       ,  **_snake_case			:					Optional[Any]      )->None:






   '''simple docstring'''

   __lowerCAmelCase					:	Optional[int]      =       self.__need()
   __lowerCAmelCase					:	Any      =       self.__allocated_resources_table
   __lowerCAmelCase					:	List[Any]      =       self.__available_resources()
   __lowerCAmelCase					:	Optional[Any]      =       self.__need_index_manager()
   for kw, val in kwargs.items():
    if kw and val is True:
     self.__pretty_data()
   print("""_""" * 50 + """\n"""      )
   while need_list:
    __lowerCAmelCase					:	Optional[Any]      =       False
    for each_need in need_list:
     __lowerCAmelCase					:	Optional[int]      =       True
     for index, need in enumerate(_snake_case      ):
      if need > available_resources[index]:
       __lowerCAmelCase					:	int      =       False
       break
     if execution:
      __lowerCAmelCase					:	int      =       True
      # get the original index of the process from ind_ctrl db
      for original_need_index, need_clone in need_index_manager.items():
       if each_need == need_clone:
        __lowerCAmelCase					:	Any      =       original_need_index
      print(F'''Process {process_number + 1} is executing.'''      )
      # remove the process run from stack
      need_list.remove(_snake_case      )
      # update available/freed resources stack
      __lowerCAmelCase					:	int      =       np.array(_snake_case      ) + np.array(
          alloc_resources_table[process_number]      )
      print(
          """Updated available resource stack for processes: """
          + """ """.join([str(_snake_case      ) for x in available_resources]      )      )
      break
    if safe:
     print("""The process is in a safe state.\n"""      )
    else:
     print("""System in unsafe state. Aborting...\n"""      )
     break






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






   '''simple docstring'''

   print(""" """ * 9 + """Allocated Resource Table"""      )
   for item in self.__allocated_resources_table:
    print(
        F'''P{self.__allocated_resources_table.index(_snake_case      ) + 1}'''
        + """ """.join(F'''{it:>8}''' for it in item      )
        + """\n"""      )
   print(""" """ * 9 + """System Resource Table"""      )
   for item in self.__maximum_claim_table:
    print(
        F'''P{self.__maximum_claim_table.index(_snake_case      ) + 1}'''
        + """ """.join(F'''{it:>8}''' for it in item      )
        + """\n"""      )
   print(
       """Current Usage by Active Processes: """
       + """ """.join(str(_snake_case      ) for x in self.__claim_vector      )      )
   print(
       """Initial Available Resources:       """
       + """ """.join(str(_snake_case      ) for x in self.__available_resources()      )      )
   time.sleep(1      )


if __name__ == "__main__":
      import doctest

      doctest.testmod()