'''simple docstring'''


def    _lowerCamelCase       ( lowerCamelCase_   :				str      ,	lowerCamelCase_   :				str  ):



     """simple docstring"""





     if not isinstance(lowerCamelCase_      ,	lowerCamelCase_  ):
          raise TypeError('plaintext must be a string'  )
     if not isinstance(lowerCamelCase_      ,	lowerCamelCase_  ):
          raise TypeError('key must be a string'  )

     if not plaintext:
          raise ValueError('plaintext is empty'  )
     if not key:
          raise ValueError('key is empty'  )

     key += plaintext
     UpperCAmelCase_				:  Optional[Any]  = plaintext.lower()
     UpperCAmelCase_				:  List[str]  = key.lower()
     UpperCAmelCase_				:  List[Any]  = 0
     UpperCAmelCase_				:  Optional[int]  = 0
     UpperCAmelCase_				:  List[Any]  = ''
     while plaintext_iterator < len(lowerCamelCase_  ):
          if (
              ord(plaintext[plaintext_iterator]  ) < 97
              or ord(plaintext[plaintext_iterator]  ) > 122
          ):
               ciphertext += plaintext[plaintext_iterator]
               plaintext_iterator += 1
          elif ord(key[key_iterator]  ) < 97 or ord(key[key_iterator]  ) > 122:
               key_iterator += 1
          else:
               ciphertext += chr(
                   (
                       (ord(plaintext[plaintext_iterator]  ) - 97 + ord(key[key_iterator]  ))
                       - 97
                   )
                   % 26
                   + 97  )
               key_iterator += 1
               plaintext_iterator += 1
     return ciphertext


def    _lowerCamelCase       ( lowerCamelCase_   :				str      ,	lowerCamelCase_   :				str  ):



     """simple docstring"""





     if not isinstance(lowerCamelCase_      ,	lowerCamelCase_  ):
          raise TypeError('ciphertext must be a string'  )
     if not isinstance(lowerCamelCase_      ,	lowerCamelCase_  ):
          raise TypeError('key must be a string'  )

     if not ciphertext:
          raise ValueError('ciphertext is empty'  )
     if not key:
          raise ValueError('key is empty'  )

     UpperCAmelCase_				:  Optional[Any]  = key.lower()
     UpperCAmelCase_				:  int  = 0
     UpperCAmelCase_				:  Optional[Any]  = 0
     UpperCAmelCase_				:  Tuple  = ''
     while ciphertext_iterator < len(lowerCamelCase_  ):
          if (
              ord(ciphertext[ciphertext_iterator]  ) < 97
              or ord(ciphertext[ciphertext_iterator]  ) > 122
          ):
               plaintext += ciphertext[ciphertext_iterator]
          else:
               plaintext += chr(
                   (ord(ciphertext[ciphertext_iterator]  ) - ord(key[key_iterator]  )) % 26
                   + 97  )
               key += chr(
                   (ord(ciphertext[ciphertext_iterator]  ) - ord(key[key_iterator]  )) % 26
                   + 97  )
               key_iterator += 1
          ciphertext_iterator += 1
     return plaintext


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 snake_case__	:     Union[str, Any]      =    int(input('''Type 1 to encrypt or 2 to decrypt:'''))
 if operation == 1:
  snake_case__	:     Dict      =    input('''Typeplaintext to be encrypted:\n''')
  snake_case__	:     List[Any]      =    input('''Type the key:\n''')
  print(encrypt(plaintext, key))
 elif operation == 2:
  snake_case__	:     List[str]      =    input('''Type the ciphertext to be decrypted:\n''')
  snake_case__	:     Optional[int]      =    input('''Type the key:\n''')
  print(decrypt(ciphertext, key))
 decrypt('''jsqqs avvwo''', '''coffee''')














'''simple docstring'''







import csv
import os

import pytest

from datasets import Dataset, DatasetDict, Features, NamedSplit, Value
from datasets.io.csv import CsvDatasetReader, CsvDatasetWriter

from ..utils import assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases





def 					SCREAMING_SNAKE_CASE_			(UpperCamelCase							,     UpperCamelCase ) ->			Dict:
							assert isinstance(UpperCamelCase							,     UpperCamelCase )
							assert dataset.num_rows == 4
							assert dataset.num_columns == 3
							assert dataset.column_names == ["col_1", "col_2", "col_3"]
							for feature, expected_dtype in expected_features.items():
														assert dataset.features[feature].dtype == expected_dtype





@pytest.mark.parametrize("""keep_in_memory"""							,     [False, True] )
def 					SCREAMING_SNAKE_CASE_			(UpperCamelCase							,     UpperCamelCase							,     UpperCamelCase ) ->			Any:
							lowerCamelCase__   :      Any			    =			tmp_path / """cache"""
							lowerCamelCase__   :      int			    =			{"""col_1""": """int64""", """col_2""": """int64""", """col_3""": """float64"""}
							with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
														lowerCamelCase__   :      Any			    =			CsvDatasetReader(UpperCamelCase							,     cache_dir=UpperCamelCase							,     keep_in_memory=UpperCamelCase ).read()
							_check_csv_dataset(UpperCamelCase							,     UpperCamelCase )





