visier-platform-sdk 22222222.99201.1993__py3-none-any.whl → 22222222.99201.2027__py3-none-any.whl

visier_platform_sdk/models/query_time_interval_dto_with_dynamic_date_from.py

@@ -0,0 +1,95 @@
+# coding: utf-8
+
+"""
+    API Reference
+
+    Detailed API reference documentation for Visier APIs. Includes all endpoints, headers, path parameters, query parameters, request body schema, response schema, JSON request samples, and JSON response samples.
+
+    The version of the OpenAPI document: 22222222.99201.2027
+    Contact: alpine@visier.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class QueryTimeIntervalDTOWithDynamicDateFrom(BaseModel):
+    """
+    QueryTimeIntervalDTOWithDynamicDateFrom
+    """ # noqa: E501
+    dynamic_date_from: StrictStr = Field(description="Dynamically select the date from which to extend in the specified `direction`. Valid values are `SOURCE` or `COMPLETE_PERIOD`. Both options determine the date using the request's `source` field. Whether the source is a metric, formula, or metrics, each source has earliest and latest data available dates to use. The `direction` determines whether the earliest or latest date is used.   * If `dynamicDateFrom` is `SOURCE`, the query returns data from a date determined by the `source` query definition element. If `dynamicDateFrom` is `COMPLETE_PERIOD`, the query returns data starting from the latest or earliest date with a complete period of data. `COMPLETE_PERIOD` returns periods defined by `intervalPeriodType`. If the period type is MONTH, it returns full months of data. If the period type is YEAR, it returns full years of data. When `dynamicDateFrom` is specified:  * If `source` is `metric`, then `dynamicDateFrom` considers the date range of available data for the metric.  * If `source` is `formula`, then `dynamicDateFrom` considers the date range of available data for the metric in the formula.  * If `source` is `analyticObject`, then `dynamicDateFrom` considers the date range of available data for the analytic object.  Then, if `direction` is `BACKWARD`, query backward from the data **end** date and if `direction` is `FORWARD`, query forward from the data **start** date.  This allows you to keep getting the latest or earliest data without changing your query every time there's new or updated data.    Example: If a tenant has Headcount metric data available from 2023-01-01 to 2024-01-01 (End date exclusive), specifying `dynamicDateFrom`: `SOURCE` with `direction`: `BACKWARD`  means the query will retrieve data backward from 2024-01-01. The effect is the same as if specifying a `fromDateTime` of 2024-01-01'T'00:00:00.000.    Example: If a tenant has Employee subject data available from 2023-01-01 to 2024-01-01 (End date exclusive), specifying `dynamicDateFrom`: `SOURCE` with `direction`: `FORWARD`   means the query will retrieve data forward from 2023-01-01. The effect is the same as if specifying a `fromDateTime` of 2023-01-01'T'00:00:00.000.   Example: If a tenant has Employee subject data available from 2023-01-10 to 2023-04-01 (End date exclusive), specifying `dynamicDateFrom`: `COMPLETE_PERIOD` with `direction`: `FORWARD`   means the query will retrieve data forward from 2023-02-01. The effect is the same as if specifying a `fromDateTime` of 2023-02-01'T'00:00:00.000.   Example: If a tenant has Employee subject data available from 2023-01-01 to 2023-03-15 (End date exclusive), specifying `dynamicDateFrom`: `COMPLETE_PERIOD` with `direction`: `BACKWARD`   means the query will retrieve data backward from 2023-03-01. The effect is the same as if specifying a `fromDateTime` of 2023-03-01'T'00:00:00.000.   Example: Retrieve a list of EmployeeIDs for the formula extending 1 month backward from the dynamic source date   ```  {    \"source\": {      \"formula\": \"on Employee validUntil instant filterBy(isActiveEmployee) aggregate count(Employee.EmployeeID)\"    },    \"columns\": [      {        \"columnDefinition\": {          \"property\": {            \"name\": \"Employee.EmployeeID\",            \"qualifyingPath\": \"Employee\"          }        }      },      {        \"columnDefinition\": {          \"effectiveDateProperty\": {}        }      }    ],    \"timeInterval\": {      \"dynamicDateFrom\": \"SOURCE\",      \"intervalPeriodType\": \"MONTH\",      \"intervalPeriodCount\": 1,      \"direction\": \"BACKWARD\"    }  }  ```", alias="dynamicDateFrom")
+    __properties: ClassVar[List[str]] = ["dynamicDateFrom"]
+
+    @field_validator('dynamic_date_from')
+    def dynamic_date_from_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['SOURCE', 'COMPLETE_PERIOD']):
+            raise ValueError("must be one of enum values ('SOURCE', 'COMPLETE_PERIOD')")
+        return value
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of QueryTimeIntervalDTOWithDynamicDateFrom from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of QueryTimeIntervalDTOWithDynamicDateFrom from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "dynamicDateFrom": obj.get("dynamicDateFrom")
+        })
+        return _obj
+
+

visier_platform_sdk/models/query_time_interval_dto_with_from_datetime.py

@@ -0,0 +1,88 @@
+# coding: utf-8
+
+"""
+    API Reference
+
+    Detailed API reference documentation for Visier APIs. Includes all endpoints, headers, path parameters, query parameters, request body schema, response schema, JSON request samples, and JSON response samples.
+
+    The version of the OpenAPI document: 22222222.99201.2027
+    Contact: alpine@visier.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class QueryTimeIntervalDTOWithFromDatetime(BaseModel):
+    """
+    QueryTimeIntervalDTOWithFromDatetime
+    """ # noqa: E501
+    from_date_time: StrictStr = Field(description="The instant from which to extend in the specified `direction`, as an ISO-8601 formatted date time string.  Valid formats: yyyy-MM-dd, yyyy-MM-dd'T'HH:mm:ss, yyyy-MM-dd'T'HH:mm:ss.SSS.  Events that occur on this date are excluded. Subject-based data that ends on this date is included.", alias="fromDateTime")
+    __properties: ClassVar[List[str]] = ["fromDateTime"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of QueryTimeIntervalDTOWithFromDatetime from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of QueryTimeIntervalDTOWithFromDatetime from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "fromDateTime": obj.get("fromDateTime")
+        })
+        return _obj
+
+

