




'''simple docstring'''




#
# Sort large text files in a minimum amount of memory
#
import argparse
import os

class 						lowerCAmelCase_   :







  '''simple docstring'''







  lowerCAmelCase_				:					int				     =						"""block_{0}.dat"""


  def __init__(						self    :	Any						,		_UpperCAmelCase    :	Union[str, Any] ):






   """simple docstring"""






   UpperCAmelCase__										=    filename
   UpperCAmelCase__										=    []


  def 							SCREAMING_SNAKE_CASE__			(						self    :	Optional[int]						,		_UpperCAmelCase    :	Optional[Any]						,		_UpperCAmelCase    :	Tuple ):






   """simple docstring"""






   UpperCAmelCase__										=    self.BLOCK_FILENAME_FORMAT.format(_UpperCAmelCase )
   with open(_UpperCAmelCase						,		"""w""" ) as file:
    file.write(_UpperCAmelCase )
   self.block_filenames.append(_UpperCAmelCase )


  def 							SCREAMING_SNAKE_CASE__			(						self    :	Any ):






   """simple docstring"""






   return self.block_filenames


  def 							SCREAMING_SNAKE_CASE__			(						self    :	List[Any]						,		_UpperCAmelCase    :	str						,		_UpperCAmelCase    :	Optional[int]=None ):






   """simple docstring"""






   UpperCAmelCase__										=    0
   with open(self.filename ) as file:
    while True:
     UpperCAmelCase__										=    file.readlines(_UpperCAmelCase )

     if lines == []:
      break

     if sort_key is None:
      lines.sort()
     else:
      lines.sort(key=_UpperCAmelCase )

     self.write_block("""""".join(_UpperCAmelCase )						,		_UpperCAmelCase )
     i += 1



  def 							SCREAMING_SNAKE_CASE__			(						self    :	Any ):






   """simple docstring"""






   map(os.remove						,		self.block_filenames )

class 						lowerCAmelCase_   :







  '''simple docstring'''







  def 							SCREAMING_SNAKE_CASE__			(						self    :	Tuple						,		_UpperCAmelCase    :	Tuple ):






   """simple docstring"""






   UpperCAmelCase__										=    -1
   UpperCAmelCase__										=    None

   for i in range(len(_UpperCAmelCase ) ):
    if min_str is None or choices[i] < min_str:
     UpperCAmelCase__										=    i

   return min_index

class 						lowerCAmelCase_   :







  '''simple docstring'''







  def __init__(						self    :	List[str]						,		_UpperCAmelCase    :	Optional[int] ):






   """simple docstring"""






   UpperCAmelCase__										=    files
   UpperCAmelCase__										=    set()
   UpperCAmelCase__										=    len(_UpperCAmelCase )
   UpperCAmelCase__										=    {i: None for i in range(self.num_buffers )}


  def 							SCREAMING_SNAKE_CASE__			(						self    :	Tuple ):






   """simple docstring"""






   return {
       i: self.buffers[i] for i in range(self.num_buffers ) if i not in self.empty
   }


  def 							SCREAMING_SNAKE_CASE__			(						self    :	Dict ):






   """simple docstring"""






   for i in range(self.num_buffers ):
    if self.buffers[i] is None and i not in self.empty:
     UpperCAmelCase__										=    self.files[i].readline()

     if self.buffers[i] == "":
      self.empty.add(_UpperCAmelCase )
      self.files[i].close()

   if len(self.empty ) == self.num_buffers:
    return False

   return True



  def 							SCREAMING_SNAKE_CASE__			(						self    :	List[str]						,		_UpperCAmelCase    :	List[str] ):






   """simple docstring"""






   UpperCAmelCase__										=    self.buffers[index]
   UpperCAmelCase__										=    None

   return value

class 						lowerCAmelCase_   :







  '''simple docstring'''







  def __init__(						self    :	Any						,		_UpperCAmelCase    :	int ):






   """simple docstring"""






   UpperCAmelCase__										=    merge_strategy


  def 							SCREAMING_SNAKE_CASE__			(						self    :	Optional[Any]						,		_UpperCAmelCase    :	Union[str, Any]						,		_UpperCAmelCase    :	Union[str, Any]						,		_UpperCAmelCase    :	str ):






   """simple docstring"""






   UpperCAmelCase__										=    FilesArray(self.get_file_handles(_UpperCAmelCase						,		_UpperCAmelCase ) )
   with open(_UpperCAmelCase						,		"""w"""						,		_UpperCAmelCase ) as outfile:
    while buffers.refresh():
     UpperCAmelCase__										=    self.merge_strategy.select(buffers.get_dict() )
     outfile.write(buffers.unshift(_UpperCAmelCase ) )



  def 							SCREAMING_SNAKE_CASE__			(						self    :	Union[str, Any]						,		_UpperCAmelCase    :	Optional[Any]						,		_UpperCAmelCase    :	Dict ):






   """simple docstring"""






   UpperCAmelCase__										=    {}

   for i in range(len(_UpperCAmelCase ) ):
    UpperCAmelCase__										=    open(filenames[i]						,		"""r"""						,		_UpperCAmelCase )  # noqa: UP015

   return files