@pytest.mark.parametrize(
    """features"""							,     [
        None,
        {"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""},
        {"""col_1""": """string""", """col_2""": """string""", """col_3""": """string"""},
        {"""col_1""": """int32""", """col_2""": """int32""", """col_3""": """int32"""},
        {"""col_1""": """float32""", """col_2""": """float32""", """col_3""": """float32"""},
    ]							,     )
def 					SCREAMING_SNAKE_CASE_			(UpperCamelCase							,     UpperCamelCase							,     UpperCamelCase ) ->			Any:
							lowerCamelCase__   :      Optional[int]			    =			tmp_path / """cache"""
							# CSV file loses col_1 string dtype information: default now is "int64" instead of "string"
							lowerCamelCase__   :      int			    =			{"""col_1""": """int64""", """col_2""": """int64""", """col_3""": """float64"""}
							lowerCamelCase__   :      int			    =			features.copy() if features else default_expected_features
							lowerCamelCase__   :      List[Any]			    =			(
							    Features({feature: Value(UpperCamelCase ) for feature, dtype in features.items()} ) if features is not None else None
							)
							lowerCamelCase__   :      Union[str, Any]			    =			CsvDatasetReader(UpperCamelCase							,     features=UpperCamelCase							,     cache_dir=UpperCamelCase ).read()
							_check_csv_dataset(UpperCamelCase							,     UpperCamelCase )





@pytest.mark.parametrize("""split"""							,     [None, NamedSplit("""train""" ), """train""", """test"""] )
def 					SCREAMING_SNAKE_CASE_			(UpperCamelCase							,     UpperCamelCase							,     UpperCamelCase ) ->			Union[str, Any]:
							lowerCamelCase__   :      Any			    =			tmp_path / """cache"""
							lowerCamelCase__   :      Union[str, Any]			    =			{"""col_1""": """int64""", """col_2""": """int64""", """col_3""": """float64"""}
							lowerCamelCase__   :      List[Any]			    =			CsvDatasetReader(UpperCamelCase							,     cache_dir=UpperCamelCase							,     split=UpperCamelCase ).read()
							_check_csv_dataset(UpperCamelCase							,     UpperCamelCase )
							assert dataset.split == split if split else "train"





@pytest.mark.parametrize("""path_type"""							,     [str, list] )
def 					SCREAMING_SNAKE_CASE_			(UpperCamelCase							,     UpperCamelCase							,     UpperCamelCase ) ->			Union[str, Any]:
							if issubclass(UpperCamelCase							,     UpperCamelCase ):
														lowerCamelCase__   :      int			    =			csv_path
							elif issubclass(UpperCamelCase							,     UpperCamelCase ):
														lowerCamelCase__   :      Tuple			    =			[csv_path]
							lowerCamelCase__   :      Optional[int]			    =			tmp_path / """cache"""
							lowerCamelCase__   :      str			    =			{"""col_1""": """int64""", """col_2""": """int64""", """col_3""": """float64"""}
							lowerCamelCase__   :      Dict			    =			CsvDatasetReader(UpperCamelCase							,     cache_dir=UpperCamelCase ).read()
							_check_csv_dataset(UpperCamelCase							,     UpperCamelCase )





def 					SCREAMING_SNAKE_CASE_			(UpperCamelCase							,     UpperCamelCase							,     UpperCamelCase=("train",) ) ->			int:
							assert isinstance(UpperCamelCase							,     UpperCamelCase )
							for split in splits:
														lowerCamelCase__   :      Optional[Any]			    =			dataset_dict[split]
														assert dataset.num_rows == 4
														assert dataset.num_columns == 3
														assert dataset.column_names == ["col_1", "col_2", "col_3"]
														for feature, expected_dtype in expected_features.items():
																					assert dataset.features[feature].dtype == expected_dtype





@pytest.mark.parametrize("""keep_in_memory"""							,     [False, True] )
def 					SCREAMING_SNAKE_CASE_			(UpperCamelCase							,     UpperCamelCase							,     UpperCamelCase ) ->			Optional[Any]:
							lowerCamelCase__   :      List[Any]			    =			tmp_path / """cache"""
							lowerCamelCase__   :      Dict			    =			{"""col_1""": """int64""", """col_2""": """int64""", """col_3""": """float64"""}
							with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
														lowerCamelCase__   :      Any			    =			CsvDatasetReader({"""train""": csv_path}							,     cache_dir=UpperCamelCase							,     keep_in_memory=UpperCamelCase ).read()
							_check_csv_datasetdict(UpperCamelCase							,     UpperCamelCase )





@pytest.mark.parametrize(
    """features"""							,     [
        None,
        {"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""},
        {"""col_1""": """string""", """col_2""": """string""", """col_3""": """string"""},
        {"""col_1""": """int32""", """col_2""": """int32""", """col_3""": """int32"""},
        {"""col_1""": """float32""", """col_2""": """float32""", """col_3""": """float32"""},
    ]							,     )
def 					SCREAMING_SNAKE_CASE_			(UpperCamelCase							,     UpperCamelCase							,     UpperCamelCase ) ->			int:
							lowerCamelCase__   :      int			    =			tmp_path / """cache"""
							# CSV file loses col_1 string dtype information: default now is "int64" instead of "string"
							lowerCamelCase__   :      Optional[Any]			    =			{"""col_1""": """int64""", """col_2""": """int64""", """col_3""": """float64"""}
							lowerCamelCase__   :      List[str]			    =			features.copy() if features else default_expected_features
							lowerCamelCase__   :      Tuple			    =			(
							    Features({feature: Value(UpperCamelCase ) for feature, dtype in features.items()} ) if features is not None else None
							)
							lowerCamelCase__   :      str			    =			CsvDatasetReader({"""train""": csv_path}							,     features=UpperCamelCase							,     cache_dir=UpperCamelCase ).read()
							_check_csv_datasetdict(UpperCamelCase							,     UpperCamelCase )





@pytest.mark.parametrize("""split"""							,     [None, NamedSplit("""train""" ), """train""", """test"""] )
def 					SCREAMING_SNAKE_CASE_			(UpperCamelCase							,     UpperCamelCase							,     UpperCamelCase ) ->			Any:
							if split:
														lowerCamelCase__   :      Tuple			    =			{split: csv_path}
							else:
														lowerCamelCase__   :      Union[str, Any]			    =			{"""train""": csv_path, """test""": csv_path}
							lowerCamelCase__   :      Dict			    =			tmp_path / """cache"""
							lowerCamelCase__   :      Union[str, Any]			    =			{"""col_1""": """int64""", """col_2""": """int64""", """col_3""": """float64"""}
							lowerCamelCase__   :      Tuple			    =			CsvDatasetReader(UpperCamelCase							,     cache_dir=UpperCamelCase ).read()
							_check_csv_datasetdict(UpperCamelCase							,     UpperCamelCase							,     splits=list(path.keys() ) )
							assert all(dataset[split].split == split for split in path.keys() )





def 					SCREAMING_SNAKE_CASE_			(UpperCamelCase ) ->			Tuple:
							with open(UpperCamelCase							,     encoding="""utf-8""" ) as csvfile:
														yield from csv.reader(UpperCamelCase )





def 					SCREAMING_SNAKE_CASE_			(UpperCamelCase							,     UpperCamelCase ) ->			Optional[int]:
							lowerCamelCase__   :      Union[str, Any]			    =			tmp_path / """cache"""
							lowerCamelCase__   :      List[str]			    =			os.path.join(UpperCamelCase							,     """tmp.csv""" )
							lowerCamelCase__   :      Optional[Any]			    =			CsvDatasetReader({"""train""": csv_path}							,     cache_dir=UpperCamelCase ).read()
							CsvDatasetWriter(dataset["""train"""]							,     UpperCamelCase							,     num_proc=1 ).write()

							lowerCamelCase__   :      Optional[Any]			    =			iter_csv_file(UpperCamelCase )
							lowerCamelCase__   :      str			    =			iter_csv_file(UpperCamelCase )

							for rowa, rowa in zip(UpperCamelCase							,     UpperCamelCase ):
														assert rowa == rowa





def 					SCREAMING_SNAKE_CASE_			(UpperCamelCase							,     UpperCamelCase ) ->			List[str]:
							lowerCamelCase__   :      Any			    =			tmp_path / """cache"""
							lowerCamelCase__   :      List[str]			    =			os.path.join(UpperCamelCase							,     """tmp.csv""" )
							lowerCamelCase__   :      Optional[int]			    =			CsvDatasetReader({"""train""": csv_path}							,     cache_dir=UpperCamelCase ).read()
							CsvDatasetWriter(dataset["""train"""]							,     UpperCamelCase							,     num_proc=2 ).write()

							lowerCamelCase__   :      Tuple			    =			iter_csv_file(UpperCamelCase )
							lowerCamelCase__   :      Union[str, Any]			    =			iter_csv_file(UpperCamelCase )

							for rowa, rowa in zip(UpperCamelCase							,     UpperCamelCase ):
														assert rowa == rowa





def 					SCREAMING_SNAKE_CASE_			(UpperCamelCase							,     UpperCamelCase ) ->			Optional[int]:
							lowerCamelCase__   :      List[Any]			    =			tmp_path / """cache"""
							lowerCamelCase__   :      List[Any]			    =			os.path.join(UpperCamelCase							,     """tmp.csv""" )
							lowerCamelCase__   :      Dict			    =			CsvDatasetReader({"""train""": csv_path}							,     cache_dir=UpperCamelCase ).read()
							with pytest.raises(UpperCamelCase ):
														CsvDatasetWriter(dataset["""train"""]							,     UpperCamelCase							,     num_proc=0 )

