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

mindbridgeapi/analysis_type_item.py

@@ -0,0 +1,45 @@
+#
+#  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 ClassVar, Generator
+from pydantic import ConfigDict, Field, field_validator, model_validator
+from mindbridgeapi.analysis_source_type_item import AnalysisSourceTypeItem
+from mindbridgeapi.common_validators import (
+    _convert_userinfo_to_useritem,
+    _warning_if_extra_fields,
+)
+from mindbridgeapi.generated_pydantic_model.model import ApiAnalysisTypeRead
+
+
+def _empty_analysis_source_types() -> Generator[AnalysisSourceTypeItem, None, None]:
+    """Empty generator function
+
+    This returns an empty generator function, it's use is to ensure
+    analysis_source_types is not None for the AnalysisTypeItem class
+    """
+    yield from ()
+
+
+class AnalysisTypeItem(ApiAnalysisTypeRead):
+    GENERAL_LEDGER: ClassVar[str] = "4b8360d00000000000000000"
+    NOT_FOR_PROFIT_GENERAL_LEDGER: ClassVar[str] = "4b8360d00000000000000001"
+    NOT_FOR_PROFIT_GENERAL_LEDGER_FUND: ClassVar[str] = "4b8360d00000000000000002"
+    ACCOUNTS_PAYABLE_V2: ClassVar[str] = "4b8360d00000000000000003"
+    ACCOUNTS_RECEIVABLE_V2: ClassVar[str] = "4b8360d00000000000000004"
+    analysis_source_types: Generator[AnalysisSourceTypeItem, None, None] = Field(
+        default_factory=_empty_analysis_source_types, 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)

mindbridgeapi/analysis_types.py

@@ -0,0 +1,62 @@
+#
+#  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.analysis_source_types import AnalysisSourceTypes
+from mindbridgeapi.analysis_type_item import AnalysisTypeItem
+from mindbridgeapi.base_set import BaseSet
+from mindbridgeapi.exceptions import ItemNotFoundError
+
+
+@dataclass
+class AnalysisTypes(BaseSet):
+    @cached_property
+    def base_url(self) -> str:
+        return f"{self.server.base_url}/analysis-types"
+
+    def get_by_id(self, id: str) -> AnalysisTypeItem:
+        url = f"{self.base_url}/{id}"
+        resp_dict = super()._get_by_id(url=url)
+
+        analysis_type = AnalysisTypeItem.model_validate(resp_dict)
+        self.restart_analysis_source_types(analysis_type)
+        return analysis_type
+
+    def get(
+        self, json: Optional[Dict[str, Any]] = None
+    ) -> Generator[AnalysisTypeItem, None, None]:
+        if json is None:
+            json = {}
+
+        url = f"{self.base_url}/query"
+        for resp_dict in super()._get(url=url, json=json):
+            analysis_type = AnalysisTypeItem.model_validate(resp_dict)
+            self.restart_analysis_source_types(analysis_type)
+            yield analysis_type
+
+    def restart_analysis_source_types(
+        self, analysis_type_item: AnalysisTypeItem
+    ) -> None:
+        if getattr(analysis_type_item, "id", None) is None:
+            raise ItemNotFoundError
+
+        if analysis_type_item.source_configurations is None:
+            return
+
+        analysis_source_type_ids = [
+            x.source_type_id
+            for x in analysis_type_item.source_configurations
+            if x.source_type_id is not None
+        ]
+
+        if len(analysis_source_type_ids) != 0:
+            analysis_type_item.analysis_source_types = AnalysisSourceTypes(
+                server=self.server
+            ).get(json={"id": {"$in": analysis_source_type_ids}})

mindbridgeapi/async_results.py

