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

mindbridgeapi/common_validators.py

@@ -0,0 +1,71 @@
+#
+#  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 typing import Any
+import warnings
+from mindbridgeapi.generated_pydantic_model.model import ApiUserInfo, ApiUserInfoRead
+from mindbridgeapi.generated_pydantic_model.model import ApiUserRead as UserItem
+from mindbridgeapi.generated_pydantic_model.model import Role
+
+logger = logging.getLogger(__name__)
+
+
+def _warning_if_extra_fields(self: Any) -> Any:
+    """Emits a warning if the model had any extra fields
+
+    This is used to create a warning if and only if the model had any extra fields, but
+    still allow the model to be used. For example:
+    ```py
+    x = mbapi.AccountingPeriod(badkey="ksodhjksdl")
+    AccountingPeriod had extra fields, specifically:
+                  badkey: ksodhjksdl
+    ```
+
+    Returns:
+        Any: The original object
+    """
+    if self.model_extra is None or len(self.model_extra) == 0:
+        return self
+
+    log_lines = [f"{type(self).__name__} had extra fields, specifically:"]
+    for key, value in self.model_extra.items():
+        log_lines.append(f"{key.rjust(20)}: {value}")
+
+    warn_message = "\n".join(log_lines)
+    warnings.warn(warn_message, stacklevel=2)
+
+    return self
+
+
+def _convert_userinfo_to_useritem(v: Any) -> Any:
+    """Converts from UserInfo to UserItem
+
+    If it's a ApiUserInfo or ApiUserInfoRead it changes to UserItem, with just the
+    relevant fields set. It also does some extra conversion if it seems to be an API
+    user.
+
+    Args:
+        v (Any): The original data
+
+    Returns:
+        Any: UserItem if possible, the original data otherwise
+    """
+
+    if not isinstance(v, (ApiUserInfo, ApiUserInfoRead)):
+        return v
+
+    prefix = "(API) "
+    if v.user_name is None or not v.user_name.startswith(prefix):
+        return UserItem(id=v.user_id, first_name=v.user_name)  # type: ignore[call-arg]
+
+    prefix_len = len(prefix)
+    first_name = v.user_name[prefix_len:]
+    return UserItem(  # type: ignore[call-arg]
+        id=v.user_id, first_name=first_name, last_name="", role=Role.ROLE_ADMIN
+    )

mindbridgeapi/data_tables.py

@@ -0,0 +1,206 @@
+#
+#  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 TYPE_CHECKING, Any, Dict, Generator, List, Optional
+import warnings
+from mindbridgeapi.async_results import AsyncResults
+from mindbridgeapi.base_set import BaseSet
+from mindbridgeapi.exceptions import ItemError, ItemNotFoundError, ParameterError
+from mindbridgeapi.generated_pydantic_model.model import (
+    ApiAsyncResult,
+    ApiDataTableExportRequest,
+    ApiDataTableQuerySortOrder,
+    ApiDataTableRead,
+    Direction,
+    MindBridgeQueryTerm,
+)
+from mindbridgeapi.generated_pydantic_model.model import Status2 as AsyncResultStatus
+from mindbridgeapi.generated_pydantic_model.model import Type1 as AsyncResultType
+from mindbridgeapi.generated_pydantic_model.model import Type4 as DataTableColumnType
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class DataTables(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}/data-tables"
+
+    def get_by_id(self, id: str) -> ApiDataTableRead:
+        url = f"{self.base_url}/{id}"
+        resp_dict = super()._get_by_id(url=url)
+
+        return ApiDataTableRead.model_validate(resp_dict)
+
+    def get(
+        self, json: Optional[Dict[str, Any]] = None
+    ) -> Generator[ApiDataTableRead, None, None]:
+        logger.info("Starting Query (get)")
+
+        if json is None:
+            json = {}
+
+        json_str = MindBridgeQueryTerm.model_construct(root=json).model_dump_json()
+        logger.info(f"Query (get) is: {json_str}")
+
+        if "analysisId" not in json_str:
+            raise ValueError(  # noqa:TRY003
+                "At least one valid analysisId 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 ApiDataTableRead.model_validate(resp_dict)
+
+    def export(
+        self,
+        input_item: ApiDataTableRead,
+        fields: Optional[List[str]] = None,
+        query: Optional[Dict[str, Any]] = None,
+        limit: Optional[int] = None,
+        sort_direction: Optional[Direction] = None,
+        sort_field: Optional[str] = None,
+    ) -> ApiAsyncResult:
+        if getattr(input_item, "id", None) is None:
+            raise ItemNotFoundError
+
+        if input_item.columns is None:
+            raise ItemError(f"{input_item.columns=}")
+
+        if fields is None:
+            fields = []
+
+        if len(fields) == 0:
+            """
+            "KEYWORD_SEARCH columns can't be included in data table exports. Attempting
+                to select them as part of fields will cause the export request to
+                fail.". Similarly fields that are filter only can't be included as
+                fields.
+            """
+            fields = [
+                x.field
+                for x in input_item.columns
+                if x.type != DataTableColumnType.KEYWORD_SEARCH
+                and x.field is not None
+                and not x.filter_only
+            ]
+
+        if query is None:
+            query = {}
+
+        if sort_direction is None:
+            sort_direction = Direction.ASC
+
+        if not isinstance(sort_direction, Direction):
+            try:
+                sort_direction = Direction(sort_direction)
+            except ValueError as err:
+                raise ParameterError(
+                    parameter_name="sort_direction",
+                    details="Not a valid Direction",
+                ) from err
+
+        if sort_field is not None and not isinstance(sort_field, str):
+            raise ParameterError(
+                parameter_name="sort_field", details="Not provided as str"
+            )
+
+        if sort_field is None and input_item.type == "flows_compact":
+            sort_field = "flow_id"
+        elif sort_field is None and input_item.logical_name == "gl_journal_lines":
+            sort_field = "rowid"
+        elif sort_field is None and input_item.logical_name == "gl_journal_tx":
+            sort_field = "txid"
+        elif sort_field is None or sort_field == "":
+            # Don't send a sort
+            sort_field = None
+            sort_direction = None
+
+        url = f"{self.base_url}/{input_item.id}/export"
+        data_table_export_request = ApiDataTableExportRequest(  # type: ignore[call-arg]
+            fields=fields,
+            query=MindBridgeQueryTerm.model_construct(root=query),
+            limit=limit,
+            sort=ApiDataTableQuerySortOrder(direction=sort_direction, field=sort_field),
+        )
+
+        json = data_table_export_request.model_dump(
+            mode="json", by_alias=True, exclude_none=True
+        )
+
+        resp_dict = super()._create(url=url, json=json)
+
+        return ApiAsyncResult.model_validate(resp_dict)
+
+    def wait_for_export(
+        self,
+        async_result: ApiAsyncResult,
+        check_interval_seconds: int = -873,  # Depreciated
+        max_wait_minutes: int = (24 * 60),
+    ) -> None:
+        """Wait for the async result for the data table export to complete
+
+        Waits, at most the minutes specified, for the async result to be COMPLETE and
+        raises and error if any error
+
+        Args:
+            async_result (AsyncResultItem): Async result to check
+            max_wait_minutes (int): Maximum minutes to wait (default: `24 * 60`)
+
+        Raises:
+            ValueError: If not a DATA_TABLE_EXPORT
+        """
+        if check_interval_seconds != -873:
+            warnings.warn(
+                "check_interval_seconds was provided to wait_for_export 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
+
+        if async_result.type != AsyncResultType.DATA_TABLE_EXPORT:
+            raise ItemError(f"{async_result.type=}")
+
+        self.async_result_set._wait_for_async_result(
+            async_result=async_result,
+            max_wait_minutes=max_wait_minutes,
+            init_interval_sec=10,
+        )
+
+    def download(
+        self, async_result: ApiAsyncResult, 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)
+
+        url = f"{self.server.base_url}/file-results/{async_result.entity_id}/export"
+
+        if async_result.type != AsyncResultType.DATA_TABLE_EXPORT:
+            raise ItemError(f"{async_result.type=}")
+
+        if async_result.status != AsyncResultStatus.COMPLETE:
+            raise ItemError(f"{async_result.status=}")
+
+        return super()._download(url=url, output_path=output_file_path)

mindbridgeapi/engagement_item.py

@@ -0,0 +1,100 @@
+#
+#  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 datetime import date
+from typing import Any, Dict, Generator, Optional, Type, Union
+from pydantic import ConfigDict, Field, field_validator, model_validator
+from pydantic_core import PydanticUndefined
+from mindbridgeapi.accounting_period import AccountingPeriod
+from mindbridgeapi.analysis_item import AnalysisItem
+from mindbridgeapi.common_validators import (
+    _convert_userinfo_to_useritem,
+    _warning_if_extra_fields,
+)
+from mindbridgeapi.file_manager_item import FileManagerItem
+from mindbridgeapi.generated_pydantic_model.model import (
+    ApiEngagementCreateOnly,
+    ApiEngagementRead,
+    ApiEngagementUpdate,
+)
+from mindbridgeapi.library_item import LibraryItem
+
+
+def _empty_analyses() -> Generator[AnalysisItem, None, None]:
+    """Empty generator function
+
+    This returns an empty generator function, it's use is to ensure analyses is not None
+    for the EngagementItem class
+    """
+    yield from ()
+
+
+def _empty_file_manager_items() -> Generator[FileManagerItem, None, None]:
+    """Empty generator function
+
+    This returns an empty generator function, it's use is to ensure file_manager_items
+    is not None for the EngagementItem class
+    """
+    yield from ()
+
+
+class EngagementItem(ApiEngagementRead):
+    file_manager_items: Generator[FileManagerItem, None, None] = Field(
+        default_factory=_empty_file_manager_items, exclude=True
+    )
+    analyses: Generator[AnalysisItem, None, None] = Field(
+        default_factory=_empty_analyses, exclude=True
+    )
+    settings_based_on_engagement_id: Optional[str] = Field().merge_field_infos(
+        ApiEngagementCreateOnly.model_fields["settings_based_on_engagement_id"]
+    )
+    accounting_package: str = Field().merge_field_infos(
+        ApiEngagementRead.model_fields["accounting_package"], default="Other"
+    )
+    accounting_period: AccountingPeriod = Field().merge_field_infos(
+        ApiEngagementRead.model_fields["accounting_period"],
+        default=PydanticUndefined,
+        default_factory=lambda: AccountingPeriod(),
+    )
+    audit_period_end_date: date = Field().merge_field_infos(
+        ApiEngagementRead.model_fields["audit_period_end_date"],
+        default=date(date.today().year, 12, 31),
+    )
+    industry: str = Field().merge_field_infos(
+        ApiEngagementRead.model_fields["industry"], default="Other"
+    )
+    library_id: str = Field().merge_field_infos(
+        ApiEngagementRead.model_fields["library_id"],
+        default=LibraryItem.MINDBRIDGE_FOR_PROFIT,
+    )
+
+    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 _get_post_json(
+        self, out_class: Type[Union[ApiEngagementCreateOnly, ApiEngagementUpdate]]
+    ) -> Dict[str, Any]:
+        in_class_dict = self.model_dump()
+        out_class_object = out_class.model_validate(in_class_dict)
+        return out_class_object.model_dump(
+            mode="json", by_alias=True, exclude_none=True
+        )
+
+    @property
+    def create_json(self) -> Dict[str, Any]:
+        return self._get_post_json(out_class=ApiEngagementCreateOnly)
+
+    @property
+    def update_json(self) -> Dict[str, Any]:
+        return self._get_post_json(out_class=ApiEngagementUpdate)

mindbridgeapi/engagements.py

@@ -0,0 +1,93 @@
+#
+#  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
+from typing import Any, Dict, Generator, Optional
+from mindbridgeapi.analyses import Analyses
+from mindbridgeapi.base_set import BaseSet
+from mindbridgeapi.engagement_item import EngagementItem
+from mindbridgeapi.exceptions import ItemAlreadyExistsError, ItemNotFoundError
+from mindbridgeapi.file_manager import FileManager
+
+
+@dataclass
+class Engagements(BaseSet):
+    @cached_property
+    def base_url(self) -> str:
+        return f"{self.server.base_url}/engagements"
+
+    def create(self, item: EngagementItem) -> EngagementItem:
+        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)
+        engagement = EngagementItem.model_validate(resp_dict)
+        self.restart_file_manager_items(engagement)
+        self.restart_analyses(engagement)
+
+        return engagement
+
+    def get_by_id(self, id: str) -> EngagementItem:
+        url = f"{self.base_url}/{id}"
+        resp_dict = super()._get_by_id(url=url)
+        engagement = EngagementItem.model_validate(resp_dict)
+        self.restart_file_manager_items(engagement)
+        self.restart_analyses(engagement)
+
+        return engagement
+
+    def update(self, item: EngagementItem) -> EngagementItem:
+        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)
+
+        engagement = EngagementItem.model_validate(resp_dict)
+        self.restart_file_manager_items(engagement)
+        self.restart_analyses(engagement)
+
+        return engagement
+
+    def get(
+        self, json: Optional[Dict[str, Any]] = None
+    ) -> Generator[EngagementItem, None, None]:
+        if json is None:
+            json = {}
+
+        url = f"{self.base_url}/query"
+        for resp_dict in super()._get(url=url, json=json):
+            engagement = EngagementItem.model_validate(resp_dict)
+            self.restart_file_manager_items(engagement)
+            self.restart_analyses(engagement)
+            yield engagement
+
+    def restart_file_manager_items(self, engagement_item: EngagementItem) -> None:
+        if getattr(engagement_item, "id", None) is None:
+            raise ItemNotFoundError
+
+        engagement_item.file_manager_items = FileManager(server=self.server).get(
+            json={"engagementId": {"$eq": engagement_item.id}}
+        )
+
+    def restart_analyses(self, engagement_item: EngagementItem) -> None:
+        if getattr(engagement_item, "id", None) is None:
+            raise ItemNotFoundError
+
+        engagement_item.analyses = Analyses(server=self.server).get(
+            json={"engagementId": {"$eq": engagement_item.id}}
+        )
+
+    def delete(self, item: EngagementItem) -> None:
+        if getattr(item, "id", None) is None:
+            raise ItemNotFoundError
+
+        url = f"{self.base_url}/{item.id}"
+        super()._delete(url=url)

mindbridgeapi/enumerations/analysis_source_type.py

@@ -0,0 +1,142 @@
+#
+#  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 enum import unique
+from mindbridgeapi.enumerations.deprecated_enum import DeprecatedStrEnum
+
+
+@unique
+class AnalysisSourceType(DeprecatedStrEnum):
+    """This is Deprecated, use mbapi.AnalysisSourceTypeItem instead to get these IDs"""
+
+    # General Ledger (for-profit) - 4b8360d00000000000000000
+    GENERAL_LEDGER_JOURNAL = (
+        "4b8361d00000000000000000",
+        "Use mbapi.AnalysisSourceTypeItem.GENERAL_LEDGER_JOURNAL instead",
+    )
+    OPENING_BALANCE = (
+        "4b8361d00000000000000002",
+        "Use mbapi.AnalysisSourceTypeItem.OPENING_BALANCE instead",
+    )
+    CLOSING_BALANCE = (
+        "4b8361d00000000000000003",
+        "Use mbapi.AnalysisSourceTypeItem.CLOSING_BALANCE instead",
+    )
+    CHART_OF_ACCOUNTS = (
+        "4b8361d00000000000000004",
+        "Use mbapi.AnalysisSourceTypeItem.CHART_OF_ACCOUNTS instead",
+    )
+    ADJUSTING_ENTRIES = (
+        "4b8361d00000000000000016",
+        "Use mbapi.AnalysisSourceTypeItem.ADJUSTING_ENTRIES instead",
+    )
+    RECLASSIFICATION_ENTRIES = (
+        "4b8361d00000000000000017",
+        "Use mbapi.AnalysisSourceTypeItem.RECLASSIFICATION_ENTRIES instead",
+    )
+    ELIMINATION_ENTRIES = (
+        "4b8361d00000000000000018",
+        "Use mbapi.AnalysisSourceTypeItem.ELIMINATION_ENTRIES instead",
+    )
+
+    # General Ledger (not-for-profit) - 4b8360d00000000000000001
+    NOT_FOR_PROFIT_GENERAL_LEDGER_JOURNAL = (
+        "4b8361d00000000000000051",
+        "Use mbapi.AnalysisSourceTypeItem.NOT_FOR_PROFIT_GENERAL_LEDGER_JOURNAL "
+        "instead",
+    )
+    NOT_FOR_PROFIT_OPENING_BALANCE = (
+        "4b8361d00000000000000057",
+        "Use mbapi.AnalysisSourceTypeItem.NOT_FOR_PROFIT_OPENING_BALANCE instead",
+    )
+    NOT_FOR_PROFIT_CLOSING_BALANCE = (
+        "4b8361d00000000000000058",
+        "Use mbapi.AnalysisSourceTypeItem.NOT_FOR_PROFIT_CLOSING_BALANCE instead",
+    )
+
+    # General Ledger (not-for-profit with funds) - 4b8360d00000000000000002
+    GENERAL_LEDGER_JOURNAL_FUND = (
+        "4b8361d00000000000000001",
+        "Use mbapi.AnalysisSourceTypeItem.GENERAL_LEDGER_JOURNAL_FUND instead",
+    )
+    FUND_OPENING_BALANCE = (
+        "4b8361d00000000000000059",
+        "Use mbapi.AnalysisSourceTypeItem.FUND_OPENING_BALANCE instead",
+    )
+    FUND_CLOSING_BALANCE = (
+        "4b8361d0000000000000005a",
+        "Use mbapi.AnalysisSourceTypeItem.FUND_CLOSING_BALANCE instead",
+    )
+    FUND_CHART_OF_ACCOUNTS = (
+        "4b8361d00000000000000005",
+        "Use mbapi.AnalysisSourceTypeItem.FUND_CHART_OF_ACCOUNTS instead",
+    )
+
+    # Accounts Payable - 4b8360d00000000000000003
+    ACCOUNTS_PAYABLE_DETAIL = (
+        "4b8361d00000000000000006",
+        "Use mbapi.AnalysisSourceTypeItem.ACCOUNTS_PAYABLE_DETAIL instead",
+    )
+    CLOSING_PAYABLES_LIST = (
+        "4b8361d00000000000000010",
+        "Use mbapi.AnalysisSourceTypeItem.CLOSING_PAYABLES_LIST instead",
+    )
+    VENDOR_OPENING_BALANCES = (
+        "4b8361d00000000000000007",
+        "Use mbapi.AnalysisSourceTypeItem.VENDOR_OPENING_BALANCES instead",
+    )
+    VENDOR_LIST = (
+        "4b8361d00000000000000008",
+        "Use mbapi.AnalysisSourceTypeItem.VENDOR_LIST instead",
+    )
+    OPEN_PAYABLES_LIST = (
+        "4b8361d00000000000000009",
+        "Use mbapi.AnalysisSourceTypeItem.OPEN_PAYABLES_LIST instead",
+    )
+
+    # Accounts Receivable - 4b8360d00000000000000004
+    ACCOUNTS_RECEIVABLE_DETAIL = (
+        "4b8361d00000000000000011",
+        "Use mbapi.AnalysisSourceTypeItem.ACCOUNTS_RECEIVABLE_DETAIL instead",
+    )
+    CLOSING_RECEIVABLES_LIST = (
+        "4b8361d00000000000000014",
+        "Use mbapi.AnalysisSourceTypeItem.CLOSING_RECEIVABLES_LIST instead",
+    )
+    CUSTOMER_OPENING_BALANCES = (
+        "4b8361d00000000000000012",
+        "Use mbapi.AnalysisSourceTypeItem.CUSTOMER_OPENING_BALANCES instead",
+    )
+    CUSTOMER_LIST = (
+        "4b8361d00000000000000039",
+        "Use mbapi.AnalysisSourceTypeItem.CUSTOMER_LIST instead",
+    )
+    OPEN_RECEIVABLES_LIST = (
+        "4b8361d00000000000000013",
+        "Use mbapi.AnalysisSourceTypeItem.OPEN_RECEIVABLES_LIST instead",
+    )
+
+    # Additional Analysis Data
+    ADDITIONAL_ANALYSIS_DATA = (
+        "4b8361d00000000000000015",
+        "Use mbapi.AnalysisSourceTypeItem.ADDITIONAL_ANALYSIS_DATA instead",
+    )
+
+    # Other
+    FUND_ADJUSTING_ENTRIES = (
+        "4b8361d00000000000000019",
+        "Use mbapi.AnalysisSourceTypeItem.FUND_ADJUSTING_ENTRIES instead",
+    )
+    FUND_ELIMINATION_ENTRIES = (
+        "4b8361d00000000000000020",
+        "Use mbapi.AnalysisSourceTypeItem.FUND_ELIMINATION_ENTRIES instead",
+    )
+    FUND_RECLASSIFICATION_ENTRIES = (
+        "4b8361d00000000000000021",
+        "Use mbapi.AnalysisSourceTypeItem.FUND_RECLASSIFICATION_ENTRIES instead",
+    )