visier_platform_sdk/models/query_time_interval_dto_with_from_instant.py

@@ -0,0 +1,88 @@
+# coding: utf-8
+
+"""
+    API Reference
+
+    Detailed API reference documentation for Visier APIs. Includes all endpoints, headers, path parameters, query parameters, request body schema, response schema, JSON request samples, and JSON response samples.
+
+    The version of the OpenAPI document: 22222222.99201.2027
+    Contact: alpine@visier.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class QueryTimeIntervalDTOWithFromInstant(BaseModel):
+    """
+    QueryTimeIntervalDTOWithFromInstant
+    """ # noqa: E501
+    from_instant: StrictStr = Field(description="The instant from which to extend in the specified `direction`, in milliseconds since 1970-01-01T00:00:00Z.  Events that occur on this date are excluded. Subject-based data that ends on this date is included.  Note: Epochs are expressed as 64-bit integers and represented as stringified longs in JSON due to  JSON's inherent limitation in representing large numbers.", alias="fromInstant")
+    __properties: ClassVar[List[str]] = ["fromInstant"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of QueryTimeIntervalDTOWithFromInstant from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of QueryTimeIntervalDTOWithFromInstant from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "fromInstant": obj.get("fromInstant")
+        })
+        return _obj
+
+

visier_platform_sdk/models/query_time_intervals_dto.py

@@ -5,7 +5,7 @@
 
     Detailed API reference documentation for Visier APIs. Includes all endpoints, headers, path parameters, query parameters, request body schema, response schema, JSON request samples, and JSON response samples.
 
-    The version of the OpenAPI document: 22222222.99201.1993
+    The version of the OpenAPI document: 22222222.99201.2027
     Contact: alpine@visier.com
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
@@ -14,137 +14,139 @@
 
 
 from __future__ import annotations
-import pprint
-import re  # noqa: F401
 import json
+import pprint
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, ValidationError, field_validator
+from typing import Any, List, Optional
+from visier_platform_sdk.models.query_time_intervals_dto_with_dynamic_date_from import QueryTimeIntervalsDTOWithDynamicDateFrom
+from visier_platform_sdk.models.query_time_intervals_dto_with_from_datetime import QueryTimeIntervalsDTOWithFromDatetime
+from visier_platform_sdk.models.query_time_intervals_dto_with_from_instant import QueryTimeIntervalsDTOWithFromInstant
+from pydantic import StrictStr, Field
+from typing import Union, List, Set, Optional, Dict
+from typing_extensions import Literal, Self
 
-from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr, field_validator
-from typing import Any, ClassVar, Dict, List, Optional
-from visier_platform_sdk.models.time_shift_dto import TimeShiftDTO
-from typing import Optional, Set
-from typing_extensions import Self
+QUERYTIMEINTERVALSDTO_ONE_OF_SCHEMAS = ["QueryTimeIntervalsDTOWithDynamicDateFrom", "QueryTimeIntervalsDTOWithFromDatetime", "QueryTimeIntervalsDTOWithFromInstant"]
 
 class QueryTimeIntervalsDTO(BaseModel):
     """
     A QueryTimeIntervals defines a series of time intervals to query, including the \"from\" time, period type, period count,  number of intervals, time direction, and shift to apply to each time interval.
