Automatically update Python SDK

Author: github-actions[bot]

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "trophy"
-version = "1.0.20"
+version = "1.0.21"
 description = "A Python library for the Trophy API"
 license = {text = "MIT"}
 readme = "README.md"

trophy/__init__.py

@@ -8,6 +8,8 @@
     AchievementWithStatsResponseEventAttribute,
     AchievementWithStatsResponseUserAttributesItem,
     BaseStreakResponse,
+    BulkStreakResponse,
+    BulkStreakResponseItem,
     CompletedAchievementResponse,
     ErrorBody,
     EventResponse,
@@ -62,6 +64,8 @@
     "AsyncTrophyApi",
     "BadRequestError",
     "BaseStreakResponse",
+    "BulkStreakResponse",
+    "BulkStreakResponseItem",
     "CompletedAchievementResponse",
     "ErrorBody",
     "EventResponse",

trophy/streaks/client.py

@@ -2,22 +2,96 @@
 
 from ..core.client_wrapper import SyncClientWrapper
 import typing
-from .types.streaks_rankings_request_type import StreaksRankingsRequestType
 from ..core.request_options import RequestOptions
-from ..types.streak_ranking_user import StreakRankingUser
+from ..types.bulk_streak_response import BulkStreakResponse
 from ..core.pydantic_utilities import parse_obj_as
 from ..errors.unauthorized_error import UnauthorizedError
 from ..types.error_body import ErrorBody
 from ..errors.unprocessable_entity_error import UnprocessableEntityError
 from json.decoder import JSONDecodeError
 from ..core.api_error import ApiError
+from .types.streaks_rankings_request_type import StreaksRankingsRequestType
+from ..types.streak_ranking_user import StreakRankingUser
 from ..core.client_wrapper import AsyncClientWrapper
 
 
 class StreaksClient:
     def __init__(self, *, client_wrapper: SyncClientWrapper):
         self._client_wrapper = client_wrapper
 
+    def list(
+        self,
+        *,
+        user_ids: typing.Optional[typing.Union[str, typing.Sequence[str]]] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> BulkStreakResponse:
+        """
+        Get the streak lengths of a list of users, ranked by streak length from longest to shortest.
+
+        Parameters
+        ----------
+        user_ids : typing.Optional[typing.Union[str, typing.Sequence[str]]]
+            A list of up to 100 user IDs.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        BulkStreakResponse
+            Successful operation
+
+        Examples
+        --------
+        from trophy import TrophyApi
+
+        client = TrophyApi(
+            api_key="YOUR_API_KEY",
+        )
+        client.streaks.list()
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            "streaks",
+            method="GET",
+            params={
+                "userIds": user_ids,
+            },
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return typing.cast(
+                    BulkStreakResponse,
+                    parse_obj_as(
+                        type_=BulkStreakResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+            if _response.status_code == 401:
+                raise UnauthorizedError(
+                    typing.cast(
+                        ErrorBody,
+                        parse_obj_as(
+                            type_=ErrorBody,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    )
+                )
+            if _response.status_code == 422:
+                raise UnprocessableEntityError(
+                    typing.cast(
+                        ErrorBody,
+                        parse_obj_as(
+                            type_=ErrorBody,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    )
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
     def rankings(
         self,
         *,
@@ -101,6 +175,87 @@ class AsyncStreaksClient:
     def __init__(self, *, client_wrapper: AsyncClientWrapper):
         self._client_wrapper = client_wrapper
 
+    async def list(
+        self,
+        *,
+        user_ids: typing.Optional[typing.Union[str, typing.Sequence[str]]] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> BulkStreakResponse:
+        """
+        Get the streak lengths of a list of users, ranked by streak length from longest to shortest.
+
+        Parameters
+        ----------
+        user_ids : typing.Optional[typing.Union[str, typing.Sequence[str]]]
+            A list of up to 100 user IDs.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        BulkStreakResponse
+            Successful operation
+
+        Examples
+        --------
+        import asyncio
+
+        from trophy import AsyncTrophyApi
+
+        client = AsyncTrophyApi(
+            api_key="YOUR_API_KEY",
+        )
+
+
+        async def main() -> None:
+            await client.streaks.list()
+
+
+        asyncio.run(main())
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "streaks",
+            method="GET",
+            params={
+                "userIds": user_ids,
+            },
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return typing.cast(
+                    BulkStreakResponse,
+                    parse_obj_as(
+                        type_=BulkStreakResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+            if _response.status_code == 401:
+                raise UnauthorizedError(
+                    typing.cast(
+                        ErrorBody,
+                        parse_obj_as(
+                            type_=ErrorBody,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    )
+                )
+            if _response.status_code == 422:
+                raise UnprocessableEntityError(
+                    typing.cast(
+                        ErrorBody,
+                        parse_obj_as(
+                            type_=ErrorBody,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    )
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
     async def rankings(
         self,
         *,

trophy/types/__init__.py

@@ -11,6 +11,8 @@
     AchievementWithStatsResponseUserAttributesItem,
 )
 from .base_streak_response import BaseStreakResponse
+from .bulk_streak_response import BulkStreakResponse
+from .bulk_streak_response_item import BulkStreakResponseItem
 from .completed_achievement_response import CompletedAchievementResponse
 from .error_body import ErrorBody
 from .event_response import EventResponse
@@ -48,6 +50,8 @@
     "AchievementWithStatsResponseEventAttribute",
     "AchievementWithStatsResponseUserAttributesItem",
     "BaseStreakResponse",
+    "BulkStreakResponse",
+    "BulkStreakResponseItem",
     "CompletedAchievementResponse",
     "ErrorBody",
     "EventResponse",

trophy/types/bulk_streak_response.py

@@ -0,0 +1,6 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+from .bulk_streak_response_item import BulkStreakResponseItem
+
+BulkStreakResponse = typing.List[BulkStreakResponseItem]

trophy/types/bulk_streak_response_item.py

@@ -0,0 +1,40 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import typing_extensions
+from ..core.serialization import FieldMetadata
+import pydantic
+import typing
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class BulkStreakResponseItem(UniversalBaseModel):
+    user_id: typing_extensions.Annotated[str, FieldMetadata(alias="userId")] = (
+        pydantic.Field()
+    )
+    """
+    The ID of the user.
+    """
+
+    streak_length: typing_extensions.Annotated[
+        int, FieldMetadata(alias="streakLength")
+    ] = pydantic.Field()
+    """
+    The length of the user's streak.
+    """
+
+    extended: typing.Optional[str] = pydantic.Field(default=None)
+    """
+    The timestamp the streak was extended, as a string.
+    """
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(
+            extra="allow", frozen=True
+        )  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow