mindbridge-api-python-client 1.5.1__tar.gz → 1.6.1__tar.gz

{mindbridge_api_python_client-1.5.1 → mindbridge_api_python_client-1.6.1}/PKG-INFO

@@ -1,32 +1,30 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: mindbridge-api-python-client
-Version: 1.5.1
+Version: 1.6.1
 Summary: Interact with the MindBridge API
-Home-page: https://www.mindbridge.ai
-License: Proprietary
+License: LicenseRef-Proprietary
+Keywords: MindBridge
 Author: MBAI Support
 Author-email: mbaisupport@mindbridge.ai
 Maintainer: MBAI Support
 Maintainer-email: mbaisupport@mindbridge.ai
-Requires-Python: >=3.9,<4.0
+Requires-Python: >= 3.9
 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.13
-Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Typing :: Typed
 Requires-Dist: pydantic (>=2.5.2,<3.0.0)
-Requires-Dist: urllib3 (>=2.0.7,<3.0.0)
+Requires-Dist: urllib3 (>=2.3.0,<3.0.0)
+Project-URL: Homepage, https://www.mindbridge.ai
 Description-Content-Type: text/markdown
 
 <h1 align="center">MindBridge API Python Client</h1>

mindbridge_api_python_client-1.6.1/pyproject.toml

@@ -0,0 +1,148 @@
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[project]
+name = "mindbridge-api-python-client"
+version = "1.6.1"
+description = "Interact with the MindBridge API"
+readme = "README.md"
+license = "LicenseRef-Proprietary"
+license-files = ["LICENSE.txt"]
+authors = [
+    {name = "MBAI Support", email = "mbaisupport@mindbridge.ai"}, # Must be first so that PyPI displays this
+    {name = "Edgar Silva", email = "edgar.silva@mindbridge.ai"},
+    {name = "Jordan Hatcher", email = "jordan.hatcher@mindbridge.ai"},
+    {name = "Kevin Paulson", email = "kevin.paulson@mindbridge.ai"},
+    {name = "Michael Smith", email = "msmith@mindbridge.ai"},
+    {name = "Owen Allen", email = "owen.allen@mindbridge.ai"},
+    {name = "Wing-Leung Chan", email = "wing-leung.chan@mindbridge.ai"},
+]
+maintainers = [
+    {name = "MBAI Support", email = "mbaisupport@mindbridge.ai"},
+]
+dependencies = [
+  "pydantic (>=2.5.2,<3.0.0)",
+  "urllib3 (>=2.3.0,<3.0.0)",
+]
+requires-python = ">= 3.9"
+keywords = [ "MindBridge" ]
+dynamic = [ "classifiers" ]
+
+[project.urls]
+homepage = "https://www.mindbridge.ai"
+
+[tool.poetry]
+requires-poetry = ">=2.0"
+classifiers = [ # Python classifiers are automatically added by poetry
+    "Development Status :: 4 - Beta",
+    "Framework :: Pydantic",
+    "Framework :: Pydantic :: 2",
+    "Framework :: Pytest",
+    "License :: Other/Proprietary License",
+    "Operating System :: OS Independent",
+    "Typing :: Typed",
+]
+packages = [
+    { include = "mindbridgeapi", from = "src" },
+]
+
+[tool.poetry.group.lint]
+optional = true
+
+[tool.poetry.group.lint.dependencies]
+ruff = "^0.9.6"
+
+[tool.poetry.group.test]
+optional = true
+
+[tool.poetry.group.test.dependencies]
+pytest = "^8.1.1"
+pytest-randomly = "^3.15.0"
+openpyxl = "^3.1.5"
+pandas = "^2.2.3"
+datamodel-code-generator = "^0.28.0"
+mypy = "^1.13.0"
+pytest-cov = "^6.0.0"
+pytest-html = "^4.1.1"
+
+[tool.ruff]
+extend-exclude = [
+    "src/mindbridgeapi/generated_pydantic_model/model.py",
+    ".cci_pycache",
+]
+
+[tool.ruff.format]
+line-ending = "lf"
+
+[tool.ruff.lint]
+select = [
+    "I", # isort
+    "F", # Pyflakes
+    "E", "W", # pycodestyle
+    "N", # pep8-naming
+    "B", # flake8-bugbear
+    "C4", # flake8-comprehensions
+    "ISC", # flake8-implicit-str-concat
+    "PT", # flake8-pytest-style
+    "RET", # flake8-return
+    "SIM", # flake8-simplify
+    "TID", # flake8-tidy-imports
+    "TRY", # tryceratops
+    "TC", # flake8-type-checking
+    "RUF100",
+    # flake8-clean-block = "^0.1.2"
+    # flake8-encodings = "^0.5.1" https://github.com/astral-sh/ruff/issues/3278
+]
+ignore = [
+    "E111", "E114", "E117", # Conflicting lint rules with formatter
+    "SIM105", # Did not seem useful
+    "TRY003", # Did not seem useful
+]
+
+[tool.ruff.lint.flake8-tidy-imports]
+ban-relative-imports = "all"
+
+[tool.ruff.lint.isort]
+combine-as-imports = true
+force-sort-within-sections = true
+no-lines-before = ["future", "standard-library", "first-party", "local-folder", "third-party"]
+
+[tool.pytest.ini_options]
+addopts = [
+    "--strict-config",
+    "--strict-markers",
+    "--cov=mindbridgeapi",
+    "--cov=generate_model",
+    "--cov=set_circleci_pytest_enviroment_variables",
+    "--cov-report=html",
+    "--cov-report=term",
+    "--cov-report=xml",
+]
+
+xfail_strict = true
+filterwarnings = [ "error" ]
+pythonpath = [ "tools" ]
+
+[tool.coverage.run]
+branch = true
+omit = [ "src/mindbridgeapi/generated_pydantic_model/*" ]
+
+[tool.coverage.report]
+exclude_also = [
+    "if TYPE_CHECKING:",
+    'if __name__ == "__main__":',
+]
+
+[tool.mypy]
+mypy_path = "$MYPY_CONFIG_FILE_DIR/src"
+packages = "mindbridgeapi,tools.generate_model,tools.set_circleci_pytest_enviroment_variables"
+plugins = [ "pydantic.mypy" ]
+strict = true
+no_implicit_optional = true
+show_error_codes = true
+
+[tool.pydantic-mypy]
+init_forbid_extra = true
+init_typed = true
+warn_required_dynamic_aliases = true

