osu.py 2.2.0__tar.gz → 2.2.2__tar.gz

{osu_py-2.2.0/osu.py.egg-info → osu_py-2.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: osu.py
-Version: 2.2.0
+Version: 2.2.2
 Summary: API Wrapper for osu!api v2 written in Python.
 Home-page: https://github.com/Sheepposu/osu.py
 Author: Sheepposu

{osu_py-2.2.0 → osu_py-2.2.2}/osu/__init__.py

@@ -14,4 +14,4 @@ from .util import (
 from .results import *
 
 
-__version__ = "2.2.0"
+__version__ = "2.2.2"

{osu_py-2.2.0 → osu_py-2.2.2}/osu/asyncio/client.py

@@ -1449,6 +1449,9 @@ class AsynchronousClient:
             User default mode will be used if not specified.
 
         key: Optional[:class:`str`]
+            **DEPRECATED**
+            It's recommended to prefix usernames with @ instead of setting key
+
             Type of user passed in url parameter. Can be either `id` or `username`
             to limit lookup by their respective type. Passing empty or invalid
             value will result in id lookup followed by username lookup if not found.
@@ -1466,7 +1469,8 @@ class AsynchronousClient:
             `user_achievements`.
         """
         mode = parse_enum_args(mode)
-        return User(await self.http.make_request(Path.get_user(user, mode), key=key))
+        user = f"@{user}" if key is not None and key.lower() == "username" else user
+        return User(await self.http.make_request(Path.get_user(user, mode)))
 
     async def get_users(self, ids: Sequence[int]) -> List[UserCompact]:
         """

{osu_py-2.2.0 → osu_py-2.2.2}/osu/client.py

@@ -1424,6 +1424,9 @@ class Client:
             User default mode will be used if not specified.
 
         key: Optional[:class:`str`]
+            **DEPRECATED**
+            It's recommended to prefix usernames with @ instead of setting key
+
             Type of user passed in url parameter. Can be either `id` or `username`
             to limit lookup by their respective type. Passing empty or invalid
             value will result in id lookup followed by username lookup if not found.
@@ -1441,7 +1444,8 @@ class Client:
             `user_achievements`.
         """
         mode = parse_enum_args(mode)
-        return User(self.http.make_request(Path.get_user(user, mode), key=key))
+        user = f"@{user}" if key is not None and key.lower() == "username" else user
+        return User(self.http.make_request(Path.get_user(user, mode)))
 
     def get_users(self, ids: Sequence[int]) -> List[UserCompact]:
         """
@@ -1461,6 +1465,9 @@ class Client:
             Includes attributes: country, cover, groups, statistics_rulesets.
         """
         res = self.http.make_request(Path.get_users(), **{"ids[]": ids})
+        import json
+        with open("users.json", "w", encoding="utf-8") as f:
+            json.dump(res["users"], f)
         return list(map(UserCompact, res["users"]))
 
     def get_wiki_page(self, locale: str, path: str) -> WikiPage:

{osu_py-2.2.0 → osu_py-2.2.2}/osu/enums.py

@@ -460,8 +460,7 @@ class GameModeStr(Enum):
     CATCH = "fruits"
     MANIA = "mania"
 
-    @staticmethod
-    def get_int_equivalent(gamemode: Enum) -> IntEnum:
+    def get_int_equivalent(self: "GameModeStr") -> "GameModeInt":
         return GameModeInt[gamemode.name]
 
 
@@ -485,8 +484,7 @@ class GameModeInt(IntEnum):
     CATCH = 2
     MANIA = 3
 
-    @staticmethod
-    def get_str_equivalent(gamemode: IntEnum) -> Enum:
+    def get_str_equivalent(self: "GameModeInt") -> GameModeStr:
         return GameModeStr[gamemode.name]
 
 

{osu_py-2.2.0 → osu_py-2.2.2}/osu/objects/achievement.py

@@ -1,6 +1,6 @@
 from typing import Optional
 
-from ..util import prettify, get_optional
+from ..util import prettify, get_optional, get_required
 from ..enums import GameModeStr
 
 
@@ -40,15 +40,15 @@ class Achievement:
     )
 
     def __init__(self, data):
-        self.icon_url: str = data["icon_url"]
-        self.id: int = data["id"]
-        self.name: str = data["name"]
-        self.grouping: str = data["grouping"]
-        self.ordering: int = data["ordering"]
-        self.slug: str = data["slug"]
-        self.description: str = data["description"]
+        self.icon_url: str = get_required(data, "icon_url")
+        self.id: int = get_required(data, "id")
+        self.name: str = get_required(data, "name")
+        self.grouping: str = get_required(data, "grouping")
+        self.ordering: int = get_required(data, "ordering")
+        self.slug: str = get_required(data, "slug")
+        self.description: str = get_required(data, "description")
         self.mode: GameModeStr = get_optional(data, "mode", GameModeStr)
-        self.instructions: Optional[str] = data["instructions"]
+        self.instructions: Optional[str] = get_required(data, "instructions")
 
     def __repr__(self):
         return prettify(self, "name", "description")

{osu_py-2.2.0 → osu_py-2.2.2}/osu/objects/beatmap.py

@@ -2,7 +2,7 @@ from dateutil import parser
 from typing import Dict, Optional, List, Union, TYPE_CHECKING
 
 from ..enums import RankStatus, GameModeStr, GameModeInt
-from ..util import prettify, get_optional, get_optional_list
+from ..util import prettify, get_optional, get_optional_list, get_required
 from .user import UserCompact
 from .current_user_attributes import BeatmapsetPermissions
 
@@ -138,25 +138,25 @@ class BeatmapsetCompact:
         from .discussion import BeatmapsetDiscussion
         from .beatmapset_event import BeatmapsetEvent
 
-        self.artist: str = data["artist"]
-        self.artist_unicode: str = data["artist_unicode"]
-        self.covers: Covers = Covers(data["covers"])
-        self.creator: str = data["creator"]
-        self.favourite_count: int = data["favourite_count"]
+        self.artist: str = get_required(data, "artist")
+        self.artist_unicode: str = get_required(data, "artist_unicode")
+        self.covers: Covers = Covers(get_required(data, "covers"))
+        self.creator: str = get_required(data, "creator")
+        self.favourite_count: int = get_required(data, "favourite_count")
         self.hype: Optional[BeatmapsetRequirement] = get_optional(data, "hype", BeatmapsetRequirement)
-        self.id: int = data["id"]
-        self.nsfw: bool = data["nsfw"]
-        self.offset: int = data["offset"]
-        self.play_count: int = data["play_count"]
-        self.preview_url: str = data["preview_url"]
-        self.source: str = data["source"]
-        self.spotlight: bool = data["spotlight"]
-        self.status: RankStatus = RankStatus[data["status"].upper()]
-        self.title: str = data["title"]
-        self.title_unicode: str = data["title_unicode"]
-        self.track_id: Optional[int] = data["track_id"]
-        self.user_id: int = data["user_id"]
-        self.video: bool = data["video"]
+        self.id: int = get_required(data, "id")
+        self.nsfw: bool = get_required(data, "nsfw")
+        self.offset: int = get_required(data, "offset")
+        self.play_count: int = get_required(data, "play_count")
+        self.preview_url: str = get_required(data, "preview_url")
+        self.source: str = get_required(data, "source")
+        self.spotlight: bool = get_required(data, "spotlight")
+        self.status: RankStatus = RankStatus[get_required(data, "status").upper()]
+        self.title: str = get_required(data, "title")
+        self.title_unicode: str = get_required(data, "title_unicode")
+        self.track_id: Optional[int] = get_required(data, "track_id")
+        self.user_id: int = get_required(data, "user_id")
+        self.video: bool = get_required(data, "video")
 
         self.background_url: str = f"https://assets.ppy.sh/beatmaps/{self.id}/covers/raw.jpg"
 
@@ -251,22 +251,22 @@ class Beatmapset(BeatmapsetCompact):
     def __init__(self, data):
         super().__init__(data)
 
-        self.availability: BeatmapsetAvailability = BeatmapsetAvailability(data["availability"])
+        self.availability: BeatmapsetAvailability = BeatmapsetAvailability(get_required(data, "availability"))
         self.beatmaps: Optional[List[Beatmap]] = get_optional_list(data, "beatmaps", Beatmap)
-        self.bpm: float = data["bpm"]
-        self.can_be_hyped: bool = data["can_be_hyped"]
+        self.bpm: float = get_required(data, "bpm")
+        self.can_be_hyped: bool = get_required(data, "can_be_hyped")
         self.deleted_at: Optional[datetime] = get_optional(data, "deleted_at", parser.parse)
         self.discussion_enabled: bool = True  # Deprecated, all beatmapset discussions are enabled
-        self.discussion_locked: bool = data["discussion_locked"]
-        self.is_scoreable: bool = data["is_scoreable"]
+        self.discussion_locked: bool = get_required(data, "discussion_locked")
+        self.is_scoreable: bool = get_required(data, "is_scoreable")
         self.last_updated: Optional[datetime] = get_optional(data, "last_updated", parser.parse)
-        self.legacy_thread_url: Optional[str] = data["legacy_thread_url"]
-        self.nominations_summary: BeatmapsetRequirement = BeatmapsetRequirement(data["nominations_summary"])
-        self.ranked: RankStatus = RankStatus(data["ranked"])
+        self.legacy_thread_url: Optional[str] = get_required(data, "legacy_thread_url")
+        self.nominations_summary: BeatmapsetRequirement = BeatmapsetRequirement(get_required(data, "nominations_summary"))
+        self.ranked: RankStatus = RankStatus(get_required(data, "ranked"))
         self.ranked_date: Optional[datetime] = get_optional(data, "ranked_date", parser.parse)
-        self.storyboard: bool = data["storyboard"]
+        self.storyboard: bool = get_required(data, "storyboard")
         self.submitted_date: Optional[datetime] = get_optional(data, "submitted_date", parser.parse)
-        self.tags: str = data["tags"]
+        self.tags: str = get_required(data, "tags")
 
 
 class BeatmapCompact:
@@ -319,14 +319,14 @@ class BeatmapCompact:
     )
 
     def __init__(self, data):
-        self.beatmapset_id: int = data["beatmapset_id"]
-        self.difficulty_rating: float = data["difficulty_rating"]
-        self.id: int = data["id"]
-        self.mode: GameModeStr = GameModeStr(data["mode"])
-        self.status: RankStatus = RankStatus[data["status"].upper()]
-        self.total_length: int = data["total_length"]
-        self.user_id: int = data["user_id"]
-        self.version: str = data["version"]
+        self.beatmapset_id: int = get_required(data, "beatmapset_id")
+        self.difficulty_rating: float = get_required(data, "difficulty_rating")
+        self.id: int = get_required(data, "id")
+        self.mode: GameModeStr = GameModeStr(get_required(data, "mode"))
+        self.status: RankStatus = RankStatus[get_required(data, "status").upper()]
+        self.total_length: int = get_required(data, "total_length")
+        self.user_id: int = get_required(data, "user_id")
+        self.version: str = get_required(data, "version")
 
         self.beatmapset: Optional[BeatmapsetCompact] = get_optional(data, "beatmapset", BeatmapsetCompact)
         self.checksum: Optional[str] = data.get("checksum")
@@ -412,25 +412,25 @@ class Beatmap(BeatmapCompact):
     def __init__(self, data):
         super().__init__(data)
 
-        self.accuracy: float = data["accuracy"]
-        self.ar: float = data["ar"]
+        self.accuracy: float = get_required(data, "accuracy")
+        self.ar: float = get_required(data, "ar")
         self.beatmapset: Optional[Beatmapset] = get_optional(data, "beatmapset", Beatmapset)
-        self.bpm: float = data["bpm"]
-        self.convert: Optional[bool] = data["convert"]
-        self.count_circles: int = data["count_circles"]
-        self.count_sliders: int = data["count_sliders"]
-        self.count_spinners: int = data["count_spinners"]
-        self.cs: float = data["cs"]
+        self.bpm: float = get_required(data, "bpm")
+        self.convert: Optional[bool] = get_required(data, "convert")
+        self.count_circles: int = get_required(data, "count_circles")
+        self.count_sliders: int = get_required(data, "count_sliders")
+        self.count_spinners: int = get_required(data, "count_spinners")
+        self.cs: float = get_required(data, "cs")
         self.deleted_at: Optional[datetime] = get_optional(data, "deleted_at", parser.parse)
-        self.drain: float = data["drain"]
-        self.hit_length: int = data["hit_length"]
-        self.is_scoreable: bool = data["is_scoreable"]
-        self.last_updated: datetime = parser.parse(data["last_updated"])
-        self.mode_int: GameModeInt = GameModeInt(data["mode_int"])
-        self.passcount: int = data["passcount"]
-        self.playcount: int = data["playcount"]
-        self.ranked: RankStatus = RankStatus(data["ranked"])
-        self.url: str = data["url"]
+        self.drain: float = get_required(data, "drain")
+        self.hit_length: int = get_required(data, "hit_length")
+        self.is_scoreable: bool = get_required(data, "is_scoreable")
+        self.last_updated: datetime = parser.parse(get_required(data, "last_updated"))
+        self.mode_int: GameModeInt = GameModeInt(get_required(data, "mode_int"))
+        self.passcount: int = get_required(data, "passcount")
+        self.playcount: int = get_required(data, "playcount")
+        self.ranked: RankStatus = RankStatus(get_required(data, "ranked"))
+        self.url: str = get_required(data, "url")
 
 
 class MetadataAttribute:
@@ -447,8 +447,8 @@ class MetadataAttribute:
     __slots__ = ("id", "name")
 
     def __init__(self, data):
-        self.id: Optional[int] = data["id"]
-        self.name: str = data["name"]
+        self.id: Optional[int] = get_required(data, "id")
+        self.name: str = get_required(data, "name")
 
 
 class OsuBeatmapDifficultyAttributes:
@@ -484,13 +484,13 @@ class OsuBeatmapDifficultyAttributes:
     )
 
     def __init__(self, data):
-        self.aim_difficulty: float = data["aim_difficulty"]
-        self.approach_rate: float = data["approach_rate"]
-        self.flashlight_difficulty: float = data["flashlight_difficulty"]
-        self.overall_difficulty: float = data["overall_difficulty"]
-        self.slider_factor: float = data["slider_factor"]
-        self.speed_difficulty: float = data["speed_difficulty"]
-        self.speed_note_count: float = data["speed_note_count"]
+        self.aim_difficulty: float = get_required(data, "aim_difficulty")
+        self.approach_rate: float = get_required(data, "approach_rate")
+        self.flashlight_difficulty: float = get_required(data, "flashlight_difficulty")
+        self.overall_difficulty: float = get_required(data, "overall_difficulty")
+        self.slider_factor: float = get_required(data, "slider_factor")
+        self.speed_difficulty: float = get_required(data, "speed_difficulty")
+        self.speed_note_count: float = get_required(data, "speed_note_count")
 
     def __repr__(self):
         return prettify(self, "aim_difficulty", "speed_difficulty")
@@ -523,11 +523,11 @@ class TaikoBeatmapDifficultyAttributes:
     )
 
     def __init__(self, data):
-        self.stamina_difficulty: float = data["stamina_difficulty"]
-        self.rhythm_difficulty: float = data["rhythm_difficulty"]
-        self.colour_difficulty: float = data["colour_difficulty"]
-        self.great_hit_window: float = data["great_hit_window"]
-        self.peak_difficulty: float = data["peak_difficulty"]
+        self.stamina_difficulty: float = get_required(data, "stamina_difficulty")
+        self.rhythm_difficulty: float = get_required(data, "rhythm_difficulty")
+        self.colour_difficulty: float = get_required(data, "colour_difficulty")
+        self.great_hit_window: float = get_required(data, "great_hit_window")
+        self.peak_difficulty: float = get_required(data, "peak_difficulty")
 
     def __repr__(self):
         return prettify(self, "stamina_difficulty")
@@ -546,7 +546,7 @@ class FruitsBeatmapDifficultyAttributes:
     __slots__ = "approach_rate"
 
     def __init__(self, data):
-        self.approach_rate: float = data["approach_rate"]
+        self.approach_rate: float = get_required(data, "approach_rate")
 
     def __repr__(self):
         return prettify(self, "approach_rate")
@@ -567,8 +567,8 @@ class ManiaBeatmapDifficultyAttributes:
     __slots__ = ("great_hit_window", "score_multiplier")
 
     def __init__(self, data):
-        self.great_hit_window: float = data["great_hit_window"]
-        self.score_multiplier: float = data["score_multiplier"]
+        self.great_hit_window: float = get_required(data, "great_hit_window")
+        self.score_multiplier: float = get_required(data, "score_multiplier")
 
     def __repr__(self):
         return prettify(self, "great_hit_window")
@@ -607,9 +607,9 @@ class BeatmapDifficultyAttributes:
         ]
 
     def __init__(self, data):
-        data = data["attributes"]
-        self.max_combo: int = data["max_combo"]
-        self.star_rating: float = data["star_rating"]
+        data = get_required(data, "attributes")
+        self.max_combo: int = get_required(data, "max_combo")
+        self.star_rating: float = get_required(data, "star_rating")
         if "aim_difficulty" in data:
             self.type = GameModeStr.STANDARD
             self.mode_attributes = OsuBeatmapDifficultyAttributes(data)
@@ -687,13 +687,13 @@ class Covers:
     )
 
     def __init__(self, data):
-        self.cover: str = data["cover"]
+        self.cover: str = get_required(data, "cover")
         self.cover_2x: str = data["cover@2x"]
-        self.card: str = data["card"]
+        self.card: str = get_required(data, "card")
         self.card_2x: str = data["card@2x"]
-        self.list: str = data["list"]
+        self.list: str = get_required(data, "list")
         self.list_2x: str = data["list@2x"]
-        self.slimcover: str = data["slimcover"]
+        self.slimcover: str = get_required(data, "slimcover")
         self.slimcover_2x: str = data["slimcover@2x"]
 
     def __repr__(self):
@@ -718,10 +718,10 @@ class BeatmapPlaycount:
     __slots__ = ("beatmap_id", "beatmap", "beatmapset", "count")
 
     def __init__(self, data):
-        self.beatmap_id: int = data["beatmap_id"]
+        self.beatmap_id: int = get_required(data, "beatmap_id")
         self.beatmap: Optional[BeatmapCompact] = get_optional(data, "beatmap", BeatmapCompact)
         self.beatmapset: Optional[BeatmapsetCompact] = get_optional(data, "beatmapset", BeatmapsetCompact)
-        self.count: int = data["count"]
+        self.count: int = get_required(data, "count")
 
     def __repr__(self):
         return prettify(self, "beatmap_id", "count")
@@ -746,7 +746,7 @@ class BeatmapsetRequirement:
     __slots__ = ("current", "required", "eligible_main_rulesets", "required_meta")
 
     def __init__(self, data):
-        self.current: int = data["current"]
+        self.current: int = get_required(data, "current")
         self.required: Optional[int] = data.get("required")
 
         self.eligible_main_rulesets: Optional[List[GameModeStr]] = get_optional_list(
@@ -774,8 +774,8 @@ class BeatmapsetRequiredNominations:
     ___slots__ = ("main_ruleset", "non_main_ruleset")
 
     def __init__(self, data):
-        self.main_ruleset = data["main_ruleset"]
-        self.non_main_ruleset = data["non_main_ruleset"]
+        self.main_ruleset = get_required(data, "main_ruleset")
+        self.non_main_ruleset = get_required(data, "non_main_ruleset")
 
 
 class BeatmapsetAvailability:
@@ -792,7 +792,7 @@ class BeatmapsetAvailability:
     __slots__ = ("download_disabled", "more_information")
 
     def __init__(self, data):
-        self.download_disabled: bool = data["download_disabled"]
+        self.download_disabled: bool = get_required(data, "download_disabled")
         self.more_information: Optional[str] = data.get("more_information")
 
     def __repr__(self):
@@ -835,7 +835,7 @@ class BaseNominations:
         self.nomination_reset: Optional[BeatmapsetEvent] = get_optional(data, "nomination_reset", BeatmapsetEvent)
         self.ranking_eta: Optional[str] = data.get("ranking_eta")
         self.ranking_queue_position: Optional[int] = data.get("ranking_queue_position")
-        self.required_hype: int = data["required_hype"]
+        self.required_hype: int = get_required(data, "required_hype")
 
     def __repr__(self):
         return prettify(self, "nominated")
@@ -860,8 +860,8 @@ class LegacyNominations(BaseNominations):
 
     def __init__(self, data):
         super().__init__(data)
-        self.current: int = data["current"]
-        self.required: int = data["required"]
+        self.current: int = get_required(data, "current")
+        self.required: int = get_required(data, "required")
 
     def __repr__(self):
         return prettify("current", "required")
@@ -887,11 +887,11 @@ class Nominations(BaseNominations):
     def __init__(self, data):
         super().__init__(data)
         self.current: Dict[GameModeStr, int] = dict(
-            zip(map(GameModeStr, (current := data["current"]).keys()), current.values())
+            zip(map(GameModeStr, (current := get_required(data, "current")).keys()), current.values())
         )
         self.required: Dict[GameModeStr, int] = dict(
             zip(
-                map(GameModeStr, (required := data["required"]).keys()),
+                map(GameModeStr, (required := get_required(data, "required")).keys()),
                 required.values(),
             )
         )
@@ -916,10 +916,10 @@ class CurrentNomination:
     """
 
     def __init__(self, data):
-        self.beatmapset_id: int = data["beatmapset_id"]
+        self.beatmapset_id: int = get_required(data, "beatmapset_id")
         self.rulesets: Optional[List[GameModeStr]] = get_optional_list(data, "rulesets", GameModeStr)
-        self.reset: bool = data["reset"]
-        self.user_id: int = data["user_id"]
+        self.reset: bool = get_required(data, "reset")
+        self.user_id: int = get_required(data, "user_id")
 
     def __repr__(self):
         return prettify(self, "beatmapset_id", "user_id")

{osu_py-2.2.0 → osu_py-2.2.2}/osu/objects/beatmapset_event.py

@@ -2,7 +2,7 @@ from dateutil import parser
 from typing import Optional, List, TYPE_CHECKING
 
 from ..enums import GameModeStr, BeatmapsetEventType
-from ..util import prettify
+from ..util import prettify, get_required
 from .discussion import BeatmapsetDiscussion
 from .beatmap import BeatmapsetCompact
 
@@ -78,18 +78,18 @@ class BeatmapsetEvent:
     )
 
     def __init__(self, data):
-        self.id: int = data["id"]
-        self.type: BeatmapsetEventType = BeatmapsetEventType(data["type"])
-        self.comment: Optional[BeatmapsetEventComment] = data["comment"]
+        self.id: int = get_required(data, "id")
+        self.type: BeatmapsetEventType = BeatmapsetEventType(get_required(data, "type"))
+        self.comment: Optional[BeatmapsetEventComment] = get_required(data, "comment")
         if self.comment is not None:
             self.comment = BeatmapsetEventComment(self.comment, self.type)  # type: ignore
-        self.created_at: datetime = parser.parse(data["created_at"])
+        self.created_at: datetime = parser.parse(get_required(data, "created_at"))
         self.user_id: Optional[int] = data.get("user_id")
         self.beatmapset: Optional[BeatmapsetCompact] = (
-            BeatmapsetCompact(data["beatmapset"]) if data.get("beatmapset") is not None else None
+            BeatmapsetCompact(get_required(data, "beatmapset")) if data.get("beatmapset") is not None else None
         )
         self.discussion: Optional[BeatmapsetDiscussion] = (
-            BeatmapsetDiscussion(data["discussion"]) if data.get("discussion") is not None else None
+            BeatmapsetDiscussion(get_required(data, "discussion")) if data.get("discussion") is not None else None
         )
 
     def __repr__(self):
@@ -106,7 +106,7 @@ class BeatmapsetEventNominate:
     __slots__ = ("modes",)
 
     def __init__(self, data):
-        self.modes: List[GameModeStr] = list(map(GameModeStr, data["modes"]))
+        self.modes: List[GameModeStr] = list(map(GameModeStr, get_required(data, "modes")))
 
     def __repr__(self):
         return prettify(self, "modes")
@@ -122,7 +122,7 @@ class BeatmapsetEventRemoveFromLoved:
     __slots__ = ("reason",)
 
     def __init__(self, data):
-        self.reason: str = data["reason"]
+        self.reason: str = get_required(data, "reason")
 
     def __repr__(self):
         return prettify(self, "reason")
@@ -138,7 +138,7 @@ class BeatmapsetEventDisqualify:
     __slots__ = ("nominator_ids",)
 
     def __init__(self, data):
-        self.nominator_ids: List[int] = data["nominator_ids"]
+        self.nominator_ids: List[int] = get_required(data, "nominator_ids")
 
     def __repr__(self):
         return prettify(self, "nominator_ids")
@@ -156,8 +156,8 @@ class BeatmapsetEventVote:
     __slots__ = ("user_id", "score")
 
     def __init__(self, data):
-        self.user_id: int = data["user_id"]
-        self.score: int = data["score"]
+        self.user_id: int = get_required(data, "user_id")
+        self.score: int = get_required(data, "score")
 
     def __repr__(self):
         return prettify(self, "user_id", "score")
@@ -176,10 +176,10 @@ class BeatmapsetEventKudosuChange:
 
     def __init__(self, data):
         self.new_votes: Optional[BeatmapsetEventVote] = (
-            BeatmapsetEventVote(data["new_votes"]) if data.get("new_votes") is not None else None
+            BeatmapsetEventVote(get_required(data, "new_votes")) if data.get("new_votes") is not None else None
         )
         self.votes: Optional[List[BeatmapsetEventVote]] = (
-            list(map(BeatmapsetEventVote, data["votes"])) if data.get("votes") is not None else None
+            list(map(BeatmapsetEventVote, get_required(data, "votes"))) if data.get("votes") is not None else None
         )
 
     def __repr__(self):
@@ -205,7 +205,7 @@ class BeatmapsetEventKudosuRecalculate:
 
     def __init__(self, data):
         self.new_votes: Optional[BeatmapsetEventVote] = (
-            BeatmapsetEventVote(data["new_votes"]) if data.get("new_votes") is not None else None
+            BeatmapsetEventVote(get_required(data, "new_votes")) if data.get("new_votes") is not None else None
         )
 
     def __repr__(self):
@@ -222,7 +222,7 @@ class BeatmapsetEventDiscussionLock:
     __slots__ = ("reason",)
 
     def __init__(self, data):
-        self.reason: str = data["reason"]
+        self.reason: str = get_required(data, "reason")
 
     def __repr__(self):
         return prettify(self, "reason")
@@ -238,7 +238,7 @@ class BeatmapsetEventNominationReset:
     __slots__ = ("nominator_ids",)
 
     def __init__(self, data):
-        self.nominator_ids: List[int] = data["nominator_ids"]
+        self.nominator_ids: List[int] = get_required(data, "nominator_ids")
 
     def __repr__(self):
         return prettify(self, "nominator_ids")
@@ -256,8 +256,8 @@ class BeatmapsetEventNominationResetReceived:
     __slots__ = ("source_user_id", "source_user_username")
 
     def __init__(self, data):
-        self.source_user_id: int = data["source_user_id"]
-        self.source_user_username: str = data["source_user_username"]
+        self.source_user_id: int = get_required(data, "source_user_id")
+        self.source_user_username: str = get_required(data, "source_user_username")
 
     def __repr__(self):
         return prettify(self, "source_user_id", "source_user_username")
@@ -275,8 +275,8 @@ class BeatmapsetEventEdit:
     __slots__ = ("old", "new")
 
     def __init__(self, data):
-        self.old: str = data["old"]
-        self.new: str = data["new"]
+        self.old: str = get_required(data, "old")
+        self.new: str = get_required(data, "new")
 
     def __repr__(self):
         return prettify(self, "old", "new")
@@ -314,10 +314,10 @@ class BeatmapsetEventBeatmapOwnerChange:
     __slots__ = ("beatmap_id", "beatmap_version", "new_user_id", "new_user_username")
 
     def __init__(self, data):
-        self.beatmap_id: int = data["beatmap_id"]
-        self.beatmap_version: str = data["beatmap_version"]
-        self.new_user_id: int = data["new_user_id"]
-        self.new_user_username: str = data["new_user_username"]
+        self.beatmap_id: int = get_required(data, "beatmap_id")
+        self.beatmap_version: str = get_required(data, "beatmap_version")
+        self.new_user_id: int = get_required(data, "new_user_id")
+        self.new_user_username: str = get_required(data, "new_user_username")
 
     def __repr__(self):
         return prettify(self, "beatmap_id", "new_user_username")