Skip to content

ModelKitReference class

You can import the ModelKitReference class from kitops.modelkit.reference:

from kitops.modelkit.reference import ModelKitReference

A class to represent a modelkit reference broken down into its parts. This class parses a modelkit tag and provides access to its components. These include the registry, namespace, model, and tag.

Attributes:

Name Type Description
registry str

The registry for the model.
namespace str

The namespace for the model.
model str

The model name.
tag str

The tag for the model.

Methods:

Name Description
__init__

Initializes the ModelKitReference instance by parsing a tag.
registry

Gets or sets the registry.
namespace

Gets or sets the namespace.
repository

Gets or sets the repository name.
tag

Gets or sets the tag.
Source code in kitops/modelkit/reference.py 
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
class ModelKitReference:
    """
    A class to represent a modelkit reference broken down into its parts.
    This class parses a modelkit tag and provides access to its components.
    These include the registry, namespace, model, and tag.

    Attributes:
        registry (str): The registry for the model.
        namespace (str): The namespace for the model.
        model (str): The model name.
        tag (str): The tag for the model.

    Methods:
        __init__():
            Initializes the ModelKitReference instance by parsing a tag.
        registry:
            Gets or sets the registry.
        namespace:
            Gets or sets the namespace.
        repository:
            Gets or sets the repository name.
        tag:
            Gets or sets the tag.
    """
    def __init__(self, modelkit_tag: Optional[str]):
        """
        Initializes the ModelKitReference instance by parsing a tag.

        Args:
            modelkit_tag (Optional[str]): The tag to parse. It should be in the form of:
                {registry}/{namespace}/{model}:{tag}

        Examples:
            >>> ref = ModelKitReference("jozu.ml/jozu-demos/titanic-survivability:latest")
            >>> ref.registry
            'jozu.ml'
            >>> ref.namespace
            'jozu-demos'
            >>> ref.repository
            'titanic-survivability'
            >>> ref.tag
            'latest'
        """
        if not modelkit_tag:
            self.registry = None
            self.namespace = None
            self.repository = None
            self.tag = None
        else:
            # try to parse the modelkit tag into its components. 
            try:
                parts = parse_modelkit_tag(modelkit_tag)
                self.registry = parts.get("registry")
                self.namespace = parts.get("namespace")
                self.repository = parts.get("model")
                self.tag = parts.get("tag")
            except ValueError as e:
                raise ValueError(
                        f"Error parsing modelkit tag: {modelkit_tag}"
                      ) from e

    @property
    def registry(self) -> Optional[str]:
        """
        Gets the registry.
        """
        return self._registry

    @registry.setter
    def registry(self, value: Optional[str]):
        """
        Sets the registry.

        Args:
            value (str): The registry to set.

        Raises:
            ValueError: If the registry is not a string or is not None

        Examples:
            >>> ref = ModelKitReference("jozu.ml/jozu-demos/titanic-survivability:latest")
            >>> ref.registry = "new_registry"
            >>> ref.registry
            'new_registry'
        """
        if value is not None and not isinstance(value, str):
            raise ValueError("Registry must be a string or None")
        self._registry = value

    @property
    def namespace(self) -> Optional[str]:
        """
        Gets the namespace.

        Examples:
            >>> ref = ModelKitReference("jozu.ml/jozu-demos/titanic-survivability:latest")
            >>> ref.namespace = "new_namespace"
            >>> ref.namespace
            'new_namespace'
        """
        return self._namespace

    @namespace.setter
    def namespace(self, value: Optional[str]):
        """
        Sets the namespace.

        Args:
            value (str): The namespace to set.

            Raises:
                ValueError: If the namespace is not a string or is not None.

                Examples:
                >>> ref = ModelKitReference("jozu.ml/jozu-demos/titanic-survivability:latest")
                >>> ref.namespace = "new_namespace"
                >>> ref.namespace
                'new_namespace'
        """
        if value is not None and not isinstance(value, str):
            raise ValueError("Namespace must be a string or None.")
        self._namespace = value

    @property
    def repository(self) -> Optional[str]:
        """
        Gets the repository name.

        Examples:
            >>> ref = ModelKitReference("jozu.ml/jozu-demos/titanic-survivability:latest")
            >>> ref.repository = "new_model"
            >>> ref.repository
            'new_repository'    
        """
        return self._repository

    @repository.setter
    def repository(self, value: Optional[str]):
        """
        Sets the repository name.

        Args:
            value (str): The repository name to set.

            Raises:
                ValueError: If the repository name is not a string or is None.

            Examples:
                >>> ref = ModelKitReference("jozu.ml/jozu-demos/titanic-survivability:latest")
                >>> ref.repository = "new_repository"
                >>> ref.repository
                'new_repository'
        """
        if value is not None and not isinstance(value, str):
            raise ValueError("Model name must be a string.")
        self._repository = value

    @property
    def tag(self) -> Optional[str]:
        """
        Gets the tag.

        Examples:
            >>> ref = ModelKitReference("jozu.ml/jozu-demos/titanic-survivability:latest")
            >>> ref.tag = "new_tag"
            >>> ref.tag
            'new_tag'
        """
        return self._tag

    @tag.setter
    def tag(self, value: Optional[str]):
        """
        Sets the tag.

        Args:
            value (str): The tag to set.

            Raises:
                ValueError: If the tag is not a string or None.

            Examples:
                >>> ref = ModelKitReference("jozu.ml/jozu-demos/titanic-survivability:latest")
                >>> ref.tag = "new_tag"
                >>> ref.tag
                'new_tag'
        """
        if value is not None and not isinstance(value, str):
            raise ValueError("Tag must be a string or None.")
        self._tag = value

    @property
    def modelkit_tag(self):
        if not self.registry:
            raise ValueError("Registry must be set to a non-empty string.")
        if not self.namespace:
            raise ValueError("Namespace must be set to a non-empty string.")
        if not self.repository:
            raise ValueError("Repository must be set to a non-empty string.")
        if not self.tag:
            raise ValueError("tag must be set to a non-empty string.")
        return f"{self.registry}/{self.namespace}/{self.repository}:{self.tag}"

