encrypt.py

try:
    import os
    import sys
    from fernet import Fernet

    #check file open by app 
    if  os.path.exists("process/run_by_app_01") :
        os.remove("process/run_by_app_01")
    else:
        sys.exit()

    #read files for encryption
    file = open("process/encrypt_select_file","r" ,encoding='utf8')
    files_for_encrypt = file.read().split("<><><><><>")[:-1]
    file.close()

    #read no. data 
    data_count_total = 0
    data_count_list = []
    for file in files_for_encrypt:
        read_file = open(file ,"rb")
        data_count = 0
        while True:
            if read_file.readline() ==  b"":
                f = open("process/file_read_complete","w")
                f.close()
                while os.path.exists("process/file_read_complete"):
                    #check program is closed ?
                    if os.path.exists("process/exit"):
                        sys.exit()
                data_count_list.append(data_count)
                read_file.close()
                break
            data_count_total += 1
            data_count += 1  
            #check program is closed ?
            if os.path.exists("process/exit"):
                sys.exit()

    #zero line files check
    data_count_list_index = 0
    while data_count_list_index < len(data_count_list) :
        #check program is closed ?
        if os.path.exists("process/exit"):
            sys.exit()
        if data_count_list[data_count_list_index] == 0:
            data_count_list[data_count_list_index] = 1
        data_count_list_index += 1   
    
    
    #get key
    try:
        key_file = open("process/key","rb")
        key = key_file.readline()
    except:
        key = Fernet.generate_key()
        key_file = open("process/key","wb")
        key_file.write(key)
        key_file.close()


    while 1:
        #check program is closed ?
        if os.path.exists("process/exit"):
            sys.exit()
        if os.path.exists("process/encrypt_decrypt_start"):
            break

    #create file name
    def genarate_name(file_name):
        file_type = file_name.split(".")[-1]
        file_name = file_name.replace("."+file_type,"")
        genarated_name  =  file_name + "_ec."  +  file_type
        return genarated_name


    file_index = -1
    for file in files_for_encrypt:
        #one file encrypt start
        progression_file =open("process/progression","w")
        progression_file.write("0")
        progression_file.close()

        #reading and createing files 
        original_file = open(file,"rb")
        encrypted_file = open(genarate_name(file),"wb")

        lines_encrypted = 0
        file_index += 1
        encrypted_target = 1

        while True:
            if int((lines_encrypted/data_count_list[file_index])*100) == encrypted_target :
                try:
                    progression_file = open("process/progression" ,"w")
                    progression_file.write(str(encrypted_target))
                    progression_file.close()
                except:
                    pass
                encrypted_target += 1

            #find errors in percentage
            if int((lines_encrypted/data_count_list[file_index])*100) > 100 :
                try:
                    error_file = open("system error/encrypt pro.txt","a")
                except:
                    error_file = open("system error/encrypt pro.txt","w")
                error_file.write(str(files_for_encrypt[file_index])  + "\n")
                error_file.write(str(lines_encrypted) + "  |  " + str(data_count_list[file_index])  + "\n")
                error_file.write(str(int((lines_encrypted/data_count_list[file_index])*100)) +"%"  + "\n")
                error_file.write("--------------------------------------------------------" + "\n\n")

            #read original file
            original_content = original_file.readline()
        
            #check end of file
            if original_content == b"":
                #one file encrypt completed
                progression_file =open("process/progression","w")
                progression_file.write("100")
                progression_file.close()

                #one file encrypt ended
                file = open("process/file_completed","w")
                file.close()
                while os.path.exists("process/file_completed"):
                    #check program is closed ?
                    if os.path.exists("process/exit"):
                        sys.exit()
                break

            else:
                #encryption
                if lines_encrypted < 10000:
                    encrypted_content = Fernet(key).encrypt(original_content)
                else:
                    encrypted_content = b"`[`>`" + original_content.replace(b" ",b"`>~`") + b"`[`>`"

                #adding new content
                encrypted_content += b"|~~~<>\n"

                #write encrypted content on new file
                encrypted_file.write(encrypted_content)

                #count encrypted lines
                lines_encrypted += 1 


            #check program is closed ?
            if os.path.exists("process/exit"):
                sys.exit()
except Exception as error :
    try :
        os.mkdir("system error")
    except:
        pass
    try:
        f = open("system error/encrypt log.txt" ,"a")
    except:
        f = open("system error/encrypt log.txt" ,"w")
    f.write(str(error)+"\n")
    f.write("-------------------------------------------------------------" + "\n\n")
    f.close()