lusid-sdk 2.1.81__py3-none-any.whl → 2.1.92__py3-none-any.whl

lusid/models/staged_modification.py

@@ -0,0 +1,160 @@
+# 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, List, Optional
+from pydantic.v1 import BaseModel, Field, StrictInt, StrictStr, conlist
+from lusid.models.requested_changes import RequestedChanges
+from lusid.models.staged_modification_decision import StagedModificationDecision
+from lusid.models.staged_modification_staging_rule import StagedModificationStagingRule
+from lusid.models.staged_modifications_entity_hrefs import StagedModificationsEntityHrefs
+
+class StagedModification(BaseModel):
+    """
+    StagedModification
+    """
+    id: Optional[StrictStr] = Field(None, description="The unique Id for the staged modification")
+    as_at_staged: Optional[datetime] = Field(None, alias="asAtStaged", description="Time at which the modification was staged.")
+    user_id_staged: Optional[StrictStr] = Field(None, alias="userIdStaged", description="Id of the user who created the stage modification request.")
+    requested_id_staged: Optional[StrictStr] = Field(None, alias="requestedIdStaged", description="The Request Id that initiated this staged modification.")
+    action: Optional[StrictStr] = Field(None, description="Type of action of the staged modification, either create, update or delete.")
+    staging_rule: Optional[StagedModificationStagingRule] = Field(None, alias="stagingRule")
+    decisions: Optional[conlist(StagedModificationDecision)] = Field(None, description="Object containing information relating to the decision on the staged modification.")
+    decisions_count: Optional[StrictInt] = Field(None, alias="decisionsCount", description="Number of decisions made.")
+    status: Optional[StrictStr] = Field(None, description="The status of the staged modification.")
+    entity_type: Optional[StrictStr] = Field(None, alias="entityType", description="The type of the entity that the staged modification applies to.")
+    scope: Optional[StrictStr] = Field(None, description="The scope of the entity that this staged modification applies to.")
+    entity_unique_id: Optional[StrictStr] = Field(None, alias="entityUniqueId", description="The unique Id of the entity the staged modification applies to.")
+    requested_changes: Optional[RequestedChanges] = Field(None, alias="requestedChanges")
+    entity_hrefs: Optional[StagedModificationsEntityHrefs] = Field(None, alias="entityHrefs")
+    __properties = ["id", "asAtStaged", "userIdStaged", "requestedIdStaged", "action", "stagingRule", "decisions", "decisionsCount", "status", "entityType", "scope", "entityUniqueId", "requestedChanges", "entityHrefs"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    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) -> StagedModification:
+        """Create an instance of StagedModification 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 staging_rule
+        if self.staging_rule:
+            _dict['stagingRule'] = self.staging_rule.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in decisions (list)
+        _items = []
+        if self.decisions:
+            for _item in self.decisions:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['decisions'] = _items
+        # override the default output from pydantic by calling `to_dict()` of requested_changes
+        if self.requested_changes:
+            _dict['requestedChanges'] = self.requested_changes.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of entity_hrefs
+        if self.entity_hrefs:
+            _dict['entityHrefs'] = self.entity_hrefs.to_dict()
+        # set to None if id (nullable) is None
+        # and __fields_set__ contains the field
+        if self.id is None and "id" in self.__fields_set__:
+            _dict['id'] = None
+
+        # set to None if user_id_staged (nullable) is None
+        # and __fields_set__ contains the field
+        if self.user_id_staged is None and "user_id_staged" in self.__fields_set__:
+            _dict['userIdStaged'] = None
+
+        # set to None if requested_id_staged (nullable) is None
+        # and __fields_set__ contains the field
+        if self.requested_id_staged is None and "requested_id_staged" in self.__fields_set__:
+            _dict['requestedIdStaged'] = None
+
+        # set to None if action (nullable) is None
+        # and __fields_set__ contains the field
+        if self.action is None and "action" in self.__fields_set__:
+            _dict['action'] = None
+
+        # set to None if decisions (nullable) is None
+        # and __fields_set__ contains the field
+        if self.decisions is None and "decisions" in self.__fields_set__:
+            _dict['decisions'] = None
+
+        # set to None if status (nullable) is None
+        # and __fields_set__ contains the field
+        if self.status is None and "status" in self.__fields_set__:
+            _dict['status'] = None
+
+        # 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 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
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> StagedModification:
+        """Create an instance of StagedModification from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return StagedModification.parse_obj(obj)
+
+        _obj = StagedModification.parse_obj({
+            "id": obj.get("id"),
+            "as_at_staged": obj.get("asAtStaged"),
+            "user_id_staged": obj.get("userIdStaged"),
+            "requested_id_staged": obj.get("requestedIdStaged"),
+            "action": obj.get("action"),
+            "staging_rule": StagedModificationStagingRule.from_dict(obj.get("stagingRule")) if obj.get("stagingRule") is not None else None,
+            "decisions": [StagedModificationDecision.from_dict(_item) for _item in obj.get("decisions")] if obj.get("decisions") is not None else None,
+            "decisions_count": obj.get("decisionsCount"),
+            "status": obj.get("status"),
+            "entity_type": obj.get("entityType"),
+            "scope": obj.get("scope"),
+            "entity_unique_id": obj.get("entityUniqueId"),
+            "requested_changes": RequestedChanges.from_dict(obj.get("requestedChanges")) if obj.get("requestedChanges") is not None else None,
+            "entity_hrefs": StagedModificationsEntityHrefs.from_dict(obj.get("entityHrefs")) if obj.get("entityHrefs") is not None else None
+        })
+        return _obj

