osudroid-api-wrapper 0.0.5__tar.gz → 0.0.6__tar.gz

{osudroid_api_wrapper-0.0.5 → osudroid_api_wrapper-0.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: osudroid-api-wrapper
-Version: 0.0.5
+Version: 0.0.6
 Summary: Python api wrapper for osu!droid
 Author-email: unclem <mannringyt11@gmail.com>
 License: MIT License

{osudroid_api_wrapper-0.0.5 → osudroid_api_wrapper-0.0.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "osudroid-api-wrapper"
-version = "0.0.5"
+version = "0.0.6"
 authors = [
   { name="unclem", email="mannringyt11@gmail.com" }
 ]

osudroid_api_wrapper-0.0.6/src/osudroid_api_wrapper/__init__.py

@@ -0,0 +1,2 @@
+from .structs import Profile
+from .classes import Replay, Score, ModList, Player, Beatmap, mods

{osudroid_api_wrapper-0.0.5 → osudroid_api_wrapper-0.0.6}/src/osudroid_api_wrapper/classes/__init__.py

@@ -1,5 +1,3 @@
 from .replay import Replay
 from .score import Score
-from .base import Mods, Player, Beatmap
-
-
+from .base import ModList, Player, Beatmap, mods

{osudroid_api_wrapper-0.0.5 → osudroid_api_wrapper-0.0.6}/src/osudroid_api_wrapper/classes/base/__init__.py

@@ -1,3 +1,4 @@
 from .beatmap import Beatmap
 from .player import Player
-from .mods import Mods
+from .modlist import ModList
+

{osudroid_api_wrapper-0.0.5 → osudroid_api_wrapper-0.0.6}/src/osudroid_api_wrapper/classes/base/beatmap.py

@@ -29,7 +29,6 @@ import os
 import requests
 
 dotenv.load_dotenv()
-key = os.getenv("OSU_API_KEY")
 
 
 class Beatmap:
@@ -51,16 +50,17 @@ class Beatmap:
         self.length: int = None
 
     @classmethod
-    def get_beatmap(cls, beatmap_id: int = None, md5: str = None) -> 'Beatmap':
+    def get_beatmap(cls, beatmap_id: int = None, md5: str = None) -> "Beatmap":
+        key = os.getenv("OSU_API_KEY")
+
         beatmap = cls()
         url = "https://old.ppy.sh/api/get_beatmaps"
         if key is "":
-            raise ValueError("API key is not set. Please set the OSU_API_KEY environment variable.")
+            raise ValueError(
+                "API key is not set. Please set the OSU_API_KEY environment variable."
+            )
         if beatmap_id is not None:
-            params = {
-            "k": key,
-            "b": beatmap_id
-            }
+            params = {"k": key, "b": beatmap_id}
             response = requests.get(url, params=params)
             data = response.json()
             if len(data) == 0:
@@ -68,10 +68,7 @@ class Beatmap:
             data = data[0]
 
         elif md5 is not None:
-            params = {
-                "k": key,
-                "h": md5
-            }
+            params = {"k": key, "h": md5}
             response = requests.get(url, params=params)
             data = response.json()
             if len(data) == 0:
@@ -95,9 +92,8 @@ class Beatmap:
         beatmap.star = float(data["difficultyrating"])
         beatmap.length = int(data["total_length"])
         beatmap.combo = int(data["max_combo"])
-        
-        return beatmap
 
+        return beatmap
 
     @property
     def to_dict(self):
@@ -116,5 +112,5 @@ class Beatmap:
             "bpm": self.bpm,
             "star": self.star,
             "length": self.length,
-            "combo": self.combo
+            "combo": self.combo,
         }

osudroid_api_wrapper-0.0.6/src/osudroid_api_wrapper/classes/base/modlist.py

@@ -0,0 +1,255 @@
+from .mods import (
+    Mod,
+    ModApproachDifferent,
+    ModAuto,
+    ModAutopilot,
+    ModCustomSpeed,
+    ModDifficultyAdjust,
+    ModDoubleTime,
+    ModEasy,
+    ModFlashlight,
+    ModHardRock,
+    ModHalfTime,
+    ModHidden,
+    ModMuted,
+    ModNightcore,
+    ModNoFail,
+    ModPerfect,
+    ModPrecise,
+    ModReallyEasy,
+    ModRelax,
+    ModScoreV2,
+    ModSuddenDeath,
+    ModSynesthesia,
+    ModTraceable,
+    ModWindDown,
+    ModWindUp,
+    ModRandom,
+    ModMirror,
+    ModFreezeFrame,
+    ModSmallCircles,
+    ModReplayV6,
+)
+from typing import List
+import re
+import json
+
+# TODO: Fix mod order, remove repeated mapping declarations, check acronyms, add missing mods
+
+
+class ModList:
+
+    def __init__(self, mods=None):
+        self.__mods: List[Mod] = mods
+
+    @classmethod
+    def from_droid_site(cls, mods: str):
+
+        mod_abbreviations: dict[str, type[Mod]] = {
+            "None": "",
+            "Easy": ModEasy,
+            "HalfTime": ModHalfTime,
+            "NoFail": ModNoFail,
+            "ReallyEasy": ModReallyEasy,
+            "DoubleTime": ModDoubleTime,
+            "Flashlight": ModFlashlight,
+            "HardRock": ModHardRock,
+            "Hidden": ModHidden,
+            "Nightcore": ModNightcore,
+            "Perfect": ModPerfect,
+            "Precise": ModPrecise,
+            "SuddenDeath": ModSuddenDeath,
+            "Traceable": ModTraceable,
+        }
+        mod_list = []
+        for mod in mods.split(","):
+            mod = mod.strip()
+            if mod.startswith("CustomSpeed"):
+                mod_list.append(ModCustomSpeed(float(mod.split("(")[1][:-2])))
+                continue
+
+            if mod in mod_abbreviations:
+                if mod == "None":
+                    continue
+                mod_list.append(mod_abbreviations[mod]())
+
+            else:
+                raise ValueError(f"Unknown mod: {mod}")
+
+        return cls(mod_list)
+
+    @classmethod
+    def from_droid_replay_v6(cls, mods: list):
+        mod_mapping = {
+            "MOD_NOFAIL": ModNoFail,
+            "MOD_EASY": ModEasy,
+            "MOD_HIDDEN": ModHidden,
+            "MOD_HARDROCK": ModHardRock,
+            "MOD_SUDDENDEATH": ModSuddenDeath,
+            "MOD_DOUBLETIME": ModDoubleTime,
+            "MOD_RELAX": ModRelax,
+            "MOD_HALFTIME": ModHalfTime,
+            "MOD_NIGHTCORE": ModNightcore,
+            "MOD_FLASHLIGHT": ModFlashlight,
+            "MOD_SCOREV2": ModScoreV2,
+            "MOD_AUTOPILOT": ModAutopilot,
+            "MOD_AUTO": ModAuto,
+            "MOD_PRECISE": ModPrecise,
+            "MOD_REALLYEASY": ModReallyEasy,
+            "MOD_SMALLCIRCLES": ModSmallCircles,
+            "MOD_PERFECT": ModPerfect,
+            "MOD_SUDDENDEATH": ModSuddenDeath,
+        }
+        mod_list = []
+        for mod in mods:
+            if mod in mod_mapping:
+                mod_list.append(mod_mapping[mod]())
+            else:
+                raise ValueError(f"Unknown mod: {mod}")
+
+        return cls(mod_list)
+
+    @classmethod
+    def from_dict(cls, mods: list):
+        mod_classes: List[type[Mod]] = [
+            ModEasy,
+            ModHalfTime,
+            ModNoFail,
+            ModReallyEasy,
+            ModDoubleTime,
+            ModFlashlight,
+            ModHardRock,
+            ModHidden,
+            ModNightcore,
+            ModPerfect,
+            ModPrecise,
+            ModSuddenDeath,
+            ModTraceable,
+            ModAuto,
+            ModAutopilot,
+            ModRelax,
+            ModCustomSpeed,
+            ModDifficultyAdjust,
+            ModMirror,
+            ModRandom,
+            ModScoreV2,
+            ModApproachDifferent,
+            ModFreezeFrame,
+            ModMuted,
+            ModSynesthesia,
+            ModWindDown,
+            ModWindUp,
+        ]
+
+        mod_mapping = {cls_().acronym: cls_() for cls_ in mod_classes}
+
+        mod_list = []
+        for mod in mods:
+            acronym = mod["acronym"]
+            if acronym in mod_mapping:
+                mod_instance = mod_mapping[acronym]
+                settings = mod.get("settings", {})
+                for key, value in settings.items():
+                    try:
+                        mod_instance.settings.set_value(key, value)
+                    except ValueError as e:
+                        raise ValueError(
+                            f"Invalid setting '{key}' for mod '{acronym}': {e}"
+                        )
+                mod_list.append(mod_instance)
+
+        return cls(mod_list)
+
+    @classmethod
+    def from_droid_letters(cls, mods: str):
+        mod_mapping: dict[str, type[Mod]] = {
+            "n": ModNoFail,
+            "e": ModEasy,
+            "h": ModHidden,
+            "r": ModHardRock,
+            "u": ModSuddenDeath,
+            "d": ModDoubleTime,
+            "x": ModCustomSpeed,
+            "t": ModHalfTime,
+            "c": ModNightcore,
+            "i": ModFlashlight,
+            "v": ModScoreV2,
+            "p": ModAutopilot,
+            "a": ModApproachDifferent,
+            "s": ModPrecise,
+            "l": ModReallyEasy,
+            "m": ModSynesthesia,
+            "f": ModPerfect,
+            "b": ModTraceable,
+        }
+        mod_list = []
+        mod_chars = re.sub(r"\bx\d+\.\d+\b|[^a-z]", "", mods)
+        for char in mod_chars:
+            if char in mod_mapping:
+                mod_list.append(mod_mapping[char]())
+            else:
+                raise ValueError(f"Unknown mod character: {char}")
+
+        matchar = re.search(r"\bAR(\d+\.\d+)\b", mods)
+        matchcs = re.search(r"\bCS(\d+\.\d+)\b", mods)
+        matchod = re.search(r"\bOD(\d+\.\d+)\b", mods)
+        matchhp = re.search(r"\bHP(\d+\.\d+)\b", mods)
+        matchsm = re.search(r"\bx(\d+\.\d+)\b", mods, re.IGNORECASE)
+        matchfld = re.search(r"\bFLD(\d+\.\d+)\b", mods)
+
+        if matchar or matchcs or matchod or matchhp:
+            da = ModDifficultyAdjust(
+                ar=float(matchar.group(1)) if matchar else None,
+                cs=float(matchcs.group(1)) if matchcs else None,
+                od=float(matchod.group(1)) if matchod else None,
+                hp=float(matchhp.group(1)) if matchhp else None,
+            )
+            mod_list.append(da)
+        if matchsm:
+            mod_list.append(ModCustomSpeed(float(matchsm.group(1))))
+        if matchfld:
+            if mod_list.count(ModFlashlight) == 0:
+                mod_list.append(ModFlashlight(matchfld.group(1)))
+        return cls(mod_list)
+
+    @property
+    def mods(self) -> List[Mod]:
+        """List of mods."""
+        return self.__mods
+
+    def get_mod(self, acronym: str) -> Mod | None:
+        """Get a mod by its acronym."""
+        for mod in self.__mods:
+            if mod.acronym == acronym:
+                return mod
+        return None
+
+    def add_mod(self, mod: Mod):
+        """Add a new mod to the list."""
+        if not isinstance(mod, Mod):
+            raise TypeError("mod must be an instance of Mod.")
+        self.__mods.append(mod)
+
+    @property
+    def as_json(self) -> List[dict]:
+        """Return the mod list as a JSON serializable list with full mod details."""
+        return [mod.as_json for mod in self.__mods]
+
+    @property
+    def as_standard_mods(self) -> str:
+        """Return the mod list as a string of mod acronyms and settings."""
+        return "".join(mod.as_standard_mod for mod in self.__mods if mod.acronym)
+
+    @property
+    def as_calculatable_mods(self) -> list:
+        """Return the mod list as a string of mods suitable for pp calculation."""
+        return [mod.as_calculatable for mod in self.__mods]
+
+    @property
+    def as_json_string(self) -> str:
+        """Return the mod list as a JSON string."""
+        return json.dumps(self.as_calculatable_mods, separators=(",", ":"))
+
+    def __iter__(self):
+        """Iterate over the mods."""
+        return iter(self.__mods)

osudroid_api_wrapper-0.0.6/src/osudroid_api_wrapper/classes/base/mods/__init__.py

@@ -0,0 +1,31 @@
+from .mod import Mod
+from .mod_easy import ModEasy
+from .mod_reallyeasy import ModReallyEasy
+from .mod_hardrock import ModHardRock
+from .mod_hidden import ModHidden
+from .mod_flashlight import ModFlashlight
+from .mod_precise import ModPrecise
+from .mod_relax import ModRelax
+from .mod_autopilot import ModAutopilot
+from .mod_auto import ModAuto
+from .mod_nofail import ModNoFail
+from .mod_scorev2 import ModScoreV2
+from .mod_suddendeath import ModSuddenDeath
+from .mod_perfect import ModPerfect
+from .mod_doubletime import ModDoubleTime
+from .mod_nightcore import ModNightcore
+from .mod_halftime import ModHalfTime
+from .mod_windup import ModWindUp
+from .mod_winddown import ModWindDown
+from .mod_mirror import ModMirror
+from .mod_traceable import ModTraceable
+from .mod_muted import ModMuted
+from .mod_approachdifferent import ModApproachDifferent
+from .mod_random import ModRandom
+from .mod_freezeframe import ModFreezeFrame
+from .mod_synesthesia import ModSynesthesia
+from .mod_customspeed import ModCustomSpeed
+from .mod_difficultyadjust import ModDifficultyAdjust
+from .settings import SettingsList, Setting
+from .mod_smallcircles import ModSmallCircles
+from .mod_replayv6 import ModReplayV6

osudroid_api_wrapper-0.0.6/src/osudroid_api_wrapper/classes/base/mods/mod.py

@@ -0,0 +1,90 @@
+from abc import ABC, abstractmethod
+from typing import List
+from .settings.settings_list import SettingsList
+
+
+class Mod(ABC):
+    """Base class for all mods."""
+
+    def __init__(self):
+        self.__name: str = None
+        self.__acronym: str = None
+        self.__settings: SettingsList = SettingsList()
+        self.__is_ranked: bool = True
+
+    @property
+    def name(self) -> str:
+        """Name of the mod."""
+        return self.__name
+
+    @name.setter
+    def name(self, new_name: str):
+        """Set the name of the mod."""
+        if self.__name is not None:
+            raise ValueError("Name can only be set once.")
+        self.__name = new_name
+
+    @property
+    def acronym(self) -> str:
+        """Acronym of the mod."""
+        return self.__acronym
+
+    @acronym.setter
+    def acronym(self, new_acronym: str):
+        """Set the acronym of the mod."""
+        if self.__acronym is not None:
+            raise ValueError("Acronym can only be set once.")
+        self.__acronym = new_acronym
+
+    @property
+    def is_ranked(self) -> bool:
+        """Submit status of the mod"""
+        return self.__is_ranked
+
+    @is_ranked.setter
+    def is_ranked(self, new_is_ranked: bool):
+        """Set the ranked status of the mod."""
+        self.__is_ranked = new_is_ranked
+
+    @property
+    def as_json(self) -> dict:
+        """Return the mod as a JSON serializable dictionary."""
+        return {
+            "name": self.__name,
+            "acronym": self.__acronym,
+            "settings": self.__settings.as_json,
+            "is_ranked": self.__is_ranked,
+        }
+
+    @property
+    def as_standard_mod(self) -> str:
+        """Return the mod as a standard mod instance."""
+        return self.__acronym
+
+    @property
+    def as_calculatable(self) -> dict:
+        """Return the mod in a format suitable for pp calculation."""
+        ret = {
+            "acronym": self.__acronym,
+        }
+        if self.__settings.as_calculatable:
+            ret["settings"] = self.__settings.as_calculatable
+        return ret
+
+    @property
+    def settings(self) -> SettingsList:
+        """Settings of the mod."""
+        return self.__settings
+
+    @settings.setter
+    def settings(self, new_settings: SettingsList):
+        """Set the settings of the mod."""
+        if not isinstance(new_settings, SettingsList):
+            raise TypeError("Settings must be an instance of SettingsList.")
+        self.__settings = new_settings
+
+    def __repr__(self):
+        return f"{self.__name}({self.settings})"
+
+    def __str__(self):
+        return f"{self.__name}({self.settings})"

osudroid_api_wrapper-0.0.6/src/osudroid_api_wrapper/classes/base/mods/mod_approachdifferent.py

@@ -0,0 +1,58 @@
+from .mod import Mod
+from .settings import Setting
+from enum import Enum
+from typing import override
+
+
+class ApproachStyle(Enum):
+    """Enum for approach styles in the approach different mod."""
+
+    LINEAR = 0
+    GRAVITY = 1
+    IN_OUT_1 = 2
+    IN_OUT_2 = 3
+    ACCELERATE_1 = 4
+    ACCELERATE_2 = 5
+    ACCELERATE_3 = 6
+    DECELERATE_1 = 7
+    DECELERATE_2 = 8
+    DECELERATE_3 = 9
+    BOUNCE_IN = 10
+    BOUNCE_OUT = 11
+    BOUNCE_IN_OUT = 12
+
+
+class ModApproachDifferent(Mod):
+    """ModApproachDifferent class represents the approach different mod in osu!droid."""
+
+    def __init__(self, scale: float = None, style: ApproachStyle = None):
+        super().__init__()
+        self.name = "Approach Different"
+        self.acronym = "AD"
+        self.is_ranked = False
+        self.settings.add_setting(
+            Setting(
+                name="scale",
+                default_value=3.0,
+                value=scale,
+                min_value=1.5,
+                max_value=10.0,
+                step=0.1,
+            )
+        )
+        self.settings.add_setting(
+            Setting(
+                name="style",
+                default_value=ApproachStyle.LINEAR,
+                value=style,
+                min_value=0,
+                max_value=len(ApproachStyle) - 1,
+                step=1,
+            )
+        )
+
+    @property
+    @override
+    def as_standard_mod(self):
+        # This mod have options, but for some reason it is not displayed in the game
+        return self.__acronym

osudroid_api_wrapper-0.0.6/src/osudroid_api_wrapper/classes/base/mods/mod_auto.py

@@ -0,0 +1,11 @@
+from .mod import Mod
+
+
+class ModAuto(Mod):
+    """ModAutoplay class represents the autoplay mod in osu!droid."""
+
+    def __init__(self):
+        super().__init__()
+        self.name = "Auto"
+        self.acronym = "AT"
+        self.is_ranked = False

osudroid_api_wrapper-0.0.6/src/osudroid_api_wrapper/classes/base/mods/mod_autopilot.py

@@ -0,0 +1,11 @@
+from .mod import Mod
+
+
+class ModAutopilot(Mod):
+    """ModAutopilot class represents the autopilot mod in osu!droid."""
+
+    def __init__(self):
+        super().__init__()
+        self.name = "Autopilot"
+        self.acronym = "AP"
+        self.is_ranked = False

osudroid_api_wrapper-0.0.6/src/osudroid_api_wrapper/classes/base/mods/mod_customspeed.py

@@ -0,0 +1,27 @@
+from .mod import Mod
+from .settings import Setting
+from typing import override
+
+
+class ModCustomSpeed(Mod):
+    """ModCustomSpeed class represents the custom speed mod in osu!droid."""
+
+    def __init__(self, rateMultiplier: float = None):
+        super().__init__()
+        self.name = "Custom Speed"
+        self.acronym = "CS"
+        self.settings.add_setting(
+            Setting(
+                name="rateMultiplier",
+                default_value=1.0,
+                value=rateMultiplier,
+                min_value=0.5,
+                max_value=2.0,
+                step=0.05,
+            )
+        )
+
+    @property
+    @override
+    def as_standard_mod(self):
+        return f"{self.acronym}(x{self.settings.get_setting('rateMultiplier').value})"

osudroid_api_wrapper-0.0.6/src/osudroid_api_wrapper/classes/base/mods/mod_difficultyadjust.py

@@ -0,0 +1,39 @@
+from .mod import Mod
+from .settings import Setting
+from typing import override
+
+
+class ModDifficultyAdjust(Mod):
+    """ModDifficultyAdjust class represents the difficulty adjustment mod in osu!droid."""
+
+    def __init__(
+        self, ar: float = None, cs: float = None, od: float = None, hp: float = None
+    ):
+
+        super().__init__()
+        self.name = "Difficulty Adjust"
+        self.acronym = "DA"
+        self.settings.add_setting(
+            Setting(name="ar", value=ar, min_value=0.0, max_value=12.5, step=0.1)
+        )
+        self.settings.add_setting(
+            Setting(name="cs", value=cs, min_value=0.0, max_value=15.0, step=0.1)
+        )
+        self.settings.add_setting(
+            Setting(name="od", value=od, min_value=0.0, max_value=11.0, step=0.1)
+        )
+        self.settings.add_setting(
+            Setting(name="hp", value=hp, min_value=0.0, max_value=11.0, step=0.1)
+        )
+        self.is_ranked = False
+
+    @property
+    @override
+    def as_standard_mod(self) -> str:
+        string = f"{self.acronym}"
+        stats = ", ".join(
+            f"{setting.name.upper()}{setting.value}"
+            for setting in self.settings
+            if (setting.value is not None and setting.value != setting.default_value)
+        )
+        return f"{string}({stats})" if stats else string

osudroid_api_wrapper-0.0.6/src/osudroid_api_wrapper/classes/base/mods/mod_doubletime.py

@@ -0,0 +1,10 @@
+from .mod import Mod
+
+
+class ModDoubleTime(Mod):
+    """ModDoubleTime class represents the doubletime mod in osu!droid."""
+
+    def __init__(self):
+        super().__init__()
+        self.name = "Double Time"
+        self.acronym = "DT"

osudroid_api_wrapper-0.0.6/src/osudroid_api_wrapper/classes/base/mods/mod_easy.py

@@ -0,0 +1,10 @@
+from .mod import Mod
+
+
+class ModEasy(Mod):
+    """ModEasy class represents the easy mod in osu!droid."""
+
+    def __init__(self):
+        super().__init__()
+        self.name = "Easy"
+        self.acronym = "EZ"

osudroid_api_wrapper-0.0.6/src/osudroid_api_wrapper/classes/base/mods/mod_flashlight.py

@@ -0,0 +1,35 @@
+from .mod import Mod
+from .settings import SettingsList, Setting
+from typing import override
+
+
+class ModFlashlight(Mod):
+    """ModFlashlight class represents the flashlight mod in osu!droid."""
+
+    def __init__(self, areaFollowDelay: float = None):
+        super().__init__()
+        self.name = "Flashlight"
+        self.acronym = "FL"
+        self.settings.add_setting(
+            Setting(
+                name="areaFollowDelay",
+                min_value=0.12,
+                max_value=1.2,
+                default_value=0.12,
+                value=areaFollowDelay,
+                step=0.12,
+            )
+        )
+
+    @property
+    @override
+    def as_standard_mod(self) -> str:
+        if (
+            self.settings.get_setting("areaFollowDelay").value is not None
+            and self.settings.get_setting("areaFollowDelay").value
+            != self.settings.get_setting("areaFollowDelay").default_value
+        ):
+            return (
+                f"{self.acronym}({self.settings.get_setting('areaFollowDelay').value}s)"
+            )
+        return self.acronym