From c6610f62cec3621450e8ad56866b85296b764644 Mon Sep 17 00:00:00 2001 From: Roman Shevchenko Date: Tue, 23 Apr 2013 19:59:28 +0200 Subject: [PATCH] Command line API cleaned --- .../rest/sphinx/SphinxBaseCommand.java | 18 ++-- .../com/jetbrains/pyqt/CompileQrcAction.java | 2 +- .../python/buildout/BuildoutFacet.java | 9 +- .../python/console/PydevConsoleRunner.java | 6 +- .../python/debugger/PyDebugRunner.java | 4 +- .../python/run/PythonCommandLineState.java | 35 +++---- .../com/jetbrains/python/run/PythonTask.java | 18 ++-- .../jetbrains/python/sdk/PythonEnvUtil.java | 98 +++++++------------ .../jetbrains/python/sdk/PythonSdkType.java | 21 ++-- .../sdk/flavors/IronPythonSdkFlavor.java | 6 -- .../python/sdk/flavors/JythonSdkFlavor.java | 3 +- .../python/sdk/flavors/PythonSdkFlavor.java | 19 ++-- 12 files changed, 103 insertions(+), 136 deletions(-) diff --git a/python/python-rest/src/com/jetbrains/rest/sphinx/SphinxBaseCommand.java b/python/python-rest/src/com/jetbrains/rest/sphinx/SphinxBaseCommand.java index c873dca31a61..bcb0dd0643e9 100644 --- a/python/python-rest/src/com/jetbrains/rest/sphinx/SphinxBaseCommand.java +++ b/python/python-rest/src/com/jetbrains/rest/sphinx/SphinxBaseCommand.java @@ -1,7 +1,6 @@ package com.jetbrains.rest.sphinx; import com.google.common.collect.Lists; -import com.google.common.collect.Maps; import com.intellij.execution.ExecutionException; import com.intellij.execution.RunContentExecutor; import com.intellij.execution.configurations.GeneralCommandLine; @@ -18,12 +17,12 @@ import com.intellij.openapi.ui.TextFieldWithBrowseButton; import com.intellij.openapi.util.SystemInfo; import com.intellij.openapi.vfs.LocalFileSystem; import com.intellij.openapi.vfs.VirtualFile; +import com.jetbrains.python.ReSTService; import com.jetbrains.python.buildout.BuildoutFacet; import com.jetbrains.python.run.PythonCommandLineState; import com.jetbrains.python.run.PythonProcessRunner; import com.jetbrains.python.run.PythonTracebackFilter; import com.jetbrains.python.sdk.PythonSdkType; -import com.jetbrains.python.ReSTService; import com.jetbrains.rest.RestUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -33,8 +32,8 @@ import java.awt.*; import java.util.Collections; import java.util.List; -import static com.jetbrains.python.sdk.PythonEnvUtil.setPythonIOEncoding; -import static com.jetbrains.python.sdk.PythonEnvUtil.setPythonUnbuffered; +import static com.jetbrains.python.sdk.PythonEnvUtil.PYTHONIOENCODING; +import static com.jetbrains.python.sdk.PythonEnvUtil.PYTHONUNBUFFERED; /** * User : catherine @@ -141,8 +140,10 @@ public class SphinxBaseCommand { ParamsGroup script_params = cmd.getParametersList().getParamsGroup(PythonCommandLineState.GROUP_SCRIPT); assert script_params != null; - if (getCommandPath(sdk) != null) - cmd.setExePath(getCommandPath(sdk)); + String commandPath = getCommandPath(sdk); + if (commandPath != null) { + cmd.setExePath(commandPath); + } if (params != null) { for (String p : params) { @@ -150,8 +151,9 @@ public class SphinxBaseCommand { } } - cmd.setPassParentEnvs(true); - cmd.setEnvParams(setPythonUnbuffered(setPythonIOEncoding(Maps.newHashMap(), "utf-8"))); + cmd.setPassParentEnvironment(true); + cmd.setEnvironment(PYTHONIOENCODING, "utf-8"); + cmd.setEnvironment(PYTHONUNBUFFERED, "1"); List pathList = Lists.newArrayList(PythonCommandLineState.getAddedPaths(sdk)); pathList.addAll(PythonCommandLineState.collectPythonPath(module)); diff --git a/python/src/com/jetbrains/pyqt/CompileQrcAction.java b/python/src/com/jetbrains/pyqt/CompileQrcAction.java index 95131bd3ab4c..25d4172acaeb 100644 --- a/python/src/com/jetbrains/pyqt/CompileQrcAction.java +++ b/python/src/com/jetbrains/pyqt/CompileQrcAction.java @@ -46,7 +46,7 @@ public class CompileQrcAction extends AnAction { } GeneralCommandLine cmdLine = new GeneralCommandLine(); - cmdLine.setPassParentEnvs(true); + cmdLine.setPassParentEnvironment(true); cmdLine.setExePath(path); cmdLine.addParameters("-o", dialog.getOutputPath()); for (VirtualFile vFile : vFiles) { diff --git a/python/src/com/jetbrains/python/buildout/BuildoutFacet.java b/python/src/com/jetbrains/python/buildout/BuildoutFacet.java index c9d2a20c033f..8c2622efea4b 100644 --- a/python/src/com/jetbrains/python/buildout/BuildoutFacet.java +++ b/python/src/com/jetbrains/python/buildout/BuildoutFacet.java @@ -242,7 +242,6 @@ public class BuildoutFacet extends Facet implements } public void patchCommandLineForBuildout(GeneralCommandLine commandLine) { - Map new_env = PythonEnvUtil.cloneEnv(commandLine.getEnvParams()); // we need a copy lest we change config's map. ParametersList params = commandLine.getParametersList(); // alter execution script ParamsGroup script_params = params.getParamsGroup(PythonCommandLineState.GROUP_SCRIPT); @@ -250,12 +249,13 @@ public class BuildoutFacet extends Facet implements if (script_params.getParameters().size() > 0) { String normal_script = script_params.getParameters().get(0); // expect DjangoUtil.MANAGE_FILE String engulfer_path = PythonHelpersLocator.getHelperPath("pycharm/buildout_engulfer.py"); - new_env.put("PYCHARM_ENGULF_SCRIPT", getConfiguration().getScriptName()); + commandLine.setEnvironment("PYCHARM_ENGULF_SCRIPT", getConfiguration().getScriptName()); script_params.getParametersList().replaceOrPrepend(normal_script, engulfer_path); } - // add pycharm helpers to pythonpath so that fixGetpass is importable - PythonEnvUtil.addToPythonPath(new_env, PythonHelpersLocator.getHelpersRoot().getAbsolutePath()); + // add pycharm helpers to pythonpath so that fixGetpass is importable + PythonEnvUtil.addToPythonPath(commandLine, PythonHelpersLocator.getHelpersRoot().getAbsolutePath()); + /* // set prependable paths List paths = facet.getAdditionalPythonPath(); @@ -264,7 +264,6 @@ public class BuildoutFacet extends Facet implements new_env.put("PYCHARM_PREPEND_SYSPATH", path_value); } */ - commandLine.setEnvParams(new_env); } @Nullable diff --git a/python/src/com/jetbrains/python/console/PydevConsoleRunner.java b/python/src/com/jetbrains/python/console/PydevConsoleRunner.java index e0563bbd5c3b..ce2efe1d5f64 100644 --- a/python/src/com/jetbrains/python/console/PydevConsoleRunner.java +++ b/python/src/com/jetbrains/python/console/PydevConsoleRunner.java @@ -266,12 +266,14 @@ public class PydevConsoleRunner extends AbstractConsoleRunnerWithHistory envs) + private Process createRemoteConsoleProcess(PythonRemoteInterpreterManager manager, String[] command, Map env) throws ExecutionException { RemoteSdkData data = (RemoteSdkData)mySdk.getSdkAdditionalData(); GeneralCommandLine commandLine = new GeneralCommandLine(command); - commandLine.setEnvParams(envs); + if (env != null) { + commandLine.setEnvironment(env); + } commandLine.getParametersList().set(1, PythonRemoteInterpreterManager.toSystemDependent(new File(data.getHelpersPath(), PYDEV_PYDEVCONSOLE_PY) diff --git a/python/src/com/jetbrains/python/debugger/PyDebugRunner.java b/python/src/com/jetbrains/python/debugger/PyDebugRunner.java index 111e4767f680..289fd006ab4f 100644 --- a/python/src/com/jetbrains/python/debugger/PyDebugRunner.java +++ b/python/src/com/jetbrains/python/debugger/PyDebugRunner.java @@ -194,7 +194,7 @@ public class PyDebugRunner extends GenericProgramRunner { } if (PyDebuggerOptionsProvider.getInstance(project).isSupportGeventDebugging()) { - generalCommandLine.getEnvParamsNotNull().put(GEVENT_SUPPORT, "True"); + generalCommandLine.setEnvironment(GEVENT_SUPPORT, "True"); } final String[] debuggerArgs = new String[]{ @@ -214,6 +214,6 @@ public class PyDebugRunner extends GenericProgramRunner { roots.add(contentRoot.getPath()); } - commandLine.getEnvParamsNotNull().put(PYCHARM_PROJECT_ROOTS, StringUtil.join(roots, File.pathSeparator)); + commandLine.setEnvironment(PYCHARM_PROJECT_ROOTS, StringUtil.join(roots, File.pathSeparator)); } } diff --git a/python/src/com/jetbrains/python/run/PythonCommandLineState.java b/python/src/com/jetbrains/python/run/PythonCommandLineState.java index 0a0d72f133e1..965c3aa83178 100644 --- a/python/src/com/jetbrains/python/run/PythonCommandLineState.java +++ b/python/src/com/jetbrains/python/run/PythonCommandLineState.java @@ -25,10 +25,10 @@ import com.intellij.openapi.project.Project; import com.intellij.openapi.projectRoots.Sdk; import com.intellij.openapi.projectRoots.SdkAdditionalData; import com.intellij.openapi.roots.*; -import com.intellij.openapi.ui.Messages; import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.vfs.JarFileSystem; import com.intellij.openapi.vfs.VirtualFile; +import com.intellij.util.containers.ContainerUtil; import com.intellij.util.containers.HashMap; import com.jetbrains.python.PythonHelpersLocator; import com.jetbrains.python.console.PyDebugConsoleBuilder; @@ -36,8 +36,6 @@ import com.jetbrains.python.debugger.PyDebugRunner; import com.jetbrains.python.debugger.PyDebuggerOptionsProvider; import com.jetbrains.python.facet.LibraryContributingFacet; import com.jetbrains.python.facet.PythonPathContributingFacet; -import com.jetbrains.python.remote.PyRemoteSdkAdditionalData; -import com.jetbrains.python.remote.PythonRemoteInterpreterManager; import com.jetbrains.python.sdk.PySdkUtil; import com.jetbrains.python.sdk.PythonEnvUtil; import com.jetbrains.python.sdk.PythonSdkAdditionalData; @@ -227,27 +225,24 @@ public abstract class PythonCommandLineState extends CommandLineState { } protected void initEnvironment(GeneralCommandLine commandLine) { - Map envs = myConfig.getEnvs(); - if (envs == null) { - envs = new HashMap(); + boolean passParentEnvironment = myConfig.isPassParentEnvs(); + + Map env = myConfig.getEnvs(); + if (env == null) { + env = new HashMap(); } else { - envs = new HashMap(envs); + env = new HashMap(env); } + addPredefinedEnvironmentVariables(env, passParentEnvironment); + commandLine.setEnvironment(env); - addPredefinedEnvironmentVariables(envs, myConfig.isPassParentEnvs()); - addCommonEnvironmentVariables(envs); + commandLine.setEnvironment(PythonEnvUtil.PYTHONUNBUFFERED, "1"); + commandLine.setEnvironment("PYCHARM_HOSTED", "1"); - commandLine.setEnvParams(envs); - commandLine.setPassParentEnvs(myConfig.isPassParentEnvs()); + commandLine.setPassParentEnvironment(passParentEnvironment); - buildPythonPath(commandLine, myConfig.isPassParentEnvs()); - } - - - protected static void addCommonEnvironmentVariables(Map envs) { - PythonEnvUtil.setPythonUnbuffered(envs); - envs.put("PYCHARM_HOSTED", "1"); + buildPythonPath(commandLine, passParentEnvironment); } public void addPredefinedEnvironmentVariables(Map envs, boolean passParentEnvs) { @@ -275,7 +270,9 @@ public abstract class PythonCommandLineState extends CommandLineState { flavor.initPythonPath(commandLine, pathList); } else { - PythonSdkFlavor.initPythonPath(commandLine.getEnvParamsNotNull(), passParentEnvs, pathList); + Map env = ContainerUtil.newHashMap(commandLine.getEnvironment()); + PythonSdkFlavor.initPythonPath(env, passParentEnvs, pathList); + commandLine.setEnvironment(env); } } diff --git a/python/src/com/jetbrains/python/run/PythonTask.java b/python/src/com/jetbrains/python/run/PythonTask.java index 1a1496454428..3b340f19056e 100644 --- a/python/src/com/jetbrains/python/run/PythonTask.java +++ b/python/src/com/jetbrains/python/run/PythonTask.java @@ -24,9 +24,7 @@ import com.jetbrains.python.sdk.PythonSdkType; import org.jetbrains.annotations.Nullable; import java.util.ArrayList; -import java.util.HashMap; import java.util.List; -import java.util.Map; /** * Base class for tasks which are run from PyCharm with results displayed in a toolwindow (manage.py, setup.py, Sphinx etc). @@ -112,8 +110,8 @@ public class PythonTask { PythonCommandLineState.createStandardGroupsIn(cmd); ParamsGroup scriptParams = cmd.getParametersList().getParamsGroup(PythonCommandLineState.GROUP_SCRIPT); assert scriptParams != null; - cmd.setPassParentEnvs(true); - Map envs = new HashMap(); + + cmd.setPassParentEnvironment(true); if (!SystemInfo.isWindows && !PySdkUtil.isRemote(mySdk)) { cmd.setExePath("bash"); ParamsGroup bashParams = cmd.getParametersList().addParamsGroupAt(0, "Bash"); @@ -128,11 +126,10 @@ public class PythonTask { bashParams.addParameter(paramString.toString()); } else { - final String PATH_KEY = OSUtil.getPATHenvVariableName(); - String sysPath = System.getenv().get(PATH_KEY); - if (!StringUtil.isEmpty(sysPath)) { - final String path = envs.get(PATH_KEY); - envs.put(PATH_KEY, OSUtil.appendToPATHenvVariable(path, sysPath)); + String pathKey = OSUtil.getPATHenvVariableName(); + String sysPath = System.getenv().get(pathKey); + if (pathKey != null && !StringUtil.isEmpty(sysPath)) { + cmd.setEnvironment(pathKey, OSUtil.appendToPATHenvVariable(null, sysPath)); } cmd.setExePath(homePath); @@ -140,8 +137,7 @@ public class PythonTask { scriptParams.addParameters(myParameters); } - PythonEnvUtil.setPythonUnbuffered(envs); - cmd.setEnvParams(envs); + cmd.setEnvironment(PythonEnvUtil.PYTHONUNBUFFERED, "1"); List pythonPath = setupPythonPath(); PythonCommandLineState.initPythonPath(cmd, true, pythonPath, homePath); diff --git a/python/src/com/jetbrains/python/sdk/PythonEnvUtil.java b/python/src/com/jetbrains/python/sdk/PythonEnvUtil.java index 1e816b2e1123..c2f0c8943896 100644 --- a/python/src/com/jetbrains/python/sdk/PythonEnvUtil.java +++ b/python/src/com/jetbrains/python/sdk/PythonEnvUtil.java @@ -2,8 +2,8 @@ package com.jetbrains.python.sdk; import com.google.common.collect.Lists; import com.google.common.collect.Sets; +import com.intellij.execution.configurations.GeneralCommandLine; import com.intellij.openapi.util.text.StringUtil; -import com.intellij.util.containers.HashMap; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -17,36 +17,20 @@ import java.util.Set; * @author traff */ public class PythonEnvUtil { - public static final String PYTHONPATH = "PYTHONPATH"; - public static final String PYTHONUNBUFFERED = "PYTHONUNBUFFERED"; - public static final String PYTHONIOENCODING = "PYTHONIOENCODING"; + @SuppressWarnings("SpellCheckingInspection") public static final String PYTHONPATH = "PYTHONPATH"; + @SuppressWarnings("SpellCheckingInspection") public static final String PYTHONUNBUFFERED = "PYTHONUNBUFFERED"; + @SuppressWarnings("SpellCheckingInspection") public static final String PYTHONIOENCODING = "PYTHONIOENCODING"; - private PythonEnvUtil() { + private PythonEnvUtil() { } + + public static Map setPythonUnbuffered(@NotNull Map env) { + env.put(PYTHONUNBUFFERED, "1"); + return env; } - public static Map setPythonUnbuffered(@NotNull Map envs) { - envs.put(PYTHONUNBUFFERED, "1"); - return envs; - } - - public static Map setPythonIOEncoding(@NotNull Map envs, @NotNull String encoding) { - envs.put(PYTHONIOENCODING, encoding); - return envs; - } - - /** - * @param source - * @return a copy of source map, or a new map if source is null. - */ - public static Map cloneEnv(@Nullable Map source) { - Map new_env; - if (source != null) { - new_env = new HashMap(source); - } - else { - new_env = new HashMap(); - } - return new_env; + public static Map setPythonIOEncoding(@NotNull Map env, @NotNull String encoding) { + env.put(PYTHONIOENCODING, encoding); + return env; } /** @@ -58,58 +42,48 @@ public class PythonEnvUtil { */ @NotNull public static String appendToPathEnvVar(@Nullable String source, @NotNull String value) { - if (StringUtil.isNotEmpty(source)) { - assert source != null; - Set vals = Sets.newHashSet(source.split(File.pathSeparator)); - if (!vals.contains(value)) { - return source + File.pathSeparator + value; - } - else { - return source; - } - } - return value; + if (StringUtil.isEmpty(source)) return value; + Set paths = Sets.newHashSet(source.split(File.pathSeparator)); + return !paths.contains(value) ? source + File.pathSeparator + value : source; } - public static void addToEnv(@NotNull Map envs, String key, @NotNull Collection values) { + public static void addPathsToEnv(@NotNull Map env, String key, @NotNull Collection values) { for (String val : values) { - addPathToEnv(envs, key, val); + addPathToEnv(env, key, val); } } - public static void addPathToEnv(@NotNull Map envs, String key, String value) { + public static void addPathToEnv(@NotNull Map env, String key, String value) { if (!StringUtil.isEmpty(value)) { - if (envs.containsKey(key)) { - envs.put(key, appendToPathEnvVar(envs.get(key), value)); + if (env.containsKey(key)) { + env.put(key, appendToPathEnvVar(env.get(key), value)); } else { - envs.put(key, value); + env.put(key, value); } } } - public static void addToPythonPath(@NotNull Map envs, @NotNull Collection values) { - addToEnv(envs, PYTHONPATH, values); + public static void addPathToEnv(@NotNull GeneralCommandLine cmd, @NotNull String key, @NotNull String value) { + String currentPath = cmd.getEnvironment().get(key); + cmd.setEnvironment(key, appendToPathEnvVar(currentPath, value)); } - public static void addToPythonPath(@NotNull Map envs, String value) { - addPathToEnv(envs, PYTHONPATH, value); + public static void addToPythonPath(@NotNull Map env, @NotNull Collection values) { + addPathsToEnv(env, PYTHONPATH, values); } + public static void addToPythonPath(@NotNull Map env, String value) { + addPathToEnv(env, PYTHONPATH, value); + } + + public static void addToPythonPath(@NotNull GeneralCommandLine cmd, @NotNull String value) { + addPathToEnv(cmd, PYTHONPATH, value); + } @Nullable - public static List getPythonPathList(Map envs) { - return getPathListFromEnv(envs, PYTHONPATH); - } - - public static List getPathListFromEnv(@NotNull Map envs, String envKey) { - String pythonPath = envs.get(envKey); - if (pythonPath != null) { - String[] paths = pythonPath.split(Character.toString(File.pathSeparatorChar)); - return Lists.newArrayList(paths); - } - else { - return null; - } + public static List getPathListFromEnv(@NotNull GeneralCommandLine cmd, @NotNull String envKey) { + String pythonPath = cmd.getEnvironment().get(envKey); + return pythonPath != null ? Lists.newArrayList(pythonPath.split(File.pathSeparator)) : null; } } diff --git a/python/src/com/jetbrains/python/sdk/PythonSdkType.java b/python/src/com/jetbrains/python/sdk/PythonSdkType.java index 805c7527b6c0..25cda20afcd8 100644 --- a/python/src/com/jetbrains/python/sdk/PythonSdkType.java +++ b/python/src/com/jetbrains/python/sdk/PythonSdkType.java @@ -321,14 +321,15 @@ public class PythonSdkType extends SdkType { /** * Alters PATH so that a virtualenv is activated, if present. * - * @param commandLine what to patch - * @param sdkHome home of SDK we're using - * @param passParentEnvs iff true, include system paths in PATH + * @param commandLine what to patch + * @param sdkHome home of SDK we're using + * @param passParentEnvironment iff true, include system paths in PATH */ - public static void patchCommandLineForVirtualenv(GeneralCommandLine commandLine, String sdkHome, boolean passParentEnvs) { - @NonNls final String PATH = "PATH"; + public static void patchCommandLineForVirtualenv(GeneralCommandLine commandLine, String sdkHome, boolean passParentEnvironment) { File virtualEnvRoot = getVirtualEnvRoot(sdkHome); if (virtualEnvRoot != null) { + @NonNls final String PATH = "PATH"; + // prepend virtualenv bin if it's not already on PATH File bin = new File(virtualEnvRoot, "bin"); if (!bin.exists()) { @@ -336,21 +337,19 @@ public class PythonSdkType extends SdkType { } String virtualenvBin = bin.getPath(); - Map env = commandLine.getEnvParams(); String pathValue; - if (env != null && env.containsKey(PATH)) { + Map env = commandLine.getEnvironment(); + if (env.containsKey(PATH)) { pathValue = PythonEnvUtil.appendToPathEnvVar(env.get(PATH), virtualenvBin); } - else if (passParentEnvs) { + else if (passParentEnvironment) { // append to PATH pathValue = PythonEnvUtil.appendToPathEnvVar(System.getenv(PATH), virtualenvBin); } else { pathValue = virtualenvBin; } - Map newEnv = PythonEnvUtil.cloneEnv(env); // we need a copy lest we change config's map. - newEnv.put(PATH, pathValue); - commandLine.setEnvParams(newEnv); + commandLine.setEnvironment(PATH, pathValue); } } diff --git a/python/src/com/jetbrains/python/sdk/flavors/IronPythonSdkFlavor.java b/python/src/com/jetbrains/python/sdk/flavors/IronPythonSdkFlavor.java index d12b4c1ea22b..ae5817c3d45d 100644 --- a/python/src/com/jetbrains/python/sdk/flavors/IronPythonSdkFlavor.java +++ b/python/src/com/jetbrains/python/sdk/flavors/IronPythonSdkFlavor.java @@ -1,6 +1,5 @@ package com.jetbrains.python.sdk.flavors; -import com.intellij.execution.configurations.GeneralCommandLine; import com.intellij.openapi.util.text.StringUtil; import icons.PythonIcons; import org.jetbrains.annotations.NotNull; @@ -68,11 +67,6 @@ public class IronPythonSdkFlavor extends PythonSdkFlavor { return Collections.singletonList("-X:Frames"); } - @Override - public void initPythonPath(GeneralCommandLine cmd, Collection path) { - initPythonPath(path, cmd.getEnvParamsNotNull()); - } - @Override public void initPythonPath(Collection path, Map env) { addToEnv("IRONPYTHONPATH", StringUtil.join(path, File.pathSeparator), env); diff --git a/python/src/com/jetbrains/python/sdk/flavors/JythonSdkFlavor.java b/python/src/com/jetbrains/python/sdk/flavors/JythonSdkFlavor.java index 2d452c7eb102..7617792ff99f 100644 --- a/python/src/com/jetbrains/python/sdk/flavors/JythonSdkFlavor.java +++ b/python/src/com/jetbrains/python/sdk/flavors/JythonSdkFlavor.java @@ -41,7 +41,8 @@ public class JythonSdkFlavor extends PythonSdkFlavor { @Override public void initPythonPath(GeneralCommandLine cmd, Collection path) { - initPythonPath(path, cmd.getEnvParamsNotNull()); + super.initPythonPath(cmd, path); + ParamsGroup paramGroup = cmd.getParametersList().getParamsGroup(PythonCommandLineState.GROUP_EXE_OPTIONS); assert paramGroup != null; for (String param : paramGroup.getParameters()) { diff --git a/python/src/com/jetbrains/python/sdk/flavors/PythonSdkFlavor.java b/python/src/com/jetbrains/python/sdk/flavors/PythonSdkFlavor.java index c61239fbe790..2d4b04aa1c34 100644 --- a/python/src/com/jetbrains/python/sdk/flavors/PythonSdkFlavor.java +++ b/python/src/com/jetbrains/python/sdk/flavors/PythonSdkFlavor.java @@ -11,6 +11,7 @@ import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.util.text.StringUtil; import com.intellij.openapi.vfs.encoding.EncodingManager; import com.intellij.util.PatternUtil; +import com.intellij.util.containers.ContainerUtil; import com.jetbrains.python.psi.LanguageLevel; import com.jetbrains.python.sdk.PySdkUtil; import com.jetbrains.python.sdk.PythonEnvUtil; @@ -191,11 +192,18 @@ public abstract class PythonSdkFlavor { } public void initPythonPath(GeneralCommandLine cmd, Collection path) { - initPythonPath(path, cmd.getEnvParamsNotNull()); + Map env = ContainerUtil.newHashMap(cmd.getEnvironment()); + initPythonPath(path, env); + cmd.setEnvironment(env); } - public static void addToEnv(final String key, String value, Map envs) { - PythonEnvUtil.addPathToEnv(envs, key, value); + public void initPythonPath(Collection path, Map env) { + path = appendSystemPythonPath(path); + addToEnv(PythonEnvUtil.PYTHONPATH, StringUtil.join(path, File.pathSeparator), env); + } + + public static void addToEnv(final String key, String value, Map env) { + PythonEnvUtil.addPathToEnv(env, key, value); } @SuppressWarnings({"MethodMayBeStatic"}) @@ -222,9 +230,4 @@ public abstract class PythonSdkFlavor { public Icon getIcon() { return PythonIcons.Python.Python; } - - public void initPythonPath(Collection path, Map env) { - path = appendSystemPythonPath(path); - addToEnv(PythonEnvUtil.PYTHONPATH, StringUtil.join(path, File.pathSeparator), env); - } }