{mindbridge_api_python_client-1.5.1 → mindbridge_api_python_client-1.6.1}/src/mindbridgeapi/__init__.py

@@ -21,10 +21,10 @@ from mindbridgeapi.enumerations.analysis_type import AnalysisType
 from mindbridgeapi.enumerations.system_library import SystemLibrary
 from mindbridgeapi.file_manager_item import FileManagerItem, FileManagerType
 from mindbridgeapi.generated_pydantic_model.model import (
+    Frequency,
     PeriodType as AnalysisEffectiveDateMetricsPeriod,
+    TargetWorkflowState,
 )
-from mindbridgeapi.generated_pydantic_model.model import Frequency
-from mindbridgeapi.generated_pydantic_model.model import TargetWorkflowState
 from mindbridgeapi.library_item import LibraryItem
 from mindbridgeapi.organization_item import OrganizationItem
 from mindbridgeapi.server import Server

{mindbridge_api_python_client-1.5.1 → mindbridge_api_python_client-1.6.1}/src/mindbridgeapi/account_grouping_item.py

@@ -17,8 +17,6 @@ from mindbridgeapi.common_validators import (
 from mindbridgeapi.generated_pydantic_model.model import (
     ApiAccountGroupingRead,
     ApiAccountGroupingUpdate,
-)
-from mindbridgeapi.generated_pydantic_model.model import (
     Type7 as _AccountGroupingFileType,
 )
 

{mindbridge_api_python_client-1.5.1 → mindbridge_api_python_client-1.6.1}/src/mindbridgeapi/account_groupings.py

@@ -8,7 +8,6 @@
 
 from dataclasses import dataclass
 from functools import cached_property
-import logging
 from typing import TYPE_CHECKING, Any, Optional, Union
 from mindbridgeapi.account_grouping_item import (
     AccountGroupingFileType,
@@ -28,8 +27,6 @@ if TYPE_CHECKING:
     from os import PathLike
     from pathlib import Path
 
-logger = logging.getLogger(__name__)
-
 
 @dataclass
 class AccountGroupings(BaseSet):

{mindbridge_api_python_client-1.5.1 → mindbridge_api_python_client-1.6.1}/src/mindbridgeapi/account_groups.py

@@ -8,18 +8,15 @@
 
 from dataclasses import dataclass
 from functools import cached_property
-import logging
 from typing import TYPE_CHECKING, Any, 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
+from mindbridgeapi.common_validators import _convert_json_query
+from mindbridgeapi.exceptions import ItemNotFoundError
 
 if TYPE_CHECKING:
     from collections.abc import Generator
 
-logger = logging.getLogger(__name__)
-
 
 @dataclass
 class AccountGroups(BaseSet):
@@ -36,26 +33,10 @@ class AccountGroups(BaseSet):
     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."
-                ),
-            )
+        mb_query_dict = _convert_json_query(json, required_key="accountGroupingId")
 
         url = f"{self.base_url}/query"
