Eric Assistant: comparison AssistantEric/APIsManager.py

-:20a97b9662c6
+:025683852a63
 Module implementing the APIsManager.
 """
 import os
-from PyQt4.QtCore import QTimer, QThread, QFileInfo, pyqtSignal, QCoreApplication, \
+from PyQt4.QtCore import QTimer, QThread, QFileInfo, pyqtSignal, QDateTime, QObject, Qt
-QEvent, QDateTime, QObject, Qt
 try:
 from PyQt4.QtSql import QSqlDatabase, QSqlQuery
 except ImportError:
 # just ignore it because the main plug-in file will deal with it
 pass
 import Utilities.ModuleParser
 import Utilities
 import Preferences
-WorkerStarted = QEvent.User + 2001
+WorkerStatusStarted = 2001
-WorkerFinished = QEvent.User + 2002
+WorkerStatusFinished = 2002
-WorkerAborted = QEvent.User + 2003
+WorkerStatusAborted = 2003
+WorkerStatusFile = 2004
 ApisNameProject = "__Project__"
 class DbAPIsWorker(QThread):
 """
 Class implementing a worker thread to prepare the API database.
-"""
+@signal processing(status, file) emitted to indicate the processing status
+(one of WorkerStatus..., string)
+"""
+processing = pyqtSignal(int, str)
 populate_api_stmt = """
 INSERT INTO api (acWord, context, fullContext, signature, fileId, pictureId)
 VALUES (:acWord, :context, :fullContext, :signature, :fileId, :pictureId)
 """
 populate_del_api_stmt = """
 if os.path.exists(basesFile):
 modTimeBases = QFileInfo(basesFile).lastModified()
 if modTimeBases > modTime:
 modTime = modTimeBases
 if loadTime < modTime:
+self.processing.emit(WorkerStatusFile, apiFile)
 self.__loadApiFile(apiFile)
 def __classesAttributesApi(self, module):
 """
 Private method to generate class api section for class attributes.
 pass
 language = None
 if len(apis) > 0:
 self.__storeApis(apis, bases, apiFile, language)
+else:
+# just store file info to avoid rereading it every time
+self.__storeFileInfoOnly(apiFile)
+def __storeFileInfoOnly(self, apiFile):
+"""
+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.
+"""
+db = QSqlDatabase.database(self.__language)
+db.transaction()
+try:
+query = QSqlQuery(db)
+# step 1: create entry in file table
+query.prepare(self.populate_file_stmt)
+query.bindValue(":file", apiFile)
+query.exec_()
+# step 2: update the file entry
+query.prepare(self.update_file_stmt)
+query.bindValue(":lastRead", QDateTime.currentDateTime())
+query.bindValue(":file", apiFile)
+query.exec_()
+finally:
+del query
+if self.__aborted:
+db.rollback()
+else:
+db.commit()
 def __storeApis(self, apis, bases, apiFile, language):
 """
 Private method to put the API entries into the database.
 query.bindValue(":baseClasses", baseClasses)
 query.bindValue(":fileId", id)
 query.exec_()
 if not self.__aborted:
-# step 4: update the file entry
+# step 5: update the file entry
 query.prepare(self.update_file_stmt)
 query.bindValue(":lastRead", QDateTime.currentDateTime())
 query.bindValue(":file", apiFile)
 query.exec_()
 finally:
 def run(self):
 """
 Public method to perform the threads work.
 """
-QCoreApplication.postEvent(self.__proxy, QEvent(QEvent.Type(WorkerStarted)))
+self.processing.emit(WorkerStatusStarted, "")
 db = QSqlDatabase.database(self.__language)
 if db.isValid() and db.isOpen():
 # step 1: remove API files not wanted any longer
 if not self.__refresh:
 for apiFile in self.__apiFiles:
 if not self.__aborted:
 self.__loadApiFileIfNewer(apiFile)
 if self.__aborted:
-QCoreApplication.postEvent(self.__proxy, QEvent(QEvent.Type(WorkerAborted)))
+self.processing.emit(WorkerStatusAborted, "")
 else:
-QCoreApplication.postEvent(self.__proxy, QEvent(QEvent.Type(WorkerFinished)))
+self.processing.emit(WorkerStatusFinished, "")
 class DbAPIs(QObject):
 """
 Class implementing an API storage entity.
