mindbridge-api-python-client 1.4.8__py3-none-any.whl

mindbridge_api_python_client-1.4.8.dist-info/LICENSE.txt

@@ -0,0 +1,11 @@
+This package contains intellectual property proprietary to MindBridge as per
+the Agreement, in addition to sample data sets, and shall be used for internal
+purposes by MindBridge clients only.
+
+You may include portions of this package in your software as needed for the
+purposes of consuming the MindBridge API.
+
+You may not redistribute this package to third parties except for the express
+purposes of the third party needing to develop software to integrate with
+MindBridge in order to further utilization of the MindBridge Software per the
+applicable Agreement.

mindbridge_api_python_client-1.4.8.dist-info/METADATA

@@ -0,0 +1,64 @@
+Metadata-Version: 2.1
+Name: mindbridge-api-python-client
+Version: 1.4.8
+Summary: Interact with the MindBridge API
+Home-page: https://www.mindbridge.ai
+License: Proprietary
+Author: Edgar Silva
+Author-email: edgar.silva@mindbridge.ai
+Maintainer: Kevin Paulson
+Maintainer-email: kevin.paulson@mindbridge.ai
+Requires-Python: >=3.8.1,<4.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Flake8
+Classifier: Framework :: Pydantic
+Classifier: Framework :: Pydantic :: 2
+Classifier: Framework :: Pytest
+Classifier: License :: Other/Proprietary License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Typing :: Typed
+Requires-Dist: pydantic (>=2.5.2,<3.0.0)
+Requires-Dist: typing-extensions (>=4.0.0,<5.0.0) ; python_version < "3.9"
+Requires-Dist: urllib3 (>=2.0.7,<3.0.0)
+Project-URL: Repository, https://github.com/mindbridge-ai/mindbridge-api-python-client
+Description-Content-Type: text/markdown
+
+<h1 align="center">MindBridge API Python Client</h1>
+<p align="center">
+    <img alt="Logo of MindBridge" src="https://www.mindbridge.ai/wp-content/uploads/2021/07/MindBridge_Logo_Primary_RGB.png" />
+</p>
+
+Interact with the MindBridge API using this Python SDK. Please see [The MindBridge API](https://www.mindbridge.ai/support/api/) for more information about the MindBridge API. You can also [Access MindBridge Customer Support](https://support.mindbridge.ai/hc/en-us/articles/360054147834-Access-MindBridge-Customer-Support) or [Contact us](https://www.mindbridge.ai/contact/).
+
+## Installation
+mindbridge-api-python-client can be installed with [pip](https://pip.pypa.io):
+
+```sh
+python -m pip install mindbridge-api-python-client
+```
+
+## Usage
+Replace `subdomain.mindbridge.ai` with your MindBridge tenant URL.
+```python
+import getpass
+import mindbridgeapi as mbapi
+
+url = "subdomain.mindbridge.ai"
+token = getpass.getpass(f"Token for {url}: ")
+
+server = mbapi.Server(url=url, token=token)
+
+organization = mbapi.OrganizationItem(name="My Organization name")
+organization = server.organizations.create(organization)
+
+# Create engagements, analyses and run them, etc.
+```
+

mindbridge_api_python_client-1.4.8.dist-info/RECORD

@@ -0,0 +1,43 @@
+mindbridgeapi/__init__.py,sha256=8G4ZvHpaG2IZvzzbqPSYFjr1mKI2qorCDAfrC9ERh90,2804
+mindbridgeapi/accounting_period.py,sha256=Wpg8ICAL6P_A6jdsfEXoozR77T3f4R4k05aXrZi1GS0,1186
+mindbridgeapi/analyses.py,sha256=NqQ78Rz9c-RKXonYrvOYM8eowvxqPBbhulYyA2XhHUw,14053
+mindbridgeapi/analysis_item.py,sha256=Duj5oF6n46mY8K-tu2NqeSwEZRKaQjgV3SL9MxpCn9U,6081
+mindbridgeapi/analysis_period.py,sha256=SpmmOb0HvOLhaY3ZYeIaws3JUvQQb0fCfGeXOfFRZEw,2219
+mindbridgeapi/analysis_source_item.py,sha256=MyED_MXyxrL7_i77ovlxwB2Jj2nGssR2soYmb_A3UE8,7427
+mindbridgeapi/analysis_source_type_item.py,sha256=kUDsneQ_CTY5isv1LzseDYRGaj3BR8XDqEqLfnu7K9A,2885
+mindbridgeapi/analysis_source_types.py,sha256=WHZpoO9inmrz571rJf4CjFqDESewxD5EFhMEHHi1Q6A,1214
+mindbridgeapi/analysis_sources.py,sha256=bjNpsMRnQzCVhQ8wAqTTcJ1IJrB9hHVW71Va4KhI1es,4783
+mindbridgeapi/analysis_type_item.py,sha256=fJkqSdppcHfCODAEXXgwlMHJ4OKex7gzNGH9rAgfzdE,1770
+mindbridgeapi/analysis_types.py,sha256=OpiQQavoO1zcWCJirRvTX4LCoBACnjCOOZXn1j-Q8yI,2178
+mindbridgeapi/async_results.py,sha256=T-n5gAlL7IOJeui4e5yHhCPU9eTnraaqLSySiMkLEMY,6575
+mindbridgeapi/base_set.py,sha256=okBFRJ67JOydHarKL_5dgHS4-9twwttmZqmYf6sqlLk,5973
+mindbridgeapi/chunked_file_item.py,sha256=dGUco2qjl0xmbJ59AYXPm4T1n6psoLBjsCOVQgXcsgk,1208
+mindbridgeapi/chunked_file_part_item.py,sha256=-iWXTCIR0cLX9mZWJC-eqmUckhg_PhGEGuZWXzXdhEM,852
+mindbridgeapi/chunked_files.py,sha256=7B61HihsX1ODmpkQGSTBzL6yQc1J8jwWEZXGUzhkwAA,2303
+mindbridgeapi/column_mapping.py,sha256=A76_7gQEvdTN_RihuoXKqI6eKEVG2t3kceEAXZO_yUg,739
+mindbridgeapi/common_validators.py,sha256=EVnpt7-PVmqCldaPMBjSD1Zmu_QVfF2l5Lt3pMPqLjI,2273
+mindbridgeapi/data_tables.py,sha256=jnSs2zqCdWdjY4gQFNkIruvoFEdqDitLreoa4rexlhA,7323
+mindbridgeapi/engagement_item.py,sha256=uBC8zP3qIZjxT0_xBSPVXosOFwcypFJ6P6KDymD1QgA,3646
+mindbridgeapi/engagements.py,sha256=Y2rn_sCFUAaOeB-VnZH97I0qrriIk4r0z4xBDYU5-o4,3347
+mindbridgeapi/enumerations/analysis_source_type.py,sha256=eqFg2OOpt_qInwboW81avmnJSTtzjrZwS2einKO4eQ0,5019
+mindbridgeapi/enumerations/analysis_type.py,sha256=kEZINjyqqwsXyXcm_NCLBcQc_VIEc_fXqpwVuPIkKvI,1218
+mindbridgeapi/enumerations/deprecated_enum.py,sha256=703qNP-MgdJS1zJtRTGuFwpYZCiViLhw5ilFWI8-Cf8,2199
+mindbridgeapi/enumerations/system_library.py,sha256=Q9xaZEXA6uArwuyMhO5gclcF1vUtuDun40NjVXC6IGE,1066
+mindbridgeapi/exceptions.py,sha256=_eSZaajT4ssuTTg57clv24ARZyswqqMAA3lxIiP6P18,2937
+mindbridgeapi/file_manager.py,sha256=5Z3_BcMq1ObaKZiOjNUxsZAzqq20Kx9HG32lEozTSqw,7249
+mindbridgeapi/file_manager_item.py,sha256=5Z_n4ijgqfM-Psj3snDQZWe9jLlJLLiYHvyJ5xwmkz8,3640
+mindbridgeapi/generated_pydantic_model/model.py,sha256=dZhsYcD4smFAiQsmYOKe6Ak8uzbahwUa0UcmXxgALkA,210089
+mindbridgeapi/libraries.py,sha256=16Ldvf3AxgvR3n5Gn8a2AkeFYIfEiEAZ767o7aeUxrk,1879
+mindbridgeapi/library_item.py,sha256=ykbJRxdQmIwAWxpfFHOPMZz1_FHRpnErQnYLCMc8aPg,1629
+mindbridgeapi/organization_item.py,sha256=9X6jVeWAoKIXpBnEQ-bkwdjY-ZwN9B_RH4IKHh0Kdps,2032
+mindbridgeapi/organizations.py,sha256=EornYxX2dF-QAJtNuAKIYIVicgoEkoLllT_dgBFm2AE,2810
+mindbridgeapi/server.py,sha256=ty1L9yiVuwK3Q1sJOsKdYgBuzvWQZ2GrXrgcRouXhBA,7586
+mindbridgeapi/task_item.py,sha256=T_kCYPt1Neu4jIF_xWS4C0ICncXPgC2Na_qOEfKMPZU,1502
+mindbridgeapi/tasks.py,sha256=4BpzsVOI_Hd6B3WAGVlb9qGrXF93aMKMCTK_iCPPe6A,5096
+mindbridgeapi/transaction_id_selection.py,sha256=gR53cQYegS80WyK1Ao1IEFm0r1DRChnzgzBNFtWPjns,1178
+mindbridgeapi/users.py,sha256=UVzMmEWXxdtRmbNnah8y9Lgg1Dbt4ZJ9R0KkQTZ7v0M,1314
+mindbridgeapi/virtual_column.py,sha256=0Ke0VLO2uKRXoiUQC9PhNaHSz3QTVla4gU_y1hupJmk,3802
+mindbridge_api_python_client-1.4.8.dist-info/LICENSE.txt,sha256=mplBHRn1FrWL_Ef6JvSXBssVPDfPUm57qAP0FeeenTQ,565
+mindbridge_api_python_client-1.4.8.dist-info/METADATA,sha256=ofrLn8ppEVqwAmLLifgvE15LnCgykwQx3DVLnxwi1H4,2498
+mindbridge_api_python_client-1.4.8.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+mindbridge_api_python_client-1.4.8.dist-info/RECORD,,

mindbridge_api_python_client-1.4.8.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.0
+Root-Is-Purelib: true
+Tag: py3-none-any

mindbridgeapi/__init__.py

@@ -0,0 +1,69 @@
+#
+#  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 mindbridgeapi.accounting_period import AccountingPeriod
+from mindbridgeapi.analysis_item import AnalysisItem
+from mindbridgeapi.analysis_period import AnalysisPeriod
+from mindbridgeapi.analysis_source_item import AnalysisSourceItem
+from mindbridgeapi.analysis_source_type_item import AnalysisSourceTypeItem
+from mindbridgeapi.analysis_type_item import AnalysisTypeItem
+from mindbridgeapi.chunked_file_item import ChunkedFileItem
+from mindbridgeapi.chunked_file_part_item import ChunkedFilePartItem
+from mindbridgeapi.column_mapping import ColumnMapping
+from mindbridgeapi.engagement_item import EngagementItem
+from mindbridgeapi.enumerations.analysis_source_type import AnalysisSourceType
+from mindbridgeapi.enumerations.analysis_type import AnalysisType
+from mindbridgeapi.enumerations.system_library import SystemLibrary
+from mindbridgeapi.file_manager_item import FileManagerItem
+from mindbridgeapi.generated_pydantic_model.model import (
+    PeriodType as AnalysisEffectiveDateMetricsPeriod,
+)
+from mindbridgeapi.generated_pydantic_model.model import Frequency
+from mindbridgeapi.generated_pydantic_model.model import Status4 as TaskStatus
+from mindbridgeapi.generated_pydantic_model.model import TargetWorkflowState
+from mindbridgeapi.generated_pydantic_model.model import Type5 as FileManagerType
+from mindbridgeapi.generated_pydantic_model.model import Type11 as TaskType
+from mindbridgeapi.generated_pydantic_model.model import Type13 as TransactionIdType
+from mindbridgeapi.generated_pydantic_model.model import Type17 as VirtualColumnType
+from mindbridgeapi.library_item import LibraryItem
+from mindbridgeapi.organization_item import OrganizationItem
+from mindbridgeapi.server import Server
+from mindbridgeapi.task_item import TaskItem
+from mindbridgeapi.transaction_id_selection import TransactionIdSelection
+from mindbridgeapi.virtual_column import VirtualColumn
+
+__all__ = [
+    "AccountingPeriod",
+    "AnalysisItem",
+    "AnalysisPeriod",
+    "AnalysisSourceItem",
+    "AnalysisSourceTypeItem",
+    "AnalysisTypeItem",
+    "ChunkedFileItem",
+    "ChunkedFilePartItem",
+    "ColumnMapping",
+    "EngagementItem",
+    "AnalysisSourceType",
+    "AnalysisType",
+    "SystemLibrary",
+    "FileManagerItem",
+    "AnalysisEffectiveDateMetricsPeriod",
+    "Frequency",
+    "TaskStatus",
+    "TargetWorkflowState",
+    "FileManagerType",
+    "TaskType",
+    "TransactionIdType",
+    "VirtualColumnType",
+    "LibraryItem",
+    "OrganizationItem",
+    "Server",
+    "TaskItem",
+    "TransactionIdSelection",
+    "VirtualColumn",
+]

mindbridgeapi/accounting_period.py

@@ -0,0 +1,34 @@
+#
+#  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 pydantic import ConfigDict, Field, model_validator
+from mindbridgeapi.common_validators import _warning_if_extra_fields
+from mindbridgeapi.generated_pydantic_model.model import (
+    ApiAccountingPeriodRead,
+    Frequency,
+)
+
+
+class AccountingPeriod(ApiAccountingPeriodRead):
+    fiscal_start_month: int = Field().merge_field_infos(
+        ApiAccountingPeriodRead.model_fields["fiscal_start_month"], default=1
+    )
+    fiscal_start_day: int = Field().merge_field_infos(
+        ApiAccountingPeriodRead.model_fields["fiscal_start_day"], default=1
+    )
+    frequency: Frequency = Field().merge_field_infos(
+        ApiAccountingPeriodRead.model_fields["frequency"], default=Frequency.ANNUAL
+    )
+
+    model_config = ConfigDict(
+        extra="allow",
+        validate_assignment=True,
+        validate_default=True,
+        validate_return=True,
+    )
+    _ = model_validator(mode="after")(_warning_if_extra_fields)

mindbridgeapi/analyses.py

@@ -0,0 +1,383 @@
+#
+#  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 datetime import date
+from functools import cached_property
+import logging
+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.base_set import BaseSet
+from mindbridgeapi.data_tables import DataTables
+from mindbridgeapi.exceptions import (
+    ItemAlreadyExistsError,
+    ItemError,
+    ItemNotFoundError,
+    ParameterError,
+    UnexpectedServerError,
+    ValidationError,
+)
+from mindbridgeapi.generated_pydantic_model.model import (
+    ApiAnalysisStatusRead,
+    ApiAsyncResult,
+    ApiEngagementRollForwardRequest,
+    EntityType,
+)
+from mindbridgeapi.generated_pydantic_model.model import Type1 as AsyncResultType
+from mindbridgeapi.tasks import Tasks
+
+if TYPE_CHECKING:
+    from mindbridgeapi.engagement_item import EngagementItem
+
+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"
+
+    def create(self, item: AnalysisItem) -> AnalysisItem:
+        if getattr(item, "id", None) is not None and item.id is not None:
+            raise ItemAlreadyExistsError(item.id)
+
+        url = self.base_url
+        resp_dict = super()._create(url=url, json=item.create_json)
+        analysis = AnalysisItem.model_validate(resp_dict)
+        self.restart_analysis_sources(analysis)
+        self.restart_data_tables(analysis)
+        self.restart_tasks(analysis)
+
+        return analysis
+
+    def update(self, item: AnalysisItem) -> AnalysisItem:
+        if getattr(item, "id", None) is None:
+            raise ItemNotFoundError
+
+        url = f"{self.base_url}/{item.id}"
+        resp_dict = super()._update(url=url, json=item.update_json)
+
+        analysis = AnalysisItem.model_validate(resp_dict)
+        self.restart_analysis_sources(analysis)
+        self.restart_data_tables(analysis)
+        self.restart_tasks(analysis)
+
+        return analysis
+
+    def get(
+        self, json: Optional[Dict[str, Any]] = None
+    ) -> Generator[AnalysisItem, None, None]:
+        if json is None:
+            json = {}
+
+        url = f"{self.base_url}/query"
+        for resp_dict in super()._get(url=url, json=json):
+            analysis = AnalysisItem.model_validate(resp_dict)
+            self.restart_analysis_sources(analysis)
+            self.restart_data_tables(analysis)
+            self.restart_tasks(analysis)
+
+            yield analysis
+
+    def delete(self, item: AnalysisItem) -> None:
+        if getattr(item, "id", None) is None:
+            raise ItemNotFoundError
+
+        url = f"{self.base_url}/{item.id}"
+        super()._delete(url=url)
+
+    def start(self, item: AnalysisItem) -> AnalysisItem:
+        warnings.warn(
+            "Use the run function instead", category=DeprecationWarning, stacklevel=2
+        )
+        return self.run(item)
+
+    def run(self, item: AnalysisItem) -> AnalysisItem:
+        analysis_id = getattr(item, "id", None)
+        if analysis_id is None:
+            raise ItemNotFoundError
+
+        url = f"{self.base_url}/{analysis_id}/run"
+        resp_dict = super()._create(url=url)
+        async_result = ApiAsyncResult.model_validate(resp_dict)
+
+        if async_result.type != AsyncResultType.ANALYSIS_RUN:
+            raise ItemError(f"Async Result Type was {async_result.type}.")
+
+        if async_result.entity_id != analysis_id:
+            raise UnexpectedServerError(
+                details="async_result.entity_id was not the same as the item id"
+            )
+
+        return self.get_by_id(analysis_id)
+
+    def wait_for_analysis_sources(
+        self,
+        analysis: AnalysisItem,
+        check_interval_seconds: int = -873,  # Depreciated
+        max_wait_minutes: int = 24 * 60,
+    ) -> AnalysisItem:
+        if check_interval_seconds != -873:
+            warnings.warn(
+                "check_interval_seconds was provided to wait_for_analysis_sources as "
+                f"{check_interval_seconds}. This will not be referenced as now the "
+                "check interval will be exponentially increasing to a max interval",
+                category=DeprecationWarning,
+                stacklevel=2,
+            )
+
+        del check_interval_seconds
+
+        analysis_id = getattr(analysis, "id", None)
+        if analysis_id is None:
+            raise ItemNotFoundError
+
+        analysis = self.get_by_id(analysis_id)
+
+        if getattr(analysis, "id", None) != analysis_id:
+            raise UnexpectedServerError(  # noqa: TRY003
+                "analysis id was not the same as requested."
+            )
+
+        # 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(
+                json={
+                    "$and": [
+                        {"entityId": {"$eq": analysis_source.id}},
+                        {"type": {"$eq": AsyncResultType.ANALYSIS_SOURCE_INGESTION}},
+                        {"entityType": {"$eq": EntityType.ANALYSIS_SOURCE}},
+                    ]
+                }
+            )
+            async_results_list = list(async_results)
+            if len(async_results_list) == 0:
+                """
+                This shouldn't occur as analysis sources are started as soon as they are
+                added to the analysis
+                """
+                raise UnexpectedServerError(
+                    f"Unable to find {EntityType.ANALYSIS_SOURCE} status for:"
+                    f" {analysis_source.id}."
+                )
+
+            async_result = max(
+                async_results_list,
+                key=lambda x: getattr(x, "last_modified_date", date.min),
+            )
+            async_results_to_check.append(async_result)
+
+        if len(async_results_to_check) == 0:
+            """
+            There will be one item in this list for every analysis_source otherwise an
+            error would have been raised in the loop above.
+            """
+            raise ItemError("Analysis has no analysis sources.")  # noqa: TRY003
+
+        self.async_result_set._wait_for_async_results(
+            async_results=async_results_to_check,
+            max_wait_minutes=max_wait_minutes,
+            init_interval_sec=11,
+        )
+
+        analysis_status = self.status(analysis)
+        analysis_status_ready = getattr(analysis_status, "ready", False)
+        analysis_status_preflight_errors = getattr(
+            analysis_status, "preflight_errors", []
+        )
+        if analysis_status_ready:
+            logger.info(f"Analysis ({analysis_id}) is ready to run")
+        else:
+            err_msg = f"Analysis ({analysis_id}) is not ready to run"
+            if len(analysis_status_preflight_errors) == 0:
+                err_msg = f"{err_msg} (no preflight_errors)"
+            else:
+                preflight_errors_str = ", ".join(
+                    [str(i.name) for i in analysis_status_preflight_errors]
+                )
+                err_msg = f"{err_msg}. Preflight Errors: {preflight_errors_str}"
+
+            raise ValidationError(err_msg)
+
+        return self.get_by_id(analysis_id)
+
+    def status(self, item: AnalysisItem) -> ApiAnalysisStatusRead:
+        if getattr(item, "id", None) is None:
+            raise ItemNotFoundError
+
+        url = f"{self.base_url}/{item.id}/status"
+        resp_dict = super()._get_by_id(url=url)
+        analysis_status = ApiAnalysisStatusRead.model_validate(resp_dict)
+
+        self._status_log_message(item, analysis_status)
+
+        return analysis_status
+
+    @staticmethod
+    def _status_log_message(
+        analysis: AnalysisItem, analysis_status_item: ApiAnalysisStatusRead
+    ) -> None:
+        log_message = f"Analysis Status for {analysis.name} ({analysis.id}):"
+        log_message += f"\n    ready: {analysis_status_item.ready}"
+        log_message += f"\n    status: {analysis_status_item.status}"
+        log_message += (
+            "\n    unmapped_account_mapping_count:"
+            f" {analysis_status_item.unmapped_account_mapping_count}"
+        )
+        log_message += (
+            "\n    mapped_account_mapping_count:"
+            f" {analysis_status_item.mapped_account_mapping_count}"
+        )
+        log_message += (
+            "\n    inferred_account_mapping_count:"
+            f" {analysis_status_item.inferred_account_mapping_count}"
+        )
+        log_message += "\n    preflight_errors:"
+        for pfe in getattr(analysis_status_item, "preflight_errors", []):
+            log_message += f"\n    - {pfe}"
+
+        log_message += "\n    source_statuses:"
+        for source_status in getattr(analysis_status_item, "source_statuses", []):
+            log_message += f"\n    - source_id: {source_status.source_id}"
+            log_message += f"\n    - status: {source_status.status}"
+            log_message += (
+                "\n    - analysis_source_type_id:"
+                f" {source_status.analysis_source_type_id}"
+            )
+            log_message += f"\n    - period_id: {source_status.period_id}"
+            log_message += "\n"
+
+        logger.info(log_message)
+
+    def wait_for_analysis(
+        self,
+        analysis: AnalysisItem,
+        check_interval_seconds: int = -873,  # Depreciated
+        max_wait_minutes: int = 24 * 60,
+    ) -> AnalysisItem:
+        if check_interval_seconds != -873:
+            warnings.warn(
+                "check_interval_seconds was provided to wait_for_analysis as "
+                f"{check_interval_seconds}. This will not be referenced as now the "
+                "check interval will be exponentially increasing to a max interval",
+                category=DeprecationWarning,
+                stacklevel=2,
+            )
+
+        del check_interval_seconds
+
+        analysis_id = getattr(analysis, "id", None)
+        if analysis_id is None:
+            raise ItemNotFoundError
+
+        async_results = self.async_result_set.get(
+            json={
+                "$and": [
+                    {"entityId": {"$eq": analysis_id}},
+                    {"type": {"$eq": AsyncResultType.ANALYSIS_RUN}},
+                    {"entityType": {"$eq": EntityType.ANALYSIS}},
+                ]
+            }
+        )
+        async_results_list = list(async_results)
+        if len(async_results_list) == 0:
+            raise ValidationError(
+                f"Unable to find {EntityType.ANALYSIS} run status for: {analysis_id}."
+                " Possibly the analysis has not been started yet?"
+            )
+
+        async_result = max(
+            async_results_list, key=lambda x: getattr(x, "last_modified_date", date.min)
+        )
+
+        self.async_result_set._wait_for_async_result(
+            async_result=async_result,
+            max_wait_minutes=max_wait_minutes,
+            init_interval_sec=76,
+        )
+
+        return self.get_by_id(analysis_id)
+
+    def roll_forward_analysis_to_engagement(
+        self,
+        analysis_item: AnalysisItem,
+        engagement_item: "EngagementItem",
+        interim: bool = False,
+    ) -> AnalysisItem:
+        url = f"{self.base_url}/engagement-roll-forward"
+
+        if analysis_item.id is None or analysis_item.engagement_id is None:
+            raise ItemNotFoundError
+
+        if engagement_item.id is None:
+            raise ItemNotFoundError
+
+        if analysis_item.engagement_id == engagement_item.id:
+            raise ParameterError(
+                parameter_name="engagement_id",
+                details=(
+                    "The target engagement cannot be the same engagement in which the "
+                    "analysis exists."
+                ),
+            )
+
+        roll_forward_request = ApiEngagementRollForwardRequest(
+            analysis_id=analysis_item.id,
+            interim=interim,
+            target_engagement_id=engagement_item.id,
+        )
+        roll_forward_request_json = roll_forward_request.model_dump(
+            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)
+        if async_result.entity_id is None:
+            raise UnexpectedServerError(details="async_result.entity_id was None")
+
+        return self.get_by_id(async_result.entity_id)
+
+    def get_by_id(self, id: str) -> AnalysisItem:
+        url = f"{self.base_url}/{id}"
+        resp_dict = super()._get_by_id(url=url)
+        analysis = AnalysisItem.model_validate(resp_dict)
+        self.restart_analysis_sources(analysis)
+        self.restart_data_tables(analysis)
+
+        return analysis
+
+    def restart_data_tables(self, analysis_item: AnalysisItem) -> None:
+        if getattr(analysis_item, "id", None) is None:
+            raise ItemNotFoundError
+
+        analysis_item.data_tables = DataTables(server=self.server).get(
+            json={"analysisId": {"$eq": analysis_item.id}}
+        )
+
+    def restart_analysis_sources(self, analysis_item: AnalysisItem) -> None:
+        if getattr(analysis_item, "id", None) is None:
+            raise ItemNotFoundError
+
+        analysis_item.analysis_sources = AnalysisSources(server=self.server).get(
+            json={"analysisId": {"$eq": analysis_item.id}}
+        )
+
+    def restart_tasks(self, analysis_item: AnalysisItem) -> None:
+        if getattr(analysis_item, "id", None) is None:
+            raise ItemNotFoundError
+
+        analysis_item.tasks = Tasks(server=self.server).get(
+            json={"analysisId": {"$eq": analysis_item.id}}
+        )