-        for resp_dict in super()._get(url=url, json=json):
+        for resp_dict in super()._get(url=url, json=mb_query_dict):
             yield AccountGroupItem.model_validate(resp_dict)
 
     def update(self, account_group: AccountGroupItem) -> AccountGroupItem:

{mindbridge_api_python_client-1.5.1 → mindbridge_api_python_client-1.6.1}/src/mindbridgeapi/account_mappings.py

@@ -8,18 +8,15 @@
 
 from dataclasses import dataclass
 from functools import cached_property
-import logging
 from typing import TYPE_CHECKING, Any, Optional
 from mindbridgeapi.account_mapping_item import AccountMappingItem
 from mindbridgeapi.base_set import BaseSet
-from mindbridgeapi.exceptions import ItemNotFoundError, ParameterError
-from mindbridgeapi.generated_pydantic_model.model import MindBridgeQueryTerm
+from mindbridgeapi.common_validators import _convert_json_query
+from mindbridgeapi.exceptions import ItemNotFoundError
 
 if TYPE_CHECKING:
     from collections.abc import Generator
 
-logger = logging.getLogger(__name__)
-
 
 @dataclass
 class AccountMappings(BaseSet):
@@ -35,26 +32,10 @@ class AccountMappings(BaseSet):
     def get(
         self, json: Optional[dict[str, Any]] = None
     ) -> "Generator[AccountMappingItem, 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"{json} was converted to {json_str}")
-
-        if "engagementId" not in json_str:
-            raise ParameterError(
-                parameter_name="json",
-                details=(
-                    "At least one valid engagementId term must be provided when "
-                    "querying this entity."
-                ),
-            )
+        mb_query_dict = _convert_json_query(json, required_key="engagementId")
 
         url = f"{self.base_url}/query"
-        for resp_dict in super()._get(url=url, json=json):
+        for resp_dict in super()._get(url=url, json=mb_query_dict):
             yield AccountMappingItem.model_validate(resp_dict)
 
     def update(self, item: AccountMappingItem) -> AccountMappingItem:

{mindbridge_api_python_client-1.5.1 → mindbridge_api_python_client-1.6.1}/src/mindbridgeapi/analyses.py

@@ -83,12 +83,6 @@ class Analyses(BaseSet):
         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:

{mindbridge_api_python_client-1.5.1 → mindbridge_api_python_client-1.6.1}/src/mindbridgeapi/analysis_period.py

