wallaroo.models

  1import datetime
  2from typing import TYPE_CHECKING, Any, Dict, List, Optional, cast
  3
  4from dateutil import parser as dateparse
  5
  6from .model import Model
  7from .object import (
  8    DehydratedValue,
  9    Object,
 10    RequiredAttributeMissing,
 11    rehydrate,
 12    value_if_present,
 13)
 14from .unwrap import unwrap
 15from .wallaroo_ml_ops_api_client.api.model import models_get
 16from .wallaroo_ml_ops_api_client.models import models_get_json_body
 17from .wallaroo_ml_ops_api_client.models.models_get_response_500 import (
 18    ModelsGetResponse500,
 19)
 20
 21if TYPE_CHECKING:
 22    # Imports that happen below in methods to fix circular import dependency
 23    # issues need to also be specified here to satisfy mypy type checking.
 24    from .client import Client
 25    from .model import Model
 26    from .model_config import ModelConfig
 27
 28
 29class Models(Object):
 30    """
 31    A Wallaroo Model object. Models may have multiple versions, accessed via .versions()
 32    """
 33
 34    def __init__(
 35        self, client: Optional["Client"], data: Dict[str, Any], standalone=False
 36    ) -> None:
 37        self.client = client
 38        self._config: Optional["ModelConfig"] = None
 39        super().__init__(
 40            gql_client=client._gql_client if client is not None else None,
 41            data=data,
 42            standalone=standalone,
 43        )
 44
 45    def __repr__(self) -> str:
 46        return str(
 47            {
 48                "name": self.name(),
 49                "versions": len(self.versions()),
 50                "owner_id": self.owner_id(),
 51                "last_update_time": self.last_update_time(),
 52                "created_at": self.created_at(),
 53            }
 54        )
 55
 56    def _repr_html_(self) -> str:
 57        return f"""
 58          <table>
 59            <tr>
 60              <th>Name</td>
 61              <td>{self.name()}</td>
 62            </tr>
 63            <tr>
 64              <th># of Versions</td>
 65              <td>{len(self.versions())}</td>
 66            </tr>
 67            <tr>
 68              <th>Owner ID</td>
 69              <td>{self.owner_id()}</td>
 70            </tr>
 71            <tr>
 72              <th>Last Updated</td>
 73              <td>{self.last_update_time()}</td>
 74            </tr>
 75            <tr>
 76              <th>Created At</td>
 77              <td>{self.created_at()}</td>
 78            </tr>
 79          </table>
 80        """
 81
 82    def _fill(self, data: Dict[str, Any]) -> None:
 83        """Fills an object given a response dictionary from the GraphQL API.
 84
 85        Only the primary key member must be present; other members will be
 86        filled in via rehydration if their corresponding member function is
 87        called.
 88        """
 89        for required_attribute in ["id"]:
 90            if required_attribute not in data:
 91                raise RequiredAttributeMissing(
 92                    self.__class__.__name__, required_attribute
 93                )
 94        # Required
 95        self._id = data["id"]
 96
 97        # Optional
 98        self._name = value_if_present(data, "name")
 99        self._owner_id = value_if_present(data, "owner_id")
