add uninstall cmd

Author: gau-nernst

engine/extensions/python-engines/python_utils.cc

@@ -20,11 +20,21 @@ std::filesystem::path GetUvPath() {
   const auto bin_name = system_info->os == kWindowsOs ? "uv.exe" : "uv";
   return GetPythonEnginesPath() / "bin" / bin_name;
 }
+bool UvCleanCache() {
+  auto cmd = UvBuildCommand("cache");
+  cmd.push_back("clean");
+  auto result = cortex::process::SpawnProcess(cmd);
+  if (result.has_error()) {
+    CTL_INF(result.error());
+    return false;
+  }
+  return cortex::process::WaitProcess(result.value());
+}
 
-bool IsUvInstalled() {
+bool UvIsInstalled() {
   return std::filesystem::exists(GetUvPath());
 }
-cpp::result<void, std::string> InstallUv() {
+cpp::result<void, std::string> UvInstall() {
   const auto py_bin_path = GetPythonEnginesPath() / "bin";
   std::filesystem::create_directories(py_bin_path);
 
@@ -75,7 +85,7 @@ cpp::result<void, std::string> InstallUv() {
   // this Python installation.
   // we can add this once we allow passing custom env var to SpawnProcess().
   // https://docs.astral.sh/uv/reference/cli/#uv-python-install
-  std::vector<std::string> command = BuildUvCommand("python");
+  std::vector<std::string> command = UvBuildCommand("python");
   command.push_back("install");
   command.push_back("3.10");
 
@@ -92,7 +102,7 @@ cpp::result<void, std::string> InstallUv() {
   return {};
 }
 
-std::vector<std::string> BuildUvCommand(const std::string& action,
+std::vector<std::string> UvBuildCommand(const std::string& action,
                                         const std::string& directory) {
   // use our own cache dir so that when users delete cortexcpp/, everything is deleted.
   const auto cache_dir = GetPythonEnginesPath() / "cache" / "uv";
@@ -106,31 +116,4 @@ std::vector<std::string> BuildUvCommand(const std::string& action,
   return command;
 }
 
-// cpp::result<void, std::string> UvDownloadDeps(
-//     const std::filesystem::path& model_dir) {
-//   if (!IsUvInstalled())
-//     return cpp::fail(
-//         "uv is not installed. Please run `cortex engines install python`.");
-
-//   std::vector<std::string> command = BuildUvCommand("sync", model_dir.string());
-
-//   // script mode. 1st argument is path to .py script
-//   if (!std::filesystem::exists(model_dir / "pyproject.toml")) {
-//     config::PythonModelConfig py_cfg;
-//     py_cfg.ReadFromYaml((model_dir / "model.yml").string());
-//     command.push_back("--script");
-//     command.push_back(py_cfg.entrypoint[0]);
-//   }
-
-//   auto result = cortex::process::SpawnProcess(command);
-//   if (result.has_error())
-//     return cpp::fail("Fail to install Python dependencies. " + result.error());
-
-//   if (!cortex::process::WaitProcess(result.value())) {
-//     return cpp::fail("Fail to install Python dependencies.");
-//   }
-
-//   return {};
-// }
-
 }  // namespace python_utils

engine/extensions/python-engines/python_utils.h

@@ -14,12 +14,11 @@ std::filesystem::path GetEnvsPath();
 std::filesystem::path GetUvPath();
 
 // UV-related functions
-bool IsUvInstalled();
-cpp::result<void, std::string> InstallUv();
-std::vector<std::string> BuildUvCommand(const std::string& action,
+bool UvIsInstalled();
+cpp::result<void, std::string> UvInstall();
+std::vector<std::string> UvBuildCommand(const std::string& action,
                                         const std::string& directory = "");
-// cpp::result<void, std::string> UvDownloadDeps(
-//     const std::filesystem::path& yaml_path);
+bool UvCleanCache();
 
 struct PythonSubprocess {
   cortex::process::ProcessInfo proc_info;

engine/services/engine_service.cc

@@ -201,6 +201,16 @@ cpp::result<bool, std::string> EngineService::UninstallEngineVariant(
     } else {
       return cpp::fail("No variant provided");
     }
+  } else if (ne == kVllmEngine) {
+    // variant is ignored for vLLM
+    if (version == std::nullopt) {
+      path_to_remove = python_utils::GetEnvsPath() / "vllm";
+
+      // we only clean uv cache when all vLLM versions are deleted
+      python_utils::UvCleanCache();
+    } else {
+      path_to_remove = python_utils::GetEnvsPath() / "vllm" / version.value();
+    }
   } else {
     return cpp::fail("Not implemented for engine " + ne);
   }
@@ -394,8 +404,8 @@ cpp::result<void, std::string> EngineService::DownloadVllm(
   // NOTE: everything below is not async
   // to make it async, we have to run everything in a thread (spawning and waiting
   // for subprocesses)
-  if (!python_utils::IsUvInstalled()) {
-    auto result = python_utils::InstallUv();
+  if (!python_utils::UvIsInstalled()) {
+    auto result = python_utils::UvInstall();
     if (result.has_error())
       return result;
   }
@@ -421,21 +431,20 @@ cpp::result<void, std::string> EngineService::DownloadVllm(
   // initialize venv
   if (!fs::exists(vllm_path / ".venv")) {
     std::vector<std::string> cmd =
-        python_utils::BuildUvCommand("venv", vllm_path.string());
+        python_utils::UvBuildCommand("venv", vllm_path.string());
     cmd.push_back("--relocatable");
     auto result = cortex::process::SpawnProcess(cmd);
     if (result.has_error())
       return cpp::fail(result.error());
 
     // TODO: check return code
-    // NOTE: these are not async
     cortex::process::WaitProcess(result.value());
   }
 
   // install vLLM
   {
     std::vector<std::string> cmd =
-        python_utils::BuildUvCommand("pip", vllm_path.string());
+        python_utils::UvBuildCommand("pip", vllm_path.string());
     cmd.push_back("install");
     cmd.push_back("vllm==" + concrete_version);
     auto result = cortex::process::SpawnProcess(cmd);
@@ -444,7 +453,6 @@ cpp::result<void, std::string> EngineService::DownloadVllm(
 
     // TODO: check return code
     // one reason this may fail is that the requested version does not exist
-    // NOTE: these are not async
     cortex::process::WaitProcess(result.value());
   }