lusid-sdk 2.0.50b0__py3-none-any.whl → 2.1.683__py3-none-any.whl

{lusid_sdk-2.0.50b0.dist-info → lusid_sdk-2.1.683.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.7.0
+Generator: poetry-core 1.9.1
 Root-Is-Purelib: true
 Tag: py3-none-any

lusid/extensions/api_client_builder.py

@@ -1,138 +0,0 @@
-from lusid.extensions.api_configuration import ApiConfiguration
-import logging
-import aiohttp
-from typing import Union, Any, Optional, Tuple, Callable
-from lusid.api_client import ApiClient as AsyncApiClient
-from lusid.extensions.api_client import SyncApiClient
-from lusid.extensions.refreshing_token import RefreshingToken
-from lusid.configuration import Configuration
-import lusid.extensions.retry as retry
-from lusid.extensions.socket_keep_alive import keep_alive_socket_options
-from lusid.extensions.tcp_keep_alive_connector import TcpKeepAliveConnector
-import os
-
-logger = logging.getLogger(__name__)
-
-
-def _get_access_token(
-    api_config: ApiConfiguration, id_provider_response_handler=None
-):
-    try:
-        if api_config.access_token is not None:
-            return api_config.access_token
-        logger.debug(
-            "Access token not provided, \
-                will attempt to set up client using OIDC parameters"
-        )
-        return RefreshingToken(
-            api_configuration=api_config,
-            id_provider_response_handler=id_provider_response_handler,
-        )
-    except AttributeError:
-        logger.exception(
-            "Could not retrieve access token - ensure api_config is an ApiConfiguration object"
-        )
-        raise
-    except ValueError:
-        logger.exception(
-            "Could not retrieve access token - ensure fields required to authenticate are set"
-        )
-        raise
-
-
-def build_client(
-    api_config: ApiConfiguration,
-    build_async_client: bool = False,
-    id_provider_response_handler: Callable = None,
-    tcp_keep_alive: bool = False,
-    socket_options: Optional[
-        Union[Tuple[Any, Any, Any], Tuple[Any, Any, None, int]]
-    ] = None,
-    correlation_id: Optional[str] = None,
-    app_name: Optional[str] = None,
-) -> Union[AsyncApiClient, SyncApiClient]:
-    """Build an ApiClient that can be used to connect to LUSID.
-
-    Parameters
-    ----------
-    api_config : ApiConfiguration
-        configuration for the ApiClient, including auth.
-    build_async_client : bool, optional
-        Should a synchronous or async client be built, by default False
-    id_provider_response_handler : Callable, optional
-        A function that can be used to handle responses from identity providers, by default None
-    tcp_keep_alive : bool, optional
-        Set tcp_keep_alive options on client connections, by default False
-    socket_options : Optional[ Union[Tuple[Any, Any, Any], Tuple[Any, Any, None, int]] ], optional
-        Custom socket options for client connections, by default None
-    correlation_id : Optional[str], optional
-        Sets an additional header on the client which 
-        tags each request with a correlation id, by default None
-    app_name : Optional[str], optional
-        Name of the application, by default None
-
-    Returns
-    -------
-    Union[AsyncApiClient, SyncApiClient]
-        Either a synchronous or asynchronous ApiClient
-
-    Raises
-    ------
-    ValueError
-        Raised if necessary configuration not provided in ApiConfiguration object
-    """
-    try:
-        if api_config.api_url is None:
-            logger.error("Api Url must have a value")
-            raise ValueError("Api Url must have a value")
-        config = Configuration(
-            access_token=_get_access_token(api_config, id_provider_response_handler),
-            host=api_config.api_url,
-            ssl_ca_cert=api_config.certificate_filename,
-        )
-        if tcp_keep_alive:
-            config.socket_options = socket_options or keep_alive_socket_options()
-        # Set the proxy for lusid if needed
-        if api_config.proxy_config is not None:
-            config.proxy = api_config.proxy_config.address
-            config.proxy_headers = api_config.proxy_config.headers
-    except (AttributeError, ValueError):
-        logger.exception(
-            "Unable to build api client, required configuration not provided"
-        )
-        raise
-
-    if build_async_client:
-        # Create and return the ApiClient
-        api_client = AsyncApiClient(configuration=config)
-        if tcp_keep_alive:
-            connector = TcpKeepAliveConnector(
-                limit=api_client.rest_client.pool_manager.connector.limit,
-                ssl=api_client.rest_client.pool_manager.connector._ssl,
-                socket_options=config.socket_options,
-            )
-            api_client.rest_client.pool_manager = aiohttp.ClientSession(
-                connector=connector,
-                trust_env=True
-            )
-        rest_client_wrapper = retry.RetryingRestWrapperAsync
-
-    else:
-        # Create and return the ApiClient
-        api_client = SyncApiClient(configuration=config)
-        rest_client_wrapper = retry.RetryingRestWrapper
-
-    rc = api_client.rest_client
-    wrapped_rest_client = rest_client_wrapper(rc)
-    api_client.rest_client = wrapped_rest_client
-
-    # set the application name if specified
-    if app_name is not None:
-        api_client.set_default_header("X-LUSID-Application", app_name)
-
-    # set a correlation id for all requests initiated with this ApiClient
-    corr_id = correlation_id or os.getenv("FBN_CORRELATION_ID")
-    if corr_id is not None:
-        api_client.set_default_header("CorrelationId", corr_id)
-
-    return api_client

lusid/models/configuration_recipe_snippet.py

@@ -1,139 +0,0 @@
-# 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 import BaseModel, Field, conlist, constr, validator
-from lusid.models.aggregation_options import AggregationOptions
-from lusid.models.configuration_recipe import ConfigurationRecipe
-from lusid.models.market_data_key_rule import MarketDataKeyRule
-from lusid.models.market_options import MarketOptions
-from lusid.models.pricing_options import PricingOptions
-from lusid.models.vendor_model_rule import VendorModelRule
-
-class ConfigurationRecipeSnippet(BaseModel):
-    """
-    If it is desired to have multiple recipes, there is a strong likelihood that they will share various components.  A configuration recipe snippet allows a user to define a set of rules that can then be included into a parent recipe.  This allows sharing of common blocks of the recipe.                For example, a user might define a set of rules for resolving Fx and then include them into every recipe used firm-wide, thereby  enforcing consistency. As the rules can be permissioned differently using Shrine, it is possible to enable users to   read but not alter such a rule set.                The same applies to a set of pricing rules.                A configuration snippet must only contain one entry from the available set.                 Recipes are compiled from the set of snippets through a model that is analogous to inheritance.  A recipe can have a set of 'parent' recipes from which it inherits. These are specified in the inheritance section of a recipe.  Upon loading, the recipe will fall back on these recipe components for any options or rules that are not explicitly specified in the  named recipe for the request.                This allows control of pricing to be harmonised across a set of desks within an institution. Suppose that, e.g.  there are four desks looking after products under the areas of Fx, Rates, Credit and Exotics.  The model and market data for pricing given asset types would potentially be controlled by the appropriate desk; e.g. rules for Fx market data resolution being  controlled by the Fx desk. The exotics desk would likely depend upon rules for all the other asset classes as well as, say, correlation rules of its own.  It could inherit the market data and model rules from the other desks for finding the appropriate institution-standard data and then overlay that with the correlation rules.                Note that permissioning of the store means that one could decide that only a particular desk or control function could update certain rules. That would assist the abilitiy  to ensure that pricing is performed consistently and provide an audit of changes made to it along with restricting changes to appropriate authorised functions.  # noqa: E501
-    """
-    scope: constr(strict=True, max_length=64, min_length=1) = Field(..., description="The scope used when updating or inserting the Configuration Recipe snippet")
-    code: constr(strict=True, max_length=64, min_length=1) = Field(..., description="User given string name (code) to identify the recipe.")
-    aggregation_options: Optional[AggregationOptions] = Field(None, alias="aggregationOptions")
-    model_rules: Optional[conlist(VendorModelRule)] = Field(None, alias="modelRules", description="The set of model rules that are available. There may be multiple rules for Vendors, but only one per model-instrument pair.  Which of these preference sets is used depends upon the model choice selection if specified, or failing that the global default model specification  in the options.")
-    pricing_options: Optional[PricingOptions] = Field(None, alias="pricingOptions")
-    market_rules: Optional[conlist(MarketDataKeyRule)] = Field(None, alias="marketRules", description="The set of rules that define how to resolve particular use cases. These can be relatively general or specific in nature.  Nominally any number are possible and will be processed in order where applicable. However, there is evidently a potential  for increased computational cost where many rules must be applied to resolve data. Ensuring that portfolios are structured in  such a way as to reduce the number of rules required is therefore sensible.")
-    market_options: Optional[MarketOptions] = Field(None, alias="marketOptions")
-    recipe: Optional[ConfigurationRecipe] = None
-    __properties = ["scope", "code", "aggregationOptions", "modelRules", "pricingOptions", "marketRules", "marketOptions", "recipe"]
-
-    @validator('scope')
-    def scope_validate_regular_expression(cls, value):
-        """Validates the regular expression"""
-        if not re.match(r"^[a-zA-Z0-9\-_]+$", value):
-            raise ValueError(r"must validate the regular expression /^[a-zA-Z0-9\-_]+$/")
-        return value
-
-    @validator('code')
-    def code_validate_regular_expression(cls, value):
-        """Validates the regular expression"""
-        if not re.match(r"^[a-zA-Z0-9\-_]+$", value):
-            raise ValueError(r"must validate the regular expression /^[a-zA-Z0-9\-_]+$/")
-        return value
-
-    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) -> ConfigurationRecipeSnippet:
-        """Create an instance of ConfigurationRecipeSnippet 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 aggregation_options
-        if self.aggregation_options:
-            _dict['aggregationOptions'] = self.aggregation_options.to_dict()
-        # override the default output from pydantic by calling `to_dict()` of each item in model_rules (list)
-        _items = []
-        if self.model_rules:
-            for _item in self.model_rules:
-                if _item:
-                    _items.append(_item.to_dict())
-            _dict['modelRules'] = _items
-        # override the default output from pydantic by calling `to_dict()` of pricing_options
-        if self.pricing_options:
-            _dict['pricingOptions'] = self.pricing_options.to_dict()
-        # override the default output from pydantic by calling `to_dict()` of each item in market_rules (list)
-        _items = []
-        if self.market_rules:
-            for _item in self.market_rules:
-                if _item:
-                    _items.append(_item.to_dict())
-            _dict['marketRules'] = _items
-        # override the default output from pydantic by calling `to_dict()` of market_options
-        if self.market_options:
-            _dict['marketOptions'] = self.market_options.to_dict()
-        # override the default output from pydantic by calling `to_dict()` of recipe
-        if self.recipe:
-            _dict['recipe'] = self.recipe.to_dict()
-        # set to None if model_rules (nullable) is None
-        # and __fields_set__ contains the field
-        if self.model_rules is None and "model_rules" in self.__fields_set__:
-            _dict['modelRules'] = None
-
-        # set to None if market_rules (nullable) is None
-        # and __fields_set__ contains the field
-        if self.market_rules is None and "market_rules" in self.__fields_set__:
-            _dict['marketRules'] = None
-
-        return _dict
-
-    @classmethod
-    def from_dict(cls, obj: dict) -> ConfigurationRecipeSnippet:
-        """Create an instance of ConfigurationRecipeSnippet from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return ConfigurationRecipeSnippet.parse_obj(obj)
-
-        _obj = ConfigurationRecipeSnippet.parse_obj({
-            "scope": obj.get("scope"),
-            "code": obj.get("code"),
-            "aggregation_options": AggregationOptions.from_dict(obj.get("aggregationOptions")) if obj.get("aggregationOptions") is not None else None,
-            "model_rules": [VendorModelRule.from_dict(_item) for _item in obj.get("modelRules")] if obj.get("modelRules") is not None else None,
-            "pricing_options": PricingOptions.from_dict(obj.get("pricingOptions")) if obj.get("pricingOptions") is not None else None,
-            "market_rules": [MarketDataKeyRule.from_dict(_item) for _item in obj.get("marketRules")] if obj.get("marketRules") is not None else None,
-            "market_options": MarketOptions.from_dict(obj.get("marketOptions")) if obj.get("marketOptions") is not None else None,
-            "recipe": ConfigurationRecipe.from_dict(obj.get("recipe")) if obj.get("recipe") is not None else None
-        })
-        return _obj

