osudroid-api-wrapper 0.0.1__py3-none-any.whl

osudroid-api-wrapper/classes/base/beatmap.py

@@ -0,0 +1,112 @@
+"""Used https://github.com/xjunko/Yuzumi/blob/main/objects/beatmap.py as a reference
+Original license from xjunko/Yuzumi:
+
+MIT License
+
+Copyright (c) 2021 FireRedz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+"""
+
+import dotenv
+import os
+import requests
+
+dotenv.load_dotenv()
+key = os.getenv("OSU_API_KEY")
+
+
+class Beatmap:
+    def __init__(self):
+        self.beatmap_id: int = None
+        self.beatmapset_id: int = None
+        self.md5: str = None
+        self.artist: str = None
+        self.title: str = None
+        self.version: str = None
+        self.creator: str = None
+        self.ar: float = None
+        self.od: float = None
+        self.hp: float = None
+        self.cs: float = None
+        self.bpm: float = None
+        self.star: float = None
+        self.length: int = None
+
+    @classmethod
+    def get_beatmap(cls, beatmap_id: int = None, md5: str = None) -> 'Beatmap':
+        beatmap = cls()
+        url = "https://old.ppy.sh/api/get_beatmaps"
+        if beatmap_id is not None:
+            params = {
+            "k": key,
+            "b": beatmap_id
+            }
+            response = requests.get(url, params=params)
+            data = response.json()
+            data = data[0]
+
+        elif md5 is not None:
+            params = {
+                "k": key,
+                "h": md5
+            }
+            response = requests.get(url, params=params)
+            data = response.json()
+            if len(data) == 0:
+                return None
+            data = data[0]
+
+        beatmap.beatmap_id = int(data["beatmap_id"])
+        beatmap.beatmapset_id = int(data["beatmapset_id"])
+        beatmap.md5 = data["file_md5"]
+        beatmap.artist = data["artist"]
+        beatmap.title = data["title"]
+        beatmap.version = data["version"]
+        beatmap.creator = data["creator"]
+        beatmap.ar = float(data["diff_approach"])
+        beatmap.od = float(data["diff_overall"])
+        beatmap.hp = float(data["diff_drain"])
+        beatmap.cs = float(data["diff_size"])
+        beatmap.bpm = float(data["bpm"])
+        beatmap.star = float(data["difficultyrating"])
+        beatmap.length = int(data["total_length"])
+        
+        return beatmap
+
+
+    @property
+    def to_dict(self):
+        return {
+            "beatmap_id": self.beatmap_id,
+            "beatmapset_id": self.beatmapset_id,
+            "md5": self.md5,
+            "artist": self.artist,
+            "title": self.title,
+            "version": self.version,
+            "creator": self.creator,
+            "ar": self.ar,
+            "od": self.od,
+            "hp": self.hp,
+            "cs": self.cs,
+            "bpm": self.bpm,
+            "star": self.star,
+            "length": self.length
+
+        }

osudroid-api-wrapper/classes/base/mods.py

@@ -0,0 +1,33 @@
+class Mods:
+    def __init__(self, mods=None):
+        self.mods = mods or []
+        self.speed_multiplier = None
+
+    @classmethod
+    def from_droid_site(cls, mods: str):
+        mod_abbreviations = {
+            'None': 'NM', 'NoFail': 'NF', 'Easy': 'EZ', 'HalfTime': 'HT',
+            'Hidden': 'HD', 'HardRock': 'HR', 'DoubleTime': 'DT', 'Flashlight': 'FL',
+            'Precise': 'PR', 'SuddenDeath': 'SD', 'Perfect': 'PF', 'NightCore': 'NC',
+        }
+        return cls([mod_abbreviations.get(mod, mod) for mod in mods.split(",")])
+
+    @classmethod
+    def from_droid_replay(cls, mods: str):
+        mod_mapping = {
+            "MOD_NOFAIL": "NF", "MOD_EASY": "EZ", "MOD_HIDDEN": "HD",
+            "MOD_HARDROCK": "HR", "MOD_SUDDENDEATH": "SD", "MOD_DOUBLETIME": "DT",
+            "MOD_RELAX": "RX", "MOD_HALFTIME": "HT", "MOD_NIGHTCORE": "NC",
+            "MOD_FLASHLIGHT": "FL", "MOD_SCOREV2": "V2", "MOD_AUTOPILOT": "AP",
+            "MOD_AUTO": "AT", "MOD_PRECISE": "PR", "MOD_REALLYEASY": "REZ",
+            "MOD_SMALLCIRCLES": "SC", "MOD_PERFECT": "PF", "MOD_SUDDENDEATH": "SU",
+        }
+        return cls([mod_mapping.get(mod, mod) for mod in mods.split(",")])
+
+    @classmethod
+    def from_droid_api(cls, mods: dict):
+        instance = cls(list(mods))
+        instance.speed_multiplier = next((mod for mod in mods if mod.startswith("x")), None)
+        return instance
+
+

