PY-44016 Introduce HelpersAwareTargetEnvironmentRequest and rewrite PythonScripts.kt accordingly

GitOrigin-RevId: b3d1a3a8b5600134eefb3ff4cca729a6100545b1
2026-01-08 15:09:39 +07:00 · 2021-02-07 00:41:06 +03:00
parent 2982b53431
commit d2f15b6adc
12 changed files with 132 additions and 78 deletions
--- a/python/python-rest/src/com/jetbrains/rest/run/RestCommandLineState.java
+++ b/python/python-rest/src/com/jetbrains/rest/run/RestCommandLineState.java
@@ -9,13 +9,13 @@ import com.intellij.execution.process.ProcessAdapter;
 import com.intellij.execution.process.ProcessEvent;
 import com.intellij.execution.process.ProcessHandler;
 import com.intellij.execution.runners.ExecutionEnvironment;
-import com.intellij.execution.target.TargetEnvironmentRequest;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.openapi.vfs.LocalFileSystem;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.jetbrains.python.HelperPackage;
 import com.jetbrains.python.run.*;
+import com.jetbrains.python.run.target.HelpersAwareTargetEnvironmentRequest;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;

@@ -64,8 +64,8 @@ public abstract class RestCommandLineState extends PythonCommandLineState {
  }

  @Override
