refactor: rename weapon skin methods for consistency

examples/basic2.py

@@ -43,18 +43,18 @@ async def main() -> None:
 
         # skin
 
-        skins = await client.fetch_weapon_skins()
+        skins = await client.fetch_skins()
         for skin in skins:
             print(skin.display_name)
 
         # skin level
 
-        skin_levels = await client.fetch_weapon_skin_levels()
+        skin_levels = await client.fetch_skin_levels()
         for level in skin_levels:
             print(level.display_name)
 
         # skin chroma
-        skin_chromas = await client.fetch_weapon_skin_chromas()
+        skin_chromas = await client.fetch_skin_chromas()
         for chroma in skin_chromas:
             print(chroma.display_name)
 

tests/test_client.py

@@ -348,44 +348,44 @@ async def test_weapons(client: Client) -> None:
 
 @pytest.mark.anyio
 async def test_weapon_skins(client: Client) -> None:
-    weapon_skins = await client.fetch_weapon_skins()
+    weapon_skins = await client.fetch_skins()
     assert len(weapon_skins) > 0
 
     weapon_skin_id = weapon_skins[0].uuid
-    weapon_skin = await client.fetch_weapon_skin(str(weapon_skin_id))
+    weapon_skin = await client.fetch_skin(str(weapon_skin_id))
     assert weapon_skin is not None
     assert weapon_skin_id == weapon_skin.uuid
 
     with pytest.raises(NotFound):
-        await client.fetch_weapon_skin('fake-weapon-skin-id')
+        await client.fetch_skin('fake-weapon-skin-id')
 
 
 @pytest.mark.anyio
 async def test_weapon_skin_chromas(client: Client) -> None:
-    weapon_skin_chromas = await client.fetch_weapon_skin_chromas()
+    weapon_skin_chromas = await client.fetch_skin_chromas()
     assert len(weapon_skin_chromas) > 0
 
     weapon_skin_chroma_id = weapon_skin_chromas[0].uuid
-    weapon_skin_chroma = await client.fetch_weapon_skin_chroma(str(weapon_skin_chroma_id))
+    weapon_skin_chroma = await client.fetch_skin_chroma(str(weapon_skin_chroma_id))
     assert weapon_skin_chroma is not None
     assert weapon_skin_chroma_id == weapon_skin_chroma.uuid
 
     with pytest.raises(NotFound):
-        await client.fetch_weapon_skin_chroma('fake-weapon-skin-chroma-id')
+        await client.fetch_skin_chroma('fake-weapon-skin-chroma-id')
 
 
 @pytest.mark.anyio
 async def test_weapon_skin_levels(client: Client) -> None:
-    weapon_skin_levels = await client.fetch_weapon_skin_levels()
+    weapon_skin_levels = await client.fetch_skin_levels()
     assert len(weapon_skin_levels) > 0
 
     weapon_skin_level_id = weapon_skin_levels[0].uuid
-    weapon_skin_level = await client.fetch_weapon_skin_level(str(weapon_skin_level_id))
+    weapon_skin_level = await client.fetch_skin_level(str(weapon_skin_level_id))
     assert weapon_skin_level is not None
     assert weapon_skin_level_id == weapon_skin_level.uuid
 
     with pytest.raises(NotFound):
-        await client.fetch_weapon_skin_level('fake-weapon-skin-level-id')
+        await client.fetch_skin_level('fake-weapon-skin-level-id')
 
 
 @pytest.mark.anyio

valorant/client.py

@@ -397,36 +397,32 @@ async def fetch_weapons(self, *, language: LanguageOption | None = None) -> list
         weapons = Response[list[Weapon]].model_validate(data)
         return weapons.data
 
-    async def fetch_weapon_skin(self, uuid: str, /, *, language: LanguageOption | None = None) -> Skin | None:
+    async def fetch_skin(self, uuid: str, /, *, language: LanguageOption | None = None) -> Skin | None:
         data = await self.http.get_weapon_skin(uuid, language=language or self.language)
         skin = Response[Skin].model_validate(data)
         return skin.data
 
-    async def fetch_weapon_skins(self, *, language: LanguageOption | None = None) -> list[Skin]:
+    async def fetch_skins(self, *, language: LanguageOption | None = None) -> list[Skin]:
         data = await self.http.get_weapon_skins(language=language or self.language)
         skins = Response[list[Skin]].model_validate(data)
         return skins.data
 
-    async def fetch_weapon_skin_chroma(
-        self, uuid: str, /, *, language: LanguageOption | None = None
-    ) -> SkinChroma | None:
+    async def fetch_skin_chroma(self, uuid: str, /, *, language: LanguageOption | None = None) -> SkinChroma | None:
         data = await self.http.get_weapon_skin_chroma(uuid, language=language or self.language)
         skin_chroma = Response[SkinChroma].model_validate(data)
         return skin_chroma.data
 
-    async def fetch_weapon_skin_chromas(self, *, language: LanguageOption | None = None) -> list[SkinChroma]:
+    async def fetch_skin_chromas(self, *, language: LanguageOption | None = None) -> list[SkinChroma]:
         data = await self.http.get_weapon_skin_chromas(language=language or self.language)
         skin_chromas = Response[list[SkinChroma]].model_validate(data)
         return skin_chromas.data
 
-    async def fetch_weapon_skin_level(
-        self, uuid: str, /, *, language: LanguageOption | None = None
-    ) -> SkinLevel | None:
+    async def fetch_skin_level(self, uuid: str, /, *, language: LanguageOption | None = None) -> SkinLevel | None:
         data = await self.http.get_weapon_skin_level(uuid, language=language or self.language)
         skin_level = Response[SkinLevel].model_validate(data)
         return skin_level.data
 
-    async def fetch_weapon_skin_levels(self, *, language: LanguageOption | None = None) -> list[SkinLevel]:
+    async def fetch_skin_levels(self, *, language: LanguageOption | None = None) -> list[SkinLevel]:
         data = await self.http.get_weapon_skin_levels(language=language or self.language)
         skin_levels = Response[list[SkinLevel]].model_validate(data)
         return skin_levels.data

valorant/models/contracts.py

@@ -69,7 +69,7 @@ class Reward(BaseUUIDModel):
 
     async def fetch_item(self, *, client: Client) -> RewardItemType | None:  # noqa: PLR0911
         if self.type is RewardType.skin_level:
-            return await client.fetch_weapon_skin_level(str(self.uuid))
+            return await client.fetch_skin_level(str(self.uuid))
         if self.type is RewardType.buddy_level:
             return await client.fetch_buddy_level(str(self.uuid))
         if self.type is RewardType.player_card: