lusid-sdk 2.1.242__py3-none-any.whl → 2.1.246__py3-none-any.whl

lusid/models/__init__.py

@@ -417,6 +417,7 @@ from lusid.models.instrument_cash_flow import InstrumentCashFlow
 from lusid.models.instrument_definition import InstrumentDefinition
 from lusid.models.instrument_definition_format import InstrumentDefinitionFormat
 from lusid.models.instrument_delete_modes import InstrumentDeleteModes
+from lusid.models.instrument_entity import InstrumentEntity
 from lusid.models.instrument_event import InstrumentEvent
 from lusid.models.instrument_event_configuration import InstrumentEventConfiguration
 from lusid.models.instrument_event_holder import InstrumentEventHolder
@@ -613,6 +614,7 @@ from lusid.models.place_blocks_request import PlaceBlocksRequest
 from lusid.models.placement import Placement
 from lusid.models.placement_request import PlacementRequest
 from lusid.models.placement_set_request import PlacementSetRequest
+from lusid.models.placement_update_request import PlacementUpdateRequest
 from lusid.models.portfolio import Portfolio
 from lusid.models.portfolio_cash_flow import PortfolioCashFlow
 from lusid.models.portfolio_cash_ladder import PortfolioCashLadder
@@ -649,6 +651,7 @@ from lusid.models.pricing_model import PricingModel
 from lusid.models.pricing_options import PricingOptions
 from lusid.models.processed_command import ProcessedCommand
 from lusid.models.property_definition import PropertyDefinition
+from lusid.models.property_definition_entity import PropertyDefinitionEntity
 from lusid.models.property_definition_search_result import PropertyDefinitionSearchResult
 from lusid.models.property_definition_type import PropertyDefinitionType
 from lusid.models.property_domain import PropertyDomain
@@ -928,6 +931,7 @@ from lusid.models.update_data_type_request import UpdateDataTypeRequest
 from lusid.models.update_derived_property_definition_request import UpdateDerivedPropertyDefinitionRequest
 from lusid.models.update_fee_type_request import UpdateFeeTypeRequest
 from lusid.models.update_instrument_identifier_request import UpdateInstrumentIdentifierRequest
+from lusid.models.update_placements_response import UpdatePlacementsResponse
 from lusid.models.update_portfolio_group_request import UpdatePortfolioGroupRequest
 from lusid.models.update_portfolio_request import UpdatePortfolioRequest
 from lusid.models.update_property_definition_request import UpdatePropertyDefinitionRequest
