mindbridge-api-python-client 1.4.10__tar.gz → 1.4.11__tar.gz

{mindbridge_api_python_client-1.4.10 → mindbridge_api_python_client-1.4.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mindbridge-api-python-client
-Version: 1.4.10
+Version: 1.4.11
 Summary: Interact with the MindBridge API
 Home-page: https://www.mindbridge.ai
 License: Proprietary

{mindbridge_api_python_client-1.4.10 → mindbridge_api_python_client-1.4.11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "mindbridge-api-python-client"
-version = "1.4.10"
+version = "1.4.11"
 description = "Interact with the MindBridge API"
 license = "Proprietary"
 authors = [
@@ -63,7 +63,6 @@ flake8-clean-block = "^0.1.2"
 flake8-comprehensions = "^3.14.0"
 flake8-encodings = "^0.5.1"
 flake8-implicit-str-concat = "^0.4.0"
-flake8-newspaper-style = "^0.4.3"
 flake8-pytest-style = "^2.0.0"
 flake8-return = "^1.2.0"
 flake8-simplify = "^0.21.0"

mindbridge_api_python_client-1.4.11/src/mindbridgeapi/account_group_item.py

@@ -0,0 +1,31 @@
+#
+#  Copyright MindBridge Analytics Inc. all rights reserved.
+#
+#  This material is confidential and may not be copied, distributed,
+#  reversed engineered, decompiled or otherwise disseminated without
+#  the prior written consent of MindBridge Analytics Inc.
+#
+
+from typing import Any, Dict
+from pydantic import ConfigDict, model_validator
+from mindbridgeapi.common_validators import _warning_if_extra_fields
+from mindbridgeapi.generated_pydantic_model.model import (
+    ApiAccountGroupRead,
+    ApiAccountGroupUpdate,
+)
+
+
+class AccountGroupItem(ApiAccountGroupRead):
+    model_config = ConfigDict(
+        extra="allow",
+        validate_assignment=True,
+        validate_default=True,
+        validate_return=True,
+    )
+    _ = model_validator(mode="after")(_warning_if_extra_fields)
+
+    @property
+    def update_json(self) -> Dict[str, Any]:
+        in_class_dict = self.model_dump()
+        ag_update = ApiAccountGroupUpdate.model_validate(in_class_dict)
+        return ag_update.model_dump(mode="json", by_alias=True, exclude_none=True)

mindbridge_api_python_client-1.4.11/src/mindbridgeapi/account_grouping_item.py

@@ -0,0 +1,49 @@
+#
+#  Copyright MindBridge Analytics Inc. all rights reserved.
+#
+#  This material is confidential and may not be copied, distributed,
+#  reversed engineered, decompiled or otherwise disseminated without
+#  the prior written consent of MindBridge Analytics Inc.
+#
+
+from typing import Any, Dict, Generator
+from pydantic import ConfigDict, Field, field_validator, model_validator
+from mindbridgeapi.account_group_item import AccountGroupItem
+from mindbridgeapi.common_validators import (
+    _convert_userinfo_to_useritem,
+    _warning_if_extra_fields,
+)
+from mindbridgeapi.generated_pydantic_model.model import (
+    ApiAccountGroupingRead,
+    ApiAccountGroupingUpdate,
+)
+
+
+def _empty_account_groups() -> Generator[AccountGroupItem, None, None]:
+    """Empty generator function
+
+    This returns an empty generator function, it's use is to ensure account_groups is
+    not None for the AccountGroupingItem class
+    """
+    yield from ()
+
+
+class AccountGroupingItem(ApiAccountGroupingRead):
+    account_groups: Generator[AccountGroupItem, None, None] = Field(
+        default_factory=_empty_account_groups, exclude=True
+    )
+
+    model_config = ConfigDict(
+        extra="allow",
+        validate_assignment=True,
+        validate_default=True,
+        validate_return=True,
+    )
+    _a = model_validator(mode="after")(_warning_if_extra_fields)
+    _b = field_validator("*")(_convert_userinfo_to_useritem)
+
+    @property
+    def update_json(self) -> Dict[str, Any]:
+        in_class_dict = self.model_dump()
+        ag_update = ApiAccountGroupingUpdate.model_validate(in_class_dict)
+        return ag_update.model_dump(mode="json", by_alias=True, exclude_none=True)

{mindbridge_api_python_client-1.4.10 → mindbridge_api_python_client-1.4.11}/src/mindbridgeapi/account_groupings.py

@@ -11,18 +11,17 @@ from functools import cached_property
 import logging
 from typing import TYPE_CHECKING, Any, Dict, Generator, Optional, Union
 from mindbridgeapi.account_grouping_item import AccountGroupingItem
+from mindbridgeapi.async_result_item import AsyncResultItem
 from mindbridgeapi.async_results import AsyncResults
 from mindbridgeapi.base_set import BaseSet
 from mindbridgeapi.exceptions import ItemError, ItemNotFoundError
 from mindbridgeapi.generated_pydantic_model.model import (
-    ApiAsyncResult,
     ApiImportAccountGroupingParamsCreateOnly,
     ApiImportAccountGroupingParamsUpdate,
 )
 from mindbridgeapi.generated_pydantic_model.model import (
     Type7 as AccountGroupingFileType,
 )
-from mindbridgeapi.generated_pydantic_model.model import Status2 as AsyncResultStatus
 from mindbridgeapi.generated_pydantic_model.model import Type1 as AsyncResultType
 
 if TYPE_CHECKING:
@@ -46,7 +45,9 @@ class AccountGroupings(BaseSet):
         url = f"{self.base_url}/{id}"
         resp_dict = super()._get_by_id(url=url)
 
-        return AccountGroupingItem.model_validate(resp_dict)
+        account_grouping = AccountGroupingItem.model_validate(resp_dict)
+        self.restart_account_groups(account_grouping)
+        return account_grouping
 
     def get(
         self, json: Optional[Dict[str, Any]] = None
@@ -56,19 +57,21 @@ class AccountGroupings(BaseSet):
 
         url = f"{self.base_url}/query"
         for resp_dict in super()._get(url=url, json=json):
-            yield AccountGroupingItem.model_validate(resp_dict)
+            account_grouping = AccountGroupingItem.model_validate(resp_dict)
+            self.restart_account_groups(account_grouping)
+            yield account_grouping
 
-    def export(self, input_item: AccountGroupingItem) -> ApiAsyncResult:
+    def export(self, input_item: AccountGroupingItem) -> AsyncResultItem:
         if getattr(input_item, "id", None) is None:
             raise ItemNotFoundError
 
         url = f"{self.base_url}/{input_item.id}/export"
         resp_dict = super()._create(url=url)
 
-        return ApiAsyncResult.model_validate(resp_dict)
+        return AsyncResultItem.model_validate(resp_dict)
 
     def wait_for_export(
-        self, async_result: ApiAsyncResult, max_wait_minutes: int = 5
+        self, async_result: AsyncResultItem, max_wait_minutes: int = 5
     ) -> None:
         """Wait for the async result for the data table export to complete
 
@@ -92,23 +95,22 @@ class AccountGroupings(BaseSet):
         )
 
     def download(
-        self, async_result: ApiAsyncResult, output_file_path: "Path"
+        self, async_result: AsyncResultItem, output_file_path: "Path"
     ) -> "Path":
-        # Get the current status
-        resp_dict = super()._get_by_id(
-            url=f"{self.server.base_url}/async-results/{async_result.id}"
-        )
-        async_result = ApiAsyncResult.model_validate(resp_dict)
+        if async_result.id is None:
+            raise ItemNotFoundError
 
-        url = f"{self.server.base_url}/file-results/{async_result.entity_id}/export"
+        async_result = self.server.async_results.get_by_id(async_result.id)
 
-        if async_result.type != AsyncResultType.ACCOUNT_GROUPING_EXPORT:
-            raise ItemError(f"{async_result.type=}")
+        file_result_id = async_result._get_file_result_id(
+            expected_type=AsyncResultType.ACCOUNT_GROUPING_EXPORT
+        )
 
-        if async_result.status != AsyncResultStatus.COMPLETE:
-            raise ItemError(f"{async_result.status=}")
+        file_result = self.server.file_results.get_by_id(file_result_id)
 
-        return super()._download(url=url, output_path=output_file_path)
+        return self.server.file_results.export(
+            file_result=file_result, output_file_path=output_file_path
+        )
 
     def upload(
         self,
@@ -125,7 +127,9 @@ class AccountGroupings(BaseSet):
         json = ag_params.model_dump(mode="json", by_alias=True, exclude_none=True)
         resp_dict = super()._create(url=url, json=json)
 
-        return AccountGroupingItem.model_validate(resp_dict)
+        account_grouping = AccountGroupingItem.model_validate(resp_dict)
+        self.restart_account_groups(account_grouping)
+        return account_grouping
 
     def update(self, account_grouping: AccountGroupingItem) -> AccountGroupingItem:
         if getattr(account_grouping, "id", None) is None:
@@ -134,7 +138,9 @@ class AccountGroupings(BaseSet):
         url = f"{self.base_url}/{account_grouping.id}"
         resp_dict = super()._update(url=url, json=account_grouping.update_json)
 
-        return AccountGroupingItem.model_validate(resp_dict)
+        account_grouping = AccountGroupingItem.model_validate(resp_dict)
+        self.restart_account_groups(account_grouping)
+        return account_grouping
 
     def delete(self, account_grouping: AccountGroupingItem) -> None:
         if getattr(account_grouping, "id", None) is None:
@@ -157,4 +163,14 @@ class AccountGroupings(BaseSet):
         json = ag_params.model_dump(mode="json", by_alias=True, exclude_none=True)
         resp_dict = super()._create(url=url, json=json)
 
-        return AccountGroupingItem.model_validate(resp_dict)
+        account_grouping = AccountGroupingItem.model_validate(resp_dict)
+        self.restart_account_groups(account_grouping)
+        return account_grouping
+
+    def restart_account_groups(self, account_grouping: AccountGroupingItem) -> None:
+        if getattr(account_grouping, "id", None) is None:
+            raise ItemNotFoundError
+
+        account_grouping.account_groups = self.server.account_groups.get(
+            json={"accountGroupingId": {"$eq": account_grouping.id}}
+        )

mindbridge_api_python_client-1.4.11/src/mindbridgeapi/account_groups.py

@@ -0,0 +1,65 @@
+#
+#  Copyright MindBridge Analytics Inc. all rights reserved.
+#
+#  This material is confidential and may not be copied, distributed,
+#  reversed engineered, decompiled or otherwise disseminated without
+#  the prior written consent of MindBridge Analytics Inc.
+#
+
+from dataclasses import dataclass
+from functools import cached_property
+import logging
+from typing import Any, Dict, Generator, Optional
+from mindbridgeapi.account_group_item import AccountGroupItem
+from mindbridgeapi.base_set import BaseSet
+from mindbridgeapi.exceptions import ItemNotFoundError, ParameterError
+from mindbridgeapi.generated_pydantic_model.model import MindBridgeQueryTerm
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class AccountGroups(BaseSet):
+    @cached_property
+    def base_url(self) -> str:
+        return f"{self.server.base_url}/account-groups"
+
+    def get_by_id(self, id: str) -> AccountGroupItem:
+        url = f"{self.base_url}/{id}"
+        resp_dict = super()._get_by_id(url=url)
+
+        return AccountGroupItem.model_validate(resp_dict)
+
+    def get(
+        self, json: Optional[Dict[str, Any]] = None
+    ) -> Generator[AccountGroupItem, None, None]:
+        if json is None:
+            json = {}
+
+        mindbridgequeryterm = MindBridgeQueryTerm.model_validate(json)
+        json_str = mindbridgequeryterm.model_dump_json(
+            by_alias=True, exclude_none=True, warnings=False
+        )
+        logger.info(f"Query (get) is: {json_str}")
+
+        if "accountGroupingId" not in json_str:
+            raise ParameterError(
+                parameter_name="json",
+                details=(
+                    "At least one valid accountGroupingId term must be provided when "
+                    "querying this entity."
+                ),
+            )
+
+        url = f"{self.base_url}/query"
+        for resp_dict in super()._get(url=url, json=json):
+            yield AccountGroupItem.model_validate(resp_dict)
+
+    def update(self, account_group: AccountGroupItem) -> AccountGroupItem:
+        if getattr(account_group, "id", None) is None:
+            raise ItemNotFoundError
+
+        url = f"{self.base_url}/{account_group.id}"
+        resp_dict = super()._update(url=url, json=account_group.update_json)
+
+        return AccountGroupItem.model_validate(resp_dict)

{mindbridge_api_python_client-1.4.10 → mindbridge_api_python_client-1.4.11}/src/mindbridgeapi/analyses.py

@@ -14,7 +14,7 @@ from typing import TYPE_CHECKING, Any, Dict, Generator, Optional
 import warnings
 from mindbridgeapi.analysis_item import AnalysisItem
 from mindbridgeapi.analysis_sources import AnalysisSources
-from mindbridgeapi.async_results import AsyncResults
+from mindbridgeapi.async_result_item import AsyncResultItem
 from mindbridgeapi.base_set import BaseSet
 from mindbridgeapi.data_tables import DataTables
 from mindbridgeapi.exceptions import (
@@ -27,7 +27,6 @@ from mindbridgeapi.exceptions import (
 )
 from mindbridgeapi.generated_pydantic_model.model import (
     ApiAnalysisStatusRead,
-    ApiAsyncResult,
     ApiEngagementRollForwardRequest,
     EntityType,
 )
@@ -42,9 +41,6 @@ logger = logging.getLogger(__name__)
 
 @dataclass
 class Analyses(BaseSet):
-    def __post_init__(self) -> None:
-        self.async_result_set = AsyncResults(server=self.server)
-
     @cached_property
     def base_url(self) -> str:
         return f"{self.server.base_url}/analyses"
@@ -133,7 +129,7 @@ class Analyses(BaseSet):
         # Get the list of async_result ids
         async_results_to_check = []
         for analysis_source in analysis.analysis_sources:
-            async_results = self.async_result_set.get(
+            async_results = self.server.async_results.get(
                 json={
                     "$and": [
                         {"entityId": {"$eq": analysis_source.id}},
@@ -166,7 +162,7 @@ class Analyses(BaseSet):
             """
             raise ItemError("Analysis has no analysis sources.")  # noqa: TRY003
 
-        self.async_result_set._wait_for_async_results(
+        self.server.async_results._wait_for_async_results(
             async_results=async_results_to_check,
             max_wait_minutes=max_wait_minutes,
             init_interval_sec=11,
@@ -261,7 +257,7 @@ class Analyses(BaseSet):
         if analysis.id is None:
             raise ItemNotFoundError
 
-        async_results = self.async_result_set.get(
+        async_results = self.server.async_results.get(
             json={
                 "$and": [
                     {"entityId": {"$eq": analysis.id}},
@@ -281,7 +277,7 @@ class Analyses(BaseSet):
             async_results_list, key=lambda x: getattr(x, "last_modified_date", date.min)
         )
 
-        self.async_result_set._wait_for_async_result(
+        self.server.async_results._wait_for_async_result(
             async_result=async_result,
             max_wait_minutes=max_wait_minutes,
             init_interval_sec=76,
@@ -321,7 +317,7 @@ class Analyses(BaseSet):
             mode="json", by_alias=True, exclude_none=True
         )
         resp_dict = super()._create(url=url, json=roll_forward_request_json)
-        async_result = ApiAsyncResult.model_validate(resp_dict)
+        async_result = AsyncResultItem.model_validate(resp_dict)
         if async_result.entity_id is None:
             raise UnexpectedServerError(details="async_result.entity_id was None")
 

{mindbridge_api_python_client-1.4.10 → mindbridge_api_python_client-1.4.11}/src/mindbridgeapi/analysis_sources.py

@@ -11,6 +11,7 @@ from functools import cached_property
 import logging
 from typing import Any, Dict, Generator, Optional
 from mindbridgeapi.analysis_source_item import AnalysisSourceItem
+from mindbridgeapi.async_result_item import AsyncResultItem
 from mindbridgeapi.base_set import BaseSet
 from mindbridgeapi.exceptions import (
     ItemAlreadyExistsError,
@@ -24,7 +25,6 @@ from mindbridgeapi.generated_pydantic_model.model import (
 from mindbridgeapi.generated_pydantic_model.model import (
     PeriodType as AnalysisEffectiveDateMetricsPeriod,
 )
-from mindbridgeapi.generated_pydantic_model.model import ApiAsyncResult
 from mindbridgeapi.generated_pydantic_model.model import Type1 as AsyncResultType
 
 logger = logging.getLogger(__name__)
@@ -42,7 +42,7 @@ class AnalysisSources(BaseSet):
 
         url = self.base_url
         resp_dict = super()._create(url=url, json=item.create_json)
-        async_result = ApiAsyncResult.model_validate(resp_dict)
+        async_result = AsyncResultItem.model_validate(resp_dict)
 
         if async_result.type != AsyncResultType.ANALYSIS_SOURCE_INGESTION:
             raise UnexpectedServerError(f"Async Result Type: {async_result.type}")
@@ -109,7 +109,7 @@ class AnalysisSources(BaseSet):
         url = f"{self.base_url}/{item.id}"
         resp_dict = super()._update(url=url, json=item.update_json)
 
-        async_result = ApiAsyncResult.model_validate(resp_dict)
+        async_result = AsyncResultItem.model_validate(resp_dict)
 
         if async_result.type != AsyncResultType.ANALYSIS_SOURCE_INGESTION:
             raise UnexpectedServerError(f"Async Result Type: {async_result.type}")

mindbridge_api_python_client-1.4.11/src/mindbridgeapi/async_result_item.py

@@ -0,0 +1,70 @@
+#
+#  Copyright MindBridge Analytics Inc. all rights reserved.
+#
+#  This material is confidential and may not be copied, distributed,
+#  reversed engineered, decompiled or otherwise disseminated without
+#  the prior written consent of MindBridge Analytics Inc.
+#
+
+import logging
+from pydantic import ConfigDict, field_validator, model_validator
+from mindbridgeapi.common_validators import (
+    _convert_userinfo_to_useritem,
+    _warning_if_extra_fields,
+)
+from mindbridgeapi.exceptions import ItemError, ItemNotFoundError, ValidationError
+from mindbridgeapi.generated_pydantic_model.model import ApiAsyncResult
+from mindbridgeapi.generated_pydantic_model.model import Status2 as AsyncResultStatus
+from mindbridgeapi.generated_pydantic_model.model import Type1 as AsyncResultType
+
+logger = logging.getLogger(__name__)
+
+
+class AsyncResultItem(ApiAsyncResult):
+    model_config = ConfigDict(
+        extra="allow",
+        validate_assignment=True,
+        validate_default=True,
+        validate_return=True,
+    )
+    _a = model_validator(mode="after")(_warning_if_extra_fields)
+    _b = field_validator("*")(_convert_userinfo_to_useritem)
+
+    def _check_if_completed(self) -> bool:
+        """Checks if the AsyncResultItem is completed
+
+        Returns True if COMPLETE, False if IN_PROGRESS and raises and error otherwise.
+
+        Returns:
+            bool: True if COMPLETE, False if IN_PROGRESS
+
+        Raises:
+            ValidationError: If the async_result resulted in an error state
+        """
+        async_result_str = (
+            f"Async Result {self.id} for"
+            f" {self.entity_type} {self.entity_id} resulted in"
+            f" {self.status}"
+        )
+        logger.info(async_result_str)
+
+        if self.status == AsyncResultStatus.IN_PROGRESS:
+            return False
+
+        if self.status == AsyncResultStatus.COMPLETE:
+            return True
+
+        # Must be AsyncResultStatus.ERROR
+        raise ValidationError(f"{async_result_str} with message {self.error}.")
+
+    def _get_file_result_id(self, expected_type: AsyncResultType) -> str:
+        if self.type != expected_type:
+            raise ItemError(f"{self.type=}")
+
+        if self.status != AsyncResultStatus.COMPLETE:
+            raise ItemError(f"{self.status=}")
+
+        if self.entity_id is None:
+            raise ItemNotFoundError
+
+        return self.entity_id

{mindbridge_api_python_client-1.4.10 → mindbridge_api_python_client-1.4.11}/src/mindbridgeapi/async_results.py

@@ -11,15 +11,13 @@ from functools import cached_property
 import logging
 import time
 from typing import Any, Dict, Generator, List, Optional
+from mindbridgeapi.async_result_item import AsyncResultItem
 from mindbridgeapi.base_set import BaseSet
 from mindbridgeapi.exceptions import (
     ItemNotFoundError,
     UnexpectedServerError,
     ValidationError,
 )
-from mindbridgeapi.generated_pydantic_model.model import (
-    ApiAsyncResult as AsyncResultItem,
-)
 from mindbridgeapi.generated_pydantic_model.model import Status2 as AsyncResultStatus
 
 logger = logging.getLogger(__name__)
@@ -52,6 +50,45 @@ class AsyncResults(BaseSet):
             init_interval_sec=init_interval_sec,
         )
 
+    @staticmethod
+    def _wait_for_async_results_refresh_sorted_ids(
+        async_results: List[AsyncResultItem],
+    ) -> List[str]:
+        async_result_ids = []
+        for async_result in async_results:
+            if async_result.id is None:
+                raise ItemNotFoundError
+
+            async_result_ids.append(async_result.id)
+
+        return sorted(async_result_ids)
+
+    def _wait_for_async_results_refresh(
+        self, async_results: List[AsyncResultItem]
+    ) -> List[AsyncResultItem]:
+        if not async_results:
+            return []
+
+        sorted_async_result_ids = self._wait_for_async_results_refresh_sorted_ids(
+            async_results=async_results
+        )
+
+        new_async_results = list(
+            self.get(json={"id": {"$in": sorted_async_result_ids}})
+        )
+
+        sorted_new_async_result_ids = self._wait_for_async_results_refresh_sorted_ids(
+            async_results=new_async_results
+        )
+
+        if sorted_async_result_ids != sorted_new_async_result_ids:
+            raise UnexpectedServerError(
+                f"AsyncResults received didn't match: {sorted_async_result_ids=}, "
+                f"{sorted_new_async_result_ids=}"
+            )
+
+        return new_async_results
+
     def _wait_for_async_results(
         self,
         async_results: List[AsyncResultItem],
@@ -82,66 +119,46 @@ class AsyncResults(BaseSet):
         while (time.monotonic() - start_time) < max_wait_seconds:
             loop_start_time = time.monotonic()
             elapsed_time = loop_start_time - start_time
-            sorted_async_results_ids = sorted(
-                [x.id for x in async_results if x.id is not None]
-            )
-            number_of_async_results = len(sorted_async_results_ids)
-            if number_of_async_results != len(async_results):
-                raise ItemNotFoundError
 
             logger.info(
                 "Starting a AsyncResult iteration. It has been: "
-                f"{elapsed_time:.1f} seconds. Loop {i=} and {number_of_async_results} "
+                f"{elapsed_time:.1f} seconds. Loop {i=} and {len(async_results)} "
                 "to check"
             )
 
-            if number_of_async_results <= 0:
+            if not async_results:
                 break
 
-            if number_of_async_results == 1:
-                new_async_results = [self.get_by_id(sorted_async_results_ids[0])]
-            else:
-                query = {"id": {"$in": sorted_async_results_ids}}
-                new_async_results = list(self.get(json=query))
-
-            if (
-                sorted([x.id for x in new_async_results if x.id is not None])
-                != sorted_async_results_ids
-            ):
-                raise UnexpectedServerError(  # noqa: TRY003
-                    "AsyncResults received didn't match requested"
+            new_async_results = [
+                async_result
+                for async_result in self._wait_for_async_results_refresh(
+                    async_results=async_results
                 )
+                if not async_result._check_if_completed()
+            ]
 
-            async_results = []
-            for async_result in new_async_results:
-                if async_result is None:
-                    raise UnexpectedServerError("AsyncResult was None")  # noqa: TRY003
-
-                if not self._check_if_async_result_is_completed(async_result):
-                    async_results.append(async_result)
-
-            if len(async_results) == 0:
+            if not new_async_results:
                 break
 
-            sleep_seconds = interval_sec - (time.monotonic() - loop_start_time)
+            sleep_seconds = max(interval_sec - (time.monotonic() - loop_start_time), 0)
             logger.info(
                 f"Waiting for about {sleep_seconds} seconds as some of the async "
                 "results are not complete yet."
             )
-            if sleep_seconds > 0:
-                time.sleep(sleep_seconds)
+            time.sleep(sleep_seconds)
 
             elapsed_time = time.monotonic() - start_time
-            logger.info(
-                "Finished a AsyncResult iteration. It has been:"
-                f" {elapsed_time:.1f} seconds"
-            )
 
             if interval_sec < max_interval_sec:
                 interval_sec = min(init_interval_sec * 2**i, max_interval_sec)
 
             i = i + 1
 
+            logger.info(
+                "Finished a AsyncResults iteration. It has been:"
+                f" {elapsed_time:.1f} seconds"
+            )
+
         else:
             raise TimeoutError(f"Waited too long: {max_wait_minutes} minutes")
 

{mindbridge_api_python_client-1.4.10 → mindbridge_api_python_client-1.4.11}/src/mindbridgeapi/base_set.py

@@ -173,4 +173,7 @@ class BaseSet:
             except (UnicodeDecodeError, json.JSONDecodeError):
                 pass
 
-            raise ValidationError(http_error_msg)
+            if resp.status < 500:
+                raise ValidationError(http_error_msg)
+
+            raise UnexpectedServerError(http_error_msg)