osudroid-api-wrapper/classes/base/player.py

@@ -0,0 +1,114 @@
+import bs4
+import datetime
+import requests
+
+
+class Player:
+    def __init__(self):
+        self.uid: int = 0
+        self.username: str = None
+        self.country: str = None
+        self.score_rank: int = 0
+        self.pp_rank: int = 0
+        self.country_rank: int = 0
+        self.pp: float = 0.0
+        self.total_score: int = 0
+        self.playcount: int = 0
+        self.accuracy: float = 0.0
+        self.registered_on: int = 0
+        self.last_login: int = 0
+
+    def __parse(self, soup):
+        text_content = soup.get_text()
+        country_index = text_content.find("Location:")
+        self.country = text_content[country_index +
+                                    len("Location:"):].splitlines()[0].strip()
+        score_rank_index = text_content.find("Score Rank:")
+        self.score_rank = int(
+            text_content[score_rank_index + len("Score Rank:"):].splitlines()[0].strip().replace("#", ""))
+        pp_rank_index = text_content.find("PP Rank:")
+        self.pp_rank = int(
+            text_content[pp_rank_index + len("PP Rank:"):].splitlines()[0].strip().replace("#", ""))
+        self.username = soup.select_one(
+            "html body main div nav div div div:nth-of-type(3) div:nth-of-type(1) a:nth-of-type(1)").text
+
+        table = soup.find("table")
+        if table:
+            rows = table.find_all("tr")
+            for row in rows:
+                columns = row.find_all("td")
+                if columns:
+                    if columns[0].text == "Performance Points":
+                        self.pp = float(
+                            columns[1].text.replace(
+                                ",", "").replace(
+                                "pp", ""))
+                    elif columns[0].text == "Ranked Score":
+                        self.total_score = int(
+                            columns[1].text.replace(",", ""))
+                    elif columns[0].text == "Play Count":
+                        self.playcount = int(columns[1].text.replace(",", ""))
+                    elif columns[0].text == "Hit Accuracy":
+                        self.accuracy = float(columns[1].text.replace("%", ""))
+        return self
+
+    @classmethod
+    def _parse_from_bsoup(cls, soup) -> 'Player':
+        player = cls()
+        player.__parse(soup)
+        return player
+    
+    @classmethod
+    def _from_api_response(cls, data) -> 'Player':
+        player = cls()
+        
+        player.uid = data['UserId']
+        player.username = data['Username']
+        player.pp_rank = int(data['GlobalRank'])
+        player.country_rank = int(data['CountryRank'])
+        player.total_score = int(data['OverallScore'])
+        player.pp = int(data['OverallPP'])
+        player.playcount = int(data['OverallPlaycount'])
+        player.accuracy = float(data['OverallAccuracy']) * 100
+        player.registered_on = datetime.datetime.strptime(
+            data['Registered'], "%Y-%m-%dT%H:%M:%S.%fZ").timestamp()
+        player.country = data['Region']
+        return player
+    
+    @classmethod
+    def from_droid_site(cls, uid: int) -> 'Player':
+        player = cls()
+        url = f"https://osudroid.moe/profile.php?uid={uid}"
+        response = requests.get(url)
+        player.uid = uid
+        soup = bs4.BeautifulSoup(response.text, 'html.parser')
+        player.__parse(soup)
+        return player
+
+    
+    @classmethod
+    def from_api(cls, uid: int = None, username: str = None) -> 'Player':
+        player = cls()
+        if username:
+            url = f"https://new.osudroid.moe/apitest/profile-username/{username}"
+        elif uid:
+            url = f"https://new.osudroid.moe/apitest/profile-uid/{uid}"
+        response = requests.get(url)
+        data = response.json()
+        player = cls._from_api_response(data)
+        return player
+    
+    @property
+    def to_dict(self):
+        return {
+            'uid': self.uid,
+            'username': self.username,
+            'country': self.country,
+            'score_rank': self.score_rank,
+            'pp_rank': self.pp_rank,
+            'pp': self.pp,
+            'total_score': self.total_score,
+            'playcount': self.playcount,
+            'accuracy': self.accuracy
+        }
+        

osudroid-api-wrapper/classes/replay.py