lusid/models/staged_modification_decision.py

@@ -0,0 +1,97 @@
+# 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 BaseModel, Field, StrictStr
+
+class StagedModificationDecision(BaseModel):
+    """
+    StagedModificationDecision
+    """
+    as_at: Optional[datetime] = Field(None, alias="asAt", description="Time the decision request is made.")
+    user_id: Optional[StrictStr] = Field(None, alias="userId", description="ID of user that approved the request.")
+    request_id: Optional[StrictStr] = Field(None, alias="requestId", description="ID of user that made the request.")
+    decision: Optional[StrictStr] = Field(None, description="The decision on the requested staged modification, can be 'Approve' or 'Reject'.")
+    comment: Optional[StrictStr] = Field(None, description="Comment on decision.")
+    __properties = ["asAt", "userId", "requestId", "decision", "comment"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    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) -> StagedModificationDecision:
+        """Create an instance of StagedModificationDecision 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 user_id (nullable) is None
+        # and __fields_set__ contains the field
+        if self.user_id is None and "user_id" in self.__fields_set__:
+            _dict['userId'] = None
+
+        # set to None if request_id (nullable) is None
+        # and __fields_set__ contains the field
+        if self.request_id is None and "request_id" in self.__fields_set__:
+            _dict['requestId'] = None
+
+        # set to None if decision (nullable) is None
+        # and __fields_set__ contains the field
+        if self.decision is None and "decision" in self.__fields_set__:
+            _dict['decision'] = None
+
+        # set to None if comment (nullable) is None
+        # and __fields_set__ contains the field
+        if self.comment is None and "comment" in self.__fields_set__:
+            _dict['comment'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> StagedModificationDecision:
+        """Create an instance of StagedModificationDecision from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return StagedModificationDecision.parse_obj(obj)
+
+        _obj = StagedModificationDecision.parse_obj({
+            "as_at": obj.get("asAt"),
+            "user_id": obj.get("userId"),
+            "request_id": obj.get("requestId"),
+            "decision": obj.get("decision"),
+            "comment": obj.get("comment")
+        })
+        return _obj

lusid/models/staged_modification_decision_request.py

@@ -0,0 +1,71 @@
+# 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
+from pydantic.v1 import BaseModel, Field, constr
+
+class StagedModificationDecisionRequest(BaseModel):
+    """
+    StagedModificationDecisionRequest
+    """
+    decision: constr(strict=True, min_length=1) = Field(..., description="The decision on the requested staged modification, can be 'Approve' or 'Reject'.")
+    comment: constr(strict=True, max_length=256, min_length=1) = Field(..., description="Comment on decision.")
+    __properties = ["decision", "comment"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    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) -> StagedModificationDecisionRequest:
+        """Create an instance of StagedModificationDecisionRequest 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)
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> StagedModificationDecisionRequest:
+        """Create an instance of StagedModificationDecisionRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return StagedModificationDecisionRequest.parse_obj(obj)
+
+        _obj = StagedModificationDecisionRequest.parse_obj({
+            "decision": obj.get("decision"),
+            "comment": obj.get("comment")
+        })
+        return _obj

lusid/models/staged_modification_effective_range.py

@@ -0,0 +1,71 @@
+# 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 BaseModel, Field
+
+class StagedModificationEffectiveRange(BaseModel):
+    """
+    StagedModificationEffectiveRange
+    """
+    from_date: Optional[datetime] = Field(None, alias="fromDate", description="Time the decision request is made.")
+    until_date: Optional[datetime] = Field(None, alias="untilDate", description="ID of user that approved the request.")
+    __properties = ["fromDate", "untilDate"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    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) -> StagedModificationEffectiveRange:
+        """Create an instance of StagedModificationEffectiveRange 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)
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> StagedModificationEffectiveRange:
+        """Create an instance of StagedModificationEffectiveRange from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return StagedModificationEffectiveRange.parse_obj(obj)
+
+        _obj = StagedModificationEffectiveRange.parse_obj({
+            "from_date": obj.get("fromDate"),
+            "until_date": obj.get("untilDate")
+        })
+        return _obj

lusid/models/staged_modification_staging_rule.py

