Skip to content

Kitfile class

You can import the Kitfile class from kitops.modelkit.kitfile:

from kitops.modelkit.kitfile import Kitfile

Kitfile class to manage KitOps ModelKits and Kitfiles.

Attributes:

Name Type Description
path str

Path to the Kitfile.
Source code in kitops/modelkit/kitfile.py 
 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
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
class Kitfile:
    """
    Kitfile class to manage KitOps ModelKits and Kitfiles.

    Attributes:
        path (str): Path to the Kitfile.
    """

    def __init__(self, path: str | None = None):
        """
        Initialize the Kitfile from a path to an existing Kitfile, or 
        create an empty Kitfile.

        Examples:
            >>> kitfile = Kitfile(path="path/to/Kitfile")
            >>> kitfile.to_yaml()

            >>> kitfile = Kitfile()
            >>> kitfile.manifestVersion = "1.0"
            >>> kitfile.package = {"name": "my_package", "version": "0.1.0",
            ...                    "description": "My package description",
            ...                    "authors": ["Author 1", "Author 2"]}
            >>> kitfile.code = [{"path": "code/", "description": "Code description",
            ...                  "license": "Apache-2.0"}]
            >>> kitfile.datasets = [{"name": "my_dataset", "path": "datasets/",
            ...                      "description": "Dataset description",
            ...                      "license": "Apache-2.0"}]
            >>> kitfile.docs = [{"path": "docs/", "description": "Docs description"}]
            >>> kitfile.model = {"name": "my_model", "path": "model/",
            ...                  "framework": "tensorflow", "version": "2.0.0",
            ...                  "description": "Model description",
            ...                  "license": "Apache-2.0", "parts": [],
            ...                  "parameters": ""}
            >>> kitfile.to_yaml()
            'manifestVersion: 1.0
             package:
                 name: my_package
                 version: 0.1.0
                 description: My package description
                 authors:
                 - Author 1
                 - Author 2
             code:
             - path: code/
               description: Code description
               license: Apache-2.0
             datasets:
             - name: my_dataset
               path: datasets/
               description: Dataset description
               license: Apache-2.0
             docs:
             - path: docs/
               description: Docs description
             model:
                 name: my_model
                 path: model/
                 framework: tensorflow
                 version: 2.0.0
                 description: Model description
                 license: Apache-2.0'

        Args:
            path (str, optional): Path to existing Kitfile to load. Defaults to None.

        Returns:
            Kitfile (Kitfile): Kitfile object.
        """
        self._data: Dict = {}
        self._kitfile_allowed_keys = {'manifestVersion', 'package', 
                                     'code', 'datasets', 'docs', 'model'}

        # initialize the kitfile section validators
        self._initialize_kitfile_section_validators()

        # initialize an empty kitfile object
        self.manifestVersion = ""
        self.package = {"name": "", "version": "", "description": "", 
                        "authors": []}
        self.code = []
        self.datasets = []
        self.docs = []
        self.model = {"name": "", "path": "", "description": "", 
                      "framework": "", "license": "", "version": "", 
                      "parts": [], "parameters": ""}

        if path:
            self.load(path)

    def _initialize_kitfile_section_validators(self):
        """
        Initialize validators for Kitfile sections.
        """
        self._manifestVersion_validator = ManifestVersionValidator(
                                            section='manifestVersion',
                                            allowed_keys=set())
        self._package_validator = PackageValidator(
                                    section='package',
                                    allowed_keys={"name", "version", 
                                                  "description", "authors"})
        self._code_validator = CodeValidator(
                                    section='code',
                                    allowed_keys={"path", "description", 
                                                  "license"})
        self._datasets_validator = DatasetsValidator(
                                    section='datasets',
                                    allowed_keys={"name", "path", 
                                                  "description", "license"})
        self._docs_validator = DocsValidator(
                                    section='docs',
                                    allowed_keys={"path", "description"})
        self._model_validator = ModelValidator(
                                    section='model',
                                    allowed_keys={"name", "path", "framework",
                                                  "version", "description", 
                                                  "license", "parts", 
                                                  "parameters"})

    def _validate_and_set_attributes(self, data: Dict[str, Any]):
        """
        Validate and set attributes from the provided data.

        Args:
            data (Dict[str, Any]): Data to validate and set.
        """
        for key, value in data.items():
            self.__setattr__(key, value)

    def load(self, path):
        """
        Load Kitfile data from a yaml-formatted file and set the
        corresponding attributes.

        Args:
            path (str): Path to the Kitfile.
        """
        kitfile_path = Path(path)
        if not kitfile_path.exists():
            raise ValueError(f"Path '{kitfile_path}' does not exist.")

        # try to load the kitfile
        try:
            with open(kitfile_path, 'r') as kitfile:
            # Load the yaml data
                data = yaml.safe_load(kitfile)
        except yaml.YAMLError as e:
            if hasattr(e, 'problem_mark'):
                mark = e.problem_mark
                raise yaml.YAMLError(
                            "Error parsing Kitfile at " +
                            f"line{mark.line+1}, " +
                            f"column:{mark.column+1}.") from e
            else:
                raise

        try:
            validate_dict(value=data, 
                          allowed_keys=self._kitfile_allowed_keys)
        except ValueError as e:
            raise ValueError(
                    "Kitfile must be a dictionary with allowed " +
                     f"keys: {', '.join(self._kitfile_allowed_keys)}"
                    ) from e
        # kitfile has been successfully loaded into data
        self._validate_and_set_attributes(data)

    @property
    def manifestVersion(self) -> str:
        """
        Get the manifest version.

        Returns:
            str: Manifest version.
        """
        return self._data["manifestVersion"]

    @manifestVersion.setter
    def manifestVersion(self, value: str):
        """
        Set the manifest version.

        Args:
            value (str): Manifest version.
        """
        self._manifestVersion_validator.validate(data=value)
        self._data["manifestVersion"] = value

    @property
    def package(self) -> Dict[str, Any]:
        """
        Get the package information.

        Returns:
            Dict[str, Any]: Package information.
        """
        return self._data["package"]

    @package.setter
    def package(self, value: Dict[str, Any]):
        """
        Set the package information.

        Args:
            value (Dict[str, Any]): Package information.
        """
        self._package_validator.validate(data=value)
        self._data["package"] = value

    @property
    def code(self) -> List[Dict[str, Any]]:
        """
        Get the code section.

        Returns:
            List[Dict[str, Any]]: Code section.
        """
        return self._data["code"]

    @code.setter
    def code(self, value: List[Dict[str, Any]]):
        """
        Set the code section.

        Args:
            value (List[Dict[str, Any]]): Code section.
        """
        self._code_validator.validate(data=value)
        self._data["code"] = value

    @property
    def datasets(self) -> List[Dict[str, Any]]:
        """
        Get the datasets section.

        Returns:
            List[Dict[str, Any]]: Datasets section.
        """
        return self._data["datasets"]

    @datasets.setter
    def datasets(self, value: List[Dict[str, Any]]):
        """
        Set the datasets section.

        Args:
            value (List[Dict[str, Any]]): Datasets section.
        """
        self._datasets_validator.validate(data=value)
        self._data["datasets"] = value

    @property
    def docs(self) -> List[Dict[str, Any]]:
        """
        Get the docs section.

        Returns:
            List[Dict[str, Any]]: Docs section.
        """
        return self._data["docs"]

    @docs.setter
    def docs(self, value: List[Dict[str, Any]]):
        """
        Set the docs section.

        Args:
            value (List[Dict[str, Any]]): Docs section.
        """
        self._docs_validator.validate(data=value)
        self._data["docs"] = value

    @property
    def model(self) -> Dict[str, Any]:
        """
        Get the model section.

        Returns:
            Dict[str, Any]: Model section.
        """
        return self._data["model"]

    @model.setter
    def model(self, value: Dict[str, Any]):
        """
        Set the model section.

        Args:
            value (Dict[str, Any]): Model section.
        """
        self._model_validator.validate(data=value)
        self._data["model"] = value

    def to_yaml(self, suppress_empty_values: bool = True) -> str:
        """
        Serialize the Kitfile to YAML format. 

        Args:
            suppress_empty_values (bool, optional): Whether to suppress 
                empty values. Defaults to True.
        Returns:
            str: YAML representation of the Kitfile.
        """
        dict_to_print = self._data
        if suppress_empty_values:
            dict_to_print = copy.deepcopy(self._data)
            dict_to_print = clean_empty_items(dict_to_print)

        return yaml.safe_dump(data = dict_to_print, sort_keys=False,
                         default_flow_style=False)

    def print(self) -> None:
        """
        Print the Kitfile to the console.

        Returns:
            None
        """
        print('\n\nKitfile Contents...')
        print('===================\n')
        output = self.to_yaml()
        if IS_A_TTY:
            output = f"{Color.GREEN.value}{output}{Color.RESET.value}"
        print(output)

    def save(self, path: str = "Kitfile", print: bool = True) -> None:
        """
        Save the Kitfile to a file.

        Args:
            path (str): Path to save the Kitfile. Defaults to "Kitfile".
            print (bool): If True, print the Kitfile to the console. 
                Defaults to True.

        Returns:
            None

        Examples:
            >>> kitfile = Kitfile()
            >>> kitfile.save("path/to/Kitfile")
        """
        with open(path, 'w') as file:
            file.write(self.to_yaml())

        if print:
            self.print()

