wallaroo.wallaroo_ml_ops_api_client.models.assays_get_results_response_200_item_window_summary API documentation

# wallaroo.wallaroo_ml_ops_api_client.models.assays_get_results_response_200_item_window_summary

View Source

      1import datetime
      2from typing import Any, Dict, List, Type, TypeVar, Union, cast
      3
      4import attr
      5from dateutil.parser import isoparse
      6
      7from ..models.assays_get_results_response_200_item_window_summary_aggregation import \
      8    AssaysGetResultsResponse200ItemWindowSummaryAggregation
      9from ..types import UNSET, Unset
     10
     11T = TypeVar("T", bound="AssaysGetResultsResponse200ItemWindowSummary")
     12
     13@attr.s(auto_attribs=True)
     14class AssaysGetResultsResponse200ItemWindowSummary:
     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 (AssaysGetResultsResponse200ItemWindowSummaryAggregation):
     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: AssaysGetResultsResponse200ItemWindowSummaryAggregation
     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 = AssaysGetResultsResponse200ItemWindowSummaryAggregation(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_get_results_response_200_item_window_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_get_results_response_200_item_window_summary.additional_properties = d
    172        return assays_get_results_response_200_item_window_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 AssaysGetResultsResponse200ItemWindowSummary: View Source

     14@attr.s(auto_attribs=True)
     15class AssaysGetResultsResponse200ItemWindowSummary:
     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 (AssaysGetResultsResponse200ItemWindowSummaryAggregation):
     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: AssaysGetResultsResponse200ItemWindowSummaryAggregation
     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 = AssaysGetResultsResponse200ItemWindowSummaryAggregation(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_get_results_response_200_item_window_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_get_results_response_200_item_window_summary.additional_properties = d
    173        return assays_get_results_response_200_item_window_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 (AssaysGetResultsResponse200ItemWindowSummaryAggregation): start (Union[Unset, None, datetime.datetime]): end (Union[Unset, None, datetime.datetime]):

AssaysGetResultsResponse200ItemWindowSummary( 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_get_results_response_200_item_window_summary_aggregation.AssaysGetResultsResponse200ItemWindowSummaryAggregation, 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>) View Source

     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 AssaysGetResultsResponse200ItemWindowSummary.

def to_dict(self) -> Dict[str, Any]: View Source

     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: View Source

    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 = AssaysGetResultsResponse200ItemWindowSummaryAggregation(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_get_results_response_200_item_window_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_get_results_response_200_item_window_summary.additional_properties = d
    173        return assays_get_results_response_200_item_window_summary

additional_keys: List[str]