@@ -40,12 +40,9 @@ class AnalysisPeriod(ApiAnalysisPeriodRead):
         if not isinstance(other, AnalysisPeriod):
             return NotImplemented
 
-        if (self.start_date > other.end_date) or (
+        return (self.start_date > other.end_date) or (
             (self.end_date == other.end_date) and (self.start_date > other.start_date)
-        ):
-            return True
-
-        return False
+        )
 
     def __le__(self, other: object) -> bool:
         return NotImplemented

{mindbridge_api_python_client-1.5.1 → mindbridge_api_python_client-1.6.1}/src/mindbridgeapi/analysis_source_item.py

@@ -92,11 +92,11 @@ class _ApiAnalysisSourceCreateOnly(ApiAnalysisSourceCreateOnly):
         appropriate virtual column type.
     """
 
-    proposed_virtual_columns: Optional[
-        list[_VirtualColumn]
-    ] = Field().merge_field_infos(
-        ApiAnalysisSourceCreateOnly.model_fields["proposed_virtual_columns"]
-    )  # type: ignore[assignment]
+    proposed_virtual_columns: Optional[list[_VirtualColumn]] = (
+        Field().merge_field_infos(  # type: ignore[assignment]
+            ApiAnalysisSourceCreateOnly.model_fields["proposed_virtual_columns"]
+        )
+    )
 
 
 class _ApiAnalysisSourceUpdate(ApiAnalysisSourceUpdate):
@@ -106,11 +106,11 @@ class _ApiAnalysisSourceUpdate(ApiAnalysisSourceUpdate):
         determine the appropriate virtual column type.
     """
 
-    proposed_virtual_columns: Optional[
-        list[_VirtualColumn]
-    ] = Field().merge_field_infos(
-        ApiAnalysisSourceUpdate.model_fields["proposed_virtual_columns"]
-    )  # type: ignore[assignment]
+    proposed_virtual_columns: Optional[list[_VirtualColumn]] = (
+        Field().merge_field_infos(  # type: ignore[assignment]
+            ApiAnalysisSourceUpdate.model_fields["proposed_virtual_columns"]
+        )
+    )
     virtual_columns: Optional[list[_VirtualColumn]] = Field().merge_field_infos(
         ApiAnalysisSourceUpdate.model_fields["virtual_columns"]
     )  # type: ignore[assignment]
@@ -127,11 +127,11 @@ class AnalysisSourceItem(ApiAnalysisSourceRead):
         ApiAnalysisSourceRead.model_fields["analysis_source_type_id"],
         default=AnalysisSourceTypeItem.GENERAL_LEDGER_JOURNAL,
     )
-    proposed_virtual_columns: Optional[
-        list[_VirtualColumn]
-    ] = Field().merge_field_infos(
-        ApiAnalysisSourceRead.model_fields["proposed_virtual_columns"]
-    )  # type: ignore[assignment]
+    proposed_virtual_columns: Optional[list[_VirtualColumn]] = (
+        Field().merge_field_infos(  # type: ignore[assignment]
+            ApiAnalysisSourceRead.model_fields["proposed_virtual_columns"]
+        )
+    )
     virtual_columns: Optional[list[_VirtualColumn]] = Field().merge_field_infos(
         ApiAnalysisSourceRead.model_fields["virtual_columns"]
     )  # type: ignore[assignment]

{mindbridge_api_python_client-1.5.1 → mindbridge_api_python_client-1.6.1}/src/mindbridgeapi/analysis_sources.py

@@ -21,8 +21,6 @@ from mindbridgeapi.exceptions import (
 )
 from mindbridgeapi.generated_pydantic_model.model import (
     ApiEffectiveDateMetricsRead as AnalysisEffectiveDateMetrics,
-)
-from mindbridgeapi.generated_pydantic_model.model import (
     PeriodType as AnalysisEffectiveDateMetricsPeriod,
 )
 