@@ -0,0 +1,259 @@
+"""Partial rewrite of the rian8337/osu-droid-replay-analyzer on python
+
+https://github.com/Rian8337/osu-droid-module/tree/master/packages/osu-droid-replay-analyzer
+
+MIT License
+
+Copyright (c) 2021 Rian8337
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+"""
+
+import javaobj.v2
+import javaobj.v2.transformers
+from stream_unzip import stream_unzip
+import javaobj
+import struct
+import io
+from classes.replay_data.movementtype import MovementType
+from classes.replay_data.cursordata import CursorData
+from classes.replay_data.hitresult import HitResult
+from classes.replay_data.replayobjectdata import ReplayObjectData
+
+
+class Replay:
+    def __init__(self):
+        self.replay_file = None
+        self.replay_obj = None
+        self.map: str = None
+        self.file_name: str = None
+        self.md5: str = None
+        self.unix_date: int = 0
+        self.hit300k: int = 0
+        self.hit300: int = 0
+        self.hit100k: int = 0
+        self.hit100: int = 0
+        self.hit50: int = 0
+        self.hit0: int = 0
+        self.score: int = 0
+        self.combo: int = 0
+        self.username: str = None
+        self.parsed_mods: list = []
+        self.converted_mods: list = []
+        self.__buffer_offset: int = 0
+        self.cursor_data: list = []
+        self.hit_result_data: list = []
+
+    def __zipped_chunks(self, filename):
+        with open(filename, "rb") as f:
+            while chunk := f.read(65536):
+                yield chunk
+
+
+
+    def __read_byte(self, replay_data):
+        replay_data.seek(self.__buffer_offset)
+        self.__buffer_offset += 1
+        return struct.unpack(">b", replay_data.read(1))[0]
+
+    def __read_short(self, replay_data):
+        replay_data.seek(self.__buffer_offset)
+        self.__buffer_offset += 2
+        return struct.unpack(">h", replay_data.read(2))[0]
+    
+    def __read_int(self, replay_data):
+        replay_data.seek(self.__buffer_offset)
+        self.__buffer_offset += 4
+        return struct.unpack(">i", replay_data.read(4))[0]
+
+    def __read_float(self, replay_data):
+        replay_data.seek(self.__buffer_offset)
+        self.__buffer_offset += 4
+        return struct.unpack(">f", replay_data.read(4))[0]
+
+    def __droid_replay_mods_to_std(self):
+        mod_mapping = {
+            "MOD_NOFAIL": "NF",
+            "MOD_EASY": "EZ",
+            "MOD_HIDDEN": "HD",
+            "MOD_HARDROCK": "HR",
+            "MOD_SUDDENDEATH": "SD",
+            "MOD_DOUBLETIME": "DT",
+            "MOD_RELAX": "RX",
+            "MOD_HALFTIME": "HT",
+            "MOD_NIGHTCORE": "NC",
+            "MOD_FLASHLIGHT": "FL",
+            "MOD_SCOREV2": "V2",
+            "MOD_AUTOPILOT": "AP",
+            "MOD_AUTO": "AT",
+            "MOD_PRECISE": "PR",
+            "MOD_REALLYEASY": "REZ",
+            "MOD_SMALLCIRCLES": "SC",
+            "MOD_PERFECT": "PF",
+            "MOD_SUDDENDEATH": "SU",
+        }
+
+        for mod in self.parsed_mods:
+            if mod in mod_mapping:
+                self.converted_mods.append(mod_mapping[mod])
+        return self.converted_mods
+
+    def __parse_movement_data(self, replay_data):
+        replay_data = io.BytesIO(replay_data)
+        size = self.__read_int(replay_data)
+
+        # copypasta begins here
+        for i in range(size):
+            move_size = self.__read_int(replay_data)
+            time = []
+            x = []
+            y = []
+            id = []
+            for j in range(0, move_size):
+                time.append(self.__read_int(replay_data))
+                id.append(time[j] & 3)
+                time[j] >>= 2
+                if id[j] != MovementType.UP.value:
+                    if self.version >= 5:
+                        x.append(self.__read_float(replay_data))
+                        y.append(self.__read_float(replay_data))
+                    else:
+                        x.append(self.__read_short(replay_data))
+                        y.append(self.__read_short(replay_data))
+                else:
+                    x.append(-1)
+                    y.append(-1)
+
+            cursor_data = CursorData({
+                "size": move_size,
+                "time": time,
+                "x": x,
+                "y": y,
+                "id": id
+            }).to_dict
+
+            self.cursor_data.append(cursor_data['occurrence_groups'])
+            
+    def __parse_hitresult_data(self, replay_data):
+        replay_data = io.BytesIO(replay_data)
+
+        hitobject_data_lenght = self.__read_int(replay_data)
+        
+        for i in range(hitobject_data_lenght):
+            replay_object_data = ReplayObjectData(
+                accuracy=0.0,
+                tickset=[],
+                result=HitResult.MISS
+            )
+            replay_object_data.accuracy = self.__read_short(replay_data)
+            len = self.__read_byte(replay_data)
+            
+            if len > 0:
+                bytes = []
+                for j in range(len):
+                    bytes.append(self.__read_byte(replay_data))
+                for j in range(len * 8):
+                    replay_object_data.tickset.append((bytes[len - round(j/8) - 1] & (1 << round(j % 8))) != 0)
+                
+            replay_object_data.result = HitResult(self.__read_byte(replay_data))
+            self.hit_result_data.append(replay_object_data.to_dict)
+                    
+            
+
+    def load(self, filename):
+        self.replay_file = filename
+
+        for file_name, file_size, unzipped_chunks in stream_unzip(
+                self.__zipped_chunks(filename)):
+
+            data_buffer = io.BytesIO()
+
+            try:
+                for chunk in unzipped_chunks:
+                    data_buffer.write(chunk)
+            except Exception as e:
+                break
+
+        self.replay_obj = javaobj.v2.loads(data_buffer.getvalue())
+
+        for fields in self.replay_obj[0].to_dict['field_data'].values():
+            for field, value in fields.items():
+                if field.name == 'version':
+                    self.version = value
+
+        self.map = self.replay_obj[1].value
+        self.file_name = self.replay_obj[2].value
+        self.md5 = self.replay_obj[3].value
+
+        if self.version >= 3:
+            (self.unix_date, self.hit300k, self.hit300,
+             self.hit100k, self.hit100, self.hit50,
+             self.hit0, self.score, self.combo) = struct.unpack(">Qiiiiiiii", io.BytesIO(self.replay_obj[4].data).read(40))
+            self.username = self.replay_obj[5].value
+
+            for field in self.replay_obj[6].to_dict['field_data'].values():
+                for field, value in field.items():
+                    if field.name == "elements":
+                        for element in value:
+                            self.parsed_mods.append(element.value)
+                        break
+
+            self.__droid_replay_mods_to_std()
+
+        if self.version >= 4:
+            modifiers = self.replay_obj[7].value.split("|")
+            for modifier in modifiers:
+                if modifier.startswith("AR"):
+                    self.force_ar = float(modifier.replace("AR", ""))
+                if modifier.startswith("CS"):
+                    self.force_cs = float(modifier.replace("CS", ""))
+                if modifier.startswith("OD"):
+                    self.force_od = float(modifier.replace("OD", ""))
+                if modifier.startswith("HP"):
+                    self.force_hp = float(modifier.replace("HP", ""))
+                if modifier.startswith("x"):
+                    self.speed_multiplier = float(
+                        modifier.replace("x", "") or 1)
+                if modifier.startswith("FLD"):
+                    self.fl_delay = float(modifier.replace("FLD", "") or 0.12)
+
+        buffer_index = 0
+        if self.version <= 2:
+            buffer_index = 4
+        elif self.version == 3:
+            buffer_index = 7
+        elif self.version >= 4:
+            buffer_index = 8
+
+        replay_data = io.BytesIO()
+        for i in range(buffer_index, len(self.replay_obj)):
+            replay_data.write(self.replay_obj[i].data)
+
+        self.__parse_movement_data(replay_data.getvalue())
+        print(self.__buffer_offset)
+        self.__parse_hitresult_data(replay_data.getvalue())
+
+    def __str__(self):
+        string = ""
+        for key, value in self.to_dict.items():
+            if key == "replay_obj" or key == "replay_file" or key == "cursor_data":
+                continue
+
+            string += f"{key}: {value} "
+        return string