100        self._created_at = (
101            dateparse.isoparse(data["created_at"])
102            if "created_at" in data
103            else DehydratedValue()
104        )
105        self._last_update_time = (
106            dateparse.isoparse(data["updated_at"])
107            if "updated_at" in data
108            else DehydratedValue()
109        )
110
111        self._versions = (
112            [Model(client=self.client, data=x) for x in data["models"]]
113            if "models" in data
114            else DehydratedValue()
115        )
116
117    def _fetch_attributes(self) -> Dict[str, Any]:
118        """Fetches all member data from the GraphQL API."""
119        client = unwrap(self.client)
120        ret = models_get.sync(
121            client=client.mlops(),
122            json_body=models_get_json_body.ModelsGetJsonBody(self.id()),
123        )
124
125        if isinstance(ret, ModelsGetResponse500):
126            raise RuntimeError(ret.msg)
127
128        if ret is None:
129            raise RuntimeError("An error occurred loading the model.")
130
131        return ret.to_dict()
132
133    def id(self) -> int:
134        return self._id
135
136    @rehydrate("_name")
137    def name(self) -> str:
138        return cast(str, self._name)
139
140    @rehydrate("_owner_id")
141    def owner_id(self) -> str:
142        return cast(str, self._owner_id)
143
144    @rehydrate("_last_update_time")
145    def last_update_time(self) -> datetime.datetime:
146        return cast(datetime.datetime, self._last_update_time)
147
148    @rehydrate("_created_at")
149    def created_at(self) -> datetime.datetime:
150        return cast(datetime.datetime, self._created_at)
151
152    @rehydrate("_versions")
153    def versions(self) -> List["Model"]:
154        return cast(List["Model"], self._versions)
155
156
157class ModelsList(List[Models]):
158    """Wraps a list of Models for display in a display-aware environment like Jupyter."""
159
160    def _repr_html_(self) -> str:
161        def row(models: Models):
162            return f"""
163            <tr>
164              <td>{models.name()}</td>
165              <td>{len(models.versions())}</td>
166              <td>{models.owner_id()}</td>
167              <td>{models.last_update_time()}</td>
168              <td>{models.created_at()}</td>
169            </tr>
170          """
171
172        return f"""
173          <table>
174            <tr>
175              <th>Name</th>
176              <th># of Versions</th>
177              <th>Owner ID</th>
178              <th>Last Updated</th>
179              <th>Created At</th>
180            </tr>
181            {" ".join([row(models) for models in self])}
182          </table>
183        """
class Models(wallaroo.object.Object):
 30class Models(Object):
 31    """
 32    A Wallaroo Model object. Models may have multiple versions, accessed via .versions()
 33    """
 34
 35    def __init__(
 36        self, client: Optional["Client"], data: Dict[str, Any], standalone=False
 37    ) -> None:
 38        self.client = client
 39        self._config: Optional["ModelConfig"] = None
 40        super().__init__(
 41            gql_client=client._gql_client if client is not None else None,
 42            data=data,
 43            standalone=standalone,
 44        )
 45
 46    def __repr__(self) -> str:
 47        return str(
 48            {
 49                "name": self.name(),
 50                "versions": len(self.versions()),
 51                "owner_id": self.owner_id(),
 52                "last_update_time": self.last_update_time(),
 53                "created_at": self.created_at(),
 54            }
 55        )
 56
 57    def _repr_html_(self) -> str:
 58        return f"""
 59          <table>
 60            <tr>
 61              <th>Name</td>
 62              <td>{self.name()}</td>
 63            </tr>
 64            <tr>
 65              <th># of Versions</td>
 66              <td>{len(self.versions())}</td>
 67            </tr>
 68            <tr>
 69              <th>Owner ID</td>
 70              <td>{self.owner_id()}</td>
 71            </tr>
 72            <tr>
 73              <th>Last Updated</td>
 74              <td>{self.last_update_time()}</td>
 75            </tr>
 76            <tr>
 77              <th>Created At</td>
 78              <td>{self.created_at()}</td>
 79            </tr>
 80          </table>
 81        """
 82
 83    def _fill(self, data: Dict[str, Any]) -> None:
 84        """Fills an object given a response dictionary from the GraphQL API.
 85
 86        Only the primary key member must be present; other members will be
 87        filled in via rehydration if their corresponding member function is
 88        called.
 89        """
 90        for required_attribute in ["id"]:
 91            if required_attribute not in data:
 92                raise RequiredAttributeMissing(
 93                    self.__class__.__name__, required_attribute
 94                )
 95        # Required
 96        self._id = data["id"]
 97
 98        # Optional
 99        self._name = value_if_present(data, "name")
100        self._owner_id = value_if_present(data, "owner_id")
101        self._created_at = (
102            dateparse.isoparse(data["created_at"])
103            if "created_at" in data
104            else DehydratedValue()
105        )
106        self._last_update_time = (
107            dateparse.isoparse(data["updated_at"])
108            if "updated_at" in data
109            else DehydratedValue()
110        )
111
112        self._versions = (
113            [Model(client=self.client, data=x) for x in data["models"]]
114            if "models" in data
115            else DehydratedValue()
116        )
117
118    def _fetch_attributes(self) -> Dict[str, Any]:
119        """Fetches all member data from the GraphQL API."""
120        client = unwrap(self.client)
121        ret = models_get.sync(
122            client=client.mlops(),
123            json_body=models_get_json_body.ModelsGetJsonBody(self.id()),
124        )
125
126        if isinstance(ret, ModelsGetResponse500):
127            raise RuntimeError(ret.msg)
128
129        if ret is None:
130            raise RuntimeError("An error occurred loading the model.")
131
132        return ret.to_dict()
133
134    def id(self) -> int:
135        return self._id
136
137    @rehydrate("_name")
138    def name(self) -> str:
139        return cast(str, self._name)
140
141    @rehydrate("_owner_id")
142    def owner_id(self) -> str:
143        return cast(str, self._owner_id)
144
145    @rehydrate("_last_update_time")
146    def last_update_time(self) -> datetime.datetime:
147        return cast(datetime.datetime, self._last_update_time)
148
149    @rehydrate("_created_at")
150    def created_at(self) -> datetime.datetime:
151        return cast(datetime.datetime, self._created_at)
152
153    @rehydrate("_versions")
154    def versions(self) -> List["Model"]:
155        return cast(List["Model"], self._versions)

