Eric Assistant: comparison AssistantEric/APIsManager.py

-:402d146da2f1
+:8f4d794d8ee0
 Module implementing the APIsManager.
 """
 import os
-from PyQt4.QtCore import *
+from PyQt4.QtCore import QTimer, QThread, QFileInfo, pyqtSignal, QCoreApplication, \
+QEvent, QDateTime, QObject, Qt
 from PyQt4.QtSql import QSqlDatabase, QSqlQuery
 from E5Gui.E5Application import e5App
 import QScintilla.Lexers
 WorkerFinished = QEvent.User + 2002
 WorkerAborted = QEvent.User + 2003
 ApisNameProject = "__Project__"
 class DbAPIsWorker(QThread):
 """
 Class implementing a worker thread to prepare the API database.
 """
 populate_api_stmt = """
 INSERT INTO api (acWord, context, fullContext, signature, fileId, pictureId)
 VALUES (:acWord, :context, :fullContext, :signature, :fileId, :pictureId)
 """
 populate_del_api_stmt = """
 DELETE FROM api WHERE fileId = :fileId
 """
 """
 file_delete_id_stmt = """
 DELETE FROM file WHERE id = :id
 """
-def __init__(self, proxy, language, apiFiles, projectPath = "", refresh = False):
+def __init__(self, proxy, language, apiFiles, projectPath="", refresh=False):
 """
 Constructor
 @param proxy reference to the object that is proxied (DbAPIs)
 @param language language of the APIs object (string)
 QThread.__init__(self)
 self.setTerminationEnabled(True)
 # Get the AC word separators for all of the languages that the editor supports.
 # This has to be before we create a new thread, because access to GUI elements
 # is not allowed from non-gui threads.
 self.__wseps = {}
 for lang in QScintilla.Lexers.getSupportedLanguages():
 lexer = QScintilla.Lexers.getLexer(lang)
 if lexer is not None:
 @param apiFile filename of the raw API file (string)
 """
 if self.__language == ApisNameProject:
 try:
 module = Utilities.ModuleParser.readModule(
 os.path.join(self.__projectPath, apiFile),
-basename = self.__projectPath + os.sep,
+basename=self.__projectPath + os.sep,
-caching = False)
+caching=False)
 language = module.getType()
 if language:
 apiGenerator = APIGenerator(module)
 apis = apiGenerator.genAPI(True, "", True)
 else:
 if self.__aborted:
 QCoreApplication.postEvent(self.__proxy, QEvent(QEvent.Type(WorkerAborted)))
 else:
 QCoreApplication.postEvent(self.__proxy, QEvent(QEvent.Type(WorkerFinished)))
 class DbAPIs(QObject):
 """
 Class implementing an API storage entity.
 @signal apiPreparationFinished() emitted after the API preparation has finished
 @signal apiPreparationStarted() emitted after the API preparation has started
 @signal apiPreparationCancelled() emitted after the API preparation has been
 cancelled
 """
 apiPreparationFinished = pyqtSignal()
 apiPreparationStarted = pyqtSignal()
 apiPreparationCancelled = pyqtSignal()
 """
 drop_mgmt_stmt = """DROP TABLE IF EXISTS mgmt"""
 create_api_stmt = """
 CREATE TABLE api
 (acWord TEXT,
 context TEXT,
 fullContext TEXT,
 signature TEXT,
 fileId INTEGER,
 pictureId INTEGER,
 UNIQUE(acWord, fullContext, signature) ON CONFLICT IGNORE
 )
 api_files_stmt = """
 SELECT file FROM file
 """
 ac_stmt = """
 SELECT DISTINCT acWord, fullContext, pictureId FROM api
 WHERE acWord GLOB :acWord
 ORDER BY acWord
 """
 ac_context_stmt = """
 SELECT DISTINCT acWord, fullContext, pictureId FROM api
 WHERE context = :context
 ORDER BY acWord
 """
 ct_stmt = """
 SELECT DISTINCT acWord, signature, fullContext FROM api
 """
 mgmt_insert_stmt = """
 INSERT INTO mgmt (format) VALUES ({0:d})
 """.format(DB_VERSION)
-def __init__(self, language, newStyle, parent = None):
+def __init__(self, language, parent=None):
 """
 Constructor
 @param language language of the APIs object (string)
-@param newStyle flag indicating usage of new style signals (bool)
 @param parent reference to the parent object (QObject)
 """
 QObject.__init__(self, parent)
 self.setObjectName("DbAPIs_{0}".format(language))