lusid/models/je_lines_query_parameters.py

@@ -1,105 +0,0 @@
-# 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 import BaseModel, Field, StrictStr, conlist, constr, validator
-
-class JELinesQueryParameters(BaseModel):
-    """
-    JELinesQueryParameters
-    """
-    start_date: Optional[StrictStr] = Field(None, alias="startDate", description="The start date of the JELines.")
-    end_date: Optional[StrictStr] = Field(None, alias="endDate", description="The end date of the JELInes")
-    filter: Optional[constr(strict=True, max_length=16384, min_length=0)] = Field(None, description="Expression to filter the result set.")
-    property_keys: Optional[conlist(StrictStr)] = Field(None, alias="propertyKeys", description="A list of property keys from the 'Instrument', 'Transaction', 'Portfolio', 'Account', 'LegalEntity' or 'CustodianAccount' domain to decorate onto the JELine.")
-    __properties = ["startDate", "endDate", "filter", "propertyKeys"]
-
-    @validator('filter')
-    def filter_validate_regular_expression(cls, value):
-        """Validates the regular expression"""
-        if value is None:
-            return value
-
-        if not re.match(r"^[\s\S]*$", value):
-            raise ValueError(r"must validate the regular expression /^[\s\S]*$/")
-        return value
-
-    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) -> JELinesQueryParameters:
-        """Create an instance of JELinesQueryParameters 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 start_date (nullable) is None
-        # and __fields_set__ contains the field
-        if self.start_date is None and "start_date" in self.__fields_set__:
-            _dict['startDate'] = None
-
-        # set to None if end_date (nullable) is None
-        # and __fields_set__ contains the field
-        if self.end_date is None and "end_date" in self.__fields_set__:
-            _dict['endDate'] = None
-
-        # set to None if filter (nullable) is None
-        # and __fields_set__ contains the field
-        if self.filter is None and "filter" in self.__fields_set__:
-            _dict['filter'] = None
-
-        # set to None if property_keys (nullable) is None
-        # and __fields_set__ contains the field
-        if self.property_keys is None and "property_keys" in self.__fields_set__:
-            _dict['propertyKeys'] = None
-
-        return _dict
-
-    @classmethod
-    def from_dict(cls, obj: dict) -> JELinesQueryParameters:
-        """Create an instance of JELinesQueryParameters from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return JELinesQueryParameters.parse_obj(obj)
-
-        _obj = JELinesQueryParameters.parse_obj({
-            "start_date": obj.get("startDate"),
-            "end_date": obj.get("endDate"),
-            "filter": obj.get("filter"),
-            "property_keys": obj.get("propertyKeys")
-        })
-        return _obj

