lusid-sdk 2.1.874__py3-none-any.whl → 2.1.876__py3-none-any.whl

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.8052\n"\
+               "Version of the API: 0.11.8058\n"\
                "SDK Package Version: {package_version}".\
                format(env=sys.platform, pyversion=sys.version, package_version=package_version)
 

lusid/models/__init__.py

@@ -268,6 +268,7 @@ from lusid.models.create_reconciliation_request import CreateReconciliationReque
 from lusid.models.create_reference_portfolio_request import CreateReferencePortfolioRequest
 from lusid.models.create_relation_definition_request import CreateRelationDefinitionRequest
 from lusid.models.create_relation_request import CreateRelationRequest
+from lusid.models.create_relational_dataset_definition_request import CreateRelationalDatasetDefinitionRequest
 from lusid.models.create_relationship_definition_request import CreateRelationshipDefinitionRequest
 from lusid.models.create_relationship_request import CreateRelationshipRequest
 from lusid.models.create_sequence_request import CreateSequenceRequest
@@ -761,6 +762,7 @@ from lusid.models.paged_resource_list_of_property_definition import PagedResourc
 from lusid.models.paged_resource_list_of_property_definition_search_result import PagedResourceListOfPropertyDefinitionSearchResult
 from lusid.models.paged_resource_list_of_reconciliation import PagedResourceListOfReconciliation
 from lusid.models.paged_resource_list_of_reference_list_response import PagedResourceListOfReferenceListResponse
+from lusid.models.paged_resource_list_of_relational_dataset_definition import PagedResourceListOfRelationalDatasetDefinition
 from lusid.models.paged_resource_list_of_relationship_definition import PagedResourceListOfRelationshipDefinition
 from lusid.models.paged_resource_list_of_sequence_definition import PagedResourceListOfSequenceDefinition
 from lusid.models.paged_resource_list_of_staged_modification import PagedResourceListOfStagedModification
@@ -905,6 +907,8 @@ from lusid.models.reference_portfolio_weight_type import ReferencePortfolioWeigh
 from lusid.models.related_entity import RelatedEntity
 from lusid.models.relation import Relation
 from lusid.models.relation_definition import RelationDefinition
+from lusid.models.relational_dataset_definition import RelationalDatasetDefinition
+from lusid.models.relational_dataset_field_definition import RelationalDatasetFieldDefinition
 from lusid.models.relationship import Relationship
 from lusid.models.relationship_definition import RelationshipDefinition
 from lusid.models.relative_date_offset import RelativeDateOffset
@@ -1169,6 +1173,7 @@ from lusid.models.update_portfolio_request import UpdatePortfolioRequest
 from lusid.models.update_property_definition_request import UpdatePropertyDefinitionRequest
 from lusid.models.update_reconciliation_request import UpdateReconciliationRequest
 from lusid.models.update_reference_data_request import UpdateReferenceDataRequest
+from lusid.models.update_relational_dataset_definition_request import UpdateRelationalDatasetDefinitionRequest
 from lusid.models.update_relationship_definition_request import UpdateRelationshipDefinitionRequest
 from lusid.models.update_staging_rule_set_request import UpdateStagingRuleSetRequest
 from lusid.models.update_tax_rule_set_request import UpdateTaxRuleSetRequest
