wallaroo.wallaroo_ml_ops_api_client.models.assays_run_interactive_response_200_item_baseline_summary

  1import datetime
  2from typing import Any, Dict, List, Type, TypeVar, Union, cast
  3
  4import attr
  5from dateutil.parser import isoparse
  6
  7from ..models.assays_run_interactive_response_200_item_baseline_summary_aggregation import \
  8    AssaysRunInteractiveResponse200ItemBaselineSummaryAggregation
  9from ..types import UNSET, Unset
 10
 11T = TypeVar("T", bound="AssaysRunInteractiveResponse200ItemBaselineSummary")
 12
 13@attr.s(auto_attribs=True)
 14class AssaysRunInteractiveResponse200ItemBaselineSummary:
 15    """ Result from summarizing one sample collection.
 16
 17    Attributes:
 18        count (int):
 19        min_ (float):
 20        max_ (float):
 21        mean (float):
 22        median (float):
 23        std (float):  Standard deviation.
 24        edges (List[float]):
 25        edge_names (List[str]):
 26        aggregated_values (List[float]):
 27        aggregation (AssaysRunInteractiveResponse200ItemBaselineSummaryAggregation):
 28        start (Union[Unset, None, datetime.datetime]):
 29        end (Union[Unset, None, datetime.datetime]):
 30    """
 31
 32    count: int
 33    min_: float
 34    max_: float
 35    mean: float
 36    median: float
 37    std: float
 38    edges: List[float]
 39    edge_names: List[str]
 40    aggregated_values: List[float]
 41    aggregation: AssaysRunInteractiveResponse200ItemBaselineSummaryAggregation
 42    start: Union[Unset, None, datetime.datetime] = UNSET
 43    end: Union[Unset, None, datetime.datetime] = UNSET
 44    additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
 45
 46
 47    def to_dict(self) -> Dict[str, Any]:
 48        count = self.count
 49        min_ = self.min_
 50        max_ = self.max_
 51        mean = self.mean
 52        median = self.median
 53        std = self.std
 54        edges = self.edges
 55
 56
 57
 58
 59        edge_names = self.edge_names
 60
 61
 62
 63
 64        aggregated_values = self.aggregated_values
 65
 66
 67
 68
 69        aggregation = self.aggregation.value
 70
 71        start: Union[Unset, None, str] = UNSET
 72        if not isinstance(self.start, Unset):
 73            start = self.start.isoformat() if self.start else None
 74
 75        end: Union[Unset, None, str] = UNSET
 76        if not isinstance(self.end, Unset):
 77            end = self.end.isoformat() if self.end else None
 78
 79
 80        field_dict: Dict[str, Any] = {}
 81        field_dict.update(self.additional_properties)
 82        field_dict.update({
 83            "count": count,
 84            "min": min_,
 85            "max": max_,
 86            "mean": mean,
 87            "median": median,
 88            "std": std,
 89            "edges": edges,
 90            "edge_names": edge_names,
 91            "aggregated_values": aggregated_values,
 92            "aggregation": aggregation,
 93        })
 94        if start is not UNSET:
 95            field_dict["start"] = start
 96        if end is not UNSET:
 97            field_dict["end"] = end
 98
 99        return field_dict
