esd-services-api-client 1.1.4__py3-none-any.whl → 1.1.5__py3-none-any.whl

esd_services_api_client/_version.py

@@ -1 +1 @@
-__version__ = '1.1.4'
+__version__ = '1.1.5'

esd_services_api_client/boxer/README.md

@@ -11,62 +11,74 @@ export BOXER_CONSUMER_ID="my_app_consumer"
 export BOXER_PRIVATE_KEY="MIIEpAIBAA..."
 ```
 
-### Retrieving User Claims:
+### Retrieving Claims:
 
 ```python
-from esd_services_api_client.boxer import BoxerConnector
-conn = BoxerConnector(base_url="https://boxer.test.sneaksanddata.com")
-claims = conn.get_claims_by_user("user@domain.tld")
-for claim in claims:
+from esd_services_api_client.boxer import select_authentication, BoxerClaimConnector
+auth = select_authentication("azuread", "test")
+conn = BoxerClaimConnector(base_url="https://boxer-claim.test.sneaksanddata.com", auth=auth)
+resp = conn.get_claims("email@ecco.com", "azuread")
+for claim in resp:
     print(claim.to_dict())
 ```
-
-### Retrieving Claims by Type:
-
-```python
-from esd_services_api_client.boxer import BoxerConnector
-conn = BoxerConnector(base_url="https://boxer.test.sneaksanddata.com")
-claims = conn.get_claims_by_type("App1.AccessPolicy")
+Output:
+```bash
+{'claim_name':'test1.test.sneaksanddata.com/.*', 'claim_value':'.*'}
+{'claim_name':'test2.test.sneaksanddata.com/.*', 'claim_value':'.*'}
 ```
 
-### Retrieving Group Claims:
-
+### Insert claims:
 ```python
-from esd_services_api_client.boxer import BoxerConnector
-conn = BoxerConnector(base_url="https://boxer.test.sneaksanddata.com")
-claims = conn.get_claims_by_group("ad_group_name")
+from esd_services_api_client.boxer import select_authentication, BoxerClaimConnector, Claim
+auth = select_authentication("azuread", "test")
+conn = BoxerClaimConnector(base_url="https://boxer-claim.test.sneaksanddata.com", auth=auth)
+claims = [Claim("some-test-1.test.sneaksanddata.com", ".*"), Claim("some-test-2.test.sneaksanddata.com", ".*")]
+resp = conn.add_claim("email@ecco.com", "azuread", claims)
+print(resp)
 ```
-
-### Setting a user claim:
-```python
-from esd_services_api_client.boxer import BoxerConnector
-from esd_services_api_client.boxer import BoxerClaim
-claim = BoxerClaim(issuer="App1", claim_type="App1.CanManageConsumers", claim_value="true")
-conn = BoxerConnector(base_url="https://boxer.test.sneaksanddata.com")
-conn.push_user_claim(claim, "app1admin")
+Output:
+```bash
+ClaimResponse(identity_provider='azuread', user_id='email@ecco.com', claims=[{'some-test-1.test.sneaksanddata.com': '.*'}, {'some-test-2.test.sneaksanddata.com': '.*'}], billing_id= None}
 ```
 
-### Setting a group claim:
+### Remove claims:
 ```python
-from esd_services_api_client.boxer import BoxerConnector
-from esd_services_api_client.boxer import BoxerClaim
-claim = BoxerClaim(issuer="App1", claim_type="App1.CanManageConsumers", claim_value="true")
-conn = BoxerConnector(base_url="https://boxer.test.sneaksanddata.com")
-conn.push_group_claim(claim, "ad_group_name")
+from esd_services_api_client.boxer import select_authentication, BoxerClaimConnector, Claim
+auth = select_authentication("azuread", "test")
+conn = BoxerClaimConnector(base_url="https://boxer-claim.test.sneaksanddata.com", auth=auth)
+claims = [Claim("some-test-1.test.sneaksanddata.com", ".*"), Claim("some-test-2.test.sneaksanddata.com", ".*")]
+resp = conn.remove_claim("email@ecco.com", "azuread", claims)
+print(resp)
+```
+Output:
+```bash
+ClaimResponse(identity_provider='azuread', user_id='email@ecco.com', claims=[], billing_id= None}
 ```
 
-### Creating a new Auth Consumer (obtaining private key):
+### Add a user:
 ```python