osudroid-api-wrapper/classes/replay_data/cursordata.py

@@ -0,0 +1,101 @@
+"""
+Rewrite of the CursorData class of rian8337/osu-droid-replay-analyzer 
+https://github.com/Rian8337/osu-droid-module/blob/master/packages/osu-droid-replay-analyzer/src/data/CursorData.ts
+
+MIT License
+
+Copyright (c) 2021 Rian8337
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+"""
+
+from typing import List, Optional
+from classes.replay_data.cursoroccurrence import CursorOccurrence
+from classes.replay_data.cursoroccurrencegroup import CursorOccurrenceGroup
+from classes.replay_data.movementtype import MovementType
+
+
+class CursorData:
+    def __init__(self, values: dict):
+        self.occurrence_groups: List[CursorOccurrenceGroup] = []
+        down_occurrence: Optional[CursorOccurrence] = None
+        move_occurrences: List[CursorOccurrence] = []
+
+        for i in range(values["size"]):
+            occurrence = CursorOccurrence(
+                time=values["time"][i],
+                x=values["x"][i],
+                y=values["y"][i],
+                id=MovementType(values["id"][i]),
+            )
+
+            if occurrence.id == MovementType.DOWN:
+                down_occurrence = occurrence
+            elif occurrence.id == MovementType.MOVE:
+                move_occurrences.append(occurrence)
+            elif occurrence.id == MovementType.UP:
+                if down_occurrence:
+                    self.occurrence_groups.append(
+                        CursorOccurrenceGroup(
+                            down=down_occurrence,
+                            moves=move_occurrences,
+                            up=occurrence,
+                        )
+                    )
+                    down_occurrence = None
+                move_occurrences = []
+
+        # Handle any remaining occurrences
+        if down_occurrence and move_occurrences:
+            self.occurrence_groups.append(
+                CursorOccurrenceGroup(
+                    down=down_occurrence,
+                    moves=move_occurrences
+                )
+            )
+
+    @property
+    def earliest_occurrence_time(self) -> Optional[int]:
+        return self.occurrence_groups[0].start_time if self.occurrence_groups else None
+
+    @property
+    def latest_occurrence_time(self) -> Optional[int]:
+        return self.occurrence_groups[-1].end_time if self.occurrence_groups else None
+
+    @property
+    def total_occurrences(self) -> int:
+        return sum(
+            1 + len(group.moves) + (1 if group.up else 0)
+            for group in self.occurrence_groups
+        )
+
+    @property
+    def all_occurrences(self) -> List[CursorOccurrence]:
+        return [
+            occurrence
+            for group in self.occurrence_groups
+            for occurrence in group.all_occurrences
+        ]
+
+    @property
+    def to_dict(self):
+        return {
+            "occurrence_groups": [group.to_dict for group in self.occurrence_groups]
+        }

osudroid-api-wrapper/classes/replay_data/cursoroccurrence.py

@@ -0,0 +1,48 @@
+"""Rewrite of the CursorOccurrence, Vector classes of rian8337/osu-droid-replay-analyzer
+https://github.com/Rian8337/osu-droid-module/blob/master/packages/osu-droid-replay-analyzer/src/data/CursorOccurrence.ts
+
+MIT License
+
+Copyright (c) 2021 Rian8337
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+"""
+
+
+class Vector:
+    def __init__(self, x, y):
+        self.x = x
+        self.y = y
+
+    @property
+    def to_dict(self):
+        return {"x": self.x, "y": self.y}
+
+
+class CursorOccurrence:
+    def __init__(self, x, y, time, id):
+        self.position = Vector(x, y)
+        self.time = time
+        self.id = id
+
+    @property
+    def to_dict(self):
+        return {"position": self.position.to_dict, "time": self.time,
+                "id": self.id}

osudroid-api-wrapper/classes/replay_data/cursoroccurrencegroup.py

@@ -0,0 +1,120 @@
+""" Rewrite of the CursorOccurrenceGroup class of rian8337/osu-droid-replay-analyzer
+https://github.com/Rian8337/osu-droid-module/blob/master/packages/osu-droid-replay-analyzer/src/data/CursorOccurrenceGroup.ts
+
+MIT License
+
+Copyright (c) 2021 Rian8337
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+"""
+
+from typing import List, Optional
+from classes.replay_data.cursoroccurrence import CursorOccurrence
+from classes.replay_data.movementtype import MovementType
+
+
+class CursorOccurrenceGroup:
+    def __init__(self, down: CursorOccurrence,
+                 moves: List[CursorOccurrence], up: Optional[CursorOccurrence] = None):
+        self._down = down
+        self._moves = moves
+        self.down = down  
+        self.up = up  
+
+    @property
+    def down(self) -> CursorOccurrence:
+        return self._down
+
+    @down.setter
+    def down(self, value: CursorOccurrence):
+        if value.id != MovementType.DOWN:
+            raise TypeError(
+                "Attempting to set the down cursor occurrence to one with a different movement type.")
+        self._down = value
+
+    @property
+    def moves(self) -> List[CursorOccurrence]:
+        return self._moves
+
+    @property
+    def up(self) -> Optional[CursorOccurrence]:
+        return self._up
+
+    @up.setter
+    def up(self, value: Optional[CursorOccurrence]):
+        if value and value.id != MovementType.UP:
+            raise TypeError(
+                "Attempting to set the up cursor occurrence to one with a different movement type.")
+        self._up = value
+
+    @property
+    def start_time(self) -> int:
+        return self._down.time
+
+    @property
+    def end_time(self) -> int:
+        return self._up.time if self._up else (
+            self._moves[-1].time if self._moves else self._down.time)
+
+    @property
+    def duration(self) -> int:
+        return self.end_time - self.start_time
+
+    @property
+    def all_occurrences(self) -> List[CursorOccurrence]:
+        cursors = [self._down, *self._moves]
+        if self._up:
+            cursors.append(self._up)
+        return cursors
+
+    def is_active_at(self, time: int) -> bool:
+        return self.start_time <= time <= self.end_time
+
+    def cursor_at(self, time: int) -> Optional[CursorOccurrence]:
+        if not self.is_active_at(time):
+            return None
+
+        if self._down.time == time:
+            return self._down
+
+        if self._up and self._up.time == time:
+            return self._up
+
+        # Бинарный поиск в moves
+        l, r = 0, len(self._moves) - 1
+
+        while l <= r:
+            pivot = l + (r - l) // 2
+            if self._moves[pivot].time < time:
+                l = pivot + 1
+            elif self._moves[pivot].time > time:
+                r = pivot - 1
+            else:
+                return self._moves[pivot]
+
+        # l указывает на первый элемент с time > time, вернём предыдущий
+        return self._moves[l - 1] if l > 0 else None
+
+    @property
+    def to_dict(self):
+        return {
+            "down": self._down.to_dict,
+            "moves": [move.to_dict for move in self._moves],
+            "up": self._up.to_dict if self._up else None
+        }

osudroid-api-wrapper/classes/replay_data/hitresult.py

@@ -0,0 +1,33 @@
+"""Rewrite of the HitResult class of rian8337/osu-droid-replay-analyzer
+https://github.com/Rian8337/osu-droid-module/blob/master/packages/osu-droid-replay-analyzer/src/constants/HitResult.ts
+
+MIT License
+
+Copyright (c) 2021 Rian8337
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+"""
+
+import enum
+
+class HitResult(enum.Enum):
+    MISS = 1
+    MEH = 2
+    GOOD = 3
+    GREAT = 4

osudroid-api-wrapper/classes/replay_data/movementtype.py

@@ -0,0 +1,37 @@
+"""Rewrite of the MovementType class of rian8337/osu-droid-replay-analyzer
+https://github.com/Rian8337/osu-droid-module/blob/master/packages/osu-droid-replay-analyzer/src/constants/MovementType.ts
+
+MIT License
+
+Copyright (c) 2021 Rian8337
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+"""
+
+import enum
+
+
+class MovementType(enum.Enum):
+    DOWN = 0
+    MOVE = 1
+    UP = 2
+
+    @property
+    def to_dict(self):
+        return self.value

osudroid-api-wrapper/classes/replay_data/replayobjectdata.py

@@ -0,0 +1,38 @@
+"""Rewrite of the ReplayObjectData class of rian8337/osu-droid-replay-analyzer
+https://github.com/Rian8337/osu-droid-module/blob/master/packages/osu-droid-replay-analyzer/src/data/ReplayObjectData.ts
+
+MIT License
+
+Copyright (c) 2021 Rian8337
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+"""
+
+import classes.replay_data.hitresult as hitresult
+from typing import Optional, List
+
+class ReplayObjectData:
+    
+    def __init__(self, accuracy:Optional[float], tickset:Optional[List[bool]], result:hitresult.HitResult):
+        self.accuracy:float = accuracy
+        self.tickset:List[bool] = tickset
+        self.result:hitresult.HitResult = result
+        
+    
+        

osudroid-api-wrapper/classes/score.py

