Eric Assistant: comparison AssistantEric/APIsManager.py

-:62d9dc4eedd5
+:89ff060ef0d9
 """
 import contextlib
 import os
-from PyQt5.QtCore import (
+from PyQt6.QtCore import (
 QTimer, QThread, QFileInfo, pyqtSignal, QDateTime, QObject, Qt
 )
 with contextlib.suppress(ImportError):
-from PyQt5.QtSql import QSqlDatabase, QSqlQuery
+from PyQt6.QtSql import QSqlDatabase, QSqlQuery
-from E5Gui.E5Application import e5App
+from EricWidgets.EricApplication import ericApp
 import QScintilla.Lexers
 import Globals
 import Utilities.ModuleParser
 def __autoCompletionWordSeparators(self, language):
 """
 Private method to get the word separator characters for a language.
-@param language language of the APIs object (string)
+@param language language of the APIs object
-@return word separator characters (list of strings)
+@type str
+@return word separator characters
+@rtype list of str
 """
 if language:
 return self.__wseps.get(language, None)
 else:
 return self.__proxy.autoCompletionWordSeparators()
 def __loadApiFileIfNewer(self, apiFile):
 """
 Private method to load an API file, if it is newer than the one read
 into the database.
-@param apiFile filename of the raw API file (string)
+@param apiFile filename of the raw API file
+@type str
 """
 db = QSqlDatabase.database(self.__connectionName)
 db.transaction()
 try:
 query = QSqlQuery(db)
 def __classesAttributesApi(self, module):
 """
 Private method to generate class api section for class attributes.
-@param module module object to get the info from (Module)
+@param module module object to get the info from
-@return API information (list of strings)
+@type Module
+@return API information
+@rtype list of str
 """
 api = []
 modulePath = module.name.split('.')
 moduleName = "{0}.".format('.'.join(modulePath))
 def __loadApiFile(self, apiFile):
 """
 Private method to read a raw API file into the database.
-@param apiFile filename of the raw API file (string)
+@param apiFile filename of the raw API file
+@type str
 """
 apis = []
 bases = []
 if self.__language == ApisNameProject:
 Private method to store file info only.
 Doing this avoids rereading the file whenever the API is initialized
 in case the given file doesn't contain API data.
-@param apiFile file name of the API file (string)
+@param apiFile file name of the API file
+@type str
 """
 db = QSqlDatabase.database(self.__connectionName)
 db.transaction()
 try:
 query = QSqlQuery(db)
 def __storeApis(self, apis, bases, apiFile, language):
 """
 Private method to put the API entries into the database.
-@param apis list of api entries (list of strings)
+@param apis list of api entries
-@param bases list of base class entries (list of strings)
+@type list of str
-@param apiFile filename of the file read to get the APIs (string)
+@param bases list of base class entries
-@param language programming language of the file of the APIs (string)
+@type list of str
+@param apiFile filename of the file read to get the APIs
+@type str
+@param language programming language of the file of the APIs
+@type str
 """
 wseps = self.__autoCompletionWordSeparators(language)
 if wseps is None:
 return
 def __deleteApiFile(self, apiFile):
 """
 Private method to delete all references to an api file.
-@param apiFile filename of the raw API file (string)
+@param apiFile filename of the raw API file
+@type str
 """
 db = QSqlDatabase.database(self.__connectionName)
 db.transaction()
 try:
 query = QSqlQuery(db)
 """
 Private method to initialize as a project API object.
 """
 self.__lexer = None
