Java PyFile类代码示例

import com.jetbrains.python.psi.PyFile; //导入依赖的package包/类
@Nullable
@Override
public PsiElement getTarget(@NotNull DataContext dataContext) {
  Project project = CommonDataKeys.PROJECT.getData(dataContext);
  if (project == null) return null;

  PsiElement element = CommonDataKeys.PSI_ELEMENT.getData(dataContext);
  if (element == null) {
    Editor editor = CommonDataKeys.EDITOR.getData(dataContext);
    if (editor != null) {
      PsiFile file = PsiDocumentManager.getInstance(project).getPsiFile(editor.getDocument());
      if (file == null) return null;

      element = TargetElementUtil.findTargetElement(editor, TargetElementUtil.ELEMENT_NAME_ACCEPTED |
                                                            TargetElementUtil.REFERENCED_ELEMENT_ACCEPTED |
                                                            TargetElementUtil.LOOKUP_ITEM_ACCEPTED);
      if (element instanceof PyFunction || element instanceof PyClass || element instanceof PyFile) {
        return element;
      }

      element = file.findElementAt(editor.getCaretModel().getOffset());
    }
  }
  return PsiTreeUtil.getNonStrictParentOfType(element, PyFunction.class, PyClass.class, PyFile.class);
}
 

import com.jetbrains.python.psi.PyFile; //导入依赖的package包/类
@Override
protected Collection<PyCustomMember> getMembersByQName(PyFile module, String qName) {
 final PyFile moduleSkeleton = PyUserSkeletonsUtil.getUserSkeletonForModuleQName(qName, module);
  if (moduleSkeleton != null) {
    final List<PyCustomMember> results = new ArrayList<PyCustomMember>();
    for (PyElement element : moduleSkeleton.iterateNames()) {
      if (element instanceof PsiFileSystemItem) {
        continue;
      }
      final String name = element.getName();
      if (name != null) {
        results.add(new PyCustomMember(name, element));
      }
    }
    return results;
  }
  return Collections.emptyList();
}
 

import com.jetbrains.python.psi.PyFile; //导入依赖的package包/类
@NotNull
@Override
public Collection<PyCustomMember> getMembers(PyClassType classType, PsiElement location) {
  PyClass clazz = classType.getPyClass();
  final String qualifiedName = clazz.getQualifiedName();
  if ("socket._socketobject".equals(qualifiedName)) {
    final PyFile socketFile = (PyFile)clazz.getContainingFile();
    List<PyCustomMember> socketMembers = socketFile.getUserData(mySocketMembersKey);
    if (socketMembers == null) {
      socketMembers = calcSocketMembers(socketFile);
      socketFile.putUserData(mySocketMembersKey, socketMembers);
    }
    return socketMembers;
  }
  return Collections.emptyList();
}
 

import com.jetbrains.python.psi.PyFile; //导入依赖的package包/类
public DFAMap<ScopeVariable> fun(final DFAMap<ScopeVariable> map, final Instruction instruction) {
  final PsiElement element = instruction.getElement();
  if (element == null || !((PyFile) element.getContainingFile()).getLanguageLevel().isPy3K()){
    return processReducedMap(map, instruction, element);
  }
  // Scope reduction
  final DFAMap<ScopeVariable> reducedMap = new DFAMap<ScopeVariable>();
  for (Map.Entry<String, ScopeVariable> entry : map.entrySet()) {
    final ScopeVariable value = entry.getValue();
    // Support PEP-3110. (PY-1408)
    if (value.isParameter()){
      final PsiElement declaration = value.getDeclarations().iterator().next();
      final PyExceptPart exceptPart = PyExceptPartNavigator.getPyExceptPartByTarget(declaration);
      if (exceptPart != null){
        if (!PsiTreeUtil.isAncestor(exceptPart, element, false)){
          continue;
        }
      }
    } 
    reducedMap.put(entry.getKey(), value);
  }

  return processReducedMap(reducedMap, instruction, element);
}
 

import com.jetbrains.python.psi.PyFile; //导入依赖的package包/类
public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) {
  if (!(file instanceof PyFile)) {
    return false;
  }

  PsiElement element = file.findElementAt(editor.getCaretModel().getOffset());
  PyBinaryExpression binaryExpression = PsiTreeUtil.getParentOfType(element, PyBinaryExpression.class, false);
  while (binaryExpression != null) {
    PyElementType operator = binaryExpression.getOperator();
    if (FLIPPED_OPERATORS.containsKey(operator)) {
      String operatorText = binaryExpression.getPsiOperator().getText();
      String flippedOperatorText = FLIPPED_OPERATORS.get(operator);
      if (flippedOperatorText.equals(operatorText)) {
        setText(PyBundle.message("INTN.flip.$0", operatorText));
      }
      else {
        setText(PyBundle.message("INTN.flip.$0.to.$1", operatorText, flippedOperatorText));
      }
      return true;
    }
    binaryExpression = PsiTreeUtil.getParentOfType(binaryExpression, PyBinaryExpression.class);
  }
  return false;
}
 

