


"""simple docstring"""

import copy

from ...configuration_utils import PretrainedConfig
from ...utils import add_start_docstrings


a_			   =					r'''\n    [`RagConfig`] stores the configuration of a *RagModel*. Configuration objects inherit from [`PretrainedConfig`] and\n    can be used to control the model outputs. Read the documentation from [`PretrainedConfig`] for more information.\n\n    Args:\n        title_sep (`str`, *optional*, defaults to  `\" / \"`):\n            Separator inserted between the title and the text of the retrieved document when calling [`RagRetriever`].\n        doc_sep (`str`, *optional*, defaults to  `\" // \"`):\n            Separator inserted between the text of the retrieved document and the original input when calling\n            [`RagRetriever`].\n        n_docs (`int`, *optional*, defaults to 5):\n            Number of documents to retrieve.\n        max_combined_length (`int`, *optional*, defaults to 300):\n            Max length of contextualized input returned by [`~RagRetriever.__call__`].\n        retrieval_vector_size (`int`, *optional*, defaults to 768):\n            Dimensionality of the document embeddings indexed by [`RagRetriever`].\n        retrieval_batch_size (`int`, *optional*, defaults to 8):\n            Retrieval batch size, defined as the number of queries issues concurrently to the faiss index encapsulated\n            [`RagRetriever`].\n        dataset (`str`, *optional*, defaults to `\"wiki_dpr\"`):\n            A dataset identifier of the indexed dataset in HuggingFace Datasets (list all available datasets and ids\n            using `datasets.list_datasets()`).\n        dataset_split (`str`, *optional*, defaults to `\"train\"`)\n            Which split of the `dataset` to load.\n        index_name (`str`, *optional*, defaults to `\"compressed\"`)\n            The index name of the index associated with the `dataset`. One can choose between `\"legacy\"`, `\"exact\"` and\n            `\"compressed\"`.\n        index_path (`str`, *optional*)\n            The path to the serialized faiss index on disk.\n        passages_path (`str`, *optional*):\n            A path to text passages compatible with the faiss index. Required if using\n            [`~models.rag.retrieval_rag.LegacyIndex`]\n        use_dummy_dataset (`bool`, *optional*, defaults to `False`)\n            Whether to load a \"dummy\" variant of the dataset specified by `dataset`.\n        label_smoothing (`float`, *optional*, defaults to 0.0):\n            Only relevant if `return_loss` is set to `True`. Controls the `epsilon` parameter value for label smoothing\n            in the loss calculation. If set to 0, no label smoothing is performed.\n        do_marginalize (`bool`, *optional*, defaults to `False`):\n            If `True`, the logits are marginalized over all documents by making use of\n            `torch.nn.functional.log_softmax`.\n        reduce_loss (`bool`, *optional*, defaults to `False`):\n            Whether or not to reduce the NLL loss using the `torch.Tensor.sum` operation.\n        do_deduplication (`bool`, *optional*, defaults to `True`):\n            Whether or not to deduplicate the generations from different context documents for a given input. Has to be\n            set to `False` if used while training with distributed backend.\n        exclude_bos_score (`bool`, *optional*, defaults to `False`):\n            Whether or not to disregard the BOS token when computing the loss.\n        output_retrieved(`bool`, *optional*, defaults to `False`):\n            If set to `True`, `retrieved_doc_embeds`, `retrieved_doc_ids`, `context_input_ids` and\n            `context_attention_mask` are returned. See returned tensors for more detail.\n        use_cache (`bool`, *optional*, defaults to `True`):\n            Whether or not the model should return the last key/values attentions (not used by all models).\n        forced_eos_token_id (`int`, *optional*):\n            The id of the token to force as the last generated token when `max_length` is reached. Usually set to\n            `eos_token_id`.\n'''