lusid/models/look_up_pricing_model_options.py

@@ -1,93 +0,0 @@
-# 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 import Field, StrictBool, StrictStr, validator
-from lusid.models.model_options import ModelOptions
-
-class LookUpPricingModelOptions(ModelOptions):
-    """
-    Model options for look up pricing.  # noqa: E501
-    """
-    add_accrual: StrictBool = Field(..., alias="addAccrual", description="Add Instrument Accrual to Valuation")
-    apply_index_ratio: StrictBool = Field(..., alias="applyIndexRatio", description="Apply Index Ratio to price before valuation.  Used for InflationLinkedBond")
-    model_options_type: StrictStr = Field(..., alias="modelOptionsType", description="The available values are: Invalid, OpaqueModelOptions, EmptyModelOptions, IndexModelOptions, FxForwardModelOptions, FundingLegModelOptions, EquityModelOptions, LookUpPricingModelOptions")
-    additional_properties: Dict[str, Any] = {}
-    __properties = ["modelOptionsType", "addAccrual", "applyIndexRatio"]
-
-    @validator('model_options_type')
-    def model_options_type_validate_enum(cls, value):
-        """Validates the enum"""
-        if value not in ('Invalid', 'OpaqueModelOptions', 'EmptyModelOptions', 'IndexModelOptions', 'FxForwardModelOptions', 'FundingLegModelOptions', 'EquityModelOptions', 'LookUpPricingModelOptions'):
-            raise ValueError("must be one of enum values ('Invalid', 'OpaqueModelOptions', 'EmptyModelOptions', 'IndexModelOptions', 'FxForwardModelOptions', 'FundingLegModelOptions', 'EquityModelOptions', 'LookUpPricingModelOptions')")
-        return value
-
-    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) -> LookUpPricingModelOptions:
-        """Create an instance of LookUpPricingModelOptions 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={
-                            "additional_properties"
-                          },
-                          exclude_none=True)
-        # puts key-value pairs in additional_properties in the top level
-        if self.additional_properties is not None:
-            for _key, _value in self.additional_properties.items():
-                _dict[_key] = _value
-
-        return _dict
-
-    @classmethod
-    def from_dict(cls, obj: dict) -> LookUpPricingModelOptions:
-        """Create an instance of LookUpPricingModelOptions from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return LookUpPricingModelOptions.parse_obj(obj)
-
-        _obj = LookUpPricingModelOptions.parse_obj({
-            "model_options_type": obj.get("modelOptionsType"),
-            "add_accrual": obj.get("addAccrual"),
-            "apply_index_ratio": obj.get("applyIndexRatio")
-        })
-        # store additional fields in additional_properties
-        for _key in obj.keys():
-            if _key not in cls.__properties:
-                _obj.additional_properties[_key] = obj.get(_key)
-
-        return _obj

