Java PythonLanguage类代码示例

import com.jetbrains.python.PythonLanguage; //导入依赖的package包/类
@NotNull
private static Course getCourse(@NotNull Project project, @NotNull CCNewProjectPanel settingsPanel) {
  final Course course = new Course();
  String name = settingsPanel.getName();
  course.setName(name);
  course.setAuthorsAsString(settingsPanel.getAuthors());
  course.setDescription(settingsPanel.getDescription());

  String language = PythonLanguage.getInstance().getID();
  course.setLanguage(language);
  course.setCourseMode(CCUtils.COURSE_MODE);

  StudyTaskManager.getInstance(project).setCourse(course);
  StudyUtils.registerStudyToolWindow(course, project);
  return course;
}
 

import com.jetbrains.python.PythonLanguage; //导入依赖的package包/类
private void addPreColonStatements() {
  extend(
    CompletionType.BASIC,
    psiElement()
      .withLanguage(PythonLanguage.getInstance())
      .and(FIRST_ON_LINE)
        //.andNot(RIGHT_AFTER_COLON)
      .andNot(IN_IMPORT_STMT)
      .andNot(IN_PARAM_LIST)
      .andNot(IN_ARG_LIST)
      .andNot(BEFORE_COND)
      .andNot(AFTER_QUALIFIER).andNot(IN_STRING_LITERAL)
    ,
    new CompletionProvider<CompletionParameters>() {
      protected void addCompletions(
        @NotNull final CompletionParameters parameters, final ProcessingContext context, @NotNull final CompletionResultSet result
      ) {
        putKeywords(result, TailType.NONE, PyNames.DEF, PyNames.CLASS, PyNames.FOR, PyNames.IF, PyNames.WHILE, PyNames.WITH);
        putKeywords(result, TailType.CASE_COLON, PyNames.TRY);
      }
    }
  );
}
 

import com.jetbrains.python.PythonLanguage; //导入依赖的package包/类
private void addStatements() {
  PsiElementPattern.Capture<PsiElement> inStatement = psiElement()
    .withLanguage(PythonLanguage.getInstance())
    .and(IN_BEGIN_STMT)
    .andNot(IN_IMPORT_STMT)
    .andNot(IN_PARAM_LIST)
    .andNot(IN_ARG_LIST)
    .andNot(BEFORE_COND)
    .andNot(AFTER_QUALIFIER);

  extend(
    CompletionType.BASIC,
    inStatement,
    new CompletionProvider<CompletionParameters>() {
      protected void addCompletions(
        @NotNull final CompletionParameters parameters, final ProcessingContext context, @NotNull final CompletionResultSet result
      ) {
        putKeywords(result, TailType.SPACE, PyNames.ASSERT, PyNames.DEL, PyNames.EXEC, PyNames.FROM, PyNames.IMPORT, PyNames.RAISE);
        putKeywords(result, TailType.NONE, PyNames.PASS);
      }
    }
  );

  extend(CompletionType.BASIC, inStatement.andNot(PY3K), new PyKeywordCompletionProvider(TailType.SPACE, PyNames.PRINT));
}
 

import com.jetbrains.python.PythonLanguage; //导入依赖的package包/类
public PySpecialMethodNamesCompletionContributor() {
  extend(
    CompletionType.BASIC,
    psiElement()
      .withLanguage(PythonLanguage.getInstance())
      .and(psiElement().inside(psiElement(PyFunction.class).inside(psiElement(PyClass.class))))
      .and(psiElement().afterLeaf("def"))
   ,
    new CompletionProvider<CompletionParameters>() {
      protected void addCompletions(
        @NotNull final CompletionParameters parameters, final ProcessingContext context, @NotNull final CompletionResultSet result
      ) {
        LanguageLevel languageLevel = LanguageLevel.forElement(parameters.getOriginalFile());
        for (Map.Entry<String, PyNames.BuiltinDescription> entry: PyNames.getBuiltinMethods(languageLevel).entrySet()) {
          LookupElementBuilder item = LookupElementBuilder
            .create(entry.getKey() + entry.getValue().getSignature())
            .bold()
            .withTypeText("predefined")
            .withIcon(PythonIcons.Python.Nodes.Cyan_dot)
          ;
          result.addElement(TailTypeDecorator.withTail(item, TailType.CASE_COLON));
        }
      }
    }
  );
}
 