A Wallaroo Model object. Models may have multiple versions, accessed via .versions()

Models( client: Optional[wallaroo.client.Client], data: Dict[str, Any], standalone=False)
35    def __init__(
36        self, client: Optional["Client"], data: Dict[str, Any], standalone=False
37    ) -> None:
38        self.client = client
39        self._config: Optional["ModelConfig"] = None
40        super().__init__(
41            gql_client=client._gql_client if client is not None else None,
42            data=data,
43            standalone=standalone,
44        )

Base constructor.

Each object requires:

  • a GraphQL client - in order to fill its missing members dynamically
  • an initial data blob - typically from unserialized JSON, contains at
  • least the data for required members (typically the object's primary key) and optionally other data members.
def id(self) -> int:
134    def id(self) -> int:
135        return self._id
def name(*args, **kwargs):
41        def wrapper(*args, **kwargs):
42            obj = args[0]
43            if not getattr(obj, "_standalone", None):
44                present = getattr(obj, attr) != DehydratedValue()
45                # Uncomment to debug while testing
46                # print(
47                #    "rehydrate: {} -> {}".format(
48                #        attr, "present" if present else "not present"
49                #    )
50                # )
51                if not present:
52                    obj._rehydrate()
53            result = fn(*args, **kwargs)
54            return result
def owner_id(*args, **kwargs):
41        def wrapper(*args, **kwargs):
42            obj = args[0]
43            if not getattr(obj, "_standalone", None):
44                present = getattr(obj, attr) != DehydratedValue()
45                # Uncomment to debug while testing
46                # print(
47                #    "rehydrate: {} -> {}".format(
48                #        attr, "present" if present else "not present"
49                #    )
50                # )
51                if not present:
52                    obj._rehydrate()
53            result = fn(*args, **kwargs)
54            return result
def last_update_time(*args, **kwargs):
41        def wrapper(*args, **kwargs):
42            obj = args[0]
43            if not getattr(obj, "_standalone", None):
44                present = getattr(obj, attr) != DehydratedValue()
45                # Uncomment to debug while testing
46                # print(
47                #    "rehydrate: {} -> {}".format(
48                #        attr, "present" if present else "not present"
49                #    )
50                # )
51                if not present:
52                    obj._rehydrate()
53            result = fn(*args, **kwargs)
54            return result
def created_at(*args, **kwargs):
41        def wrapper(*args, **kwargs):
42            obj = args[0]
43            if not getattr(obj, "_standalone", None):
44                present = getattr(obj, attr) != DehydratedValue()
45                # Uncomment to debug while testing
46                # print(
47                #    "rehydrate: {} -> {}".format(
48                #        attr, "present" if present else "not present"
49                #    )
50                # )
51                if not present:
52                    obj._rehydrate()
53            result = fn(*args, **kwargs)
54            return result
def versions(*args, **kwargs):
41        def wrapper(*args, **kwargs):
42            obj = args[0]
43            if not getattr(obj, "_standalone", None):
44                present = getattr(obj, attr) != DehydratedValue()
45                # Uncomment to debug while testing
46                # print(
47                #    "rehydrate: {} -> {}".format(
48                #        attr, "present" if present else "not present"
49                #    )
50                # )
51                if not present:
52                    obj._rehydrate()
53            result = fn(*args, **kwargs)
54            return result
class ModelsList(typing.List[wallaroo.models.Models]):
158class ModelsList(List[Models]):
159    """Wraps a list of Models for display in a display-aware environment like Jupyter."""
160
161    def _repr_html_(self) -> str:
162        def row(models: Models):
163            return f"""
164            <tr>
165              <td>{models.name()}</td>
166              <td>{len(models.versions())}</td>
167              <td>{models.owner_id()}</td>
168              <td>{models.last_update_time()}</td>
169              <td>{models.created_at()}</td>
170            </tr>
171          """
172
173        return f"""
174          <table>
175            <tr>
176              <th>Name</th>
177              <th># of Versions</th>
178              <th>Owner ID</th>
179              <th>Last Updated</th>
180              <th>Created At</th>
181            </tr>
182            {" ".join([row(models) for models in self])}
183          </table>
184        """

Wraps a list of Models for display in a display-aware environment like Jupyter.

Inherited Members
builtins.list
list
clear
copy
append
insert
extend
pop
remove
index
count
reverse
sort