namespace: Optional[str] property writable

Gets the namespace.

Examples:

>>> ref = ModelKitReference("jozu.ml/jozu-demos/titanic-survivability:latest")
>>> ref.namespace = "new_namespace"
>>> ref.namespace
'new_namespace'

registry: Optional[str] property writable

Gets the registry.

repository: Optional[str] property writable

Gets the repository name.

Examples:

>>> ref = ModelKitReference("jozu.ml/jozu-demos/titanic-survivability:latest")
>>> ref.repository = "new_model"
>>> ref.repository
'new_repository'

tag: Optional[str] property writable

Gets the tag.

Examples:

>>> ref = ModelKitReference("jozu.ml/jozu-demos/titanic-survivability:latest")
>>> ref.tag = "new_tag"
>>> ref.tag
'new_tag'

__init__(modelkit_tag)

Initializes the ModelKitReference instance by parsing a tag.

Parameters:

Name Type Description Default
modelkit_tag Optional[str]

The tag to parse. It should be in the form of: {registry}/{namespace}/{model}:{tag}

 required

Examples:

>>> ref = ModelKitReference("jozu.ml/jozu-demos/titanic-survivability:latest")
>>> ref.registry
'jozu.ml'
>>> ref.namespace
'jozu-demos'
>>> ref.repository
'titanic-survivability'
>>> ref.tag
'latest'
Source code in kitops/modelkit/reference.py 
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
def __init__(self, modelkit_tag: Optional[str]):
    """
    Initializes the ModelKitReference instance by parsing a tag.

    Args:
        modelkit_tag (Optional[str]): The tag to parse. It should be in the form of:
            {registry}/{namespace}/{model}:{tag}

    Examples:
        >>> ref = ModelKitReference("jozu.ml/jozu-demos/titanic-survivability:latest")
        >>> ref.registry
        'jozu.ml'
        >>> ref.namespace
        'jozu-demos'
        >>> ref.repository
        'titanic-survivability'
        >>> ref.tag
        'latest'
    """
    if not modelkit_tag:
        self.registry = None
        self.namespace = None
        self.repository = None
        self.tag = None
    else:
        # try to parse the modelkit tag into its components. 
        try:
            parts = parse_modelkit_tag(modelkit_tag)
            self.registry = parts.get("registry")
            self.namespace = parts.get("namespace")
            self.repository = parts.get("model")
            self.tag = parts.get("tag")
        except ValueError as e:
            raise ValueError(
                    f"Error parsing modelkit tag: {modelkit_tag}"
                  ) from e