esd-services-api-client 1.1.3__tar.gz → 1.1.5__tar.gz

{esd_services_api_client-1.1.3 → esd_services_api_client-1.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: esd-services-api-client
-Version: 1.1.3
+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.5/esd_services_api_client/_version.py

@@ -0,0 +1 @@
+__version__ = '1.1.5'

{esd_services_api_client-1.1.3 → esd_services_api_client-1.1.5}/esd_services_api_client/beast/v3/_connector.py

@@ -254,6 +254,16 @@ class BeastConnector:
 
         return response.json()["lifeCycleStage"]
 
+    def get_request_runtime_info(self, request_id: str) -> Optional[dict]:
+        """
+          Returns the runtime information for the given request. Returns None in case error retry fails to resolve within given timeout.
+        :param request_id: A request identifier to read runtime info for.
+        """
+        response = self.http.get(f"{self.base_url}/job/requests/{request_id}")
+        response.raise_for_status()
+
+        return response.json()
+
     def start_job(self, job_params: BeastJobParams, job_name: str) -> Optional[str]:
         """
           Starts a job through Beast.

esd_services_api_client-1.1.5/esd_services_api_client/boxer/README.md

@@ -0,0 +1,103 @@
+# Boxer API Connector
+
+Conenctor for working with [Boxer](https://github.com/SneaksAndData/boxer) AuthZ/AuthN API. 
+
+## Usage
+
+Two environment variables must be set before you can use this connector:
+
+```shell
+export BOXER_CONSUMER_ID="my_app_consumer"
+export BOXER_PRIVATE_KEY="MIIEpAIBAA..."
+```
+
+### Retrieving Claims:
+
+```python
+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())
+```
+Output:
+```bash
+{'claim_name':'test1.test.sneaksanddata.com/.*', 'claim_value':'.*'}
+{'claim_name':'test2.test.sneaksanddata.com/.*', 'claim_value':'.*'}
+```
+
+### Insert claims:
+```python
+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)
+```
+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}
+```
+
+### Remove claims:
+```python
+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}
+```
+
+### Add a user:
+```python
+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)
+```
+
+### Remove a user:
+```python
+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
+```python
+from esd_services_api_client.boxer import BoxerConnector, RefreshableExternalTokenAuth, BoxerTokenAuth
+from esd_services_api_client.crystal import CrystalConnector
+
+auth_method = "example"
+
+def get_external_token() -> str:
+    return "example_token"
+
+# Configure authentication with boxer
+external_auth = RefreshableExternalTokenAuth(lambda: get_external_token(), auth_method)
+boxer_connector = BoxerConnector(base_url="https://example.com", auth=external_auth)
+
+# Inject boxer auth to Crystal connector
+connector = CrystalConnector(base_url="https://example.com", auth=BoxerTokenAuth(boxer_connector))
+
+# Use Crystal connector with boxer auth
+connector.await_runs("algorithm", ["id"])
+```

{esd_services_api_client-1.1.3 → esd_services_api_client-1.1.5}/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-1.1.5/esd_services_api_client/boxer/_models.py

@@ -0,0 +1,75 @@
+"""
+ Models for Boxer
+"""
+#  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 dataclasses import dataclass
+
+from dataclasses_json import LetterCase, dataclass_json, DataClassJsonMixin
+
+
+@dataclass_json
+@dataclass
+class Claim(DataClassJsonMixin):
+    """
+    Boxer Claim
+    """
+
+    claim_name: str
+    claim_value: str
+
+
+@dataclass_json
+@dataclass
+class ClaimPayload(DataClassJsonMixin):
+    """
+    Boxer Claim Payload for Deleting/Inserting claims
+    """
+
+    operation: str
+    claims: dict
+
+    def add_claim(self, claim: Claim) -> "ClaimPayload":
+        """
+        Add a claim to the ClaimPayload
+        """
+        self.claims |= {claim.claim_name: claim.claim_value}
+        return self
+
+
+@dataclass_json(letter_case=LetterCase.CAMEL)
+@dataclass
+class ClaimResponse(DataClassJsonMixin):
+    """
+    Boxer Claim request response
+    """
+
+    identity_provider: str
+    user_id: str
+    claims: list[dict]
+    billing_id: str
+
+
+class BoxerToken:
+    """
+    Represents token created by BoxerConnector.get_token
+    """
+
+    def __init__(self, token: str):
+        self._token = token
+
+    def __str__(self):
+        return self._token

{esd_services_api_client-1.1.3 → esd_services_api_client-1.1.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "esd-services-api-client"
-version = "1.1.3"
+version = "1.1.5"
 description = "Python clients for ESD services"
 authors = ["ECCO Sneaks & Data <esdsupport@ecco.com>"]
 maintainers = ['GZU <gzu@ecco.com>', 'JRB <ext-jrb@ecco.com>', 'VISA <visa@ecco.com>']

esd_services_api_client-1.1.3/esd_services_api_client/_version.py

@@ -1 +0,0 @@
-__version__ = '1.1.3'

esd_services_api_client-1.1.3/esd_services_api_client/boxer/README.md

@@ -1,91 +0,0 @@
-# Boxer API Connector
-
-Conenctor for working with [Boxer](https://github.com/SneaksAndData/boxer) AuthZ/AuthN API. 
-
-## Usage
-
-Two environment variables must be set before you can use this connector:
-
-```shell
-export BOXER_CONSUMER_ID="my_app_consumer"
-export BOXER_PRIVATE_KEY="MIIEpAIBAA..."
-```
-
-### Retrieving User 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:
-    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")
-```
-
-### Retrieving Group 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")
-```
-
-### 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")
-```
-
-### Setting a group 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_group_claim(claim, "ad_group_name")
-```
-
-### Creating a new Auth Consumer (obtaining private key):
-```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")
-```
-
-### Getting Consumer's public key:
-```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")
-```
-
-### Using as an authentication provider for other connectors
-```python
-from esd_services_api_client.boxer import BoxerConnector, RefreshableExternalTokenAuth, BoxerTokenAuth
-from esd_services_api_client.crystal import CrystalConnector
-
-auth_method = "example"
-
-def get_external_token() -> str:
-    return "example_token"
-
-# Configure authentication with boxer
-external_auth = RefreshableExternalTokenAuth(lambda: get_external_token(), auth_method)
-boxer_connector = BoxerConnector(base_url="https://example.com", auth=external_auth)
-
-# Inject boxer auth to Crystal connector
-connector = CrystalConnector(base_url="https://example.com", auth=BoxerTokenAuth(boxer_connector))
-
-# Use Crystal connector with boxer auth
-connector.await_runs("algorithm", ["id"])
-```

esd_services_api_client-1.1.3/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")

esd_services_api_client-1.1.3/esd_services_api_client/boxer/_models.py

@@ -1,131 +0,0 @@
-"""
- Models for Boxer
-"""
-#  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 dataclasses import dataclass
-from typing import Dict
-
-
-@dataclass
-class BoxerClaim:
-    """
-    Boxer Claim
-    """
-
-    claim_type: 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
-class UserClaim:
-    """
-    Boxer User Claim
-    """
-
-    user_id: str
-    user_claim_id: str
-    claim: BoxerClaim
-
-    def to_dict(self) -> Dict:
-        """Convert to Dictionary
-        :return: Dictionary
-        """
-        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:
-        """
-        return UserClaim(
-            user_id=json_data["userId"],
-            user_claim_id=json_data["userClaimId"],
-            claim=BoxerClaim.from_dict(json_data["claim"]),
-        )
-
-
-@dataclass
-class GroupClaim:
-    """
-    Boxer Group Claim
-    """
-
-    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"]),
-        )
-
-
-class BoxerToken:
-    """
-    Represents token created by BoxerConnector.get_token
-    """
-
-    def __init__(self, token: str):
-        self._token = token
-
-    def __str__(self):
-        return self._token