code: 
  
  
  #
  # Sort large text files in a minimum amount of memory
  #
  import argparse
  import os
  
  
  
  
  
  
  
  class 				__SCREAMING_SNAKE_CASE   :
        A				:							str    							=     'block_{0}.dat'
  
  
        def __init__(							self							,						SCREAMING_SNAKE_CASE__		):
              lowercase			:   int					   =		filename
              lowercase			:   List[str]					   =		[]
  
  
        def        __lowerCamelCase			(							self							,						SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__		):
              lowercase			:   List[Any]					   =		self.BLOCK_FILENAME_FORMAT.format(SCREAMING_SNAKE_CASE__		)
              with open(SCREAMING_SNAKE_CASE__							,						'''w'''		) as file:
                    file.write(SCREAMING_SNAKE_CASE__		)
              self.block_filenames.append(SCREAMING_SNAKE_CASE__		)
  
  
        def        __lowerCamelCase			(							self		):
              return self.block_filenames
  
  
        def        __lowerCamelCase			(							self							,						SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__=None		):
              lowercase			:   Tuple					   =		0
              with open(self.filename		) as file:
                    while True:
                          lowercase			:   Any					   =		file.readlines(SCREAMING_SNAKE_CASE__		)
  
                          if lines == []:
                                break
  
                          if sort_key is None:
                                lines.sort()
                          else:
                                lines.sort(key=SCREAMING_SNAKE_CASE__		)
  
                          self.write_block(''''''.join(SCREAMING_SNAKE_CASE__		)							,						SCREAMING_SNAKE_CASE__		)
                          i += 1
  
  
  
  
  
  
        def        __lowerCamelCase			(							self		):
              map(os.remove							,						self.block_filenames		)
  
  
  
  
  
  
  
  class 				__SCREAMING_SNAKE_CASE   :
  
  
        def        __lowerCamelCase			(							self							,						SCREAMING_SNAKE_CASE__		):
              lowercase			:   int					   =		-1
              lowercase			:   List[str]					   =		None
  
              for i in range(len(SCREAMING_SNAKE_CASE__		)		):
                    if min_str is None or choices[i] < min_str:
                          lowercase			:   Dict					   =		i
  
              return min_index
  
  
  
  
  
  
  
  class 				__SCREAMING_SNAKE_CASE   :
  
  
        def __init__(							self							,						SCREAMING_SNAKE_CASE__		):
              lowercase			:   Tuple					   =		files
              lowercase			:   List[Any]					   =		set()
              lowercase			:   Dict					   =		len(SCREAMING_SNAKE_CASE__		)
              lowercase			:   Optional[Any]					   =		{i: None for i in range(self.num_buffers		)}
  
  
        def        __lowerCamelCase			(							self		):
              return {
                  i: self.buffers[i] for i in range(self.num_buffers		) if i not in self.empty
              }
  
  
        def        __lowerCamelCase			(							self		):
              for i in range(self.num_buffers		):
                    if self.buffers[i] is None and i not in self.empty:
                          lowercase			:   Optional[int]					   =		self.files[i].readline()
  
                          if self.buffers[i] == "":
                                self.empty.add(SCREAMING_SNAKE_CASE__		)
                                self.files[i].close()
  
              if len(self.empty		) == self.num_buffers:
                    return False
  
              return True
  
  
  
  
  
  
        def        __lowerCamelCase			(							self							,						SCREAMING_SNAKE_CASE__		):
              lowercase			:   List[str]					   =		self.buffers[index]
              lowercase			:   Tuple					   =		None
  
              return value
  
  
  
  
  
  
  
  class 				__SCREAMING_SNAKE_CASE   :
  
  
        def __init__(							self							,						SCREAMING_SNAKE_CASE__		):
              lowercase			:   List[Any]					   =		merge_strategy
  
  
        def        __lowerCamelCase			(							self							,						SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__		):
              lowercase			:   Optional[Any]					   =		FilesArray(self.get_file_handles(SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__		)		)
              with open(SCREAMING_SNAKE_CASE__							,						'''w'''							,						SCREAMING_SNAKE_CASE__		) as outfile:
                    while buffers.refresh():
                          lowercase			:   Any					   =		self.merge_strategy.select(buffers.get_dict()		)
                          outfile.write(buffers.unshift(SCREAMING_SNAKE_CASE__		)		)
  
  
  
  
  
  
        def        __lowerCamelCase			(							self							,						SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__		):
              lowercase			:   Optional[int]					   =		{}
  
              for i in range(len(SCREAMING_SNAKE_CASE__		)		):
                    lowercase			:   int					   =		open(filenames[i]							,						'''r'''							,						SCREAMING_SNAKE_CASE__		)  # noqa: UP015
  
              return files
  
  
  
  
  
  
  
  class 				__SCREAMING_SNAKE_CASE   :
  
  
        def __init__(							self							,						SCREAMING_SNAKE_CASE__		):
              lowercase			:   int					   =		block_size
  
  
        def        __lowerCamelCase			(							self							,						SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__=None		):
              lowercase			:   Optional[int]					   =		self.get_number_blocks(SCREAMING_SNAKE_CASE__							,						self.block_size		)
              lowercase			:   Union[str, Any]					   =		FileSplitter(SCREAMING_SNAKE_CASE__		)
              splitter.split(self.block_size							,						SCREAMING_SNAKE_CASE__		)
  
              lowercase			:   List[Any]					   =		FileMerger(NWayMerge()		)
              lowercase			:   List[Any]					   =		self.block_size / (num_blocks + 1)
              merger.merge(splitter.get_block_filenames()							,						filename + '''.out'''							,						SCREAMING_SNAKE_CASE__		)
  
              splitter.cleanup()
  
  
  
  
  
  
        def        __lowerCamelCase			(							self							,						SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__		):
              return (os.stat(SCREAMING_SNAKE_CASE__		).st_size / block_size) + 1
  
  
  
  
  
  def 			__lowercase	(						_UpperCamelCase     )    ->int:
  
  
  
  
  
  
  
        """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(_UpperCamelCase     )
  
  
  
  
  def 			__lowercase	(						)    ->List[Any]:
  
  
  
  
  
  
  
        """simple docstring"""
  
        lowercase			:   Optional[Any]					   =		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'''     )
        lowercase			:   Dict					   =		parser.parse_args()
  
        lowercase			:   Optional[Any]					   =		ExternalSort(parse_memory(args.mem     )     )
        sorter.sort(args.filename[0]     )
  
  
  if __name__ == "__main__":
    main()
  
  
style_context: 
  
  
  from __future__ import annotations
  
  
  
  
  def 			__lowercase	(						_UpperCamelCase     )    ->list[int]:
  
  
  
  
  
  
  
        """simple docstring"""
  
        assert (
            isinstance(_UpperCamelCase,    _UpperCamelCase     ) and mask > 0
        ), f"""mask needs to be positive integer, your input {mask}"""
        lowercase			:   Optional[int]					   =		[]
        lowercase			:   Optional[int]					   =		mask
  
        while submask:
              all_submasks.append(_UpperCamelCase     )
              lowercase			:   Dict					   =		(submask - 1) & mask
  
        return all_submasks
  
  
  if __name__ == "__main__":
    import doctest
  
    doctest.testmod()
  
  