





'''simple docstring'''

from __future__ import annotations

import random
import unittest

from transformers import TransfoXLConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
  import tensorflow as tf

  from transformers import (
      TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFTransfoXLForSequenceClassification,
      TFTransfoXLLMHeadModel,
      TFTransfoXLModel,
  )






class    UpperCAmelCase	:
 def __init__(				self      :Union[str, Any]						,       lowercase_      :List[str]						,       )->							Tuple:
     A__				=			parent
     A__				=			13
     A__				=			7
     A__				=			30
     A__				=			self.seq_length + self.mem_len
     A__				=			15
     A__				=			True
     A__				=			True
     A__				=			99
     A__				=			[10, 50, 80]
     A__				=			32
     A__				=			32
     A__				=			4
     A__				=			8
     A__				=			1_28
     A__				=			2
     A__				=			2
     A__				=			None
     A__				=			1
     A__				=			0
     A__				=			3
     A__				=			self.vocab_size - 1
     A__				=			0.0_1
 def      UpperCAmelCase_							(				self      :List[str]							)->							int:
     A__				=			ids_tensor([self.batch_size, self.seq_length]						,       self.vocab_size							)
     A__				=			ids_tensor([self.batch_size, self.seq_length]						,       self.vocab_size							)

     A__				=			None
     if self.use_labels:
         A__				=			ids_tensor([self.batch_size, self.seq_length]						,       self.vocab_size							)

     A__				=			TransfoXLConfig(
         vocab_size=self.vocab_size						,       mem_len=self.mem_len						,       clamp_len=self.clamp_len						,       cutoffs=self.cutoffs						,       d_model=self.hidden_size						,       d_embed=self.d_embed						,       n_head=self.num_attention_heads						,       d_head=self.d_head						,       d_inner=self.d_inner						,       div_val=self.div_val						,       n_layer=self.num_hidden_layers						,       eos_token_id=self.eos_token_id						,       pad_token_id=self.vocab_size - 1						,       init_range=self.init_range						,       num_labels=self.num_labels						,       )

     return (config, input_ids_a, input_ids_a, lm_labels)
 def      UpperCAmelCase_							(				self      :str							)->							Optional[int]:
     random.seed(self.seed							)
     tf.random.set_seed(self.seed							)
 def      UpperCAmelCase_							(				self      :Dict						,       lowercase_      :Tuple						,       lowercase_      :Optional[Any]						,       lowercase_      :Union[str, Any]						,       lowercase_      :List[str]							)->							List[str]:
     A__				=			TFTransfoXLModel(lowercase_							)

     A__,	A__				=			model(lowercase_							).to_tuple()

     A__				=			{"input_ids": input_ids_a, "mems": mems_a}

     A__,	A__				=			model(lowercase_							).to_tuple()

     self.parent.assertEqual(hidden_states_a.shape						,       (self.batch_size, self.seq_length, self.hidden_size)							)
     self.parent.assertEqual(hidden_states_a.shape						,       (self.batch_size, self.seq_length, self.hidden_size)							)
     self.parent.assertListEqual(
         [mem.shape for mem in mems_a]						,       [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers						,       )
     self.parent.assertListEqual(
         [mem.shape for mem in mems_a]						,       [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers						,       )
 def      UpperCAmelCase_							(				self      :Optional[Any]						,       lowercase_      :str						,       lowercase_      :Optional[int]						,       lowercase_      :List[Any]						,       lowercase_      :Optional[int]							)->							Optional[Any]:
     A__				=			TFTransfoXLLMHeadModel(lowercase_							)

     A__,	A__				=			model(lowercase_							).to_tuple()

     A__				=			{"input_ids": input_ids_a, "labels": lm_labels}
     A__,	A__				=			model(lowercase_							).to_tuple()

     A__,	A__				=			model([input_ids_a, mems_a]							).to_tuple()

     A__				=			{"input_ids": input_ids_a, "mems": mems_a, "labels": lm_labels}

     A__,	A__				=			model(lowercase_							).to_tuple()

     self.parent.assertEqual(lm_logits_a.shape						,       (self.batch_size, self.seq_length, self.vocab_size)							)
     self.parent.assertListEqual(
         [mem.shape for mem in mems_a]						,       [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers						,       )

     self.parent.assertEqual(lm_logits_a.shape						,       (self.batch_size, self.seq_length, self.vocab_size)							)
     self.parent.assertListEqual(
         [mem.shape for mem in mems_a]						,       [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers						,       )
 def      UpperCAmelCase_							(				self      :Optional[int]						,       lowercase_      :List[Any]						,       lowercase_      :List[Any]						,       lowercase_      :Dict						,       lowercase_      :str							)->							Dict:
     A__				=			TFTransfoXLForSequenceClassification(lowercase_							)
     A__				=			model(lowercase_							)
     self.parent.assertEqual(result.logits.shape						,       (self.batch_size, self.num_labels)							)



 def      UpperCAmelCase_							(				self      :Optional[Any]							)->							Tuple:
     A__				=			self.prepare_config_and_inputs()
     ((A__),	(A__),	(A__),	(A__))				=			config_and_inputs
     A__				=			{"input_ids": input_ids_a}
     return config, inputs_dict






@require_tf
class    UpperCAmelCase	(       UpperCamelCase__			,       UpperCamelCase__			,       unittest.TestCase				):
 __lowercase   		=				(
     (TFTransfoXLModel, TFTransfoXLLMHeadModel, TFTransfoXLForSequenceClassification) if is_tf_available() else ()
 )
 __lowercase   		=				() if is_tf_available() else ()
 __lowercase   		=				(
     {
         """feature-extraction""": TFTransfoXLModel,
         """text-classification""": TFTransfoXLForSequenceClassification,
         """text-generation""": TFTransfoXLLMHeadModel,
         """zero-shot""": TFTransfoXLForSequenceClassification,
     }
     if is_tf_available()
     else {}
 )
 # TODO: add this test when TFTransfoXLLMHead has a linear output layer implemented
 __lowercase   		=				False
 __lowercase   		=				False
 __lowercase   		=				False
 __lowercase   		=				False
 def      UpperCAmelCase_							(				self      :str						,       lowercase_      :int						,       lowercase_      :Union[str, Any]						,       lowercase_      :Optional[Any]						,       lowercase_      :str						,       lowercase_      :Union[str, Any]							)->							int:
     if pipeline_test_casse_name == "TextGenerationPipelineTests":
         # Get `ValueError: AttributeError: 'NoneType' object has no attribute 'new_ones'` or `AssertionError`.
         # `TransfoXLConfig` was never used in pipeline tests: cannot create a simple
         # tokenizer.
         return True

     return False
 def      UpperCAmelCase_							(				self      :int							)->							Union[str, Any]:
     A__				=			TFTransfoXLModelTester(self							)
     A__				=			ConfigTester(self						,       config_class=lowercase_						,       d_embed=37							)
 def      UpperCAmelCase_							(				self      :List[str]							)->							List[Any]:
     self.config_tester.run_common_tests()
 def      UpperCAmelCase_							(				self      :List[str]							)->							Any:
     self.model_tester.set_seed()
     A__				=			self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_transfo_xl_model(*lowercase_							)
 def      UpperCAmelCase_							(				self      :List[str]							)->							List[str]:
     self.model_tester.set_seed()
     A__				=			self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_transfo_xl_lm_head(*lowercase_							)
 def      UpperCAmelCase_							(				self      :Union[str, Any]							)->							Optional[Any]:
     A__				=			self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_transfo_xl_for_sequence_classification(*lowercase_							)
 def      UpperCAmelCase_							(				self      :str							)->							Optional[int]:
     A__,	A__				=			self.model_tester.prepare_config_and_inputs_for_common()
     A__				=			[TFTransfoXLForSequenceClassification]

     for model_class in self.all_model_classes:
         A__				=			model_class(lowercase_							)
         assert isinstance(model.get_input_embeddings()						,       tf.keras.layers.Layer							)
         if model_class in list_other_models_with_output_ebd:
             A__				=			model.get_output_embeddings()
             assert isinstance(lowercase_						,       tf.keras.layers.Layer							)
             A__				=			model.get_bias()
             assert name is None
         else:
             A__				=			model.get_output_embeddings()
             assert x is None
             A__				=			model.get_bias()
             assert name is None
 def      UpperCAmelCase_							(				self      :Tuple							)->							List[Any]:
     # TODO JP: Make TransfoXL XLA compliant
     pass
 @slow
 def      UpperCAmelCase_							(				self      :Union[str, Any]							)->							Union[str, Any]:
     for model_name in TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         A__				=			TFTransfoXLModel.from_pretrained(lowercase_							)
         self.assertIsNotNone(lowercase_							)



 @unittest.skip(reason="This model doesn't play well with fit() due to not returning a single loss."							)
 def      UpperCAmelCase_							(				self      :List[str]							)->							int:
     pass






@require_tf
class    UpperCAmelCase	(       unittest.TestCase				):
 @unittest.skip("Skip test until #12651 is resolved."							)
 @slow
 def      UpperCAmelCase_							(				self      :List[str]							)->							Tuple:
     A__				=			TFTransfoXLLMHeadModel.from_pretrained("transfo-xl-wt103"							)
     # fmt: off
     A__				=			tf.convert_to_tensor([[33,12_97,2,1,10_09,4,11_09,1_17_39,47_62,3_58,5,25,2_45,22,17_06,17,2_00_98,5,32_15,21,37,11_10,3,13,10_41,4,24,6_03,4_90,2,7_14_77,2_00_98,10_44_47,2,2_09_61,1,26_04,4,1,3_29,3,62_24,8_31,1_60_02,2,8,6_03,7_89_67,2_95_46,23,8_03,20,25,4_16,5,8,2_32,4,2_77,6,18_55,46_01,3,2_95_46,54,8,36_09,5,5_72_11,49,4,1,2_77,18,8,17_55,1_56_91,3,3_41,25,4_16,6_93,4_25_73,71,17,4_01,94,31,1_79_19,2,2_95_46,78_73,18,1,4_35,23,1_10_11,7_55,5,51_67,3,79_83,98,84,2,2_95_46,32_67,8,36_09,4,1,48_65,10_75,2,60_87,71,6,3_46,8,58_54,3,2_95_46,8_24,14_00,18_68,2,19,1_60,2,3_11,8,54_96,2,2_09_20,17,25,1_50_97,3,24,24,0]]						,       dtype=tf.intaa							)  # noqa: E231
     # fmt: on
     #  In 1991 , the remains of Russian Tsar Nicholas II and his family
     #  ( except for Alexei and Maria ) are discovered .
     #  The voice of Nicholas's young son , Tsarevich Alexei Nikolaevich , narrates the
     #  remainder of the story . 1883 Western Siberia ,
     #  a young Grigori Rasputin is asked by his father and a group of men to perform magic .
     #  Rasputin has a vision and denounces one of the men as a horse thief . Although his
     #  father initially slaps him for making such an accusation , Rasputin watches as the
     #  man is chased outside and beaten . Twenty years later , Rasputin sees a vision of
     #  the Virgin Mary , prompting him to become a priest . Rasputin quickly becomes famous ,
     #  with people , even a bishop , begging for his blessing . <eod> </s> <eos>

     # fmt: off
     A__				=			[33,12_97,2,1,10_09,4,11_09,1_17_39,47_62,3_58,5,25,2_45,22,17_06,17,2_00_98,5,32_15,21,37,11_10,3,13,10_41,4,24,6_03,4_90,2,7_14_77,2_00_98,10_44_47,2,2_09_61,1,26_04,4,1,3_29,3,62_24,8_31,1_60_02,2,8,6_03,7_89_67,2_95_46,23,8_03,20,25,4_16,5,8,2_32,4,2_77,6,18_55,46_01,3,2_95_46,54,8,36_09,5,5_72_11,49,4,1,2_77,18,8,17_55,1_56_91,3,3_41,25,4_16,6_93,4_25_73,71,17,4_01,94,31,1_79_19,2,2_95_46,78_73,18,1,4_35,23,1_10_11,7_55,5,51_67,3,79_83,98,84,2,2_95_46,32_67,8,36_09,4,1,48_65,10_75,2,60_87,71,6,3_46,8,58_54,3,2_95_46,8_24,14_00,18_68,2,19,1_60,2,3_11,8,54_96,2,2_09_20,17,25,1_50_97,3,24,24,0,33,1,18_57,2,1,10_09,4,11_09,1_17_39,47_62,3_58,5,25,2_45,28,11_10,3,13,10_41,4,24,6_03,4_90,2,7_14_77,2_00_98,10_44_47,2,2_09_61,1,26_04,4,1,3_29,3,0]  # noqa: E231
     # fmt: on
     #  In 1991, the remains of Russian Tsar Nicholas II and his family (
     #  except for Alexei and Maria ) are discovered. The voice of young son,
     #  Tsarevich Alexei Nikolaevich, narrates the remainder of the story.
     #  1883 Western Siberia, a young Grigori Rasputin is asked by his father
     #  and a group of men to perform magic. Rasputin has a vision and
     #  denounces one of the men as a horse thief. Although his father initially
     #  slaps him for making such an accusation, Rasputin watches as the man
     #  is chased outside and beaten. Twenty years later, Rasputin sees a vision
     #  of the Virgin Mary, prompting him to become a priest.
     #  Rasputin quickly becomes famous, with people, even a bishop, begging for
     #  his blessing. <unk> <unk> <eos> In the 1990s, the remains of Russian Tsar
     # Nicholas II and his family were discovered. The voice of <unk> young son,
     # Tsarevich Alexei Nikolaevich, narrates the remainder of the story.<eos>

     A__				=			model.generate(lowercase_						,       max_length=2_00						,       do_sample=lowercase_							)
     self.assertListEqual(output_ids[0].numpy().tolist()						,       lowercase_							)










'''simple docstring'''

from __future__ import annotations

import time

import numpy as np

__lowerCAmelCase							:	Optional[Any]			=[8, 5, 9, 7]
__lowerCAmelCase							:	Optional[int]			=[
    [2, 0, 1, 1],
    [0, 1, 2, 1],
    [4, 0, 0, 3],
    [0, 2, 1, 0],
    [1, 0, 3, 0],
]
__lowerCAmelCase							:	List[Any]			=[
    [3, 2, 1, 4],
    [0, 2, 5, 2],
    [5, 1, 0, 5],
    [1, 5, 3, 0],
    [3, 0, 3, 3],
]






class    UpperCAmelCase	:
 def __init__(				self      :Optional[int]						,       lowercase_      :list[int]						,       lowercase_      :list[list[int]]						,       lowercase_      :list[list[int]]						,       )->							None:
     A__				=			claim_vector
     A__				=			allocated_resources_table
     A__				=			maximum_claim_table
 def      UpperCAmelCase_							(				self      :Union[str, Any]							)->							list[int]:
     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      :Tuple							)->							list[int]:
     return np.array(self.__claim_vector							) - np.array(
         self.__processes_resource_summation()							)
 def      UpperCAmelCase_							(				self      :Dict							)->							list[list[int]]:
     return [
         list(np.array(self.__maximum_claim_table[i]							) - np.array(lowercase_							)							)
         for i, allocated_resource in enumerate(self.__allocated_resources_table							)
     ]
 def      UpperCAmelCase_							(				self      :Any							)->							dict[int, list[int]]:
     return {self.__need().index(lowercase_							): i for i in self.__need()}
 def      UpperCAmelCase_							(				self      :Tuple						,       **lowercase_      :List[str]							)->							None:
     A__				=			self.__need()
     A__				=			self.__allocated_resources_table
     A__				=			self.__available_resources()
     A__				=			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:
         A__				=			False
         for each_need in need_list:
             A__				=			True
             for index, need in enumerate(lowercase_							):
                 if need > available_resources[index]:
                     A__				=			False
                     break
             if execution:
                 A__				=			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:
                         A__				=			original_need_index
                 print(F"Process {process_number + 1} is executing."							)
                 # remove the process run from stack
                 need_list.remove(lowercase_							)
                 # update available/freed resources stack
                 A__				=			np.array(lowercase_							) + np.array(
                     alloc_resources_table[process_number]							)
                 print(
                     "Updated available resource stack for processes: "
                     + " ".join([str(lowercase_							) 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      :Optional[Any]							)->							Tuple:
     print(" " * 9 + "Allocated Resource Table"							)
     for item in self.__allocated_resources_table:
         print(
             F"P{self.__allocated_resources_table.index(lowercase_							) + 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(lowercase_							) + 1}"
             + " ".join(F"{it:>8}" for it in item							)
             + "\n"							)
     print(
         "Current Usage by Active Processes: "
         + " ".join(str(lowercase_							) for x in self.__claim_vector							)							)
     print(
         "Initial Available Resources:       "
         + " ".join(str(lowercase_							) for x in self.__available_resources()							)							)
     time.sleep(1							)


if __name__ == "__main__":
  import doctest

  doctest.testmod()