lusid/models/reconciliation_break_id.py

@@ -1,88 +0,0 @@
-# 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 import BaseModel, Field, StrictStr
-from lusid.models.reconciliation_run_id import ReconciliationRunId
-
-class ReconciliationBreakId(BaseModel):
-    """
-    ReconciliationBreakId
-    """
-    reconciliation_run: Optional[ReconciliationRunId] = Field(None, alias="reconciliationRun")
-    break_id: Optional[StrictStr] = Field(None, alias="breakId")
-    as_string: Optional[StrictStr] = Field(None, alias="asString")
-    __properties = ["reconciliationRun", "breakId", "asString"]
-
-    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) -> ReconciliationBreakId:
-        """Create an instance of ReconciliationBreakId 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={
-                            "as_string",
-                          },
-                          exclude_none=True)
-        # override the default output from pydantic by calling `to_dict()` of reconciliation_run
-        if self.reconciliation_run:
-            _dict['reconciliationRun'] = self.reconciliation_run.to_dict()
-        # set to None if break_id (nullable) is None
-        # and __fields_set__ contains the field
-        if self.break_id is None and "break_id" in self.__fields_set__:
-            _dict['breakId'] = None
-
-        # set to None if as_string (nullable) is None
-        # and __fields_set__ contains the field
-        if self.as_string is None and "as_string" in self.__fields_set__:
-            _dict['asString'] = None
-
-        return _dict
-
-    @classmethod
-    def from_dict(cls, obj: dict) -> ReconciliationBreakId:
-        """Create an instance of ReconciliationBreakId from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return ReconciliationBreakId.parse_obj(obj)
-
-        _obj = ReconciliationBreakId.parse_obj({
-            "reconciliation_run": ReconciliationRunId.from_dict(obj.get("reconciliationRun")) if obj.get("reconciliationRun") is not None else None,
-            "break_id": obj.get("breakId"),
-            "as_string": obj.get("asString")
-        })
-        return _obj