-self.__project = e5App().getObject("Project")
+self.__project = ericApp().getObject("Project")
 self.__project.projectOpened.connect(self.__projectOpened)
 self.__project.newProject.connect(self.__projectOpened)
 self.__project.projectClosed.connect(self.__projectClosed)
 self.__project.projectFormCompiled.connect(self.__projectFormCompiled)
 self.__project.projectChanged.connect(self.__projectChanged)
 def _apiDbName(self):
 """
 Protected method to determine the name of the database file.
-@return name of the database file (string)
+@return name of the database file
+@rtype str
 """
 if self.__language == ApisNameProject:
 return os.path.join(self.__project.getProjectManagementDir(),
 "project-apis.db")
 else:
 def __openApiDb(self):
 """
 Private method to open the API database.
-@return flag indicating the database status (boolean)
+@return flag indicating the database status
+@rtype bool
 """
 db = QSqlDatabase.database(self.__connectionName, False)
 if not db.isValid():
 # the database connection is a new one
 db = QSqlDatabase.addDatabase("QSQLITE", self.__connectionName)
 def getApiFiles(self):
 """
 Public method to get a list of API files loaded into the database.
-@return list of API filenames (list of strings)
+@return list of API filenames
+@rtype list of str
 """
 apiFiles = []
 db = QSqlDatabase.database(self.__connectionName)
 db.transaction()
 def __isPrepared(self):
 """
 Private method to check, if the database has been prepared.
-@return flag indicating the prepared status (boolean)
+@return flag indicating the prepared status
+@rtype bool
 """
 db = QSqlDatabase.database(self.__connectionName)
 prepared = len(db.tables()) > 0
 if prepared:
 db.transaction()
 def getCompletions(self, start=None, context=None, followHierarchy=False):
 """
 Public method to determine the possible completions.
-@keyparam start string giving the start of the word to be
+@param start string giving the start of the word to be
-completed (string)
+completed
-@keyparam context string giving the context (e.g. classname)
+@type str
-to be completed (string)
+@param context string giving the context (e.g. classname)
-@keyparam followHierarchy flag indicating to follow the hierarchy of
+to be completed
-base classes (boolean)
+@type str
+@param followHierarchy flag indicating to follow the hierarchy of
+base classes
+@type bool
 @return list of dictionaries with possible completions
-(key 'completion' contains the completion (string),
+(key 'completion' contains the completion,
-key 'context' contains the context (string) and
+key 'context' contains the context and
-key 'pictureId' contains the ID of the icon to be shown (string))
+key 'pictureId' contains the ID of the icon to be shown)
+@rtype list of dict
 """
 completions = []
 db = QSqlDatabase.database(self.__connectionName)
 if db.isOpen() and not self.__inPreparation:
 def getCalltips(self, acWord, commas, context=None, fullContext=None,
 showContext=True, followHierarchy=False):
 """
 Public method to determine the calltips.
-@param acWord function to get calltips for (string)
+@param acWord function to get calltips for
+@type str
 @param commas minimum number of commas contained in the calltip
-(integer)
+@type int
-@param context string giving the context (e.g. classname) (string)
+@param context string giving the context (e.g. classname)
-@param fullContext string giving the full context (string)
+@type str
+@param fullContext string giving the full context
+@type str
 @param showContext flag indicating to show the calltip context
-(boolean)
+@type bool
-@keyparam followHierarchy flag indicating to follow the hierarchy of
+@param followHierarchy flag indicating to follow the hierarchy of
-base classes (boolean)
+base classes
-@return list of calltips (list of string)
+@type bool
+@return list of calltips
+@rtype list of str
 """
 calltips = []
 db = QSqlDatabase.database(self.__connectionName)
 if db.isOpen() and not self.__inPreparation:
 def __enoughCommas(self, s, commas):
 """
 Private method to determine, if the given string contains enough
 commas.
-@param s string to check (string)
+@param s string to check
-@param commas number of commas to check for (integer)
+@type str
-@return flag indicating, that there are enough commas (boolean)
+@param commas number of commas to check for
+@type int
+@return flag indicating, that there are enough commas
+@rtype bool
 """
 end = s.find(')')
 if end < 0:
 return False
 def __getProjectFormSources(self, normalized=False):
 """
 Private method to get the source files for the project forms.
-@keyparam normalized flag indicating a normalized filename is wanted
+@param normalized flag indicating a normalized filename is wanted
-(boolean)
+@type bool
-@return list of project form sources (list of strings)
+@return list of project form sources
-"""
+@rtype list of str
-if self.__project.getProjectLanguage() == "Python3":
+"""
+if self.__project.getProjectLanguage() in (
+"Python3", "MicroPython", "Cython"
+):
 sourceExt = ".py"
 elif self.__project.getProjectLanguage() == "Ruby":
 sourceExt = ".rb"
 else:
 return []
 def prepareAPIs(self, rawList=None):
 """
 Public method to prepare the APIs if neccessary.
