lusid-sdk 2.1.983__py3-none-any.whl → 2.1.984__py3-none-any.whl

lusid/__init__.py

@@ -413,6 +413,7 @@ from lusid.models.data_map_key import DataMapKey
 from lusid.models.data_mapping import DataMapping
 from lusid.models.data_model_membership import DataModelMembership
 from lusid.models.data_model_summary import DataModelSummary
+from lusid.models.data_quality_check_result import DataQualityCheckResult
 from lusid.models.data_scope import DataScope
 from lusid.models.data_type import DataType
 from lusid.models.data_type_entity import DataTypeEntity
@@ -715,6 +716,8 @@ from lusid.models.loan_interest_repayment_event import LoanInterestRepaymentEven
 from lusid.models.loan_period import LoanPeriod
 from lusid.models.loan_principal_repayment_event import LoanPrincipalRepaymentEvent
 from lusid.models.lock_period_diary_entry_request import LockPeriodDiaryEntryRequest
+from lusid.models.lusid_entity_dataset import LusidEntityDataset
+from lusid.models.lusid_entity_result import LusidEntityResult
 from lusid.models.lusid_instrument import LusidInstrument
 from lusid.models.lusid_problem_details import LusidProblemDetails
 from lusid.models.lusid_trade_ticket import LusidTradeTicket
@@ -1129,6 +1132,8 @@ from lusid.models.rounding_configuration import RoundingConfiguration
 from lusid.models.rounding_configuration_component import RoundingConfigurationComponent
 from lusid.models.rounding_convention import RoundingConvention
 from lusid.models.rules_interval import RulesInterval
+from lusid.models.run_check_request import RunCheckRequest
+from lusid.models.run_check_response import RunCheckResponse
 from lusid.models.scaling_methodology import ScalingMethodology
 from lusid.models.schedule import Schedule
 from lusid.models.schedule_type import ScheduleType
