Pyton voice-controlled data encryption

import speech_recognition as sr
import pygame
import uuid
import time
import os

pygame.mixer.pre_init(16000, 16, 2, 4096)
pygame.mixer.init()


def random_key(string_length=16):
    random = str(uuid.uuid4())
    random = random.upper()
    random = random.replace("-", "")
    return random[0:string_length]


def encrypt(key, msg):
    encryped = []
    for i, c in enumerate(msg):
        key_c = ord(key[i % len(key)])
        msg_c = ord(c)
        encryped.append(chr((msg_c + key_c) % 127))
    return ''.join(encryped)


def decrypt(key, encryped):
    msg = []
    for i, c in enumerate(encryped):
        key_c = ord(key[i % len(key)])
        enc_c = ord(c)
        msg.append(chr((enc_c - key_c) % 127))
    return ''.join(msg)


if __name__ == '__main__':
    more = True
    while more:
        # --open application--
        r_op = sr.Recognizer()
        kljuc_op = 'login'
        with sr.Microphone() as source:
            audio_op = r_op.listen(source)
        try:
            prim_op = r_op.recognize_google(audio_op)
            if prim_op == kljuc_op:
                instr = pygame.mixer.Sound('welcome.wav')
                instr.play()
        except sr.UnknownValueError:
            err = pygame.mixer.Sound('error.wav')
            err.play()
            time.sleep(5)
            exit()
        # --generate sequence--
        if prim_op:
            r_pk = sr.Recognizer()
            kljuc_pk = 'key'
            kljuc_del = 'delete'
            fail_pk = 'stop'
            with sr.Microphone() as source:
                audio_pk = r_pk.listen(source)
            try:
                prim_pk = r_pk.recognize_google(audio_pk)
                if prim_pk == fail_pk:
                    abt = pygame.mixer.Sound('close.wav')
                    abt.play()
                    time.sleep(2)
                    exit()
                if prim_pk == kljuc_pk:
                    seq1 = pygame.mixer.Sound('sequence1.wav')
                    seq1.play()
                    with open("generated_key.txt", "w") as myfile:
                        myfile.write(random_key(16))
                    time.sleep(1)
                elif prim_pk == kljuc_del:
                    path = 'C:/Users/Goran Horvat/Desktop/OPB/OPB projekt/files'
                    for root, directories, filenames in os.walk(path):
                        for filename in filenames:
                            if filename.endswith(".txt"):
                                ex = os.path.join(root, filename)
                                os.remove(ex)
                    f_del = pygame.mixer.Sound('deleted.wav')
                    f_del.play()
                    time.sleep(2)
                    exit()
            except sr.UnknownValueError:
                err = pygame.mixer.Sound('error.wav')
                err.play()
                time.sleep(5)
                exit()

        # --existing/new file--
        if prim_pk:
            kljuc_efi = 'open existing'
            kljuc_nfi = 'create'
            fail_fi = 'stop'
            r_fi = sr.Recognizer()
            with sr.Microphone() as source:
                audio_fi = r_fi.listen(source)
            try:
                prim_fi = r_fi.recognize_google(audio_fi)
                if prim_fi == fail_fi:
                    abt = pygame.mixer.Sound('close.wav')
                    abt.play()
                    time.sleep(2)
                    exit()
                if prim_fi == kljuc_efi:
                    loc = 'C:/Users/Goran Horvat/Desktop/OPB/OPB projekt/files'
                    for root, directories, filenames in os.walk(loc):
                        for filename in filenames:
                            if filename.endswith(".txt"):
                                ex = os.path.join(root, filename)
                    f_ex = pygame.mixer.Sound('existing_loaded.wav')
                    f_ex.play()
                elif prim_fi == kljuc_nfi:
                    r_msg = sr.Recognizer()
                    message = pygame.mixer.Sound('message.wav')
                    message.play()

                    with sr.Microphone() as source:
                        audio_msg = r_msg.record(source, 5)
                    try:
                        prim_msg = r_msg.recognize_google(audio_msg)
                        r_file = sr.Recognizer()
                        time.sleep(3)
                        file = pygame.mixer.Sound('file_name.wav')
                        file.play()
                        with sr.Microphone() as source:
                            audio_file = r_file.listen(source)
                        try:
                            prim_file = r_file.recognize_google(audio_file)
                            with open(prim_file+".txt", "w") as myfile:
                                myfile.write(prim_msg)
                            time.sleep(3)
                            f_new = pygame.mixer.Sound('file_new.wav')
                            f_new.play()
                        except sr.UnknownValueError:
                            err = pygame.mixer.Sound('error.wav')
                            err.play()
                            time.sleep(5)
                            exit()
                    except sr.UnknownValueError:
                        err = pygame.mixer.Sound('error.wav')
                        err.play()
                        time.sleep(5)
                        exit()
            except sr.UnknownValueError:
                err = pygame.mixer.Sound('error.wav')
                err.play()
                time.sleep(5)
                exit()

        # --encrypt--
        if prim_pk:
            r_en = sr.Recognizer()
            kljuc_en = 'encrypt'
            fail_en = 'stop'
            with sr.Microphone() as source:
                audio_en = r_en.listen(source)
            try:
                prim_en = r_en.recognize_google(audio_en)
                if prim_en == fail_en:
                    abt = pygame.mixer.Sound('close.wav')
                    abt.play()
                    time.sleep(2)
                    exit()
                if prim_en == kljuc_en:
                    with open("generated_key.txt") as myfile:
                        key_en = "".join(line.rstrip() for line in myfile)
                    cipher_en = key_en
                    seq2 = pygame.mixer.Sound('sequence2.wav')
                    seq2.play()
            except sr.UnknownValueError:
                err = pygame.mixer.Sound('error.wav')
                err.play()
                time.sleep(5)
                exit()
            if prim_fi == 'open existing':
                with open(ex) as efile:
                    new_exists = "".join(line.rstrip() for line in efile)
                encrypted = encrypt(cipher_en, new_exists)
            else:
                with open(prim_file+".txt") as myfile:
                    msg = "".join(line.rstrip() for line in myfile)
                encrypted = encrypt(cipher_en, msg)

            if prim_fi == 'open existing':
                with open(ex+"_encrypted.txt", "w") as efile:
                    efile.write(encrypted)
            else:
                with open(prim_file+"_encrypted.txt", "w") as myfile:
                    myfile.write(encrypted)

            time.sleep(2)
            encr = pygame.mixer.Sound('encryption.wav')
            encr.play()

        # --decrypt--
        if encrypted:
            r_de = sr.Recognizer()
            kljuc_de = 'decrypt'
            fail_de = 'stop'
            with sr.Microphone() as source:
                audio_de = r_de.listen(source)
            try:
                prim_de = r_de.recognize_google(audio_de)
                if prim_de == fail_de:
                    abt = pygame.mixer.Sound('close.wav')
                    abt.play()
                    time.sleep(2)
                    exit()
                if prim_de == kljuc_de:
                    with open("generated_key.txt") as myfile:
                        key_de = "".join(line.rstrip() for line in myfile)
                    cipher_de = key_de
            except sr.UnknownValueError:
                err = pygame.mixer.Sound('error.wav')
                err.play()
                time.sleep(5)
                exit()
            if prim_fi == 'open existing':
                with open(ex+"_encrypted.txt") as efile:
                    new_exists = "".join(line.rstrip() for line in efile)
                decrypted = decrypt(key_de, encrypted)
            else:
                with open(prim_file+"_encrypted.txt") as myfile:
                    msg = "".join(line.rstrip() for line in myfile)
                decrypted = decrypt(key_de, encrypted)

            if prim_fi == 'open existing':
                with open(ex+"_decrypted.txt", "w") as efile:
                    efile.write(decrypted)
            else:
                with open(prim_file+"_decrypted.txt", "w") as myfile:
                    myfile.write(decrypted)
            time.sleep(1)
            decr = pygame.mixer.Sound('decryption.wav')
            decr.play()
            time.sleep(1)

        # --close application--
        if decrypted:
            r_cl = sr.Recognizer()
            kljuc_cl = 'exit'
            with sr.Microphone() as source:
                audio_cl = r_cl.listen(source)
            try:
                prim_cl = r_cl.recognize_google(audio_cl)
                if prim_cl == kljuc_cl:
                    end = pygame.mixer.Sound('close.wav')
                    end.play()
                    time.sleep(2)
                    more = False
                    exit()
            except sr.UnknownValueError:
                err = pygame.mixer.Sound('error.wav')
                err.play()
                time.sleep(5)
                exit()