-from esd_services_api_client.boxer import BoxerConnector
-conn = BoxerConnector(base_url="https://boxer.test.sneaksanddata.com")
-priv_key = conn.create_consumer("app_consumer")
+from esd_services_api_client.boxer import select_authentication, BoxerClaimConnector, Claim
+auth = select_authentication("azuread", "test")
+conn = BoxerClaimConnector(base_url="https://boxer-claim.test.sneaksanddata.com", auth=auth)
+resp = conn.add_user("test@ecco.com", "azuread")
+print(resp)
+```
+Output:
+```bash
+ClaimResponse(identity_provider='azuread', user_id='test@ecco.com', claims=[], billing_id=None)
 ```
 
-### Getting Consumer's public key:
+### Remove a user:
 ```python
-from esd_services_api_client.boxer import BoxerConnector
-conn = BoxerConnector(base_url="https://boxer.test.sneaksanddata.com")
-pub_key = conn.get_consumer_public_key("app_consumer")
+from esd_services_api_client.boxer import select_authentication, BoxerClaimConnector, Claim
+auth = select_authentication("azuread", "test")
+conn = BoxerClaimConnector(base_url="https://boxer-claim.test.sneaksanddata.com", auth=auth)
+resp = conn.remove_user("test@ecco.com", "azuread")
+print(resp.status_code)
+```
+Output:
+```bash
+200
 ```
 
 ### Using as an authentication provider for other connectors

esd_services_api_client/boxer/_connector.py

@@ -17,12 +17,12 @@
 #
 
 import os
-from typing import Iterator, Optional
+from functools import reduce
+from typing import Optional, Iterator, final
 
-import jwt
 from adapta.security.clients import AzureClient
 from adapta.utils import session_with_retries
-from requests import Session
+from requests import Session, Response
 
 from esd_services_api_client.boxer._base import BoxerTokenProvider
 from esd_services_api_client.boxer._auth import (
@@ -32,11 +32,116 @@ from esd_services_api_client.boxer._auth import (
     ExternalAuthBase,
     RefreshableExternalTokenAuth,
 )
-from esd_services_api_client.boxer._helpers import (
-    _iterate_user_claims_response,
-    _iterate_boxer_claims_response,
+from esd_services_api_client.boxer._models import (
+    BoxerToken,
+    Claim,
+    ClaimPayload,
+    ClaimResponse,
 )
-from esd_services_api_client.boxer._models import BoxerClaim, UserClaim, BoxerToken
+
+
+@final
+class BoxerClaimConnector:
+    """
+    Boxer Claims API connector
+    """
+
+    def __init__(self, *, base_url: str, auth: Optional[BoxerTokenAuth] = None):
+        """Creates Boxer Claims connector, capable of managing claims
+        :param base_url: Base URL for Boxer Claims endpoint
+        :param auth: Boxer-based authentication
+        """
+        self._base_url = base_url
+        self._http = session_with_retries()
+        if auth and isinstance(auth, BoxerTokenAuth):
+            self._http.hooks["response"].append(auth.get_refresh_hook(self._http))
+        self._http.auth = auth
+
+    def get_claims(self, user_id: str, provider: str) -> Optional[Iterator[Claim]]:
+        """
+        Returns the claims assigned to the specified user_id and provider
+        """
+        response = self._http.get(f"{self._base_url}/claim/{provider}/{user_id}")
+        if response.status_code == 404:
+            return None
+        response.raise_for_status()
+        return self._iterate_user_claims_response(response)
+
+    def add_user(self, user_id: str, provider: str) -> ClaimResponse:
+        """
+        Adds a new user_id, provider pair
+        """
+        response = self._http.post(f"{self._base_url}/claim/{provider}/{user_id}")
+        response.raise_for_status()
+        return ClaimResponse.from_dict(response.json())
+
+    def remove_user(self, user_id: str, provider: str) -> Response:
+        """
+        Removes the specified user_id, provider pair and assigned claims
+        """
+        response = self._http.delete(f"{self._base_url}/claim/{provider}/{user_id}")
+        response.raise_for_status()
+        return response
+
+    def add_claim(
+        self, user_id: str, provider: str, claims: list[Claim]
+    ) -> Optional[ClaimResponse]:
+        """
+        Adds a new claim to an existing user_id, provider pair
+        """
+        payload_json = self._prepare_claim_payload(user_id, provider, claims, "Insert")
+        response = self._http.patch(
+            f"{self._base_url}/claim/{provider}/{user_id}",
+            data=payload_json,
+            headers={"Content-Type": "application/json"},
+        )
+        response.raise_for_status()
+        return ClaimResponse.from_dict(response.json())
+
+    def remove_claim(
+        self, user_id: str, provider: str, claims: list[Claim]
+    ) -> Optional[ClaimResponse]:
+        """
+        Removes the specified claim
+        """
+        payload_json = self._prepare_claim_payload(user_id, provider, claims, "Delete")
+        response = self._http.patch(
+            f"{self._base_url}/claim/{provider}/{user_id}",
+            data=payload_json,
+            headers={"Content-Type": "application/json"},
+        )
+        return ClaimResponse.from_dict(response.json())
+
+    def _prepare_claim_payload(
+        self, user_id: str, provider: str, claims: list[Claim], operation: str
+    ) -> Optional[str]:
+        """
+        Prepare payload for Inserting/Deleting claims
+        """
+        if self.get_claims(user_id, provider) is not None:
+            payload = ClaimPayload(operation, {})
+            claim_payload = reduce(
+                lambda cp, claim: cp.add_claim(claim), claims, payload
+            )
+
+            return claim_payload.to_json()
+        return None
+
+    def _iterate_user_claims_response(
+        self, user_claim_response: Response
+    ) -> Optional[Iterator[Claim]]:
+        """Creates an iterator to iterate user claims from Json Response
+        :param user_claim_response: HTTP Response
+        """
+        response_json = user_claim_response.json()
+        if response_json and "claims" in response_json:
+            for claim in response_json["claims"]:
+                if isinstance(claim, dict) and len(claim) == 1:
+                    for key, value in claim.items():
+                        yield Claim.from_dict({"claim_name": key, "claim_value": value})
+                        break
+        else:
+            raise ValueError("Expected response body of type application/json")
 
 
 class BoxerConnector(BoxerTokenProvider):
@@ -65,92 +170,6 @@ class BoxerConnector(BoxerTokenProvider):
             self.http.hooks["response"].append(auth.get_refresh_hook(self.http))
         self.retry_attempts = retry_attempts
 
-    def push_user_claim(self, claim: BoxerClaim, user_id: str):
-        """Adds/Overwrites a new Boxer Claim to a user
-        :param claim: Boxer Claim
-        :param user_id: User's UPN
-        :return:
-        """
-        target_url = f"{self.base_url}/claims/user/{user_id}"
-        claim_json = claim.to_dict()
-        response = self.http.post(target_url, json=claim_json)
-        response.raise_for_status()
-        print(f"Successfully pushed user claim for user {user_id}")
-
-    def push_group_claim(self, claim: BoxerClaim, group_name: str):
-        """Adds/Overwrites a new Boxer Claim to a user
-        :param claim: Boxer Claim
-        :param group_name: Group Name
-        :return:
-        """
-        target_url = f"{self.base_url}/claims/group/{group_name}"
-        claim_json = claim.to_dict()
-        response = self.http.post(target_url, json=claim_json)
-        response.raise_for_status()
-        print(f"Successfully pushed user claim for group {group_name}")
-
-    def get_claims_by_type(self, claims_type: str) -> Iterator[UserClaim]:
-        """Reads claims of specified type from Boxer.
-        :param claims_type: claim type to filter claims by.
-        :return: Iterator[UserClaim]
-        """
-        target_url = f"{self.base_url}/claims/type/{claims_type}"
-        response = self.http.get(target_url)
-        response.raise_for_status()
-        return _iterate_user_claims_response(response)
-
-    def get_claims_by_user(self, user_id: str) -> Iterator[BoxerClaim]:
-        """Reads user claims from Boxer
-        :param user_id: user upn to load claims for
-        :return: Iterator[UserClaim]
-        """
-        empty_user_token = jwt.encode({"upn": user_id}, "_", algorithm="HS256")
-        target_url = f"{self.base_url}/claims/user/{empty_user_token}"
-        response = self.http.get(target_url)
-        response.raise_for_status()
-        return _iterate_boxer_claims_response(response)
-
-    def get_claims_by_group(self, group_name: str) -> Iterator[BoxerClaim]:
-        """Reads group claims from Boxer
-        :param group_name: group name to load claims for
-        :return: Iterator[UserClaim]
-        """
-        target_url = f"{self.base_url}/claims/group/{group_name}"
-        response = self.http.get(target_url)
-        response.raise_for_status()
-        return _iterate_boxer_claims_response(response)
-
-    def get_claims_for_token(self, jwt_token: str) -> Iterator[BoxerClaim]:
-        """Reads user claims from Boxer based on jwt token
-        :param jwt_token: jwt token with UPN set
-        :return: Iterator[UserClaim]
-        """
-        target_url = f"{self.base_url}/claims/user/{jwt_token}"
-        response = self.http.get(target_url)
-        response.raise_for_status()
-        return _iterate_boxer_claims_response(response)
-
-    def create_consumer(self, consumer_id: str, overwrite: bool = False) -> str:
-        """Adds/Overwrites a new Boxer Claim to a user
-        :param consumer_id: Consumer ID of new consumer
-        :param overwrite: Flag to overwrite if consumer with given consumer_id already exists
-        :return: New consumer's private key (Base64 Encoded)
-        """
-        target_url = f"{self.base_url}/consumer/{consumer_id}?overwrite={overwrite}"
-        response = self.http.post(target_url, json={})
-        response.raise_for_status()
-        return response.text
-
-    def get_consumer_public_key(self, consumer_id: str) -> str:
-        """Reads Consumer's public key
-        :param consumer_id: Boxer Claim
-        :return: public key (Base64 Encoded)
-        """
-        target_url = f"{self.base_url}/consumer/publicKey/{consumer_id}"
-        response = self.http.get(target_url, json={})
-        response.raise_for_status()
-        return response.text
-
     def get_token(self) -> BoxerToken:
         """
         Authorize with external token and return BoxerToken

esd_services_api_client/boxer/_models.py

@@ -17,106 +17,50 @@
 #
 
 from dataclasses import dataclass
-from typing import Dict
 
+from dataclasses_json import LetterCase, dataclass_json, DataClassJsonMixin
 
+
+@dataclass_json
 @dataclass
-class BoxerClaim:
+class Claim(DataClassJsonMixin):
     """
     Boxer Claim
     """
 
-    claim_type: str
+    claim_name: str
     claim_value: str
-    issuer: str
-
-    def to_dict(self) -> Dict:
-        """Convert to Dictionary
-        :return: Dictionary
-        """
-        return {
-            "claimType": self.claim_type,
-            "claimValue": self.claim_value,
-            "issuer": self.issuer,
-        }
-
-    @classmethod
-    def from_dict(cls, json_data: Dict):
-        """Initialize from Dictionary
-        :param json_data: Dictionary
-        :return:
-        """
-        return BoxerClaim(
-            claim_type=json_data["claimType"],
-            claim_value=json_data["claimValue"],
-            issuer=json_data["issuer"],
-        )
 
 
+@dataclass_json
 @dataclass
-class UserClaim:
+class ClaimPayload(DataClassJsonMixin):
     """
-    Boxer User Claim
+    Boxer Claim Payload for Deleting/Inserting claims
     """
 
-    user_id: str
-    user_claim_id: str
-    claim: BoxerClaim
+    operation: str
+    claims: dict
 
-    def to_dict(self) -> Dict:
-        """Convert to Dictionary
-        :return: Dictionary
+    def add_claim(self, claim: Claim) -> "ClaimPayload":
         """
-        return {
-            "userId": self.user_id,
-            "userClaimId": self.user_claim_id,
-            "claim": self.claim.to_dict(),
-        }
-
-    @classmethod
-    def from_dict(cls, json_data: Dict):
-        """Initialize from Dictionary
-        :param json_data: Dictionary
-        :return:
+        Add a claim to the ClaimPayload
         """
-        return UserClaim(
-            user_id=json_data["userId"],
-            user_claim_id=json_data["userClaimId"],
-            claim=BoxerClaim.from_dict(json_data["claim"]),
-        )
+        self.claims |= {claim.claim_name: claim.claim_value}
+        return self
 
 
+@dataclass_json(letter_case=LetterCase.CAMEL)
 @dataclass
-class GroupClaim:
+class ClaimResponse(DataClassJsonMixin):
     """
-    Boxer Group Claim
+    Boxer Claim request response
     """
 
-    group_name: str
-    group_claim_id: str
-    claim: BoxerClaim
-
-    def to_dict(self) -> Dict:
-        """Convert to Dictionary
-        :return: Dictionary
-        """
-        return {
-            "groupName": self.group_name,
-            "groupClaimId": self.group_claim_id,
-            "claim": self.claim.to_dict(),
-        }
-
-    @classmethod
-    def from_dict(cls, json_data: Dict):
-        """Initialize from Dictionary
-        :param json_data: Dictionary
-        :return:
-        """
-        return GroupClaim(
-            group_name=json_data["groupName"],
-            group_claim_id=json_data["groupClaimId"],
-            claim=BoxerClaim.from_dict(json_data["claim"]),
-        )
+    identity_provider: str
+    user_id: str
+    claims: list[dict]
+    billing_id: str
 
 
 class BoxerToken:

{esd_services_api_client-1.1.4.dist-info → esd_services_api_client-1.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: esd-services-api-client
-Version: 1.1.4
+Version: 1.1.5
 Summary: Python clients for ESD services
 Home-page: https://github.com/SneaksAndData/esd-services-api-client
 License: Apache 2.0

{esd_services_api_client-1.1.4.dist-info → esd_services_api_client-1.1.5.dist-info}/RECORD

@@ -1,5 +1,5 @@
 esd_services_api_client/__init__.py,sha256=rP0njtEgVSMm-sOVayVfcRUrrubl4lme7HI2zS678Lo,598
-esd_services_api_client/_version.py,sha256=PjrAut5wUOgcQz79krZcrxCW7JYdU9nfMwMc8EdCaFo,22
+esd_services_api_client/_version.py,sha256=hTCioFruYR1lv7FF57n5II-8lYry8FuIYb1fA4g2ccc,22
 esd_services_api_client/beast/__init__.py,sha256=QwbmVfn2AOvfA-2_4I_hXpdiLr_kX319fPRpuOOgyqY,765
 esd_services_api_client/beast/v2/__init__.py,sha256=9lVZVxos-Ljov5SvVzvrjTAxMCeJAfn1dIVSGM56QDU,749
 esd_services_api_client/beast/v2/_connector.py,sha256=jjPjnHvNLrukcYnXjJKTnz4LMcbAlCzU76ysDbl_DcI,11302
@@ -7,19 +7,18 @@ esd_services_api_client/beast/v2/_models.py,sha256=XOTZqr83mX44SpXG4KBDEHJozVuDQ
 esd_services_api_client/beast/v3/__init__.py,sha256=TRjB4-T6eIORpMvdylb32_GinrIpYNFmAdshSC1HqHg,749
 esd_services_api_client/beast/v3/_connector.py,sha256=DrzlSAFw08NAtxf3u5VGVheamFE9gY2F50Z5Fg7QZe0,11585
 esd_services_api_client/beast/v3/_models.py,sha256=q-tGQCJEaqQaHvE8HmooMem3fGkhWCyWrDXOPhdXCsU,6930
-esd_services_api_client/boxer/README.md,sha256=U8kXXtJFi1w0woQ4F_UOdDZiQl6-K7zFmQEUV4EktfM,2983
+esd_services_api_client/boxer/README.md,sha256=-MAhYUPvmEMcgx_lo_2PlH_gZI1lndGv8fnDQYIpurU,3618
 esd_services_api_client/boxer/__init__.py,sha256=OYsWvdnLan0kmjUcH4I2-m1rbPeARKp5iqhp8uyudPk,780
 esd_services_api_client/boxer/_auth.py,sha256=vA7T9y0oZV2f17UWQ2or9CK8vAsNnHB10G5HNQe1l1I,7440
 esd_services_api_client/boxer/_base.py,sha256=PSU08QzTKFkXfzx7fF5FIHBOZXshxNEd1J_qKGo0Rd0,976
-esd_services_api_client/boxer/_connector.py,sha256=OBNQHlXHM3V6LWTlLFBpDBgS-m9Q3n-sLlqSGPAz4rQ,8476
-esd_services_api_client/boxer/_helpers.py,sha256=hjf96CWYEH2iThYDcBB1iEGzalUWn-S9PZJzZJ6bdG0,1736
-esd_services_api_client/boxer/_models.py,sha256=2tdVNRGQ0roR3THfzTq7KF2eQ5mS30PbxpqYhPm1y6A,3105
+esd_services_api_client/boxer/_connector.py,sha256=kATr7IyQKtvsGlvgVInO_DsGGC4yCC1aW3RxoXt-QIM,8672
+esd_services_api_client/boxer/_models.py,sha256=q_xRHOXlRroKrDrNUxQJUFGSotxYvUbRY1rYmx8UfJg,1697
 esd_services_api_client/common/__init__.py,sha256=rP0njtEgVSMm-sOVayVfcRUrrubl4lme7HI2zS678Lo,598
 esd_services_api_client/crystal/__init__.py,sha256=afSGQRkDic0ECsJfgu3b291kX8CyU57sjreqxj5cx-s,787
 esd_services_api_client/crystal/_api_versions.py,sha256=2BMiQRS0D8IEpWCCys3dge5alVBRCZrOuCR1QAn8UIM,832
 esd_services_api_client/crystal/_connector.py,sha256=yJObx9kHtaUmjry_B7EaJqbxn6t9aR0ypgrCGsCO5pI,12854
 esd_services_api_client/crystal/_models.py,sha256=eRhGAl8LjglCyIFwf1bcFBhjbpSuRYucuF2LO388L2E,4025
-esd_services_api_client-1.1.4.dist-info/LICENSE,sha256=0gS6zXsPp8qZhzi1xaGCIYPzb_0e8on7HCeFJe8fOpw,10693
-esd_services_api_client-1.1.4.dist-info/METADATA,sha256=ecLSWSdHfeFWKBPAGbPq2eR3XmCYjbLrpHVI1r3g-S4,1077
-esd_services_api_client-1.1.4.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-esd_services_api_client-1.1.4.dist-info/RECORD,,
+esd_services_api_client-1.1.5.dist-info/LICENSE,sha256=0gS6zXsPp8qZhzi1xaGCIYPzb_0e8on7HCeFJe8fOpw,10693
+esd_services_api_client-1.1.5.dist-info/METADATA,sha256=5qE27jp2LFYLK3LyO2TgiYmBjL5BadEumHwqM5W4sD8,1077
+esd_services_api_client-1.1.5.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+esd_services_api_client-1.1.5.dist-info/RECORD,,

esd_services_api_client/boxer/_helpers.py

@@ -1,46 +0,0 @@
-""" Helper functions to parse responses
-"""
-#  Copyright (c) 2023. ECCO Sneaks & Data
-#
-#  Licensed under the Apache License, Version 2.0 (the "License");
-#  you may not use this file except in compliance with the License.
-#  You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-#  Unless required by applicable law or agreed to in writing, software
-#  distributed under the License is distributed on an "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#  See the License for the specific language governing permissions and
-#  limitations under the License.
-#
-
-from requests import Response
-
-from esd_services_api_client.boxer._models import UserClaim, BoxerClaim
-
-
-def _iterate_user_claims_response(user_claim_response: Response):
-    """Creates an iterator to iterate user claims from Json Response
-    :param user_claim_response: HTTP Response containing json array of type UserClaim
-    """
-    response_json = user_claim_response.json()
-
-    if response_json:
-        for api_response_item in response_json:
-            yield UserClaim.from_dict(api_response_item)
-    else:
-        raise ValueError("Expected response body of type application/json")
-
-
-def _iterate_boxer_claims_response(boxer_claim_response: Response):
-    """Creates an iterator to iterate user claims from Json Response
-    :param boxer_claim_response: HTTP Response containing json array of type BoxerClaim
-    """
-    response_json = boxer_claim_response.json()
-
-    if response_json:
-        for api_response_item in response_json:
-            yield BoxerClaim.from_dict(api_response_item)
-    else:
-        raise ValueError("Expected response body of type application/json")