code: List[Dict[str, Any]] property writable

Get the code section.

Returns:

Type Description
List[Dict[str, Any]]

List[Dict[str, Any]]: Code section.

datasets: List[Dict[str, Any]] property writable

Get the datasets section.

Returns:

Type Description
List[Dict[str, Any]]

List[Dict[str, Any]]: Datasets section.

docs: List[Dict[str, Any]] property writable

Get the docs section.

Returns:

Type Description
List[Dict[str, Any]]

List[Dict[str, Any]]: Docs section.

manifestVersion: str property writable

Get the manifest version.

Returns:

Name Type Description
str str

Manifest version.

model: Dict[str, Any] property writable

Get the model section.

Returns:

Type Description
Dict[str, Any]

Dict[str, Any]: Model section.

package: Dict[str, Any] property writable

Get the package information.

Returns:

Type Description
Dict[str, Any]

Dict[str, Any]: Package information.

__init__(path=None)

Initialize the Kitfile from a path to an existing Kitfile, or create an empty Kitfile.

Examples:

>>> kitfile = Kitfile(path="path/to/Kitfile")
>>> kitfile.to_yaml()

>>> kitfile = Kitfile()
>>> kitfile.manifestVersion = "1.0"
>>> kitfile.package = {"name": "my_package", "version": "0.1.0",
...                    "description": "My package description",
...                    "authors": ["Author 1", "Author 2"]}
>>> kitfile.code = [{"path": "code/", "description": "Code description",
...                  "license": "Apache-2.0"}]
>>> kitfile.datasets = [{"name": "my_dataset", "path": "datasets/",
...                      "description": "Dataset description",
...                      "license": "Apache-2.0"}]
>>> kitfile.docs = [{"path": "docs/", "description": "Docs description"}]
>>> kitfile.model = {"name": "my_model", "path": "model/",
...                  "framework": "tensorflow", "version": "2.0.0",
...                  "description": "Model description",
...                  "license": "Apache-2.0", "parts": [],
...                  "parameters": ""}
>>> kitfile.to_yaml()
'manifestVersion: 1.0
 package:
     name: my_package
     version: 0.1.0
     description: My package description
     authors:
     - Author 1
     - Author 2
 code:
 - path: code/
   description: Code description
   license: Apache-2.0
 datasets:
 - name: my_dataset
   path: datasets/
   description: Dataset description
   license: Apache-2.0
 docs:
 - path: docs/
   description: Docs description
 model:
     name: my_model
     path: model/
     framework: tensorflow
     version: 2.0.0
     description: Model description
     license: Apache-2.0'