-@keyparam rawList list of raw API files (list of strings)
+@param rawList list of raw API files
+@type list of str
 """
 if self.__inPreparation:
 return
 projectPath = ""
 [f for f in self.__getProjectFormSources() if
 f not in apiFiles])
 projectPath = self.__project.getProjectPath()
 projectType = ""
 else:
-try:
+apiFiles = Preferences.getEditorAPI(
-apiFiles = Preferences.getEditorAPI(
+self.__language, projectType=self.__projectType)
-self.__language, projectType=self.__projectType)
-except TypeError:
-# older interface
-apiFiles = Preferences.getEditorAPI(self.__language)
 projectType = self.__projectType
 self.__worker = DbAPIsWorker(self, self.__language, apiFiles,
 self._apiDbName(), projectPath,
 projectType=projectType)
 self.__worker.processing.connect(
 def getLexer(self):
 """
 Public method to return a reference to our lexer object.
-@return reference to the lexer object (QScintilla.Lexers.Lexer)
+@return reference to the lexer object
+@rtype Lexer
 """
 return self.__lexer
 def autoCompletionWordSeparators(self):
 """
 Public method to get the word separator characters.
-@return word separator characters (list of strings)
+@return word separator characters
+@rtype list of str
 """
 if self.__lexer:
 return self.__lexer.autoCompletionWordSeparators()
 return None
 def __processingStatus(self, status, filename):
 """
 Private slot handling the processing signal of the API preparation
 thread.
-@param status preparation status (integer, one of WorkerStatus...)
+@param status preparation status (one of WorkerStatus...)
-@param filename name of the file being processed (string)
+@type int
+@param filename name of the file being processed
+@type str
 """
 if status == WorkerStatusStarted:
 self.__inPreparation = True
 self.apiPreparationStatus.emit(
 self.__language, WorkerStatusStarted, "")
 def __projectOpened(self):
 """
 Private slot to perform actions after a project has been opened.
 """
-if self.__project.getProjectLanguage() == "Python3":
+if self.__project.getProjectLanguage() in (
+"Python3", "MicroPython", "Cython"
+):
 self.__discardFirst = ["self", "cls"]
 else:
 self.__discardFirst = []
 self.__lexer = QScintilla.Lexers.getLexer(
 self.__project.getProjectLanguage())
 def __projectFormCompiled(self, filename):
 """
 Private slot to handle the projectFormCompiled signal.
-@param filename name of the form file that was compiled (string)
+@param filename name of the form file that was compiled
+@type str
 """
 self.__workerQueue.append(filename)
 self.__processQueue()
 def __projectChanged(self):
 def editorSaved(self, filename):
 """
 Public slot to handle the editorSaved signal.
-@param filename name of the file that was saved (string)
+@param filename name of the file that was saved
+@type str
 """
 if self.__project.isProjectSource(filename):
 self.__workerQueue.append(filename)
 self.__processQueue()
 """
 def __init__(self, mainWindow, parent=None):
 """
 Constructor
-@param mainWindow reference to the main eric6 window (QMainWindow)
+@param mainWindow reference to the main eric7 window
-@param parent reference to the parent object (QObject)
+@type QMainWindow
+@param parent reference to the parent object
+@type QObject
 """
 QObject.__init__(self, parent)
 self.setObjectName("Assistant_APIsManager")
 self.__mw = mainWindow
 def __showMessage(self, msg):
 """
 Private message to show a message in the main windows status bar.
-@param msg message to be shown (string)
+@param msg message to be shown
+@type str
 """
 if msg:
 self.__mw.statusBar().showMessage(msg, 2000)
 def __apiPreparationStatus(self, language, status, filename):
 """
 Private slot handling the preparation status signal of an API object.
-@param language language of the API (string)
+@param language language of the API
-@param status preparation status (integer, one of WorkerStatus...)
+@type str
-@param filename name of the file being processed (string)
+@param status preparation status (one of WorkerStatus...)
+@type int
+@param filename name of the file being processed
+@type str
 """
 if language == ApisNameProject:
 language = self.tr("Project")
 if status == WorkerStatusStarted:

Mercurial Repositories > Eric Assistant / file comparison

comparison: AssistantEric/APIsManager.py

AssistantEric/APIsManager.py