@@ -1416,6 +1420,7 @@ __all__ = [
     "InstrumentDefinition",
     "InstrumentDefinitionFormat",
     "InstrumentDeleteModes",
+    "InstrumentEntity",
     "InstrumentEvent",
     "InstrumentEventConfiguration",
     "InstrumentEventHolder",
@@ -1612,6 +1617,7 @@ __all__ = [
     "Placement",
     "PlacementRequest",
     "PlacementSetRequest",
+    "PlacementUpdateRequest",
     "Portfolio",
     "PortfolioCashFlow",
     "PortfolioCashLadder",
@@ -1648,6 +1654,7 @@ __all__ = [
     "PricingOptions",
     "ProcessedCommand",
     "PropertyDefinition",
+    "PropertyDefinitionEntity",
     "PropertyDefinitionSearchResult",
     "PropertyDefinitionType",
     "PropertyDomain",
@@ -1927,6 +1934,7 @@ __all__ = [
     "UpdateDerivedPropertyDefinitionRequest",
     "UpdateFeeTypeRequest",
     "UpdateInstrumentIdentifierRequest",
+    "UpdatePlacementsResponse",
     "UpdatePortfolioGroupRequest",
     "UpdatePortfolioRequest",
     "UpdatePropertyDefinitionRequest",

lusid/models/dependency_source_filter.py

@@ -28,7 +28,8 @@ class DependencySourceFilter(BaseModel):
     instrument_type: Optional[constr(strict=True, max_length=32, min_length=0)] = Field(None, alias="instrumentType", description="Specify that a rule should only apply if the market data is requested by an instrument of a given instrument type.  If null, then no filtering on instrument type is applied.")
     asset_class: Optional[constr(strict=True, max_length=32, min_length=0)] = Field(None, alias="assetClass", description="Specify that a rule should only apply if the market data is requested by an instrument of a given asset class.  If null, then no filtering on asset class is applied.")
     dom_ccy: Optional[StrictStr] = Field(None, alias="domCcy", description="Specify that a rule should only apply if the market data is requested by an instrument with a given domestic currency.  If null, then no filtering on currency is applied.")
-    __properties = ["instrumentType", "assetClass", "domCcy"]
+    long_or_short_indicator: Optional[StrictStr] = Field(None, alias="longOrShortIndicator", description="Specify that a rule should apply if the market data is requested by a model with a given long or short indicator.  If none, then no filtering on LongOrShortIndicator is applied.")
+    __properties = ["instrumentType", "assetClass", "domCcy", "longOrShortIndicator"]
 
     class Config:
         """Pydantic configuration"""
@@ -69,6 +70,11 @@ class DependencySourceFilter(BaseModel):
         if self.dom_ccy is None and "dom_ccy" in self.__fields_set__:
             _dict['domCcy'] = None
 
+        # set to None if long_or_short_indicator (nullable) is None
+        # and __fields_set__ contains the field
+        if self.long_or_short_indicator is None and "long_or_short_indicator" in self.__fields_set__:
+            _dict['longOrShortIndicator'] = None
+
         return _dict
 
     @classmethod
@@ -83,6 +89,7 @@ class DependencySourceFilter(BaseModel):
         _obj = DependencySourceFilter.parse_obj({
             "instrument_type": obj.get("instrumentType"),
             "asset_class": obj.get("assetClass"),
-            "dom_ccy": obj.get("domCcy")
+            "dom_ccy": obj.get("domCcy"),
+            "long_or_short_indicator": obj.get("longOrShortIndicator")
         })
         return _obj

lusid/models/instrument_entity.py

@@ -0,0 +1,146 @@
+# 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, constr
+from lusid.models.instrument import Instrument
+from lusid.models.link import Link
+
+class InstrumentEntity(BaseModel):
+    """
+    A list of instruments.  # noqa: E501
+    """
+    href: StrictStr = Field(..., description="The specific Uniform Resource Identifier (URI) for this resource at the requested effective and asAt datetime.")
+    entity_unique_id: constr(strict=True, min_length=1) = Field(..., alias="entityUniqueId", description="The unique id of the entity.")
+    as_at_version_number: Optional[StrictInt] = Field(None, alias="asAtVersionNumber", description="The integer version number for the entity (the entity was created at version 1)")
+    status: constr(strict=True, min_length=1) = Field(..., description="The status of the entity at the current time.")
+    as_at_deleted: Optional[datetime] = Field(None, alias="asAtDeleted", description="The asAt datetime at which the entity was deleted.")
+    user_id_deleted: Optional[StrictStr] = Field(None, alias="userIdDeleted", description="The unique id of the user who deleted the entity.")
+    request_id_deleted: Optional[StrictStr] = Field(None, alias="requestIdDeleted", description="The unique request id of the command that deleted the entity.")
+    effective_at_created: Optional[datetime] = Field(None, alias="effectiveAtCreated", description="The EffectiveAt this Entity is created, if entity does not currently exist in EffectiveAt.")
+    prevailing_instrument: Optional[Instrument] = Field(None, alias="prevailingInstrument")
+    deleted_instrument: Optional[Instrument] = Field(None, alias="deletedInstrument")
+    previewed_status: Optional[StrictStr] = Field(None, alias="previewedStatus", description="The status of the previewed entity.")
+    previewed_instrument: Optional[Instrument] = Field(None, alias="previewedInstrument")
+    links: Optional[conlist(Link)] = None
+    __properties = ["href", "entityUniqueId", "asAtVersionNumber", "status", "asAtDeleted", "userIdDeleted", "requestIdDeleted", "effectiveAtCreated", "prevailingInstrument", "deletedInstrument", "previewedStatus", "previewedInstrument", "links"]
+
+    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) -> InstrumentEntity:
+        """Create an instance of InstrumentEntity 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 prevailing_instrument
+        if self.prevailing_instrument:
+            _dict['prevailingInstrument'] = self.prevailing_instrument.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of deleted_instrument
+        if self.deleted_instrument:
+            _dict['deletedInstrument'] = self.deleted_instrument.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of previewed_instrument
+        if self.previewed_instrument:
+            _dict['previewedInstrument'] = self.previewed_instrument.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 as_at_version_number (nullable) is None
+        # and __fields_set__ contains the field
+        if self.as_at_version_number is None and "as_at_version_number" in self.__fields_set__:
+            _dict['asAtVersionNumber'] = None
+
+        # set to None if as_at_deleted (nullable) is None
+        # and __fields_set__ contains the field
+        if self.as_at_deleted is None and "as_at_deleted" in self.__fields_set__:
+            _dict['asAtDeleted'] = None
+
+        # set to None if user_id_deleted (nullable) is None
+        # and __fields_set__ contains the field
+        if self.user_id_deleted is None and "user_id_deleted" in self.__fields_set__:
+            _dict['userIdDeleted'] = None
+
+        # set to None if request_id_deleted (nullable) is None
+        # and __fields_set__ contains the field
+        if self.request_id_deleted is None and "request_id_deleted" in self.__fields_set__:
+            _dict['requestIdDeleted'] = None
+
+        # set to None if effective_at_created (nullable) is None
+        # and __fields_set__ contains the field
+        if self.effective_at_created is None and "effective_at_created" in self.__fields_set__:
+            _dict['effectiveAtCreated'] = None
+
+        # set to None if previewed_status (nullable) is None
+        # and __fields_set__ contains the field
+        if self.previewed_status is None and "previewed_status" in self.__fields_set__:
+            _dict['previewedStatus'] = 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) -> InstrumentEntity:
+        """Create an instance of InstrumentEntity from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return InstrumentEntity.parse_obj(obj)
+
+        _obj = InstrumentEntity.parse_obj({
+            "href": obj.get("href"),
+            "entity_unique_id": obj.get("entityUniqueId"),
+            "as_at_version_number": obj.get("asAtVersionNumber"),
+            "status": obj.get("status"),
+            "as_at_deleted": obj.get("asAtDeleted"),
+            "user_id_deleted": obj.get("userIdDeleted"),
+            "request_id_deleted": obj.get("requestIdDeleted"),
+            "effective_at_created": obj.get("effectiveAtCreated"),
+            "prevailing_instrument": Instrument.from_dict(obj.get("prevailingInstrument")) if obj.get("prevailingInstrument") is not None else None,
+            "deleted_instrument": Instrument.from_dict(obj.get("deletedInstrument")) if obj.get("deletedInstrument") is not None else None,
+            "previewed_status": obj.get("previewedStatus"),
+            "previewed_instrument": Instrument.from_dict(obj.get("previewedInstrument")) if obj.get("previewedInstrument") 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/placement_update_request.py

@@ -0,0 +1,116 @@
+# 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, Union
+from pydantic.v1 import BaseModel, Field, StrictFloat, StrictInt, StrictStr, constr
+from lusid.models.perpetual_property import PerpetualProperty
+from lusid.models.resource_id import ResourceId
+
+class PlacementUpdateRequest(BaseModel):
+    """
+    A request to create or update a Placement.  # noqa: E501
+    """
+    id: ResourceId = Field(...)
+    quantity: Union[StrictFloat, StrictInt] = Field(..., description="The quantity of given instrument ordered.")
+    properties: Optional[Dict[str, PerpetualProperty]] = Field(None, description="Client-defined properties associated with this placement.")
+    counterparty: Optional[StrictStr] = Field(None, description="Optionally specifies the market entity this placement is placed with.")
+    execution_system: Optional[constr(strict=True, max_length=256, min_length=1)] = Field(None, alias="executionSystem", description="Optionally specifies the execution system in use.")
+    entry_type: Optional[constr(strict=True, max_length=256, min_length=1)] = Field(None, alias="entryType", description="Optionally specifies the entry type of this placement.")
+    __properties = ["id", "quantity", "properties", "counterparty", "executionSystem", "entryType"]
+
+    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) -> PlacementUpdateRequest:
+        """Create an instance of PlacementUpdateRequest 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 value in properties (dict)
+        _field_dict = {}
+        if self.properties:
+            for _key in self.properties:
+                if self.properties[_key]:
+                    _field_dict[_key] = self.properties[_key].to_dict()
+            _dict['properties'] = _field_dict
+        # set to None if properties (nullable) is None
+        # and __fields_set__ contains the field
+        if self.properties is None and "properties" in self.__fields_set__:
+            _dict['properties'] = None
+
+        # set to None if counterparty (nullable) is None
+        # and __fields_set__ contains the field
+        if self.counterparty is None and "counterparty" in self.__fields_set__:
+            _dict['counterparty'] = None
+
+        # set to None if execution_system (nullable) is None
+        # and __fields_set__ contains the field
+        if self.execution_system is None and "execution_system" in self.__fields_set__:
+            _dict['executionSystem'] = None
+
+        # set to None if entry_type (nullable) is None
+        # and __fields_set__ contains the field
+        if self.entry_type is None and "entry_type" in self.__fields_set__:
+            _dict['entryType'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> PlacementUpdateRequest:
+        """Create an instance of PlacementUpdateRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return PlacementUpdateRequest.parse_obj(obj)
+
+        _obj = PlacementUpdateRequest.parse_obj({
+            "id": ResourceId.from_dict(obj.get("id")) if obj.get("id") is not None else None,
+            "quantity": obj.get("quantity"),
+            "properties": dict(
+                (_k, PerpetualProperty.from_dict(_v))
+                for _k, _v in obj.get("properties").items()
+            )
+            if obj.get("properties") is not None
+            else None,
+            "counterparty": obj.get("counterparty"),
+            "execution_system": obj.get("executionSystem"),
+            "entry_type": obj.get("entryType")
+        })
+        return _obj

lusid/models/property_definition_entity.py

@@ -0,0 +1,146 @@
+# 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, constr
+from lusid.models.link import Link
+from lusid.models.property_definition import PropertyDefinition
+
+class PropertyDefinitionEntity(BaseModel):
+    """
+    PropertyDefinitionEntity
+    """
+    href: StrictStr = Field(..., description="The specific Uniform Resource Identifier (URI) for this resource at the requested effective and asAt datetime.")
+    entity_unique_id: constr(strict=True, min_length=1) = Field(..., alias="entityUniqueId", description="The unique id of the entity.")
+    as_at_version_number: Optional[StrictInt] = Field(None, alias="asAtVersionNumber", description="The integer version number for the entity (the entity was created at version 1)")
+    status: constr(strict=True, min_length=1) = Field(..., description="The status of the entity at the current time.")
+    as_at_deleted: Optional[datetime] = Field(None, alias="asAtDeleted", description="The asAt datetime at which the entity was deleted.")
+    user_id_deleted: Optional[StrictStr] = Field(None, alias="userIdDeleted", description="The unique id of the user who deleted the entity.")
+    request_id_deleted: Optional[StrictStr] = Field(None, alias="requestIdDeleted", description="The unique request id of the command that deleted the entity.")
+    effective_at_created: Optional[datetime] = Field(None, alias="effectiveAtCreated", description="The EffectiveAt this Entity is created, if entity does not currently exist in EffectiveAt.")
+    prevailing_property_definition: Optional[PropertyDefinition] = Field(None, alias="prevailingPropertyDefinition")
+    deleted_property_definition: Optional[PropertyDefinition] = Field(None, alias="deletedPropertyDefinition")
+    previewed_status: Optional[StrictStr] = Field(None, alias="previewedStatus", description="The status of the previewed entity.")
+    previewed_property_definition: Optional[PropertyDefinition] = Field(None, alias="previewedPropertyDefinition")
+    links: Optional[conlist(Link)] = None
+    __properties = ["href", "entityUniqueId", "asAtVersionNumber", "status", "asAtDeleted", "userIdDeleted", "requestIdDeleted", "effectiveAtCreated", "prevailingPropertyDefinition", "deletedPropertyDefinition", "previewedStatus", "previewedPropertyDefinition", "links"]
+
+    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) -> PropertyDefinitionEntity:
+        """Create an instance of PropertyDefinitionEntity 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 prevailing_property_definition
+        if self.prevailing_property_definition:
+            _dict['prevailingPropertyDefinition'] = self.prevailing_property_definition.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of deleted_property_definition
+        if self.deleted_property_definition:
+            _dict['deletedPropertyDefinition'] = self.deleted_property_definition.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of previewed_property_definition
+        if self.previewed_property_definition:
+            _dict['previewedPropertyDefinition'] = self.previewed_property_definition.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 as_at_version_number (nullable) is None
+        # and __fields_set__ contains the field
+        if self.as_at_version_number is None and "as_at_version_number" in self.__fields_set__:
+            _dict['asAtVersionNumber'] = None
+
+        # set to None if as_at_deleted (nullable) is None
+        # and __fields_set__ contains the field
+        if self.as_at_deleted is None and "as_at_deleted" in self.__fields_set__:
+            _dict['asAtDeleted'] = None
+
+        # set to None if user_id_deleted (nullable) is None
+        # and __fields_set__ contains the field
+        if self.user_id_deleted is None and "user_id_deleted" in self.__fields_set__:
+            _dict['userIdDeleted'] = None
+
+        # set to None if request_id_deleted (nullable) is None
+        # and __fields_set__ contains the field
+        if self.request_id_deleted is None and "request_id_deleted" in self.__fields_set__:
+            _dict['requestIdDeleted'] = None
+
+        # set to None if effective_at_created (nullable) is None
+        # and __fields_set__ contains the field
+        if self.effective_at_created is None and "effective_at_created" in self.__fields_set__:
+            _dict['effectiveAtCreated'] = None
+
+        # set to None if previewed_status (nullable) is None
+        # and __fields_set__ contains the field
+        if self.previewed_status is None and "previewed_status" in self.__fields_set__:
+            _dict['previewedStatus'] = 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) -> PropertyDefinitionEntity:
+        """Create an instance of PropertyDefinitionEntity from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return PropertyDefinitionEntity.parse_obj(obj)
+
+        _obj = PropertyDefinitionEntity.parse_obj({
+            "href": obj.get("href"),
+            "entity_unique_id": obj.get("entityUniqueId"),
+            "as_at_version_number": obj.get("asAtVersionNumber"),
+            "status": obj.get("status"),
+            "as_at_deleted": obj.get("asAtDeleted"),
+            "user_id_deleted": obj.get("userIdDeleted"),
+            "request_id_deleted": obj.get("requestIdDeleted"),
+            "effective_at_created": obj.get("effectiveAtCreated"),
+            "prevailing_property_definition": PropertyDefinition.from_dict(obj.get("prevailingPropertyDefinition")) if obj.get("prevailingPropertyDefinition") is not None else None,
+            "deleted_property_definition": PropertyDefinition.from_dict(obj.get("deletedPropertyDefinition")) if obj.get("deletedPropertyDefinition") is not None else None,
+            "previewed_status": obj.get("previewedStatus"),
+            "previewed_property_definition": PropertyDefinition.from_dict(obj.get("previewedPropertyDefinition")) if obj.get("previewedPropertyDefinition") 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/update_placements_response.py

@@ -0,0 +1,153 @@
+# 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, StrictStr, conlist
+from lusid.models.error_detail import ErrorDetail
+from lusid.models.link import Link
+from lusid.models.placement import Placement
+from lusid.models.response_meta_data import ResponseMetaData
+
+class UpdatePlacementsResponse(BaseModel):
+    """
+    UpdatePlacementsResponse
+    """
+    href: Optional[StrictStr] = Field(None, description="The specific Uniform Resource Identifier (URI) for this resource at the requested effective and asAt datetime.")
+    values: Optional[Dict[str, Placement]] = Field(None, description="The placements which have been successfully updated.")
+    failed: Optional[Dict[str, ErrorDetail]] = Field(None, description="The placements that could not be updated, along with a reason for their failure.")
+    metadata: Optional[Dict[str, conlist(ResponseMetaData)]] = Field(None, description="Meta data associated with the update event.")
+    links: Optional[conlist(Link)] = None
+    __properties = ["href", "values", "failed", "metadata", "links"]
+
+    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) -> UpdatePlacementsResponse:
+        """Create an instance of UpdatePlacementsResponse 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 value in values (dict)
+        _field_dict = {}
+        if self.values:
+            for _key in self.values:
+                if self.values[_key]:
+                    _field_dict[_key] = self.values[_key].to_dict()
+            _dict['values'] = _field_dict
+        # override the default output from pydantic by calling `to_dict()` of each value in failed (dict)
+        _field_dict = {}
+        if self.failed:
+            for _key in self.failed:
+                if self.failed[_key]:
+                    _field_dict[_key] = self.failed[_key].to_dict()
+            _dict['failed'] = _field_dict
+        # override the default output from pydantic by calling `to_dict()` of each value in metadata (dict of array)
+        _field_dict_of_array = {}
+        if self.metadata:
+            for _key in self.metadata:
+                if self.metadata[_key]:
+                    _field_dict_of_array[_key] = [
+                        _item.to_dict() for _item in self.metadata[_key]
+                    ]
+            _dict['metadata'] = _field_dict_of_array
+        # 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 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 values (nullable) is None
+        # and __fields_set__ contains the field
+        if self.values is None and "values" in self.__fields_set__:
+            _dict['values'] = None
+
+        # set to None if failed (nullable) is None
+        # and __fields_set__ contains the field
+        if self.failed is None and "failed" in self.__fields_set__:
+            _dict['failed'] = None
+
+        # set to None if metadata (nullable) is None
+        # and __fields_set__ contains the field
+        if self.metadata is None and "metadata" in self.__fields_set__:
+            _dict['metadata'] = 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) -> UpdatePlacementsResponse:
+        """Create an instance of UpdatePlacementsResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return UpdatePlacementsResponse.parse_obj(obj)
+
+        _obj = UpdatePlacementsResponse.parse_obj({
+            "href": obj.get("href"),
+            "values": dict(
+                (_k, Placement.from_dict(_v))
+                for _k, _v in obj.get("values").items()
+            )
+            if obj.get("values") is not None
+            else None,
+            "failed": dict(
+                (_k, ErrorDetail.from_dict(_v))
+                for _k, _v in obj.get("failed").items()
+            )
+            if obj.get("failed") is not None
+            else None,
+            "metadata": dict(
+                (_k,
+                        [ResponseMetaData.from_dict(_item) for _item in _v]
+                        if _v is not None
+                        else None
+                )
+                for _k, _v in obj.get("metadata").items()
+            ),
+            "links": [Link.from_dict(_item) for _item in obj.get("links")] if obj.get("links") is not None else None
+        })
+        return _obj