@@ -1803,6 +1808,7 @@ __all__ = [
     "DataMapping",
     "DataModelMembership",
     "DataModelSummary",
+    "DataQualityCheckResult",
     "DataScope",
     "DataType",
     "DataTypeEntity",
@@ -2105,6 +2111,8 @@ __all__ = [
     "LoanPeriod",
     "LoanPrincipalRepaymentEvent",
     "LockPeriodDiaryEntryRequest",
+    "LusidEntityDataset",
+    "LusidEntityResult",
     "LusidInstrument",
     "LusidProblemDetails",
     "LusidTradeTicket",
@@ -2519,6 +2527,8 @@ __all__ = [
     "RoundingConfigurationComponent",
     "RoundingConvention",
     "RulesInterval",
+    "RunCheckRequest",
+    "RunCheckResponse",
     "ScalingMethodology",
     "Schedule",
     "ScheduleType",

lusid/api/check_definitions_api.py

@@ -30,6 +30,8 @@ from lusid.models.check_definition import CheckDefinition
 from lusid.models.create_check_definition_request import CreateCheckDefinitionRequest
 from lusid.models.deleted_entity_response import DeletedEntityResponse
 from lusid.models.paged_resource_list_of_check_definition import PagedResourceListOfCheckDefinition
+from lusid.models.run_check_request import RunCheckRequest
+from lusid.models.run_check_response import RunCheckResponse
 from lusid.models.update_check_definition_request import UpdateCheckDefinitionRequest
 
 from lusid.api_client import ApiClient
@@ -770,6 +772,181 @@ class CheckDefinitionsApi:
             _request_auth=_params.get('_request_auth'))
 
 
+    @overload
+    async def run_check_definition(self, scope : Annotated[StrictStr, Field(..., description="Scope of the CheckDefinition to run.")], code : Annotated[StrictStr, Field(..., description="Code of the CheckDefinition to run.")], run_check_request : Annotated[Optional[RunCheckRequest], Field(description="Run request defining what dataset to run against.")] = None, **kwargs) -> RunCheckResponse:  # noqa: E501
+        ...
+
+    @overload
+    def run_check_definition(self, scope : Annotated[StrictStr, Field(..., description="Scope of the CheckDefinition to run.")], code : Annotated[StrictStr, Field(..., description="Code of the CheckDefinition to run.")], run_check_request : Annotated[Optional[RunCheckRequest], Field(description="Run request defining what dataset to run against.")] = None, async_req: Optional[bool]=True, **kwargs) -> RunCheckResponse:  # noqa: E501
+        ...
+
+    @validate_arguments
+    def run_check_definition(self, scope : Annotated[StrictStr, Field(..., description="Scope of the CheckDefinition to run.")], code : Annotated[StrictStr, Field(..., description="Code of the CheckDefinition to run.")], run_check_request : Annotated[Optional[RunCheckRequest], Field(description="Run request defining what dataset to run against.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[RunCheckResponse, Awaitable[RunCheckResponse]]:  # noqa: E501
+        """[EXPERIMENTAL] RunCheckDefinition: Runs a Check Definition against given dataset.  # noqa: E501
+
+        Runs a Check Definition against given dataset.  # noqa: E501
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.run_check_definition(scope, code, run_check_request, async_req=True)
+        >>> result = thread.get()
+
+        :param scope: Scope of the CheckDefinition to run. (required)
+        :type scope: str
+        :param code: Code of the CheckDefinition to run. (required)
+        :type code: str
+        :param run_check_request: Run request defining what dataset to run against.
+        :type run_check_request: RunCheckRequest
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _request_timeout: Timeout setting. Do not use - use the opts parameter instead
+        :param opts: Configuration options for this request
+        :type opts: ConfigurationOptions, optional
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: RunCheckResponse
+        """
+        kwargs['_return_http_data_only'] = True
+        if '_preload_content' in kwargs:
+            message = "Error! Please call the run_check_definition_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data"  # noqa: E501
+            raise ValueError(message)
+        if async_req is not None:
+            kwargs['async_req'] = async_req
+        return self.run_check_definition_with_http_info(scope, code, run_check_request, **kwargs)  # noqa: E501
+
+    @validate_arguments
+    def run_check_definition_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="Scope of the CheckDefinition to run.")], code : Annotated[StrictStr, Field(..., description="Code of the CheckDefinition to run.")], run_check_request : Annotated[Optional[RunCheckRequest], Field(description="Run request defining what dataset to run against.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+        """[EXPERIMENTAL] RunCheckDefinition: Runs a Check Definition against given dataset.  # noqa: E501
+
+        Runs a Check Definition against given dataset.  # noqa: E501
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.run_check_definition_with_http_info(scope, code, run_check_request, async_req=True)
+        >>> result = thread.get()
+
+        :param scope: Scope of the CheckDefinition to run. (required)
+        :type scope: str
+        :param code: Code of the CheckDefinition to run. (required)
+        :type code: str
+        :param run_check_request: Run request defining what dataset to run against.
+        :type run_check_request: RunCheckRequest
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _preload_content: if False, the ApiResponse.data will
+                                 be set to none and raw_data will store the
+                                 HTTP response body without reading/decoding.
+                                 Default is True.
+        :type _preload_content: bool, optional
+        :param _return_http_data_only: response data instead of ApiResponse
+                                       object with status code, headers, etc
+        :type _return_http_data_only: bool, optional
+        :param _request_timeout: Timeout setting. Do not use - use the opts parameter instead
+        :param opts: Configuration options for this request
+        :type opts: ConfigurationOptions, optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the authentication
+                              in the spec for a single request.
+        :type _request_auth: dict, optional
+        :type _content_type: string, optional: force content-type for the request
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: tuple(RunCheckResponse, status_code(int), headers(HTTPHeaderDict))
+        """
+
+        _params = locals()
+
+        _all_params = [
+            'scope',
+            'code',
+            'run_check_request'
+        ]
+        _all_params.extend(
+            [
+                'async_req',
+                '_return_http_data_only',
+                '_preload_content',
+                '_request_timeout',
+                '_request_auth',
+                '_content_type',
+                '_headers',
+                'opts'
+            ]
+        )
+
+        # validate the arguments
+        for _key, _val in _params['kwargs'].items():
+            if _key not in _all_params:
+                raise ApiTypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method run_check_definition" % _key
+                )
+            _params[_key] = _val
+        del _params['kwargs']
+
+        _collection_formats = {}
+
+        # process the path parameters
+        _path_params = {}
+        if _params['scope']:
+            _path_params['scope'] = _params['scope']
+
+        if _params['code']:
+            _path_params['code'] = _params['code']
+
+
+        # process the query parameters
+        _query_params = []
+        # process the header parameters
+        _header_params = dict(_params.get('_headers', {}))
+        # process the form parameters
+        _form_params = []
+        _files = {}
+        # process the body parameter
+        _body_params = None
+        if _params['run_check_request'] is not None:
+            _body_params = _params['run_check_request']
+
+        # set the HTTP header `Accept`
+        _header_params['Accept'] = self.api_client.select_header_accept(
+            ['text/plain', 'application/json', 'text/json'])  # noqa: E501
+
+        # set the HTTP header `Content-Type`
+        _content_types_list = _params.get('_content_type',
+            self.api_client.select_header_content_type(
+                ['application/json-patch+json', 'application/json', 'text/json', 'application/*+json']))
+        if _content_types_list:
+                _header_params['Content-Type'] = _content_types_list
+
+        # authentication setting
+        _auth_settings = ['oauth2']  # noqa: E501
+
+        _response_types_map = {
+            '200': "RunCheckResponse",
+            '400': "LusidValidationProblemDetails",
+        }
+
+        return self.api_client.call_api(
+            '/api/dataquality/checkdefinitions/{scope}/{code}/$run', 'PUT',
+            _path_params,
+            _query_params,
+            _header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            response_types_map=_response_types_map,
+            auth_settings=_auth_settings,
+            async_req=_params.get('async_req'),
+            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
+            _preload_content=_params.get('_preload_content', True),
+            _request_timeout=_params.get('_request_timeout'),
+            opts=_params.get('opts'),
+            collection_formats=_collection_formats,
+            _request_auth=_params.get('_request_auth'))
+
+
     @overload
     async def update_check_definition(self, scope : Annotated[StrictStr, Field(..., description="The scope of the specified Check Definition.")], code : Annotated[StrictStr, Field(..., description="The code of the specified Check Definition. Together with the domain and scope this uniquely identifies the Check Definition.")], update_check_definition_request : Annotated[Optional[UpdateCheckDefinitionRequest], Field(description="The request containing the updated details of the Check Definition")] = None, **kwargs) -> CheckDefinition:  # noqa: E501
         ...

lusid/configuration.py

@@ -445,7 +445,7 @@ class Configuration:
         return "Python SDK Debug Report:\n"\
                "OS: {env}\n"\
                "Python Version: {pyversion}\n"\
-               "Version of the API: 0.11.8378\n"\
+               "Version of the API: 0.11.8386\n"\
                "SDK Package Version: {package_version}".\
                format(env=sys.platform, pyversion=sys.version, package_version=package_version)
 

lusid/models/__init__.py

@@ -322,6 +322,7 @@ from lusid.models.data_map_key import DataMapKey
 from lusid.models.data_mapping import DataMapping
 from lusid.models.data_model_membership import DataModelMembership
 from lusid.models.data_model_summary import DataModelSummary
+from lusid.models.data_quality_check_result import DataQualityCheckResult
 from lusid.models.data_scope import DataScope
 from lusid.models.data_type import DataType
 from lusid.models.data_type_entity import DataTypeEntity
@@ -624,6 +625,8 @@ from lusid.models.loan_interest_repayment_event import LoanInterestRepaymentEven
 from lusid.models.loan_period import LoanPeriod
 from lusid.models.loan_principal_repayment_event import LoanPrincipalRepaymentEvent
 from lusid.models.lock_period_diary_entry_request import LockPeriodDiaryEntryRequest
+from lusid.models.lusid_entity_dataset import LusidEntityDataset
+from lusid.models.lusid_entity_result import LusidEntityResult
 from lusid.models.lusid_instrument import LusidInstrument
 from lusid.models.lusid_problem_details import LusidProblemDetails
 from lusid.models.lusid_trade_ticket import LusidTradeTicket
@@ -1038,6 +1041,8 @@ from lusid.models.rounding_configuration import RoundingConfiguration
 from lusid.models.rounding_configuration_component import RoundingConfigurationComponent
 from lusid.models.rounding_convention import RoundingConvention
 from lusid.models.rules_interval import RulesInterval
+from lusid.models.run_check_request import RunCheckRequest
+from lusid.models.run_check_response import RunCheckResponse
 from lusid.models.scaling_methodology import ScalingMethodology
 from lusid.models.schedule import Schedule
 from lusid.models.schedule_type import ScheduleType
@@ -1622,6 +1627,7 @@ __all__ = [
     "DataMapping",
     "DataModelMembership",
     "DataModelSummary",
+    "DataQualityCheckResult",
     "DataScope",
     "DataType",
     "DataTypeEntity",
@@ -1924,6 +1930,8 @@ __all__ = [
     "LoanPeriod",
     "LoanPrincipalRepaymentEvent",
     "LockPeriodDiaryEntryRequest",
+    "LusidEntityDataset",
+    "LusidEntityResult",
     "LusidInstrument",
     "LusidProblemDetails",
     "LusidTradeTicket",
@@ -2338,6 +2346,8 @@ __all__ = [
     "RoundingConfigurationComponent",
     "RoundingConvention",
     "RulesInterval",
+    "RunCheckRequest",
+    "RunCheckResponse",
     "ScalingMethodology",
     "Schedule",
     "ScheduleType",

lusid/models/data_quality_check_result.py

@@ -0,0 +1,181 @@
+# coding: utf-8
+
+"""
+    LUSID API
+
+    FINBOURNE Technology  # noqa: E501
+
+    Contact: info@finbourne.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from datetime import datetime
+from typing import Any, Dict, Optional
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictInt, StrictStr 
+from lusid.models.lusid_entity_result import LusidEntityResult
+
+class DataQualityCheckResult(BaseModel):
+    """
+    Represents the result of a data quality check operation  # noqa: E501
+    """
+    check_definition_scope:  Optional[StrictStr] = Field(None,alias="checkDefinitionScope", description="The scope of the check definition") 
+    check_definition_code:  Optional[StrictStr] = Field(None,alias="checkDefinitionCode", description="The code of the check definition") 
+    check_definition_display_name:  Optional[StrictStr] = Field(None,alias="checkDefinitionDisplayName", description="The display name of the check definition") 
+    check_run_as_at: Optional[datetime] = Field(None, alias="checkRunAsAt", description="The timestamp when the check was run")
+    result_type:  Optional[StrictStr] = Field(None,alias="resultType", description="The type of result from the check") 
+    rule_set_key:  Optional[StrictStr] = Field(None,alias="ruleSetKey", description="The key identifying the ruleset") 
+    rule_set_display_name:  Optional[StrictStr] = Field(None,alias="ruleSetDisplayName", description="The display name of the ruleset") 
+    rule_key:  Optional[StrictStr] = Field(None,alias="ruleKey", description="The key identifying the rule (for RuleInvalid, RuleBreached, RuleBreachesOverLimit)") 
+    rule_display_name:  Optional[StrictStr] = Field(None,alias="ruleDisplayName", description="The display name of the rule (for RuleInvalid, RuleBreached, RuleBreachesOverLimit)") 
+    rule_description:  Optional[StrictStr] = Field(None,alias="ruleDescription", description="The description of the rule (for RuleInvalid, RuleBreached, RuleBreachesOverLimit)") 
+    rule_formula:  Optional[StrictStr] = Field(None,alias="ruleFormula", description="The formula of the rule (for RuleInvalid, RuleBreached, RuleBreachesOverLimit)") 
+    severity: Optional[StrictInt] = Field(None, description="The severity level")
+    lusid_entity: Optional[LusidEntityResult] = Field(None, alias="lusidEntity")
+    count_rule_breaches: Optional[StrictInt] = Field(None, alias="countRuleBreaches", description="The count of rule breaches (1 for RuleBreached, multiple for RuleBreachesOverLimit)")
+    error_detail:  Optional[StrictStr] = Field(None,alias="errorDetail", description="Error details (for RulesetInvalid, RuleInvalid)") 
+    result_id:  Optional[StrictStr] = Field(None,alias="resultId", description="Unique identifier for the result in format: {{GUID of Check Definition}}-{{resultType}}-{{rulesetKey}}-{{ruleKey}}-{{entity GUID}}") 
+    __properties = ["checkDefinitionScope", "checkDefinitionCode", "checkDefinitionDisplayName", "checkRunAsAt", "resultType", "ruleSetKey", "ruleSetDisplayName", "ruleKey", "ruleDisplayName", "ruleDescription", "ruleFormula", "severity", "lusidEntity", "countRuleBreaches", "errorDetail", "resultId"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def __str__(self):
+        """For `print` and `pprint`"""
+        return pprint.pformat(self.dict(by_alias=False))
+
+    def __repr__(self):
+        """For `print` and `pprint`"""
+        return self.to_str()
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.dict(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> DataQualityCheckResult:
+        """Create an instance of DataQualityCheckResult from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        # override the default output from pydantic by calling `to_dict()` of lusid_entity
+        if self.lusid_entity:
+            _dict['lusidEntity'] = self.lusid_entity.to_dict()
+        # set to None if check_definition_scope (nullable) is None
+        # and __fields_set__ contains the field
+        if self.check_definition_scope is None and "check_definition_scope" in self.__fields_set__:
+            _dict['checkDefinitionScope'] = None
+
+        # set to None if check_definition_code (nullable) is None
+        # and __fields_set__ contains the field
+        if self.check_definition_code is None and "check_definition_code" in self.__fields_set__:
+            _dict['checkDefinitionCode'] = None
+
+        # set to None if check_definition_display_name (nullable) is None
+        # and __fields_set__ contains the field
+        if self.check_definition_display_name is None and "check_definition_display_name" in self.__fields_set__:
+            _dict['checkDefinitionDisplayName'] = None
+
+        # set to None if result_type (nullable) is None
+        # and __fields_set__ contains the field
+        if self.result_type is None and "result_type" in self.__fields_set__:
+            _dict['resultType'] = None
+
+        # set to None if rule_set_key (nullable) is None
+        # and __fields_set__ contains the field
+        if self.rule_set_key is None and "rule_set_key" in self.__fields_set__:
+            _dict['ruleSetKey'] = None
+
+        # set to None if rule_set_display_name (nullable) is None
+        # and __fields_set__ contains the field
+        if self.rule_set_display_name is None and "rule_set_display_name" in self.__fields_set__:
+            _dict['ruleSetDisplayName'] = None
+
+        # set to None if rule_key (nullable) is None
+        # and __fields_set__ contains the field
+        if self.rule_key is None and "rule_key" in self.__fields_set__:
+            _dict['ruleKey'] = None
+
+        # set to None if rule_display_name (nullable) is None
+        # and __fields_set__ contains the field
+        if self.rule_display_name is None and "rule_display_name" in self.__fields_set__:
+            _dict['ruleDisplayName'] = None
+
+        # set to None if rule_description (nullable) is None
+        # and __fields_set__ contains the field
+        if self.rule_description is None and "rule_description" in self.__fields_set__:
+            _dict['ruleDescription'] = None
+
+        # set to None if rule_formula (nullable) is None
+        # and __fields_set__ contains the field
+        if self.rule_formula is None and "rule_formula" in self.__fields_set__:
+            _dict['ruleFormula'] = None
+
+        # set to None if severity (nullable) is None
+        # and __fields_set__ contains the field
+        if self.severity is None and "severity" in self.__fields_set__:
+            _dict['severity'] = None
+
+        # set to None if count_rule_breaches (nullable) is None
+        # and __fields_set__ contains the field
+        if self.count_rule_breaches is None and "count_rule_breaches" in self.__fields_set__:
+            _dict['countRuleBreaches'] = None
+
+        # set to None if error_detail (nullable) is None
+        # and __fields_set__ contains the field
+        if self.error_detail is None and "error_detail" in self.__fields_set__:
+            _dict['errorDetail'] = None
+
+        # set to None if result_id (nullable) is None
+        # and __fields_set__ contains the field
+        if self.result_id is None and "result_id" in self.__fields_set__:
+            _dict['resultId'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> DataQualityCheckResult:
+        """Create an instance of DataQualityCheckResult from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return DataQualityCheckResult.parse_obj(obj)
+
+        _obj = DataQualityCheckResult.parse_obj({
+            "check_definition_scope": obj.get("checkDefinitionScope"),
+            "check_definition_code": obj.get("checkDefinitionCode"),
+            "check_definition_display_name": obj.get("checkDefinitionDisplayName"),
+            "check_run_as_at": obj.get("checkRunAsAt"),
+            "result_type": obj.get("resultType"),
+            "rule_set_key": obj.get("ruleSetKey"),
+            "rule_set_display_name": obj.get("ruleSetDisplayName"),
+            "rule_key": obj.get("ruleKey"),
+            "rule_display_name": obj.get("ruleDisplayName"),
+            "rule_description": obj.get("ruleDescription"),
+            "rule_formula": obj.get("ruleFormula"),
+            "severity": obj.get("severity"),
+            "lusid_entity": LusidEntityResult.from_dict(obj.get("lusidEntity")) if obj.get("lusidEntity") is not None else None,
+            "count_rule_breaches": obj.get("countRuleBreaches"),
+            "error_detail": obj.get("errorDetail"),
+            "result_id": obj.get("resultId")
+        })
+        return _obj

lusid/models/derivation_formula_explain_request.py

@@ -26,11 +26,12 @@ class DerivationFormulaExplainRequest(BaseModel):
     DerivationFormulaExplainRequest
     """
     entity_type:  StrictStr = Field(...,alias="entityType", description="The type of the entity for which the derived property or partial formula is to be resolved against.") 
-    scope:  Optional[StrictStr] = Field(None,alias="scope", description="The scope that entity exists in. If no scope is provided, the default scope for the entity type will be used.") 
-    identifier: Optional[Dict[str, StrictStr]] = Field(None, description="An identifier key/value pair that uniquely identifies the entity to explain the derived property for. This can be either an instrument identifier, an identifier property, or a scope/code identifier which take the format {entityType}/default/code : {identifier}. If no identifiers are provided, the logical evaluation tree without resolved values is returned.")
-    property_key:  Optional[StrictStr] = Field(None,alias="propertyKey", description="The key of the derived property to explain. This takes the format {domain}/{scope}/{code}.") 
-    partial_formula:  Optional[StrictStr] = Field(None,alias="partialFormula", description="A partial derivation formula to explain. Can be provided in lieu of a property key.") 
-    __properties = ["entityType", "scope", "identifier", "propertyKey", "partialFormula"]
+    scope:  Optional[StrictStr] = Field(None,alias="scope", description="(Optional) The scope that entity exists in. If no scope is provided, the default scope for the entity type will be used.") 
+    code:  Optional[StrictStr] = Field(None,alias="code", description="(Optional) The code of the entity, to be provided for entities that support scope/code retrieval. If no code or identifier is provided, the logical evaluation tree without resolved values is returned.") 
+    identifier: Optional[Dict[str, StrictStr]] = Field(None, description="(Optional). An identifier key/value pair that uniquely identifies the entity to explain the derived property for. This can be either an instrument identifier, or an identifier property. If no code or identifier is provided, the logical evaluation tree without resolved values is returned.")
+    property_key:  Optional[StrictStr] = Field(None,alias="propertyKey", description="(Optional) The key of the derived property to get an explanation for. This takes the format {domain}/{scope}/{code}. One of either property key or partial formula must be provided.") 
+    partial_formula:  Optional[StrictStr] = Field(None,alias="partialFormula", description="(Optional) A partial derivation formula to get an explanation for. Can be provided in lieu of a property key. One of either property key or partial formula must be provided.") 
+    __properties = ["entityType", "scope", "code", "identifier", "propertyKey", "partialFormula"]
 
     class Config:
         """Pydantic configuration"""
@@ -69,6 +70,11 @@ class DerivationFormulaExplainRequest(BaseModel):
         if self.scope is None and "scope" in self.__fields_set__:
             _dict['scope'] = None
 
+        # set to None if code (nullable) is None
+        # and __fields_set__ contains the field
+        if self.code is None and "code" in self.__fields_set__:
+            _dict['code'] = None
+
         # set to None if identifier (nullable) is None
         # and __fields_set__ contains the field
         if self.identifier is None and "identifier" in self.__fields_set__:
@@ -98,6 +104,7 @@ class DerivationFormulaExplainRequest(BaseModel):
         _obj = DerivationFormulaExplainRequest.parse_obj({
             "entity_type": obj.get("entityType"),
             "scope": obj.get("scope"),
+            "code": obj.get("code"),
             "identifier": obj.get("identifier"),
             "property_key": obj.get("propertyKey"),
             "partial_formula": obj.get("partialFormula")

lusid/models/lusid_entity_dataset.py

@@ -0,0 +1,109 @@
+# coding: utf-8
+
+"""
+    LUSID API
+
+    FINBOURNE Technology  # noqa: E501
+
+    Contact: info@finbourne.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from datetime import datetime
+from typing import Any, Dict, Optional
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, constr, validator 
+
+class LusidEntityDataset(BaseModel):
+    """
+    Contains the run-time parameters that are appropriate for check definitions  with datasetSchema.type = \"LusidEntity\"  # noqa: E501
+    """
+    as_at: Optional[datetime] = Field(None, alias="asAt", description="The asAt date to fetch the data. Nullable. Defaults to latest.")
+    effective_at: Optional[datetime] = Field(None, alias="effectiveAt", description="The effectiveAt date to fetch the data. Nullable. Defaults to latest.")
+    scope:  StrictStr = Field(...,alias="scope", description="The scope of the entities to check. Required.") 
+    as_at_modified_since: Optional[datetime] = Field(None, alias="asAtModifiedSince", description="Nullable. Filters the dataset for version.asAtModified greater than or equal to this value.")
+    selector_attribute:  StrictStr = Field(...,alias="selectorAttribute", description="An attribute (field name, propertyKey or identifierKey) to use to sub-divide the dataset.") 
+    selector_value:  StrictStr = Field(...,alias="selectorValue", description="The value of the above attribute used to sub-divide the dataset.") 
+    return_identifier_key:  Optional[StrictStr] = Field(None,alias="returnIdentifierKey", description="The preferred identifier to return for entities with multiple external identifiers.") 
+    __properties = ["asAt", "effectiveAt", "scope", "asAtModifiedSince", "selectorAttribute", "selectorValue", "returnIdentifierKey"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def __str__(self):
+        """For `print` and `pprint`"""
+        return pprint.pformat(self.dict(by_alias=False))
+
+    def __repr__(self):
+        """For `print` and `pprint`"""
+        return self.to_str()
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.dict(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> LusidEntityDataset:
+        """Create an instance of LusidEntityDataset from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        # set to None if as_at (nullable) is None
+        # and __fields_set__ contains the field
+        if self.as_at is None and "as_at" in self.__fields_set__:
+            _dict['asAt'] = None
+
+        # set to None if effective_at (nullable) is None
+        # and __fields_set__ contains the field
+        if self.effective_at is None and "effective_at" in self.__fields_set__:
+            _dict['effectiveAt'] = None
+
+        # set to None if as_at_modified_since (nullable) is None
+        # and __fields_set__ contains the field
+        if self.as_at_modified_since is None and "as_at_modified_since" in self.__fields_set__:
+            _dict['asAtModifiedSince'] = None
+
+        # set to None if return_identifier_key (nullable) is None
+        # and __fields_set__ contains the field
+        if self.return_identifier_key is None and "return_identifier_key" in self.__fields_set__:
+            _dict['returnIdentifierKey'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> LusidEntityDataset:
+        """Create an instance of LusidEntityDataset from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return LusidEntityDataset.parse_obj(obj)
+
+        _obj = LusidEntityDataset.parse_obj({
+            "as_at": obj.get("asAt"),
+            "effective_at": obj.get("effectiveAt"),
+            "scope": obj.get("scope"),
+            "as_at_modified_since": obj.get("asAtModifiedSince"),
+            "selector_attribute": obj.get("selectorAttribute"),
+            "selector_value": obj.get("selectorValue"),
+            "return_identifier_key": obj.get("returnIdentifierKey")
+        })
+        return _obj

lusid/models/lusid_entity_result.py

@@ -0,0 +1,121 @@
+# coding: utf-8
+
+"""
+    LUSID API
+
+    FINBOURNE Technology  # noqa: E501
+
+    Contact: info@finbourne.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from datetime import datetime
+from typing import Any, Dict, Optional
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictStr 
+
+class LusidEntityResult(BaseModel):
+    """
+    Represents LUSID entity details for a data quality check result  # noqa: E501
+    """
+    as_at: Optional[datetime] = Field(None, alias="asAt", description="The as-at timestamp for the entity")
+    effective_at: Optional[datetime] = Field(None, alias="effectiveAt", description="The effective-at timestamp for the entity")
+    entity_type:  Optional[StrictStr] = Field(None,alias="entityType", description="The type of the LUSID entity") 
+    scope:  Optional[StrictStr] = Field(None,alias="scope", description="The scope of the entity") 
+    identifier_key:  Optional[StrictStr] = Field(None,alias="identifierKey", description="The identifier key for the entity") 
+    identifier_value:  Optional[StrictStr] = Field(None,alias="identifierValue", description="The identifier value for the entity") 
+    entity_unique_id:  Optional[StrictStr] = Field(None,alias="entityUniqueId", description="The unique identifier for the entity") 
+    display_name:  Optional[StrictStr] = Field(None,alias="displayName", description="The display name of the entity") 
+    __properties = ["asAt", "effectiveAt", "entityType", "scope", "identifierKey", "identifierValue", "entityUniqueId", "displayName"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def __str__(self):
+        """For `print` and `pprint`"""
+        return pprint.pformat(self.dict(by_alias=False))
+
+    def __repr__(self):
+        """For `print` and `pprint`"""
+        return self.to_str()
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.dict(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> LusidEntityResult:
+        """Create an instance of LusidEntityResult from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        # set to None if entity_type (nullable) is None
+        # and __fields_set__ contains the field
+        if self.entity_type is None and "entity_type" in self.__fields_set__:
+            _dict['entityType'] = None
+
+        # set to None if scope (nullable) is None
+        # and __fields_set__ contains the field
+        if self.scope is None and "scope" in self.__fields_set__:
+            _dict['scope'] = None
+
+        # set to None if identifier_key (nullable) is None
+        # and __fields_set__ contains the field
+        if self.identifier_key is None and "identifier_key" in self.__fields_set__:
+            _dict['identifierKey'] = None
+
+        # set to None if identifier_value (nullable) is None
+        # and __fields_set__ contains the field
+        if self.identifier_value is None and "identifier_value" in self.__fields_set__:
+            _dict['identifierValue'] = None
+
+        # set to None if entity_unique_id (nullable) is None
+        # and __fields_set__ contains the field
+        if self.entity_unique_id is None and "entity_unique_id" in self.__fields_set__:
+            _dict['entityUniqueId'] = None
+
+        # set to None if display_name (nullable) is None
+        # and __fields_set__ contains the field
+        if self.display_name is None and "display_name" in self.__fields_set__:
+            _dict['displayName'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> LusidEntityResult:
+        """Create an instance of LusidEntityResult from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return LusidEntityResult.parse_obj(obj)
+
+        _obj = LusidEntityResult.parse_obj({
+            "as_at": obj.get("asAt"),
+            "effective_at": obj.get("effectiveAt"),
+            "entity_type": obj.get("entityType"),
+            "scope": obj.get("scope"),
+            "identifier_key": obj.get("identifierKey"),
+            "identifier_value": obj.get("identifierValue"),
+            "entity_unique_id": obj.get("entityUniqueId"),
+            "display_name": obj.get("displayName")
+        })
+        return _obj

lusid/models/run_check_request.py

@@ -0,0 +1,83 @@
+# coding: utf-8
+
+"""
+    LUSID API
+
+    FINBOURNE Technology  # noqa: E501
+
+    Contact: info@finbourne.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+
+from typing import Any, Dict, Optional
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictInt 
+from lusid.models.lusid_entity_dataset import LusidEntityDataset
+
+class RunCheckRequest(BaseModel):
+    """
+    RunCheckRequest
+    """
+    lusid_entity_dataset: Optional[LusidEntityDataset] = Field(None, alias="lusidEntityDataset")
+    limit_individual_breaches_per_rule: Optional[StrictInt] = Field(None, alias="limitIndividualBreachesPerRule", description="The maximum number of individual breaches to return per rule. Defaults to 100 if not specified.")
+    __properties = ["lusidEntityDataset", "limitIndividualBreachesPerRule"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def __str__(self):
+        """For `print` and `pprint`"""
+        return pprint.pformat(self.dict(by_alias=False))
+
+    def __repr__(self):
+        """For `print` and `pprint`"""
+        return self.to_str()
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.dict(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> RunCheckRequest:
+        """Create an instance of RunCheckRequest from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        # override the default output from pydantic by calling `to_dict()` of lusid_entity_dataset
+        if self.lusid_entity_dataset:
+            _dict['lusidEntityDataset'] = self.lusid_entity_dataset.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> RunCheckRequest:
+        """Create an instance of RunCheckRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return RunCheckRequest.parse_obj(obj)
+
+        _obj = RunCheckRequest.parse_obj({
+            "lusid_entity_dataset": LusidEntityDataset.from_dict(obj.get("lusidEntityDataset")) if obj.get("lusidEntityDataset") is not None else None,
+            "limit_individual_breaches_per_rule": obj.get("limitIndividualBreachesPerRule")
+        })
+        return _obj

lusid/models/run_check_response.py

@@ -0,0 +1,90 @@
+# coding: utf-8
+
+"""
+    LUSID API
+
+    FINBOURNE Technology  # noqa: E501
+
+    Contact: info@finbourne.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+
+from typing import Any, Dict, List, Optional
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, conlist 
+from lusid.models.data_quality_check_result import DataQualityCheckResult
+
+class RunCheckResponse(BaseModel):
+    """
+    Response containing the results of running data quality checks  # noqa: E501
+    """
+    data_quality_check_results: Optional[conlist(DataQualityCheckResult)] = Field(None, alias="dataQualityCheckResults", description="Collection of data quality check results")
+    __properties = ["dataQualityCheckResults"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def __str__(self):
+        """For `print` and `pprint`"""
+        return pprint.pformat(self.dict(by_alias=False))
+
+    def __repr__(self):
+        """For `print` and `pprint`"""
+        return self.to_str()
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.dict(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> RunCheckResponse:
+        """Create an instance of RunCheckResponse from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        # override the default output from pydantic by calling `to_dict()` of each item in data_quality_check_results (list)
+        _items = []
+        if self.data_quality_check_results:
+            for _item in self.data_quality_check_results:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['dataQualityCheckResults'] = _items
+        # set to None if data_quality_check_results (nullable) is None
+        # and __fields_set__ contains the field
+        if self.data_quality_check_results is None and "data_quality_check_results" in self.__fields_set__:
+            _dict['dataQualityCheckResults'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> RunCheckResponse:
+        """Create an instance of RunCheckResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return RunCheckResponse.parse_obj(obj)
+
+        _obj = RunCheckResponse.parse_obj({
+            "data_quality_check_results": [DataQualityCheckResult.from_dict(_item) for _item in obj.get("dataQualityCheckResults")] if obj.get("dataQualityCheckResults") is not None else None
+        })
+        return _obj

{lusid_sdk-2.1.983.dist-info → lusid_sdk-2.1.984.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lusid-sdk
-Version: 2.1.983
+Version: 2.1.984
 Summary: LUSID API
 Home-page: https://github.com/finbourne/lusid-sdk-python
 License: MIT
@@ -134,6 +134,7 @@ Class | Method | HTTP request | Description
 *CheckDefinitionsApi* | [**delete_check_definition**](docs/CheckDefinitionsApi.md#delete_check_definition) | **DELETE** /api/dataquality/checkdefinitions/{scope}/{code} | [EXPERIMENTAL] DeleteCheckDefinition: Deletes a particular Check Definition
 *CheckDefinitionsApi* | [**get_check_definition**](docs/CheckDefinitionsApi.md#get_check_definition) | **GET** /api/dataquality/checkdefinitions/{scope}/{code} | [EXPERIMENTAL] GetCheckDefinition: Get a single Check Definition by scope and code.
 *CheckDefinitionsApi* | [**list_check_definitions**](docs/CheckDefinitionsApi.md#list_check_definitions) | **GET** /api/dataquality/checkdefinitions | [EXPERIMENTAL] ListCheckDefinitions: List Check Definitions
+*CheckDefinitionsApi* | [**run_check_definition**](docs/CheckDefinitionsApi.md#run_check_definition) | **PUT** /api/dataquality/checkdefinitions/{scope}/{code}/$run | [EXPERIMENTAL] RunCheckDefinition: Runs a Check Definition against given dataset.
 *CheckDefinitionsApi* | [**update_check_definition**](docs/CheckDefinitionsApi.md#update_check_definition) | **PUT** /api/dataquality/checkdefinitions/{scope}/{code} | [EXPERIMENTAL] UpdateCheckDefinition: Update Check Definition defined by scope and code
 *ComplexMarketDataApi* | [**delete_complex_market_data**](docs/ComplexMarketDataApi.md#delete_complex_market_data) | **POST** /api/complexmarketdata/{scope}/$delete | DeleteComplexMarketData: Delete one or more items of complex market data, assuming they are present.
 *ComplexMarketDataApi* | [**get_complex_market_data**](docs/ComplexMarketDataApi.md#get_complex_market_data) | **POST** /api/complexmarketdata/{scope}/$get | GetComplexMarketData: Get complex market data
@@ -1003,6 +1004,7 @@ Class | Method | HTTP request | Description
  - [DataMapping](docs/DataMapping.md)
  - [DataModelMembership](docs/DataModelMembership.md)
  - [DataModelSummary](docs/DataModelSummary.md)
+ - [DataQualityCheckResult](docs/DataQualityCheckResult.md)
  - [DataScope](docs/DataScope.md)
  - [DataType](docs/DataType.md)
  - [DataTypeEntity](docs/DataTypeEntity.md)
@@ -1305,6 +1307,8 @@ Class | Method | HTTP request | Description
  - [LoanPeriod](docs/LoanPeriod.md)
  - [LoanPrincipalRepaymentEvent](docs/LoanPrincipalRepaymentEvent.md)
  - [LockPeriodDiaryEntryRequest](docs/LockPeriodDiaryEntryRequest.md)
+ - [LusidEntityDataset](docs/LusidEntityDataset.md)
+ - [LusidEntityResult](docs/LusidEntityResult.md)
  - [LusidInstrument](docs/LusidInstrument.md)
  - [LusidProblemDetails](docs/LusidProblemDetails.md)
  - [LusidTradeTicket](docs/LusidTradeTicket.md)
@@ -1719,6 +1723,8 @@ Class | Method | HTTP request | Description
  - [RoundingConfigurationComponent](docs/RoundingConfigurationComponent.md)
  - [RoundingConvention](docs/RoundingConvention.md)
  - [RulesInterval](docs/RulesInterval.md)
+ - [RunCheckRequest](docs/RunCheckRequest.md)
+ - [RunCheckResponse](docs/RunCheckResponse.md)
  - [ScalingMethodology](docs/ScalingMethodology.md)
  - [Schedule](docs/Schedule.md)
  - [ScheduleType](docs/ScheduleType.md)

{lusid_sdk-2.1.983.dist-info → lusid_sdk-2.1.984.dist-info}/RECORD

@@ -1,4 +1,4 @@
-lusid/__init__.py,sha256=7jMeT4MnqKaDCaHGTuADcb6mDXE0QE1V2SSlJn_ZF4k,147489
+lusid/__init__.py,sha256=EbQBMkuCMi064zl-N5pXaMvvKrVtj1dAu1IqXZn_D9o,147939
 lusid/api/__init__.py,sha256=yCGwgeQBZ1RZovOUo7Jq24Txz4o6naRgnWAzQVGdHAk,6784
 lusid/api/abor_api.py,sha256=EdyHrd5yRcz7MOffhFa1cgtcBaPuPJmbArHWIXv7tuQ,174322
 lusid/api/abor_configuration_api.py,sha256=xQ9HcXm02eDFhCdWUHjqFRWl1oQMxm2LNObJ9kcLauU,84216
@@ -11,7 +11,7 @@ lusid/api/application_metadata_api.py,sha256=GdueWnWdBjIhbyb6gfBgLYqQ7_UerR0J68T
 lusid/api/blocks_api.py,sha256=WvkS7tK4jY1R_SWV8FqjCr5zpF9Gx1basp62FBdyH_E,43230
 lusid/api/calendars_api.py,sha256=Z1Zo2PDggpII8e6DyKlun1EZkCqU0I9MtqTsKfu5buI,141755
 lusid/api/chart_of_accounts_api.py,sha256=cyLfNKPJpBuy61U1HqVGNh1bmwAoTDpaIGQ1SeuMU-I,404270
-lusid/api/check_definitions_api.py,sha256=zw7_DW1YE54fudySGCKA-xchihCFleCZXlyum3dlllg,61393
+lusid/api/check_definitions_api.py,sha256=TpMePfYFXB8NiUQYlqy7SWFIS-7ofxPGo3B97-Skg0U,70425
 lusid/api/complex_market_data_api.py,sha256=kNH08g5rGYAMg7srkVhhqjzQ8oICqiTPFZJcFOV84EA,64940
 lusid/api/compliance_api.py,sha256=zVn3TuZ97PqKKh-b666fHgs3mfVcDD9nELX7zTTsdz0,161480
 lusid/api/configuration_recipe_api.py,sha256=1hdNB1imRjVzf8KAmqnNJE10jv883s1SCza5dl8fP9Q,99363
@@ -80,7 +80,7 @@ lusid/api/translation_api.py,sha256=xpRuTfwQvYBlWe6r_L2EI_uVpXqHFnEOim-i-kVQ85E,
 lusid/api/workspace_api.py,sha256=0pCNi3ZCRbIo0NXKa85XE7vtq0WV5YOKcQKvFlcLUaY,120708
 lusid/api_client.py,sha256=ewMTmf9SRurY8pYnUx9jy24RdldPCOa4US38pnrVxjA,31140
 lusid/api_response.py,sha256=6-gnhty6lu8MMAERt3_kTVD7UxQgWFfcjgpcq6iN5IU,855
-lusid/configuration.py,sha256=JMW3IaI4FuEEWzp0n8UHeDU5tpigS-0Zo7py9j3y9G0,17980
+lusid/configuration.py,sha256=yBlr_BYRXWOXRFy-tBqJGI5P1p_C-MHvJtQ5KbBf9jE,17980
 lusid/exceptions.py,sha256=HIQwgmQrszLlcVCLaqex8dO0laVuejUyOMz7U2ZWJ6s,5326
 lusid/extensions/__init__.py,sha256=dzDHEzpn-9smd2-_UMWQzeyX6Ha4jGf6fnqx7qxKxNI,630
 lusid/extensions/api_client.py,sha256=GzygWg_h603QK1QS2HvAijuE2R1TnvoF6-Yg0CeM3ug,30943
@@ -95,7 +95,7 @@ lusid/extensions/rest.py,sha256=dp-bD_LMR2zAL1tmC3-urhWKLomXx7r5iGN1VteMBVQ,1601
 lusid/extensions/retry.py,sha256=EhW9OKJmGHipxN3H7eROH5DiMlAnfBVl95NQrttcsdg,14834
 lusid/extensions/socket_keep_alive.py,sha256=eX5ICvGfVzUCGIm80Q2RknfFZrBQAdnrcpY61M29V_k,1997
 lusid/extensions/tcp_keep_alive_connector.py,sha256=zaGtUsygRsxB1_4B3x39K3ILwztdhMLDv5bFZV7zmGE,3877
-lusid/models/__init__.py,sha256=ZTmJc1-mETQ0J9F39X7ggKOGs_q3niYo-Z1I0f8Kxko,139673
+lusid/models/__init__.py,sha256=9umlLCsRnEkWYXQjro550_MXVFVFbKEMwPzObwIt5HY,140123
 lusid/models/a2_b_breakdown.py,sha256=-FXgILrvtZXQDmvS0ARaJVGBq5LJ4AH-o3HjujFVmS4,3198
 lusid/models/a2_b_category.py,sha256=WunXUgx-dCnApPeLC8Qo5tVCX8Ywxkehib1vmNqNgNs,2957
 lusid/models/a2_b_data_record.py,sha256=qANTmV1_HUEo4l72-F8qzZjlQxOe0Onc9WPz7h-WWuY,9993
@@ -404,6 +404,7 @@ lusid/models/data_map_key.py,sha256=Gxe4xysNghZtf5G9d6ROkGF1tJiV5DwjsyGqD-undvI,
 lusid/models/data_mapping.py,sha256=xRTIttedYFaOM3uEOkMoNWUO5wd28igV-FeRmSI_WL8,3869
 lusid/models/data_model_membership.py,sha256=LFZAVhRrWOLM6wCvVKSiao4oAiLQuKRT7Tb9nmZjGYw,3143
 lusid/models/data_model_summary.py,sha256=UpqSS7hmnQI-53Ie8a8EB_Naj3SJI5-lJAYJINDump0,4103
+lusid/models/data_quality_check_result.py,sha256=TFqBfAbOJ8FzbC5yuDOIXvAJwVZI-zBoEonuTcmr1c0,9348
 lusid/models/data_scope.py,sha256=YPqqE1B6oL7uqqx0YohrqqiQhMYBBT3GsSjo-l4qUdE,2579
 lusid/models/data_type.py,sha256=XYLnShK3ZT6EajnWw41dqrmABir6IaDqOaaRd8YEPB4,17901
 lusid/models/data_type_entity.py,sha256=eVjZ1fRZMwjY0WSM7LBQPjJ8CJpCHU53xkbsFGIWRck,7612
@@ -433,7 +434,7 @@ lusid/models/deleted_entity_response.py,sha256=B11ZEZwBxb_PLgbykXdBdLo6Iu6O8Otzq
 lusid/models/dependency_source_filter.py,sha256=4GKl5zFqKpWH4ob8beEW7AgSQ97NffrxUXVeRZZU8ec,5939
 lusid/models/deposit_close_event.py,sha256=XSLQbANRq2ADWjZ9N4tkxBlMd4RHQHaOQg16OTpbs8o,11341
 lusid/models/deposit_interest_payment_event.py,sha256=7gxsFwx1inGEEwSy0UGNoNxobTg67GASgoM8if031fw,11782
-lusid/models/derivation_formula_explain_request.py,sha256=p7eflm_24FSlekRFQrYn2mbkYg07Mdxvg_XfqvRF0vg,4481
+lusid/models/derivation_formula_explain_request.py,sha256=aLS9Xf9GQ_GFRw3gdoMQJNDGhNyEYoYczTBJyzXQ4wE,5117
 lusid/models/derived_property_component.py,sha256=ZGFCCt8fCprTvEoCWk-A8zsmHndZCf757kQyOI2xuf0,5490
 lusid/models/described_address_key.py,sha256=UHxYHgYe3uM-6rQSTCzeEqft0ngze4TdCc-JesxCp_I,2932
 lusid/models/dialect.py,sha256=oiXWtrDKwEoOa9yGObMfDLhH0QlJAaKOgCRraDYiim0,3227
@@ -706,6 +707,8 @@ lusid/models/loan_interest_repayment_event.py,sha256=uA3m7fBv5OjVDgn_IVrQyZ10Rgg
 lusid/models/loan_period.py,sha256=aYoZLiXQRkjj0DWmXs4ihxHUxYW7Nc0-mfkFaSBAE4k,2383
 lusid/models/loan_principal_repayment_event.py,sha256=KLplsHpXj5CSi8jXWe-0ooEMfcqG-iGZXFgkdQBJ_Dg,13770
 lusid/models/lock_period_diary_entry_request.py,sha256=pqJQGtnL8Oy8WJ1St3QgA5HhESmvrunFPeBZ0fP9O3I,3126
+lusid/models/lusid_entity_dataset.py,sha256=liQjIxxpwWPoOosVGiuQjd0GylhpgiEkXPsYHHU9Vmg,4706
+lusid/models/lusid_entity_result.py,sha256=FcDEYQ-VyYsnfruavcwVwL8jxsQKURt9wfRAsPTr3ys,4934
 lusid/models/lusid_instrument.py,sha256=d_wmtAY5dtD8vEaAoAjKtmAryC3W_7N03oENYjs7Ba0,11448
 lusid/models/lusid_problem_details.py,sha256=BkzYYV7IX1vrdC8TZNika8RBXHp0s5HIUgq-Jh2Ohd0,4162
 lusid/models/lusid_trade_ticket.py,sha256=CLvRuxyzxlMC9Lc4fS0She-41iMedrIIEsN7DiYtS_o,12704
@@ -1120,6 +1123,8 @@ lusid/models/rounding_configuration.py,sha256=omjrizntdNApbrOAlN-a1b3n8Y4tOwY_PR
 lusid/models/rounding_configuration_component.py,sha256=UTD9vmAJSHzBsxG3YIpaJwVM1Gscf5zKh_-untK-Sg8,2320
 lusid/models/rounding_convention.py,sha256=x_rQcvmU6IWuTAibUPKP_izyiV6FU601X5EaUKHrb18,4299
 lusid/models/rules_interval.py,sha256=Bs3nL2xYdaaINdFZesQ0mfce5MeA95ose8aItQdCi1w,3003
+lusid/models/run_check_request.py,sha256=SteXDIntK3B27Ud85f2XSQq3thbt8zVjqvOmtdfzK2k,2881
+lusid/models/run_check_response.py,sha256=TUgY8poUxJPa9yEi8S2MF2AKu07a-0CRBCSYXIDbJiE,3179
 lusid/models/scaling_methodology.py,sha256=rP8s-CkaG3rZGG9E9MxCJu3NzbKKool_r_fB-DxMlg0,699
 lusid/models/schedule.py,sha256=cqHH_wfTBW4TXCab7IUf4Bs3GbGLyGQuoo2KTBMbKWE,7563
 lusid/models/schedule_type.py,sha256=hdAqhI4A6L1z-Ipwd2xaecMiTCFqRN1Bz1Lc2BWXZTg,955
@@ -1395,6 +1400,6 @@ lusid/models/year_month_day.py,sha256=gwSoxFwlD_wffKdddo1wfvAcLq3Cht3FHQidiaHzAA
 lusid/models/yield_curve_data.py,sha256=sifVmM0PAAB9wfI3aKf4dLbZS45bqiRv9ffZxQx7JRU,9663
 lusid/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lusid/rest.py,sha256=HQT__5LQEMu6_1sLKvYj-DI4FH1DJXBIPYfZCTTyrY4,13431
-lusid_sdk-2.1.983.dist-info/METADATA,sha256=Me8g8DKYV8Ju_E0Uy1GqhY4rLGlmE41Gp3kdiAqXMMk,234533
-lusid_sdk-2.1.983.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-lusid_sdk-2.1.983.dist-info/RECORD,,
+lusid_sdk-2.1.984.dist-info/METADATA,sha256=wFhlUclppwT3BuRXQS4zwa4me2geJRe6FFp7ry9XKt0,235038
+lusid_sdk-2.1.984.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+lusid_sdk-2.1.984.dist-info/RECORD,,