100
101
102
103    @classmethod
104    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
105        d = src_dict.copy()
106        count = d.pop("count")
107
108        min_ = d.pop("min")
109
110        max_ = d.pop("max")
111
112        mean = d.pop("mean")
113
114        median = d.pop("median")
115
116        std = d.pop("std")
117
118        edges = cast(List[float], d.pop("edges"))
119
120
121        edge_names = cast(List[str], d.pop("edge_names"))
122
123
124        aggregated_values = cast(List[float], d.pop("aggregated_values"))
125
126
127        aggregation = AssaysRunInteractiveResponse200ItemBaselineSummaryAggregation(d.pop("aggregation"))
128
129
130
131
132        _start = d.pop("start", UNSET)
133        start: Union[Unset, None, datetime.datetime]
134        if _start is None:
135            start = None
136        elif isinstance(_start,  Unset):
137            start = UNSET
138        else:
139            start = isoparse(_start)
140
141
142
143
144        _end = d.pop("end", UNSET)
145        end: Union[Unset, None, datetime.datetime]
146        if _end is None:
147            end = None
148        elif isinstance(_end,  Unset):
149            end = UNSET
150        else:
151            end = isoparse(_end)
152
153
154
155
156        assays_run_interactive_response_200_item_baseline_summary = cls(
157            count=count,
158            min_=min_,
159            max_=max_,
160            mean=mean,
161            median=median,
162            std=std,
163            edges=edges,
164            edge_names=edge_names,
165            aggregated_values=aggregated_values,
166            aggregation=aggregation,
167            start=start,
168            end=end,
169        )
170
171        assays_run_interactive_response_200_item_baseline_summary.additional_properties = d
172        return assays_run_interactive_response_200_item_baseline_summary
173
174    @property
175    def additional_keys(self) -> List[str]:
176        return list(self.additional_properties.keys())
177
178    def __getitem__(self, key: str) -> Any:
179        return self.additional_properties[key]
180
181    def __setitem__(self, key: str, value: Any) -> None:
182        self.additional_properties[key] = value
183
184    def __delitem__(self, key: str) -> None:
185        del self.additional_properties[key]
186
187    def __contains__(self, key: str) -> bool:
188        return key in self.additional_properties
@attr.s(auto_attribs=True)
class AssaysRunInteractiveResponse200ItemBaselineSummary:
 14@attr.s(auto_attribs=True)
 15class AssaysRunInteractiveResponse200ItemBaselineSummary:
 16    """ Result from summarizing one sample collection.
 17
 18    Attributes:
 19        count (int):
 20        min_ (float):
 21        max_ (float):
 22        mean (float):
 23        median (float):
 24        std (float):  Standard deviation.
 25        edges (List[float]):
 26        edge_names (List[str]):
 27        aggregated_values (List[float]):
 28        aggregation (AssaysRunInteractiveResponse200ItemBaselineSummaryAggregation):
 29        start (Union[Unset, None, datetime.datetime]):
 30        end (Union[Unset, None, datetime.datetime]):
 31    """
 32
 33    count: int
 34    min_: float
 35    max_: float
 36    mean: float
 37    median: float
 38    std: float
 39    edges: List[float]
 40    edge_names: List[str]
 41    aggregated_values: List[float]
 42    aggregation: AssaysRunInteractiveResponse200ItemBaselineSummaryAggregation
 43    start: Union[Unset, None, datetime.datetime] = UNSET
 44    end: Union[Unset, None, datetime.datetime] = UNSET
 45    additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
 46
 47
 48    def to_dict(self) -> Dict[str, Any]:
 49        count = self.count
 50        min_ = self.min_
 51        max_ = self.max_
 52        mean = self.mean
 53        median = self.median
 54        std = self.std
 55        edges = self.edges
 56
 57
 58
 59
 60        edge_names = self.edge_names
 61
 62
 63
 64
 65        aggregated_values = self.aggregated_values
 66
 67
 68
 69
 70        aggregation = self.aggregation.value
 71
 72        start: Union[Unset, None, str] = UNSET
 73        if not isinstance(self.start, Unset):
 74            start = self.start.isoformat() if self.start else None
 75
 76        end: Union[Unset, None, str] = UNSET
 77        if not isinstance(self.end, Unset):
 78            end = self.end.isoformat() if self.end else None
 79
 80
 81        field_dict: Dict[str, Any] = {}
 82        field_dict.update(self.additional_properties)
 83        field_dict.update({
 84            "count": count,
 85            "min": min_,
 86            "max": max_,
 87            "mean": mean,
 88            "median": median,
 89            "std": std,
 90            "edges": edges,
 91            "edge_names": edge_names,
 92            "aggregated_values": aggregated_values,
 93            "aggregation": aggregation,
 94        })
 95        if start is not UNSET:
 96            field_dict["start"] = start
 97        if end is not UNSET:
 98            field_dict["end"] = end
 99