-    """ # noqa: E501
-    from_instant: Optional[StrictStr] = Field(default=None, description="The instant from which to extend, in milliseconds since 1970-01-01T00:00:00Z.  Events that occur on this date are excluded. Subject-based data that ends on this date is included.  Note: Epochs are expressed as 64-bit integers and represented as stringified longs in JSON due to JSON's  inherent limitation in representing large numbers.", alias="fromInstant")
-    from_date_time: Optional[StrictStr] = Field(default=None, description="The instant from which to extend, as an ISO-8601 formatted date time string. This value is exclusive.  Valid formats: yyyy-MM-dd, yyyy-MM-dd'T'HH:mm:ss, yyyy-MM-dd'T'HH:mm:ss.SSS.  Events that occur on this date are excluded. Subject-based data that ends on this date is included.", alias="fromDateTime")
-    dynamic_date_from: Optional[StrictStr] = Field(default=None, description="Dynamically select the date from which to extend. Valid values are `SOURCE` or `COMPLETE_PERIOD`. Both options use the `source` query definition element to determine the date.   If `dynamicDateFrom` is `SOURCE`, the query returns data from a date determined by the `source` query definition element. If `dynamicDateFrom` is `COMPLETE_PERIOD`, the query returns data starting from the latest or earliest date with a complete period of data. When `dynamicDateFrom` is specified:  * If `source` is `metric`, then `dynamicDateFrom` considers the date range of available data for the metric.  * If `source` is `formula`, then `dynamicDateFrom` considers the date range of available data for the metric in the formula.  * If `source` is `metrics`, then `dynamicDateFrom` considers the date range of available data for the metric in the formula.  Then, if `direction` is `BACKWARD`, query backward from the data **end** date and if `direction` is `FORWARD`, query forward from the data **start** date.   This allows you to keep getting the latest or earliest data without changing your query every time there's new or updated data.   Note: For multi-metric queries, if `direction` is `BACKWARD`, query backward from the earliest data end date of all metrics and if `direction` is `FORWARD`, query forward from the latest data start date of all metrics.   This ensures that all metrics have data in the specified time range.   Example: If a tenant has Headcount metric data available from 2023-01-01 to 2024-01-01 (End date exclusive), specifying `dynamicDateFrom`: `SOURCE` with `direction`: `BACKWARD`   means the query will retrieve data backward from 2024-01-01. The effect is the same as if specifying a `fromDateTime` of 2024-01-01'T'00:00:00.000.    Example: If a tenant has Employee subject data available from 2023-01-10 to 2023-04-01 (End date exclusive), specifying `dynamicDateFrom`: `COMPLETE_PERIOD` with `direction`: `FORWARD`   means the query will retrieve data forward from 2023-02-01. The effect is the same as if specifying a `fromDateTime` of 2023-02-01'T'00:00:00.000.    Example: If a tenant has Employee subject data available from 2023-01-01 to 2023-03-15 (End date exclusive), specifying `dynamicDateFrom`: `COMPLETE_PERIOD` with `direction`: `BACKWARD`   means the query will retrieve data backward from 2023-03-01. The effect is the same as if specifying a `fromDateTime` of 2023-03-01'T'00:00:00.000.    Example: If a tenant has Headcount data available from 2023-01-01 to 2024-09-01 and Exit Count data available from 2023-01-01 to 2024-01-01, specifying `dynamicDateFrom`: `SOURCE` with `direction`: `BACKWARD` means the query will retrieve data backward from 2024-01-01.   Exit Count has an earlier data end date than Headcount, so `dynamicDateFrom` retrieves data backward from Exit Count's data end date to ensure both metrics have data in the specified time range.   Example: Retrieve Headcount (employeeCount) extending 1 month backward from Headcount's dynamic source date       {           \"query\": {               \"source\": {                   \"metric\": \"employeeCount\"               },               \"timeIntervals\": {                   \"dynamicDateFrom\": \"SOURCE\",                   \"intervalPeriodType\": \"MONTH\",                   \"intervalCount\": 1,                   \"direction\": \"BACKWARD\"               }           }       }", alias="dynamicDateFrom")
-    interval_period_type: Optional[StrictStr] = Field(default=None, description="The time period type for each interval. Default is MONTH.", alias="intervalPeriodType")
-    interval_period_count: Optional[StrictInt] = Field(default=None, description="The number of time periods per interval. Default is 1.", alias="intervalPeriodCount")
-    interval_count: Optional[StrictInt] = Field(default=None, description="The number of intervals. Default is 1.", alias="intervalCount")
-    direction: Optional[StrictStr] = Field(default=None, description="The direction to extend. Defaults is BACKWARD.")
-    shift: Optional[TimeShiftDTO] = Field(default=None, description="The amount of time to shift the time interval by, such as backward by one year.")
-    trailing_period_type: Optional[StrictStr] = Field(default=None, description="The time period type for each trailing period. If `trailingPeriodCount` is defined and `trailingPeriodType` is undefined, the default trailing period type is `MONTH`.  If both `trailingPeriodType` and `trailingPeriodCount` are undefined, `intervalPeriodCount` is used as the trailing period count.  Note: This parameter is only applicable to metrics that can calculate trailing time. If defined on a metric that doesn't have trailing time, the platform ignores the parameter.", alias="trailingPeriodType")
-    trailing_period_count: Optional[StrictInt] = Field(default=None, description="The number of time periods per trailing period. If `trailingPeriodType` is defined and `trailingPeriodCount` is undefined, the default trailing period count is 1.  Note: This parameter is only applicable to metrics that can calculate trailing time. If defined on a metric that doesn't have trailing time, the platform ignores the parameter.", alias="trailingPeriodCount")
-    __properties: ClassVar[List[str]] = ["fromInstant", "fromDateTime", "dynamicDateFrom", "intervalPeriodType", "intervalPeriodCount", "intervalCount", "direction", "shift", "trailingPeriodType", "trailingPeriodCount"]
-
-    @field_validator('dynamic_date_from')
-    def dynamic_date_from_validate_enum(cls, value):
-        """Validates the enum"""
-        if value is None:
-            return value
-
-        if value not in set(['SOURCE', 'COMPLETE_PERIOD']):
-            raise ValueError("must be one of enum values ('SOURCE', 'COMPLETE_PERIOD')")
-        return value
-
-    @field_validator('interval_period_type')
-    def interval_period_type_validate_enum(cls, value):
-        """Validates the enum"""
-        if value is None:
-            return value
-
-        if value not in set(['MONTH', 'DAY', 'WEEK', 'QUARTER', 'YEAR']):
-            raise ValueError("must be one of enum values ('MONTH', 'DAY', 'WEEK', 'QUARTER', 'YEAR')")
-        return value
-
-    @field_validator('direction')
-    def direction_validate_enum(cls, value):
-        """Validates the enum"""
-        if value is None:
-            return value
-
-        if value not in set(['BACKWARD', 'FORWARD']):
-            raise ValueError("must be one of enum values ('BACKWARD', 'FORWARD')")
-        return value
-
-    @field_validator('trailing_period_type')
-    def trailing_period_type_validate_enum(cls, value):
-        """Validates the enum"""
-        if value is None:
-            return value
-
-        if value not in set(['MONTH', 'DAY', 'WEEK', 'QUARTER', 'YEAR']):
-            raise ValueError("must be one of enum values ('MONTH', 'DAY', 'WEEK', 'QUARTER', 'YEAR')")
-        return value
+    """
+    # data type: QueryTimeIntervalsDTOWithFromInstant
+    oneof_schema_1_validator: Optional[QueryTimeIntervalsDTOWithFromInstant] = None
+    # data type: QueryTimeIntervalsDTOWithFromDatetime
+    oneof_schema_2_validator: Optional[QueryTimeIntervalsDTOWithFromDatetime] = None
+    # data type: QueryTimeIntervalsDTOWithDynamicDateFrom
+    oneof_schema_3_validator: Optional[QueryTimeIntervalsDTOWithDynamicDateFrom] = None
+    actual_instance: Optional[Union[QueryTimeIntervalsDTOWithDynamicDateFrom, QueryTimeIntervalsDTOWithFromDatetime, QueryTimeIntervalsDTOWithFromInstant]] = None
+    one_of_schemas: Set[str] = { "QueryTimeIntervalsDTOWithDynamicDateFrom", "QueryTimeIntervalsDTOWithFromDatetime", "QueryTimeIntervalsDTOWithFromInstant" }
 
     model_config = ConfigDict(
-        populate_by_name=True,
         validate_assignment=True,
         protected_namespaces=(),
     )
 
 
