Logs.TF Stats Calculator v3

import requests
import re
import time
import sys
import os
import threading
import datetime
import calendar
from concurrent.futures import ThreadPoolExecutor, as_completed
from progress.spinner import Spinner
from sty import fg, bg, ef, rs
from sty import Style, RgbFg

fg.redder = Style(RgbFg(255,60,60))
os.system('cls' if os.name == 'nt' else 'clear')
print(fg.redder + "\nCreated by: Mimky" + fg.rs)

SID64 = input("Enter SteamID64: ")

try:
    SID3 = 'U:1:' + (str(int(SID64) - 76561197960265728))
except ValueError:
    print('\nInputted Steam ID was not an Integer.')
    input('\n\nPress Enter to Quit...')
    sys.exit()

logs_prof = 'https://logs.tf/profile/' + SID64
logs = requests.get(logs_prof).text

results = re.search('<p>(.*?)</p>', logs)
p_name = re.search('<title>(.*?)</title>', logs)

try:
    log_count = int(''.join(i for i in results.group(1) if i.isdigit()))
    if log_count > 10000:
        log_count = 10000
except:
    print('\nInvald Steam ID or No Logs on Account.')
    input('\n\nPress Enter to Quit...')
    sys.exit()

if log_count > 25:
    total_pages = int(log_count / 25) + 1
else:
    total_pages = 1

print('\n\n' + str(total_pages) + ' Pages and ' + str(log_count) + ' Logs Found for Player: ' + p_name.group(1)[:-10])

def create_dates():
    global start_date_lst_int
    global end_date_lst_int
    global curdate
    global end_date_epoch
    global start_date_epoch
    global firstdate
    start_date_lst_int = None
    end_date_lst_int = None
    curdate = None
    end_date_epoch = None
    start_date_epoch = None
    firstdate = False

def create_variables1():
    global gamemode_dic
    global gamemode_printed
    gamemode_printed = False

    gamemode_dic = {
    '1' : '[ 1 ] Sixes',
    '2' : '[ 2 ] Highlander',
    '3' : '[ 3 ] Prolander',
    '4' : '[ 4 ] Fours',
    '5' : '[ 5 ] Bball / Ultiduo'
    }

def create_variables2():

    global mercenary_dic
    mercenary_dic = {
    '1' : '[ 1 ] Scout',
    '2' : '[ 2 ] Soldier',
    '3' : '[ 3 ] Pyro',
    '4' : '[ 4 ] Demoman',
    '5' : '[ 5 ] Heavy',
    '6' : '[ 6 ] Engineer',
    '7' : '[ 7 ] Medic',
    '8' : '[ 8 ] Sniper',
    '9' : '[ 9 ] Spy'
    }

create_dates()
create_variables1()
create_variables2()

def print_sorter(string):
    string1 = ''
    for i in string:
        if i in map(chr, range(97, 123)) or i in map(chr, range(65, 91)) or i == ' ' or i == '/':
            string1 += i
    string2 = string1.split('   ')
    for i in string2:
        if i == '':
            string2.remove(i)
    string3 = [x.strip(' ') for x in string2]
    return (', '.join(string3))

def ask_filter_input():
    global filter_input
    filter_input = input('Would you like to filter your search? (y/n)\n> ')
    if filter_input not in ['y', 'n']:
        ask_filter_input()
ask_filter_input()