lusid/models/reconciliation_run_id.py

@@ -1,85 +0,0 @@
-# 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 import BaseModel, Field, StrictInt, StrictStr
-from lusid.models.reconciliation_id import ReconciliationId
-
-class ReconciliationRunId(BaseModel):
-    """
-    ReconciliationRunId
-    """
-    reconciliation: Optional[ReconciliationId] = None
-    var_date: Optional[datetime] = Field(None, alias="date")
-    version: Optional[StrictInt] = None
-    as_string: Optional[StrictStr] = Field(None, alias="asString")
-    __properties = ["reconciliation", "date", "version", "asString"]
-
-    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) -> ReconciliationRunId:
-        """Create an instance of ReconciliationRunId 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={
-                            "as_string",
-                          },
-                          exclude_none=True)
-        # override the default output from pydantic by calling `to_dict()` of reconciliation
-        if self.reconciliation:
-            _dict['reconciliation'] = self.reconciliation.to_dict()
-        # set to None if as_string (nullable) is None
-        # and __fields_set__ contains the field
-        if self.as_string is None and "as_string" in self.__fields_set__:
-            _dict['asString'] = None
-
-        return _dict
-
-    @classmethod
-    def from_dict(cls, obj: dict) -> ReconciliationRunId:
-        """Create an instance of ReconciliationRunId from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return ReconciliationRunId.parse_obj(obj)
-
-        _obj = ReconciliationRunId.parse_obj({
-            "reconciliation": ReconciliationId.from_dict(obj.get("reconciliation")) if obj.get("reconciliation") is not None else None,
-            "var_date": obj.get("date"),
-            "version": obj.get("version"),
-            "as_string": obj.get("asString")
-        })
-        return _obj