import com.jetbrains.python.sdk.PythonSdkType; //导入依赖的package包/类
public static Presentation updateSphinxQuickStartRequiredAction(final AnActionEvent e) {
  final Presentation presentation = e.getPresentation();

  final Project project = e.getData(CommonDataKeys.PROJECT);
  if (project != null) {
    Module module = e.getData(LangDataKeys.MODULE);
    if (module == null) {
      Module[] modules = ModuleManager.getInstance(project).getModules();
      module = modules.length == 0 ? null : modules [0];
    }
    if (module != null) {
      Sdk sdk = PythonSdkType.findPythonSdk(module);
      if (sdk != null) {
        PyPackageManager manager = PyPackageManager.getInstance(sdk);
        try {
          final PyPackage sphinx = manager.findPackage("Sphinx", false);
          presentation.setEnabled(sphinx != null);
        }
        catch (ExecutionException ignored) {
        }
      }
    }
  }
  return presentation;
}
 

import com.jetbrains.python.sdk.PythonSdkType; //导入依赖的package包/类
@Nullable
public static AutoImportQuickFix proposeImportFix(final PyElement node, PsiReference reference) {
  final String text = reference.getElement().getText();
  final String refText = reference.getRangeInElement().substring(text); // text of the part we're working with

  // don't propose meaningless auto imports if no interpreter is configured
  final Module module = ModuleUtilCore.findModuleForPsiElement(node);
  if (module != null && PythonSdkType.findPythonSdk(module) == null) {
    return null;
  }

  // don't show auto-import fix if we're trying to reference a variable which is defined below in the same scope
  ScopeOwner scopeOwner = PsiTreeUtil.getParentOfType(node, ScopeOwner.class);
  if (scopeOwner != null && ControlFlowCache.getScope(scopeOwner).containsDeclaration(refText)) {
    return null;
  }

  AutoImportQuickFix fix = addCandidates(node, reference, refText, null);
  if (fix != null) return fix;
  final String packageName = PyPackageAliasesProvider.commonImportAliases.get(refText);
  if (packageName != null) {
    fix = addCandidates(node, reference, packageName, refText);
    if (fix != null) return fix;
  }
  return null;
}
 

import com.jetbrains.python.sdk.PythonSdkType; //导入依赖的package包/类
@Override
public void visitPyTargetExpression(final PyTargetExpression node) {
  String targetName = node.getName();
  if (PyNames.NONE.equals(targetName)) {
    final VirtualFile vfile = node.getContainingFile().getVirtualFile();
    if (vfile != null && !vfile.getUrl().contains("/" + PythonSdkType.SKELETON_DIR_NAME + "/")){
      getHolder().createErrorAnnotation(node, (myOp == Operation.Delete) ? DELETING_NONE : ASSIGNMENT_TO_NONE);
    }
  }
  if (PyNames.DEBUG.equals(targetName)) {
    if (LanguageLevel.forElement(node).isPy3K()) {
      getHolder().createErrorAnnotation(node, "assignment to keyword");
    }
    else {
      getHolder().createErrorAnnotation(node, "cannot assign to __debug__");
    }
  }
}
 

import com.jetbrains.python.sdk.PythonSdkType; //导入依赖的package包/类
@Override
public void visitPyFile(PyFile node) {
  super.visitPyFile(node);
  if (PlatformUtils.isPyCharm()) {
    final Module module = ModuleUtilCore.findModuleForPsiElement(node);
    if (module != null) {
      final Sdk sdk = PythonSdkType.findPythonSdk(module);
      if (sdk == null) {
        registerProblem(node, "No Python interpreter configured for the project", new ConfigureInterpreterFix());
      }
      else if (PythonSdkType.isInvalid(sdk)) {
        registerProblem(node, "Invalid Python interpreter selected for the project", new ConfigureInterpreterFix());
      }
    }
  }
}
 