-  protected @NotNull PythonExecution buildPythonExecution(@NotNull TargetEnvironmentRequest targetEnvironmentRequest) {
-    PythonScriptExecution pythonScriptExecution = PythonScripts.prepareHelperScriptExecution(getRunner(), targetEnvironmentRequest);
+  protected @NotNull PythonExecution buildPythonExecution(@NotNull HelpersAwareTargetEnvironmentRequest helpersAwareRequest) {
+    PythonScriptExecution pythonScriptExecution = PythonScripts.prepareHelperScriptExecution(getRunner(), helpersAwareRequest);
    final String key = getKey();
    if (key != null) pythonScriptExecution.addParameter(key);
    pythonScriptExecution.addParameter(getTask());
--- a/python/src/com/jetbrains/python/console/PydevConsoleCli.kt
+++ b/python/src/com/jetbrains/python/console/PydevConsoleCli.kt
@@ -7,7 +7,7 @@ import com.intellij.execution.ExecutionException
 import com.intellij.execution.configurations.GeneralCommandLine
 import com.intellij.execution.configurations.ParamsGroup
 import com.intellij.execution.target.HostPort
-import com.intellij.execution.target.TargetEnvironmentRequest
+import com.intellij.execution.target.TargetEnvironment
 import com.intellij.execution.target.value.TargetEnvironmentFunction
 import com.intellij.openapi.projectRoots.Sdk
 import com.intellij.openapi.projectRoots.SdkAdditionalData
@@ -15,10 +15,12 @@ import com.jetbrains.python.PythonHelper
 import com.jetbrains.python.run.PythonCommandLineState
 import com.jetbrains.python.run.PythonExecution
 import com.jetbrains.python.run.prepareHelperScriptExecution
+import com.jetbrains.python.run.target.HelpersAwareTargetEnvironmentRequest
 import com.jetbrains.python.sdk.PythonEnvUtil
 import com.jetbrains.python.sdk.PythonSdkAdditionalData
 import com.jetbrains.python.sdk.flavors.PythonSdkFlavor
 import java.io.File
+import java.util.function.Function

 const val MODE_OPTION = "mode"
 const val MODE_OPTION_SERVER_VALUE = "server"
@@ -116,8 +118,9 @@ fun waitForPythonConsoleServerToBeStarted(process: Process) {
  PydevConsoleRunnerImpl.getRemotePortFromProcess(process)
 }

-fun createPythonConsoleScriptInServerMode(serverPort: Int, targetEnvironmentRequest: TargetEnvironmentRequest): PythonExecution {
-  val pythonScriptExecution = prepareHelperScriptExecution(PythonHelper.CONSOLE, targetEnvironmentRequest)
+fun createPythonConsoleScriptInServerMode(serverPort: Int,
+                                          helpersAwareTargetRequest: HelpersAwareTargetEnvironmentRequest): PythonExecution {
+  val pythonScriptExecution = prepareHelperScriptExecution(PythonHelper.CONSOLE, helpersAwareTargetRequest)
  pythonScriptExecution.addParameter(getOptionString(MODE_OPTION, MODE_OPTION_SERVER_VALUE))
  pythonScriptExecution.addParameter(getOptionString(PORT_OPTION, serverPort))
  return pythonScriptExecution
@@ -127,9 +130,9 @@ fun createPythonConsoleScriptInServerMode(serverPort: Int, targetEnvironmentRequ
 * @param ideServerPort           the host and port where the IDE being Python
 *                                Console frontend listens for the connection
 */
-fun createPythonConsoleScriptInClientMode(ideServerPort: TargetEnvironmentFunction<HostPort>,
-                                          targetEnvironmentRequest: TargetEnvironmentRequest): PythonExecution {
-  val pythonScriptExecution = prepareHelperScriptExecution(PythonHelper.CONSOLE, targetEnvironmentRequest)
+fun createPythonConsoleScriptInClientMode(ideServerPort: Function<TargetEnvironment, HostPort>,
+                                          helpersAwareTargetRequest: HelpersAwareTargetEnvironmentRequest): PythonExecution {
+  val pythonScriptExecution = prepareHelperScriptExecution(PythonHelper.CONSOLE, helpersAwareTargetRequest)
  pythonScriptExecution.addParameter(getOptionString(MODE_OPTION, MODE_OPTION_CLIENT_VALUE))
  pythonScriptExecution.addParameter(getOptionString(HOST_OPTION, ideServerPort.andThen(HostPort::host)))
  pythonScriptExecution.addParameter(getOptionString(PORT_OPTION, ideServerPort.andThen(HostPort::port)))
--- a/python/src/com/jetbrains/python/console/PydevConsoleRunnerImpl.java
+++ b/python/src/com/jetbrains/python/console/PydevConsoleRunnerImpl.java
@@ -86,6 +86,7 @@ import com.jetbrains.python.remote.PyRemoteSdkAdditionalDataBase;
 import com.jetbrains.python.remote.PyRemoteSocketToLocalHostProvider;
 import com.jetbrains.python.remote.PythonRemoteInterpreterManager;
 import com.jetbrains.python.run.*;
+import com.jetbrains.python.run.target.HelpersAwareTargetEnvironmentRequest;
 import com.jetbrains.python.sdk.PythonSdkUtil;
 import com.jetbrains.python.sdk.flavors.PythonSdkFlavor;
 import icons.PythonIcons;
@@ -362,8 +363,8 @@ public class PydevConsoleRunnerImpl implements PydevConsoleRunner {
  @NotNull
  private PythonExecution createPythonConsoleExecution(@NotNull Function<TargetEnvironment, HostPort> ideServerPort,
                                                       @NotNull PythonConsoleRunParams runParams,
-                                                       @NotNull TargetEnvironmentRequest targetEnvironmentRequest) {
-    return doCreatePythonConsoleExecution(ideServerPort, runParams, targetEnvironmentRequest);
+                                                       @NotNull HelpersAwareTargetEnvironmentRequest helpersAwareTargetRequest) {
+    return doCreatePythonConsoleExecution(ideServerPort, runParams, helpersAwareTargetRequest);
  }

  @NotNull
@@ -407,9 +408,11 @@ public class PydevConsoleRunnerImpl implements PydevConsoleRunner {
  @NotNull
  private PythonExecution doCreatePythonConsoleExecution(@NotNull Function<TargetEnvironment, HostPort> ideServerPort,
                                                         @NotNull PythonConsoleRunParams runParams,
-                                                         @NotNull TargetEnvironmentRequest targetEnvironmentRequest) {
+                                                         @NotNull HelpersAwareTargetEnvironmentRequest helpersAwareTargetRequest) {
    PythonExecution pythonConsoleScriptExecution =
-      PydevConsoleCli.createPythonConsoleScriptInClientMode(ideServerPort, targetEnvironmentRequest);
+      PydevConsoleCli.createPythonConsoleScriptInClientMode(ideServerPort, helpersAwareTargetRequest);
+
+    TargetEnvironmentRequest targetEnvironmentRequest = helpersAwareTargetRequest.getTargetEnvironmentRequest();

    PyRemoteSdkAdditionalDataBase remoteSdkAdditionalData = getRemoteAdditionalData(mySdk);
    if (remoteSdkAdditionalData != null) {
@@ -501,7 +504,8 @@ public class PydevConsoleRunnerImpl implements PydevConsoleRunner {
      throw new ExecutionException(e);
    }

-    TargetEnvironmentRequest targetEnvironmentRequest = createTargetEnvironmentRequest(sdk);
+    HelpersAwareTargetEnvironmentRequest helpersAwareRequest = PythonCommandLineState.getPythonTargetInterpreter(myProject, sdk);
+    TargetEnvironmentRequest targetEnvironmentRequest = helpersAwareRequest.getTargetEnvironmentRequest();
    TargetEnvironment.LocalPortBinding ideServerPortBinding = new TargetEnvironment.LocalPortBinding(ideServerPort, null);
    targetEnvironmentRequest.getLocalPortBindings().add(ideServerPortBinding);
    Function<TargetEnvironment, HostPort> ideServerHostPortOnTarget = targetEnvironment -> {
@@ -524,7 +528,7 @@ public class PydevConsoleRunnerImpl implements PydevConsoleRunner {
    }

    PythonConsoleRunParams runParams = createConsoleRunParams(myWorkingDir, sdk, myEnvironmentVariables);
-    PythonExecution pythonConsoleExecution = createPythonConsoleExecution(ideServerHostPortOnTarget, runParams, targetEnvironmentRequest);
+    PythonExecution pythonConsoleExecution = createPythonConsoleExecution(ideServerHostPortOnTarget, runParams, helpersAwareRequest);
    List<String> interpreterOptions;
    if (!StringUtil.isEmptyOrSpaces(runParams.getInterpreterOptions())) {
      interpreterOptions = ParametersListUtil.parse(runParams.getInterpreterOptions());
@@ -590,21 +594,6 @@ public class PydevConsoleRunnerImpl implements PydevConsoleRunner {
    }
  }

-  /**
-   * @throws IllegalStateException if there is no extension point registered
-   *                               for the type of Python interpreter of the
-   *                               provided SDK
-   * @see PythonInterpreterTargetEnvironmentFactory
-   */
-  @NotNull
-  private static TargetEnvironmentRequest createTargetEnvironmentRequest(@NotNull Sdk sdk) {
-    TargetEnvironmentRequest environmentRequest = PythonInterpreterTargetEnvironmentFactory.findTargetEnvironmentRequest(sdk);
-    if (environmentRequest == null) {
-      throw new IllegalStateException("Cannot find execution environment for SDK " + sdk);
-    }
-    return environmentRequest;
-  }
-
  @Contract("null -> null")
  @Nullable
  private static PyRemoteSdkAdditionalDataBase getRemoteAdditionalData(@Nullable Sdk sdk) {
--- a/python/src/com/jetbrains/python/debugger/PyDebugRunner.java
+++ b/python/src/com/jetbrains/python/debugger/PyDebugRunner.java
@@ -43,6 +43,7 @@ import com.jetbrains.python.console.pydev.ConsoleCommunicationListener;
 import com.jetbrains.python.debugger.settings.PyDebuggerSettings;
 import com.jetbrains.python.psi.LanguageLevel;
 import com.jetbrains.python.run.*;
+import com.jetbrains.python.run.target.HelpersAwareTargetEnvironmentRequest;
 import com.jetbrains.python.sdk.flavors.PythonSdkFlavor;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NonNls;
@@ -127,7 +128,8 @@ public class PyDebugRunner implements ProgramRunner<RunnerSettings> {
  }

  @NotNull
-  private Promise<XDebugSession> createSessionUsingTargetsApi(@NotNull RunProfileState state, @NotNull final ExecutionEnvironment environment) {
+  private Promise<XDebugSession> createSessionUsingTargetsApi(@NotNull RunProfileState state,
+                                                              @NotNull final ExecutionEnvironment environment) {
    PythonCommandLineState pyState = (PythonCommandLineState)state;
    RunProfile profile = environment.getRunProfile();
    return Promises
@@ -152,8 +154,8 @@ public class PyDebugRunner implements ProgramRunner<RunnerSettings> {
  }

  private @NotNull XDebugSession createXDebugSession(@NotNull ExecutionEnvironment environment,
-                                                              PythonCommandLineState pyState,
-                                                              ServerSocket serverSocket, ExecutionResult result) throws ExecutionException {
+                                                     PythonCommandLineState pyState,
+                                                     ServerSocket serverSocket, ExecutionResult result) throws ExecutionException {
    return XDebuggerManager.getInstance(environment.getProject()).
      startSession(environment, new XDebugProcessStarter() {
        @Override
@@ -474,9 +476,10 @@ public class PyDebugRunner implements ProgramRunner<RunnerSettings> {
                                                                        @NotNull PythonCommandLineState pyState,
                                                                        @NotNull PythonExecution originalPythonScript,
                                                                        @Nullable RunProfile runProfile,
-                                                                        @NotNull TargetEnvironmentRequest targetEnvironmentRequest) {
-    PythonScriptExecution debuggerScript = PythonScripts.prepareHelperScriptExecution(PythonHelper.DEBUGGER, targetEnvironmentRequest);
+                                                                        @NotNull HelpersAwareTargetEnvironmentRequest request) {
+    PythonScriptExecution debuggerScript = PythonScripts.prepareHelperScriptExecution(PythonHelper.DEBUGGER, request);

+    TargetEnvironmentRequest targetEnvironmentRequest = request.getTargetEnvironmentRequest();
    PythonScripts.extendEnvs(debuggerScript, originalPythonScript.getEnvs(), targetEnvironmentRequest.getTargetPlatform());

    debuggerScript.setWorkingDir(originalPythonScript.getWorkingDir());
@@ -753,15 +756,17 @@ public class PyDebugRunner implements ProgramRunner<RunnerSettings> {

    @NotNull
    @Override
-    public PythonExecution build(@NotNull TargetEnvironmentRequest targetEnvironmentRequest, @NotNull PythonExecution pythonScript) {
+    public PythonExecution build(@NotNull HelpersAwareTargetEnvironmentRequest helpersAwareTargetRequest,
+                                 @NotNull PythonExecution pythonScript) {
      TargetEnvironment.LocalPortBinding ideServerPortBinding = new TargetEnvironment.LocalPortBinding(myIdeDebugServerLocalPort, null);
-      targetEnvironmentRequest.getLocalPortBindings().add(ideServerPortBinding);
+      helpersAwareTargetRequest.getTargetEnvironmentRequest().getLocalPortBindings().add(ideServerPortBinding);

      Function<TargetEnvironment, HostPort> ideServerPortBindingValue =
        TargetEnvironmentFunctions.getTargetEnvironmentValue(ideServerPortBinding);

      PythonScriptExecution debuggerScript =
-        prepareDebuggerScriptExecution(myProject, ideServerPortBindingValue, myPyState, pythonScript, myProfile, targetEnvironmentRequest);
+        prepareDebuggerScriptExecution(myProject, ideServerPortBindingValue, myPyState, pythonScript, myProfile,
+                                       helpersAwareTargetRequest);

      // TODO [Targets API] We loose interpreter parameters here :(

--- a/python/src/com/jetbrains/python/run/PythonCommandLineState.java
+++ b/python/src/com/jetbrains/python/run/PythonCommandLineState.java
@@ -18,7 +18,10 @@ import com.intellij.execution.process.ProcessHandler;
 import com.intellij.execution.process.ProcessTerminatedListener;
 import com.intellij.execution.runners.ExecutionEnvironment;
 import com.intellij.execution.runners.ProgramRunner;
-import com.intellij.execution.target.*;
+import com.intellij.execution.target.TargetEnvironment;
+import com.intellij.execution.target.TargetEnvironmentRequest;
+import com.intellij.execution.target.TargetProgressIndicator;
+import com.intellij.execution.target.TargetedCommandLine;
 import com.intellij.execution.target.value.TargetEnvironmentFunctions;
 import com.intellij.execution.ui.ConsoleView;
 import com.intellij.facet.Facet;
@@ -59,6 +62,7 @@ import com.jetbrains.python.facet.PythonPathContributingFacet;
 import com.jetbrains.python.library.PythonLibraryType;
 import com.jetbrains.python.remote.PyRemotePathMapper;
 import com.jetbrains.python.run.target.PySdkTargetPaths;
+import com.jetbrains.python.run.target.HelpersAwareTargetEnvironmentRequest;
 import com.jetbrains.python.sdk.PySdkUtil;
 import com.jetbrains.python.sdk.PythonEnvUtil;
 import com.jetbrains.python.sdk.PythonSdkAdditionalData;
@@ -292,26 +296,27 @@ public abstract class PythonCommandLineState extends CommandLineState {
  @NotNull
  protected ProcessHandler startProcess(@NotNull PythonScriptTargetedCommandLineBuilder builder)
    throws ExecutionException {
-    TargetEnvironmentRequest targetEnvironmentRequest = createTargetEnvironmentRequest();
+    HelpersAwareTargetEnvironmentRequest helpersAwareTargetRequest = getPythonTargetInterpreter();

    Sdk sdk = getSdk();
    if (sdk != null) {
      PythonRunConfigurationTargetEnvironmentAdjuster adjuster =
        PythonRunConfigurationTargetEnvironmentAdjuster.findTargetEnvironmentRequestAdjuster(sdk);
      if (adjuster != null) {
-        adjuster.adjust(targetEnvironmentRequest, myConfig);
+        adjuster.adjust(helpersAwareTargetRequest.getTargetEnvironmentRequest(), myConfig);
      }
    }

    // The original Python script to be executed
-    PythonExecution pythonScript = buildPythonExecutionFinal(targetEnvironmentRequest);
+    PythonExecution pythonScript = buildPythonExecutionFinal(helpersAwareTargetRequest);

    // Python script that may be the debugger script that runs the original script
-    PythonExecution realPythonExecution = builder.build(targetEnvironmentRequest, pythonScript);
+    PythonExecution realPythonExecution = builder.build(helpersAwareTargetRequest, pythonScript);

    // TODO [Targets API] [major] Meaningful progress indicator should be taken
    EmptyProgressIndicator progressIndicator = new EmptyProgressIndicator();
-    TargetEnvironment targetEnvironment = targetEnvironmentRequest.prepareEnvironment(TargetProgressIndicator.EMPTY);
+    TargetEnvironment targetEnvironment =
+      helpersAwareTargetRequest.getTargetEnvironmentRequest().prepareEnvironment(TargetProgressIndicator.EMPTY);

    List<String> interpreterParameters = getConfiguredInterpreterParameters();
    TargetedCommandLine targetedCommandLine =
@@ -328,8 +333,9 @@ public abstract class PythonCommandLineState extends CommandLineState {
  }

  @NotNull
-  private PythonExecution buildPythonExecutionFinal(@NotNull TargetEnvironmentRequest targetEnvironmentRequest) {
-    PythonExecution pythonExecution = buildPythonExecution(targetEnvironmentRequest);
+  private PythonExecution buildPythonExecutionFinal(HelpersAwareTargetEnvironmentRequest helpersAwareTargetRequest) {
+    TargetEnvironmentRequest targetEnvironmentRequest = helpersAwareTargetRequest.getTargetEnvironmentRequest();
+    PythonExecution pythonExecution = buildPythonExecution(helpersAwareTargetRequest);
    pythonExecution.setWorkingDir(getPythonExecutionWorkingDir(targetEnvironmentRequest));
    initEnvironment(myConfig.getProject(), pythonExecution, myConfig, createRemotePathMapper(), isDebug(), targetEnvironmentRequest);
    customizePythonExecutionEnvironmentVars(targetEnvironmentRequest, pythonExecution.getEnvs(), myConfig.isPassParentEnvs());
@@ -484,11 +490,11 @@ public abstract class PythonCommandLineState extends CommandLineState {
   * User volumes (including the volumes for project files) are expected to be
   * already requested.
   *
-   * @param targetEnvironment
+   * @param helpersAwareRequest the request
   * @return the representation of Python script or module execution
   */
  @NotNull
-  protected PythonExecution buildPythonExecution(@NotNull TargetEnvironmentRequest targetEnvironmentRequest) {
+  protected PythonExecution buildPythonExecution(@NotNull HelpersAwareTargetEnvironmentRequest helpersAwareRequest) {
    throw new UnsupportedOperationException("The implementation of Run Configuration based on Targets API is absent");
  }

@@ -946,17 +952,22 @@ public abstract class PythonCommandLineState extends CommandLineState {
  }

  @NotNull
-  private TargetEnvironmentRequest createTargetEnvironmentRequest() {
-    Sdk sdk = getSdk();
+  private HelpersAwareTargetEnvironmentRequest getPythonTargetInterpreter() {
+    return getPythonTargetInterpreter(myConfig.getProject(), getSdk());
+  }
+
+  @NotNull
+  public static HelpersAwareTargetEnvironmentRequest getPythonTargetInterpreter(@NotNull Project project, @Nullable Sdk sdk) {
    if (sdk == null) {
      throw new IllegalStateException("SDK is not defined for Run Configuration");
    }
    else {
-      TargetEnvironmentRequest environmentRequest = PythonInterpreterTargetEnvironmentFactory.findTargetEnvironmentRequest(sdk);
-      if (environmentRequest == null) {
+      HelpersAwareTargetEnvironmentRequest helpersAwareTargetRequest =
+        PythonInterpreterTargetEnvironmentFactory.findPythonTargetInterpreter(sdk, project);
+      if (helpersAwareTargetRequest == null) {
        throw new IllegalStateException("Cannot find execution environment for SDK " + sdk);
      }
-      return environmentRequest;
+      return helpersAwareTargetRequest;
    }
  }

--- a/python/src/com/jetbrains/python/run/PythonInterpreterTargetEnvironmentFactory.kt
+++ b/python/src/com/jetbrains/python/run/PythonInterpreterTargetEnvironmentFactory.kt
@@ -1,26 +1,30 @@
 // Copyright 2000-2021 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
 package com.jetbrains.python.run

-import com.intellij.execution.target.TargetEnvironmentRequest
-import com.intellij.execution.target.local.LocalTargetEnvironmentRequest
+import com.intellij.execution.target.TargetEnvironmentType
 import com.intellij.openapi.extensions.ExtensionPointName
+import com.intellij.openapi.project.Project
 import com.intellij.openapi.projectRoots.Sdk
 import com.jetbrains.python.remote.PyRemoteSdkAdditionalDataBase
+import com.jetbrains.python.run.target.HelpersAwareLocalTargetEnvironmentRequest
+import com.jetbrains.python.run.target.HelpersAwareTargetEnvironmentRequest
 import org.jetbrains.annotations.ApiStatus

@ApiStatus.Experimental
 interface PythonInterpreterTargetEnvironmentFactory {
-  fun getTargetEnvironmentRequest(sdk: Sdk): TargetEnvironmentRequest?
+  fun getPythonTargetInterpreter(sdk: Sdk, project: Project): HelpersAwareTargetEnvironmentRequest?
+
+  fun getTargetType(): TargetEnvironmentType<*>

  companion object {
    @JvmStatic
    val EP_NAME = ExtensionPointName<PythonInterpreterTargetEnvironmentFactory>("Pythonid.interpreterTargetEnvironmentFactory")

    @JvmStatic
-    fun findTargetEnvironmentRequest(sdk: Sdk): TargetEnvironmentRequest? {
-      if (sdk.sdkAdditionalData !is PyRemoteSdkAdditionalDataBase) return LocalTargetEnvironmentRequest()
-
-      return EP_NAME.extensionList.mapNotNull { it.getTargetEnvironmentRequest(sdk) }.firstOrNull()
-    }
+    fun findPythonTargetInterpreter(sdk: Sdk, project: Project): HelpersAwareTargetEnvironmentRequest? =
+      when (sdk.sdkAdditionalData) {
+        is PyRemoteSdkAdditionalDataBase -> EP_NAME.extensionList.mapNotNull { it.getPythonTargetInterpreter(sdk, project) }.firstOrNull()
+        else -> HelpersAwareLocalTargetEnvironmentRequest
+      }
  }
 }
--- a/python/src/com/jetbrains/python/run/PythonScriptCommandLineState.java
+++ b/python/src/com/jetbrains/python/run/PythonScriptCommandLineState.java
@@ -41,7 +41,7 @@ import com.jetbrains.python.actions.PyExecuteInConsole;
 import com.jetbrains.python.actions.PyRunFileInConsoleAction;
 import com.jetbrains.python.console.PyConsoleOptions;
 import com.jetbrains.python.console.PydevConsoleRunner;
-import com.jetbrains.python.remote.PyRemotePathMapper;
+import com.jetbrains.python.run.target.HelpersAwareTargetEnvironmentRequest;
 import com.jetbrains.python.run.target.PySdkTargetPaths;
 import com.jetbrains.python.sdk.PythonEnvUtil;
 import com.jetbrains.python.sdk.PythonSdkUtil;
@@ -220,7 +220,8 @@ public class PythonScriptCommandLineState extends PythonCommandLineState {
  }

  @Override
-  protected @NotNull PythonExecution buildPythonExecution(@NotNull TargetEnvironmentRequest targetEnvironmentRequest) {
+  protected @NotNull PythonExecution buildPythonExecution(@NotNull HelpersAwareTargetEnvironmentRequest helpersAwareRequest) {
+    TargetEnvironmentRequest targetEnvironmentRequest = helpersAwareRequest.getTargetEnvironmentRequest();
    PythonExecution pythonExecution;
    if (myConfig.isModuleMode()) {
      PythonModuleExecution moduleExecution = new PythonModuleExecution();
--- a/python/src/com/jetbrains/python/run/PythonScriptTargetedCommandLineBuilder.kt
+++ b/python/src/com/jetbrains/python/run/PythonScriptTargetedCommandLineBuilder.kt
@@ -1,7 +1,7 @@
 // Copyright 2000-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
 package com.jetbrains.python.run

-import com.intellij.execution.target.TargetEnvironmentRequest
+import com.jetbrains.python.run.target.HelpersAwareTargetEnvironmentRequest
 import org.jetbrains.annotations.ApiStatus

@ApiStatus.Experimental
@@ -10,5 +10,5 @@ interface PythonScriptTargetedCommandLineBuilder {
   * Takes [pythonScript] and modifies it along with [targetEnvironmentRequest]
   * for specific execution strategy (e.g. debugging, profiling, etc).
   */
-  fun build(targetEnvironmentRequest: TargetEnvironmentRequest, pythonScript: PythonExecution): PythonExecution
+  fun build(helpersAwareTargetRequest: HelpersAwareTargetEnvironmentRequest, pythonScript: PythonExecution): PythonExecution
 }
--- a/python/src/com/jetbrains/python/run/PythonScripts.kt
+++ b/python/src/com/jetbrains/python/run/PythonScripts.kt
@@ -1,17 +1,25 @@
 // Copyright 2000-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
@file:JvmName("PythonScripts")
+
 package com.jetbrains.python.run

 import com.intellij.execution.Platform
 import com.intellij.execution.configurations.ParametersList
-import com.intellij.execution.target.*
-import com.intellij.execution.target.value.*
+import com.intellij.execution.target.TargetEnvironment
+import com.intellij.execution.target.TargetPlatform
+import com.intellij.execution.target.TargetedCommandLine
+import com.intellij.execution.target.TargetedCommandLineBuilder
+import com.intellij.execution.target.value.TargetEnvironmentFunction
+import com.intellij.execution.target.value.TargetValue
+import com.intellij.execution.target.value.getRelativeTargetPath
+import com.intellij.execution.target.value.joinToStringFunction
 import com.intellij.openapi.diagnostic.Logger
 import com.intellij.openapi.projectRoots.Sdk
 import com.intellij.openapi.util.io.FileUtil
 import com.jetbrains.python.HelperPackage
 import com.jetbrains.python.PythonHelpersLocator
 import com.jetbrains.python.remote.PyRemoteSdkAdditionalDataBase
+import com.jetbrains.python.run.target.HelpersAwareTargetEnvironmentRequest
 import com.jetbrains.python.sdk.PythonSdkType

 private val LOG = Logger.getInstance("#com.jetbrains.python.run.PythonScripts")
@@ -78,9 +86,10 @@ private fun resolveUploadPath(localPath: String, uploads: Iterable<Upload>): Tar
  return upload.targetPath.getRelativeTargetPath(localRelativePath)
 }

-fun prepareHelperScriptExecution(helperPackage: HelperPackage, targetEnvironmentRequest: TargetEnvironmentRequest): PythonScriptExecution =
+fun prepareHelperScriptExecution(helperPackage: HelperPackage,
+                                 helpersAwareTargetRequest: HelpersAwareTargetEnvironmentRequest): PythonScriptExecution =
  PythonScriptExecution().apply {
-    val uploads = applyHelperPackageToPythonPath(helperPackage, targetEnvironmentRequest)
+    val uploads = applyHelperPackageToPythonPath(helperPackage, helpersAwareTargetRequest)
    pythonScriptPath = resolveUploadPath(helperPackage.asParamString(), uploads)
  }

@@ -90,14 +99,10 @@ private const val PYTHONPATH_ENV = "PYTHONPATH"
 * Requests the upload of PyCharm helpers root directory to the target.
 */
 fun PythonExecution.applyHelperPackageToPythonPath(helperPackage: HelperPackage,
-                                                   targetEnvironmentRequest: TargetEnvironmentRequest): Iterable<Upload> {
-  // TODO [Targets API] Helpers scripts should be synchronized by the version of the IDE
+                                                   helpersAwareTargetRequest: HelpersAwareTargetEnvironmentRequest): Iterable<Upload> {
  val localHelpersRootPath = PythonHelpersLocator.getHelpersRoot().absolutePath
-  val uploadRoot = TargetEnvironment.UploadRoot(localRootPath = PythonHelpersLocator.getHelpersRoot().toPath(),
-                                                targetRootPath = TargetEnvironment.TargetPath.Temporary())
-  targetEnvironmentRequest.uploadVolumes += uploadRoot
-  val targetUploadPath = uploadRoot.getTargetUploadPath()
-  val targetPlatform = targetEnvironmentRequest.targetPlatform
+  val targetPlatform = helpersAwareTargetRequest.targetEnvironmentRequest.targetPlatform
+  val targetUploadPath = helpersAwareTargetRequest.preparePyCharmHelpers()
  val targetPathSeparator = targetPlatform.platform.pathSeparator
  val uploads = helperPackage.pythonPathEntries.map {
    // TODO [Targets API] Simplify the paths resolution
--- a/python/src/com/jetbrains/python/run/target/HelpersAwareLocalTargetEnvironmentRequest.kt
+++ b/python/src/com/jetbrains/python/run/target/HelpersAwareLocalTargetEnvironmentRequest.kt
@@ -0,0 +1,15 @@
+// Copyright 2000-2021 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
+package com.jetbrains.python.run.target
+
+import com.intellij.execution.target.TargetEnvironmentRequest
+import com.intellij.execution.target.local.LocalTargetEnvironmentRequest
+import com.intellij.execution.target.value.TargetEnvironmentFunction
+import com.intellij.execution.target.value.constant
+import com.jetbrains.python.PythonHelpersLocator
+
+object HelpersAwareLocalTargetEnvironmentRequest : HelpersAwareTargetEnvironmentRequest {
+  override val targetEnvironmentRequest: TargetEnvironmentRequest
+    get() = LocalTargetEnvironmentRequest()
+
+  override fun preparePyCharmHelpers(): TargetEnvironmentFunction<String> = constant(PythonHelpersLocator.getHelpersRoot().path)
+}
--- a/python/src/com/jetbrains/python/run/target/HelpersAwareTargetEnvironmentRequest.kt
+++ b/python/src/com/jetbrains/python/run/target/HelpersAwareTargetEnvironmentRequest.kt
@@ -0,0 +1,19 @@
+// Copyright 2000-2021 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
+package com.jetbrains.python.run.target
+
+import com.intellij.execution.target.TargetEnvironmentRequest
+import com.intellij.execution.target.value.TargetEnvironmentFunction
+
+/**
+ * The target request for Python interpreter configured in PyCharm on a
+ * specific target.
+ */
+interface HelpersAwareTargetEnvironmentRequest {
+  val targetEnvironmentRequest: TargetEnvironmentRequest
+
+  /**
+   * The value that could be resolved to the path to the root of PyCharm
+   * helpers scripts.
+   */
+  fun preparePyCharmHelpers(): TargetEnvironmentFunction<String>
+}
--- a/python/src/com/jetbrains/python/testing/PythonTestCommandLineStateBase.java
+++ b/python/src/com/jetbrains/python/testing/PythonTestCommandLineStateBase.java
@@ -26,6 +26,7 @@ import com.jetbrains.python.HelperPackage;
 import com.jetbrains.python.PythonHelpersLocator;
 import com.jetbrains.python.console.PythonDebugLanguageConsoleView;
 import com.jetbrains.python.run.*;
+import com.jetbrains.python.run.target.HelpersAwareTargetEnvironmentRequest;
 import com.jetbrains.python.sdk.PythonSdkUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -103,8 +104,9 @@ public abstract class PythonTestCommandLineStateBase<T extends AbstractPythonRun
  }

  @Override
-  protected @NotNull PythonExecution buildPythonExecution(@NotNull TargetEnvironmentRequest targetEnvironmentRequest) {
-    PythonScriptExecution testScriptExecution = PythonScripts.prepareHelperScriptExecution(getRunner(), targetEnvironmentRequest);
+  protected @NotNull PythonExecution buildPythonExecution(@NotNull HelpersAwareTargetEnvironmentRequest helpersAwareRequest) {
+    TargetEnvironmentRequest targetEnvironmentRequest = helpersAwareRequest.getTargetEnvironmentRequest();
+    PythonScriptExecution testScriptExecution = PythonScripts.prepareHelperScriptExecution(getRunner(), helpersAwareRequest);
    addBeforeParameters(testScriptExecution);
    addTestSpecsAsParameters(testScriptExecution, getTestSpecs());
    addAfterParameters(targetEnvironmentRequest, testScriptExecution);