Eric Assistant: comparison AssistantEric/APIsManager.py

-:08c7aece376c
+:7d868e8e1cfb
 from E5Gui.E5Application import e5App
 import QScintilla.Lexers
+import Globals
 import Utilities.ModuleParser
 import Utilities
 import Preferences
 WorkerStatusStarted = 2001
 file_delete_id_stmt = """
 DELETE FROM file WHERE id = :id
 """
 def __init__(self, proxy, language, apiFiles, projectPath="",
-refresh=False):
+refresh=False, projectType=""):
 """
 Constructor
-@param proxy reference to the object that is proxied (DbAPIs)
+@param proxy reference to the object that is proxied
-@param language language of the APIs object (string)
+@type DbAPIs
-@param apiFiles list of API files to process (list of strings)
+@param language language of the APIs object
+@type str
+@param apiFiles list of API files to process
+@type list of str
 @param projectPath path of the project. Only needed, if the APIs
-are extracted out of the sources of a project. (string)
+are extracted out of the sources of a project.
+@type str
 @param refresh flag indicating a refresh of the APIs of one file
-(boolean)
+@type bool
+@param projectType type of the project
+@type str
 """
 QThread.__init__(self)
 self.setTerminationEnabled(True)
 if lexer is not None:
 self.__wseps[lang] = lexer.autoCompletionWordSeparators()
 self.__proxy = proxy
 self.__language = language
+self.__projectType = projectType
 self.__apiFiles = apiFiles[:]
 self.__aborted = False
 self.__projectPath = projectPath
 self.__refresh = refresh
+if self.__projectType:
+self.__connectionName = "{0}_{1}".format(
+self.__language, self.__projectType)
+else:
+self.__connectionName = self.__language
 def __autoCompletionWordSeparators(self, language):
 """
 Private method to get the word separator characters for a language.
 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)
 """
-db = QSqlDatabase.database(self.__language)
+db = QSqlDatabase.database(self.__connectionName)
 db.transaction()
 try:
 query = QSqlQuery(db)
 query.prepare(self.file_loaded_stmt)
 query.bindValue(":file", apiFile)
 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)
 """
-db = QSqlDatabase.database(self.__language)
+db = QSqlDatabase.database(self.__connectionName)
 db.transaction()
 try:
 query = QSqlQuery(db)
 # step 1: create entry in file table
 query.prepare(self.populate_file_stmt)
 else:
 wseps = self.__proxy.autoCompletionWordSeparators()
 if wseps is None:
 return
-db = QSqlDatabase.database(self.__language)
+db = QSqlDatabase.database(self.__connectionName)
 db.transaction()
 try:
 query = QSqlQuery(db)
 # step 1: create entry in file table and get the ID
 query.prepare(self.populate_file_stmt)
 """
 Private method to delete all references to an api file.
 @param apiFile filename of the raw API file (string)
 """
-db = QSqlDatabase.database(self.__language)
+db = QSqlDatabase.database(self.__connectionName)
 db.transaction()
 try:
 query = QSqlQuery(db)
 # step 1: get the ID belonging to the api file
 """
 Public method to perform the threads work.
 """
 self.processing.emit(WorkerStatusStarted, "")
-db = QSqlDatabase.database(self.__language)
+db = QSqlDatabase.database(self.__connectionName)
 if db.isValid() and db.isOpen():
 # step 1: remove API files not wanted any longer
 if not self.__refresh:
 loadedApiFiles = self.__proxy.getApiFiles()
 for apiFile in loadedApiFiles:
 """
 mgmt_insert_stmt = """
 INSERT INTO mgmt (format) VALUES ({0:d})
 """.format(DB_VERSION)
-def __init__(self, language, parent=None):
+def __init__(self, language, projectType="", parent=None):
 """
 Constructor
-@param language language of the APIs object (string)
+@param language language of the APIs object
-@param parent reference to the parent object (QObject)
+@type str
+@param projectType type of the project
+@type str
+@param parent reference to the parent object
+@type QObject
 """
 QObject.__init__(self, parent)
-self.setObjectName("DbAPIs_{0}".format(language))
+if projectType:
+self.setObjectName("DbAPIs_{0}_{1}".format(language, projectType))
+else:
+self.setObjectName("DbAPIs_{0}".format(language))
 self.__inPreparation = False
 self.__worker = None
 self.__workerQueue = []
 self.__opened = False