import com.jetbrains.python.sdk.PythonSdkType; //导入依赖的package包/类
public static boolean isIpythonNewFormat(@NotNull final VirtualFile virtualFile) {
  final Project project = ProjectUtil.guessProjectForFile(virtualFile);
  if (project != null) {
    final Module module = ProjectRootManager.getInstance(project).getFileIndex().getModuleForFile(virtualFile);
    if (module != null) {
      final Sdk sdk = PythonSdkType.findPythonSdk(module);
      if (sdk != null) {
        try {
          final PyPackage ipython = PyPackageManager.getInstance(sdk).findPackage("ipython", true);
          if (ipython != null && VersionComparatorUtil.compare(ipython.getVersion(), "3.0") <= 0) {
            return false;
          }
        }
        catch (ExecutionException ignored) {
        }
      }
    }
  }
  return true;
}
 

import com.jetbrains.python.sdk.PythonSdkType; //导入依赖的package包/类
/**
 * Resolve relative imports from sdk root to the skeleton dir
 */
private void addRelativeImportResultsFromSkeletons(@NotNull final PsiFile foothold) {
  final boolean inSource = FileIndexFacade.getInstance(foothold.getProject()).isInContent(foothold.getVirtualFile());
  if (inSource) return;
  PsiDirectory containingDirectory = foothold.getContainingDirectory();
  if (myRelativeLevel > 0) {
    containingDirectory = ResolveImportUtil.stepBackFrom(foothold, myRelativeLevel);
  }
  if (containingDirectory != null) {
    final QualifiedName containingQName = QualifiedNameFinder.findCanonicalImportPath(containingDirectory, null);
    if (containingQName != null && containingQName.getComponentCount() > 0) {
      final QualifiedName absoluteQName = containingQName.append(myQualifiedName.toString());
      final QualifiedNameResolverImpl absoluteVisitor =
        (QualifiedNameResolverImpl)new QualifiedNameResolverImpl(absoluteQName).fromElement(foothold);

      final Sdk sdk = PythonSdkType.getSdk(foothold);
      if (sdk == null) return;
      final VirtualFile skeletonsDir = PySdkUtil.findSkeletonsDir(sdk);
      if (skeletonsDir == null) return;
      final PsiDirectory directory = myContext.getPsiManager().findDirectory(skeletonsDir);
      final PsiElement psiElement = absoluteVisitor.resolveModuleAt(directory);
      if (psiElement != null)
        myLibResults.add(psiElement);
    }
  }
}
 

import com.jetbrains.python.sdk.PythonSdkType; //导入依赖的package包/类
@Nullable
public static GlobalSearchScope excludeSdkTestsScope(Project project, Sdk sdk) {
  if (sdk != null && sdk.getSdkType() instanceof PythonSdkType) {
    VirtualFile libDir = findLibDir(sdk);
    if (libDir != null) {
      // superset of test dirs found in Python 2.5 to 3.1
      List<VirtualFile> testDirs = findTestDirs(libDir, "test", "bsddb/test", "ctypes/test", "distutils/tests", "email/test",
                                                "importlib/test", "json/tests", "lib2to3/tests", "sqlite3/test", "tkinter/test",
                                                "idlelib/testcode.py");
      if (!testDirs.isEmpty()) {
        GlobalSearchScope scope = buildUnionScope(project, testDirs);
        return GlobalSearchScope.notScope(scope);
      }
    }
  }
  return null;
}
 

import com.jetbrains.python.sdk.PythonSdkType; //导入依赖的package包/类
public static VirtualFile findVirtualEnvLibDir(Sdk sdk) {
  VirtualFile[] classVFiles = sdk.getRootProvider().getFiles(OrderRootType.CLASSES);
  String homePath = sdk.getHomePath();
  if (homePath != null) {
    File root = PythonSdkType.getVirtualEnvRoot(homePath);
    if (root != null) {
      File libRoot = new File(root, "lib");
      File[] versionRoots = libRoot.listFiles();
      if (versionRoots != null && versionRoots.length == 1) {
        libRoot = versionRoots[0];
      }
      for (VirtualFile file : classVFiles) {
        if (FileUtil.pathsEqual(file.getPath(), libRoot.getPath())) {
          return file;
        }
      }
    }
  }
  return null;
}
 

