def delete_model(model_id: str):
api_client = get_swagger_client()
api_instance = swagger_client.ModelServiceApi(api_client=api_client)
try:
api_instance.delete_model(model_id)
except ApiException as e:
print("Exception when calling ModelServiceApi -> delete_model: %s\n" % e, file=stderr)
def delete_assets(upload_assets_response: ApiCatalogUploadResponse = None):
api_client = get_swagger_client()
delete_methods = {
"components":
swagger_client.ComponentServiceApi(api_client).delete_component,
"datasets":
swagger_client.DatasetServiceApi(api_client).delete_dataset,
"models": swagger_client.ModelServiceApi(api_client).delete_model,
"notebooks":
swagger_client.NotebookServiceApi(api_client).delete_notebook,
"pipelines":
swagger_client.PipelineServiceApi(api_client).delete_pipeline
}
try:
for asset_type, delete_method in delete_methods.items():
if upload_assets_response:
asset_list = upload_assets_response.__getattribute__(
asset_type)
for asset in asset_list:
delete_method(asset.id)
else:
delete_method("*")
except ApiException as e:
print(f"Exception when calling {delete_method}: {e}\n", file=stderr)
def download_model_tgz(model_id, download_dir: str = None) -> str:
api_client = get_swagger_client()
api_instance = swagger_client.ModelServiceApi(api_client=api_client)
try:
response: HTTPResponse = \
api_instance.download_model_files(model_id,
include_generated_code=True,
_preload_content=False)
attachment_header = response.info().get("Content-Disposition",
f"attachment; filename={model_id}.tgz")
download_filename = re.sub("attachment; filename=", "", attachment_header)
download_dir = download_dir or os.path.join(tempfile.gettempdir(), "download", "models")
os.makedirs(download_dir, exist_ok=True)
tarfile_path = os.path.join(download_dir, download_filename)
with open(tarfile_path, 'wb') as f:
f.write(response.read())
print(tarfile_path)
return tarfile_path
except ApiException as e:
print("Exception when calling ModelServiceApi -> download_model_files: %s\n" % e, file=stderr)
return "Download failed?"
def upload_model_file(model_id, file_path):
api_client = get_swagger_client()
api_instance = swagger_client.ModelServiceApi(api_client=api_client)
try:
response = api_instance.upload_model_file(id=model_id, uploadfile=file_path)
print(f"Upload file '{file_path}' to model '{model_id}'")
except ApiException as e:
print("Exception when calling ModelServiceApi -> upload_model_file: %s\n" % e, file=stderr)
raise e
def get_model(model_id: str) -> ApiModel:
api_client = get_swagger_client()
api_instance = swagger_client.ModelServiceApi(api_client=api_client)
try:
model_meta: ApiModel = api_instance.get_model(model_id)
pprint(model_meta, indent=2)
return model_meta
except ApiException as e:
print("Exception when calling ModelServiceApi -> get_model: %s\n" % e, file=stderr)
return None
def upload_model_template(uploadfile_name, name=None) -> str:
api_client = get_swagger_client()
api_instance = swagger_client.ModelServiceApi(api_client=api_client)
try:
print(f"Uploading '{uploadfile_name}' ... ", end='')
model: ApiModel = api_instance.upload_model(uploadfile=uploadfile_name, name=name)
print(f"{model.id} '{model.name}'")
return model.id
except ApiException as e:
print("Exception when calling ModelServiceApi -> upload_model: %s\n" % e, file=stderr)
raise e
return None
def set_featured_models(model_ids: [str]):
api_client = get_swagger_client()
api_instance = swagger_client.ModelServiceApi(api_client=api_client)
try:
api_response = api_instance.set_featured_models(model_ids)
except ApiException as e:
print("Exception when calling ModelServiceApi -> set_featured_models: %s\n" % e, file=stderr)
return None
def approve_models_for_publishing(model_ids: [str]):
api_client = get_swagger_client()
api_instance = swagger_client.ModelServiceApi(api_client=api_client)
try:
api_response = api_instance.approve_models_for_publishing(model_ids)
except ApiException as e:
print("Exception when calling ModelServiceApi -> approve_models_for_publishing: %s\n" % e, file=stderr)
return None
def verify_model_download(model_id: str) -> bool:
api_client = get_swagger_client()
api_instance = swagger_client.ModelServiceApi(api_client=api_client)
try:
response: HTTPResponse = \
api_instance.download_model_files(model_id,
include_generated_code=True,
_preload_content=False)
tgz_file = BytesIO(response.read())
tar = tarfile.open(fileobj=tgz_file)
file_contents = {m.name: tar.extractfile(m).read().decode("utf-8")
for m in tar.getmembers()}
# verify template text matches
template_response: ApiGetTemplateResponse = api_instance.get_model_template(model_id)
template_from_api = template_response.template
template_from_tgz = [content for filename, content in file_contents.items()
if filename.endswith(".yaml") or filename.endswith(".yml")][0]
assert template_from_api == template_from_tgz
# verify generated code matches
generate_code_response: ApiGenerateModelCodeResponse = \
api_instance.generate_model_code(model_id)
for model_script in generate_code_response.scripts:
stage = model_script.pipeline_stage
platform = model_script.execution_platform
script_from_api = model_script.script_code
downloaded_script = [content for filename, content in file_contents.items()
if f"run_{stage}_{platform}" in filename][0]
assert script_from_api == downloaded_script
print("downloaded files match")
return True
except ApiException as e:
print("Exception when calling ModelServiceApi -> download_model_files: %s\n" % e, file=stderr)
return False
def run_code(model_id: str, pipeline_stage: str, execution_platform: str, run_name: str = None, parameters=dict()) -> str:
api_client = get_swagger_client()
api_instance = swagger_client.ModelServiceApi(api_client=api_client)
try:
run_code_response: ApiRunCodeResponse = api_instance.run_model(model_id, pipeline_stage, execution_platform,
run_name=run_name, parameters=parameters)
print(run_code_response.run_url)
return run_code_response.run_url
except ApiException as e:
print("Exception while calling ModelServiceApi -> run_code: %s\n" % e, file=stderr)
return None
def list_models(filter_dict: dict = {}, sort_by: str = None) -> [ApiModel]:
api_client = get_swagger_client()
api_instance = swagger_client.ModelServiceApi(api_client=api_client)
try:
filter_str = json.dumps(filter_dict) if filter_dict else None
api_response: ApiListModelsResponse = api_instance.list_models(filter=filter_str, sort_by=sort_by)
for c in api_response.models:
print("%s %s %s" % (c.id, c.created_at.strftime("%Y-%m-%d %H:%M:%S"), c.name))
return api_response.models
except ApiException as e:
print("Exception when calling ModelServiceApi -> list_models: %s\n" % e, file=stderr)
return []
def get_template(template_id: str) -> str:
api_client = get_swagger_client()
api_instance = swagger_client.ModelServiceApi(api_client=api_client)
try:
template_response: ApiGetTemplateResponse = api_instance.get_model_template(template_id)
print(template_response.template)
# yaml_dict = yaml.load(template_response.template, Loader=yaml.FullLoader)
# model_name = yaml_dict.get("name") or f"template_{template_id}"
# template_file = os.path.join("files", model_name) + ".yaml"
# with open(template_file, "w") as f:
# f.write(template_response.template)
return template_response.template
except ApiException as e:
print("Exception when calling ModelServiceApi -> get_model_template: %s\n" % e, file=stderr)
return None
def generate_code(model_id: str) -> str:
api_client = get_swagger_client()
api_instance = swagger_client.ModelServiceApi(api_client=api_client)
try:
generate_code_response: ApiGenerateModelCodeResponse = api_instance.generate_model_code(model_id)
for model_script in generate_code_response.scripts:
print(f"#######################################################")
print(f"# pipeline_stage: {model_script.pipeline_stage}")
print(f"# execution_platform: {model_script.execution_platform}")
print(f"#######################################################")
print()
print(model_script.script_code)
print()
return generate_code_response.scripts
except ApiException as e:
print("Exception while calling ModelServiceApi -> generate_code: %s\n" % e, file=stderr)
return None