@@ -0,0 +1,194 @@
+#
+#  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
+import time
+from typing import Any, Dict, Generator, List, Optional
+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__)
+
+
+@dataclass
+class AsyncResults(BaseSet):
+    @cached_property
+    def base_url(self) -> str:
+        return f"{self.server.base_url}/async-results"
+
+    def _wait_for_async_result(
+        self,
+        async_result: AsyncResultItem,
+        max_wait_minutes: int,
+        init_interval_sec: int,
+    ) -> None:
+        """Wait for async result 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
+        """
+        self._wait_for_async_results(
+            async_results=[async_result],
+            max_wait_minutes=max_wait_minutes,
+            init_interval_sec=init_interval_sec,
+        )
+
+    def _wait_for_async_results(
+        self,
+        async_results: List[AsyncResultItem],
+        max_wait_minutes: int,
+        init_interval_sec: int,
+    ) -> None:
+        """Wait for async results to complete
+
+        Waits, at most the minutes specified, for all async results to be COMPLETE and
+        raises and error if any error
+
+        Args:
+            async_results (List[AsyncResultItem]): Async results to check
+            max_wait_minutes (int): Maximum minutes to wait
+            init_interval_sec (int): The initial seconds to wait
+
+        Raises:
+            TimeoutError: If waited for more than specified
+        """
+
+        max_interval_sec = 60 * 5
+        max_wait_seconds = max_wait_minutes * 60
+        start_time = time.monotonic()
+        elapsed_time = 0.0
+        interval_sec = init_interval_sec
+        i = 0
+
+        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} "
+                "to check"
+            )
+
+            if number_of_async_results <= 0:
+                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"
+                )
+
+            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:
+                break
+
+            sleep_seconds = interval_sec - (time.monotonic() - loop_start_time)
+            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)
+
+            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
+
+        else:
+            raise TimeoutError(f"Waited too long: {max_wait_minutes} minutes")
+
+    def _check_if_async_result_is_completed(
+        self, async_result: AsyncResultItem
+    ) -> bool:
+        """Checks if the Async Result is completed
+
+        Returns True if COMPLETE, False if IN_PROGRESS and raises and error otherwise.
+
+        Args:
+            async_result (AsyncResultItem): The async result to check
+
+        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 {async_result.id} for"
+            f" {async_result.entity_type} {async_result.entity_id} resulted in"
+            f" {async_result.status}"
+        )
+        logger.info(async_result_str)
+
+        if async_result.status == AsyncResultStatus.IN_PROGRESS:
+            return False
+
+        if async_result.status == AsyncResultStatus.COMPLETE:
+            return True
+
+        # Must be AsyncResultStatus.ERROR
+        raise ValidationError(f"{async_result_str} with message {async_result.error}.")
+
+    def get(
+        self, json: Optional[Dict[str, Any]] = None
+    ) -> Generator[AsyncResultItem, None, None]:
+        if json is None:
+            json = {}
+
+        url = f"{self.base_url}/query"
+        for resp_dict in super()._get(url=url, json=json):
+            yield AsyncResultItem.model_validate(resp_dict)
+
+    def get_by_id(self, id: str) -> AsyncResultItem:
+        url = f"{self.base_url}/{id}"
+        resp_dict = super()._get_by_id(url=url)
+
+        return AsyncResultItem.model_validate(resp_dict)

mindbridgeapi/base_set.py

@@ -0,0 +1,175 @@
+#
+#  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 http.client import responses
+import json
+import logging
+import shutil
+from typing import TYPE_CHECKING, Any, Dict, Generator, Iterable, List, Optional
+from urllib.parse import urlencode
+from mindbridgeapi.exceptions import UnexpectedServerError, ValidationError
+
+if TYPE_CHECKING:
+    from pathlib import Path
+    from urllib3.response import BaseHTTPResponse
+    from mindbridgeapi.server import Server
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class BaseSet:
+    server: "Server"
+
+    def _get_by_id(
+        self, url: str, query_parameters: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        resp = self.server.http.request("GET", url, fields=query_parameters)
+        self._check_response(resp)
+        return self._response_as_dict(resp)
+
+    def _get(
+        self, url: str, json: Dict[str, Any]
+    ) -> Generator[Dict[str, Any], None, None]:
+        item_holder: List[Dict[str, Any]] = []
+        page_number = 0
+        page_is_not_last = True
+
+        while True:
+            if len(item_holder) != 0:
+                yield item_holder.pop(0)
+            elif page_is_not_last:
+                params = {"page": page_number}
+                request_url = f"{url}?{urlencode(params)}"
+
+                resp = self.server.http.request("POST", request_url, json=json)
+                self._check_response(resp)
+                resp_dict = self._response_as_dict(resp)
+
+                if "last" not in resp_dict or not isinstance(resp_dict["last"], bool):
+                    raise UnexpectedServerError(f"{resp_dict}")
+
+                page_is_not_last = not resp_dict["last"]
+
+                if "content" not in resp_dict or not isinstance(
+                    resp_dict["content"], list
+                ):
+                    raise UnexpectedServerError(f"{resp_dict}")
+
+                item_holder.extend(resp_dict["content"])
+
+                page_number = page_number + 1
+            else:
+                return  # No more items
+
+    def _create(
+        self,
+        url: str,
+        json: Optional[Dict[str, Any]] = None,
+        extra_ok_statuses: Optional[Iterable[int]] = None,
+    ) -> Dict[str, Any]:
+        if json is None:
+            json = {}
+
+        resp = self.server.http.request("POST", url, json=json)
+        self._check_response(resp=resp, extra_ok_statuses=extra_ok_statuses)
+        return self._response_as_dict(resp)
+
+    def _delete(self, url: str) -> None:
+        resp = self.server.http.request("DELETE", url)
+        self._check_response(resp)
+
+    def _update(self, url: str, json: Dict[str, Any]) -> Dict[str, Any]:
+        resp = self.server.http.request("PUT", url, json=json)
+        self._check_response(resp)
+        return self._response_as_dict(resp)
+
+    def _upload(self, url: str, files: Dict[str, Any]) -> Dict[str, Any]:
+        resp = self.server.http.request("POST", url, fields=files)
+
+        self._check_response(resp)
+
+        if resp.status == 204:
+            return {}
+
+        return self._response_as_dict(resp)
+
+    @staticmethod
+    def _response_as_dict(resp: "BaseHTTPResponse") -> Dict[str, Any]:
+        """Converts the HTTP response body as a dict
+
+        Args:
+            resp (urllib3.response.BaseHTTPResponse): The HTTP response from the server
+
+        Returns:
+            Dict[str, Any]: The dict representation of the JSON response from the server
+
+        Raises:
+            UnexpectedServerError: When the response is not JSON, or it is JSON but
+                python didn't parase the data to a dict
+        """
+        try:
+            resp_obj = resp.json()
+        except UnicodeDecodeError as err:
+            raise UnexpectedServerError("body was not UTF-8.") from err  # noqa:TRY003
+        except json.JSONDecodeError as err:
+            raise UnexpectedServerError("body was not JSON.") from err  # noqa:TRY003
+
+        if not isinstance(resp_obj, dict):
+            raise UnexpectedServerError("JSON was not an object.")  # noqa:TRY003
+
+        return resp_obj
+
+    def _download(self, url: str, output_path: "Path") -> "Path":
+        with self.server.http.request("GET", url, preload_content=False) as resp, open(
+            output_path, "wb"
+        ) as write_file:
+            shutil.copyfileobj(resp, write_file)
+            self._check_response(resp)
+            resp.release_conn()
+
+        return output_path
+
+    @staticmethod
+    def _check_response(
+        resp: "BaseHTTPResponse",
+        extra_ok_statuses: Optional[Iterable[int]] = None,
+    ) -> None:
+        """Raises error if response status is not ok, also logs"""
+
+        if extra_ok_statuses is None:
+            extra_ok_statuses = iter(())
+
+        status_text = responses.get(resp.status, "")
+
+        log_str = "HTTP response (approximately):"
+        log_str += f"\n{resp.status} {status_text}"
+        for k, v in resp.headers.items():
+            log_str += f"\n{k}: {v}"
+
+        log_str += "\n"
+        try:
+            log_str += f"\n{json.dumps(resp.json(), indent=4, sort_keys=True)}"
+        except (UnicodeDecodeError, json.JSONDecodeError):
+            if len(resp.data) > 0:
+                log_str += "\n[Body that is apparently not JSON data]"
+
+        logger.debug(log_str)
+
+        # Raise error if not ok
+        if 400 <= resp.status < 600 and resp.status not in extra_ok_statuses:
+            http_error_msg = f"{resp.status}: {status_text} for url: {resp.url}"
+            try:
+                http_error_msg += (
+                    f"\n{json.dumps(resp.json(), indent=4, sort_keys=True)}"
+                )
+            except (UnicodeDecodeError, json.JSONDecodeError):
+                pass
+
+            raise ValidationError(http_error_msg)

mindbridgeapi/chunked_file_item.py

@@ -0,0 +1,37 @@
+#
+#  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, field_validator, model_validator
+from mindbridgeapi.common_validators import (
+    _convert_userinfo_to_useritem,
+    _warning_if_extra_fields,
+)
+from mindbridgeapi.generated_pydantic_model.model import (
+    ApiChunkedFileCreateOnly,
+    ApiChunkedFileRead,
+)
+
+
+class ChunkedFileItem(ApiChunkedFileRead):
+    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 create_json(self) -> Dict[str, Any]:
+        in_class_dict = self.model_dump()
+        out_class_object = ApiChunkedFileCreateOnly.model_validate(in_class_dict)
+        return out_class_object.model_dump(
+            mode="json", by_alias=True, exclude_none=True
+        )

mindbridgeapi/chunked_file_part_item.py

@@ -0,0 +1,25 @@
+#
+#  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, model_validator
+from mindbridgeapi.common_validators import _warning_if_extra_fields
+from mindbridgeapi.generated_pydantic_model.model import ApiChunkedFilePartRead
+
+
+class ChunkedFilePartItem(ApiChunkedFilePartRead):
+    model_config = ConfigDict(
+        extra="allow",
+        validate_assignment=True,
+        validate_default=True,
+        validate_return=True,
+    )
+    _ = model_validator(mode="after")(_warning_if_extra_fields)
+
+    @property
+    def create_body(self) -> str:
+        return self.model_dump_json(by_alias=True, exclude_none=True)

mindbridgeapi/chunked_files.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.
+#
+
+from dataclasses import dataclass
+from functools import cached_property
+from typing import TYPE_CHECKING, Any, Dict, Generator, Optional
+from mindbridgeapi.base_set import BaseSet
+from mindbridgeapi.chunked_file_item import ChunkedFileItem
+from mindbridgeapi.exceptions import ItemAlreadyExistsError, ItemNotFoundError
+
+if TYPE_CHECKING:
+    from mindbridgeapi.chunked_file_part_item import ChunkedFilePartItem
+
+
+@dataclass
+class ChunkedFiles(BaseSet):
+    @cached_property
+    def base_url(self) -> str:
+        return f"{self.server.base_url}/chunked-files"
+
+    def create(self, item: ChunkedFileItem) -> ChunkedFileItem:
+        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)
+
+        return ChunkedFileItem.model_validate(resp_dict)
+
+    def get_by_id(self, id: str) -> ChunkedFileItem:
+        url = f"{self.base_url}/{id}"
+        resp_dict = super()._get_by_id(url=url)
+
+        return ChunkedFileItem.model_validate(resp_dict)
+
+    def get(
+        self, json: Optional[Dict[str, Any]] = None
+    ) -> Generator[ChunkedFileItem, None, None]:
+        if json is None:
+            json = {}
+
+        url = f"{self.base_url}/query"
+        for resp_dict in super()._get(url=url, json=json):
+            yield ChunkedFileItem.model_validate(resp_dict)
+
+    def send_chunk(
+        self,
+        chunked_file_item: ChunkedFileItem,
+        chunked_file_part_item: "ChunkedFilePartItem",
+        data: bytes,
+    ) -> None:
+        if getattr(chunked_file_item, "id", None) is None:
+            raise ItemNotFoundError
+
+        url = f"{self.base_url}/{chunked_file_item.id}/part"
+        files = {
+            "chunkedFilePart": (
+                None,
+                chunked_file_part_item.create_body,
+                "application/json",
+            ),
+            "fileChunk": (chunked_file_item.name, data),
+        }
+
+        super()._upload(url=url, files=files)

mindbridgeapi/column_mapping.py

@@ -0,0 +1,21 @@
+#
+#  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, model_validator
+from mindbridgeapi.common_validators import _warning_if_extra_fields
+from mindbridgeapi.generated_pydantic_model.model import ApiProposedColumnMappingRead
+
+
+class ColumnMapping(ApiProposedColumnMappingRead):
+    model_config = ConfigDict(
+        extra="allow",
+        validate_assignment=True,
+        validate_default=True,
+        validate_return=True,
+    )
+    _ = model_validator(mode="after")(_warning_if_extra_fields)