Сортировка данных в файле по ключу

import re
from dateutil import parser
 
with open('in.txt', 'r') as f_in:
    print(*sorted(f_in.readlines(), key=lambda x: parser.parse(re.search(r'(?<=")\d[-:\d ]+', x).group())))

import os
import sys
import time
import dataclasses
import argparse
from pathlib import Path
import shutil
import json
import re
from dateutil.parser import parse
 
 
def time_of_function(function):
    """
    decorator time
    """
    def wrapped(*args):
        start_time = time.perf_counter()
        start_time_ns = time.perf_counter_ns()
        res = function(*args)
        print(f'seconds: {time.perf_counter() - start_time}')
        print(f'nsseconds: {time.perf_counter_ns() - start_time_ns}')
        return res
    return wrapped
 
@dataclasses.dataclass
class ParseArgs(object):
    """Commandline class"""
    def __init__(self):
        parser = argparse.ArgumentParser(description='Tool to generate test logs.')
 
        parser.add_argument(
            'input_dir_1',
            metavar='<INPUT DIR1>',
            type=str,
            help=f'path to dir with generated logs_a',
        )
 
        parser.add_argument(
            'input_dir_2',
            metavar='<INPUT DIR2>',
            type=str,
            help=f'path to dir with generated logs_b',
        )
 
        parser.add_argument(
            '-o',
            '--out',
            metavar='<OUTPUT DIR>',
            type=str,
            default=os.getcwd(),
            help=f'path to dir with output file',
        )
 
        parser.add_argument(
            '-f', '--force',
            action='store_const',
            const=True,
            default=False,
            help='force write log',
            dest='force_write',
        )
 
        self.args = parser.parse_args()
 
    def parse_dir(self) -> list:
        """
        directory return function
        a = ParseArgs()
        a.parse_dir()[0] - path dir file_a
        a.parse_dir()[1] - path dir file_b
        a.parse_dir()[2] - path dir file_out
        """
        return [os.path.dirname(self.args.input_dir_1), os.path.dirname(self.args.input_dir_2), os.path.dirname(self.args.out)]
 
    def parse_filename(self) -> list:
        """
        filenames return function
        a = ParseArgs()
        a.parse_filename()[0] - filename file_a
        a.parse_filename()[1] - filename file_b
        """
        return [os.path.basename(self.args.input_dir_1), os.path.basename(self.args.input_dir_2)]
 
@dataclasses.dataclass
class CreateDir(object):
    """File-out directory class
    dir_path = Path(a.parse_dir()[-1])
    b = CreateDir(dir_path, force_write=args.force_write)
    """
    def __init__(self, dir_path: Path, *, force_write: bool = False) -> None:
        if dir_path.exists():
            if not force_write:
                raise FileExistsError(
                    f'Dir "{dir_path}" already exists. Remove it first or choose another one.')
            shutil.rmtree(dir_path)
        dir_path.mkdir(parents=True)
 
    def func(self):
        """
        new function
        """
        pass
 
@dataclasses.dataclass
class MergeLogFiles(object):
    """A class for merging files"""
    def __init__(self):
        a = ParseArgs()
        self.args = a.args
        self.file_a = args.input_dir_1
        self.file_b = args.input_dir_2
        self.file_out = args.out
 
    @time_of_function
    def jsonl_file(self):
        for infile in self.file_a,self.file_b:
            with open(infile, 'r') as file:
                with open(self.file_out, 'a+') as write_file:
                    for line in file:
                        write_file.write(line)
    @time_of_function
    def jsonl_sorted(self):
        with open(self.file_out, 'r') as f_in:
            print(*sorted(f_in.readlines(), key=lambda x: parse(re.search(r'(?<="date": ")\d[-:\d ]+', x).group())))
 
 
if __name__ == '__main__':
    # Arguments
    a = ParseArgs()
    args = a.args
    # Create dir
    dir_path = Path(a.parse_dir()[-1])
    b = CreateDir(dir_path, force_write=args.force_write)
    # Merge logs
    c = MergeLogFiles()
    c.jsonl_file()
    c.jsonl_sorted()