100        return field_dict
101
102
103
104    @classmethod
105    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
106        d = src_dict.copy()
107        count = d.pop("count")
108
109        min_ = d.pop("min")
110
111        max_ = d.pop("max")
112
113        mean = d.pop("mean")
114
115        median = d.pop("median")
116
117        std = d.pop("std")
118
119        edges = cast(List[float], d.pop("edges"))
120
121
122        edge_names = cast(List[str], d.pop("edge_names"))
123
124
125        aggregated_values = cast(List[float], d.pop("aggregated_values"))
126
127
128        aggregation = AssaysRunInteractiveResponse200ItemBaselineSummaryAggregation(d.pop("aggregation"))
129
130
131
132
133        _start = d.pop("start", UNSET)
134        start: Union[Unset, None, datetime.datetime]
135        if _start is None:
136            start = None
137        elif isinstance(_start,  Unset):
138            start = UNSET
139        else:
140            start = isoparse(_start)
141
142
143
144
145        _end = d.pop("end", UNSET)
146        end: Union[Unset, None, datetime.datetime]
147        if _end is None:
148            end = None
149        elif isinstance(_end,  Unset):
150            end = UNSET
151        else:
152            end = isoparse(_end)
153
154
155
156
157        assays_run_interactive_response_200_item_baseline_summary = cls(
158            count=count,
159            min_=min_,
160            max_=max_,
161            mean=mean,
162            median=median,
163            std=std,
164            edges=edges,
165            edge_names=edge_names,
166            aggregated_values=aggregated_values,
167            aggregation=aggregation,
168            start=start,
169            end=end,
170        )
171
172        assays_run_interactive_response_200_item_baseline_summary.additional_properties = d
173        return assays_run_interactive_response_200_item_baseline_summary
174
175    @property
176    def additional_keys(self) -> List[str]:
177        return list(self.additional_properties.keys())
178
179    def __getitem__(self, key: str) -> Any:
180        return self.additional_properties[key]
181
182    def __setitem__(self, key: str, value: Any) -> None:
183        self.additional_properties[key] = value
184
185    def __delitem__(self, key: str) -> None:
186        del self.additional_properties[key]
187
188    def __contains__(self, key: str) -> bool:
189        return key in self.additional_properties

Result from summarizing one sample collection.

Attributes: count (int): min_ (float): max_ (float): mean (float): median (float): std (float): Standard deviation. edges (List[float]): edge_names (List[str]): aggregated_values (List[float]): aggregation (AssaysRunInteractiveResponse200ItemBaselineSummaryAggregation): start (Union[Unset, None, datetime.datetime]): end (Union[Unset, None, datetime.datetime]):

AssaysRunInteractiveResponse200ItemBaselineSummary( count: int, min_: float, max_: float, mean: float, median: float, std: float, edges: List[float], edge_names: List[str], aggregated_values: List[float], aggregation: wallaroo.wallaroo_ml_ops_api_client.models.assays_run_interactive_response_200_item_baseline_summary_aggregation.AssaysRunInteractiveResponse200ItemBaselineSummaryAggregation, start: Union[wallaroo.wallaroo_ml_ops_api_client.types.Unset, NoneType, datetime.datetime] = <wallaroo.wallaroo_ml_ops_api_client.types.Unset object>, end: Union[wallaroo.wallaroo_ml_ops_api_client.types.Unset, NoneType, datetime.datetime] = <wallaroo.wallaroo_ml_ops_api_client.types.Unset object>)
 2def __init__(self, count, min_, max_, mean, median, std, edges, edge_names, aggregated_values, aggregation, start=attr_dict['start'].default, end=attr_dict['end'].default):
 3    self.count = count
 4    self.min_ = min_
 5    self.max_ = max_
 6    self.mean = mean
 7    self.median = median
 8    self.std = std
 9    self.edges = edges