@add_start_docstrings(__snake_case)
class    __lowercase     (					__snake_case):







						"""simple docstring"""







						_A		:							Optional[int]							       =		"""rag"""
						_A		:							Any							       =		True







						def __init__(self   ,		lowercase__=None   ,		lowercase__=True   ,		lowercase__=None   ,		lowercase__=None   ,		lowercase__=None   ,		lowercase__=None   ,		lowercase__=None   ,		lowercase__=" / "   ,		lowercase__=" // "   ,		lowercase__=5   ,		lowercase__=3_00   ,		lowercase__=7_68   ,		lowercase__=8   ,		lowercase__="wiki_dpr"   ,		lowercase__="train"   ,		lowercase__="compressed"   ,		lowercase__=None   ,		lowercase__=None   ,		lowercase__=False   ,		lowercase__=False   ,		lowercase__=0.0   ,		lowercase__=True   ,		lowercase__=False   ,		lowercase__=False   ,		lowercase__=False   ,		lowercase__=True   ,		lowercase__=None   ,		**lowercase__   ,		):
											super().__init__(
											    bos_token_id=_lowercase   ,		pad_token_id=_lowercase   ,		eos_token_id=_lowercase   ,		decoder_start_token_id=_lowercase   ,		forced_eos_token_id=_lowercase   ,		is_encoder_decoder=_lowercase   ,		prefix=_lowercase   ,		vocab_size=_lowercase   ,		**_lowercase   ,		)
											assert (
											    "question_encoder" in kwargs and "generator" in kwargs
											), "Config has to be initialized with question_encoder and generator config"
											snake_case_					:		Optional[int] 					=					kwargs.pop("""question_encoder"""       )
											snake_case_					:		List[str] 					=					question_encoder_config.pop("""model_type"""       )
											snake_case_					:		List[Any] 					=					kwargs.pop("""generator"""       )
											snake_case_					:		List[Any] 					=					decoder_config.pop("""model_type"""       )

											from ..auto.configuration_auto import AutoConfig

											snake_case_					:		Optional[Any] 					=					AutoConfig.for_model(_lowercase   ,		**_lowercase       )
											snake_case_					:		Optional[Any] 					=					AutoConfig.for_model(_lowercase   ,		**_lowercase       )

											snake_case_					:		Dict 					=					reduce_loss
											snake_case_					:		Tuple 					=					label_smoothing
											snake_case_					:		List[Any] 					=					exclude_bos_score
											snake_case_					:		Optional[int] 					=					do_marginalize

											snake_case_					:		int 					=					title_sep
											snake_case_					:		Any 					=					doc_sep
											snake_case_					:		str 					=					n_docs
											snake_case_					:		int 					=					max_combined_length

											snake_case_					:		List[str] 					=					dataset
											snake_case_					:		Optional[int] 					=					dataset_split
											snake_case_					:		Optional[Any] 					=					index_name

											snake_case_					:		Tuple 					=					retrieval_vector_size
											snake_case_					:		Dict 					=					retrieval_batch_size
											snake_case_					:		Optional[int] 					=					passages_path
											snake_case_					:		Optional[Any] 					=					index_path
											snake_case_					:		int 					=					use_dummy_dataset

											snake_case_					:		List[str] 					=					output_retrieved

											snake_case_					:		List[Any] 					=					do_deduplication

											snake_case_					:		int 					=					use_cache

											if self.forced_eos_token_id is None:
																snake_case_					:		str 					=					getattr(self.generator   ,		"""forced_eos_token_id"""   ,		_lowercase       )







						@classmethod
						def 						__UpperCamelCase							(cls   ,		lowercase__   ,		lowercase__   ,		**lowercase__       ):
											return cls(question_encoder=question_encoder_config.to_dict()   ,		generator=generator_config.to_dict()   ,		**_lowercase       )







						def 						__UpperCamelCase							(self       ):
											snake_case_					:		Union[str, Any] 					=					copy.deepcopy(self.__dict__       )
											snake_case_					:		List[str] 					=					self.question_encoder.to_dict()
											snake_case_					:		Any 					=					self.generator.to_dict()
											snake_case_					:		Optional[Any] 					=					self.__class__.model_type
											return output









"""simple docstring"""

import argparse
import hashlib  # hashlib is only used inside the Test class
import struct