import com.jetbrains.python.sdk.PythonSdkType; //导入依赖的package包/类
@Nullable
public static Sdk findSdkForNonModuleFile(PsiFileSystemItem psiFile) {
  Project project = psiFile.getProject();
  Sdk sdk = null;
  final VirtualFile vfile = psiFile instanceof PsiFile ? ((PsiFile) psiFile).getOriginalFile().getVirtualFile() : psiFile.getVirtualFile();
  if (vfile != null) { // reality
    final ProjectRootManager projectRootManager = ProjectRootManager.getInstance(project);
    sdk = projectRootManager.getProjectSdk();
    if (sdk == null) {
      final List<OrderEntry> orderEntries = projectRootManager.getFileIndex().getOrderEntriesForFile(vfile);
      for (OrderEntry orderEntry : orderEntries) {
        if (orderEntry instanceof JdkOrderEntry) {
          sdk = ((JdkOrderEntry)orderEntry).getJdk();
        }
        else if (orderEntry instanceof ModuleLibraryOrderEntryImpl) {
          sdk = PythonSdkType.findPythonSdk(orderEntry.getOwnerModule());
        }
      }
    }
  }
  return sdk;
}
 

import com.jetbrains.python.sdk.PythonSdkType; //导入依赖的package包/类
@Nullable
private static PyBuiltinCache getBuiltInCache(PyQualifiedExpression element) {
  final PsiElement realContext = PyPsiUtils.getRealContext(element);
  PsiFileSystemItem psiFile = realContext.getContainingFile();
  if (psiFile == null) {
    return null;
  }
  Sdk sdk = PyBuiltinCache.findSdkForFile(psiFile);
  if (sdk != null && sdk.getSdkType() instanceof PythonSdkType) {
    // this case is already handled by PythonBuiltinReferenceResolveProvider
    return null;
  }
  Sdk pythonSdk = PySdkUtils.getPythonSdk(psiFile.getProject());
  return pythonSdk != null
      ? PythonSdkPathCache.getInstance(psiFile.getProject(), pythonSdk).getBuiltins()
      : null;
}
 

import com.jetbrains.python.sdk.PythonSdkType; //导入依赖的package包/类
public void generateBuiltinSkeletons(@NotNull Sdk sdk) throws InvalidSdkException {
  //noinspection ResultOfMethodCallIgnored
  new File(mySkeletonsPath).mkdirs();
  String binaryPath = sdk.getHomePath();
  if (binaryPath == null) throw new InvalidSdkException("Broken home path for " + sdk.getName());

  long startTime = System.currentTimeMillis();
  final ProcessOutput runResult = getProcessOutput(
    new File(binaryPath).getParent(),
    new String[]{
      binaryPath,
      PythonHelpersLocator.getHelperPath(GENERATOR3),
      "-d", mySkeletonsPath, // output dir
      "-b", // for builtins
    },
    PythonSdkType.getVirtualEnvExtraEnv(binaryPath), MINUTE * 5
  );
  runResult.checkSuccess(LOG);
  LOG.info("Rebuilding builtin skeletons took " + (System.currentTimeMillis() - startTime) + " ms");
}
 

import com.jetbrains.python.sdk.PythonSdkType; //导入依赖的package包/类
@NotNull
public static String createVirtualEnv(@NotNull String destinationDir, String version) throws ExecutionException {
  final String condaExecutable = PyCondaPackageService.getCondaExecutable();
  if (condaExecutable == null) throw new PyExecutionException("Cannot find conda", "Conda", Collections.<String>emptyList(), new ProcessOutput());

  final ArrayList<String> parameters = Lists.newArrayList(condaExecutable, "create", "-p", destinationDir,
                                                          "python=" + version, "-y");

  final GeneralCommandLine commandLine = new GeneralCommandLine(parameters);
  final Process process = commandLine.createProcess();
  final CapturingProcessHandler handler = new CapturingProcessHandler(process);
  final ProgressIndicator indicator = ProgressManager.getInstance().getProgressIndicator();
  final ProcessOutput result = handler.runProcessWithProgressIndicator(indicator);
  if (result.isCancelled()) {
    throw new RunCanceledByUserException();
  }
  final int exitCode = result.getExitCode();
  if (exitCode != 0) {
    final String message = StringUtil.isEmptyOrSpaces(result.getStdout()) && StringUtil.isEmptyOrSpaces(result.getStderr()) ?
                           "Permission denied" : "Non-zero exit code";
    throw new PyExecutionException(message, "Conda", parameters, result);
  }
  final String binary = PythonSdkType.getPythonExecutable(destinationDir);
  final String binaryFallback = destinationDir + File.separator + "bin" + File.separator + "python";
  return (binary != null) ? binary : binaryFallback;
}
 

