PY-52688 support pipenv for remote targets

GitOrigin-RevId: 497680bc7ae4fd820e7a8e77d677e24a4ec557d8

Author: alexkats

python/mcp/src/com/intellij/python/mcp/environment/PythonEnvironmentMcpToolset.kt

@@ -20,16 +20,15 @@ import com.intellij.python.hatch.impl.sdk.HatchSdkFlavor
 import com.intellij.python.pyproject.model.api.ModuleCreateInfo
 import com.intellij.python.pyproject.model.api.autoConfigureSdkIfNeeded
 import com.intellij.python.pyproject.model.api.getModuleInfo
-import com.jetbrains.python.hatch.sdk.HatchSdkAdditionalData
 import com.jetbrains.python.sdk.PythonEnvironment
 import com.jetbrains.python.sdk.configurePythonSdk
 import com.jetbrains.python.sdk.configuration.CreateSdkInfo
 import com.jetbrains.python.sdk.configuration.createSdk
 import com.jetbrains.python.sdk.findPythonSdk
+import com.jetbrains.python.sdk.pipenv.PyPipEnvSdkFlavor
 import com.jetbrains.python.sdk.poetry.PyPoetrySdkFlavor
 import com.jetbrains.python.sdk.pySdkAdditionalData
 import com.jetbrains.python.sdk.pythonInterpreterAsync
-import com.jetbrains.python.sdk.uv.UvSdkAdditionalData
 import com.jetbrains.python.sdk.uv.UvSdkFlavor
 import com.jetbrains.python.sdk.withSdkConfigurationLock
 import kotlinx.coroutines.currentCoroutineContext
