visier-platform-sdk 22222222.99201.1914b1__py3-none-any.whl → 22222222.99201.1925__py3-none-any.whl

visier_platform_sdk/models/cell_set_axis_position_dto.py

@@ -0,0 +1,92 @@
+# 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.1925
+    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, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class CellSetAxisPositionDTO(BaseModel):
+    """
+    The position along the axis of a cell set.
+    """ # noqa: E501
+    path: Optional[List[StrictStr]] = Field(default=None, description="A list of strings representing the members within a dimension path. For example,  a dimension for Location may have the paths \"Canada, BC, Vancouver\" and \"US, California, San Francisco\".")
+    display_name: Optional[StrictStr] = Field(default=None, description="The display name of the position. This is optional and is omitted if unavailable or not requested.", alias="displayName")
+    display_name_path: Optional[List[StrictStr]] = Field(default=None, description="Optional display name path of the member.", alias="displayNamePath")
+    __properties: ClassVar[List[str]] = ["path", "displayName", "displayNamePath"]
+
+    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 CellSetAxisPositionDTO 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 CellSetAxisPositionDTO from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "path": obj.get("path"),
+            "displayName": obj.get("displayName"),
+            "displayNamePath": obj.get("displayNamePath")
+        })
+        return _obj
+
+

visier_platform_sdk/models/cell_set_dto.py

@@ -0,0 +1,114 @@
+# 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.1925
+    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
+from typing import Any, ClassVar, Dict, List, Optional
+from visier_platform_sdk.models.cell_dto import CellDTO
+from visier_platform_sdk.models.cell_set_axis_dto import CellSetAxisDTO
+from typing import Optional, Set
+from typing_extensions import Self
+
+class CellSetDTO(BaseModel):
+    """
+    The set of cells returned from executing an aggregation query.  A CellSet represents a structured, multidimensional array of values.
+    """ # noqa: E501
+    cells: Optional[List[CellDTO]] = Field(default=None, description="The set of cells that represent the result of your query.")
+    axes: Optional[List[CellSetAxisDTO]] = Field(default=None, description="The set of axes for the cell set that represent the objects the data is grouped by.")
+    lineage: Optional[LineageDTO] = Field(default=None, description="Lineage information for this cell set. This can be omitted if the cell has no lineage or the user did not request lineage information.")
+    __properties: ClassVar[List[str]] = ["cells", "axes", "lineage"]
+
+    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 CellSetDTO 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 each item in cells (list)
+        _items = []
+        if self.cells:
+            for _item_cells in self.cells:
+                if _item_cells:
+                    _items.append(_item_cells.to_dict())
+            _dict['cells'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in axes (list)
+        _items = []
+        if self.axes:
+            for _item_axes in self.axes:
+                if _item_axes:
+                    _items.append(_item_axes.to_dict())
+            _dict['axes'] = _items
+        # override the default output from pydantic by calling `to_dict()` of lineage
+        if self.lineage:
+            _dict['lineage'] = self.lineage.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CellSetDTO from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "cells": [CellDTO.from_dict(_item) for _item in obj["cells"]] if obj.get("cells") is not None else None,
+            "axes": [CellSetAxisDTO.from_dict(_item) for _item in obj["axes"]] if obj.get("axes") is not None else None,
+            "lineage": LineageDTO.from_dict(obj["lineage"]) if obj.get("lineage") is not None else None
+        })
+        return _obj
+
+from visier_platform_sdk.models.lineage_dto import LineageDTO
+# TODO: Rewrite to not use raise_errors
+CellSetDTO.model_rebuild(raise_errors=False)
+

visier_platform_sdk/models/cell_set_or_error_dto.py

@@ -0,0 +1,98 @@
+# 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.1925
+    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
+from typing import Any, ClassVar, Dict, List, Optional
+from visier_platform_sdk.models.cell_set_dto import CellSetDTO
+from visier_platform_sdk.models.query_execution_error_dto import QueryExecutionErrorDTO
+from typing import Optional, Set
+from typing_extensions import Self
+
+class CellSetOrErrorDTO(BaseModel):
+    """
+    A result that is either a cell set for a successful query execution, or an error for a failed query execution.
+    """ # noqa: E501
+    cell_set: Optional[CellSetDTO] = Field(default=None, description="The resulting cell set from a successful query execution.", alias="cellSet")
+    error: Optional[QueryExecutionErrorDTO] = Field(default=None, description="An error for a failed query execution.")
+    __properties: ClassVar[List[str]] = ["cellSet", "error"]
+
+    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 CellSetOrErrorDTO 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 cell_set
+        if self.cell_set:
+            _dict['cellSet'] = self.cell_set.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of error
+        if self.error:
+            _dict['error'] = self.error.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CellSetOrErrorDTO from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "cellSet": CellSetDTO.from_dict(obj["cellSet"]) if obj.get("cellSet") is not None else None,
+            "error": QueryExecutionErrorDTO.from_dict(obj["error"]) if obj.get("error") is not None else None
+        })
+        return _obj
+
+

visier_platform_sdk/models/clone_files_into_source_parameters_dto.py

