def setUpClass(cls):
replay1_path = RES / "replay.osr"
with open(replay1_path, "rb") as f:
data = f.read()
cls._replays = [
parse_replay(data, pure_lzma=False),
parse_replay_file(replay1_path)
]
cls._combination_replay = parse_replay_file(RES / "replay2.osr")
async def _from_replay(self, replay_path):
self.replay_path = replay_path
self.replay = parse_replay_file(self.replay_path)
self.process_replay()
self.get_mods()
self.submission = None
self.cg_replay = None
needs_bg = self.process_beatmap()
await self.get_id()
await self.find_submission()
user_task = asyncio.create_task(self.get_user())
status_task = asyncio.create_task(self.get_status())
ranking_task = asyncio.create_task(self.get_ranking())
bg_task = asyncio.create_task(self.get_background(needs_bg))
diff_task = asyncio.create_task(self.get_difficulty())
await user_task
await status_task
await ranking_task
await bg_task
await diff_task
self.calculate_accuracy()
self.calculate_sliderbreaks()
self.calculate_statistics()
self.find_ur()
self.get_rank()
async def _from_submission(self, submission):
self.submission = submission
self.replay_path = await self.osu_api.download_replay(
self.submission['best_id'])
self.replay = parse_replay_file(self.replay_path)
self.process_submission()
self.process_replay()
self.get_mods()
needs_bg = self.process_beatmap()
self.cg_replay = None
user_task = asyncio.create_task(self.get_user())
bg_task = asyncio.create_task(self.get_background(needs_bg))
status_task = asyncio.create_task(self.get_status())
ranking_task = asyncio.create_task(self.get_ranking())
diff_task = asyncio.create_task(self.get_difficulty())
await user_task
await bg_task
await status_task
await ranking_task
await diff_task
self.calculate_sliderbreaks()
self.calculate_statistics()
self.find_ur()
def find_beatmap_(replay_path, osu_path):
replayfile = osrparse.parse_replay_file(replay_path)
print(replay_path)
osuDb = open(osu_path + '/osu!.db', "rb")
print(str(osuDb))
beatmap = getMapInfo(osuDb.read(), replayfile.beatmap_hash)
osuDb.close()
return beatmap["folder_name"]
def submit_replay(self):
if Logic.submit_replay_lock:
return None
Logic.submit_replay_lock = True
try:
replay_to_submit = self.get_replay()
except PermissionError:
time.sleep(1)
replay_to_submit = self.get_replay()
if replay_to_submit is None:
print("Failed to find replay.")
Logic.submit_replay_lock = False
return None
try:
parsed_replay = parse_replay_file(replay_to_submit)
except PermissionError:
time.sleep(1)
parsed_replay = parse_replay_file(replay_to_submit)
except:
traceback.print_exc(file=sys.stdout)
Logic.submit_replay_lock = False
return None
try:
if parsed_replay.game_mode != GameMode.Standard:
raise Exception('Only osu!standard game mode is supported.')
beatmap = self.get_or_create_beatmap(parsed_replay.beatmap_hash)
profile = self.get_or_create_profile(parsed_replay.player_name)
score = self.get_or_create_or_update_score(parsed_replay, beatmap,
profile)
ranked_pp_obtained, total_pp_obtained, ranks_increased = self.update_profile(
profile)
except:
traceback.print_exc(file=sys.stdout)
Logic.submit_replay_lock = False
return None
Logic.submit_replay_lock = False
latest_score = self.map_score_model(parsed_replay)
latest_pp, latest_score_acc = self.calculate_score_pp(
beatmap.beatmap_id, latest_score)
return score, latest_score, latest_score_acc, latest_pp, ranked_pp_obtained, total_pp_obtained, ranks_increased
def find_beatmap_(replay_path,osu_path):
replayfile = osrparse.parse_replay_file(replay_path)
osuDb = open(osu_path + '/osu!.db', "rb")
beatmap = getMapInfo(osuDb.read(), replayfile.beatmap_hash)
osuDb.close()
try:
logging.info("Loaded beatmap folder {}".format(beatmap["folder_name"]))
return beatmap["folder_name"]
except Exception as e:
logging.error(repr(e))
def main():
# Create hashes of beatmaps and store as dict
beatmap_dict = dict()
for filename in os.listdir(BEATMAP_DIR):
full_path = os.path.join(BEATMAP_DIR, filename)
md5 = hashlib.md5(open(full_path, 'rb').read()).hexdigest()
print("Loaded beatmap", filename, md5)
beatmap_dict[md5] = Beatmap(full_path)
# Process replays
for filename in os.listdir(PROCESS_DIR):
print("Processing replay " + str(filename) + "... ", end='')
replay = parse_replay_file(os.path.join(PROCESS_DIR, filename))
replay.filename = filename # Save filename from osu page
# Found matching beatmap
if replay.beatmap_hash in beatmap_dict:
print("Found matching beatmap")
move_done = False
beatmap = beatmap_dict[replay.beatmap_hash]
spinners_coords = extract_spinner_movement(replay, beatmap)
# Handle multiple spinners per map
for i in range(len(spinners_coords)):
coords = spinners_coords[i]
# Main visualization call
key_data = visualize(replay,
coords,
beatmap,
spinner_ind=i,
export_ps=True)
print("Returning key from visualization", key_data)
if key_data == LEGIT_KEY:
write_coords_csv(replay, i, coords, LEGIT_DIR)
move_done = True
elif key_data == CHEAT_KEY:
write_coords_csv(replay, i, coords, CHEAT_DIR)
move_done = True
elif key_data == SKIP_KEY:
print("Skipping")
else:
raise ValueError("Bad returned key")
if move_done: # Move to done dir
os.rename(os.path.join(PROCESS_DIR, filename),
os.path.join(DONE_DIR, filename))
print("Moved replay to", os.path.join(DONE_DIR, filename))
else:
print("No matching beatmap found! Skipping...")
continue
def main():
path = '- Mike Greene - Bill Nye the Science Guy Theme Song (Chinese Intro) [Easy] (2019-10-14) Osu.osr'
parse = parse_replay_file(path)
api_key = get_api_key()
beatmap_data = call_beatmap_data(api_key, parse.beatmap_hash)
HitObjectsData = get_hitobjects_data()
osr_parse = parse_osr(play_data, HitObjectsData, beatmap_data)
def from_path(path):
"""
Creates a Replay instance from the data contained by file at the given path.
Args:
[String or Path] path: The absolute path to the replay file.
Returns:
The Replay instance created from the given path.
"""
parsed_replay = osrparse.parse_replay_file(path)
check_replay_data = parsed_replay.play_data
enabled_mods = parsed_replay.mod_combination
player_name = parsed_replay.player_name
return LocalReplay(check_replay_data, player_name, enabled_mods)
def load(self, loader, cache):
"""
Loads the data for this replay from the osr file.
Parameters
----------
loader: :class:`~.loader.Loader`
The :class:`~.loader.Loader` to load this replay with.
cache: bool
Whether to cache this replay after loading it. This only has an
effect if ``self.cache`` is unset (``None``). Note that currently
we do not cache :class:`~.ReplayPath` regardless of this parameter.
Notes
-----
If ``replay.loaded`` is ``True``, this method has no effect.
``replay.loaded`` is set to ``True`` after this method is finished.
"""
self.log.debug("Loading ReplayPath %r", self)
if self.loaded:
self.log.debug("%s already loaded, not loading", self)
return
loaded = osrparse.parse_replay_file(self.path)
self.game_version = GameVersion(loaded.game_version, concrete=True)
self.timestamp = loaded.timestamp
self.map_id = loader.map_id(loaded.beatmap_hash)
self.username = loaded.player_name
# our `user_id` attribute is lazy loaded, so we need to retain the
# `Loader#user_id` function to use later to load it.
self._user_id_func = loader.user_id
self._user_id = None
self.mods = Mod(int(loaded.mod_combination))
self.replay_id = loaded.replay_id
self.beatmap_hash = loaded.beatmap_hash
self._process_replay_data(loaded.play_data)
self.loaded = True
self.log.log(TRACE, "Finished loading %s", self)
def get_maplength(self, jsondata):
if Map.name == jsondata["data"]["config"][".osr path"]:
return
Map.name = jsondata["data"]["config"][".osr path"]
try:
replay_data = osrparse.parse_replay_file(
jsondata["data"]["config"][".osr path"])
except Exception as e:
logging.error(repr(e))
Map.length = 1
Map.name = None
return
if Mod.DoubleTime in replay_data.mod_combination or Mod.Nightcore in replay_data.mod_combination:
time_frame = 1500
elif Mod.HalfTime in replay_data.mod_combination:
time_frame = 750
else:
time_frame = 1000
laststring = jsondata["data"]["config"]["Beatmap path"][-1]
if laststring != "/" and laststring != "\\":
jsondata["data"]["config"]["Beatmap path"] += "/"
try:
mappath = get_osu(jsondata["data"]["config"]["Beatmap path"],
replay_data.beatmap_hash)
except BeatmapNotFound:
print("replay not specified yet")
Map.length = 1
Map.name = None
return
color = {"ComboNumber": 1}
osudata = osuparser.read_file(mappath, 1, color, False)
Map.length = osudata.hitobjects[-1]["end time"] - osudata.hitobjects[
0]["time"]
Map.length /= time_frame
#!python3
import sys
from osrparse import parse_replay_file
from decimal import *
#returns instance of Replay
# fileLocation = "Z:\\Program Files (x86)\\osu!\\Data\\r\\63ad71780c93c267b696caf9e1e8a38c-131070592227256434.osr"
# print (str(sys.argv))
fileLocation = sys.argv[1]
file = parse_replay_file(fileLocation)
mods = ""
if (len(file.mod_combination) > 0):
mods +='+'
for i in file.mod_combination:
i = str(i)
if i == 'Mod.NoMod':
mods = '+nomod'
break
if i == 'Mod.NoFail':
mods += 'nf'
if i == 'Mod.Easy':
mods += 'ez'
if i == 'Mod.Hidden':
mods += 'hd'
if i == 'Mod.HardRock':
mods += 'hr'
if i == 'Mod.DoubleTime':
mods += 'dt'
if i == 'Mod.Nightcore':
mods += 'nc'
draw_full_graph_timer(hiterror_graph_canvas, ms, tap_time_list, hiterror_timer_line)
time_label.after(30, draw_difficulty_graphs_timers)
Tk().withdraw()
osr_file_path = filedialog.askopenfilename(title="Select an osr file", filetypes=(("osr files", "*.osr"),))
osu_file_path = filedialog.askopenfilename(title="Select an osu file", filetypes=(("osu files", "*.osu"),))
print("loading/parsing files [1/5]")
osu_file = open(osu_file_path, 'r', encoding="utf-8")
osu_lines = [line.rstrip('\n') for line in osu_file]
mp3_name = beatmap_parser.mp3_name(osu_lines)
mp3_file_path = "/".join(osu_file_path.split("/")[:-1]) + "/{}".format(mp3_name)
replay_file = parse_replay_file(osr_file_path)
replay_mods = [str(mod)[4:] for mod in list(replay_file.mod_combination)]
replay_data = replay_file.play_data
replay_times = [i.time_since_previous_action for i in replay_data]
print("creating hitobject data [2/5]")
speed_multiplier = 1
if "DoubleTime" in replay_mods or "Nightcore" in replay_mods:
speed_multiplier = 1.5
if "HalfTime" in replay_mods:
speed_multiplier = 0.75
hardrock = False
if "HardRock" in replay_mods:
hardrock = True
def cache_replay(path):
# Deleting old files
if parsed_args.verbose:
print("Removing previous temporary files")
if os.path.exists(pathToFile):
os.remove(pathToFile)
if os.path.exists(pathToCsv):
os.remove(pathToCsv)
# Getting files
if not os.path.exists(path):
replay = requests.get(path)
if replay.status_code is not 200:
print("File doesnt exist or cant be downloaded. Exiting...")
return
with open(pathToFile, "wb") as f:
print("Saving replay file")
f.write(replay.content)
else:
with open(path, "rb") as g:
with open(pathToFile, "wb") as f:
print("Saving replay file")
f.write(g.read())
print("Replay file used: \"{0}\".\nGot from \"{1}\"".format(
pathToFile, path))
print("Loading Replay file")
replay = osrparse.parse_replay_file(pathToFile)
# Raw Data to CSV
print("Getting Raw Data from Replay")
x = []
y = []
deltaTime = []
realTime = []
totalTime = 0
keys = []
target = []
t = 1
if parsed_args.legit:
t = 0
# Standard = 0
# Taiko = 1
# CatchTheBeat = 2
# Osumania = 3
if replay.game_mode is not GameMode.Standard:
print("Only supporting std replays (0). Found: {}".format(
replay.game_mode))
return
for playEvent in replay.play_data:
x.append(playEvent.x)
y.append(playEvent.y)
deltaTime.append(playEvent.time_since_previous_action)
keys.append(playEvent.keys_pressed)
totalTime += playEvent.time_since_previous_action
realTime.append(totalTime)
target.append(t)
dataframe = pd.DataFrame({
"x": x,
"y": y,
"deltaTime": deltaTime,
"realTime": realTime,
"keys": keys,
"cheated": target
})
print("Saving Raw Gameplay data to csv")
dataframe.to_csv(pathToCsv)
if parsed_args.verbose:
print(dataframe)