Parameters:

Name Type Description Default
path str

Path to existing Kitfile to load. Defaults to None.

 None

Returns:

Name Type Description
Kitfile Kitfile

Kitfile object.
Source code in kitops/modelkit/kitfile.py 
 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
def __init__(self, path: str | None = None):
    """
    Initialize the Kitfile from a path to an existing Kitfile, or 
    create an empty Kitfile.

    Examples:
        >>> kitfile = Kitfile(path="path/to/Kitfile")
        >>> kitfile.to_yaml()

        >>> kitfile = Kitfile()
        >>> kitfile.manifestVersion = "1.0"
        >>> kitfile.package = {"name": "my_package", "version": "0.1.0",
        ...                    "description": "My package description",
        ...                    "authors": ["Author 1", "Author 2"]}
        >>> kitfile.code = [{"path": "code/", "description": "Code description",
        ...                  "license": "Apache-2.0"}]
        >>> kitfile.datasets = [{"name": "my_dataset", "path": "datasets/",
        ...                      "description": "Dataset description",
        ...                      "license": "Apache-2.0"}]
        >>> kitfile.docs = [{"path": "docs/", "description": "Docs description"}]
        >>> kitfile.model = {"name": "my_model", "path": "model/",
        ...                  "framework": "tensorflow", "version": "2.0.0",
        ...                  "description": "Model description",
        ...                  "license": "Apache-2.0", "parts": [],
        ...                  "parameters": ""}
        >>> kitfile.to_yaml()
        'manifestVersion: 1.0
         package:
             name: my_package
             version: 0.1.0
             description: My package description
             authors:
             - Author 1
             - Author 2
         code:
         - path: code/
           description: Code description
           license: Apache-2.0
         datasets:
         - name: my_dataset
           path: datasets/
           description: Dataset description
           license: Apache-2.0
         docs:
         - path: docs/
           description: Docs description
         model:
             name: my_model
             path: model/
             framework: tensorflow
             version: 2.0.0
             description: Model description
             license: Apache-2.0'

    Args:
        path (str, optional): Path to existing Kitfile to load. Defaults to None.

    Returns:
        Kitfile (Kitfile): Kitfile object.
    """
    self._data: Dict = {}
    self._kitfile_allowed_keys = {'manifestVersion', 'package', 
                                 'code', 'datasets', 'docs', 'model'}

    # initialize the kitfile section validators
    self._initialize_kitfile_section_validators()

    # initialize an empty kitfile object
    self.manifestVersion = ""
    self.package = {"name": "", "version": "", "description": "", 
                    "authors": []}
    self.code = []
    self.datasets = []
    self.docs = []
    self.model = {"name": "", "path": "", "description": "", 
                  "framework": "", "license": "", "version": "", 
                  "parts": [], "parameters": ""}

    if path:
        self.load(path)