+self.__projectType = projectType
 self.__language = language
+if self.__projectType:
+self.__connectionName = "{0}_{1}".format(
+self.__language, self.__projectType)
+else:
+self.__connectionName = self.__language
 if self.__language == ApisNameProject:
 self.__initAsProject()
 else:
 self.__initAsLanguage()
 if self.__language in ["Python", "Python2", "Python3"]:
 self.__discardFirst = ["self", "cls"]
 else:
 self.__discardFirst = []
 self.__lexer = QScintilla.Lexers.getLexer(self.__language)
-self.__apifiles = Preferences.getEditorAPI(self.__language)
+try:
+self.__apifiles = Preferences.getEditorAPI(
+self.__language, projectType=self.__projectType)
+except TypeError:
+# older interface
+self.__apifiles = Preferences.getEditorAPI(self.__language)
 self.__apifiles.sort()
 if self.__lexer is not None:
 self.__openAPIs()
 def _apiDbName(self):
 """
 if self.__language == ApisNameProject:
 return os.path.join(self.__project.getProjectManagementDir(),
 "project-apis.db")
 else:
-apiDir = os.path.join(Utilities.getConfigDir(), "APIs")
+apisDir = os.path.join(Globals.getConfigDir(), "APIs")
-if not os.path.exists(apiDir):
+if not os.path.exists(apisDir):
-os.makedirs(apiDir)
+os.makedirs(apisDir)
-return os.path.join(apiDir, "{0}-api.db".format(self.__language))
+if self.__projectType:
+filename = "{0}_{1}-api.db".format(self.__language,
+self.__projectType)
+else:
+filename = "{0}-api.db".format(self.__language)
+return os.path.join(apisDir, filename)
 def close(self):
 """
 Public method to close the database.
 """
 not self.__worker.isFinished():
 self.__worker.terminate()
 if self.__worker is not None:
 self.__worker.wait(5000)
-if QSqlDatabase and QSqlDatabase.database(self.__language).isOpen():
+if QSqlDatabase and QSqlDatabase.database(
-QSqlDatabase.database(self.__language).close()
+self.__connectionName).isOpen():
+QSqlDatabase.database(self.__connectionName).close()
 QSqlDatabase.removeDatabase(self.__language)
 self.__opened = False
 def __openApiDb(self):
 """
 Private method to open the API database.
 @return flag indicating the database status (boolean)
 """
-db = QSqlDatabase.database(self.__language, False)
+db = QSqlDatabase.database(self.__connectionName, False)
 if not db.isValid():
 # the database connection is a new one
-db = QSqlDatabase.addDatabase("QSQLITE", self.__language)
+db = QSqlDatabase.addDatabase("QSQLITE", self.__connectionName)
 dbName = self._apiDbName()
 if self.__language == ApisNameProject and \
 not os.path.exists(
 self.__project.getProjectManagementDir()):
 opened = False
 else:
 db.setDatabaseName(dbName)
 opened = db.open()
 if not opened:
-QSqlDatabase.removeDatabase(self.__language)
+QSqlDatabase.removeDatabase(self.__connectionName)
 else:
 opened = True
 return opened
 def __createApiDB(self):
 """
 Private method to create an API database.
 """
-db = QSqlDatabase.database(self.__language)
+db = QSqlDatabase.database(self.__connectionName)
 db.transaction()
 try:
 query = QSqlQuery(db)
 # step 1: drop old tables
 query.exec_(self.drop_mgmt_stmt)
 @return list of API filenames (list of strings)
 """
 apiFiles = []
-db = QSqlDatabase.database(self.__language)
+db = QSqlDatabase.database(self.__connectionName)
 db.transaction()
 try:
 query = QSqlQuery(db)
 query.exec_(self.api_files_stmt)
 while query.next():
 """
 Private method to check, if the database has been prepared.
 @return flag indicating the prepared status (boolean)
 """
-db = QSqlDatabase.database(self.__language)
+db = QSqlDatabase.database(self.__connectionName)
 prepared = len(db.tables()) > 0
 if prepared:
 db.transaction()
 prepared = False
 try:
 key 'context' contains the context (string) and
 key 'pictureId' contains the ID of the icon to be shown (string))
 """
 completions = []
-db = QSqlDatabase.database(self.__language)
+db = QSqlDatabase.database(self.__connectionName)
 if db.isOpen() and not self.__inPreparation:
 db.transaction()
 try:
 query = None
 base classes (boolean)
 @return list of calltips (list of string)
 """
 calltips = []