if filter_input == 'y':

    class Daterange:

        @classmethod
        def daterangeerror(cls, error_code):
            os.system('cls' if os.name == 'nt' else 'clear')
            print(fg.redder + "\nCreated by: Mimky" + fg.rs)
            print('\nError occured while inputting dates.')
            if error_code == 1:
                print('Error Message - Invalid End Date Input.')
            if error_code == 2:
                print('Error Message - Start Date cannot be later than End Date.')
            if error_code == 3:
                print('Error Message - Invalid Start Date Input.')
            create_dates()
            exittomenu2()

        @classmethod
        def daterangeend(cls):
            global end_date_epoch
            global end_date_lst_int
            global curdate
            global firstdate
            print('Enter an End Date (leave blank for current date):')
            end_date_inp = input('\n> ')
            if not end_date_inp:
                end_date_epoch = time.time()
                curdate = time.strftime("%m-%d-%Y").split('-')
                print('Date Range Successfully Defined.')
                exittomenu1()
                return
            end_date_lst_str = end_date_inp.split('/')
            try:
                end_date_lst_int = list(map(int, end_date_lst_str))
                end_date_epoch = int(datetime.datetime(end_date_lst_int[-1],end_date_lst_int[-3],end_date_lst_int[-2]).timestamp())
            except:
                cls.daterangeerror(1)
                return

            if not firstdate:
                if (start_date_epoch > end_date_epoch):
                    cls.daterangeerror(2)
            print('Date Range Successfully Defined.')
            exittomenu1()

        @classmethod
        def daterangestart(cls):
            global start_date_lst_int
            global start_date_epoch
            global firstdate
            os.system('cls' if os.name == 'nt' else 'clear')
            print(fg.redder + "\nCreated by: Mimky" + fg.rs)
            print("Enter a Start Date. \nExample: 6/30/2015 = June 30, 2015 (leave blank for first log's date):")
            start_date_inp = input('\n> ')
            if not start_date_inp:
                start_date_epoch = 'first'
                firstdate = True
                cls.daterangeend()
                return
            start_date_lst_str = start_date_inp.split('/')
            try:
                start_date_lst_int = list(map(int, start_date_lst_str))
                start_date_epoch = int(datetime.datetime(start_date_lst_int[-1],start_date_lst_int[-3],start_date_lst_int[-2]).timestamp())
            except:
                cls.daterangeerror(3)
            if start_date_epoch > time.time():
                cls.daterangeerror(2)
            else:
                cls.daterangeend()



    class Gamemode:

            @classmethod
            def gamemode_error(cls):
                os.system('cls' if os.name == 'nt' else 'clear')
                print(fg.redder + "\nCreated by: Mimky" + fg.rs)
                print('\nError occured while filtering gamemodes.')
                print('Error Message - Gamemode List cannot be empty. List has been reset.')

                create_variables1()
                exittomenu2()

            @classmethod
            def gamemode_interface(cls):
                os.system('cls' if os.name == 'nt' else 'clear')
                print(fg.redder + "\nCreated by: Mimky" + fg.rs)
                if all(value == '' for value in gamemode_dic.values()):
                    cls.gamemode_error()
                    return
                print('Iteration will show logs with these classes:')
                for display in gamemode_dic.values():
                    print(display)
                gamemode_selection = input("\nTo REMOVE a gamemode: Pick 1 - 5 or leave blank to exit.\n> ")
                if not gamemode_selection:
                    menu()
                    return
                if gamemode_selection not in ['1', '2', '3', '4', '5']:
                    cls.gamemode_interface()
                    return
                else:
                    gamemode_dic[gamemode_selection] = ''
                    cls.gamemode_interface()


    class Mercenary:

            @classmethod
            def mercenary_error(cls):
                os.system('cls' if os.name == 'nt' else 'clear')
                print(fg.redder + "\nCreated by: Mimky" + fg.rs)
                print('\nError occured while filtering classes.')
                print('Error Message - Class List cannot be empty. List has been reset.')
                create_variables2()
                exittomenu2()

            @classmethod
            def mercenary_interface(cls):
                os.system('cls' if os.name == 'nt' else 'clear')
                print(fg.redder + "\nCreated by: Mimky" + fg.rs)
                if all(value == '' for value in mercenary_dic.values()):
                    cls.mercenary_error()
                    return
                print('Iteration will show logs with these gamemodes:')
                for display in mercenary_dic.values():
                    print(display)
                mercenary_selection = input("\nTo REMOVE a class: Pick 1 - 9 or leave blank to exit.\n> ")
                if not mercenary_selection:
                    menu()
                    return
                if mercenary_selection not in ['1', '2', '3', '4', '5', '6', '7', '8', '9']:
                    cls.mercenary_interface()
                else:
                    mercenary_dic[mercenary_selection] = ''
                    cls.mercenary_interface()

    def selection(number_filter):
        global start_date_lst_int
        global end_date_lst_int
        global curdate
        global gamemode_dic
        global mercenary_dic

        global firstdate
        global gamemode_printed

        if number_filter not in ['1', '2', '3', '4']:
            menu()
        if number_filter == '1':
            Daterange.daterangestart()

        if number_filter == '2':
            Gamemode.gamemode_interface()

        if number_filter == '3':
            Mercenary.mercenary_interface()

        if number_filter == '4':
            os.system('cls' if os.name == 'nt' else 'clear')
            print(fg.redder + "\nCreated by: Mimky" + fg.rs)

            if start_date_lst_int is not None and end_date_lst_int is not None:
                print('Date Range: ' + calendar.month_name[start_date_lst_int[-3]] + ' ' + str(start_date_lst_int[-2]) + ', ' + str(start_date_lst_int[-1]) + ' - ' + calendar.month_name[end_date_lst_int[-3]] + ' ' + str(end_date_lst_int[-2]) + ', ' + str(end_date_lst_int[-1]))

            elif curdate is not None:
                if not firstdate:
                    print('Date Range: ' + calendar.month_name[start_date_lst_int[-3]] + ' ' + str(start_date_lst_int[-2]) + ', ' + str(start_date_lst_int[-1]) + ' - ' + calendar.month_name[int(curdate[0])] + ' ' + str(curdate[1]) + ', ' + str(curdate[2]))
                else:
                    create_dates()
                    print('Date Range: All')


            elif firstdate and end_date_lst_int is not None:
                print('Date Range: First Log - ' + calendar.month_name[end_date_lst_int[-3]] + ' ' + str(end_date_lst_int[-2]) + ', ' + str(end_date_lst_int[-1]))
            else:
                print('Date Range: All')

            gamemode_printed = False
            for value in gamemode_dic.values():
                if value == '':
                    search_gamemodes = "".join(str(value) for value in gamemode_dic.values())
                    gamemode_printed = True
                    print('Gamemodes: ' + print_sorter(search_gamemodes))
                    break
                else:
                    pass
            if not gamemode_printed:
                print('Gamemodes: All')

            mercenary_printed = False
            for value in mercenary_dic.values():
                if value == '':
                    search_mercenarys = "".join(str(value) for value in mercenary_dic.values())
                    mercenary_printed = True
                    print('Classes: ' + print_sorter(search_mercenarys))
                    break
                else:
                    pass
            if not mercenary_printed:
                print('Classes: All')


            def ask_confirmed():
                global confirmed
                confirmed = input('\nPlease confirm the settings above (y/n)\n> ')
                if confirmed not in ['y', 'n']:
                    ask_confirmed()
            ask_confirmed()

            if confirmed == 'n':
                create_variables1()
                create_variables2()
                create_dates()
                print('\nAll Inputs Reset.')
                exittomenu1()


    def exittomenu1():
        sys.stdout.write('Exiting to Menu in 3')
        sys.stdout.flush()
        time.sleep(1)
        for i in range(2, 0, -1):
            sys.stdout.write('\b')
            sys.stdout.write(str(i))
            sys.stdout.flush()
            time.sleep(1)
        menu()
    def exittomenu2():
        sys.stdout.write('Exiting to Menu in 5')
        sys.stdout.flush()
        time.sleep(1)
        for i in range(4, 0, -1):
            sys.stdout.write('\b')
            sys.stdout.write(str(i))
            sys.stdout.flush()
            time.sleep(1)
        menu()

    def menu():
        os.system('cls' if os.name == 'nt' else 'clear')
        print(fg.redder + "\nCreated by: Mimky" + fg.rs)
        print('''Pick a number.
[ 1 ] Specificy Date Range
[ 2 ] Gamemode Seperation
[ 3 ] Class Seperation
[ 4 ] Finish
''')
        number_filter = input('> ')
        selection(number_filter)

    menu()