load(path)

Load Kitfile data from a yaml-formatted file and set the corresponding attributes.

Parameters:

Name Type Description Default
path str

Path to the Kitfile.

 required
Source code in kitops/modelkit/kitfile.py 
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
def load(self, path):
    """
    Load Kitfile data from a yaml-formatted file and set the
    corresponding attributes.

    Args:
        path (str): Path to the Kitfile.
    """
    kitfile_path = Path(path)
    if not kitfile_path.exists():
        raise ValueError(f"Path '{kitfile_path}' does not exist.")

    # try to load the kitfile
    try:
        with open(kitfile_path, 'r') as kitfile:
        # Load the yaml data
            data = yaml.safe_load(kitfile)
    except yaml.YAMLError as e:
        if hasattr(e, 'problem_mark'):
            mark = e.problem_mark
            raise yaml.YAMLError(
                        "Error parsing Kitfile at " +
                        f"line{mark.line+1}, " +
                        f"column:{mark.column+1}.") from e
        else:
            raise

    try:
        validate_dict(value=data, 
                      allowed_keys=self._kitfile_allowed_keys)
    except ValueError as e:
        raise ValueError(
                "Kitfile must be a dictionary with allowed " +
                 f"keys: {', '.join(self._kitfile_allowed_keys)}"
                ) from e
    # kitfile has been successfully loaded into data
    self._validate_and_set_attributes(data)

print()

Print the Kitfile to the console.

Returns:

Type Description
None

None
Source code in kitops/modelkit/kitfile.py 
346
347
348
349
350
351
352
353
354
355
356
357
358
def print(self) -> None:
    """
    Print the Kitfile to the console.

    Returns:
        None
    """
    print('\n\nKitfile Contents...')
    print('===================\n')
    output = self.to_yaml()
    if IS_A_TTY:
        output = f"{Color.GREEN.value}{output}{Color.RESET.value}"
    print(output)

save(path='Kitfile', print=True)

Save the Kitfile to a file.

Parameters:

Name Type Description Default
path str

Path to save the Kitfile. Defaults to "Kitfile".

 'Kitfile'
print bool

If True, print the Kitfile to the console. Defaults to True.

 True

Returns:

Type Description
None

None

Examples:

>>> kitfile = Kitfile()
>>> kitfile.save("path/to/Kitfile")
Source code in kitops/modelkit/kitfile.py 
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
def save(self, path: str = "Kitfile", print: bool = True) -> None:
    """
    Save the Kitfile to a file.

    Args:
        path (str): Path to save the Kitfile. Defaults to "Kitfile".
        print (bool): If True, print the Kitfile to the console. 
            Defaults to True.

    Returns:
        None

    Examples:
        >>> kitfile = Kitfile()
        >>> kitfile.save("path/to/Kitfile")
    """
    with open(path, 'w') as file:
        file.write(self.to_yaml())

    if print:
        self.print()

to_yaml(suppress_empty_values=True)

Serialize the Kitfile to YAML format.

Parameters:

Name Type Description Default
suppress_empty_values bool

Whether to suppress empty values. Defaults to True.

 True

Returns: str: YAML representation of the Kitfile.

Source code in kitops/modelkit/kitfile.py 
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
def to_yaml(self, suppress_empty_values: bool = True) -> str:
    """
    Serialize the Kitfile to YAML format. 

    Args:
        suppress_empty_values (bool, optional): Whether to suppress 
            empty values. Defaults to True.
    Returns:
        str: YAML representation of the Kitfile.
    """
    dict_to_print = self._data
    if suppress_empty_values:
        dict_to_print = copy.deepcopy(self._data)
        dict_to_print = clean_empty_items(dict_to_print)

    return yaml.safe_dump(data = dict_to_print, sort_keys=False,
                     default_flow_style=False)