import com.jetbrains.python.sdk.PythonSdkType; //导入依赖的package包/类
@NotNull
public synchronized PyPackageManager forSdk(Sdk sdk) {
  final String name = sdk.getName();
  PyPackageManagerImpl manager = myInstances.get(name);
  if (manager == null) {
    if (PythonSdkType.isRemote(sdk)) {
      manager = new PyRemotePackageManagerImpl(sdk);
    }
    else if (PyCondaPackageManagerImpl.isCondaVEnv(sdk) && PyCondaPackageService.getCondaExecutable() != null) {
      manager = new PyCondaPackageManagerImpl(sdk);
    }
    else {
      manager = new PyPackageManagerImpl(sdk);
    }
    myInstances.put(name, manager);
  }
  return manager;
}
 

import com.jetbrains.python.sdk.PythonSdkType; //导入依赖的package包/类
@Override
public void updateProjectSdk(
    Project project,
    BlazeContext context,
    ProjectViewSet projectViewSet,
    BlazeVersionData blazeVersionData,
    BlazeProjectData blazeProjectData) {
  if (!blazeProjectData.workspaceLanguageSettings.isWorkspaceType(WorkspaceType.PYTHON)) {
    return;
  }
  Sdk currentSdk = ProjectRootManager.getInstance(project).getProjectSdk();
  if (currentSdk != null && currentSdk.getSdkType() instanceof PythonSdkType) {
    return;
  }
  Sdk sdk = getOrCreatePythonSdk();
  if (sdk != null) {
    setProjectSdk(project, sdk);
  }
}
 

import com.jetbrains.python.sdk.PythonSdkType; //导入依赖的package包/类
@Nullable
private static String findErrorSolution(@NotNull PyExecutionException e, @Nullable String cause, @Nullable Sdk sdk) {
  if (cause != null) {
    if (StringUtil.containsIgnoreCase(cause, "SyntaxError")) {
      final LanguageLevel languageLevel = PythonSdkType.getLanguageLevelForSdk(sdk);
      return "Make sure that you use a version of Python supported by this package. Currently you are using Python " +
             languageLevel + ".";
    }
  }

  if (SystemInfo.isLinux && (containsInOutput(e, "pyconfig.h") || containsInOutput(e, "Python.h"))) {
    return "Make sure that you have installed Python development packages for your operating system.";
  }

  if ("pip".equals(e.getCommand()) && sdk != null) {
    return "Try to run this command from the system terminal. Make sure that you use the correct version of 'pip' " +
           "installed for your Python interpreter located at '" + sdk.getHomePath() + "'.";
  }

  return null;
}
 

import com.jetbrains.python.sdk.PythonSdkType; //导入依赖的package包/类
@Override
public void refresh() {
  final Application application = ApplicationManager.getApplication();
  application.invokeLater(new Runnable() {
    @Override
    public void run() {
      application.runWriteAction(new Runnable() {
        @Override
        public void run() {
          final VirtualFile[] files = mySdk.getRootProvider().getFiles(OrderRootType.CLASSES);
          for (VirtualFile file : files) {
            file.refresh(true, true);
          }
        }
      });
      PythonSdkType.getInstance().setupSdkPaths(mySdk);
      clearCaches();
    }
  });
}
 

import com.jetbrains.python.sdk.PythonSdkType; //导入依赖的package包/类
@Nullable
private static String findExecutable(String condaName, @Nullable final VirtualFile condaFolder) {
  if (condaFolder != null) {
    final VirtualFile bin = condaFolder.findChild(SystemInfo.isWindows ? "Scripts" : "bin");
    if (bin != null) {
      String directoryPath = bin.getPath();
      if (!SystemInfo.isWindows) {
        final VirtualFile[] children = bin.getChildren();
        if (children.length == 0) return null;
        directoryPath = children[0].getPath();
      }
      final String executableFile = PythonSdkType.getExecutablePath(directoryPath, condaName);
      if (executableFile != null) {
        return executableFile;
      }
    }
  }
  return null;
}
 

