import zlib
import ujson
import time
import psutil
from typing import List
from objects import Job
import core
tic = time.perf_counter()
jobs: List[bytes] = core.loadJobsFromFile(core.init("All", "data/"))
print("Time taken: {}".format(time.perf_counter() - tic))
print(psutil.virtual_memory().percent)
import core
from core import locale
from objects import Job
import numpy as np
from scipy.stats import ttest_ind
from typing import List, cast, Tuple
import matplotlib.pyplot as plt
import ujson
import zlib
import filters
dataFile: str = core.init("All", "data")
data: List[bytes] = core.loadJobsFromFile(dataFile)
stageList: List[str] = []
for line in data:
job: Job = Job(**ujson.loads(zlib.decompress(line)))
if job.stage is not None:
if not (getattr(job.stage.name, locale) in stageList):
stageList.append(getattr(job.stage.name, locale))
listOfData: List[Tuple[List[bytes], List[bytes]]] = []
for stage in stageList:
listOfData.append(
cast(Tuple[List[bytes], List[bytes]], filters.onStages("mem", data, [stage]))
)
with open("reports/stages.txt", "w", encoding="utf-8") as writer:
i: int = 1
for stageFiles in listOfData:
plt.figure(i)
withVal: List[bytes] = stageFiles[0]
withoutVal: List[bytes] = stageFiles[1]
withValClearWaves: List[float] = []
printJobs(dataList)
elif mode == "HypothesisTesting":
hypothesisTesting(dataList)
elif mode == "SortAttributeByStat":
sortAttributeByStat(dataList)
elif mode == "WaveClearPercentageWithWeapon":
waveClearPercentageWithWeapon(dataList)
else:
sys.exit()
print()
print("PrintOverview")
print("PrintJobs")
print("HypothesisTesting")
print("SortAttributeByStat")
print("WaveClearPercentageWithWeapon")
print("Quit")
mode = input("What would you like to do: ")
if __name__ == "__main__":
print("All")
print("User")
scope: str = input("Pick an analysis scope: ")
dataFile: str = core.init(
scope,
ujson.load(open("keys.json", "r"))["statink_key"])
data: List[List[bytes]] = [core.loadJobsFromFile(dataFile)]
while input("Add a filter [Y/N]: ") == "Y":
data = filterBy(data)
processData(data)
] = {}
filterPaths: Tuple[List[bytes], List[bytes]] = cast(
Tuple[List[bytes], List[bytes]],
filters.duringRotationInts("mem", data, [rotation]),
)
withVal: List[bytes] = filterPaths[0]
withoutVal: List[bytes] = filterPaths[1]
if hasJobs("mem", withVal):
if (hasJobs("mem", withVal)) and (hasJobs("mem", withoutVal)):
result["name"] = rotation
result["data"] = core.findWeaponsAndStageByRotation(
"mem", withVal, rotation
)
result["value"] = (
statSummary("mem", withVal, stat)[0]
- statSummary("mem", withoutVal, stat)[0]
)
rotationResultsList.append(result)
pprint.pprint(
sorted(rotationResultsList, key=lambda val: cast(float, val["value"]))
)
if __name__ == "__main__":
# fullPath: str = core.init("User", "disk", ujson.load(open("keys.json", "r"))["statink_key"])
fullPath: str = cast(str, core.init("All", "disk"))
# sortStages(core.loadJobsFromFile(fullPath), "clear_waves")
sortWeapons(core.loadJobsFromFile(fullPath), "clear_waves")
# sortSpecial(core.loadJobsFromFile(fullPath), "clear_waves")
# sortRotation(core.loadJobsFromFile(fullPath), "clear_waves")
import core
from objects import Job
import filters
from core import locale
import ujson
import gzip
import requests
from typing import Dict, List, Union, cast
import pprint
from itertools import combinations
from scipy.stats import ttest_ind
import numpy as np
import zlib
dataFile = cast(str, core.init("All", "data/"))
data = core.loadJobsFromFile(dataFile)
weaponsList: List[Dict[str, Union[str, Dict[str, str]]]] = requests.get(
"https://stat.ink/api/v2/weapon").json()
for grizzWeapon in core.grizzcoWeapons:
new = {
"name": {
locale: grizzWeapon[0]
},
"key": grizzWeapon[1],
"main_ref": grizzWeapon[1],
"type": {
"key": grizzWeapon[2]
},
}
cast(List[Dict[str, Dict[str, str]]],
weaponsList).append(cast(Dict[str, Dict[str, str]], new))
import core
from objects import Job
import numpy as np
from scipy.stats import ttest_ind
from typing import List, cast, Tuple, Optional
import matplotlib.pyplot as plt
import ujson
import zlib
import filters
dataFile: str = "data/salmonAll.jl.gz" # core.init("All", "data/")
data: Optional[List[bytes]] = core.loadJobsFromFile(dataFile)
grizzcoRotationsInts: List[int] = core.findRotationByWeaponsAndStage(
"mem",
cast(List[bytes], data),
weapons=(
"kuma_charger",
"kuma_blaster",
"kuma_brella",
"kuma_slosher",
),
)
result: Tuple[List[bytes], List[bytes]] = cast(
Tuple[List[bytes], List[bytes]],
filters.duringRotationInts("mem", data, grizzcoRotationsInts, "or"),
)
data = None
withVal: List[bytes] = result[0]
withoutVal: List[bytes] = result[1]
withValClearWaves: List[float] = []
withValDangerRate: List[float] = []