-    def to_str(self) -> str:
-        """Returns the string representation of the model using alias"""
-        return pprint.pformat(self.model_dump(by_alias=True))
-
-    def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
-        return json.dumps(self.to_dict())
+    def __init__(self, *args, **kwargs) -> None:
+        if args:
+            if len(args) > 1:
+                raise ValueError("If a position argument is used, only 1 is allowed to set `actual_instance`")
+            if kwargs:
+                raise ValueError("If a position argument is used, keyword arguments cannot be used.")
+            super().__init__(actual_instance=args[0])
+        else:
+            super().__init__(**kwargs)
+
+    @field_validator('actual_instance')
+    def actual_instance_must_validate_oneof(cls, v):
+        instance = QueryTimeIntervalsDTO.model_construct()
+        error_messages = []
+        match = 0
+        # validate data type: QueryTimeIntervalsDTOWithFromInstant
+        if not isinstance(v, QueryTimeIntervalsDTOWithFromInstant):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `QueryTimeIntervalsDTOWithFromInstant`")
+        else:
+            match += 1
+        # validate data type: QueryTimeIntervalsDTOWithFromDatetime
+        if not isinstance(v, QueryTimeIntervalsDTOWithFromDatetime):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `QueryTimeIntervalsDTOWithFromDatetime`")
+        else:
+            match += 1
+        # validate data type: QueryTimeIntervalsDTOWithDynamicDateFrom
+        if not isinstance(v, QueryTimeIntervalsDTOWithDynamicDateFrom):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `QueryTimeIntervalsDTOWithDynamicDateFrom`")
+        else:
+            match += 1
+        if match > 1:
+            # more than 1 match
+            raise ValueError("Multiple matches found when setting `actual_instance` in QueryTimeIntervalsDTO with oneOf schemas: QueryTimeIntervalsDTOWithDynamicDateFrom, QueryTimeIntervalsDTOWithFromDatetime, QueryTimeIntervalsDTOWithFromInstant. Details: " + ", ".join(error_messages))
+        elif match == 0:
+            # no match
+            raise ValueError("No match found when setting `actual_instance` in QueryTimeIntervalsDTO with oneOf schemas: QueryTimeIntervalsDTOWithDynamicDateFrom, QueryTimeIntervalsDTOWithFromDatetime, QueryTimeIntervalsDTOWithFromInstant. Details: " + ", ".join(error_messages))
+        else:
+            return v
 
     @classmethod