start_time = time.time()
if filter_input == 'y':
    spinner = Spinner('Preparing for Iteration based on Current Settings ')
else:
    spinner = Spinner('Preparing for Iteration ')
spinning = True
def start_spin():
    while spinning:
        spinner.next()
        time.sleep(0.1)
    else:
        sys.exit()
t1 = threading.Thread(target=start_spin)
t1.start()

def log_id_finder(seperated_logs):
    global all_log_ids
    all_log_ids = []
    search_term_start = '''            "id": '''
    search_term_end = ''','''
    for i in seperated_logs:
        log_id_search = re.search(search_term_start + '(.*?)' + search_term_end, i)
        all_log_ids.append(log_id_search.group(1))


logsid_prof = requests.get('''https://logs.tf/api/v1/log?player=''' + SID64 + '&limit=10000').text

search1 = re.compile('''        {''' + r'(.*?)' + '''        }''', re.DOTALL)
search2 = search1.findall(logsid_prof)

custom_date_search = False

if start_date_epoch is not None:
    custom_date_search = True

    date_search = re.compile('''"date": ''' + r'(.*?)' + ''',''', re.DOTALL)
    date_lst_str = date_search.findall(logsid_prof)
    date_lst = list(map(int, date_lst_str))
    if start_date_epoch == 'first':
        start_date_epoch = date_lst[-1] - 86400
    date_lst_search = []

    for i in date_lst:
        if start_date_epoch <= i <= end_date_epoch:
            date_lst_search.append('''"date": ''' + str(i) + ',')

    custom_search1 = []
    for i in search2:
        if any(ele in i for ele in date_lst_search):
            custom_search1.append(i)

