From c6f0af15f0f11a5dbe5eeeae67dedf1016eb5339 Mon Sep 17 00:00:00 2001 From: Alexey Katsman Date: Fri, 21 Nov 2025 18:12:27 +0100 Subject: [PATCH] PY-85634 Adapt PyInterpreterInspection to Kotlin style Follow-up to IJ-MR-178613 GitOrigin-RevId: 25175f413a9062b43e1b2e2df2ea1082ebd639de --- .../InterpreterSettingsQuickFix.kt | 24 +- .../interpreter/PyInterpreterInspection.kt | 435 +++++++----------- .../interpreter/PyInterpreterInspectionEx.kt | 42 -- 3 files changed, 186 insertions(+), 315 deletions(-) delete mode 100644 python/src/com/jetbrains/python/inspections/interpreter/PyInterpreterInspectionEx.kt diff --git a/python/src/com/jetbrains/python/inspections/interpreter/InterpreterSettingsQuickFix.kt b/python/src/com/jetbrains/python/inspections/interpreter/InterpreterSettingsQuickFix.kt index a4c728185318..eddb8feccd7c 100644 --- a/python/src/com/jetbrains/python/inspections/interpreter/InterpreterSettingsQuickFix.kt +++ b/python/src/com/jetbrains/python/inspections/interpreter/InterpreterSettingsQuickFix.kt @@ -6,7 +6,6 @@ import com.intellij.codeInspection.ProblemDescriptor import com.intellij.ide.actions.ShowSettingsUtilImpl import com.intellij.openapi.module.Module import com.intellij.openapi.module.ModuleManager -import com.intellij.openapi.options.ConfigurableGroup import com.intellij.openapi.options.ex.ConfigurableExtensionPointUtil import com.intellij.openapi.options.ex.ConfigurableVisitor import com.intellij.openapi.project.Project @@ -17,16 +16,12 @@ import com.intellij.util.PlatformUtils import com.jetbrains.python.PyPsiBundle class InterpreterSettingsQuickFix(private val myModule: Module?) : LocalQuickFix { - override fun getFamilyName(): String { - return if (PlatformUtils.isPyCharm()) - PyPsiBundle.message("INSP.interpreter.interpreter.settings") - else - PyPsiBundle.message("INSP.interpreter.configure.python.interpreter") - } + override fun getFamilyName(): String = if (PlatformUtils.isPyCharm()) + PyPsiBundle.message("INSP.interpreter.interpreter.settings") + else + PyPsiBundle.message("INSP.interpreter.configure.python.interpreter") - override fun startInWriteAction(): Boolean { - return false - } + override fun startInWriteAction(): Boolean = false override fun applyFix(project: Project, descriptor: ProblemDescriptor) { showPythonInterpreterSettings(project, myModule) @@ -36,8 +31,8 @@ class InterpreterSettingsQuickFix(private val myModule: Module?) : LocalQuickFix fun showPythonInterpreterSettings(project: Project, module: Module?) { val id = "com.jetbrains.python.configuration.PyActiveSdkModuleConfigurable" val group = ConfigurableExtensionPointUtil.getConfigurableGroup(project, true) - if (ConfigurableVisitor.findById(id, mutableListOf(group)) != null) { - ShowSettingsUtilImpl.Companion.showSettingsDialog(project, id, null) + if (ConfigurableVisitor.findById(id, listOf(group)) != null) { + ShowSettingsUtilImpl.showSettingsDialog(project, id, null) return } @@ -51,8 +46,9 @@ class InterpreterSettingsQuickFix(private val myModule: Module?) : LocalQuickFix } private fun justOneModuleInheritingSdk(project: Project, module: Module): Boolean { - return ProjectRootManager.getInstance(project).getProjectSdk() == null && - ModuleRootManager.getInstance(module).isSdkInherited() && ModuleManager.Companion.getInstance(project).modules.size < 2 + return ProjectRootManager.getInstance(project).projectSdk == null && + ModuleRootManager.getInstance(module).isSdkInherited && + ModuleManager.getInstance(project).modules.size < 2 } } } \ No newline at end of file diff --git a/python/src/com/jetbrains/python/inspections/interpreter/PyInterpreterInspection.kt b/python/src/com/jetbrains/python/inspections/interpreter/PyInterpreterInspection.kt index d321945defad..4481df2800ee 100644 --- a/python/src/com/jetbrains/python/inspections/interpreter/PyInterpreterInspection.kt +++ b/python/src/com/jetbrains/python/inspections/interpreter/PyInterpreterInspection.kt @@ -9,19 +9,20 @@ import com.intellij.codeInspection.ProblemsHolder import com.intellij.codeInspection.util.InspectionMessage import com.intellij.codeInspection.util.IntentionFamilyName import com.intellij.codeInspection.util.IntentionName -import com.intellij.openapi.application.ApplicationManager +import com.intellij.openapi.components.Service +import com.intellij.openapi.components.service import com.intellij.openapi.module.Module import com.intellij.openapi.module.ModuleUtilCore +import com.intellij.openapi.progress.runBlockingMaybeCancellable import com.intellij.openapi.project.Project import com.intellij.openapi.projectRoots.Sdk import com.intellij.openapi.roots.ProjectRootManager import com.intellij.openapi.roots.ui.configuration.projectRoot.ProjectSdksModel -import com.intellij.openapi.util.Condition import com.intellij.openapi.util.UserDataHolderBase import com.intellij.psi.PsiElementVisitor +import com.intellij.python.sdkConfigurator.common.detectSdkForModulesIn +import com.intellij.python.sdkConfigurator.common.enableSDKAutoConfigurator import com.intellij.util.PathUtil -import com.intellij.util.containers.ContainerUtil -import com.intellij.util.containers.toArray import com.jetbrains.python.PyPsiBundle import com.jetbrains.python.PythonIdeLanguageCustomization import com.jetbrains.python.inspections.PyInspection @@ -31,302 +32,218 @@ import com.jetbrains.python.psi.LanguageLevel import com.jetbrains.python.psi.PyFile import com.jetbrains.python.psi.impl.PyBuiltinCache import com.jetbrains.python.psi.types.TypeEvalContext -import com.jetbrains.python.sdk.PyDetectedSdk -import com.jetbrains.python.sdk.PySdkPopupFactory -import com.jetbrains.python.sdk.PythonSdkType +import com.jetbrains.python.sdk.* import com.jetbrains.python.sdk.conda.PyCondaSdkCustomizer import com.jetbrains.python.sdk.configuration.CreateSdkInfoWithTool import com.jetbrains.python.sdk.configuration.PyProjectSdkConfiguration -import com.jetbrains.python.sdk.detectSystemWideSdks -import com.jetbrains.python.sdk.detectVirtualEnvs -import com.jetbrains.python.sdk.filterAssociatedSdks -import com.jetbrains.python.sdk.filterSharedCondaEnvs -import com.jetbrains.python.sdk.filterSystemWideSdks -import com.jetbrains.python.sdk.guessedLanguageLevel +import com.jetbrains.python.sdk.configuration.PyProjectSdkConfigurationExtension import com.jetbrains.python.sdk.legacy.PythonSdkUtil -import com.jetbrains.python.sdk.mostPreferred -import com.jetbrains.python.sdk.setupSdkLaunch import com.jetbrains.python.ui.PyUiUtil -import one.util.streamex.StreamEx -import java.io.File -import java.util.function.Function -import java.util.regex.Matcher +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.launch import java.util.regex.Pattern +private val NAME: Pattern = Pattern.compile("Python (?\\d\\.\\d+)\\s*(\\((?.+?)\\))?") + class PyInterpreterInspection : PyInspection() { - override fun buildVisitor( - holder: ProblemsHolder, - isOnTheFly: Boolean, - session: LocalInspectionToolSession - ): PsiElementVisitor { - return Visitor(holder, PyInspectionVisitor.getContext(session)) - } + override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean, session: LocalInspectionToolSession): PsiElementVisitor = + PyInterpreterInspectionVisitor(holder, PyInspectionVisitor.getContext(session)) +} - class Visitor( - holder: ProblemsHolder?, - context: TypeEvalContext - ) : PyInspectionVisitor(holder, context) { - override fun visitPyFile(node: PyFile) { - if (isFileIgnored(node)) return - val module = ModuleUtilCore.findModuleForPsiElement(node) - val sdk = PyBuiltinCache.Companion.findSdkForFile(node) - val pyCharm = PythonIdeLanguageCustomization.isMainlyPythonIde() +class PyInterpreterInspectionVisitor( + holder: ProblemsHolder?, + context: TypeEvalContext, +) : PyInspectionVisitor(holder, context) { - val fixes: MutableList = ArrayList() - if (sdk == null) { - val message: @InspectionMessage String - if (pyCharm) { - message = PyPsiBundle.message("INSP.interpreter.no.python.interpreter.configured.for.project") - } - else { - message = PyPsiBundle.message("INSP.interpreter.no.python.interpreter.configured.for.module") - } - registerProblemWithCommonFixes(node, message, module, fixes, pyCharm) - } - } + override fun visitPyFile(node: PyFile) { + if (isFileIgnored(node)) return + val module = ModuleUtilCore.findModuleForPsiElement(node) + val sdk = PyBuiltinCache.findSdkForFile(node) + val pyCharm = PythonIdeLanguageCustomization.isMainlyPythonIde() - private fun registerProblemWithCommonFixes( - node: PyFile, - @InspectionMessage message: @InspectionMessage String, - module: Module?, - fixes: MutableList, - pyCharm: Boolean - ) { - if (module != null && pyCharm) { - val sdkName = ProjectRootManager.getInstance(node.getProject()).getProjectSdkName() - ContainerUtil.addIfNotNull(fixes, getSuitableSdkFix(sdkName, module)) - } - if (module != null && pyCharm) { - fixes.add(ConfigureInterpreterFix()) + if (sdk == null) { + val message = if (pyCharm) { + PyPsiBundle.message("INSP.interpreter.no.python.interpreter.configured.for.project") } else { - fixes.add(InterpreterSettingsQuickFix(module)) + PyPsiBundle.message("INSP.interpreter.no.python.interpreter.configured.for.module") } + registerProblemWithCommonFixes(node, message, module, pyCharm) + } + } - registerProblem(node, message, *fixes.toArray(LocalQuickFix.EMPTY_ARRAY)) + private fun registerProblemWithCommonFixes(node: PyFile, @InspectionMessage message: String, module: Module?, pyCharm: Boolean) { + val fixes = buildList { + if (module != null && pyCharm) { + val sdkName = ProjectRootManager.getInstance(node.project).projectSdkName + getSuitableSdkFix(sdkName, module)?.let { add(it) } + add(ConfigureInterpreterFix()) + } + else { + add(InterpreterSettingsQuickFix(module)) + } } - companion object { - private fun getSuitableSdkFix(name: String?, module: Module): LocalQuickFix? { - // this method is based on com.jetbrains.python.sdk.PySdkExtKt.suggestAssociatedSdkName - // please keep it in sync with the mentioned method and com.jetbrains.python.PythonSdkConfigurator.configureSdk + registerProblem(node, message, *fixes.toTypedArray()) + } +} - val existingSdks: List = existingSdks +private fun getSuitableSdkFix(name: String?, module: Module): LocalQuickFix? { + // this method is based on com.jetbrains.python.sdk.PySdkExtKt.suggestAssociatedSdkName + // please keep it in sync with the mentioned method and com.jetbrains.python.PythonSdkConfigurator.configureSdk - val associatedSdk = mostPreferred(filterAssociatedSdks(module, existingSdks)) - if (associatedSdk != null) return UseExistingInterpreterFix(associatedSdk, module) + val existingSdks = getExistingSdks() - val context = UserDataHolderBase() + val associatedSdk = mostPreferred(filterAssociatedSdks(module, existingSdks)) + if (associatedSdk != null) return UseExistingInterpreterFix(associatedSdk, module) - val createSdkInfos: List = findAllSortedForModuleForJvm(module) - if (!createSdkInfos.isEmpty()) { - return UseProvidedInterpreterFix(module, createSdkInfos.first()) + val context = UserDataHolderBase() + val createSdkInfo = runBlockingMaybeCancellable { + PyProjectSdkConfigurationExtension.findAllSortedForModule(module).firstOrNull() + } + if (createSdkInfo != null) return UseProvidedInterpreterFix(module, createSdkInfo) + + if (name != null) { + val matcher = NAME.matcher(name) + if (matcher.matches()) { + val venvName = matcher.group("name") + if (venvName != null) { + val detectedAssociatedViaRootNameEnv = detectAssociatedViaRootNameEnv(venvName, module, existingSdks, context) + if (detectedAssociatedViaRootNameEnv != null) { + return UseDetectedInterpreterFix(detectedAssociatedViaRootNameEnv, existingSdks, true, module) } - - if (name != null) { - val matcher: Matcher = NAME.matcher(name) - if (matcher.matches()) { - val venvName = matcher.group("name") - if (venvName != null) { - val detectedAssociatedViaRootNameEnv: PyDetectedSdk? = detectAssociatedViaRootNameEnv(venvName, module, existingSdks, context) - if (detectedAssociatedViaRootNameEnv != null) { - return UseDetectedInterpreterFix(detectedAssociatedViaRootNameEnv, existingSdks, true, module) - } - } - else { - val detectedSystemWideSdk: PyDetectedSdk? = detectSystemWideSdk(matcher.group("version"), module, existingSdks, context) - if (detectedSystemWideSdk != null) { - return UseDetectedInterpreterFix(detectedSystemWideSdk, existingSdks, false, module) - } - } - } - } - - if (PyCondaSdkCustomizer.Companion.instance.suggestSharedCondaEnvironments) { - val sharedCondaEnv = mostPreferred(filterSharedCondaEnvs(module, existingSdks)) - if (sharedCondaEnv != null) { - return UseExistingInterpreterFix(sharedCondaEnv, module) - } - } - - // TODO: We should use SystemPythonService here as well, postponing as it's quite unlikely we get here (although we can) - val systemWideSdk = mostPreferred(filterSystemWideSdks(existingSdks)) - if (systemWideSdk != null) { - return UseExistingInterpreterFix(systemWideSdk, module) - } - - val configurator = PyCondaSdkCustomizer.Companion.instance.fallbackConfigurator - if (configurator != null) { - val fallbackCreateSdkInfo = - PyCondaSdkCustomizer.Companion.checkEnvironmentAndPrepareSdkCreatorBlocking(configurator, module) - if (fallbackCreateSdkInfo != null) { - return UseProvidedInterpreterFix(module, fallbackCreateSdkInfo) - } - } - - val detectedSystemWideSdk = ContainerUtil.getFirstItem(detectSystemWideSdks(module, existingSdks)) + } + else { + val detectedSystemWideSdk = detectSystemWideSdk(matcher.group("version"), module, existingSdks, context) if (detectedSystemWideSdk != null) { return UseDetectedInterpreterFix(detectedSystemWideSdk, existingSdks, false, module) } - - return null - } - - private val existingSdks: List - get() { - val model = ProjectSdksModel() - model.reset(null) - return ContainerUtil.filter(model.getSdks(), - Condition { it.getSdkType() is PythonSdkType }) - } - - private fun detectAssociatedViaRootNameEnv( - associatedName: String, - module: Module, - existingSdks: List, - context: UserDataHolderBase - ): PyDetectedSdk? { - return Companion.findAssociatedViaRootNameEnv( - associatedName, - detectVirtualEnvs(module, existingSdks, context), - Function { sdk: PyDetectedSdk? -> getVirtualEnvRootName(sdk!!) } - ) - } - - private fun detectSystemWideSdk( - version: String, - module: Module, - existingSdks: List, - context: UserDataHolderBase - ): PyDetectedSdk? { - val parsedVersion: LanguageLevel = LanguageLevel.fromPythonVersion(version)!! - - if (parsedVersion.toString() == version) { - return ContainerUtil.find( - detectSystemWideSdks(module, existingSdks, context), - Condition { sdk: PyDetectedSdk -> sdk.guessedLanguageLevel == parsedVersion } - ) - } - - return null - } - - private fun findAssociatedViaRootNameEnv( - associatedName: String, - envs: List, - envRootName: Function - ): PyDetectedSdk? { - return StreamEx - .of(envs) - .filter { sdk: PyDetectedSdk -> associatedName == envRootName.apply(sdk) } - .max(compareBy { it.guessedLanguageLevel }.thenBy { it.homePath }) - .orElse(null) - } - - private fun getVirtualEnvRootName(sdk: PyDetectedSdk): String? { - val path = sdk.getHomePath() - return if (path == null) null else getEnvRootName(PythonSdkUtil.getVirtualEnvRoot(path)) - } - - private fun getEnvRootName(envRoot: File?): String? { - return if (envRoot == null) null else PathUtil.getFileName(envRoot.getPath()) } } } - class ConfigureInterpreterFix : LocalQuickFix { - @IntentionFamilyName - override fun getFamilyName(): @IntentionFamilyName String { - return PyPsiBundle.message("INSP.interpreter.configure.python.interpreter") + if (PyCondaSdkCustomizer.instance.suggestSharedCondaEnvironments) { + val sharedCondaEnv = mostPreferred(filterSharedCondaEnvs(module, existingSdks)) + if (sharedCondaEnv != null) return UseExistingInterpreterFix(sharedCondaEnv, module) + } + + // TODO: We should use SystemPythonService here as well, postponing as it's quite unlikely we get here (although we can) + val systemWideSdk = mostPreferred(filterSystemWideSdks(existingSdks)) + if (systemWideSdk != null) return UseExistingInterpreterFix(systemWideSdk, module) + + val configurator = PyCondaSdkCustomizer.instance.fallbackConfigurator + if (configurator != null) { + val fallbackCreateSdkInfo = PyCondaSdkCustomizer.checkEnvironmentAndPrepareSdkCreatorBlocking(configurator, module) + if (fallbackCreateSdkInfo != null) return UseProvidedInterpreterFix(module, fallbackCreateSdkInfo) + } + + val detectedSystemWideSdk = detectSystemWideSdks(module, existingSdks).firstOrNull() + if (detectedSystemWideSdk != null) return UseDetectedInterpreterFix(detectedSystemWideSdk, existingSdks, false, module) + + return null +} + +private fun getExistingSdks(): List { + val model = ProjectSdksModel() + model.reset(null) + return model.sdks.filter { it.sdkType is PythonSdkType } +} + +private fun detectAssociatedViaRootNameEnv( + associatedName: String, module: Module, existingSdks: List, context: UserDataHolderBase, +): PyDetectedSdk? = findAssociatedViaRootNameEnv(associatedName, detectVirtualEnvs(module, existingSdks, context)) + +private fun detectSystemWideSdk(version: String, module: Module, existingSdks: List, context: UserDataHolderBase): PyDetectedSdk? { + val parsedVersion = LanguageLevel.fromPythonVersion(version)!! + + return if (parsedVersion.toString() == version) { + detectSystemWideSdks(module, existingSdks, context).firstOrNull { it.guessedLanguageLevel == parsedVersion } + } + else null +} + +private fun findAssociatedViaRootNameEnv(associatedName: String, envs: List): PyDetectedSdk? = + envs.filter { associatedName == getVirtualEnvRootName(it) } + .maxWithOrNull(compareBy { it.guessedLanguageLevel }.thenBy { it.homePath }) + +private fun getVirtualEnvRootName(sdk: PyDetectedSdk): String? { + val file = sdk.homePath?.let { PythonSdkUtil.getVirtualEnvRoot(it) } ?: return null + return PathUtil.getFileName(file.path) +} + +private fun isFileIgnored(pyFile: PyFile): Boolean = + PyInspectionExtension.EP_NAME.extensionList.any { it.ignoreInterpreterWarnings(pyFile) } + + +class ConfigureInterpreterFix : LocalQuickFix { + @IntentionFamilyName + override fun getFamilyName(): String = PyPsiBundle.message("INSP.interpreter.configure.python.interpreter") + + override fun startInWriteAction(): Boolean = false + + override fun applyFix(project: Project, descriptor: ProblemDescriptor) { + val element = descriptor.psiElement ?: return + val module = ModuleUtilCore.findModuleForPsiElement(element) ?: return + PySdkPopupFactory.createAndShow(module) + } +} + +private class UseProvidedInterpreterFix(private val myModule: Module, private val myCreateSdkInfo: CreateSdkInfoWithTool) : LocalQuickFix { + @IntentionFamilyName + override fun getFamilyName(): String = PyPsiBundle.message("INSP.interpreter.use.suggested.interpreter") + + @IntentionName + override fun getName(): String = myCreateSdkInfo.createSdkInfo.intentionName + + override fun applyFix(project: Project, descriptor: ProblemDescriptor) { + if (!enableSDKAutoConfigurator) { + return PyProjectSdkConfiguration.configureSdkUsingCreateSdkInfo(myModule, myCreateSdkInfo) } - override fun startInWriteAction(): Boolean { - return false - } - - override fun applyFix(project: Project, descriptor: ProblemDescriptor) { - val element = descriptor.getPsiElement() - if (element == null) return - - val module = ModuleUtilCore.findModuleForPsiElement(element) - if (module == null) return - - PySdkPopupFactory.Companion.createAndShow(module) + project.service().scope.launch { + detectSdkForModulesIn(project) } } - private class UseProvidedInterpreterFix( - private val myModule: Module, - private val myCreateSdkInfo: CreateSdkInfoWithTool - ) : LocalQuickFix { - @IntentionFamilyName - override fun getFamilyName(): @IntentionFamilyName String { - return PyPsiBundle.message("INSP.interpreter.use.suggested.interpreter") - } + override fun generatePreview(project: Project, previewDescriptor: ProblemDescriptor): IntentionPreviewInfo { + // The quick fix doesn't change the code and is suggested on a file level + return IntentionPreviewInfo.EMPTY + } +} - @IntentionName - override fun getName(): @IntentionName String { - return myCreateSdkInfo.createSdkInfo.intentionName - } +private abstract class UseInterpreterFix(protected val mySdk: T) : LocalQuickFix { + @IntentionFamilyName + override fun getFamilyName(): String = PyPsiBundle.message("INSP.interpreter.use.suggested.interpreter") - override fun applyFix(project: Project, descriptor: ProblemDescriptor) { - if (!detectSdkForModulesForJvmIn(project)) { - PyProjectSdkConfiguration.configureSdkUsingCreateSdkInfo(myModule, myCreateSdkInfo) - } - } + @IntentionName + override fun getName(): String = PyPsiBundle.message("INSP.interpreter.use.interpreter", PySdkPopupFactory.shortenNameInPopup(mySdk, 75)) - override fun generatePreview(project: Project, previewDescriptor: ProblemDescriptor): IntentionPreviewInfo { - // The quick fix doesn't change the code and is suggested on a file level - return IntentionPreviewInfo.EMPTY + override fun startInWriteAction(): Boolean = false +} + +private class UseExistingInterpreterFix(existingSdk: Sdk, private val myModule: Module) : UseInterpreterFix(existingSdk) { + override fun applyFix(project: Project, descriptor: ProblemDescriptor) { + PyUiUtil.clearFileLevelInspectionResults(descriptor.psiElement.containingFile) + project.service().scope.launch { + PyProjectSdkConfiguration.setReadyToUseSdk(project, myModule, mySdk) } } +} - private abstract class UseInterpreterFix protected constructor(protected val mySdk: T) : LocalQuickFix { - @IntentionFamilyName - override fun getFamilyName(): @IntentionFamilyName String { - return PyPsiBundle.message("INSP.interpreter.use.suggested.interpreter") - } - - @IntentionName - override fun getName(): @IntentionName String { - return PyPsiBundle.message("INSP.interpreter.use.interpreter", PySdkPopupFactory.Companion.shortenNameInPopup(mySdk!!, 75)) - } - - override fun startInWriteAction(): Boolean { - return false +private class UseDetectedInterpreterFix( + detectedSdk: PyDetectedSdk, + private val myExistingSdks: List, + private val doAssociate: Boolean, + private val myModule: Module, +) : UseInterpreterFix(detectedSdk) { + override fun applyFix(project: Project, descriptor: ProblemDescriptor) { + PyUiUtil.clearFileLevelInspectionResults(descriptor.psiElement.containingFile) + project.service().scope.launch { + mySdk.setupSdk(myModule, myExistingSdks, doAssociate) } } +} - private class UseExistingInterpreterFix(existingSdk: Sdk, private val myModule: Module) : UseInterpreterFix(existingSdk) { - override fun applyFix(project: Project, descriptor: ProblemDescriptor) { - PyUiUtil.clearFileLevelInspectionResults(descriptor.getPsiElement().getContainingFile()) - ApplicationManager.getApplication().executeOnPooledThread( - Runnable { - PyProjectSdkConfiguration.setReadyToUseSdkSync(project, myModule, mySdk) - }) - } - } - - private class UseDetectedInterpreterFix( - detectedSdk: PyDetectedSdk, - private val myExistingSdks: List, - private val doAssociate: Boolean, - private val myModule: Module - ) : UseInterpreterFix(detectedSdk) { - override fun applyFix(project: Project, descriptor: ProblemDescriptor) { - PyUiUtil.clearFileLevelInspectionResults(descriptor.getPsiElement().getContainingFile()) - mySdk.setupSdkLaunch(myModule, myExistingSdks, doAssociate) - } - } - - companion object { - private val NAME: Pattern = Pattern.compile("Python (?\\d\\.\\d+)\\s*(\\((?.+?)\\))?") - - private fun isFileIgnored(pyFile: PyFile): Boolean { - return PyInspectionExtension.EP_NAME.extensionList.stream().anyMatch { ep: PyInspectionExtension? -> - ep!!.ignoreInterpreterWarnings(pyFile) - } - } - } -} \ No newline at end of file +@Service(Service.Level.PROJECT) +private class MyService(val scope: CoroutineScope) \ No newline at end of file diff --git a/python/src/com/jetbrains/python/inspections/interpreter/PyInterpreterInspectionEx.kt b/python/src/com/jetbrains/python/inspections/interpreter/PyInterpreterInspectionEx.kt deleted file mode 100644 index 041eb07f1a93..000000000000 --- a/python/src/com/jetbrains/python/inspections/interpreter/PyInterpreterInspectionEx.kt +++ /dev/null @@ -1,42 +0,0 @@ -// Copyright 2000-2025 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license. -package com.jetbrains.python.inspections.interpreter - -import com.intellij.openapi.components.Service -import com.intellij.openapi.components.service -import com.intellij.openapi.module.Module -import com.intellij.openapi.progress.runBlockingMaybeCancellable -import com.intellij.openapi.project.Project -import com.intellij.python.sdkConfigurator.common.detectSdkForModulesIn -import com.intellij.python.sdkConfigurator.common.enableSDKAutoConfigurator -import com.intellij.util.concurrency.annotations.RequiresBackgroundThread -import com.jetbrains.python.sdk.configuration.CreateSdkInfoWithTool -import com.jetbrains.python.sdk.configuration.PyProjectSdkConfigurationExtension -import kotlinx.coroutines.CoroutineScope -import kotlinx.coroutines.launch -import org.jetbrains.annotations.ApiStatus - -/** - * To be used by [PyInterpreterInspection] only - */ -@ApiStatus.Internal -internal fun detectSdkForModulesForJvmIn(project: Project): Boolean { - if (!enableSDKAutoConfigurator) { - return false - } - project.service().scope.launch { - detectSdkForModulesIn(project) - } - return true -} - -@Service(Service.Level.PROJECT) -private class MyService(val scope: CoroutineScope) - -/** - * To be used by [PyInterpreterInspection] only - */ -@ApiStatus.Internal -@RequiresBackgroundThread -internal fun findAllSortedForModuleForJvm(module: Module): List = runBlockingMaybeCancellable { - PyProjectSdkConfigurationExtension.findAllSortedForModule(module) -}