-self.__newStyle = newStyle
 self.__inPreparation = False
 self.__worker = None
 self.__workerQueue = []
 self.__language = language
 Private method to initialize as a project API object.
 """
 self.__lexer = None
 self.__project = e5App().getObject("Project")
-if self.__newStyle:
+self.__project.projectOpened.connect(self.__projectOpened)
-self.__project.projectOpened.connect(self.__projectOpened)
+self.__project.newProject.connect(self.__projectOpened)
-self.__project.newProject.connect(self.__projectOpened)
+self.__project.projectClosed.connect(self.__projectClosed)
-self.__project.projectClosed.connect(self.__projectClosed)
-else:
-self.connect(self.__project, SIGNAL("projectOpened"), self.__projectOpened)
-self.connect(self.__project, SIGNAL("newProject"), self.__projectOpened)
-self.connect(self.__project, SIGNAL("projectClosed"), self.__projectClosed)
 if self.__project.isOpen():
 self.__projectOpened()
 def __initAsLanguage(self):
 """
 Protected method to determine the name of the database file.
 @return name of the database file (string)
 """
 if self.__language == ApisNameProject:
 return os.path.join(self.__project.getProjectManagementDir(),
 "project-apis.db")
 else:
 apiDir = os.path.join(Utilities.getConfigDir(), "APIs")
 if not os.path.exists(apiDir):
 os.makedirs(apiDir)
 finally:
 del query
 db.commit()
 return prepared
-def getCompletions(self, start = None, context = None):
+def getCompletions(self, start=None, context=None):
 """
 Public method to determine the possible completions.
 @keyparam start string giving the start of the word to be
 completed (string)
 @keyparam context string giving the context (e.g. classname)
 to be completed (string)
 @return list of dictionaries with possible completions (key 'completion'
 contains the completion (string), key 'context'
 query.bindValue(":context", context)
 if query is not None:
 query.exec_()
 while query.next():
-completions.append({"completion" : query.value(0),
+completions.append({"completion": query.value(0),
-"context" : query.value(1),
+"context": query.value(1),
-"pictureId" : query.value(2)})
+"pictureId": query.value(2)})
 del query
 finally:
 db.commit()
 return completions
-def getCalltips(self, acWord, commas, context = None, fullContext = None,
+def getCalltips(self, acWord, commas, context=None, fullContext=None,
-showContext = True):
+showContext=True):
 """
 Public method to determine the calltips.
 @param acWord function to get calltips for (string)
 @param commas minimum number of commas contained in the calltip (integer)
 finally:
 db.commit()
 if context and len(calltips) == 0:
 # nothing found, try without a context
-calltips = self.getCalltips(acWord, commas, showContext = showContext)
+calltips = self.getCalltips(acWord, commas, showContext=showContext)
 return calltips
 def __enoughCommas(self, s, commas):
 """
 self.__createApiDB()
 # prepare the database if neccessary
 self.prepareAPIs()
-def prepareAPIs(self, rawList = None):
+def prepareAPIs(self, rawList=None):
 """
 Public method to prepare the APIs if neccessary.
 @keyparam rawList list of raw API files (list of strings)
 """
 if self.__language == ApisNameProject:
 projectPath = self.__project.getProjectPath()
 apiFiles = [apiFiles[0].replace(projectPath + os.sep, "")]
 else:
 projectPath = ""
 self.__worker = DbAPIsWorker(self, self.__language, apiFiles, projectPath,
-refresh = True)
+refresh=True)
 self.__worker.start()
 def getLexer(self):
 """
 Public method to return a reference to our lexer object.
 @param evt reference to the event object (QEvent)
 @return flag indicating, if the event was handled (boolean)
 """
 if evt.type() == WorkerStarted:
 self.__inPreparation = True
-if self.__newStyle:
+self.apiPreparationStarted.emit()
-self.apiPreparationStarted.emit()
-else:
-self.emit(SIGNAL('apiPreparationStarted()'))
 return True
 elif evt.type() == WorkerFinished:
 self.__inPreparation = False
-if self.__newStyle:
+self.apiPreparationFinished.emit()
-self.apiPreparationFinished.emit()
-else:
-self.emit(SIGNAL('apiPreparationFinished()'))
 QTimer.singleShot(0, self.__processQueue)
 return True
 elif evt.type() == WorkerAborted:
 self.__inPreparation = False
-if self.__newStyle:
+self.apiPreparationCancelled.emit()
-self.apiPreparationCancelled.emit()
-else:
-self.emit(SIGNAL('apiPreparationCancelled()'))
 QTimer.singleShot(0, self.__processQueue)
 return True
 else:
 return QObject.event(self,  evt)
 """
 if self.__project.isProjectSource(filename):
 self.__workerQueue.append(filename)
 self.__processQueue()
 class APIsManager(QObject):
 """
 Class implementing the APIsManager class, which is the central store for
 API information used by autocompletion and calltips.
 """
-def __init__(self, newStyle, parent = None):
+def __init__(self, parent=None):
 """
 Constructor
-@param newStyle flag indicating usage of new style signals (bool)
 @param parent reference to the parent object (QObject)
 """
 QObject.__init__(self, parent)
 self.setObjectName("APIsManager")
-self.__newStyle = newStyle
 # initialize the apis dictionary
 self.__apis = {}
 def reloadAPIs(self):
 """
 def getAPIs(self, language):
 """
 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)
 @return the apis object (APIs)
 """
 return self.__apis[language]
 except KeyError:
 if language in QScintilla.Lexers.getSupportedLanguages() or \
 language == ApisNameProject:
 # create the api object
-self.__apis[language] = DbAPIs(language, self.__newStyle)
+self.__apis[language] = DbAPIs(language)
 return self.__apis[language]
 else:
 return None
 def deactivate(self):

Mercurial Repositories > Eric Assistant / file comparison

comparison: AssistantEric/APIsManager.py

AssistantEric/APIsManager.py