-db = QSqlDatabase.database(self.__language)
+db = QSqlDatabase.database(self.__connectionName)
 if db.isOpen() and not self.__inPreparation:
 if self.autoCompletionWordSeparators():
 contextSeparator = self.autoCompletionWordSeparators()[0]
 else:
 contextSeparator = " "
 apiFiles = self.__project.getSources()[:]
 apiFiles.extend(
 [f for f in self.__getProjectFormSources() if
 f not in apiFiles])
 projectPath = self.__project.getProjectPath()
-else:
+projectType = ""
-apiFiles = Preferences.getEditorAPI(self.__language)
+else:
+try:
+apiFiles = Preferences.getEditorAPI(
+self.__language, projectType=self.__projectType)
+except TypeError:
+# older interface
+apiFiles = Preferences.getEditorAPI(self.__language)
+projectType = self.__projectType
 self.__worker = DbAPIsWorker(self, self.__language, apiFiles,
-projectPath)
+projectPath, projectType=projectType)
 self.__worker.processing.connect(
 self.__processingStatus, Qt.QueuedConnection)
 self.__worker.start()
 def __processQueue(self):
 if self.__worker is None and len(self.__workerQueue) > 0:
 apiFiles = [self.__workerQueue.pop(0)]
 if self.__language == ApisNameProject:
 projectPath = self.__project.getProjectPath()
 apiFiles = [apiFiles[0].replace(projectPath + os.sep, "")]
+projectType = ""
 else:
 projectPath = ""
+projectType = self.__projectType
 self.__worker = DbAPIsWorker(self, self.__language, apiFiles,
-projectPath, refresh=True)
+projectPath, projectType=projectType,
+refresh=True)
 self.__worker.processing.connect(
 self.__processingStatus, Qt.QueuedConnection)
 self.__worker.start()
 def getLexer(self):
 @param mainWindow reference to the main eric6 window (QMainWindow)
 @param parent reference to the parent object (QObject)
 """
 QObject.__init__(self, parent)
-self.setObjectName("APIsManager")
+self.setObjectName("Assistant_APIsManager")
 self.__mw = mainWindow
 # initialize the apis dictionary
 self.__apis = {}
 Public slot to reload the api information.
 """
 for api in list(self.__apis.values()):
 api and api.prepareAPIs()
-def getAPIs(self, language):
+def getAPIs(self, language, projectType=""):
 """
 Public method to get an apis object for autocompletion/calltips.
 This method creates and loads an APIs object dynamically upon request.
 This saves memory for languages, that might not be needed at the
 moment.
-@param language the language of the requested api object (string)
+@param language language of the requested APIs object
-@return the apis object (APIs)
+@type str
+@param projectType type of the project
+@type str
+@return reference to the APIs object
+@rtype APIs
 """
 try:
-return self.__apis[language]
+return self.__apis[(language, projectType)]
 except KeyError:
-if language in QScintilla.Lexers.getSupportedLanguages() or \
+if language in self.__supportedApiLanguages() or \
 language == ApisNameProject:
 # create the api object
-api = DbAPIs(language)
+api = DbAPIs(language, projectType=projectType)
 api.apiPreparationStatus.connect(self.__apiPreparationStatus)
-self.__apis[language] = api
+self.__apis[(language, projectType)] = api
-return self.__apis[language]
+return self.__apis[(language, projectType)]
 else:
 return None
+def __supportedApiLanguages(self):
+"""
+Private method to build a list of supported API languages.
+Note: This is a compatibility method to make this code work with
+older eric versions.
+@return list of supported API languages
+@rtype list of str
+"""
+try:
+return QScintilla.Lexers.getSupportedApiLanguages()
+except AttributeError:
+return [lang for lang in
+QScintilla.Lexers.getSupportedLanguages().keys()
+if lang != "Guessed" and not lang.startswith("Pygments|")]
 def deactivate(self):
 """
 Public method to perform actions upon deactivation.
 """

Mercurial Repositories > Eric Assistant / file comparison

comparison: AssistantEric/APIsManager.py

AssistantEric/APIsManager.py