import com.jetbrains.python.psi.PyFile; //导入依赖的package包/类
private static void addNavigationElements(final ArrayList<PsiElement> array, final PsiElement psiElement) {
  if (psiElement instanceof PyFile) {
    for (PyClass pyClass : ((PyFile)psiElement).getTopLevelClasses()) {
      addNavigationElements(array, pyClass);
    }
    for (PyFunction pyFunction : ((PyFile)psiElement).getTopLevelFunctions()) {
      addNavigationElements(array, pyFunction);
    }
  }
  else if (psiElement instanceof PyFunction){
    array.add(psiElement);
  }
  else if (psiElement instanceof PyClass) {
    Collections.addAll(array, ((PyClass)psiElement).getMethods(false));
  }
}
 

import com.jetbrains.python.psi.PyFile; //导入依赖的package包/类
@Nullable
public static DocStringFormat getFormatFromDocformatAttribute(@NotNull PsiFile file) {
  if (file instanceof PyFile) {
    final PyTargetExpression expr = ((PyFile)file).findTopLevelAttribute(PyNames.DOCFORMAT);
    if (expr != null) {
      final String docformat = PyPsiUtils.strValue(expr.findAssignedValue());
      if (docformat != null) {
        final List<String> words = StringUtil.split(docformat, " ");
        if (words.size() > 0) {
          final DocStringFormat fileFormat = DocStringFormat.fromName(words.get(0));
          if (fileFormat != null) {
            return fileFormat;
          }
        }
      }
    }
  }
  return null;
}
 

import com.jetbrains.python.psi.PyFile; //导入依赖的package包/类
@Override
public boolean isSupported(@NotNull final Class visitorClass, @NotNull final PsiFile file) {
  //inspections
  if (visitorClass == PyArgumentListInspection.class) {
    return false;
  }
  if (visitorClass == PyIncorrectDocstringInspection.class || visitorClass == PyMissingOrEmptyDocstringInspection.class ||
      visitorClass == PyUnboundLocalVariableInspection.class || visitorClass == PyUnnecessaryBackslashInspection.class ||
      visitorClass == PyByteLiteralInspection.class || visitorClass == PyNonAsciiCharInspection.class ||
      visitorClass == PyPackageRequirementsInspection.class || visitorClass == PyMandatoryEncodingInspection.class ||
      visitorClass == PyInterpreterInspection.class || visitorClass == PyDocstringTypesInspection.class ||
      visitorClass == PySingleQuotedDocstringInspection.class || visitorClass == PyClassHasNoInitInspection.class || 
      visitorClass == PyStatementEffectInspection.class) {
    return false;
  }
  //annotators
  if (visitorClass == DocStringAnnotator.class || visitorClass == ParameterListAnnotator.class || visitorClass == ReturnAnnotator.class || visitorClass == HighlightingAnnotator.class)
    return false;
  // doctest in separate file
  final PsiFile topLevelFile = InjectedLanguageManager.getInstance(file.getProject()).getTopLevelFile(file);
  if (visitorClass == PyUnresolvedReferencesInspection.class && !(topLevelFile instanceof PyFile)) {
    return false;
  }
  return true;
}
 

import com.jetbrains.python.psi.PyFile; //导入依赖的package包/类
private static boolean isInsideCodeBlock(PsiElement element) {
  if (element instanceof PsiFileSystemItem) {
    return false;
  }

  if (element == null || element.getParent() == null) return true;

  while(true) {
    if (element instanceof PyFile) {
      return false;
    }
    if (element instanceof PsiFile || element instanceof PsiDirectory || element == null) {
      return true;
    }
    PsiElement pparent = element.getParent();
    if (pparent instanceof PyFunction) {
      final PyFunction pyFunction = (PyFunction)pparent;
      return !(element == pyFunction.getParameterList() || element == pyFunction.getNameIdentifier());
    }
    element = pparent;
  }
}
 

