api-sdk-py 1.11.66__py3-none-any.whl

api_sdk_py/models/composition_entries_description.py

@@ -0,0 +1,99 @@
+# coding: utf-8
+
+"""
+    Widgetic API Gateway
+
+    API documentation for the Widgetic API Gateway
+
+    The version of the OpenAPI document: 1.0.0
+    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, StrictStr
+from typing import Any, ClassVar, Dict, List
+from api_sdk_py.models.composition_entry_table import CompositionEntryTable
+from typing import Optional, Set
+from typing_extensions import Self
+
+class CompositionEntriesDescription(BaseModel):
+    """
+    CompositionEntriesDescription
+    """ # noqa: E501
+    composition_id: StrictStr = Field(description="The composition whose entries these are", alias="compositionId")
+    has_data: StrictBool = Field(description="False when the composition keeps no entries of its own: its widget only shows content (it has no database), or nothing was set up in the database yet. That is not an error. ", alias="hasData")
+    tables: List[CompositionEntryTable] = Field(description="The tables entries are kept in (up to 20)")
+    __properties: ClassVar[List[str]] = ["compositionId", "hasData", "tables"]
+
+    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 CompositionEntriesDescription 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 tables (list)
+        _items = []
+        if self.tables:
+            for _item_tables in self.tables:
+                if _item_tables:
+                    _items.append(_item_tables.to_dict())
+            _dict['tables'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CompositionEntriesDescription from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "compositionId": obj.get("compositionId"),
+            "hasData": obj.get("hasData"),
+            "tables": [CompositionEntryTable.from_dict(_item) for _item in obj["tables"]] if obj.get("tables") is not None else None
+        })
+        return _obj
+
+

api_sdk_py/models/composition_entries_description_response.py

@@ -0,0 +1,99 @@
+# coding: utf-8
+
+"""
+    Widgetic API Gateway
+
+    API documentation for the Widgetic API Gateway
+
+    The version of the OpenAPI document: 1.0.0
+    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 api_sdk_py.models.composition_entries_description import CompositionEntriesDescription
+from api_sdk_py.models.response_meta import ResponseMeta
+from typing import Optional, Set
+from typing_extensions import Self
+
+class CompositionEntriesDescriptionResponse(BaseModel):
+    """
+    CompositionEntriesDescriptionResponse
+    """ # noqa: E501
+    success: StrictBool = Field(description="Always `true` on a success.")
+    data: CompositionEntriesDescription
+    meta: Optional[ResponseMeta] = None
+    __properties: ClassVar[List[str]] = ["success", "data", "meta"]
+
+    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 CompositionEntriesDescriptionResponse 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 data
+        if self.data:
+            _dict['data'] = self.data.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of meta
+        if self.meta:
+            _dict['meta'] = self.meta.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CompositionEntriesDescriptionResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "success": obj.get("success"),
+            "data": CompositionEntriesDescription.from_dict(obj["data"]) if obj.get("data") is not None else None,
+            "meta": ResponseMeta.from_dict(obj["meta"]) if obj.get("meta") is not None else None
+        })
+        return _obj
+
+

api_sdk_py/models/composition_entries_reading.py