@@ -0,0 +1,85 @@
+# 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 BaseModel, Field, StrictBool, StrictInt, StrictStr
+
+class StagedModificationStagingRule(BaseModel):
+    """
+    StagedModificationStagingRule
+    """
+    staging_rule_set_id: Optional[StrictStr] = Field(None, alias="stagingRuleSetId", description="System generated unique id for the staging rule set.")
+    rule_id: Optional[StrictStr] = Field(None, alias="ruleId", description="The ID of the staging rule.")
+    required_approvals: Optional[StrictInt] = Field(None, alias="requiredApprovals", description="The number of approvals required. If left blank, one approval is needed.")
+    current_user_can_decide: Optional[StrictBool] = Field(None, alias="currentUserCanDecide", description="True or False indicating whether the current user can make a decision on the staged modification.")
+    __properties = ["stagingRuleSetId", "ruleId", "requiredApprovals", "currentUserCanDecide"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    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) -> StagedModificationStagingRule:
+        """Create an instance of StagedModificationStagingRule 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 staging_rule_set_id (nullable) is None
+        # and __fields_set__ contains the field
+        if self.staging_rule_set_id is None and "staging_rule_set_id" in self.__fields_set__:
+            _dict['stagingRuleSetId'] = None
+
+        # set to None if rule_id (nullable) is None
+        # and __fields_set__ contains the field
+        if self.rule_id is None and "rule_id" in self.__fields_set__:
+            _dict['ruleId'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> StagedModificationStagingRule:
+        """Create an instance of StagedModificationStagingRule from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return StagedModificationStagingRule.parse_obj(obj)
+
+        _obj = StagedModificationStagingRule.parse_obj({
+            "staging_rule_set_id": obj.get("stagingRuleSetId"),
+            "rule_id": obj.get("ruleId"),
+            "required_approvals": obj.get("requiredApprovals"),
+            "current_user_can_decide": obj.get("currentUserCanDecide")
+        })
+        return _obj

lusid/models/staged_modifications_entity_hrefs.py

@@ -0,0 +1,88 @@
+# 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 BaseModel, Field, StrictStr
+
+class StagedModificationsEntityHrefs(BaseModel):
+    """
+    StagedModificationsEntityHrefs
+    """
+    when_staged: Optional[StrictStr] = Field(None, alias="whenStaged", description="The specific Uniform Resource Identifier (URI) for the staged modification change at the time when the change was requested.")
+    preview: Optional[StrictStr] = Field(None, description="The specific Uniform Resource Identifier (URI) for the preview of staged modification change once applied.")
+    latest: Optional[StrictStr] = Field(None, description="The specific Uniform Resource Identifier (URI) for the staged modification at latest time.")
+    __properties = ["whenStaged", "preview", "latest"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    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) -> StagedModificationsEntityHrefs:
+        """Create an instance of StagedModificationsEntityHrefs 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 when_staged (nullable) is None
+        # and __fields_set__ contains the field
+        if self.when_staged is None and "when_staged" in self.__fields_set__:
+            _dict['whenStaged'] = None
+
+        # set to None if preview (nullable) is None
+        # and __fields_set__ contains the field
+        if self.preview is None and "preview" in self.__fields_set__:
+            _dict['preview'] = None
+
+        # set to None if latest (nullable) is None
+        # and __fields_set__ contains the field
+        if self.latest is None and "latest" in self.__fields_set__:
+            _dict['latest'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> StagedModificationsEntityHrefs:
+        """Create an instance of StagedModificationsEntityHrefs from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return StagedModificationsEntityHrefs.parse_obj(obj)
+
+        _obj = StagedModificationsEntityHrefs.parse_obj({
+            "when_staged": obj.get("whenStaged"),
+            "preview": obj.get("preview"),
+            "latest": obj.get("latest")
+        })
+        return _obj

lusid/models/staged_modifications_info.py

@@ -0,0 +1,78 @@
+# 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 BaseModel, Field, StrictInt, StrictStr, conlist
+
+class StagedModificationsInfo(BaseModel):
+    """
+    The staged modifications metadata.  # noqa: E501
+    """
+    count_pending: StrictInt = Field(..., alias="countPending", description="The number of staged modifications for the entity with a status of Pending for the requested asAt.")
+    href_pending: StrictStr = Field(..., alias="hrefPending", description="Link to the list staged modifications endpoint, filtered by entityType, entityUniqueId and status (= Pending).")
+    ids_previewed: Optional[conlist(StrictStr)] = Field(None, alias="idsPreviewed", description="An array of the ids of any StagedModifications being previewed.")
+    __properties = ["countPending", "hrefPending", "idsPreviewed"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    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) -> StagedModificationsInfo:
+        """Create an instance of StagedModificationsInfo 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 ids_previewed (nullable) is None
+        # and __fields_set__ contains the field
+        if self.ids_previewed is None and "ids_previewed" in self.__fields_set__:
+            _dict['idsPreviewed'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> StagedModificationsInfo:
+        """Create an instance of StagedModificationsInfo from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return StagedModificationsInfo.parse_obj(obj)
+
+        _obj = StagedModificationsInfo.parse_obj({
+            "count_pending": obj.get("countPending"),
+            "href_pending": obj.get("hrefPending"),
+            "ids_previewed": obj.get("idsPreviewed")
+        })
+        return _obj