@@ -0,0 +1,96 @@
+# 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.1925
+    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, Optional
+from visier_platform_sdk.models.date_range_dto import DateRangeDTO
+from typing import Optional, Set
+from typing_extensions import Self
+
+class CloneFilesIntoSourceParametersDTO(BaseModel):
+    """
+    The parameters for the `cloneFilesIntoSource` option, such as the source to clone files from, the source to clone files into, and the date range of the files to clone.
+    """ # noqa: E501
+    origin_source: Optional[StrictStr] = Field(default=None, description="The unique identifier of the source to clone files from.", alias="originSource")
+    target_source: Optional[StrictStr] = Field(default=None, description="The unique identifier of the source to clone files into.", alias="targetSource")
+    date_range: Optional[DateRangeDTO] = Field(default=None, description="The date range of the files to clone. If undefined, clones all files.", alias="dateRange")
+    __properties: ClassVar[List[str]] = ["originSource", "targetSource", "dateRange"]
+
+    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 CloneFilesIntoSourceParametersDTO 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 date_range
+        if self.date_range:
+            _dict['dateRange'] = self.date_range.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CloneFilesIntoSourceParametersDTO from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "originSource": obj.get("originSource"),
+            "targetSource": obj.get("targetSource"),
+            "dateRange": DateRangeDTO.from_dict(obj["dateRange"]) if obj.get("dateRange") is not None else None
+        })
+        return _obj
+
+

visier_platform_sdk/models/cohort_filter_dto.py

@@ -0,0 +1,100 @@
+# 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.1925
+    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, StrictBool
+from typing import Any, ClassVar, Dict, List, Optional
+from visier_platform_sdk.models.key_group_filter_dto import KeyGroupFilterDTO
+from visier_platform_sdk.models.query_time_interval_dto import QueryTimeIntervalDTO
+from typing import Optional, Set
+from typing_extensions import Self
+
+class CohortFilterDTO(BaseModel):
+    """
+    Use a cohort filter to define a population as it existed during a specific time period.  Cohort filters allow you to define a population in terms of a collection of filters, known as a key group.  The cohort's defined time interval is independent of the query's time. The cohort's time interval is the  time at which the key group should be applied.  Cohorts are typically used to follow populations and understand changes to the population over time,  such as promotion and resignation rates.
+    """ # noqa: E501
+    key_group: Optional[KeyGroupFilterDTO] = Field(default=None, description="A key group is a collection of filters that define the shape of the analysis population.", alias="keyGroup")
+    exclude: Optional[StrictBool] = Field(default=None, description="If true, the population is defined by those excluded by the filters. Default is false.")
+    time_interval: Optional[QueryTimeIntervalDTO] = Field(default=None, description="The time at which to apply the key group, such as a specific day or period of months.", alias="timeInterval")
+    __properties: ClassVar[List[str]] = ["keyGroup", "exclude", "timeInterval"]
+
+    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 CohortFilterDTO 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 key_group
+        if self.key_group:
+            _dict['keyGroup'] = self.key_group.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of time_interval
+        if self.time_interval:
+            _dict['timeInterval'] = self.time_interval.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CohortFilterDTO from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "keyGroup": KeyGroupFilterDTO.from_dict(obj["keyGroup"]) if obj.get("keyGroup") is not None else None,
+            "exclude": obj.get("exclude"),
+            "timeInterval": QueryTimeIntervalDTO.from_dict(obj["timeInterval"]) if obj.get("timeInterval") is not None else None
+        })
+        return _obj
+
+

visier_platform_sdk/models/commit_and_publish_operation_response_dto.py

@@ -0,0 +1,92 @@
+# 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.1925
+    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
+from typing import Any, ClassVar, Dict, List, Optional
+from visier_platform_sdk.models.project_dto import ProjectDTO
+from typing import Optional, Set
+from typing_extensions import Self
+
+class CommitAndPublishOperationResponseDTO(BaseModel):
+    """
+    CommitAndPublishOperationResponseDTO
+    """ # noqa: E501
+    published_version: Optional[ProjectDTO] = Field(default=None, description="The project version that was published to production.", alias="publishedVersion")
+    __properties: ClassVar[List[str]] = ["publishedVersion"]
+
+    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 CommitAndPublishOperationResponseDTO 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 published_version
+        if self.published_version:
+            _dict['publishedVersion'] = self.published_version.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CommitAndPublishOperationResponseDTO from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "publishedVersion": ProjectDTO.from_dict(obj["publishedVersion"]) if obj.get("publishedVersion") is not None else None
+        })
+        return _obj
+
+

visier_platform_sdk/models/commit_dto.py

@@ -0,0 +1,92 @@
+# 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.1925
+    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, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class CommitDTO(BaseModel):
+    """
+    CommitDTO
+    """ # noqa: E501
+    id: Optional[StrictStr] = Field(default=None, description="The unique ID of the committed change.")
+    name: Optional[StrictStr] = Field(default=None, description="An identifiable name of the committed change to display in Visier.")
+    description: Optional[StrictStr] = Field(default=None, description="A description of the committed change.")
+    __properties: ClassVar[List[str]] = ["id", "name", "description"]
+
+    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 CommitDTO 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 CommitDTO from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "id": obj.get("id"),
+            "name": obj.get("name"),
+            "description": obj.get("description")
+        })
+        return _obj
+
+