class    __lowercase     :







						"""simple docstring"""







						def __init__(self   ,		lowercase__       ):
											snake_case_					:		Union[str, Any] 					=					data
											snake_case_					:		List[str] 					=					[0X6_7_4_5_2_3_0_1, 0Xe_f_c_d_a_b_8_9, 0X9_8_b_a_d_c_f_e, 0X1_0_3_2_5_4_7_6, 0Xc_3_d_2_e_1_f_0]







						@staticmethod
						def 						__UpperCamelCase							(lowercase__   ,		lowercase__       ):
											return ((n << b) | (n >> (32 - b))) & 0Xf_f_f_f_f_f_f_f







						def 						__UpperCamelCase							(self       ):
											snake_case_					:		Any 					=					B"""\x80""" + B"""\x00""" * (63 - (len(self.data       ) + 8) % 64)
											snake_case_					:		Tuple 					=					self.data + padding + struct.pack(""">Q"""   ,		8 * len(self.data       )       )
											return padded_data







						def 						__UpperCamelCase							(self       ):
											return [
											    self.padded_data[i : i + 64] for i in range(0   ,		len(self.padded_data       )   ,		64       )
											]







						def 						__UpperCamelCase							(self   ,		lowercase__       ):
											snake_case_					:		int 					=					list(struct.unpack(""">16L"""   ,		lowercase__       )       ) + [0] * 64
											for i in range(16   ,		80       ):
																snake_case_					:		Dict 					=					self.rotate((w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16])   ,		1       )
											return w







						def 						__UpperCamelCase							(self       ):
											snake_case_					:		List[Any] 					=					self.padding()
											snake_case_					:		Any 					=					self.split_blocks()
											for block in self.blocks:
																snake_case_					:		Any 					=					self.expand_block(lowercase__       )
																snake_case_					,			snake_case_					,			snake_case_					,			snake_case_					,			snake_case_					:		List[Any] 					=					self.h
																for i in range(0   ,		80       ):
																					if 0 <= i < 20:
																										snake_case_					:		Optional[Any] 					=					(b & c) | ((~b) & d)
																										snake_case_					:		List[str] 					=					0X5_a_8_2_7_9_9_9
																					elif 20 <= i < 40:
																										snake_case_					:		Union[str, Any] 					=					b ^ c ^ d
																										snake_case_					:		Tuple 					=					0X6_e_d_9_e_b_a_1
																					elif 40 <= i < 60:
																										snake_case_					:		str 					=					(b & c) | (b & d) | (c & d)
																										snake_case_					:		List[str] 					=					0X8_f_1_b_b_c_d_c
																					elif 60 <= i < 80:
																										snake_case_					:		Tuple 					=					b ^ c ^ d
																										snake_case_					:		str 					=					0Xc_a_6_2_c_1_d_6
																					snake_case_					,			snake_case_					,			snake_case_					,			snake_case_					,			snake_case_					:		Optional[Any] 					=					(
																					    self.rotate(lowercase__   ,		5       ) + f + e + k + expanded_block[i] & 0Xf_f_f_f_f_f_f_f,
																					    a,
																					    self.rotate(lowercase__   ,		30       ),
																					    c,
																					    d,
																					)
																snake_case_					:		Any 					=					(
																    self.h[0] + a & 0Xf_f_f_f_f_f_f_f,
																    self.h[1] + b & 0Xf_f_f_f_f_f_f_f,
																    self.h[2] + c & 0Xf_f_f_f_f_f_f_f,
																    self.h[3] + d & 0Xf_f_f_f_f_f_f_f,
																    self.h[4] + e & 0Xf_f_f_f_f_f_f_f,
																)
											return ("{:08x}" * 5).format(*self.h       )







def 							SCREAMING_SNAKE_CASE__      (		):



					"""simple docstring"""





					snake_case_					:		Union[str, Any] 					=					b"""Test String"""
					assert SHAaHash(SCREAMING_SNAKE_CASE__			).final_hash() == hashlib.shaa(SCREAMING_SNAKE_CASE__			).hexdigest()  # noqa: S324







def 							SCREAMING_SNAKE_CASE__      (		):



					"""simple docstring"""





					snake_case_					:		int 					=					argparse.ArgumentParser(description="""Process some strings or files"""			)
					parser.add_argument(
					    """--string"""				,    dest="""input_string"""				,    default="""Hello World!! Welcome to Cryptography"""				,    help="""Hash the string"""				,    )
					parser.add_argument("""--file"""				,    dest="""input_file"""				,    help="""Hash contents of a file"""			)
					snake_case_					:		Optional[int] 					=					parser.parse_args()
					snake_case_					:		Optional[int] 					=					args.input_string
					# In any case hash input should be a bytestring
					if args.input_file:
										with open(args.input_file				,    """rb"""			) as f:
															snake_case_					:		List[str] 					=					f.read()
					else:
										snake_case_					:		Dict 					=					bytes(SCREAMING_SNAKE_CASE__				,    """utf-8"""			)
					print(SHAaHash(SCREAMING_SNAKE_CASE__			).final_hash()			)


if __name__ == "__main__":
			main()
			import doctest

			doctest.testmod()




