refactor: simplify !with command argument parsing

app/commands.py

@@ -423,59 +423,6 @@ async def top(ctx: Context) -> Optional[str]:
 # TODO: !compare (compare to previous !last/!top post's map)
 
 
-class ParsingError(str):
-    ...
-
-
-def parse__with__command_args(
-    mode: int,
-    args: Sequence[str],
-) -> Union[Mapping[str, Any], ParsingError]:
-    """Parse arguments for the !with command."""
-
-    # tried to balance complexity vs correctness for this function
-    # TODO: it can surely be cleaned up further - need to rethink it?
-
-    if not args or len(args) > 4:
-        return ParsingError("Invalid syntax: !with <acc/nmiss/combo/mods ...>")
-
-    # !with 95% 1m 429x hddt
-    acc = mods = combo = nmiss = None
-
-    # parse acc, misses, combo and mods from arguments.
-    # tried to balance complexity vs correctness here
-    for arg in (str.lower(arg) for arg in args):
-        # mandatory suffix, combo & nmiss
-        if combo is None and arg.endswith("x") and arg[:-1].isdecimal():
-            combo = int(arg[:-1])
-            # if combo > bmap.max_combo:
-            #    return "Invalid combo."
-        elif nmiss is None and arg.endswith("m") and arg[:-1].isdecimal():
-            nmiss = int(arg[:-1])
-            # TODO: store nobjects?
-            # if nmiss > bmap.combo:
-            #    return "Invalid misscount."
-        else:
-            # optional prefix/suffix, mods & accuracy
-            arg_stripped = arg.removeprefix("+").removesuffix("%")
-            if mods is None and arg_stripped.isalpha() and len(arg_stripped) % 2 == 0:
-                mods = Mods.from_modstr(arg_stripped)
-                mods = mods.filter_invalid_combos(mode)
-            elif acc is None and arg_stripped.replace(".", "", 1).isdecimal():
-                acc = float(arg_stripped)
-                if not 0 <= acc <= 100:
-                    return ParsingError("Invalid accuracy.")
-            else:
-                return ParsingError(f"Unknown argument: {arg}")
-
-    return {
-        "acc": acc,
-        "mods": mods,
-        "combo": combo,
-        "nmiss": nmiss,
-    }
-
-
 @command(Privileges.UNRESTRICTED, aliases=["w"], hidden=True)
 async def _with(ctx: Context) -> Optional[str]:
     """Specify custom accuracy & mod combinations with `/np`."""
@@ -491,44 +438,49 @@ async def _with(ctx: Context) -> Optional[str]:
     if not await ensure_local_osu_file(osu_file_path, bmap.id, bmap.md5):
         return "Mapfile could not be found; this incident has been reported."
 
-    mode_vn = ctx.player.last_np["mode_vn"]
-
-    command_args = parse__with__command_args(mode_vn, ctx.args)
-    if isinstance(command_args, ParsingError):
-        return str(command_args)
-
-    msg_fields = []
-
-    score_args = ScoreParams(mode=mode_vn)
+    score_args = ScoreParams(mode=ctx.player.last_np["mode_vn"])
+    attributes_table = {
+        "xgeki": "ngeki",
+        "xkatu": "nkatu",
+        "x100": "n100",
+        "x50": "n50",
+        "x": "combo",
+        "m": "nmiss",
+        "%": "acc",
+    }
 
-    mods = command_args["mods"]
-    if mods is not None:
-        score_args.mods = mods
-        msg_fields.append(f"{mods!r}")
+    for arg in (arg.lower() for arg in ctx.args):
+        try:
+            if arg.startswith("+"):
+                score_args.mods = Mods.from_modstr(arg[1:]).filter_invalid_combos(
+                    ctx.player.last_np["mode_vn"],
+                )
+                continue
 
-    nmiss = command_args["nmiss"]
-    if nmiss:
-        score_args.nmiss = nmiss
-        msg_fields.append(f"{nmiss}m")
+            for (suffix, attribute) in attributes_table.items():
+                if arg.endswith(suffix):
+                    value = None
+                    if attribute == "acc":
+                        value = float(arg[: -len(suffix)])
+                        if not 0 <= value <= 100:
+                            return "Invalid accuracy. (0-100%)"
+                    else:
+                        value = int(arg[: -len(suffix)])
 
-    combo = command_args["combo"]
-    if combo is not None:
-        score_args.combo = combo
-        msg_fields.append(f"{combo}x")
+                    setattr(score_args, attribute, value)
 
-    acc = command_args["acc"]
-    if acc is not None:
-        score_args.acc = acc
-        msg_fields.append(f"{acc:.2f}%")
+        except ValueError as ex:
+            print(ex)
+            return f"Could not parse parameter '{arg}'."
 
     result = app.usecases.performance.calculate_performances(
         osu_file_path=str(osu_file_path),
         scores=[score_args],  # calculate one score
     )
 
-    return "{msg}: {performance:.2f}pp ({star_rating:.2f}*)".format(
-        msg=" ".join(msg_fields), **result[0]  # (first score result)
-    )
+    return "{performance:.2f}pp ({star_rating:.2f}*)".format(
+        **result[0]
+    )  # (first score result)
 
 
 @command(Privileges.UNRESTRICTED, aliases=["req"])