import com.jetbrains.python.sdk.PythonSdkType; //导入依赖的package包/类
/**
 * Patches the command line parameters applying patchers from first to last, and then runs it.
 *
 * @param patchers any number of patchers; any patcher may be null, and the whole argument may be null.
 * @return handler of the started process
 * @throws ExecutionException
 */
protected ProcessHandler startProcess(CommandLinePatcher... patchers) throws ExecutionException {
  GeneralCommandLine commandLine = generateCommandLine(patchers);

  // Extend command line
  PythonRunConfigurationExtensionsManager.getInstance()
    .patchCommandLine(myConfig, getRunnerSettings(), commandLine, getEnvironment().getRunner().getRunnerId());
  Sdk sdk = PythonSdkType.findSdkByPath(myConfig.getInterpreterPath());
  final ProcessHandler processHandler;
  if (PySdkUtil.isRemote(sdk)) {
    PyRemotePathMapper pathMapper = createRemotePathMapper();
    processHandler = createRemoteProcessStarter().startRemoteProcess(sdk, commandLine, myConfig.getProject(), pathMapper);
  }
  else {
    EncodingEnvironmentUtil.setLocaleEnvironmentIfMac(commandLine);
    processHandler = doCreateProcess(commandLine);
    ProcessTerminatedListener.attach(processHandler);
  }

  // attach extensions
  PythonRunConfigurationExtensionsManager.getInstance().attachExtensionsToProcess(myConfig, processHandler, getRunnerSettings());

  return processHandler;
}
 

import com.jetbrains.python.sdk.PythonSdkType; //导入依赖的package包/类
public void testFakeNamedTuple() {
  runTest(new SkeletonsTask() {
    @Override
    protected void runTestOn(@NotNull Sdk sdk) {
      final LanguageLevel languageLevel = PythonSdkType.getLanguageLevelForSdk(sdk);
      // Named tuples have been introduced in Python 2.6
      if (languageLevel.isOlderThan(LanguageLevel.PYTHON26)) {
        return;
      }

      // XXX: A workaround for invalidating VFS cache with the test file copied to our temp directory
      LocalFileSystem.getInstance().refresh(false);

      // Run inspections on code that uses named tuples
      myFixture.configureByFile(getTestName(false) + ".py");
      myFixture.enableInspections(PyUnresolvedReferencesInspection.class);

      edt(new Runnable() {
        @Override
        public void run() {
          myFixture.checkHighlighting(true, false, false);
        }
      });
    }
  });
}
 

import com.jetbrains.python.sdk.PythonSdkType; //导入依赖的package包/类
Process createCheckProcess(@NotNull final Project project, @NotNull final String executablePath) throws ExecutionException {
  final Sdk sdk = PythonSdkType.findPythonSdk(ModuleManager.getInstance(project).getModules()[0]);
  PyEduPluginConfigurator configurator = new PyEduPluginConfigurator();
  String testsFileName = configurator.getTestFileName();
  if (myTask instanceof TaskWithSubtasks) {
    testsFileName = FileUtil.getNameWithoutExtension(testsFileName);
    int index = ((TaskWithSubtasks)myTask).getActiveSubtaskIndex();
    testsFileName += EduNames.SUBTASK_MARKER + index + "." + FileUtilRt.getExtension(configurator.getTestFileName());
  }
  final File testRunner = new File(myTaskDir.getPath(), testsFileName);
  myCommandLine = new GeneralCommandLine();
  myCommandLine.withWorkDirectory(myTaskDir.getPath());
  final Map<String, String> env = myCommandLine.getEnvironment();

  final VirtualFile courseDir = project.getBaseDir();
  if (courseDir != null) {
    env.put(PYTHONPATH, courseDir.getPath());
  }
  if (sdk != null) {
    String pythonPath = sdk.getHomePath();
    if (pythonPath != null) {
      myCommandLine.setExePath(pythonPath);
      myCommandLine.addParameter(testRunner.getPath());
      myCommandLine.addParameter(FileUtil.toSystemDependentName(executablePath));
      return myCommandLine.createProcess();
    }
  }
  return null;
}