-    def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of QueryTimeIntervalsDTO from a JSON string"""
-        return cls.from_dict(json.loads(json_str))
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Return the dictionary representation of the model using alias.
-
-        This has the following differences from calling pydantic's
-        `self.model_dump(by_alias=True)`:
-
-        * `None` is only added to the output dict for nullable fields that
-          were set at model initialization. Other fields with value `None`
-          are ignored.
-        """
-        excluded_fields: Set[str] = set([
-        ])
-
-        _dict = self.model_dump(
-            by_alias=True,
-            exclude=excluded_fields,
-            exclude_none=True,
-        )
-        # override the default output from pydantic by calling `to_dict()` of shift
-        if self.shift:
-            _dict['shift'] = self.shift.to_dict()
-        return _dict
+    def from_dict(cls, obj: Union[str, Dict[str, Any]]) -> Self:
+        return cls.from_json(json.dumps(obj))
 
     @classmethod
-    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of QueryTimeIntervalsDTO from a dict"""
-        if obj is None:
+    def from_json(cls, json_str: str) -> Self:
+        """Returns the object represented by the json string"""
+        instance = cls.model_construct()
+        error_messages = []
+        match = 0
+
+        # deserialize data into QueryTimeIntervalsDTOWithFromInstant
+        try:
+            instance.actual_instance = QueryTimeIntervalsDTOWithFromInstant.from_json(json_str)
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # deserialize data into QueryTimeIntervalsDTOWithFromDatetime
+        try:
+            instance.actual_instance = QueryTimeIntervalsDTOWithFromDatetime.from_json(json_str)
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # deserialize data into QueryTimeIntervalsDTOWithDynamicDateFrom
+        try:
+            instance.actual_instance = QueryTimeIntervalsDTOWithDynamicDateFrom.from_json(json_str)
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+
+        if match > 1:
+            # more than 1 match
+            raise ValueError("Multiple matches found when deserializing the JSON string into QueryTimeIntervalsDTO with oneOf schemas: QueryTimeIntervalsDTOWithDynamicDateFrom, QueryTimeIntervalsDTOWithFromDatetime, QueryTimeIntervalsDTOWithFromInstant. Details: " + ", ".join(error_messages))
+        elif match == 0:
+            # no match
+            raise ValueError("No match found when deserializing the JSON string into QueryTimeIntervalsDTO with oneOf schemas: QueryTimeIntervalsDTOWithDynamicDateFrom, QueryTimeIntervalsDTOWithFromDatetime, QueryTimeIntervalsDTOWithFromInstant. Details: " + ", ".join(error_messages))
+        else:
+            return instance
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the actual instance"""
+        if self.actual_instance is None:
+            return "null"
+
+        if hasattr(self.actual_instance, "to_json") and callable(self.actual_instance.to_json):
+            return self.actual_instance.to_json()
+        else:
+            return json.dumps(self.actual_instance)
+
+    def to_dict(self) -> Optional[Union[Dict[str, Any], QueryTimeIntervalsDTOWithDynamicDateFrom, QueryTimeIntervalsDTOWithFromDatetime, QueryTimeIntervalsDTOWithFromInstant]]:
+        """Returns the dict representation of the actual instance"""
+        if self.actual_instance is None:
             return None
 