if gamemode_printed:
    gamemode_search_lst = []
    gamemode_players_search = []

    def add_game_search(playcount):
        gamemode_players_search.append('''            "players": ''' + playcount)

    for key in gamemode_dic.keys():
        if gamemode_dic[key] != '':
            gamemode_search_lst.append(key)
    for i in gamemode_search_lst:
        if i == '1':
            add_game_search('11')
            add_game_search('12')
            add_game_search('13')
        if i == '2':
            add_game_search('17')
            add_game_search('18')
            add_game_search('19')
        if i == '3':
            add_game_search('13')
            add_game_search('14')
            add_game_search('15')
        if i == '4':
            add_game_search('8')
            add_game_search('9')
        if i == '5':
            add_game_search('4')


    if custom_date_search:
        custom_search2 = []
        for i in custom_search1:
            if any(ele in i for ele in gamemode_players_search):
                custom_search2.append(i)
        log_id_finder(custom_search2)
    else:
        custom_search1 = []
        for i in search2:
            if any(ele in i for ele in gamemode_players_search):
                custom_search1.append(i)
        log_id_finder(custom_search1)

elif custom_date_search:
    log_id_finder(custom_search1)

else:
    log_id_finder(search2)

def epoch_time_converter(total_time, col):
    time = total_time % (24 * 3600)
    hour = total_time // 3600
    total_time %= 3600
    minutes = total_time // 60
    total_time %= 60
    seconds = total_time
    if col is False:
        return(str(int(hour)) + ' hours ' + str(int(minutes)) + ' minutes ' + str(int(seconds)) + ' seconds.')
    else:
        return(fg.yellow + str(int(hour)) + fg.rs + ' hours ' + fg.yellow + str(int(minutes)) + fg.rs + ' minutes ' + fg.yellow + str(int(seconds)) + fg.rs + ' seconds.')

eta = len(all_log_ids) * 0.2
print('\n\nEstimated Search Time: ' + epoch_time_converter(eta, False))

mercenary_custom = False
search_mercenarys = "".join(str(value) for value in mercenary_dic.values())
search_mercenarys2 = print_sorter(search_mercenarys).split(', ')
custom_class_lst = [x.lower() for x in search_mercenarys2]
for i in custom_class_lst:
    if i == 'heavy':
        custom_class_lst.remove(i)
        custom_class_lst.append('heavyweapons')

