trial sieve processor

# PREPARATION
import argparse
import math
parser = argparse.ArgumentParser(
    prog="tsproc.py",
    description="Processes test sieve results, and returns the results of the test sieve.",
    epilog="Hopefully I save you some time when test sieving."
           "Also, credits for Stack Overflow for some of the code I stole."
)
parser.add_argument(
    '-b',
    "--basic",
    help="returns only relations found",
    action="store_true"
)
parser.add_argument(
    '-v',
    "--verbose",
    help="includes extra process logs",
    action="store_true"
)
parser.add_argument(
    '-d',
    "--debug",
    help="shows variable info, as well as verbose information",
    action="store_true"
)
parser.add_argument(
    '-i',
    "--input",
    type=str,
    help="file containing ggnfs output(s) (required, isn't it obvious?)",
    required=True
)
parser.add_argument(
    '-l',
    "--length",
    type=int,
    help="amount of q in test sieve block (required for normalized rel calculation)",
    required=True
)

args = parser.parse_args()
def verboseprint(arg): print(arg) if args.verbose or args.debug else ()
def debugprint(arg): print(arg) if args.debug else ()

# PARAMETER GRABBING

# index lines of input file to a list
print("processing file...")
output = open(args.input, 'r')
filelines = output.readlines()
verboseprint("finished reading file")
debugprint(("file lines var:", filelines))

# sanitization part 1 | isolates result lines
verboseprint("isolating result lines...")
def isolate1(detectstring):
    outputs = [x for x in filelines if detectstring in x]
    return outputs

rellines = isolate1("need at least")
debugprint(("rellines list:", rellines))

qlines = isolate1("at user specified")
debugprint(("qlines list:", qlines))

speedlines = isolate1("sec/rel")
debugprint(("speedlines var:", speedlines))

specialqlines = isolate1("special q")
debugprint(("specialqlines var:", specialqlines))

threads = int(len(speedlines) / len(qlines))

# sanitizing part 2 | isolates variables
verboseprint("isolating results from lines...")

def isolate2(listinput, range1, range2):  # function to isolate int values from line
    data = []
    for x in range(len(listinput)):
        currentline = listinput[x]
        datalineunfiltered = (currentline[range1:range2])
        debugprint(("index var:", datalineunfiltered))
        datalineunfiltered = datalineunfiltered.strip()
        dataline = ""
        for y in datalineunfiltered:
            if y.isnumeric():
                dataline += y
        data.append(int(dataline))
        x += 1
    return data

relationdata = isolate2(rellines, 11, 17)
debugprint(("relation data:", relationdata))

qdata = isolate2(qlines, 55, -1)
debugprint(("starting Q data:", qdata))

speeddata = isolate2(speedlines, 31, 39)
debugprint(("speed data:", speeddata))

specialqdata = isolate2(specialqlines, 0, 3)
debugprint(("special Q data:", specialqdata))

# RESULTA
print("file processing complete, calculating results...")

verboseprint("averaging speed...")
avgspeeddata = []
x = 0
while x < len(speeddata):  # averages speed data to average per block
    y = x
    debugprint(x)
    avgspeed = sum(speeddata[y] for y in range(x, x + threads))/threads
    debugprint(("speed average:", avgspeed))
    avgspeeddata.append(avgspeed)
    x += threads

verboseprint("summing special q...")
sumqdata = []
x = 0
while x < len(specialqdata):  # sums special q into total per block
    y = x
    debugprint(x)
    sumq = sum(specialqdata[y] for y in range(x, x + threads))
    debugprint(("special q sum:", sumq))
    sumqdata.append(sumq)
    x += threads

verboseprint("calculating normalized relations...")
normreldata = []
x = 0
while x < len(relationdata):  # gets normalized relation values
    debugprint(x)
    normrel = relationdata[x]*args.length / (sumqdata[x] * math.log(qdata[x]))
    debugprint(("normalized relations:", normrel))
    normreldata.append(normrel)
    x += 1

if not args.basic:
    for x in range(len(normreldata)):
        print("Q=", qdata[x],
              "| yield / normalized yield:", relationdata[x], "/", round(normreldata[x]),
              "| speed (ms/rel):", avgspeeddata[x])
else:
    for x in range(len(normreldata)):
        print("Q=", qdata[x],
            "| yield / normalized yield:", relationdata[x], "/", round(normreldata[x]))