@@ -0,0 +1,107 @@
+from classes.base.player import Player
+from classes.base.beatmap import Beatmap
+from classes.base.mods import Mods
+import datetime
+from typing import List
+
+class Score:
+    def __init__(self):
+        self.scoreid: int = 0
+        self.filename: str = None
+        self.h300k: int = 0
+        self.h300: int = 0
+        self.h100k: int = 0
+        self.h100: int = 0
+        self.h50: int = 0
+        self.h0: int = 0
+        self.beatmap: Beatmap = Beatmap()
+        self.player: Player = Player()
+        self.score: int = 0
+        self.combo: int = 0
+        self.mods: Mods = Mods()
+        self.accuracy: float = 0.0
+        self.pp: float = 0.0
+        self.date: int = 0
+        self.grade: str = None
+        self.misses: int = 0
+
+
+        
+        
+    @classmethod
+    def _parse_from_bsoup(cls, soup, ptype:str = "Recent Plays") -> 'List[Score]':
+        scores = []
+        divs = soup.find_all('div', style="text-align: center; margin-left: 5px; margin-top: 30px;")
+        top_div = next(
+            (div for div in divs if div.find('b', style="color: #EB2F96;") and div.find('b').text == ptype),
+            None
+        )
+
+        if not top_div:
+            return scores
+
+        top_div = top_div.find_next_sibling()
+        for li in top_div.find_all('li', class_='li', style='margin-left: 15px; margin-right: 10px;'):
+            score = cls()
+            score.grade = li.find('img')['src'].replace('./assets/img/ranking-', '').replace('.png', '')
+            div = li.find('div', style='margin-bottom: 15px')
+            if div:
+                inner_div = div.find('div', style='margin: 0; color: black;')
+                small_element = inner_div.find('small', style='margin-left: 50px;')
+                details_lines = small_element.get_text(strip=True).split(' / ')
+                score.date = datetime.datetime.strptime(details_lines[0], "%Y-%m-%d %H:%M:%S").timestamp()
+                score.pp = float(details_lines[1].replace("pp: ", "").replace(",", "")) if details_lines[1].replace("pp: ", "") != "None" else 0.0
+                score.score = int(details_lines[2].replace("score:", "").replace(",", ""))
+                score.mods = Mods.from_droid_site(details_lines[3].replace("mod: ", ""))
+                score.combo = int(details_lines[4].replace("combo:", "").replace("x", ""))
+                score.accuracy = float(details_lines[5].replace("accuracy:", "").replace("%", ""))
+                score.misses = inner_div.find('small', style='color: #A82C2A;').get_text(strip=True).split(': ')[-1]
+                hash_content = inner_div.find('span', style='display:none;').contents[0].split(':')[1].replace('}', '')
+                score.beatmap = Beatmap.get_beatmap(md5=hash_content)
+            scores.append(score)
+        return scores
+
+
+    @classmethod    
+    def _from_api_response(cls, data) -> 'Score':
+        score = cls()
+        score.scoreid = data['ScoreId']
+        score.filename = data['Filename']
+        score.mods = Mods.from_droid_api(data['Mods'])
+        score.score = data['MapScore']
+        score.combo = data['MapCombo']
+        score.grade = data['MapRank']
+        score.h300k = data['MapGeki']
+        score.h300 = data['MapPerfect']
+        score.h100k = data['MapKatu']
+        score.h100 = data['MapGood']
+        score.h50 = data['MapBad']
+        score.h0 = data['MapMiss']
+        score.accuracy = data['MapAccuracy'] * 100
+        score.pp = data.get('MapPP', 0)
+        score.date = datetime.datetime.strptime(data['PlayedDate'], "%Y-%m-%dT%H:%M:%S.%fZ").timestamp()
+        
+        return score
+    
+    @property
+    def to_dict(self):
+        return {
+            'scoreid': self.scoreid,
+            'filename': self.filename,
+            'h300k': self.h300k,
+            'h300': self.h300,
+            'h100k': self.h100k,
+            'h100': self.h100,
+            'h50': self.h50,
+            'h0': self.h0,
+            'beatmap': self.beatmap.to_dict if self.beatmap else None,
+            'player': self.player.to_dict,
+            'score': self.score,
+            'combo': self.combo,
+            'mods': self.mods.to_dict,
+            'accuracy': self.accuracy,
+            'pp': self.pp,
+            'date': self.date,
+            'grade': self.grade,
+            'misses': self.misses
+        }

osudroid-api-wrapper/structs/profile.py

@@ -0,0 +1,76 @@
+from classes.score import Score
+from classes.base.player import Player
+from typing import List
+import bs4
+import requests
+
+
+class Profile():
+    def __init__(self):
+        self.player: Player = Player()
+        self.recent_scores = []
+        self.top_scores = []
+
+    def __get_recent_scores(self, soup) -> List[Score]:
+        recent_scores = Score._parse_from_bsoup(soup, "Recent Plays")
+        player = Player._parse_from_bsoup(soup)
+        for score in recent_scores:
+            score.player = player
+        self.recent_scores = recent_scores
+        return recent_scores
+
+    def __get_top_scores(self, soup) -> List[Score]:
+        top_scores = Score._parse_from_bsoup(soup, "Top Plays")   
+        player = Player._parse_from_bsoup(soup)
+        for score in top_scores:
+            score.player = player
+        self.top_scores = top_scores
+        return top_scores
+    
+
+    @classmethod
+    def from_api(cls, uid: int = None, username: str = None) -> 'Profile':
+        profile = cls()
+        if username:
+            url = f"https://new.osudroid.moe/apitest/profile-username/{username}"
+        elif uid:
+            url = f"https://new.osudroid.moe/apitest/profile-uid/{uid}"
+        resp = requests.get(url)
+        data = resp.json()
+        profile.player = Player._from_api_response(data)
+        for score in data['Last50Scores']:
+            score_obj = Score._from_api_response(score)
+            score_obj.player = profile.player
+            profile.recent_scores.append(score_obj)
+        for score in data['Top50Plays']:
+            score_obj = Score._from_api_response(score)
+            score_obj.player = profile.player
+            profile.top_scores.append(score_obj)
+        return profile
+                
+
+    @classmethod
+    def from_droid_site(cls, uid: int) -> 'Profile':
+        url = f"https://osudroid.moe/profile.php?uid={uid}"
+        profile = cls()
+        resp = requests.get(url)
+        soup = bs4.BeautifulSoup(resp.text, 'html.parser')
+        profile.player = Player._parse_from_bsoup(soup)
+        profile.__get_recent_scores(soup)
+        profile.__get_top_scores(soup)
+        return profile
+                
+    
+    @property
+    def to_dict(self):
+        return {
+            'player': self.player.to_dict if self.player else None,
+            'recent_scores': [score.to_dict  for score in self.recent_scores],
+            'top_scores': [score.to_dict for score in self.top_scores]
+        }
+                
+                
+
+
+        
+    