10    self.edge_names = edge_names
11    self.aggregated_values = aggregated_values
12    self.aggregation = aggregation
13    self.start = start
14    self.end = end
15    self.additional_properties = __attr_factory_additional_properties()

Method generated by attrs for class AssaysRunInteractiveResponse200ItemBaselineSummary.

def to_dict(self) -> Dict[str, Any]:
 48    def to_dict(self) -> Dict[str, Any]:
 49        count = self.count
 50        min_ = self.min_
 51        max_ = self.max_
 52        mean = self.mean
 53        median = self.median
 54        std = self.std
 55        edges = self.edges
 56
 57
 58
 59
 60        edge_names = self.edge_names
 61
 62
 63
 64
 65        aggregated_values = self.aggregated_values
 66
 67
 68
 69
 70        aggregation = self.aggregation.value
 71
 72        start: Union[Unset, None, str] = UNSET
 73        if not isinstance(self.start, Unset):
 74            start = self.start.isoformat() if self.start else None
 75
 76        end: Union[Unset, None, str] = UNSET
 77        if not isinstance(self.end, Unset):
 78            end = self.end.isoformat() if self.end else None
 79
 80
 81        field_dict: Dict[str, Any] = {}
 82        field_dict.update(self.additional_properties)
 83        field_dict.update({
 84            "count": count,
 85            "min": min_,
 86            "max": max_,
 87            "mean": mean,
 88            "median": median,
 89            "std": std,
 90            "edges": edges,
 91            "edge_names": edge_names,
 92            "aggregated_values": aggregated_values,
 93            "aggregation": aggregation,
 94        })
 95        if start is not UNSET:
 96            field_dict["start"] = start
 97        if end is not UNSET:
 98            field_dict["end"] = end
 99
100        return field_dict
@classmethod
def from_dict(cls: Type[~T], src_dict: Dict[str, Any]) -> ~T:
104    @classmethod
105    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
106        d = src_dict.copy()
107        count = d.pop("count")
108
109        min_ = d.pop("min")
110
111        max_ = d.pop("max")
112
113        mean = d.pop("mean")
114
115        median = d.pop("median")
116
117        std = d.pop("std")
118
119        edges = cast(List[float], d.pop("edges"))
120
121
122        edge_names = cast(List[str], d.pop("edge_names"))
123
124
125        aggregated_values = cast(List[float], d.pop("aggregated_values"))
126
127
128        aggregation = AssaysRunInteractiveResponse200ItemBaselineSummaryAggregation(d.pop("aggregation"))
129
130
131
132
133        _start = d.pop("start", UNSET)
134        start: Union[Unset, None, datetime.datetime]
135        if _start is None:
136            start = None
137        elif isinstance(_start,  Unset):
138            start = UNSET
139        else:
140            start = isoparse(_start)
141
142
143
144
145        _end = d.pop("end", UNSET)
146        end: Union[Unset, None, datetime.datetime]
147        if _end is None:
148            end = None
149        elif isinstance(_end,  Unset):
150            end = UNSET
151        else:
152            end = isoparse(_end)
153
154
155
156
157        assays_run_interactive_response_200_item_baseline_summary = cls(
158            count=count,
159            min_=min_,
160            max_=max_,
161            mean=mean,
162            median=median,
163            std=std,
164            edges=edges,
165            edge_names=edge_names,
166            aggregated_values=aggregated_values,
167            aggregation=aggregation,
168            start=start,
169            end=end,
170        )
171
172        assays_run_interactive_response_200_item_baseline_summary.additional_properties = d
173        return assays_run_interactive_response_200_item_baseline_summary
additional_keys: List[str]