clean up pre-commit errors

Author: mattwittwer

src/pb_utils.cc

@@ -27,6 +27,7 @@
 #include "pb_utils.h"
 
 #include <sys/stat.h>
+
 #include <fstream>
 
 #ifdef _WIN32
@@ -39,7 +40,7 @@
 #endif
 
 #ifndef _WIN32
-extern char **environ;
+extern char** environ;
 #endif
 
 
@@ -323,38 +324,44 @@ WrapTritonErrorInSharedPtr(TRITONSERVER_Error* error)
 }
 #endif  // NOT TRITON_PB_STUB
 
-bool IsValidIdentifier(const std::string& input) {
+bool
+IsValidIdentifier(const std::string& input)
+{
   if (input.empty()) {
     return false;
   }
-  
+
   // Check for invalid characters
   if (input.find_first_of(INVALID_CHARS) != std::string::npos) {
     return false;
   }
-  
+
   return true;
 }
 
-bool IsValidPath(const std::string& path) {
+bool
+IsValidPath(const std::string& path)
+{
   if (path.empty()) {
     return false;
   }
-  
+
   // Must be absolute path
   if (path[0] != '/') {
     return false;
   }
-  
+
   return true;
 }
 
-bool IsExecutableFile(const std::string& filepath) {
+bool
+IsExecutableFile(const std::string& filepath)
+{
   struct stat file_stat;
   if (stat(filepath.c_str(), &file_stat) != 0) {
     return false;
   }
-  
+
   // Check if it's a regular file and executable by owner
   return S_ISREG(file_stat.st_mode) && (file_stat.st_mode & S_IXUSR);
 }
@@ -368,14 +375,15 @@ GenerateUUID()
 }
 
 // Helper function to parse environment variables from activation script
-std::map<std::string, std::string> 
-ParseActivationScript(const std::string& activate_path) {
+std::map<std::string, std::string>
+ParseActivationScript(const std::string& activate_path)
+{
   std::map<std::string, std::string> env_vars;
-  
+
   // Read the current environment as baseline
 #ifndef _WIN32
   if (environ != nullptr) {
-    for (char **env = environ; *env != nullptr; env++) {
+    for (char** env = environ; *env != nullptr; env++) {
       std::string env_str(*env);
       size_t eq_pos = env_str.find('=');
       if (eq_pos != std::string::npos) {
@@ -386,33 +394,33 @@ ParseActivationScript(const std::string& activate_path) {
     }
   }
 #endif
-  
+
   // Parse activation script for environment changes
   std::ifstream activate_file(activate_path);
   if (!activate_file.is_open()) {
-    return env_vars; // Return current environment if can't read activation script
+    return env_vars;  // Return current environment if can't read activation
+                      // script
   }
-  
+
   std::string line;
   while (std::getline(activate_file, line)) {
     // Look for export statements or direct assignments
     if (line.find("export ") == 0) {
       // Handle: export VAR=value
-      line = line.substr(7); // Remove "export "
+      line = line.substr(7);  // Remove "export "
     }
-    
+
     size_t eq_pos = line.find('=');
     if (eq_pos != std::string::npos && line[0] != '#') {
       std::string key = line.substr(0, eq_pos);
       std::string value = line.substr(eq_pos + 1);
-      
+
       // Remove quotes if present
-      if (value.size() >= 2 && 
-          ((value[0] == '"' && value.back() == '"') ||
-           (value[0] == '\'' && value.back() == '\''))) {
+      if (value.size() >= 2 && ((value[0] == '"' && value.back() == '"') ||
+                                (value[0] == '\'' && value.back() == '\''))) {
         value = value.substr(1, value.size() - 2);
       }
-      
+
       // Handle variable substitution for common cases
       if (value.find("$PATH") != std::string::npos) {
         size_t pos = value.find("$PATH");
@@ -422,22 +430,23 @@ ParseActivationScript(const std::string& activate_path) {
         size_t pos = value.find("$LD_LIBRARY_PATH");
         value.replace(pos, 16, env_vars["LD_LIBRARY_PATH"]);
       }
-      
+
       env_vars[key] = value;
     }
   }
-  
+
   return env_vars;
 }
 
 // Helper function to prepare environment array for execve
-std::pair<std::vector<std::string>, std::vector<char*>> 
-PrepareEnvironment(const std::map<std::string, std::string>& env_vars, 
-                   const std::string& additional_lib_path) {
-  
+std::pair<std::vector<std::string>, std::vector<char*>>
+PrepareEnvironment(
+    const std::map<std::string, std::string>& env_vars,
+    const std::string& additional_lib_path)
+{
   std::vector<std::string> env_strings;
   std::vector<char*> env_array;
-  
+
   for (const auto& [key, value] : env_vars) {
     std::string env_string;
     if (key == "LD_LIBRARY_PATH" && !additional_lib_path.empty()) {
@@ -448,13 +457,13 @@ PrepareEnvironment(const std::map<std::string, std::string>& env_vars,
     }
     env_strings.push_back(env_string);
   }
-  
+
   // Convert to char* array
   for (auto& env_str : env_strings) {
     env_array.push_back(const_cast<char*>(env_str.c_str()));
   }
   env_array.push_back(nullptr);
-  
+
   return std::make_pair(std::move(env_strings), std::move(env_array));
 }
 

src/pb_utils.h

@@ -363,10 +363,11 @@ std::shared_ptr<TRITONSERVER_Error*> WrapTritonErrorInSharedPtr(
 std::string GenerateUUID();
 
 // Environment handling utilities for Python activation scripts
-std::map<std::string, std::string> ParseActivationScript(const std::string& activate_path);
+std::map<std::string, std::string> ParseActivationScript(
+    const std::string& activate_path);
 
 std::pair<std::vector<std::string>, std::vector<char*>> PrepareEnvironment(
-    const std::map<std::string, std::string>& env_vars,  
+    const std::map<std::string, std::string>& env_vars,
     const std::string& additional_lib_path = "");
 
 }}}  // namespace triton::backend::python

src/stub_launcher.cc

@@ -28,14 +28,14 @@
 
 #include <filesystem>
 
-#include "python_be.h"
 #include "pb_utils.h"
+#include "python_be.h"
 
 #ifdef _WIN32
 #include <process.h>  // getpid()
 #endif
 
-extern char **environ;
+extern char** environ;
 
 namespace triton { namespace backend { namespace python {
 
@@ -345,13 +345,13 @@ StubLauncher::Launch()
         TRITONSERVER_ERROR_INVALID_ARG,
         "Invalid stub name: contains invalid characters");
   }
-  
+
   if (!IsValidPath(model_path_)) {
     return TRITONSERVER_ErrorNew(
         TRITONSERVER_ERROR_INVALID_ARG,
         "Invalid model path: contains invalid characters or not absolute");
   }
-  
+
   if (!IsValidIdentifier(shm_region_name_)) {
     return TRITONSERVER_ErrorNew(
         TRITONSERVER_ERROR_INVALID_ARG,
@@ -372,12 +372,12 @@ StubLauncher::Launch()
   // Validate the stub executable path
   if (!IsValidPath(python_backend_stub)) {
     return TRITONSERVER_ErrorNew(
-        TRITONSERVER_ERROR_INVALID_ARG,
-        "Invalid python backend stub path");
+        TRITONSERVER_ERROR_INVALID_ARG, "Invalid python backend stub path");
   }
 
   if (!IsExecutableFile(python_backend_stub)) {
-    // Give the execute permission for the triton_python_backend_stub to the owner.
+    // Give the execute permission for the triton_python_backend_stub to the
+    // owner.
     int error = chmod(python_backend_stub.c_str(), S_IXUSR);
     if (error != 0) {
       return TRITONSERVER_ErrorNew(
@@ -398,24 +398,24 @@ StubLauncher::Launch()
   // revert the LD_LIBRARY_PATH changes to avoid shared library issues in
   // executables and libraries.
   ipc_control_->uses_env = false;
-  
+
   if (python_execution_env_ != "") {
-    
     // Validate Python environment paths
     if (!IsValidPath(path_to_activate_) || !IsValidPath(path_to_libpython_)) {
       return TRITONSERVER_ErrorNew(
-          TRITONSERVER_ERROR_INVALID_ARG,
-          "Invalid Python environment paths");
+          TRITONSERVER_ERROR_INVALID_ARG, "Invalid Python environment paths");
     }
-    
+
     ipc_control_->uses_env = true;
-    
+
     // Parse environment variables from activation script
-    std::map<std::string, std::string> env_vars = ParseActivationScript(path_to_activate_);
-    
-    // Prepare environment with additional library path  
-    auto [env_strings, custom_env] = PrepareEnvironment(env_vars, path_to_libpython_);
-    
+    std::map<std::string, std::string> env_vars =
+        ParseActivationScript(path_to_activate_);
+
+    // Prepare environment with additional library path
+    auto [env_strings, custom_env] =
+        PrepareEnvironment(env_vars, path_to_libpython_);
+
     // Set up arguments for direct execution
     arg_strings.push_back(python_backend_stub);
     arg_strings.push_back(model_path_);
@@ -427,7 +427,7 @@ StubLauncher::Launch()
     arg_strings.push_back(std::to_string(ipc_control_handle_));
     arg_strings.push_back(stub_name);
     arg_strings.push_back(runtime_modeldir_);
-    
+
     // Convert strings to char* array for exec
     for (const auto& arg : arg_strings) {
       exec_args.push_back(arg.c_str());
@@ -437,12 +437,15 @@ StubLauncher::Launch()
     // Log the command being executed
     std::ostringstream log_cmd;
     for (size_t i = 0; i < arg_strings.size(); ++i) {
-      if (i > 0) log_cmd << " ";
+      if (i > 0)
+        log_cmd << " ";
       log_cmd << "'" << arg_strings[i] << "'";
     }
     LOG_MESSAGE(
         TRITONSERVER_LOG_VERBOSE,
-        (std::string("Starting Python backend stub with custom environment: ") + log_cmd.str()).c_str());
+        (std::string("Starting Python backend stub with custom environment: ") +
+         log_cmd.str())
+            .c_str());
 
     pid_t pid = fork();
     if (pid < 0) {
@@ -451,11 +454,16 @@ StubLauncher::Launch()
           "Failed to fork the stub process for auto-complete.");
     }
     if (pid == 0) {
-      // Replace this child process with the new stub process using custom environment
-      execve(python_backend_stub.c_str(), const_cast<char**>(exec_args.data()), custom_env.data());
+      // Replace this child process with the new stub process using custom
+      // environment
+      execve(
+          python_backend_stub.c_str(), const_cast<char**>(exec_args.data()),
+          custom_env.data());
       // execve() never returns if succeeded. Otherwise, an error has occurred.
       std::stringstream ss;
-      ss << "Failed to run python backend stub with custom environment. Errno = " << errno << '\n'
+      ss << "Failed to run python backend stub with custom environment. Errno "
+            "= "
+         << errno << '\n'
          << "Python backend stub path: " << python_backend_stub << '\n'
          << "Activation script: " << path_to_activate_ << '\n'
          << "Library path: " << path_to_libpython_ << '\n';
@@ -464,7 +472,7 @@ StubLauncher::Launch()
     } else {
       stub_pid_ = pid;
     }
-    
+
   } else {
     arg_strings.push_back(python_backend_stub);
     arg_strings.push_back(model_path_);
@@ -476,7 +484,7 @@ StubLauncher::Launch()
     arg_strings.push_back(std::to_string(ipc_control_handle_));
     arg_strings.push_back(stub_name);
     arg_strings.push_back(runtime_modeldir_);
-    
+
     // Convert strings to char* array for exec
     for (const auto& arg : arg_strings) {
       exec_args.push_back(arg.c_str());
@@ -486,12 +494,14 @@ StubLauncher::Launch()
     // Log the command being executed
     std::ostringstream log_cmd;
     for (size_t i = 0; i < arg_strings.size(); ++i) {
-      if (i > 0) log_cmd << " ";
+      if (i > 0)
+        log_cmd << " ";
       log_cmd << "'" << arg_strings[i] << "'";
     }
     LOG_MESSAGE(
         TRITONSERVER_LOG_VERBOSE,
-        (std::string("Starting Python backend stub: ") + log_cmd.str()).c_str());
+        (std::string("Starting Python backend stub: ") + log_cmd.str())
+            .c_str());
 
     pid_t pid = fork();
     if (pid < 0) {
@@ -974,6 +984,6 @@ StubLauncher::ShareCUDAMemoryPool(
   if (pb_exception.what() != std::string{""}) {
     throw pb_exception;
   }
-  }
-  #endif  // TRITON_ENABLE_GPU
+}
+#endif  // TRITON_ENABLE_GPU
 }}};    // namespace triton::backend::python