osudroid_api_wrapper-0.0.1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 unclem2, Rian8337, xjunko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

osudroid_api_wrapper-0.0.1.dist-info/METADATA

@@ -0,0 +1,39 @@
+Metadata-Version: 2.2
+Name: osudroid-api-wrapper
+Version: 0.0.1
+Summary: Python api wrapper for osu!droid
+Author-email: unclem <mannringyt11@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2025 unclem2, Rian8337, xjunko
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/unclem2/osudroid-api-wrapper
+Project-URL: Issues, https://github.com/unclem2/osudroid-api-wrapper/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.26.0
+Requires-Dist: beautifulsoup4>=4.10.0
+Requires-Dist: javaobj-py3>=0.4.4
+Requires-Dist: stream_unzip>=0.0.99
+Requires-Dist: python-dotenv>=1.0.0

osudroid_api_wrapper-0.0.1.dist-info/RECORD

@@ -0,0 +1,18 @@
+osudroid-api-wrapper/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+osudroid-api-wrapper/classes/replay.py,sha256=r1edYtur8w9czdNJDawiq_qnA2V2rs14Nohf1hWmudg,9424
+osudroid-api-wrapper/classes/score.py,sha256=pgRGHsX0nMQ7Iw-1HVPPN6fJX_ju3SO_W7EiR8h6pls,4290
+osudroid-api-wrapper/classes/base/beatmap.py,sha256=s5rhL9nQ87Ol4iB9w2C0zH4h4Pjlt8XHHKyTsWNImUU,3702
+osudroid-api-wrapper/classes/base/mods.py,sha256=q_so6WmJ86sf0QYmXn9QHz-G8iQNr-3uM59e2mDSs6U,1393
+osudroid-api-wrapper/classes/base/player.py,sha256=F46U2lObRfzVktumAv98TuYonzzAVi3kZ3z0T4xvM70,4204
+osudroid-api-wrapper/classes/replay_data/cursordata.py,sha256=pt73jrBo0qaXgjQhM_Dbvt6NSJSOPe0F-XGCmpY-I3U,3821
+osudroid-api-wrapper/classes/replay_data/cursoroccurrence.py,sha256=s0MT-hRDxlx_6x-8cK5Vja2G_jAJPMQxhFpXqNHrtZE,1733
+osudroid-api-wrapper/classes/replay_data/cursoroccurrencegroup.py,sha256=kpMdp5moX0eUM2jamgcrG4sc1IrYgKMYrI1OFzrTHp0,4171
+osudroid-api-wrapper/classes/replay_data/hitresult.py,sha256=qSukja68PjG4cTTDlJwnN2F35OtPbBHJw-Gdm60yP9U,1355
+osudroid-api-wrapper/classes/replay_data/movementtype.py,sha256=B5qjeKpvmfOmcxcz335GlJeU-NVmYI1HC_OZH1abcc8,1414
+osudroid-api-wrapper/classes/replay_data/replayobjectdata.py,sha256=NGdHl10jU88D9vEI5VsGvaxmyObbVqm4kqLaeVsLelg,1645
+osudroid-api-wrapper/structs/profile.py,sha256=X_-mPbNaaf-2jm2MvFfiu-7pvEL7frLTy_nkBA0jvAQ,2503
+osudroid_api_wrapper-0.0.1.dist-info/LICENSE,sha256=PE59EcMlelA4jw-9J5G5MJaBUzNYRjIpd0ow5D8LYh0,1082
+osudroid_api_wrapper-0.0.1.dist-info/METADATA,sha256=KcvSoQkFNAzO9Q-vHU_Eygg_hDJOh-LLqWeCGQKdq6c,1915
+osudroid_api_wrapper-0.0.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+osudroid_api_wrapper-0.0.1.dist-info/top_level.txt,sha256=rTEbJMsRctkMLKxyyd3QOmIitpss7GkUQSkyeiCZZGY,21
+osudroid_api_wrapper-0.0.1.dist-info/RECORD,,

osudroid_api_wrapper-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.8.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

osudroid_api_wrapper-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+osudroid-api-wrapper