👨‍💻 update all deprecated code

Author: Mathieu

src/main/kotlin/debugattach/MayaAttachDebuggerProvider.kt

@@ -1,7 +1,5 @@
 package debugattach
 
-import settings.ApplicationSettings
-import utils.pathForPid
 import com.intellij.execution.process.ProcessInfo
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.projectRoots.Sdk
@@ -10,7 +8,8 @@ import com.intellij.openapi.util.Key
 import com.intellij.openapi.util.UserDataHolder
 import com.intellij.xdebugger.attach.*
 import com.jetbrains.python.sdk.PythonSdkType
-import com.jetbrains.python.sdk.PythonSdkUtil
+import settings.ApplicationSettings
+import utils.pathForPid
 import javax.swing.Icon
 
 private val mayaPathsKey = Key<MutableMap<Int, String>>("mayaPathsMap")
@@ -21,31 +20,32 @@ class MayaAttachDebuggerProvider : XAttachDebuggerProvider {
     }
 
     override fun getAvailableDebuggers(project: Project, attachHost: XAttachHost, processInfo: ProcessInfo, userData: UserDataHolder): MutableList<XAttachDebugger> {
-        if (!processInfo.executableName.toLowerCase().contains("maya")) return mutableListOf()
+        if (!processInfo.executableName.lowercase().contains("maya")) return mutableListOf()
 
         val exePath = processInfo.executableCannonicalPath.let {
             if (it.isPresent) it.get() else pathForPid(processInfo.pid) ?: return mutableListOf()
-        }.toLowerCase()
+        }.lowercase()
 
         val currentSdk = ApplicationSettings.INSTANCE.mayaSdkMapping.values.firstOrNull {
-            exePath.contains(it.mayaPath.toLowerCase())
+            exePath.contains(it.mayaPath.lowercase())
         } ?: return mutableListOf()
 
         val mayaPathMap = userData.getUserData(mayaPathsKey) ?: mutableMapOf()
         mayaPathMap[processInfo.pid] = currentSdk.mayaPath
         userData.putUserData(mayaPathsKey, mayaPathMap)
 
-        PythonSdkUtil.findSdkByPath(currentSdk.mayaPyPath)?.let {
-            return mutableListOf(MayaAttachDebugger(it, currentSdk))
+        val sdk = currentSdk.sdk
+        if (sdk != null) {
+            return mutableListOf(MayaAttachDebugger(sdk, currentSdk))
         }
-
         return mutableListOf()
     }
 
     override fun isAttachHostApplicable(attachHost: XAttachHost): Boolean = attachHost is LocalAttachHost
 }
 
 private class MayaAttachDebugger(sdk: Sdk, private val mayaSdk: ApplicationSettings.SdkInfo) : XAttachDebugger {
+    private val mySdk: Sdk = sdk
     private val mySdkHome: String? = sdk.homePath
     private val myName: String = "${PythonSdkType.getInstance().getVersionString(sdk)} ($mySdkHome)"
 
@@ -54,7 +54,7 @@ private class MayaAttachDebugger(sdk: Sdk, private val mayaSdk: ApplicationSetti
     }
 
     override fun attachDebugSession(project: Project, attachHost: XAttachHost, processInfo: ProcessInfo) {
-        val runner = MayaAttachToProcessDebugRunner(project, processInfo.pid, mySdkHome, mayaSdk)
+        val runner = MayaAttachToProcessDebugRunner(project, processInfo.pid, mySdk, mayaSdk)
         runner.launch()
     }
 }
@@ -69,18 +69,10 @@ private class MayaAttachGroup : XAttachProcessPresentationGroup {
         return mayaPaths[processInfo.pid] ?: processInfo.executableDisplayName
     }
 
-    override fun getProcessDisplayText(project: Project, info: ProcessInfo, userData: UserDataHolder): String {
-        return getItemDisplayText(project, info, userData)
-    }
-
     override fun getItemIcon(project: Project, processInfo: ProcessInfo, userData: UserDataHolder): Icon {
         return IconLoader.getIcon("/icons/MayaCharm_ToolWindow.png", this::class.java)
     }
 
-    override fun getProcessIcon(project: Project, info: ProcessInfo, userData: UserDataHolder): Icon {
-        return getItemIcon(project, info, userData)
-    }
-
     override fun getGroupName(): String {
         return "Maya"
     }

src/main/kotlin/debugattach/MayaAttachToProcessCliState.kt