@@ -80,7 +78,9 @@ class AnalysisSources(BaseSet):
     def effective_date_metrics(
         self,
         item: AnalysisSourceItem,
-        period_type: AnalysisEffectiveDateMetricsPeriod = AnalysisEffectiveDateMetricsPeriod.MONTH,  # noqa:B950
+        period_type: AnalysisEffectiveDateMetricsPeriod = (
+            AnalysisEffectiveDateMetricsPeriod.MONTH
+        ),
     ) -> AnalysisEffectiveDateMetrics:
         if getattr(item, "id", None) is None:
             raise ItemNotFoundError

{mindbridge_api_python_client-1.5.1 → mindbridge_api_python_client-1.6.1}/src/mindbridgeapi/async_result_item.py

@@ -13,9 +13,11 @@ from mindbridgeapi.common_validators import (
     _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 Status3 as _AsyncResultStatus
-from mindbridgeapi.generated_pydantic_model.model import Type1 as _AsyncResultType
+from mindbridgeapi.generated_pydantic_model.model import (
+    ApiAsyncResult,
+    Status3 as _AsyncResultStatus,
+    Type1 as _AsyncResultType,
+)
 
 logger = logging.getLogger(__name__)
 

{mindbridge_api_python_client-1.5.1 → mindbridge_api_python_client-1.6.1}/src/mindbridgeapi/base_set.py

@@ -13,6 +13,7 @@ import logging
 import shutil
 from typing import TYPE_CHECKING, Any, Optional
 from urllib.parse import urlencode
+from urllib3.util import Retry
 from mindbridgeapi.exceptions import UnexpectedServerError, ValidationError
 
 if TYPE_CHECKING:
@@ -61,7 +62,14 @@ class BaseSet:
         params = {"page": page_number}
         request_url = f"{url}?{urlencode(params)}"
 
-        resp = self.server.http.request("POST", request_url, json=json)
+        # Same as set for the PoolManager (http) in Server, but getting a page will
+        # always be considered to be idempotent so we can allow repeat post requests
+        method = "POST"
+        retries = Retry(
+            connect=3, read=3, redirect=0, other=0, allowed_methods={method}
+        )
+
+        resp = self.server.http.request(method, request_url, retries=retries, json=json)
         self._check_response(resp)
         resp_dict = self._response_as_dict(resp)
 

{mindbridge_api_python_client-1.5.1 → mindbridge_api_python_client-1.6.1}/src/mindbridgeapi/common_validators.py

@@ -7,11 +7,18 @@
 #
 
 import logging
-from typing import Any
+from typing import Any, Optional, Union
 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
+from pydantic import RootModel
+from mindbridgeapi.exceptions import ParameterError
+from mindbridgeapi.generated_pydantic_model.model import (
+    ApiUserInfo,
+    ApiUserInfoRead,
+    ApiUserRead as UserItem,
+    Role,
+)
+
+MindBridgeQuery = RootModel[dict[str, Any]]
 
 logger = logging.getLogger(__name__)
 
@@ -69,3 +76,29 @@ def _convert_userinfo_to_useritem(v: Any) -> Any:
     return UserItem(
         id=v.user_id, first_name=first_name, last_name="", role=Role.ROLE_ADMIN
     )
+
+
+def _convert_json_query(
+    json: Optional[dict[str, Any]], required_key: Optional[str] = None
+) -> dict[str, Union[int, float, bool, str]]:
+    if json is None:
+        json = {}
+
+    mb_query = MindBridgeQuery.model_validate(json)
+    json_str = mb_query.model_dump_json(exclude_none=True)
+
+    logger.info(f"Query (get) is: {json_str}")
+
+    if required_key is not None and required_key not in json_str:
+        raise ParameterError(
+            parameter_name="json",
+            details=(
+                f"At least one valid {required_key} term must be provided when querying"
+                " this entity."
+            ),
+        )
+
+    mb_query_dict: dict[str, Union[int, float, bool, str]] = mb_query.model_dump(
+        mode="json", exclude_none=True
+    )
+    return mb_query_dict

{mindbridge_api_python_client-1.5.1 → mindbridge_api_python_client-1.6.1}/src/mindbridgeapi/data_tables.py

@@ -8,28 +8,25 @@
 
 from dataclasses import dataclass
 from functools import cached_property
-import logging
 from typing import TYPE_CHECKING, Any, Optional
 import warnings
 from mindbridgeapi.async_result_item import AsyncResultItem, AsyncResultType
 from mindbridgeapi.async_results import AsyncResults
 from mindbridgeapi.base_set import BaseSet
+from mindbridgeapi.common_validators import _convert_json_query
 from mindbridgeapi.exceptions import ItemError, ItemNotFoundError, ParameterError
 from mindbridgeapi.generated_pydantic_model.model import (
     ApiDataTableExportRequest,
     ApiDataTableQuerySortOrder,
     ApiDataTableRead,
     Direction,
-    MindBridgeQueryTerm,
+    Type4 as DataTableColumnType,
 )
-from mindbridgeapi.generated_pydantic_model.model import Type4 as DataTableColumnType
 
 if TYPE_CHECKING:
     from collections.abc import Generator
     from pathlib import Path
 
-logger = logging.getLogger(__name__)
-
 
 @dataclass
 class DataTables(BaseSet):
@@ -49,28 +46,10 @@ class DataTables(BaseSet):
     def get(
         self, json: Optional[dict[str, Any]] = None
     ) -> "Generator[ApiDataTableRead, None, None]":
-        logger.info("Starting Query (get)")
-
-        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 "analysisId" not in json_str:
-            raise ParameterError(
-                parameter_name="json",
-                details=(
-                    "At least one valid analysisId term must be provided when querying "
-                    "this entity."
-                ),
-            )
+        mb_query_dict = _convert_json_query(json, required_key="analysisId")
 
         url = f"{self.base_url}/query"
-        for resp_dict in super()._get(url=url, json=json):
+        for resp_dict in super()._get(url=url, json=mb_query_dict):
             yield ApiDataTableRead.model_validate(resp_dict)
 
     @staticmethod
@@ -101,7 +80,20 @@ class DataTables(BaseSet):
         input_item: ApiDataTableRead,
         sort_direction: Optional[Direction] = None,
         sort_field: Optional[str] = None,
-    ) -> ApiDataTableQuerySortOrder:
+    ) -> Optional[ApiDataTableQuerySortOrder]:
+        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.logical_name == "gl_journal_lines":
+            sort_field = "rowid"
+        elif sort_field is None and input_item.logical_name == "gl_journal_tx":
+            sort_field = "txid"
+
+        if sort_field is None or sort_field == "":
+            return None
+
         if sort_direction is None:
             sort_direction = Direction.ASC
 
@@ -112,22 +104,6 @@ class DataTables(BaseSet):
                 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
-
         return ApiDataTableQuerySortOrder(direction=sort_direction, field=sort_field)
 
     def export(
@@ -144,23 +120,21 @@ class DataTables(BaseSet):
 
         fields = self._export_get_fields(input_item=input_item, fields=fields)
 
-        if query is None:
-            query = {}
-
-        mindbridge_query_term = MindBridgeQueryTerm.model_validate(query)
-
-        sort = self._export_get_sort(
-            input_item=input_item, sort_direction=sort_direction, sort_field=sort_field
-        )
-
         url = f"{self.base_url}/{input_item.id}/export"
         data_table_export_request = ApiDataTableExportRequest(
-            fields=fields, query=mindbridge_query_term, limit=limit, sort=sort
+            fields=fields,
+            limit=limit,
+            sort=self._export_get_sort(
+                input_item=input_item,
+                sort_direction=sort_direction,
+                sort_field=sort_field,
+            ),
         )
 
         json = data_table_export_request.model_dump(
             mode="json", by_alias=True, exclude_none=True
         )
+        json["query"] = _convert_json_query(query)
 
         resp_dict = super()._create(url=url, json=json)