@@ -0,0 +1,126 @@
+# coding: utf-8
+
+"""
+    Widgetic API Gateway
+
+    API documentation for the Widgetic API Gateway
+
+    The version of the OpenAPI document: 1.0.0
+    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, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from api_sdk_py.models.composition_entry_aggregates_block import CompositionEntryAggregatesBlock
+from api_sdk_py.models.composition_entry_tally import CompositionEntryTally
+from typing import Optional, Set
+from typing_extensions import Self
+
+class CompositionEntriesReading(BaseModel):
+    """
+    CompositionEntriesReading
+    """ # noqa: E501
+    composition_id: StrictStr = Field(description="The composition whose entries these are", alias="compositionId")
+    table: StrictStr = Field(description="The table that was read")
+    total_rows: Annotated[int, Field(strict=True, ge=0)] = Field(description="How many entries the table holds in all. Not narrowed by `since`, `until` or a filter: only `aggregates` is. ", alias="totalRows")
+    tallies: Optional[List[CompositionEntryTally]] = Field(description="How many entries have each value of the `groupBy` column, largest group first (up to 20 groups), over the whole table. `null` when no `groupBy` was asked for. For the groups of a selection (a time window, a `context` filter) or for more than 20 groups, ask for `aggregate`: `aggregates.tallies` holds up to 200 groups. ")
+    more_groups: StrictBool = Field(description="True when the `groupBy` column has more than the 20 groups `tallies` lists. It speaks of `tallies` only: `aggregates.truncated` is the same signal for `aggregates` (200 groups). ", alias="moreGroups")
+    columns: List[StrictStr] = Field(description="The name of each value of an entry in `rows`, in order, exactly as the database spells it (and as `describeCompositionEntries` lists it: `created_at` stays `created_at`). Empty when no entries were asked for, or the table has none. ")
+    rows: Optional[List[List[Any]]] = Field(description="The newest entries, newest first (up to 25). `null` when no entries were asked for. Each entry is a list of values in the order of `columns`. A value is text (cut to 200 characters), a number, a boolean or `null`. ")
+    more_rows: StrictBool = Field(description="True when the table holds more entries than `rows` lists", alias="moreRows")
+    aggregates: Optional[CompositionEntryAggregatesBlock] = Field(default=None, description="Only present when the read asked for `aggregate`. Unlike `totalRows`, `tallies` and `rows`, it is narrowed by `since`, `until` and the `context` and column filters of the same call: it answers \"the average rating this week\" where `tallies` answer \"how many of each rating, ever\". ")
+    __properties: ClassVar[List[str]] = ["compositionId", "table", "totalRows", "tallies", "moreGroups", "columns", "rows", "moreRows", "aggregates"]
+
+    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 CompositionEntriesReading 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 tallies (list)
+        _items = []
+        if self.tallies:
+            for _item_tallies in self.tallies:
+                if _item_tallies:
+                    _items.append(_item_tallies.to_dict())
+            _dict['tallies'] = _items
+        # override the default output from pydantic by calling `to_dict()` of aggregates
+        if self.aggregates:
+            _dict['aggregates'] = self.aggregates.to_dict()
+        # set to None if tallies (nullable) is None
+        # and model_fields_set contains the field
+        if self.tallies is None and "tallies" in self.model_fields_set:
+            _dict['tallies'] = None
+
+        # set to None if rows (nullable) is None
+        # and model_fields_set contains the field
+        if self.rows is None and "rows" in self.model_fields_set:
+            _dict['rows'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CompositionEntriesReading from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "compositionId": obj.get("compositionId"),
+            "table": obj.get("table"),
+            "totalRows": obj.get("totalRows"),
+            "tallies": [CompositionEntryTally.from_dict(_item) for _item in obj["tallies"]] if obj.get("tallies") is not None else None,
+            "moreGroups": obj.get("moreGroups"),
+            "columns": obj.get("columns"),
+            "rows": obj.get("rows"),
+            "moreRows": obj.get("moreRows"),
+            "aggregates": CompositionEntryAggregatesBlock.from_dict(obj["aggregates"]) if obj.get("aggregates") is not None else None
+        })
+        return _obj
+
+

api_sdk_py/models/composition_entries_reading_response.py

@@ -0,0 +1,99 @@
+# coding: utf-8
+
+"""
+    Widgetic API Gateway
+
+    API documentation for the Widgetic API Gateway
+
+    The version of the OpenAPI document: 1.0.0
+    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 api_sdk_py.models.composition_entries_reading import CompositionEntriesReading
+from api_sdk_py.models.response_meta import ResponseMeta
+from typing import Optional, Set
+from typing_extensions import Self
+
+class CompositionEntriesReadingResponse(BaseModel):
+    """
+    CompositionEntriesReadingResponse
+    """ # noqa: E501
+    success: StrictBool = Field(description="Always `true` on a success.")
+    data: CompositionEntriesReading
+    meta: Optional[ResponseMeta] = None
+    __properties: ClassVar[List[str]] = ["success", "data", "meta"]
+
+    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 CompositionEntriesReadingResponse 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 data
+        if self.data:
+            _dict['data'] = self.data.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of meta
+        if self.meta:
+            _dict['meta'] = self.meta.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CompositionEntriesReadingResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "success": obj.get("success"),
+            "data": CompositionEntriesReading.from_dict(obj["data"]) if obj.get("data") is not None else None,
+            "meta": ResponseMeta.from_dict(obj["meta"]) if obj.get("meta") is not None else None
+        })
+        return _obj
+
+

api_sdk_py/models/composition_entry_aggregate_tally.py