def start_iteration():

    scout_dict = {"time": [], "kills": [], "deaths": [], "dmg": []}
    soldier_dict = {"time": [], "kills": [], "deaths": [], "dmg": []}
    pyro_dict = {"time": [], "kills": [], "deaths": [], "dmg": []}
    demoman_dict = {"time": [], "kills": [], "deaths": [], "dmg": []}
    heavyweapons_dict = {"time": [], "kills": [], "deaths": [], "dmg": []}
    engineer_dict = {"time": [], "kills": [], "deaths": [], "dmg": []}
    medic_dict = {"time": [], "kills": [], "deaths": [], "dmg": [], "healing": [], "drops": [], "charges": []}
    sniper_dict = {"time": [], "kills": [], "deaths": [], "dmg": []}
    spy_dict = {"time": [], "kills": [], "deaths": [], "dmg": []}

    scout_lst = []
    soldier_lst = []
    pyro_lst = []
    demoman_lst = []
    heavyweapons_lst = []
    engineer_lst = []
    medic_lst = []
    sniper_lst = []
    spy_lst = []

    class_lst_search = [scout_lst, soldier_lst, pyro_lst, demoman_lst, heavyweapons_lst, engineer_lst, medic_lst, sniper_lst, spy_lst]
    class_dict_search = [scout_dict, soldier_dict, pyro_dict, demoman_dict, heavyweapons_dict, engineer_dict, medic_dict, sniper_dict, spy_dict]
    cap_lst = []

    global counter
    global log_removal
    global cooldown_check
    counter = 0
    log_removal = 0
    cooldown_check = False
    x2 = []
    x3 = []

    print('\n')


    def multithread_it(log_id):
        global counter
        global log_removal
        global cooldown_check

        while True:
            if not cooldown_check:
                break
            else:
                time.sleep(0.25)

        counter += 1
        log_printer = 'https://logs.tf/json/' + log_id
        print("\nGrabbing logs from: " "{} ({}%)".format(log_printer, round(100*counter/len(all_log_ids), 1)), end = '')
        log_iterator = requests.get(log_printer).text

        flagger = False
        while True:
            if not cooldown_check:
                if not flagger:
                    break
                else:
                    log_iterator = requests.get(log_printer).text
                    break
            else:
                flagger = True
                time.sleep(0.25)

        if "429 Too Many Requests" in log_iterator:
            cooldown_check = True
            print(fg.yellow + ' Cooling Down (Logs.tf Data Request Overflow).' + fg.rs)
            time.sleep(2.25)
            cooldown_check = False
            log_iterator = requests.get(log_printer).text

        x1 = re.search(SID3 + '(.*?)' + 'U:1:', log_iterator)
        try:
            x2.append(x1.group(1))
        except AttributeError:
            print(fg.red + ' ERROR: Log appears to be broken / outdated (skipped).' + fg.rs)
            log_removal += 1


    processes = []
    with ThreadPoolExecutor(max_workers=10) as executor:
        for i in all_log_ids:
            processes.append(executor.submit(multithread_it, i))


    for i in x2:
        y1 = re.search('''"cpc": ''' + '(.*?)' + ''', "''', i)
        y2 = y1.group(1)
        cap_lst.append(y2)
        y3 = i.split('''"type": "''')
        y3.pop(0)
        for e in y3:
            if any(ele in e for ele in custom_class_lst):
                x3.append(e)

    for i in x3:
        y4 = i.split('''", ''')[0]
        try:
            eval(y4 + '_lst').append(i)
        except NameError:
            pass

    for i in class_lst_search:
        for e in i:
            w1 = re.search('''"total_time": ''' + '(.*?)' + '''}''', e)
            w2 = re.search('''"kills": ''' + '(.*?)' + ''', "''', e)
            w3 = re.search('''"deaths": ''' + '(.*?)' + ''', "''', e)
            w4 = re.search('''"dmg": ''' + '(.*?)' + ''', "''', e)
            try:
                z1 = w1.group(1)
                z2 = w2.group(1)
                z3 = w3.group(1)
                z4 = w4.group(1)
            except AttributeError:
                continue
            class_dict_name1 = [k for k, v in locals().items() if v == i][0]
            class_dict_name2 = class_dict_name1.split('_', 1)
            class_dict = eval(class_dict_name2[0] + '_dict')

            class_dict["time"].append(z1)
            class_dict["kills"].append(z2)
            class_dict["deaths"].append(z3)
            class_dict["dmg"].append(z4)

            if class_dict_name2[0] == "medic":
                w5 = re.search('''"heal": ''' + '(.*?)' + ''',''', e)
                w6 = re.search('''"drops": ''' + '(.*?)' + ''',''', e)
                w7 = re.search('''"ubertypes": {"''' + '(.*?)' + '''}''', e)
                try:
                    z5 = w5.group(1)
                    z6 = w6.group(1)
                    z7 = w7.group(1)
                except AttributeError:
                    continue

                class_dict["healing"].append(z5)
                class_dict["drops"].append(z6)

                z8 = z7.split(',')
                for f in z8:
                        numeric_filter = filter(str.isdigit, f)
                        charge_uses = "".join(numeric_filter)
                        class_dict["charges"].append(charge_uses)


    os.system('cls' if os.name == 'nt' else 'clear')
    print(fg.redder + "\nCreated by: Mimky\n" + fg.rs)

    complete_time = 0
    complete_kills = 0
    complete_deaths = 0
    complete_damage = 0

    fg.lightgreen = Style(RgbFg(102,255,102))
    fg.lightred = Style(RgbFg(255,102,102))
    fg.lightpurple = Style(RgbFg(153,51,255))
    fg.lightblue = Style(RgbFg(135,206,235))
    fg.bluerr = Style(RgbFg(0, 150, 255))
    fg.lightyellow = Style(RgbFg(255,255,51))
    fg.pink = Style(RgbFg(255,105,180))

    class_name_printer = 0

    def confirm_quit():
        confirmed = input()
        confirm_quit()

    for dict in class_dict_search:

        total_time = sum(list(map(int, dict["time"])))
        total_kills = sum(list(map(int, dict["kills"])))
        total_deaths = sum(list(map(int, dict["deaths"])))
        total_damage = sum(list(map(int, dict["dmg"])))

        try:
            avg_kills = total_kills / (total_time / 1800)
            avg_deaths = total_deaths / (total_time / 1800)
            total_dpm = total_damage / (total_time / 60)
            total_kd = avg_kills / avg_deaths
        except ZeroDivisionError:
            continue

        class_name1 = [k for k, v in locals().items() if v == dict][0]
        class_name2 = class_name1.split('_', 1)
        class_name3 = class_name2[0]
        if class_name3 not in custom_class_lst:
            continue

        class_name_printer += 1
        class_name = class_name3.upper()
        if class_name == 'HEAVYWEAPONS':
            class_name = 'HEAVY'

        complete_time += total_time
        complete_kills += total_kills
        complete_deaths += total_deaths
        complete_damage += total_damage

        print(class_name + ':\n')
        print('\tTotal Kills:  ' + fg.green + str(total_kills) + fg.rs)
        print('\tTotal Deaths: ' + fg.red + str(total_deaths) + fg.rs)
        print('\tTotal Damage: ' + fg.bluerr + str(total_damage) + fg.rs)

        print('\n\tAverage Kills (Per 30 Minutes):  ' + fg.lightgreen + str(round(avg_kills, 2)) + fg.rs)
        print('\tAverage Deaths (Per 30 Minutes): ' + fg.lightred + str(round(avg_deaths, 2)) + fg.rs)

        print('\n\tTotal DPM: ' + fg.lightblue + str(round(total_dpm, 2)) + fg.rs)
        print('\tTotal K/D: ' + fg.lightpurple + str(round(total_kd, 2)) + fg.rs)
        if class_name == 'MEDIC':
            total_healing = sum(list(map(int, dict["healing"])))
            total_drops = sum(list(map(int, dict["drops"])))
            charges = sum(list(map(int, dict["charges"])))

            print('\n\tTotal Healing: ' + fg.pink + str(total_healing) + fg.rs)
            print('\tTotal Drops: ' + fg.pink + str(total_drops) + fg.rs)
            print('\tTotal Charges: ' + fg.pink + str(charges) + fg.rs)
        print('\tTotal Time Played: ' + epoch_time_converter(total_time, True) + '\n\n')

    end_time = time.time() - start_time
    total_caps = sum(list(map(int, cap_lst)))
    if class_name_printer > 1:
        try:
            print('\nOverall Stats:\n')
            print('\tCombined Kills:  ' + fg.green + str(complete_kills) + fg.rs)
            print('\tCombined Deaths: ' + fg.red + str(complete_deaths) + fg.rs)
            print('\tCombined Damage: ' + fg.bluerr + str(complete_damage) + fg.rs)

            print('\n\tMedian Kills (Per 30 Minutes):  ' + fg.lightgreen + str(round(complete_kills / (complete_time / 1800), 2)) + fg.rs)
            print('\tMedian Deaths (Per 30 Minutes): ' + fg.lightred + str(round(complete_deaths / (complete_time / 1800), 2)) + fg.rs)

            print('\n\tCombined DPM: ' + fg.lightblue + str(round(complete_damage / (complete_time / 60), 2)) + fg.rs)
            print('\tCombined K/D: ' + fg.lightpurple + str(round(complete_kills / complete_deaths, 2)) + fg.rs)
            print('\tCombined Time Played: ' + epoch_time_converter(complete_time, True))
            print('\n\tTotal Caps: ' + fg.lightyellow + str(total_caps) + fg.rs + ' in ' + (str((len(all_log_ids)) - log_removal)) + ' logs.')
            print('\n\nTotal Time Elapsed: ' + epoch_time_converter(end_time, True))

        except ZeroDivisionError:
            os.system('cls' if os.name == 'nt' else 'clear')
            print(fg.redder + "\nCreated by: Mimky\n" + fg.rs)
            print('ZeroDivisionError occurred.\nLog list is invalid.')
            print('Total Time Elapsed: ' + epoch_time_converter(end_time, True))

    else:
        print('Total Caps: ' + fg.lightyellow + str(total_caps) + fg.rs + ' in ' + (str((len(all_log_ids)) - log_removal)) + ' logs.')
        print('\nTotal Time Elapsed: ' + epoch_time_converter(end_time, True))
    confirm_quit()

spinning = False
start_iteration()