-@signal apiPreparationFinished(language) emitted after the API preparation has finished
+@signal apiPreparationStatus(language, status, file) emitted to indicate the
-@signal apiPreparationStarted(language) emitted after the API preparation has started
+API preparation status for a language
-@signal apiPreparationCancelled(language) emitted after the API preparation has been
+"""
-cancelled
+apiPreparationStatus = pyqtSignal(str, int, str)
-"""
-apiPreparationFinished = pyqtSignal(str)
-apiPreparationStarted = pyqtSignal(str)
-apiPreparationCancelled = pyqtSignal(str)
 DB_VERSION = 4
 create_mgmt_stmt = """
 CREATE TABLE mgmt
 [f for f in self.__getProjectFormSources() if f not in apiFiles])
 projectPath = self.__project.getProjectPath()
 else:
 apiFiles = Preferences.getEditorAPI(self.__language)
 self.__worker = DbAPIsWorker(self, self.__language, apiFiles, projectPath)
+self.__worker.processing.connect(self.__processingStatus, Qt.QueuedConnection)
 self.__worker.start()
 def __processQueue(self):
 """
 Private slot to process the queue of files to load.
 """
 if self.__worker is not None and self.__worker.isFinished():
+self.__worker.deleteLater()
 self.__worker = None
 if self.__worker is None and len(self.__workerQueue) > 0:
 apiFiles = [self.__workerQueue.pop(0)]
 if self.__language == ApisNameProject:
 apiFiles = [apiFiles[0].replace(projectPath + os.sep, "")]
 else:
 projectPath = ""
 self.__worker = DbAPIsWorker(self, self.__language, apiFiles, projectPath,
 refresh=True)
+self.__worker.processing.connect(self.__processingStatus, Qt.QueuedConnection)
 self.__worker.start()
 def getLexer(self):
 """
 Public method to return a reference to our lexer object.
 """
 if self.__lexer:
 return self.__lexer.autoCompletionWordSeparators()
 return None
-def event(self, evt):
+def __processingStatus(self, status, filename):
 """
-Protected method to handle events from the worker thread.
+Private slot handling the processing signal of the API preparation
+thread.
-@param evt reference to the event object (QEvent)
-@return flag indicating, if the event was handled (boolean)
+@param status preparation status (integer, one of WorkerStatus...)
-"""
+@param filename name of the file being processed (string)
-if evt.type() == WorkerStarted:
+"""
+if status == WorkerStatusStarted:
 self.__inPreparation = True
-self.apiPreparationStarted.emit(self.__language)
+self.apiPreparationStatus.emit(self.__language, WorkerStatusStarted, "")
-return True
+elif status == WorkerStatusFinished:
-elif evt.type() == WorkerFinished:
 self.__inPreparation = False
-self.apiPreparationFinished.emit(self.__language)
+self.apiPreparationStatus.emit(self.__language, WorkerStatusFinished, "")
 QTimer.singleShot(0, self.__processQueue)
-return True
+elif status == WorkerStatusAborted:
-elif evt.type() == WorkerAborted:
 self.__inPreparation = False
-self.apiPreparationCancelled.emit(self.__language)
+self.apiPreparationStatus.emit(self.__language, WorkerStatusAborted, "")
 QTimer.singleShot(0, self.__processQueue)
-return True
+elif status == WorkerStatusFile:
+self.apiPreparationStatus.emit(self.__language, WorkerStatusFile, filename)
-else:
-return QObject.event(self,  evt)
 ########################################################
 ## project related stuff below
 ########################################################
 except KeyError:
 if language in QScintilla.Lexers.getSupportedLanguages() or \
 language == ApisNameProject:
 # create the api object
 api = DbAPIs(language)
-api.apiPreparationFinished.connect(self.__apiPreparationFinished)
+api.apiPreparationStatus.connect(self.__apiPreparationStatus)
-api.apiPreparationStarted.connect(self.__apiPreparationStarted)
-api.apiPreparationCancelled.connect(self.__apiPreparationCancelled)
 self.__apis[language] = api
 return self.__apis[language]
 else:
 return None
 """
 Private message to show a message in the main windows status bar.
 @param msg message to be shown (string)
 """
-self.__mw.statusBar().showMessage(msg, 2000)
+if msg:
+self.__mw.statusBar().showMessage(msg, 2000)
 def __apiPreparationFinished(self, language):
 """
 Private slot handling the preparation finished signal of an API object.
 """
 if language == ApisNameProject:
 language = self.trUtf8("Project")
 self.__showMessage(self.trUtf8("Preparation of '{0}' APIs cancelled.")
 .format(language))
+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 status preparation status (integer, one of WorkerStatus...)
+@param filename name of the file being processed (string)
+"""
+if language == ApisNameProject:
+language = self.trUtf8("Project")
+if status == WorkerStatusStarted:
+self.__showMessage(self.trUtf8("Preparation of '{0}' APIs started.").format(
+language))
+elif status == WorkerStatusFile:
+self.__showMessage(self.trUtf8("'{0}' APIs: Processing '{1}'").format(
+language, os.path.basename(filename)))
+elif status == WorkerStatusFinished:
+self.__showMessage(self.trUtf8("Preparation of '{0}' APIs finished.").format(
+language))
+elif status == WorkerStatusAborted:
+self.__showMessage(self.trUtf8("Preparation of '{0}' APIs cancelled.").format(
+language))

Mercurial Repositories > Eric Assistant / file comparison

comparison: AssistantEric/APIsManager.py

AssistantEric/APIsManager.py