-        if not isinstance(obj, dict):
-            return cls.model_validate(obj)
-
-        _obj = cls.model_validate({
-            "fromInstant": obj.get("fromInstant"),
-            "fromDateTime": obj.get("fromDateTime"),
-            "dynamicDateFrom": obj.get("dynamicDateFrom"),
-            "intervalPeriodType": obj.get("intervalPeriodType"),
-            "intervalPeriodCount": obj.get("intervalPeriodCount"),
-            "intervalCount": obj.get("intervalCount"),
-            "direction": obj.get("direction"),
-            "shift": TimeShiftDTO.from_dict(obj["shift"]) if obj.get("shift") is not None else None,
-            "trailingPeriodType": obj.get("trailingPeriodType"),
-            "trailingPeriodCount": obj.get("trailingPeriodCount")
-        })
-        return _obj
+        if hasattr(self.actual_instance, "to_dict") and callable(self.actual_instance.to_dict):
+            return self.actual_instance.to_dict()
+        else:
+            # primitive type
+            return self.actual_instance
+
+    def to_str(self) -> str:
+        """Returns the string representation of the actual instance"""
+        return pprint.pformat(self.model_dump())
 
 

visier_platform_sdk/models/query_time_intervals_dto_with_dynamic_date_from.py

@@ -0,0 +1,95 @@
+# coding: utf-8
+
+"""
+    API Reference
+
+    Detailed API reference documentation for Visier APIs. Includes all endpoints, headers, path parameters, query parameters, request body schema, response schema, JSON request samples, and JSON response samples.
+
+    The version of the OpenAPI document: 22222222.99201.2027
+    Contact: alpine@visier.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class QueryTimeIntervalsDTOWithDynamicDateFrom(BaseModel):
+    """
+    QueryTimeIntervalsDTOWithDynamicDateFrom
+    """ # noqa: E501
+    dynamic_date_from: StrictStr = Field(description="Dynamically select the date from which to extend. Valid values are `SOURCE` or `COMPLETE_PERIOD`. Both options use the `source` query definition element to determine the date.   If `dynamicDateFrom` is `SOURCE`, the query returns data from a date determined by the `source` query definition element. If `dynamicDateFrom` is `COMPLETE_PERIOD`, the query returns data starting from the latest or earliest date with a complete period of data. When `dynamicDateFrom` is specified:  * If `source` is `metric`, then `dynamicDateFrom` considers the date range of available data for the metric.  * If `source` is `formula`, then `dynamicDateFrom` considers the date range of available data for the metric in the formula.  * If `source` is `metrics`, then `dynamicDateFrom` considers the date range of available data for the metric in the formula.  Then, if `direction` is `BACKWARD`, query backward from the data **end** date and if `direction` is `FORWARD`, query forward from the data **start** date.   This allows you to keep getting the latest or earliest data without changing your query every time there's new or updated data.   Note: For multi-metric queries, if `direction` is `BACKWARD`, query backward from the earliest data end date of all metrics and if `direction` is `FORWARD`, query forward from the latest data start date of all metrics.   This ensures that all metrics have data in the specified time range.   Example: If a tenant has Headcount metric data available from 2023-01-01 to 2024-01-01 (End date exclusive), specifying `dynamicDateFrom`: `SOURCE` with `direction`: `BACKWARD`   means the query will retrieve data backward from 2024-01-01. The effect is the same as if specifying a `fromDateTime` of 2024-01-01'T'00:00:00.000.    Example: If a tenant has Employee subject data available from 2023-01-10 to 2023-04-01 (End date exclusive), specifying `dynamicDateFrom`: `COMPLETE_PERIOD` with `direction`: `FORWARD`   means the query will retrieve data forward from 2023-02-01. The effect is the same as if specifying a `fromDateTime` of 2023-02-01'T'00:00:00.000.    Example: If a tenant has Employee subject data available from 2023-01-01 to 2023-03-15 (End date exclusive), specifying `dynamicDateFrom`: `COMPLETE_PERIOD` with `direction`: `BACKWARD`   means the query will retrieve data backward from 2023-03-01. The effect is the same as if specifying a `fromDateTime` of 2023-03-01'T'00:00:00.000.    Example: If a tenant has Headcount data available from 2023-01-01 to 2024-09-01 and Exit Count data available from 2023-01-01 to 2024-01-01, specifying `dynamicDateFrom`: `SOURCE` with `direction`: `BACKWARD` means the query will retrieve data backward from 2024-01-01.   Exit Count has an earlier data end date than Headcount, so `dynamicDateFrom` retrieves data backward from Exit Count's data end date to ensure both metrics have data in the specified time range.   Example: Retrieve Headcount (employeeCount) extending 1 month backward from Headcount's dynamic source date   ```  {    \"query\": {      \"source\": {        \"metric\": \"employeeCount\"      },      \"timeIntervals\": {        \"dynamicDateFrom\": \"SOURCE\",        \"intervalPeriodType\": \"MONTH\",        \"intervalCount\": 1,        \"direction\": \"BACKWARD\"      }    }  }  ```", alias="dynamicDateFrom")
+    __properties: ClassVar[List[str]] = ["dynamicDateFrom"]
+
+    @field_validator('dynamic_date_from')
+    def dynamic_date_from_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['SOURCE', 'COMPLETE_PERIOD']):
+            raise ValueError("must be one of enum values ('SOURCE', 'COMPLETE_PERIOD')")
+        return value
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of QueryTimeIntervalsDTOWithDynamicDateFrom from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of QueryTimeIntervalsDTOWithDynamicDateFrom from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "dynamicDateFrom": obj.get("dynamicDateFrom")
+        })
+        return _obj
+
+