mindbridgeapi/enumerations/analysis_type.py

@@ -0,0 +1,36 @@
+#
+#  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 enum import unique
+from mindbridgeapi.enumerations.deprecated_enum import DeprecatedStrEnum
+
+
+@unique
+class AnalysisType(DeprecatedStrEnum):
+    """This is Deprecated, use mbapi.AnalysisTypeItem instead to get these IDs"""
+
+    GENERAL_LEDGER = (
+        "4b8360d00000000000000000",
+        "Use mbapi.AnalysisTypeItem.GENERAL_LEDGER instead",
+    )
+    NOT_FOR_PROFIT_GENERAL_LEDGER = (
+        "4b8360d00000000000000001",
+        "Use mbapi.AnalysisTypeItem.NOT_FOR_PROFIT_GENERAL_LEDGER instead",
+    )
+    NOT_FOR_PROFIT_GENERAL_LEDGER_FUND = (
+        "4b8360d00000000000000002",
+        "Use mbapi.AnalysisTypeItem.NOT_FOR_PROFIT_GENERAL_LEDGER_FUND instead",
+    )
+    ACCOUNTS_PAYABLE_V2 = (
+        "4b8360d00000000000000003",
+        "Use mbapi.AnalysisTypeItem.ACCOUNTS_PAYABLE_V2 instead",
+    )
+    ACCOUNTS_RECEIVABLE_V2 = (
+        "4b8360d00000000000000004",
+        "Use mbapi.AnalysisTypeItem.ACCOUNTS_RECEIVABLE_V2 instead",
+    )