import com.jetbrains.python.psi.PyFile; //导入依赖的package包/类
private static void appendDescriptors(ASTNode node, List<FoldingDescriptor> descriptors) {
  if (node.getElementType() instanceof PyFileElementType) {
    final List<PyImportStatementBase> imports = ((PyFile)node.getPsi()).getImportBlock();
    if (imports.size() > 1) {
      final PyImportStatementBase firstImport = imports.get(0);
      final PyImportStatementBase lastImport = imports.get(imports.size()-1);
      descriptors.add(new FoldingDescriptor(firstImport, new TextRange(firstImport.getTextRange().getStartOffset(),
                                                                       lastImport.getTextRange().getEndOffset())));
    }
  }
  else if (node.getElementType() == PyElementTypes.STATEMENT_LIST) {
    foldStatementList(node, descriptors);
  }
  else if (node.getElementType() == PyElementTypes.STRING_LITERAL_EXPRESSION) {
    foldDocString(node, descriptors);
  }

  ASTNode child = node.getFirstChildNode();
  while (child != null) {
    appendDescriptors(child, descriptors);
    child = child.getTreeNext();
  }
}
 

import com.jetbrains.python.psi.PyFile; //导入依赖的package包/类
@NotNull
@Override
public Collection<PsiReference> findReferencesToHighlight(@NotNull PsiElement target, @NotNull SearchScope searchScope) {
  if (target instanceof PyImportedModule) {
    target = ((PyImportedModule) target).resolve();
  }
  if (target instanceof PyFile && PyNames.INIT_DOT_PY.equals(((PyFile)target).getName())) {
    List<PsiReference> result = new ArrayList<PsiReference>();
    result.addAll(super.findReferencesToHighlight(target, searchScope));
    PsiElement targetDir = PyUtil.turnInitIntoDir(target);
    if (targetDir != null) {
      result.addAll(ReferencesSearch.search(targetDir, searchScope, false).findAll());
    }
    return result;
  }
  return super.findReferencesToHighlight(target, searchScope);
}
 

import com.jetbrains.python.psi.PyFile; //导入依赖的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.psi.PyFile; //导入依赖的package包/类
@Override
public PsiElement getTopLevelElement(PsiElement element) {
  final PsiFile containingFile = element.getContainingFile();
  if (!(containingFile instanceof PyFile)) {
    return null;
  }
  List<PsiElement> parents = new ArrayList<PsiElement>();
  PyDocStringOwner container = PsiTreeUtil.getParentOfType(element, PyDocStringOwner.class);
  while (container != null) {
    if (container instanceof PyFile) {
      break;
    }
    parents.add(0, container);
    container = PsiTreeUtil.getParentOfType(container, PyDocStringOwner.class);
  }
  for (PsiElement parent : parents) {
    if (parent instanceof PyFunction) {
      return parent;     // we don't display any nodes under functions
    }
  }
  if (parents.size() > 0) {
    return parents.get(parents.size() - 1);
  }
  return element.getContainingFile();
}
 

import com.jetbrains.python.psi.PyFile; //导入依赖的package包/类
@Nullable
@Override
public <T extends PsiNamedElement> T resolveTopLevelMember(@NotNull final Class<T> aClass) {
  Preconditions.checkState(getModule() != null, "Module is not set");
  final String memberName = myQualifiedName.getLastComponent();
  if (memberName == null) {
    return null;
  }
  final PyFile file =
    new QualifiedNameResolverImpl(myQualifiedName.removeLastComponent()).fromModule(getModule()).firstResultOfType(PyFile.class);
  if (file == null) {
    return null;
  }
  for (final T element : PsiTreeUtil.getChildrenOfTypeAsList(file, aClass)) {
    if (memberName.equals(element.getName())) {
      return element;
    }
  }
  return null;
}
 

import com.jetbrains.python.psi.PyFile; //导入依赖的package包/类
@NotNull
@Override
public List<RatedResolveResult> resolveName(@NotNull PyQualifiedExpression element,
                                            @NotNull List<PsiElement> definers) {
  final List<RatedResolveResult> result = new ArrayList<RatedResolveResult>();
  final PsiElement realContext = PyPsiUtils.getRealContext(element);
  final String referencedName = element.getReferencedName();
  final PyBuiltinCache builtinCache = PyBuiltinCache.getInstance(realContext);
  // ...as a builtin symbol
  final PyFile bfile = builtinCache.getBuiltinsFile();
  if (bfile != null && !PyUtil.isClassPrivateName(referencedName)) {
    PsiElement resultElement = bfile.getElementNamed(referencedName);
    if (resultElement == null && "__builtins__".equals(referencedName)) {
      resultElement = bfile; // resolve __builtins__ reference
    }
    if (resultElement != null)
      result.add(new ImportedResolveResult(resultElement, PyReferenceImpl.getRate(resultElement), definers));
  }
  return result;
}