@@ -1524,6 +1529,7 @@ __all__ = [
     "CreateReferencePortfolioRequest",
     "CreateRelationDefinitionRequest",
     "CreateRelationRequest",
+    "CreateRelationalDatasetDefinitionRequest",
     "CreateRelationshipDefinitionRequest",
     "CreateRelationshipRequest",
     "CreateSequenceRequest",
@@ -2017,6 +2023,7 @@ __all__ = [
     "PagedResourceListOfPropertyDefinitionSearchResult",
     "PagedResourceListOfReconciliation",
     "PagedResourceListOfReferenceListResponse",
+    "PagedResourceListOfRelationalDatasetDefinition",
     "PagedResourceListOfRelationshipDefinition",
     "PagedResourceListOfSequenceDefinition",
     "PagedResourceListOfStagedModification",
@@ -2161,6 +2168,8 @@ __all__ = [
     "RelatedEntity",
     "Relation",
     "RelationDefinition",
+    "RelationalDatasetDefinition",
+    "RelationalDatasetFieldDefinition",
     "Relationship",
     "RelationshipDefinition",
     "RelativeDateOffset",
@@ -2425,6 +2434,7 @@ __all__ = [
     "UpdatePropertyDefinitionRequest",
     "UpdateReconciliationRequest",
     "UpdateReferenceDataRequest",
+    "UpdateRelationalDatasetDefinitionRequest",
     "UpdateRelationshipDefinitionRequest",
     "UpdateStagingRuleSetRequest",
     "UpdateTaxRuleSetRequest",

lusid/models/calendar_date.py

@@ -33,7 +33,7 @@ class CalendarDate(BaseModel):
     local_date:  StrictStr = Field(...,alias="localDate") 
     timezone:  StrictStr = Field(...,alias="timezone") 
     description:  StrictStr = Field(...,alias="description") 
-    type:  StrictStr = Field(...,alias="type") 
+    type:  Optional[StrictStr] = Field(None,alias="type") 
     attributes: Optional[DateAttributes] = None
     source_data: Optional[Dict[str, StrictStr]] = Field(None, alias="sourceData")
     __properties = ["href", "dateIdentifier", "fromUtc", "toUtc", "localDate", "timezone", "description", "type", "attributes", "sourceData"]
@@ -78,6 +78,11 @@ class CalendarDate(BaseModel):
         if self.href is None and "href" in self.__fields_set__:
             _dict['href'] = None
 
+        # set to None if type (nullable) is None
+        # and __fields_set__ contains the field
+        if self.type is None and "type" in self.__fields_set__:
+            _dict['type'] = None
+
         # set to None if source_data (nullable) is None
         # and __fields_set__ contains the field
         if self.source_data is None and "source_data" in self.__fields_set__:

lusid/models/create_relational_dataset_definition_request.py

@@ -0,0 +1,102 @@
+# 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, StrictStr, conlist, constr 
+from lusid.models.relational_dataset_field_definition import RelationalDatasetFieldDefinition
+from lusid.models.resource_id import ResourceId
+
+class CreateRelationalDatasetDefinitionRequest(BaseModel):
+    """
+    CreateRelationalDatasetDefinitionRequest
+    """
+    id: ResourceId = Field(...)
+    display_name:  StrictStr = Field(...,alias="displayName", description="A user-friendly display name for the relational dataset definition.") 
+    description:  Optional[StrictStr] = Field(None,alias="description", description="A detailed description of the relational dataset definition and its purpose.") 
+    applicable_entity_types: conlist(StrictStr) = Field(..., alias="applicableEntityTypes", description="The types of entities this relational dataset definition can be applied to (e.g. Instrument, Portfolio, etc.).")
+    field_schema: conlist(RelationalDatasetFieldDefinition) = Field(..., alias="fieldSchema", description="The schema defining the structure and data types of the relational dataset.")
+    __properties = ["id", "displayName", "description", "applicableEntityTypes", "fieldSchema"]
+
+    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) -> CreateRelationalDatasetDefinitionRequest:
+        """Create an instance of CreateRelationalDatasetDefinitionRequest 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 id
+        if self.id:
+            _dict['id'] = self.id.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in field_schema (list)
+        _items = []
+        if self.field_schema:
+            for _item in self.field_schema:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['fieldSchema'] = _items
+        # set to None if description (nullable) is None
+        # and __fields_set__ contains the field
+        if self.description is None and "description" in self.__fields_set__:
+            _dict['description'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> CreateRelationalDatasetDefinitionRequest:
+        """Create an instance of CreateRelationalDatasetDefinitionRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return CreateRelationalDatasetDefinitionRequest.parse_obj(obj)
+
+        _obj = CreateRelationalDatasetDefinitionRequest.parse_obj({
+            "id": ResourceId.from_dict(obj.get("id")) if obj.get("id") is not None else None,
+            "display_name": obj.get("displayName"),
+            "description": obj.get("description"),
+            "applicable_entity_types": obj.get("applicableEntityTypes"),
+            "field_schema": [RelationalDatasetFieldDefinition.from_dict(_item) for _item in obj.get("fieldSchema")] if obj.get("fieldSchema") is not None else None
+        })
+        return _obj

lusid/models/paged_resource_list_of_relational_dataset_definition.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 typing import Any, Dict, List, Optional
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictStr, conlist 
+from lusid.models.link import Link
+from lusid.models.relational_dataset_definition import RelationalDatasetDefinition
+
+class PagedResourceListOfRelationalDatasetDefinition(BaseModel):
+    """
+    PagedResourceListOfRelationalDatasetDefinition
+    """
+    next_page:  Optional[StrictStr] = Field(None,alias="nextPage") 
+    previous_page:  Optional[StrictStr] = Field(None,alias="previousPage") 
+    values: conlist(RelationalDatasetDefinition) = Field(...)
+    href:  Optional[StrictStr] = Field(None,alias="href") 
+    links: Optional[conlist(Link)] = None
+    __properties = ["nextPage", "previousPage", "values", "href", "links"]
+
+    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) -> PagedResourceListOfRelationalDatasetDefinition:
+        """Create an instance of PagedResourceListOfRelationalDatasetDefinition 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 values (list)
+        _items = []
+        if self.values:
+            for _item in self.values:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['values'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in links (list)
+        _items = []
+        if self.links:
+            for _item in self.links:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['links'] = _items
+        # set to None if next_page (nullable) is None
+        # and __fields_set__ contains the field
+        if self.next_page is None and "next_page" in self.__fields_set__:
+            _dict['nextPage'] = None
+
+        # set to None if previous_page (nullable) is None
+        # and __fields_set__ contains the field
+        if self.previous_page is None and "previous_page" in self.__fields_set__:
+            _dict['previousPage'] = None
+
+        # set to None if href (nullable) is None
+        # and __fields_set__ contains the field
+        if self.href is None and "href" in self.__fields_set__:
+            _dict['href'] = None
+
+        # set to None if links (nullable) is None
+        # and __fields_set__ contains the field
+        if self.links is None and "links" in self.__fields_set__:
+            _dict['links'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> PagedResourceListOfRelationalDatasetDefinition:
+        """Create an instance of PagedResourceListOfRelationalDatasetDefinition from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return PagedResourceListOfRelationalDatasetDefinition.parse_obj(obj)
+
+        _obj = PagedResourceListOfRelationalDatasetDefinition.parse_obj({
+            "next_page": obj.get("nextPage"),
+            "previous_page": obj.get("previousPage"),
+            "values": [RelationalDatasetDefinition.from_dict(_item) for _item in obj.get("values")] if obj.get("values") is not None else None,
+            "href": obj.get("href"),
+            "links": [Link.from_dict(_item) for _item in obj.get("links")] if obj.get("links") is not None else None
+        })
+        return _obj

lusid/models/relational_dataset_definition.py

@@ -0,0 +1,130 @@
+# 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, StrictStr, conlist, constr 
+from lusid.models.link import Link
+from lusid.models.relational_dataset_field_definition import RelationalDatasetFieldDefinition
+from lusid.models.resource_id import ResourceId
+from lusid.models.version import Version
+
+class RelationalDatasetDefinition(BaseModel):
+    """
+    RelationalDatasetDefinition
+    """
+    id: ResourceId = Field(...)
+    display_name:  StrictStr = Field(...,alias="displayName", description="A user-friendly display name for the relational dataset definition.") 
+    description:  Optional[StrictStr] = Field(None,alias="description", description="A detailed description of the relational dataset definition and its purpose.") 
+    applicable_entity_types: conlist(StrictStr) = Field(..., alias="applicableEntityTypes", description="The types of entities this relational dataset definition can be applied to (e.g. Instrument, Portfolio, etc.).")
+    field_schema: conlist(RelationalDatasetFieldDefinition) = Field(..., alias="fieldSchema", description="The schema defining the structure and data types of the relational dataset.")
+    href:  Optional[StrictStr] = Field(None,alias="href", description="The specific Uniform Resource Identifier (URI) for this resource at the requested effective and asAt datetime.") 
+    version: Optional[Version] = None
+    links: Optional[conlist(Link)] = None
+    __properties = ["id", "displayName", "description", "applicableEntityTypes", "fieldSchema", "href", "version", "links"]
+
+    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) -> RelationalDatasetDefinition:
+        """Create an instance of RelationalDatasetDefinition 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 id
+        if self.id:
+            _dict['id'] = self.id.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in field_schema (list)
+        _items = []
+        if self.field_schema:
+            for _item in self.field_schema:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['fieldSchema'] = _items
+        # override the default output from pydantic by calling `to_dict()` of version
+        if self.version:
+            _dict['version'] = self.version.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in links (list)
+        _items = []
+        if self.links:
+            for _item in self.links:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['links'] = _items
+        # set to None if description (nullable) is None
+        # and __fields_set__ contains the field
+        if self.description is None and "description" in self.__fields_set__:
+            _dict['description'] = None
+
+        # set to None if href (nullable) is None
+        # and __fields_set__ contains the field
+        if self.href is None and "href" in self.__fields_set__:
+            _dict['href'] = None
+
+        # set to None if links (nullable) is None
+        # and __fields_set__ contains the field
+        if self.links is None and "links" in self.__fields_set__:
+            _dict['links'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> RelationalDatasetDefinition:
+        """Create an instance of RelationalDatasetDefinition from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return RelationalDatasetDefinition.parse_obj(obj)
+
+        _obj = RelationalDatasetDefinition.parse_obj({
+            "id": ResourceId.from_dict(obj.get("id")) if obj.get("id") is not None else None,
+            "display_name": obj.get("displayName"),
+            "description": obj.get("description"),
+            "applicable_entity_types": obj.get("applicableEntityTypes"),
+            "field_schema": [RelationalDatasetFieldDefinition.from_dict(_item) for _item in obj.get("fieldSchema")] if obj.get("fieldSchema") is not None else None,
+            "href": obj.get("href"),
+            "version": Version.from_dict(obj.get("version")) if obj.get("version") is not None else None,
+            "links": [Link.from_dict(_item) for _item in obj.get("links")] if obj.get("links") is not None else None
+        })
+        return _obj

lusid/models/relational_dataset_field_definition.py

@@ -0,0 +1,106 @@
+# 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, StrictBool, StrictStr, constr 
+from lusid.models.resource_id import ResourceId
+
+class RelationalDatasetFieldDefinition(BaseModel):
+    """
+    RelationalDatasetFieldDefinition
+    """
+    field_name:  StrictStr = Field(...,alias="fieldName", description="The unique identifier for the field within the dataset.") 
+    display_name:  Optional[StrictStr] = Field(None,alias="displayName", description="A user-friendly display name for the field.") 
+    description:  Optional[StrictStr] = Field(None,alias="description", description="A detailed description of the field and its purpose.") 
+    data_type_id: ResourceId = Field(..., alias="dataTypeId")
+    required: Optional[StrictBool] = Field(None, description="Whether this field is mandatory in the dataset.")
+    usage:  Optional[StrictStr] = Field(None,alias="usage", description="The intended usage of the field (SeriesIdentifier, Value, or Metadata).") 
+    __properties = ["fieldName", "displayName", "description", "dataTypeId", "required", "usage"]
+
+    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) -> RelationalDatasetFieldDefinition:
+        """Create an instance of RelationalDatasetFieldDefinition 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 data_type_id
+        if self.data_type_id:
+            _dict['dataTypeId'] = self.data_type_id.to_dict()
+        # 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
+
+        # set to None if description (nullable) is None
+        # and __fields_set__ contains the field
+        if self.description is None and "description" in self.__fields_set__:
+            _dict['description'] = None
+
+        # set to None if usage (nullable) is None
+        # and __fields_set__ contains the field
+        if self.usage is None and "usage" in self.__fields_set__:
+            _dict['usage'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> RelationalDatasetFieldDefinition:
+        """Create an instance of RelationalDatasetFieldDefinition from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return RelationalDatasetFieldDefinition.parse_obj(obj)
+
+        _obj = RelationalDatasetFieldDefinition.parse_obj({
+            "field_name": obj.get("fieldName"),
+            "display_name": obj.get("displayName"),
+            "description": obj.get("description"),
+            "data_type_id": ResourceId.from_dict(obj.get("dataTypeId")) if obj.get("dataTypeId") is not None else None,
+            "required": obj.get("required"),
+            "usage": obj.get("usage")
+        })
+        return _obj