import com.jetbrains.python.PythonLanguage; //导入依赖的package包/类
@Override
public Comparable weigh(@NotNull final LookupElement element, @NotNull final CompletionLocation location) {
  if (!PsiUtilCore.findLanguageFromElement(location.getCompletionParameters().getPosition()).isKindOf(PythonLanguage.getInstance())) {
    return 0;
  }

  final String name = element.getLookupString();
  final LookupElementPresentation presentation = LookupElementPresentation.renderElement(element);
  // move dict keys to the top
  if ("dict key".equals(presentation.getTypeText())) {
    return element.getLookupString().length();
  }
  if (name.startsWith(DOUBLE_UNDER)) {
    if (name.endsWith(DOUBLE_UNDER)) return -10; // __foo__ is lowest
    else return -5; // __foo is lower than normal
  }
  return 0; // default
}
 

import com.jetbrains.python.PythonLanguage; //导入依赖的package包/类
@Override
public void collectRefElements(PsiElement psiElement,
                               @Nullable RenameProcessor renameProcessor,
                               @NotNull String newName,
                               Collection<PsiElement> elementsToInvert) {
  final Collection<PsiReference> refs = ReferencesSearch.search(psiElement).findAll();

  for (PsiReference ref : refs) {
    final PsiElement refElement = ref.getElement();
    final PsiElement elementToInvert = getElementToInvert(psiElement, refElement);
    if (elementToInvert != null) {
      elementsToInvert.add(elementToInvert);
    }
    else {
      ContainerUtil.addIfNotNull(elementsToInvert, getForeignElementToInvert(psiElement, refElement, PythonLanguage.getInstance()));
    }
  }
}
 

import com.jetbrains.python.PythonLanguage; //导入依赖的package包/类
private void doTest(String newName) {
  final String testName = getTestName(false);
  final String beforeName = testName + ".before.py";
  final String afterName = testName + ".after.py";
  final String dir = "refactoring/extractmethod/";

  myFixture.configureByFile(dir + beforeName);
  final RefactoringSupportProvider provider = LanguageRefactoringSupport.INSTANCE.forLanguage(PythonLanguage.getInstance());
  assertNotNull(provider);
  final RefactoringActionHandler handler = provider.getExtractMethodHandler();
  assertNotNull(handler);
  System.setProperty(PyExtractMethodUtil.NAME, newName);
  try {
    refactorUsingHandler(handler);
  }
  finally {
    System.clearProperty(PyExtractMethodUtil.NAME);
  }
  myFixture.checkResultByFile(dir + afterName);
}
 

import com.jetbrains.python.PythonLanguage; //导入依赖的package包/类
public void testResultExceedsRightMargin() {
  final CodeStyleSettings settings = getCodeStyleSettings();
  final CommonCodeStyleSettings commonSettings = settings.getCommonSettings(PythonLanguage.getInstance());

  final int oldRightMargin = settings.getRightMargin(PythonLanguage.getInstance());
  final boolean oldWrapLongLines = commonSettings.WRAP_LONG_LINES;

  settings.setRightMargin(PythonLanguage.getInstance(), 80);
  commonSettings.WRAP_LONG_LINES = true;
  try {
    doTest();
  }
  finally {
    commonSettings.WRAP_LONG_LINES = oldWrapLongLines;
    settings.setRightMargin(PythonLanguage.getInstance(), oldRightMargin);
  }
}
 

