code: def test_update_model_version_flow(client):
      name = "UpdateMVTest"
      start_time_0 = get_current_time_millis()
      client.create_registered_model(name)
      end_time_0 = get_current_time_millis()
      rmd1 = client.get_registered_model(name)
      assert_is_between(
          start_time_0, end_time_0, rmd1.creation_timestamp
      )
      assert_is_between(
          start_time_0, end_time_0, rmd1.last_updated_timestamp
      )
  
      start_time_1 = get_current_time_millis()
      mv1 = client.create_model_version(
          name, "runs:/run_id/model", "run_id_1"
      )
      end_time_1 = get_current_time_millis()
      assert mv1.version == "1"
      assert mv1.name == name
      mvd1 = client.get_model_version(name, "1")
      assert str(mvd1.description) == ""
      assert_is_between(
          start_time_1, end_time_1, mvd1.creation_timestamp
      )
      assert_is_between(
          start_time_1, end_time_1, mvd1.last_updated_timestamp
      )
  
      # creating model version changes last_updated_timestamp for registered model
      rmd2 = client.get_registered_model(name)
      assert_is_between(
          start_time_0, end_time_0, rmd2.creation_timestamp
      )
      assert_is_between(
          start_time_1, end_time_1, rmd2.last_updated_timestamp
      )
  
      assert [
          rm.latest_versions
          for rm in client.search_registered_models()
          if rm.name == name
      ] == [[mvd1]]
      mv2 = client.create_model_version(
          name, "runs:/run_id/another_model", "run_id_1"
      )
      assert mv2.version == "2"
      assert mv2.name == name
      mvd2 = client.get_model_version(name, "2")
      assert [
          rm.latest_versions
          for rm in client.search_registered_models()
          if rm.name == name
      ] == [[mvd2]]
  
      start_time_2 = get_current_time_millis()
      client.transition_model_version_stage(
          name=name, version=1, stage="Staging"
      )
      end_time_2 = get_current_time_millis()
      mvd1b = client.get_model_version(name, 1)
      assert_is_between(
          start_time_1, end_time_1, mvd1b.creation_timestamp
      )
      assert_is_between(
          start_time_2, end_time_2, mvd1b.last_updated_timestamp
      )
  
      # updating model version's stage changes last_updated_timestamp for registered model
      rmd3 = client.get_registered_model(name)
      assert_is_between(
          start_time_0, end_time_0, rmd3.creation_timestamp
      )
      assert_is_between(
          start_time_2, end_time_2, rmd3.last_updated_timestamp
      )
  
      model_versions_detailed = [
          rm.latest_versions
          for rm in client.search_registered_models()
          if rm.name == name
      ]
      assert len(model_versions_detailed) == 1
      assert {mvd.version for mvd in model_versions_detailed[0]} == {
          "1",
          "2",
      }
      assert {mvd.name for mvd in model_versions_detailed[0]} == {name}
  
      # update description
      start_time_3 = get_current_time_millis()
      client.update_model_version(
          name=name, version=1, description="This is a test model"
      )
      end_time_3 = get_current_time_millis()
      mvd1c = client.get_model_version(name, "1")
      assert str(mvd1c.description) == "This is a test model"
      assert_is_between(
          start_time_1, end_time_1, mvd1c.creation_timestamp
      )
      assert_is_between(
          start_time_3, end_time_3, mvd1c.last_updated_timestamp
      )
  
      # changing description for model version does not affect last_updated_timestamp for registered
      # model
      rmd4 = client.get_registered_model(name)
      assert_is_between(
          start_time_0, end_time_0, rmd4.creation_timestamp
      )
      assert_is_between(
          start_time_2, end_time_2, rmd4.last_updated_timestamp
      )
  
imports: import time
  import pytest
  from mlflow import MlflowClient
  from mlflow.entities.model_registry import ModelVersion, RegisteredModel
  from mlflow.exceptions import MlflowException
  from mlflow.utils.os import is_windows
  from mlflow.utils.time import get_current_time_millis
  from tests.tracking.integration_test_utils import _init_server
label_desc: Use image node_id 15 for calling a global function with example usage: test_update_model_version_flow(client) without return types