lusid/models/settlement_schedule.py

@@ -28,7 +28,8 @@ class SettlementSchedule(BaseModel):
     trade_id:  Optional[StrictStr] = Field(None,alias="tradeId") 
     settlement_date: Optional[datetime] = Field(None, alias="settlementDate")
     units: Optional[Union[StrictFloat, StrictInt]] = None
-    __properties = ["tradeId", "settlementDate", "units"]
+    bond_interest: Optional[Union[StrictFloat, StrictInt]] = Field(None, alias="bondInterest")
+    __properties = ["tradeId", "settlementDate", "units", "bondInterest"]
 
     class Config:
         """Pydantic configuration"""
@@ -81,6 +82,7 @@ class SettlementSchedule(BaseModel):
         _obj = SettlementSchedule.parse_obj({
             "trade_id": obj.get("tradeId"),
             "settlement_date": obj.get("settlementDate"),
-            "units": obj.get("units")
+            "units": obj.get("units"),
+            "bond_interest": obj.get("bondInterest")
         })
         return _obj

lusid/models/update_relational_dataset_definition_request.py

@@ -0,0 +1,96 @@
+# 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, StrictStr, conlist, constr 
+from lusid.models.relational_dataset_field_definition import RelationalDatasetFieldDefinition
+
+class UpdateRelationalDatasetDefinitionRequest(BaseModel):
+    """
+    UpdateRelationalDatasetDefinitionRequest
+    """
+    display_name:  StrictStr = Field(...,alias="displayName", description="A user-friendly display name for the relational dataset definition.") 
+    description:  Optional[StrictStr] = Field(None,alias="description", description="A detailed description of the relational dataset definition and its purpose.") 
+    applicable_entity_types: conlist(StrictStr) = Field(..., alias="applicableEntityTypes", description="The types of entities this relational dataset definition can be applied to (e.g. Instrument, Portfolio, etc.).")
+    field_schema: conlist(RelationalDatasetFieldDefinition) = Field(..., alias="fieldSchema", description="The schema defining the structure and data types of the relational dataset.")
+    __properties = ["displayName", "description", "applicableEntityTypes", "fieldSchema"]
+
+    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) -> UpdateRelationalDatasetDefinitionRequest:
+        """Create an instance of UpdateRelationalDatasetDefinitionRequest 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 field_schema (list)
+        _items = []
+        if self.field_schema:
+            for _item in self.field_schema:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['fieldSchema'] = _items
+        # set to None if description (nullable) is None
+        # and __fields_set__ contains the field
+        if self.description is None and "description" in self.__fields_set__:
+            _dict['description'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> UpdateRelationalDatasetDefinitionRequest:
+        """Create an instance of UpdateRelationalDatasetDefinitionRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return UpdateRelationalDatasetDefinitionRequest.parse_obj(obj)
+
+        _obj = UpdateRelationalDatasetDefinitionRequest.parse_obj({
+            "display_name": obj.get("displayName"),
+            "description": obj.get("description"),
+            "applicable_entity_types": obj.get("applicableEntityTypes"),
+            "field_schema": [RelationalDatasetFieldDefinition.from_dict(_item) for _item in obj.get("fieldSchema")] if obj.get("fieldSchema") is not None else None
+        })
+        return _obj