import com.jetbrains.python.PythonLanguage; //导入依赖的package包/类
private void updateToolWindow(@NotNull Project project, @NotNull ToolWindow toolWindow) {
    ContentManager contentManager = toolWindow.getContentManager();
    contentManager.removeAllContents(true);

    FileEditorManager fileEditorManager = FileEditorManager.getInstance(project);
    Editor selectedEditor = fileEditorManager.getSelectedTextEditor();
    if (selectedEditor == null) return;
    PsiFile psiFile = PsiDocumentManager.getInstance(project).getPsiFile(selectedEditor.getDocument());
    if (psiFile == null || !psiFile.getLanguage().equals(PythonLanguage.INSTANCE)) {
        return;
    }

    FileEditor fileEditor = fileEditorManager.getSelectedEditor(psiFile.getVirtualFile());
    StructureView structureView = new PTestStructureViewFactory().getStructureViewBuilder(psiFile).createStructureView(fileEditor, project);

    Content content = ContentFactory.SERVICE.getInstance().createContent(structureView.getComponent(), "", false);
    contentManager.addContent(content);
}
 

import com.jetbrains.python.PythonLanguage; //导入依赖的package包/类
protected void setVersion(Course course, CCNewProjectPanel panel) {
  String version = panel.getLanguageVersion();
  String language = PythonLanguage.getInstance().getID();
  if (version != null && !ALL_VERSIONS.equals(version)) {
    language += " " + version;
  }
  course.setLanguage(language);
}
 

import com.jetbrains.python.PythonLanguage; //导入依赖的package包/类
private void addBreak() {
  extend(
    CompletionType.BASIC, psiElement()
    .withLanguage(PythonLanguage.getInstance())
    .and(IN_BEGIN_STMT)
    .andNot(AFTER_QUALIFIER)
    .andNot(IN_PARAM_LIST)
    .andNot(IN_ARG_LIST)
    .and(IN_LOOP)
    ,
    new PyKeywordCompletionProvider(TailType.NONE, PyNames.BREAK)
  );
}
 

import com.jetbrains.python.PythonLanguage; //导入依赖的package包/类
private void addContinue() {
  extend(
    CompletionType.BASIC, psiElement()
    .withLanguage(PythonLanguage.getInstance())
    .and(IN_BEGIN_STMT)
    .andNot(AFTER_QUALIFIER)
    .andNot(IN_PARAM_LIST)
    .andNot(IN_ARG_LIST)
    .andNot(IN_FINALLY_NO_LOOP)
    .and(IN_LOOP)
    ,
    new PyKeywordCompletionProvider(TailType.NONE, PyNames.CONTINUE)
  );
}
 

import com.jetbrains.python.PythonLanguage; //导入依赖的package包/类
private void addWithinIf() {
  extend(
    CompletionType.BASIC, psiElement()
    .withLanguage(PythonLanguage.getInstance())
    .and(FIRST_ON_LINE)
    .andOr(IN_IF_BODY, AFTER_IF)
    .andNot(AFTER_QUALIFIER).andNot(IN_STRING_LITERAL)
    ,
    new PyKeywordCompletionProvider(TailType.NONE, PyUnindentingInsertHandler.INSTANCE, PyNames.ELIF));
}
 

import com.jetbrains.python.PythonLanguage; //导入依赖的package包/类
private void addElse() {
  extend(
    CompletionType.BASIC, psiElement()
    .withLanguage(PythonLanguage.getInstance())
    .and(FIRST_ON_LINE)
    .andOr(IN_COND_STMT, IN_EXCEPT_BODY, AFTER_COND_STMT_NO_ELSE, AFTER_LOOP_NO_ELSE, AFTER_EXCEPT)
    .andNot(AFTER_QUALIFIER).andNot(IN_STRING_LITERAL)
    ,
    new PyKeywordCompletionProvider(TailType.CASE_COLON, PyUnindentingInsertHandler.INSTANCE, PyNames.ELSE));
}
 

import com.jetbrains.python.PythonLanguage; //导入依赖的package包/类
private void addInfixOperators() {
  extend(
    CompletionType.BASIC, psiElement()
    .withLanguage(PythonLanguage.getInstance())
    .andNot(IN_COMMENT)
    .andNot(BEFORE_COND)
    .andNot(IN_IMPORT_STMT) // expressions there are not logical anyway
    .andNot(IN_PARAM_LIST)
    .andNot(AFTER_QUALIFIER).
      andNot(IN_STRING_LITERAL).and(IN_BEGIN_STMT)
    ,
    new PyKeywordCompletionProvider(PyNames.AND, PyNames.OR, PyNames.IS, PyNames.IN)
  );
}