Support run configuration for PyCharm Community & Professional (#19)

134130 · web-flow · commit ef1531d68b1c · 2025-02-01T00:27:01.000+09:00
Closes: #10
diff --git a/.idea/gradle.xml b/.idea/gradle.xml
diff --git a/build.gradle.kts b/build.gradle.kts
@@ -38,6 +38,7 @@ dependencies {
         pluginModule(implementation(project(":mise-products-gradle")))
         pluginModule(implementation(project(":mise-products-idea")))
         pluginModule(implementation(project(":mise-products-nodejs")))
+        pluginModule(implementation(project(":mise-products-pycharm")))
         pluginModule(implementation(project(":mise-products-rider")))
 
         plugins(listOf())
@@ -161,6 +162,7 @@ allprojects {
         detekt(project(":mise-products-gradle"))
         detekt(project(":mise-products-idea"))
         detekt(project(":mise-products-nodejs"))
+        detekt(project(":mise-products-pycharm"))
         detekt(project(":mise-products-rider"))
     }
 
@@ -215,7 +217,7 @@ val runIdePlatformTypes =
 runIdePlatformTypes.forEach { platformType ->
     intellijPlatformTesting.runIde.register("run${platformType.name}") {
         type = platformType
-        version = "2024.1"
+        version = "2024.3"
 
         plugins {
 //            plugin("pluginId", "1.0.0")
diff --git a/modules/core/src/main/kotlin/com/github/l34130/mise/core/MiseHelper.kt b/modules/core/src/main/kotlin/com/github/l34130/mise/core/MiseHelper.kt
@@ -7,7 +7,11 @@ import com.github.l34130.mise.core.run.MiseRunConfigurationSettingsEditor
 import com.github.l34130.mise.core.setting.MiseSettings
 import com.intellij.execution.configurations.RunConfigurationBase
 import com.intellij.openapi.components.service
+import com.intellij.platform.ide.progress.TaskCancellation
+import com.intellij.platform.ide.progress.withBackgroundProgress
 import com.intellij.util.application
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.runBlocking
 import java.util.function.Supplier
 
 object MiseHelper {
@@ -30,16 +34,20 @@ object MiseHelper {
                 else -> return emptyMap()
             }
 
-        return MiseCommandLineHelper
-            .getEnvVars(workDir, configEnvironment)
-            .fold(
-                onSuccess = { envVars -> envVars },
-                onFailure = {
-                    if (it !is MiseCommandLineNotFoundException) {
-                        MiseNotificationServiceUtils.notifyException("Failed to load environment variables", it)
-                    }
-                    emptyMap()
-                },
-            )
+        return runBlocking(Dispatchers.IO) {
+            withBackgroundProgress(configuration.project, "Getting Mise envvars", TaskCancellation.nonCancellable()) {
+                MiseCommandLineHelper
+                    .getEnvVars(workDir, configEnvironment)
+                    .fold(
+                        onSuccess = { envVars -> envVars },
+                        onFailure = {
+                            if (it !is MiseCommandLineNotFoundException) {
+                                MiseNotificationServiceUtils.notifyException("Failed to load environment variables", it)
+                            }
+                            mapOf()
+                        },
+                    )
+            }
+        }
     }
 }
diff --git a/modules/products/pycharm/build.gradle.kts b/modules/products/pycharm/build.gradle.kts
@@ -0,0 +1,24 @@
+import org.jetbrains.intellij.platform.gradle.IntelliJPlatformType
+import org.jetbrains.intellij.platform.gradle.TestFrameworkType
+
+fun properties(key: String) = project.findProperty(key).toString()
+
+plugins {
+    id("org.jetbrains.intellij.platform.module")
+    alias(libs.plugins.kotlin) // Kotlin support
+}
+
+dependencies {
+    implementation(project(":mise-core"))
+    testImplementation(libs.junit)
+
+    // Configure Gradle IntelliJ Plugin - read more: https://github.com/JetBrains/gradle-intellij-plugin
+    intellijPlatform {
+        create(IntelliJPlatformType.PyCharmCommunity, properties("platformVersion"))
+
+        bundledPlugins("PythonCore")
+
+        jetbrainsRuntime()
+        testFramework(TestFrameworkType.Platform)
+    }
+}
diff --git a/modules/products/pycharm/src/main/kotlin/com/github/l34130/mise/pycharm/run/MisePythonExecutionListener.kt b/modules/products/pycharm/src/main/kotlin/com/github/l34130/mise/pycharm/run/MisePythonExecutionListener.kt
@@ -0,0 +1,70 @@
+package com.github.l34130.mise.pycharm.run
+
+import com.github.l34130.mise.core.MiseHelper
+import com.intellij.execution.ExecutionListener
+import com.intellij.execution.process.ProcessHandler
+import com.intellij.execution.runners.ExecutionEnvironment
+import com.jetbrains.python.run.PythonRunConfiguration
+
+class MisePythonExecutionListener : ExecutionListener {
+    override fun processStarting(
+        executorId: String,
+        env: ExecutionEnvironment,
+    ) {
+        val pythonRunConfiguration = env.runProfile as? PythonRunConfiguration ?: return
+
+        val envVars =
+            MiseHelper.getMiseEnvVarsOrNotify(
+                configuration = pythonRunConfiguration,
+                workingDirectory = { pythonRunConfiguration.workingDirectory },
+            )
+
+        if (envVars.isEmpty()) {
+            return super.processStarting(executorId, env)
+        }
+
+        executions[env.executionId] = pythonRunConfiguration.envs
+        pythonRunConfiguration.envs.putAll(envVars)
+
+        super.processStarting(executorId, env)
+    }
+
+    override fun processStarted(
+        executorId: String,
+        env: ExecutionEnvironment,
+        handler: ProcessHandler,
+    ) {
+        restoreEnvVars(env)
+        super.processStarted(executorId, env, handler)
+    }
+
+    override fun processNotStarted(
+        executorId: String,
+        env: ExecutionEnvironment,
+    ) {
+        restoreEnvVars(env)
+        super.processNotStarted(executorId, env)
+    }
+
+    override fun processTerminating(
+        executorId: String,
+        env: ExecutionEnvironment,
+        handler: ProcessHandler,
+    ) {
+        restoreEnvVars(env)
+        super.processTerminating(executorId, env, handler)
+    }
+
+    private fun restoreEnvVars(env: ExecutionEnvironment) {
+        val originalEnvVars = executions[env.executionId] ?: return
+        executions.remove(env.executionId)
+
+        val pythonRunConfiguration = env.runProfile as? PythonRunConfiguration ?: return
+        pythonRunConfiguration.envs = originalEnvVars.toMutableMap()
+    }
+
+    companion object {
+        // Contains original environment variables
+        private val executions: MutableMap<Long, Map<String, String>> = mutableMapOf()
+    }
+}
diff --git a/modules/products/pycharm/src/main/kotlin/com/github/l34130/mise/pycharm/run/MisePythonRunConfigurationExtension.kt b/modules/products/pycharm/src/main/kotlin/com/github/l34130/mise/pycharm/run/MisePythonRunConfigurationExtension.kt
@@ -0,0 +1,63 @@
+package com.github.l34130.mise.pycharm.run
+
+import com.github.l34130.mise.core.MiseHelper
+import com.github.l34130.mise.core.run.MiseRunConfigurationSettingsEditor
+import com.intellij.execution.Location
+import com.intellij.execution.configurations.GeneralCommandLine
+import com.intellij.execution.configurations.RunnerSettings
+import com.intellij.openapi.options.SettingsEditor
+import com.jetbrains.python.run.AbstractPythonRunConfiguration
+import com.jetbrains.python.run.PythonRunConfigurationExtension
+import org.jdom.Element
+
+class MisePythonRunConfigurationExtension : PythonRunConfigurationExtension() {
+    override fun isApplicableFor(runConfiguration: AbstractPythonRunConfiguration<*>): Boolean = true
+
+    override fun isEnabledFor(
+        runConfiguration: AbstractPythonRunConfiguration<*>,
+        runnerSettings: RunnerSettings?,
+    ): Boolean = true
+
+    override fun <P : AbstractPythonRunConfiguration<*>> createEditor(configuration: P): SettingsEditor<P> =
+        MiseRunConfigurationSettingsEditor(configuration.project)
+
+    override fun getSerializationId(): String = MiseRunConfigurationSettingsEditor.SERIALIZATION_ID
+
+    override fun writeExternal(
+        runConfiguration: AbstractPythonRunConfiguration<*>,
+        element: Element,
+    ) {
+        MiseRunConfigurationSettingsEditor.writeExternal(runConfiguration, element)
+    }
+
+    override fun readExternal(
+        runConfiguration: AbstractPythonRunConfiguration<*>,
+        element: Element,
+    ) {
+        MiseRunConfigurationSettingsEditor.readExternal(runConfiguration, element)
+    }
+
+    override fun getEditorTitle(): String = MiseRunConfigurationSettingsEditor.EDITOR_TITLE
+
+    override fun patchCommandLine(
+        runConfiguration: AbstractPythonRunConfiguration<*>,
+        runnerSettings: RunnerSettings?,
+        cmdLine: GeneralCommandLine,
+        runnerId: String,
+    ) {
+        val envVars =
+            MiseHelper.getMiseEnvVarsOrNotify(
+                configuration = runConfiguration,
+                workingDirectory = { runConfiguration.workingDirectory },
+            )
+
+        cmdLine.withEnvironment(envVars)
+    }
+
+    override fun extendCreatedConfiguration(
+        configuration: AbstractPythonRunConfiguration<*>,
+        location: Location<*>,
+    ) {
+        super.extendCreatedConfiguration(configuration, location)
+    }
+}
diff --git a/settings.gradle.kts b/settings.gradle.kts
@@ -22,6 +22,7 @@ include(
     "modules/products/gradle",
     "modules/products/idea",
     "modules/products/nodejs",
+    "modules/products/pycharm",
     "modules/products/rider",
 )
 
diff --git a/src/main/resources/META-INF/mise-pycharm.xml b/src/main/resources/META-INF/mise-pycharm.xml
@@ -0,0 +1,11 @@
+<idea-plugin require-restart="false">
+    <extensions defaultExtensionNs="Pythonid">
+        <runConfigurationExtension implementation="com.github.l34130.mise.pycharm.run.MisePythonRunConfigurationExtension"/>
+<!--        <pythonCommandLineTargetEnvironmentProvider implementation="com.github.l34130.mise.python.run.PythonCommandLineTargetEnvironmentProvider"/>-->
+    </extensions>
+
+    <projectListeners>
+        <listener class="com.github.l34130.mise.pycharm.run.MisePythonExecutionListener" topic="com.intellij.execution.ExecutionListener"/>
+    </projectListeners>
+
+</idea-plugin>
diff --git a/src/main/resources/META-INF/plugin.xml b/src/main/resources/META-INF/plugin.xml
@@ -68,5 +68,6 @@
     <depends optional="true" config-file="mise-gradle.xml">com.intellij.gradle</depends>
     <depends optional="true" config-file="mise-idea.xml">com.intellij.java</depends>
     <depends optional="true" config-file="mise-javascript.xml">JavaScript</depends>
+    <depends optional="true" config-file="mise-pycharm.xml">com.intellij.modules.python</depends>
     <depends optional="true" config-file="mise-rider.xml">com.intellij.modules.rider</depends>
 </idea-plugin>

Original file line number	Diff line number	Diff line change
`@@ -22,6 +22,7 @@ include(`
`22`	`22`	`"modules/products/gradle",`
`23`	`23`	`"modules/products/idea",`
`24`	`24`	`"modules/products/nodejs",`
	`25`	`+ "modules/products/pycharm",`
`25`	`26`	`"modules/products/rider",`
`26`	`27`	`)`
`27`	`28`