@@ -108,7 +107,7 @@ class PythonEnvironmentMcpToolset : McpToolset {
   @McpDescription(
     """
     Configures a Python interpreter for the module containing the given file using PyCharm's own detection
-    (existing .venv folder, or a fresh uv/poetry/hatch venv when the corresponding tool is already installed).
+    (existing .venv folder, or a fresh uv/poetry/hatch/pipenv venv when the corresponding tool is already installed).
     Call this only after get_python_environment reported that no interpreter is configured.
     This tool does NOT install env-management tools like uv or poetry; if PyCharm needs one, the call fails
     with the missing tool name so the agent can install it manually first and retry.
@@ -224,6 +223,7 @@ class PythonEnvironmentMcpToolset : McpToolset {
     when (sdk.pySdkAdditionalData.flavor) {
         PyPoetrySdkFlavor -> "poetry"
         HatchSdkFlavor -> "hatch"
+        PyPipEnvSdkFlavor -> "pipenv"
         UvSdkFlavor -> "uv"
         else -> when (env) {
           is PythonEnvironment.Conda -> "conda"
@@ -242,7 +242,7 @@ class PythonEnvironmentMcpToolset : McpToolset {
     val executablePath: String? = null,
     @property:McpDescription("Root of the virtual environment (venv prefix or conda prefix); null for system Python or unconfigured")
     val environmentPath: String? = null,
-    @property:McpDescription("'pip', 'uv', 'poetry', 'hatch', 'conda', or 'unknown'; null when no interpreter is configured")
+    @property:McpDescription("'pip', 'uv', 'poetry', 'hatch', 'pipenv', 'conda', or 'unknown'; null when no interpreter is configured")
     val packageManager: String? = null,
     @property:McpDescription("When non-null, no interpreter is configured for this module. Describes the current state and what action to take next.")
     val noInterpreterConfigured: String? = null,

python/src/com/jetbrains/python/packaging/pipenv/PipEnvPackageManager.kt

@@ -15,24 +15,20 @@ import com.jetbrains.python.packaging.management.PythonPackageInstallRequest
 import com.jetbrains.python.packaging.management.PythonPackageManager
 import com.jetbrains.python.packaging.management.PythonRepositoryManager
 import com.jetbrains.python.packaging.pip.PipRepositoryManager
-import com.jetbrains.python.sdk.associatedModulePath
 import com.jetbrains.python.sdk.pipenv.PIP_FILE
-import com.jetbrains.python.sdk.pipenv.runPipEnv
+import com.jetbrains.python.sdk.pipenv.runPipEnvWithSdk
 import java.nio.file.Path
 import com.jetbrains.python.sdk.pipenv.PipEnvParser as SdkPipEnvParser
 
 internal class PipEnvPackageManager(project: Project, sdk: Sdk) : PythonPackageManager(project, sdk) {
-  private val modulePath: Path?
-    get() = sdk.associatedModulePath?.let { Path.of(it) }
-
   override val repositoryManager: PythonRepositoryManager = PipRepositoryManager.getInstance(project)
 
   override suspend fun syncLockedCommand(): PyResult<Unit> {
-    return runPipEnv(modulePath, "install", "--dev").mapSuccess { }
+    return runPipEnvWithSdk(sdk, "install", "--dev").mapSuccess { }
   }
 
   suspend fun lock(): PyResult<Unit> {
-    return runPipEnv(modulePath, "lock").mapSuccess { }
+    return runPipEnvWithSdk(sdk, "lock").mapSuccess { }
   }
 
   override suspend fun installPackageCommand(installRequest: PythonPackageInstallRequest, options: List<String>, module: Module?, dependencyGroup: PyDependencyGroup?): PyResult<Unit> {
@@ -41,24 +37,24 @@ internal class PipEnvPackageManager(project: Project, sdk: Sdk) : PythonPackageM
       is PythonPackageInstallRequest.ByRepositoryPythonPackageSpecifications -> {
 
         val args = listOf("install") + installRequest.specifications.map { it.nameWithVersionSpec } + options
-        runPipEnv(modulePath, *args.toTypedArray()).mapSuccess { }
+        runPipEnvWithSdk(sdk, *args.toTypedArray()).mapSuccess { }
       }
     }
   }
 
   override suspend fun updatePackageCommand(vararg specifications: PythonRepositoryPackageSpecification): PyResult<Unit> {
     val args = listOf("install") + specifications.map { it.nameWithVersionSpec }
-    return runPipEnv(modulePath, *args.toTypedArray()).mapSuccess { }
+    return runPipEnvWithSdk(sdk, *args.toTypedArray()).mapSuccess { }
   }
 
   override suspend fun uninstallPackageCommand(vararg pythonPackages: String, workspaceMember: PyWorkspaceMember?, dependencyGroup: PyDependencyGroup?): PyResult<Unit> {
     val args = listOf("uninstall") + pythonPackages.toList()
-    return runPipEnv(modulePath, *args.toTypedArray()).mapSuccess { }
+    return runPipEnvWithSdk(sdk, *args.toTypedArray()).mapSuccess { }
 
   }
 
   override suspend fun loadPackagesCommand(): PyResult<List<PythonPackage>> {
-    val output = runPipEnv(modulePath, "graph", "--json")
+    val output = runPipEnvWithSdk(sdk, "graph", "--json")
     output.getOr {
       return it
     }
@@ -72,7 +68,7 @@ internal class PipEnvPackageManager(project: Project, sdk: Sdk) : PythonPackageM
   }
 
   override suspend fun loadOutdatedPackagesCommand(): PyResult<List<PythonOutdatedPackage>> {
-    val output = runPipEnv(modulePath, "update", "--dry-run").getOr { return it }
+    val output = runPipEnvWithSdk(sdk, "update", "--dry-run").getOr { return it }
     val outdated = PipEnvParser.parseOutdatedPackagesOutput(output)
 
     return PyResult.success(outdated)
@@ -87,4 +83,4 @@ internal class PipEnvPackageManager(project: Project, sdk: Sdk) : PythonPackageM
   override val dependenciesFilesRelativePaths: List<Path>
     get() =
       listOf(Path.of(PIP_FILE))
-}
+}

python/src/com/jetbrains/python/sdk/add/v2/common.kt

@@ -146,7 +146,7 @@ enum class PythonSupportedEnvironmentManagers(
   VIRTUALENV(VENV_TOOL_ID, "sdk.create.custom.virtualenv", PythonVenvIcons.VirtualEnv, sshAutoUploadRequired = false, { true }),
   CONDA(CONDA_TOOL_ID, "sdk.create.custom.conda", PythonCommunityImplCondaIcons.Anaconda, sshAutoUploadRequired = false, { true }),
   POETRY(POETRY_TOOL_ID, "sdk.create.custom.poetry", PythonCommunityImplPoetryCommonIcons.Poetry, sshAutoUploadRequired = true, { true }),
-  PIPENV(PIPENV_TOOL_ID, "sdk.create.custom.pipenv", PythonCommunityImplPipenvIcons.PythonClosed, sshAutoUploadRequired = false),
+  PIPENV(PIPENV_TOOL_ID, "sdk.create.custom.pipenv", PythonCommunityImplPipenvIcons.PythonClosed, sshAutoUploadRequired = true, { true }),
   UV(UV_TOOL_ID, "sdk.create.custom.uv", PythonUvCommonIcons.UV, sshAutoUploadRequired = true, { true }),
   HATCH(HATCH_TOOL_ID, "sdk.create.custom.hatch", PythonHatchIcons.Logo, sshAutoUploadRequired = true, { true }),
   PYTHON(VENV_TOOL_ID, "sdk.create.custom.python", PythonParserIcons.PythonFile, sshAutoUploadRequired = false, { true })

python/src/com/jetbrains/python/sdk/add/v2/pipenv/EnvironmentCreatorPip.kt

@@ -8,7 +8,6 @@ import com.intellij.python.community.impl.pipenv.PipEnvPyTool
 import com.intellij.python.community.impl.pipenv.pipenvPath
 import com.intellij.python.pytools.PyTool
 import com.intellij.platform.util.progress.withProgressText
-import com.jetbrains.python.PyBundle
 import com.jetbrains.python.PyBundle.message
 import com.jetbrains.python.errorProcessing.ErrorSink
 import com.jetbrains.python.errorProcessing.PyResult
@@ -34,16 +33,19 @@ internal class EnvironmentCreatorPip<P : PathHolder>(model: PythonMutableTargetA
 
   override suspend fun setupEnvSdk(moduleBasePath: Path): PyResult<Sdk> {
     val basePythonBinaryPath = model.getOrInstallBasePython()
+                               ?: return PyResult.localizedError(message("python.sdk.provided.path.is.invalid", null))
+    val pipenvExecutable = model.pipenvViewModel.pipenvExecutable.get()?.pathHolder
+                           ?: return PyResult.localizedError(message("python.sdk.provided.path.is.invalid", null))
 
-    return when (basePythonBinaryPath) {
-      is PathHolder.Eel -> withProgressText(message("python.sdk.progress.pipenv.creating")) {
-        setupPipEnvSdkWithProgressReport(
-          moduleBasePath = moduleBasePath,
-          basePythonBinaryPath = basePythonBinaryPath.path,
-          installPackages = false
-        )
-      }
-      else -> PyResult.localizedError(message("target.is.not.supported", basePythonBinaryPath))
+    return withProgressText(message("python.sdk.progress.pipenv.creating")) {
+      setupPipEnvSdkWithProgressReport(
+        moduleBasePath = moduleBasePath,
+        basePythonBinaryPath = basePythonBinaryPath,
+        fileSystem = model.fileSystem,
+        pipenvExecutable = pipenvExecutable,
+        installPackages = false,
+        targetPanelExtension = model.state.targetPanelExtension.get(),
+      )
     }
   }
 }

python/src/com/jetbrains/python/sdk/pipenv/PipEnvPipFileWatcher.kt

@@ -25,15 +25,13 @@ import com.jetbrains.python.errorProcessing.emit
 import com.jetbrains.python.onFailure
 import com.jetbrains.python.packaging.utils.PyPackageCoroutine
 import com.jetbrains.python.sdk.associatedModuleDir
-import com.jetbrains.python.sdk.associatedModulePath
 import com.jetbrains.python.sdk.findAmongRoots
 import com.jetbrains.python.sdk.pythonSdk
 import com.jetbrains.python.sdk.skeleton.PySkeletonUtil
 import com.jetbrains.python.statistics.PipfileWatcherIdsHolder.Companion.RUN_PIPENV_LOCK_SUGGESTION
 import com.jetbrains.python.errorProcessing.ErrorSink
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
-import java.nio.file.Path
 
 /**
  * Watches for edits in Pipfiles inside modules with a pipenv SDK set.
@@ -114,7 +112,7 @@ internal class PipEnvPipFileWatcher : EditorFactoryListener {
     PyPackageCoroutine.launch(module.project) {
       withBackgroundProgress(module.project, description) {
         val sdk = module.pythonSdk ?: return@withBackgroundProgress
-        runPipEnv(sdk.associatedModulePath?.let { Path.of(it) }, *args.toTypedArray()).onFailure {
+        runPipEnvWithSdk(sdk, *args.toTypedArray()).onFailure {
           ErrorSink().emit(it, module.project)
         }
 
@@ -139,4 +137,4 @@ internal class PipEnvPipFileWatcher : EditorFactoryListener {
     get() = FileDocumentManager.getInstance().getFile(this)
 
   private fun VirtualFile.getModule(project: Project): Module? = ModuleUtil.findModuleForFile(this, project)
-}
+}