



import math






def 	snake_case_  (				):


       '''simple docstring'''





       _lowerCamelCase						:    Union[str, Any]         =			input('''Enter message: '''						)
       _lowerCamelCase						:    Optional[Any]         =			int(input(F'''Enter key [2-{len(A__						) - 1}]: '''						)						)
       _lowerCamelCase						:    Union[str, Any]         =			input('''Encryption/Decryption [e/d]: '''						)

       if mode.lower().startswith('''e'''						):
              _lowerCamelCase						:    List[str]         =			encrypt_message(A__,    A__						)
       elif mode.lower().startswith('''d'''						):
              _lowerCamelCase						:    Dict         =			decrypt_message(A__,    A__						)

       # Append pipe symbol (vertical bar) to identify spaces at the end.
       print(F'''Output:\n{text + "|"}'''						)






def 	snake_case_  (				A_ :		int,    A_ :		str						):


       '''simple docstring'''





       _lowerCamelCase						:    List[Any]         =			[""""""] * key
       for col in range(A__						):
              _lowerCamelCase						:    Tuple         =			col
              while pointer < len(A__						):
                     cipher_text[col] += message[pointer]
                     pointer += key
       return "".join(A__						)






def 	snake_case_  (				A_ :		int,    A_ :		str						):


       '''simple docstring'''





       _lowerCamelCase						:    Tuple         =			math.ceil(len(A__						) / key						)
       _lowerCamelCase						:    int         =			key
       _lowerCamelCase						:    List[str]         =			(num_cols * num_rows) - len(A__						)
       _lowerCamelCase						:    Any         =			[""""""] * num_cols
       _lowerCamelCase						:    Dict         =			0
       _lowerCamelCase						:    Any         =			0

       for symbol in message:
              plain_text[col] += symbol
              col += 1

              if (
                  (col == num_cols)
                  or (col == num_cols - 1)
                  and (row >= num_rows - num_shaded_boxes)
              ):
                     _lowerCamelCase						:    Optional[int]         =			0
                     row += 1

       return "".join(A__						)


if __name__ == "__main__":
   import doctest

   doctest.testmod()
   main()







"""simple docstring"""






import logging
import os
from typing import List, Tuple

import numpy as np
import psutil
import torch
import torch.distributed as dist

from transformers import RagRetriever


lowerCAmelCase__      =    logging.getLogger(__name__)






class 	__snake_case	(     _lowercase):




  def __init__(			self					:						Union[str, Any]						, __lowerCAmelCase					:						Optional[int]						, __lowerCAmelCase					:						Optional[Any]						, __lowerCAmelCase					:						List[str]						, __lowerCAmelCase					:						int=None		):






         """simple docstring"""






         super().__init__(
             __lowerCAmelCase						, question_encoder_tokenizer=__lowerCAmelCase						, generator_tokenizer=__lowerCAmelCase						, index=__lowerCAmelCase						, init_retrieval=__lowerCAmelCase						, )
         _lowerCamelCase						:    Dict         =			None




  def 						SCREAMING_SNAKE_CASE    (			self					:						Dict						, __lowerCAmelCase					:						int		):






         """simple docstring"""






         logger.info('''initializing retrieval'''		)

         # initializing a separate process group for retrieval as the default
         # nccl backend doesn't support gather/scatter operations while gloo
         # is too slow to replace nccl for the core gpu communication
         if dist.is_initialized():
                logger.info('''dist initialized'''		)
                # needs to be set manually
                _lowerCamelCase						:    List[str]         =			self._infer_socket_ifname()
                # avoid clash with the NCCL port
                _lowerCamelCase						:    Dict         =			str(distributed_port + 1		)
                _lowerCamelCase						:    str         =			dist.new_group(ranks=__lowerCAmelCase						, backend='''gloo'''		)

         # initialize retriever only on the main worker
         if not dist.is_initialized() or self._is_main():
                logger.info('''dist not initialized / main'''		)
                self.index.init_index()

         # all processes wait untill the retriever is initialized by the main process
         if dist.is_initialized():
                torch.distributed.barrier(group=self.process_group		)




  def 						SCREAMING_SNAKE_CASE    (			self					:						Optional[Any]		):






         """simple docstring"""






         return dist.get_rank(group=self.process_group		) == 0




  def 						SCREAMING_SNAKE_CASE    (			self					:						Union[str, Any]						, __lowerCAmelCase					:						Union[str, Any]						, __lowerCAmelCase					:						List[Any]						, __lowerCAmelCase					:						Tuple=torch.floataa		):






         """simple docstring"""






         _lowerCamelCase						:    Optional[Any]         =			torch.empty(__lowerCAmelCase						, dtype=__lowerCAmelCase		)
         dist.scatter(__lowerCAmelCase						, src=0						, scatter_list=__lowerCAmelCase						, group=self.process_group		)
         return target_tensor




  def 						SCREAMING_SNAKE_CASE    (			self					:						Any		):






         """simple docstring"""






         _lowerCamelCase						:    List[str]         =			psutil.net_if_addrs()
         # a hacky way to deal with varying network interface names
         _lowerCamelCase						:    str         =			next((addr for addr in addrs if addr.startswith('''e'''		))						, __lowerCAmelCase		)
         return ifname




  def 						SCREAMING_SNAKE_CASE    (			self					:						str						, __lowerCAmelCase					:						np.ndarray						, __lowerCAmelCase					:						int		):






         """simple docstring"""






         if not dist.is_initialized():
                _lowerCamelCase      ,   _lowerCamelCase						:    Any         =			self._main_retrieve(__lowerCAmelCase						, __lowerCAmelCase		)
                return retrieved_doc_embeds, doc_ids, self.index.get_doc_dicts(__lowerCAmelCase		)

         # distributed training
         _lowerCamelCase						:    Dict         =			dist.get_world_size(group=self.process_group		)

         # gather logic
         _lowerCamelCase						:    str         =			None
         if self._is_main():
                _lowerCamelCase						:    List[Any]         =			[torch.empty(question_hidden_states.shape						, dtype=torch.floataa		) for _ in range(__lowerCAmelCase		)]
         dist.gather(torch.tensor(__lowerCAmelCase		)						, dst=0						, gather_list=__lowerCAmelCase						, group=self.process_group		)

         # scatter logic
         _lowerCamelCase						:    int         =			question_hidden_states.shape[0]
         _lowerCamelCase						:    str         =			[]
         _lowerCamelCase						:    Optional[int]         =			[]
         if self._is_main():
                assert len(__lowerCAmelCase		) == world_size
                _lowerCamelCase      ,   _lowerCamelCase						:    Tuple         =			self._main_retrieve(torch.cat(__lowerCAmelCase		).numpy()						, __lowerCAmelCase		)
                _lowerCamelCase      ,   _lowerCamelCase						:    List[str]         =			torch.tensor(__lowerCAmelCase		), torch.tensor(__lowerCAmelCase		)
                _lowerCamelCase						:    List[Any]         =			self._chunk_tensor(__lowerCAmelCase						, __lowerCAmelCase		)
                _lowerCamelCase						:    Optional[Any]         =			self._chunk_tensor(__lowerCAmelCase						, __lowerCAmelCase		)
         _lowerCamelCase						:    int         =			self._scattered(__lowerCAmelCase						, [n_queries, n_docs]						, target_type=torch.intaa		)
         _lowerCamelCase						:    str         =			self._scattered(__lowerCAmelCase						, [n_queries, n_docs, question_hidden_states.shape[1]]		)

         return retrieved_doc_embeds.numpy(), doc_ids.numpy(), self.index.get_doc_dicts(__lowerCAmelCase		)