@@ -6,6 +6,7 @@ import com.intellij.execution.process.ProcessHandler
 import com.intellij.execution.runners.ExecutionEnvironment
 import com.intellij.execution.runners.ExecutionEnvironmentBuilder
 import com.intellij.openapi.project.Project
+import com.intellij.openapi.projectRoots.Sdk
 import com.jetbrains.python.PythonHelper
 import com.jetbrains.python.debugger.attach.PyAttachToProcessCommandLineState
 import com.jetbrains.python.run.PythonConfigurationType
@@ -19,7 +20,7 @@ import java.nio.file.Paths
 class MayaAttachToProcessCliState(runConfig: PythonRunConfiguration, env: ExecutionEnvironment) :
     PythonScriptCommandLineState(runConfig, env) {
     companion object {
-        fun create(project: Project, sdkPath: String, port: Int, pid: Int, mayaSdk: ApplicationSettings.SdkInfo): MayaAttachToProcessCliState {
+        fun create(project: Project, sdk: Sdk, port: Int, pid: Int, mayaSdk: ApplicationSettings.SdkInfo): MayaAttachToProcessCliState {
             val conf =
                 PythonConfigurationType.getInstance().factory.createTemplateConfiguration(project) as PythonRunConfiguration
             val env = ExecutionEnvironmentBuilder.create(project, DefaultDebugExecutor.getDebugExecutorInstance(), conf)
@@ -32,7 +33,7 @@ class MayaAttachToProcessCliState(runConfig: PythonRunConfiguration, env: Execut
             PythonEnvUtil.addToPythonPath(conf.envs, listOf(env.project.basePath))
 
             conf.workingDirectory = env.project.basePath
-            conf.sdkHome = sdkPath
+            conf.sdkHome = sdk.homePath
             conf.isUseModuleSdk = false
             conf.scriptName = Paths.get(projectSettings.pythonCachePath.toString(), "attach_pydevd.py").toString()
             conf.scriptParameters = "--port $port --pid $pid --mcPort $mcPort --pydevPath \"$debuggerPath\""

src/main/kotlin/debugattach/MayaAttachToProcessDebugRunner.kt

@@ -3,6 +3,7 @@ package debugattach
 import MayaBundle as Loc
 import com.intellij.openapi.fileEditor.FileDocumentManager
 import com.intellij.openapi.project.Project
+import com.intellij.openapi.projectRoots.Sdk
 import com.intellij.openapi.ui.Messages
 import com.intellij.openapi.util.IconLoader
 import com.intellij.xdebugger.XDebugProcess
@@ -20,9 +21,9 @@ import java.net.ServerSocket
 class MayaAttachToProcessDebugRunner(
     private val project: Project,
     private val pid: Int,
-    private val sdkPath: String?,
+    private val sdk: Sdk?,
     private val mayaSdk: ApplicationSettings.SdkInfo
-) : PyAttachToProcessDebugRunner(project, pid, sdkPath) {
+) : PyAttachToProcessDebugRunner(project, pid, sdk) {
 
     override fun launch(): XDebugSession? {
         FileDocumentManager.getInstance().saveAllDocuments()
@@ -46,7 +47,7 @@ class MayaAttachToProcessDebugRunner(
 
     private fun launchRemoteDebugServer(): XDebugSession? {
         val serverSocket = getDebuggerSocket() ?: return null
-        val state = MayaAttachToProcessCliState.create(project, sdkPath!!, serverSocket.localPort, pid, mayaSdk)
+        val state = MayaAttachToProcessCliState.create(project, sdk!!, serverSocket.localPort, pid, mayaSdk)
         val result = state.execute(state.environment.executor, this)
 
         val icon = IconLoader.getIcon("/icons/MayaCharm_ToolWindow.png", this::class.java)

src/main/kotlin/flavors/MayaSdkFlavor.kt

@@ -1,53 +1,26 @@
 package flavors
 
-import com.intellij.openapi.projectRoots.Sdk
 import com.intellij.openapi.util.io.FileUtil
 import com.intellij.openapi.vfs.VirtualFile
-import com.jetbrains.python.psi.LanguageLevel
+import com.jetbrains.python.sdk.flavors.PyFlavorData
 import com.jetbrains.python.sdk.flavors.PythonFlavorProvider
 import com.jetbrains.python.sdk.flavors.PythonSdkFlavor
-import icons.PythonIcons
+import com.jetbrains.python.psi.icons.PythonPsiApiIcons
 import java.io.File
 import javax.swing.Icon
 
-class MayaSdkFlavor private constructor() : PythonSdkFlavor() {
-    override fun isValidSdkHome(path: String): Boolean {
-        val file = File(path)
-        return file.isFile && isValidSdkPath(file) || isMayaFolder(file)
-    }
-
-    override fun isValidSdkPath(file: File): Boolean {
-        val name = FileUtil.getNameWithoutExtension(file).toLowerCase()
-        return name.startsWith("mayapy")
-    }
-
-    override fun getVersionOption(): String {
-        return "--version"
-    }
-
-    override fun getLanguageLevelFromVersionString(version: String?): LanguageLevel {
-        if (version != null && version.startsWith(verStringPrefix)) {
-            return LanguageLevel.fromPythonVersion(version.substring(verStringPrefix.length))
-                ?: LanguageLevel.getDefault()
-        }
-        return LanguageLevel.getDefault()
-    }
-
-    override fun getLanguageLevel(sdk: Sdk): LanguageLevel {
-        return getLanguageLevelFromVersionString(sdk.versionString)
-    }
-
-    override fun getLanguageLevel(sdkHome: String): LanguageLevel {
-        val version = getVersionString(sdkHome)
-        return getLanguageLevelFromVersionString(version)
+class MayaSdkFlavor private constructor() : PythonSdkFlavor<PyFlavorData.Empty>() {
+    override fun isValidSdkPath(pathStr: String): Boolean {
+        val name = FileUtil.getNameWithoutExtension(pathStr).lowercase()
+        return name.startsWith("mayapy") || isMayaFolder(File(pathStr))
     }
 
     override fun getName(): String {
         return "Maya Python"
     }
 
     override fun getIcon(): Icon {
-        return PythonIcons.Python.Python
+        return PythonPsiApiIcons.Python
     }
 
     override fun getSdkPath(path: VirtualFile): VirtualFile? {
@@ -69,5 +42,5 @@ class MayaSdkFlavor private constructor() : PythonSdkFlavor() {
 }
 
 class MayaFlavorProvider : PythonFlavorProvider {
-    override fun getFlavor(platformIndependent: Boolean): PythonSdkFlavor = MayaSdkFlavor.INSTANCE
+    override fun getFlavor(platformIndependent: Boolean): PythonSdkFlavor<PyFlavorData.Empty> = MayaSdkFlavor.INSTANCE
 }

src/main/kotlin/logconsole/LogWindow.kt

@@ -17,7 +17,7 @@ class LogWindow : ToolWindowFactory, DumbAware {
         val port = ProjectSettings.getInstance(project).selectedSdk?.port ?: 4434
 
         val contentManager = toolWindow.contentManager
-        val contentFactory = ContentFactory.SERVICE.getInstance()
+        val contentFactory = ContentFactory.getInstance()
         val mayaLogPath = PathManager.getPluginTempPath() + String.format(LOG_FILENAME_STRING, port)
 
         val console = LogConsole(

src/main/kotlin/mayacomms/MayaCommandInterface.kt

@@ -5,7 +5,7 @@ import resources.PythonStrings
 import com.intellij.notification.Notifications
 import com.intellij.openapi.application.PathManager
 import com.intellij.util.io.createDirectories
-import com.intellij.util.io.exists
+import kotlin.io.path.exists
 import java.io.*
 import java.net.Socket
 import java.nio.file.Paths

src/main/kotlin/mayacomms/MayaFunctions.kt

@@ -1,7 +1,7 @@
 package mayacomms
 
 import com.intellij.openapi.util.SystemInfo
-import com.intellij.util.io.exists
+import kotlin.io.path.exists
 import java.nio.file.Paths
 
 private const val mayaExecutableNameWin = "maya.exe"

src/main/kotlin/run/MayaCharmDebugRunner.kt

@@ -14,7 +14,6 @@ import com.intellij.xdebugger.XDebugSession
 import com.intellij.xdebugger.XDebuggerManager
 import com.jetbrains.python.debugger.PyDebugRunner
 import com.jetbrains.python.debugger.PyLocalPositionConverter
-import com.jetbrains.python.sdk.PythonSdkUtil
 import debugattach.MayaAttachToProcessCliState
 import java.net.ServerSocket
 
@@ -46,15 +45,15 @@ class MayaCharmDebugRunner : PyDebugRunner() {
             return
         }
 
-        val sdk = PythonSdkUtil.findSdkByPath(sdkInfo.mayaPyPath)
+        val sdk = sdkInfo.sdk
         if (sdk == null) {
             MayaNotifications.mayaInstanceNotFound(sdkInfo.mayaPath, environment.project)
             return
         }
 
         val serverSocket = ServerSocket(0) // port 0 forces the ServerSocket to choose its own free port
         val cliState =
-            MayaAttachToProcessCliState.create(environment.project, sdk.homePath!!, serverSocket.localPort, process.pid, sdkInfo)
+            MayaAttachToProcessCliState.create(environment.project, sdk, serverSocket.localPort, process.pid, sdkInfo)
         val executionResult = cliState.execute(environment.executor, this)
 
         XDebuggerManager.getInstance(environment.project).startSession(environment, object : XDebugProcessStarter() {

src/main/kotlin/settings/ApplicationSettings.kt

@@ -4,6 +4,7 @@ import mayacomms.mayaFromMayaPy
 import mayacomms.mayaPyExecutableName
 
 import com.intellij.openapi.components.*
+import com.intellij.openapi.projectRoots.Sdk
 import com.jetbrains.python.sdk.PythonSdkUtil
 import java.util.*
 
@@ -19,6 +20,9 @@ class ApplicationSettings : PersistentStateComponent<ApplicationSettings.State>
     data class SdkInfo(var mayaPyPath: String = "", var port: Int = -1) {
         val mayaPath: String
             get() = mayaFromMayaPy(mayaPyPath) ?: ""
+
+        val sdk: Sdk?
+            get() = INSTANCE.findByPath(mayaPyPath)
     }
 
     data class State(var mayaSdkMapping: SdkPortMap = mutableMapOf())
@@ -33,14 +37,23 @@ class ApplicationSettings : PersistentStateComponent<ApplicationSettings.State>
     init {
         val mayaSdk =
             PythonSdkUtil.getAllLocalCPythons().filter { it.homePath?.endsWith(mayaPyExecutableName) ?: false }
-        val homePaths = mayaSdk.map { it.homePath!! }
 
-        for (path in homePaths) {
+        for (sdk in mayaSdk) {
+            val path = sdk.homePath!!
             mayaSdkMapping[path] = SdkInfo(path, -1)
         }
         assignEmptyPorts()
     }
 
+    fun findByPath(path: String): Sdk? {
+        for (sdk in PythonSdkUtil.getAllSdks()) {
+            if (sdk.homePath.equals(path)) {
+                return sdk
+            }
+        }
+        return null
+    }
+
     var mayaSdkMapping: SdkPortMap
         get() = myState.mayaSdkMapping
         set(value) {
@@ -54,11 +67,11 @@ class ApplicationSettings : PersistentStateComponent<ApplicationSettings.State>
     override fun loadState(state: State) {
         val mayaPySdks =
             PythonSdkUtil.getAllLocalCPythons().filter { x -> x.homePath?.endsWith(mayaPyExecutableName) ?: false }
-        val homePaths = mayaPySdks.map { it.homePath!! }
 
         mayaSdkMapping.clear()
 
-        for (path in homePaths) {
+        for (sdk in mayaPySdks) {
+            val path = sdk.homePath!!
             if (state.mayaSdkMapping.containsKey(path)) {
                 mayaSdkMapping[path] = state.mayaSdkMapping[path]!!
                 continue
@@ -82,8 +95,11 @@ class ApplicationSettings : PersistentStateComponent<ApplicationSettings.State>
             mayaSdkMapping.remove(path)
         }
 
-        for (path in toAdd) {
-            mayaSdkMapping[path] = SdkInfo(path, -1)
+        for (sdk in mayaSdk) {
+            val path = sdk.homePath!!
+            if (path in toAdd) {
+                mayaSdkMapping[path] = SdkInfo(path, -1)
+            }
         }
         assignEmptyPorts()
     }

src/main/kotlin/settings/ui/SdkTable.kt

@@ -53,10 +53,10 @@ class SdkTablePanel(private val project: Project) :
         val selectedSdk = dialog.getOrCreateSdk() ?: return null
         SdkConfigurationUtil.addSdk(selectedSdk)
 
-        selectedSdk.homePath?.let {
+        selectedSdk.let {
             val unusedPort = ApplicationSettings.INSTANCE.getUnusedPort()
             onChanged(this)
-            return ApplicationSettings.SdkInfo(it, unusedPort)
+            return ApplicationSettings.SdkInfo(it.homePath!!, unusedPort)
         }
         return null
     }
@@ -69,7 +69,7 @@ class SdkTablePanel(private val project: Project) :
         ) == 0
 
         if (result) {
-            val sdk = PythonSdkUtil.findSdkByPath(sdkInfo.mayaPyPath) ?: return false
+            val sdk = sdkInfo.sdk ?: return false
             SdkConfigurationUtil.removeSdk(sdk)
         }
         onChanged(this)