@@ -0,0 +1,122 @@
+# coding: utf-8
+
+"""
+    Widgetic API Gateway
+
+    API documentation for the Widgetic API Gateway
+
+    The version of the OpenAPI document: 1.0.0
+    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, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing import Optional, Set
+from typing_extensions import Self
+
+class CompositionEntryAggregateTally(BaseModel):
+    """
+    The aggregates of one group (the entries that share a value of the `groupBy` column), or of the whole selection when no `groupBy` was asked for. Only the functions that were asked for with `aggregate` are present. 
+    """ # noqa: E501
+    group: Optional[StrictStr] = Field(default=None, description="The value of the `groupBy` column, as text (a number is `\"5\"`); `null` groups the entries that left it empty. Absent when no `groupBy` was asked for. ")
+    count: Optional[StrictInt] = Field(default=None, description="How many entries are in the group (or in the selection)")
+    avg: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="The average of the numeric `column`, rounded to 4 decimals. `null` when no entry matched: there is no average of nothing, and it is not 0. ")
+    min: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="The smallest value of the numeric `column`. `null` when no entry matched.")
+    max: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="The largest value of the numeric `column`. `null` when no entry matched.")
+    sum: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="The sum of the numeric `column`. `null` when no entry matched.")
+    __properties: ClassVar[List[str]] = ["group", "count", "avg", "min", "max", "sum"]
+
+    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 CompositionEntryAggregateTally 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,
+        )
+        # set to None if group (nullable) is None
+        # and model_fields_set contains the field
+        if self.group is None and "group" in self.model_fields_set:
+            _dict['group'] = None
+
+        # set to None if avg (nullable) is None
+        # and model_fields_set contains the field
+        if self.avg is None and "avg" in self.model_fields_set:
+            _dict['avg'] = None
+
+        # set to None if min (nullable) is None
+        # and model_fields_set contains the field
+        if self.min is None and "min" in self.model_fields_set:
+            _dict['min'] = None
+
+        # set to None if max (nullable) is None
+        # and model_fields_set contains the field
+        if self.max is None and "max" in self.model_fields_set:
+            _dict['max'] = None
+
+        # set to None if sum (nullable) is None
+        # and model_fields_set contains the field
+        if self.sum is None and "sum" in self.model_fields_set:
+            _dict['sum'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CompositionEntryAggregateTally from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "group": obj.get("group"),
+            "count": obj.get("count"),
+            "avg": obj.get("avg"),
+            "min": obj.get("min"),
+            "max": obj.get("max"),
+            "sum": obj.get("sum")
+        })
+        return _obj
+
+

api_sdk_py/models/composition_entry_aggregates_block.py

@@ -0,0 +1,99 @@
+# coding: utf-8
+
+"""
+    Widgetic API Gateway
+
+    API documentation for the Widgetic API Gateway
+
+    The version of the OpenAPI document: 1.0.0
+    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, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from api_sdk_py.models.composition_entry_aggregate_tally import CompositionEntryAggregateTally
+from typing import Optional, Set
+from typing_extensions import Self
+
+class CompositionEntryAggregatesBlock(BaseModel):
+    """
+    What `aggregate` asked for, computed over the entries that match `since`, `until` and the `context` and column filters of the same call. 
+    """ # noqa: E501
+    column: StrictStr = Field(description="The numeric column `avg`, `min`, `max` and `sum` were computed over. An empty text when only `count` was asked for. ")
+    tallies: List[CompositionEntryAggregateTally] = Field(description="One tally per value of `groupBy`, in the order of that column (a number as a number, `null` last), up to 200 groups; or ONE tally for the whole selection when no `groupBy` was asked for. Empty when `groupBy` was asked for and no entry matched. ")
+    truncated: Optional[StrictBool] = Field(default=None, description="True when more than 200 groups matched, so `tallies` lists the first 200 in that order. Absent otherwise. (Not to be mixed up with `moreGroups` on the reading, which is about the plain `tallies` of the whole table: those are 20 groups, largest first.) ")
+    __properties: ClassVar[List[str]] = ["column", "tallies", "truncated"]
+
+    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 CompositionEntryAggregatesBlock 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 tallies (list)
+        _items = []
+        if self.tallies:
+            for _item_tallies in self.tallies:
+                if _item_tallies:
+                    _items.append(_item_tallies.to_dict())
+            _dict['tallies'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CompositionEntryAggregatesBlock from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "column": obj.get("column"),
+            "tallies": [CompositionEntryAggregateTally.from_dict(_item) for _item in obj["tallies"]] if obj.get("tallies") is not None else None,
+            "truncated": obj.get("truncated")
+        })
+        return _obj
+
+