class 						lowerCAmelCase_   :







  '''simple docstring'''







  def __init__(						self    :	Optional[Any]						,		_UpperCAmelCase    :	List[str] ):






   """simple docstring"""






   UpperCAmelCase__										=    block_size


  def 							SCREAMING_SNAKE_CASE__			(						self    :	Optional[int]						,		_UpperCAmelCase    :	str						,		_UpperCAmelCase    :	Optional[Any]=None ):






   """simple docstring"""






   UpperCAmelCase__										=    self.get_number_blocks(_UpperCAmelCase						,		self.block_size )
   UpperCAmelCase__										=    FileSplitter(_UpperCAmelCase )
   splitter.split(self.block_size						,		_UpperCAmelCase )

   UpperCAmelCase__										=    FileMerger(NWayMerge() )
   UpperCAmelCase__										=    self.block_size / (num_blocks + 1)
   merger.merge(splitter.get_block_filenames()						,		filename + """.out"""						,		_UpperCAmelCase )

   splitter.cleanup()



  def 							SCREAMING_SNAKE_CASE__			(						self    :	Optional[Any]						,		_UpperCAmelCase    :	Optional[Any]						,		_UpperCAmelCase    :	Dict ):






   """simple docstring"""






   return (os.stat(_UpperCAmelCase ).st_size / block_size) + 1

def    _UpperCamelCase      (				SCREAMING_SNAKE_CASE__			:      Dict       ):
 '''simple docstring'''





 if string[-1].lower() == "k":
  return int(string[:-1]       ) * 1024
 elif string[-1].lower() == "m":
  return int(string[:-1]       ) * 1024 * 1024
 elif string[-1].lower() == "g":
  return int(string[:-1]       ) * 1024 * 1024 * 1024
 else:
  return int(SCREAMING_SNAKE_CASE__       )

def    _UpperCamelCase      (				):
 '''simple docstring'''





 UpperCAmelCase__										=    argparse.ArgumentParser()
 parser.add_argument(
     """-m"""       ,						"""--mem"""       ,						help="""amount of memory to use for sorting"""       ,						default="""100M"""       )
 parser.add_argument(
     """filename"""       ,						metavar="""<filename>"""       ,						nargs=1       ,						help="""name of file to sort"""       )
 UpperCAmelCase__										=    parser.parse_args()

 UpperCAmelCase__										=    ExternalSort(parse_memory(args.mem       )       )
 sorter.sort(args.filename[0]       )


if __name__ == "__main__":
    main()






'''simple docstring'''




from __future__ import annotations

import random
import string

class 						lowerCAmelCase_   :







  '''simple docstring'''







  def __init__(						self    :	int						,		_UpperCAmelCase    :	str | None = None ):






   """simple docstring"""






   UpperCAmelCase__										=    passcode or self.__passcode_creator()
   UpperCAmelCase__										=    self.__make_key_list()
   UpperCAmelCase__										=    self.__make_shift_key()


  def __str__(						self    :	int ):






   """simple docstring"""






   return "".join(self.__passcode )


  def 							SCREAMING_SNAKE_CASE__			(						self    :	List[str]						,		_UpperCAmelCase    :	list[int] ):






   """simple docstring"""






   for i in range(1						,		len(_UpperCAmelCase )						,		2 ):
    iterlist[i] *= -1
   return iterlist


  def 							SCREAMING_SNAKE_CASE__			(						self    :	int ):






   """simple docstring"""






   UpperCAmelCase__										=    string.ascii_letters + string.digits
   UpperCAmelCase__										=    [random.choice(_UpperCAmelCase ) for _ in range(random.randint(10						,		20 ) )]
   return password


  def 							SCREAMING_SNAKE_CASE__			(						self    :	Tuple ):






   """simple docstring"""






   UpperCAmelCase__										=    (
       string.ascii_letters + string.digits + string.punctuation + """ \t\n"""
   )

   UpperCAmelCase__										=    []

   # creates points known as breakpoints to break the key_list_options at those
   # points and pivot each substring
   UpperCAmelCase__										=    sorted(set(self.__passcode ) )
   UpperCAmelCase__										=    []

   # algorithm for creating a new shuffled list, keys_l, out of key_list_options
   for i in key_list_options:
    temp_list.extend(_UpperCAmelCase )

    # checking breakpoints at which to pivot temporary sublist and add it into
    # keys_l
    if i in breakpoints or i == key_list_options[-1]:
     keys_l.extend(temp_list[::-1] )
     temp_list.clear()

        # returning a shuffled keys_l to prevent brute force guessing of shift key
   return keys_l


  def 							SCREAMING_SNAKE_CASE__			(						self    :	Tuple ):






   """simple docstring"""






   UpperCAmelCase__										=    sum(self.__neg_pos([ord(_UpperCAmelCase ) for x in self.__passcode] ) )
   return num if num > 0 else len(self.__passcode )


  def 							SCREAMING_SNAKE_CASE__			(						self    :	Optional[Any]						,		_UpperCAmelCase    :	str ):






   """simple docstring"""






   UpperCAmelCase__										=    """"""

   # decoding shift like Caesar cipher algorithm implementing negative shift or
   # reverse shift or left shift
   for i in encoded_message:
    UpperCAmelCase__										=    self.__key_list.index(_UpperCAmelCase )
    decoded_message += self.__key_list[
        (position - self.__shift_key) % -len(self.__key_list )
    ]

   return decoded_message



  def 							SCREAMING_SNAKE_CASE__			(						self    :	List[str]						,		_UpperCAmelCase    :	str ):






   """simple docstring"""






   UpperCAmelCase__										=    """"""

   # encoding shift like Caesar cipher algorithm implementing positive shift or
   # forward shift or right shift
   for i in plaintext:
    UpperCAmelCase__										=    self.__key_list.index(_UpperCAmelCase )
    encoded_message += self.__key_list[
        (position + self.__shift_key) % len(self.__key_list )
    ]

   return encoded_message

def    _UpperCamelCase      (				SCREAMING_SNAKE_CASE__			:      str = "Hello, this is a modified Caesar cipher"       ):
 '''simple docstring'''





 UpperCAmelCase__										=    ShuffledShiftCipher()
 return cipa.decrypt(cipa.encrypt(SCREAMING_SNAKE_CASE__       )       )


if __name__ == "__main__":
    import doctest

    doctest.testmod()
