Change variable name to follow the develer python coding standard
authorduplo <duplo@38d2e660-2303-0410-9eaa-f027e97ec537>
Tue, 24 Mar 2009 14:54:57 +0000 (14:54 +0000)
committerduplo <duplo@38d2e660-2303-0410-9eaa-f027e97ec537>
Tue, 24 Mar 2009 14:54:57 +0000 (14:54 +0000)
git-svn-id: https://src.develer.com/svnoss/bertos/trunk@2413 38d2e660-2303-0410-9eaa-f027e97ec537

wizard/BCpuPage.py
wizard/BCreationPage.py
wizard/BFolderPage.py
wizard/BModulePage.py
wizard/BOutputPage.py
wizard/BStartPage.py
wizard/BToolchainPage.py
wizard/BWizard.py
wizard/bertos_utils.py
wizard/codelite_project.py

index 3658635f8b2e904f54c0ce3a55974a117c67d2f2..abf0251f6c1de911e4887fb5cd7a81aecc0ff666 100644 (file)
@@ -50,10 +50,10 @@ class BCpuPage(BWizardPage):
         QApplication.instance().setOverrideCursor(Qt.WaitCursor)
         bertos_utils.loadSourceTree(self._project())
         self._populateCpuList()
-        cpuName = self._projectInfoRetrieve("CPU_NAME")
+        cpu_name = self._projectInfoRetrieve("CPU_NAME")
         self._setupUi()
-        if not cpuName is None:
-            self._selectItem(cpuName)
+        if not cpu_name is None:
+            self._selectItem(cpu_name)
         QApplication.instance().restoreOverrideCursor()
         self.emit(SIGNAL("completeChanged()"))
     
index 42a419cb22fcc1d144311e4e303bda5244ee84da..3f9748445066c037a3f857b36ab450724e32889d 100644 (file)
@@ -28,11 +28,11 @@ class BCreationPage(BWizardPage):
         self._completed = False
     
     def _setupUi(self):
-        self._confirmGroup = QWidgetGroup(self.pageContent.summaryTree,
+        self._confirm_group = QWidgetGroup(self.pageContent.summaryTree,
                                             self.pageContent.createButton)
-        self._finalGroup = QWidgetGroup(self.pageContent.iconLabel,
+        self._final_group = QWidgetGroup(self.pageContent.iconLabel,
                                             self.pageContent.textLabel)
-        self._finalGroup.setVisible(False)
+        self._final_group.setVisible(False)
         summary = self.pageContent.summaryTree
         summary.setHeaderHidden(True)
         summary.setColumnCount(1)
@@ -41,56 +41,56 @@ class BCreationPage(BWizardPage):
         self._completed = False
         self._setupUi()
         self.pageContent.summaryTree.clear()
-        topLevel = []
-        folderTitle = QTreeWidgetItem(QStringList([self.tr("Project folder")]))
-        folderItem = QTreeWidgetItem(folderTitle, QStringList([os.path.normpath(self._projectInfoRetrieve("PROJECT_PATH"))]))
-        topLevel.append(folderTitle)
-        versionTitle = QTreeWidgetItem(QStringList([self.tr("BeRTOS version")]))
+        top_level = []
+        folder_title = QTreeWidgetItem(QStringList([self.tr("Project folder")]))
+        folder_item = QTreeWidgetItem(folder_title, QStringList([os.path.normpath(self._projectInfoRetrieve("PROJECT_PATH"))]))
+        top_level.append(folder_title)
+        version_title = QTreeWidgetItem(QStringList([self.tr("BeRTOS version")]))
         sources_path = self._projectInfoRetrieve("SOURCES_PATH")
-        version = QTreeWidgetItem(versionTitle, QStringList([self.tr("version: ") + bertos_utils.bertosVersion(sources_path)]))
-        sourcePath = QTreeWidgetItem(versionTitle, QStringList([self.tr("path: ") + os.path.normpath(sources_path)]))
-        topLevel.append(versionTitle)
-        cpuTitle = QTreeWidgetItem(QStringList([self.tr("CPU")]))
-        cpuName = QTreeWidgetItem(cpuTitle, QStringList([self.tr("cpu name: ") + self._projectInfoRetrieve("CPU_NAME")]))
-        topLevel.append(cpuTitle)
-        toolchainTitle = QTreeWidgetItem(QStringList([self.tr("Toolchain")]))
-        toolchainInfo = self._projectInfoRetrieve("TOOLCHAIN")
-        if "target" in toolchainInfo.keys():
-            toolchainTarget = QTreeWidgetItem(toolchainTitle, QStringList([self.tr("target: " + toolchainInfo["target"])]))
-        if "version" in toolchainInfo.keys():
-            toolchainTarget = QTreeWidgetItem(toolchainTitle, QStringList([self.tr("version: " + "GCC " + toolchainInfo["version"] + " (" + toolchainInfo["build"] + ")")]))
-        toolchainPath = QTreeWidgetItem(toolchainTitle, QStringList([self.tr("path: " + os.path.normpath(toolchainInfo["path"]))]))
-        topLevel.append(toolchainTitle)
-        moduleTitle = QTreeWidgetItem(QStringList([self.tr("Modules")]))
+        version = QTreeWidgetItem(version_title, QStringList([self.tr("version: ") + bertos_utils.bertosVersion(sources_path)]))
+        source_path = QTreeWidgetItem(version_title, QStringList([self.tr("path: ") + os.path.normpath(sources_path)]))
+        top_level.append(version_title)
+        cpu_title = QTreeWidgetItem(QStringList([self.tr("CPU")]))
+        cpu_name = QTreeWidgetItem(cpu_title, QStringList([self.tr("cpu name: ") + self._projectInfoRetrieve("CPU_NAME")]))
+        top_level.append(cpu_title)
+        toolchain_title = QTreeWidgetItem(QStringList([self.tr("Toolchain")]))
+        toolchain_info = self._projectInfoRetrieve("TOOLCHAIN")
+        if "target" in toolchain_info.keys():
+            toolchain_target = QTreeWidgetItem(toolchain_title, QStringList([self.tr("target: " + toolchain_info["target"])]))
+        if "version" in toolchain_info.keys():
+            toolchain_target = QTreeWidgetItem(toolchain_title, QStringList([self.tr("version: " + "GCC " + toolchain_info["version"] + " (" + toolchain_info["build"] + ")")]))
+        toolchain_path = QTreeWidgetItem(toolchain_title, QStringList([self.tr("path: " + os.path.normpath(toolchain_info["path"]))]))
+        top_level.append(toolchain_title)
+        module_title = QTreeWidgetItem(QStringList([self.tr("Modules")]))
         configurations = self._projectInfoRetrieve("CONFIGURATIONS")
-        moduleCategories = {}
+        module_categories = {}
         for module, information in self._projectInfoRetrieve("MODULES").items():
             if information["enabled"]:
-                if information["category"] not in moduleCategories.keys():
-                    moduleCategories[information["category"]] = []
+                if information["category"] not in module_categories.keys():
+                    module_categories[information["category"]] = []
                 moduleItem = QTreeWidgetItem(QStringList([module + " - " + information["description"]]))
-                moduleCategories[information["category"]].append(moduleItem)
+                module_categories[information["category"]].append(moduleItem)
                 if len(information["configuration"]) > 0:
                     for property, data in configurations[information["configuration"]].items():
                         # If the final char of the brief is a dot (".") removes it.
                         brief = data["brief"]
                         if brief[-1] == ".":
                             brief = brief[:-1]
-                        configurationItem = QTreeWidgetItem(moduleItem, QStringList([brief + ": " + data["value"]]))
-        for key, value in moduleCategories.items():
-            categoryItem = QTreeWidgetItem(moduleTitle, QStringList([key]))
-            categoryItem.addChildren(value)
-        topLevel.append(moduleTitle)
-        self.pageContent.summaryTree.insertTopLevelItems(0, topLevel)
+                        configuration_item = QTreeWidgetItem(moduleItem, QStringList([brief + ": " + data["value"]]))
+        for key, value in module_categories.items():
+            category_item = QTreeWidgetItem(module_title, QStringList([key]))
+            category_item.addChildren(value)
+        top_level.append(module_title)
+        self.pageContent.summaryTree.insertTopLevelItems(0, top_level)
     
     def _connectSignals(self):
         self.connect(self.pageContent.createButton, SIGNAL("clicked(bool)"), self._createProject)
     
     def _createProject(self):
         QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
-        self._confirmGroup.setVisible(False)
+        self._confirm_group.setVisible(False)
         bertos_utils.createBertosProject(self.wizard().project())
-        self._finalGroup.setVisible(True)
+        self._final_group.setVisible(True)
         self._completed = True
         QApplication.restoreOverrideCursor()
         self.emit(SIGNAL("completeChanged()"))
index e1af7e3278f8db5cbdb00de0675b4f8f67b3ba10..7de7fc73ff508bd430d87d926556436986d83301 100644 (file)
@@ -30,9 +30,9 @@ class BFolderPage(BWizardPage):
         self.pageContent.warningLabel.setVisible(False)
     
     def _initializeAttributes(self):
-        self._projectName = ""
-        self._destinationFolder = os.path.expanduser("~")
-        self.pageContent.directoryEdit.setText(self._destinationFolder)
+        self._project_name = ""
+        self._destination_folder = os.path.expanduser("~")
+        self.pageContent.directoryEdit.setText(self._destination_folder)
     
     def _connectSignals(self):
         self.connect(self.pageContent.nameEdit, SIGNAL("textChanged(const QString)"), self._nameChanged)
@@ -40,19 +40,19 @@ class BFolderPage(BWizardPage):
         self.connect(self.pageContent.directoryButton, SIGNAL("clicked()"), self._selectDirectory)
     
     def _nameChanged(self, name):
-        self._projectName = str(name).replace(" ", "_")
+        self._project_name = str(name).replace(" ", "_")
         self._setProjectPath()
     
     def _directoryChanged(self, directory):
-        self._destinationFolder = str(QDir.toNativeSeparators(directory))
+        self._destination_folder = str(QDir.toNativeSeparators(directory))
         self._setProjectPath()
     
     def _setProjectPath(self):
-        if self._destinationFolder != "" and self._projectName <> "":
-            if not self._destinationFolder.endswith(os.sep):
-                self._destinationFolder += "/"
-            self.pageContent.projectPath.setText(QDir.toNativeSeparators(self._destinationFolder + self._projectName))
-            if os.path.exists(self._destinationFolder + self._projectName):
+        if self._destination_folder != "" and self._project_name <> "":
+            if not self._destination_folder.endswith(os.sep):
+                self._destination_folder += "/"
+            self.pageContent.projectPath.setText(QDir.toNativeSeparators(self._destination_folder + self._project_name))
+            if os.path.exists(self._destination_folder + self._project_name):
                 self.pageContent.warningLabel.setVisible(True)
                 self.pageContent.warningLabel.setText(self.tr("<font color='#FF0000'>Warning: the selected directory exists, \
                     it will be destroyed with all contained subdirectories and files...</font>"))
index 06de96380e37e41d477d6728db447a64bf80af36..6fbdaaa454572553ffea89719ef60c607752c686 100644 (file)
@@ -23,7 +23,7 @@ class BModulePage(BWizardPage):
     def __init__(self):
         BWizardPage.__init__(self, UI_LOCATION + "/module_select.ui")
         self.setTitle(self.tr("Configure the BeRTOS modules"))
-        self._controlGroup = QControlGroup()
+        self._control_group = QControlGroup()
         self._connectSignals()
     
     def reloadData(self):
@@ -32,9 +32,9 @@ class BModulePage(BWizardPage):
         self._fillModuleTree()
     
     def _setupButtonGroup(self):
-        self._buttonGroup = QButtonGroup()
-        self._buttonGroup.setExclusive(False)
-        self.connect(self._buttonGroup, SIGNAL("buttonClicked(int)"), self._moduleSelectionChanged)
+        self._button_group = QButtonGroup()
+        self._button_group.setExclusive(False)
+        self.connect(self._button_group, SIGNAL("buttonClicked(int)"), self._moduleSelectionChanged)
     
     def _loadModuleData(self):
         try:
@@ -58,8 +58,8 @@ class BModulePage(BWizardPage):
         for category, modules in categories.items():
             item = QTreeWidgetItem(QStringList([category]))
             for module in modules:
-                moduleItem = QTreeWidgetItem(item, QStringList([module]))
-                moduleItem.setCheckState(0, Qt.Unchecked)
+                module_item = QTreeWidgetItem(item, QStringList([module]))
+                module_item.setCheckState(0, Qt.Unchecked)
             self.pageContent.moduleTree.addTopLevelItem(item)
         self.pageContent.moduleTree.sortItems(0, Qt.AscendingOrder)
         
@@ -67,10 +67,10 @@ class BModulePage(BWizardPage):
     def _fillPropertyTable(self):
         module = self._currentModule()
         if module is not None:
-            self._controlGroup.clear()
+            self._control_group.clear()
             configuration = self._projectInfoRetrieve("MODULES")[module]["configuration"]
-            moduleDescription = self._projectInfoRetrieve("MODULES")[module]["description"]
-            self.pageContent.moduleLabel.setText(moduleDescription)
+            module_description = self._projectInfoRetrieve("MODULES")[module]["description"]
+            self.pageContent.moduleLabel.setText(module_description)
             self.pageContent.moduleLabel.setVisible(True)
             self.pageContent.propertyTable.clear()
             if len(configuration) > 0:
@@ -100,34 +100,34 @@ class BModulePage(BWizardPage):
     
     def _insertCheckBox(self, index, value):
         ## boolean property
-        checkBox = QCheckBox()
-        self.pageContent.propertyTable.setCellWidget(index, 1, checkBox)
+        check_box = QCheckBox()
+        self.pageContent.propertyTable.setCellWidget(index, 1, check_box)
         if value == "1":
-            checkBox.setChecked(True)
+            check_box.setChecked(True)
         else:
-            checkBox.setChecked(False)
-        self._controlGroup.addControl(index, checkBox)
+            check_box.setChecked(False)
+        self._control_group.addControl(index, check_box)
     
     def _insertComboBox(self, index, value, value_list):
         ## enum property
-        comboBox = QComboBox()
-        self.pageContent.propertyTable.setCellWidget(index, 1, comboBox)
+        combo_box = QComboBox()
+        self.pageContent.propertyTable.setCellWidget(index, 1, combo_box)
         enum = self._projectInfoRetrieve("LISTS")[value_list]
         for i, element in enumerate(enum):
-            comboBox.addItem(element)
+            combo_box.addItem(element)
             if element == value:
-                comboBox.setCurrentIndex(i)
-        self._controlGroup.addControl(index, comboBox)
+                combo_box.setCurrentIndex(i)
+        self._control_group.addControl(index, combo_box)
     
     def _insertSpinBox(self, index, value, informations):
         ## int, long or undefined type property
-        spinBox = None
+        spin_box = None
         if bertos_utils.isLong(informations) or bertos_utils.isUnsignedLong(informations):
-            spinBox = QDoubleSpinBox()
-            spinBox.setDecimals(0)
+            spin_box = QDoubleSpinBox()
+            spin_box.setDecimals(0)
         else:
-            spinBox = QSpinBox()
-        self.pageContent.propertyTable.setCellWidget(index, 1, spinBox)
+            spin_box = QSpinBox()
+        self.pageContent.propertyTable.setCellWidget(index, 1, spin_box)
         minimum = -32768
         maximum = 32767
         suff = ""
@@ -147,17 +147,17 @@ class BModulePage(BWizardPage):
             minimum = int(informations["min"])
         if "max" in informations.keys():
             maximum = int(informations["max"])
-        spinBox.setRange(minimum, maximum)
-        spinBox.setSuffix(suff)
-        spinBox.setValue(int(value.replace("L", "").replace("U", "")))
-        self._controlGroup.addControl(index, spinBox)
+        spin_box.setRange(minimum, maximum)
+        spin_box.setSuffix(suff)
+        spin_box.setValue(int(value.replace("L", "").replace("U", "")))
+        self._control_group.addControl(index, spin_box)
         
     
     def _currentModule(self):
-        currentModule = self.pageContent.moduleTree.currentItem()
+        current_module = self.pageContent.moduleTree.currentItem()
         # return only the child items
-        if currentModule is not None and currentModule.parent() is not None:
-            return unicode(currentModule.text(0))
+        if current_module is not None and current_module.parent() is not None:
+            return unicode(current_module.text(0))
         else:
             return None
     
@@ -179,11 +179,11 @@ class BModulePage(BWizardPage):
     
     def _resetPropertyDescription(self):
         for index in range(self.pageContent.propertyTable.rowCount()):
-            propertyName = qvariant_converter.getString(self.pageContent.propertyTable.item(index, 0).data(Qt.UserRole))
+            property_name = qvariant_converter.getString(self.pageContent.propertyTable.item(index, 0).data(Qt.UserRole))
             # Awful solution! Needed because if the user change the module, the selection changed...
-            if propertyName not in self._currentModuleConfigurations().keys():
+            if property_name not in self._currentModuleConfigurations().keys():
                 break
-            self.pageContent.propertyTable.item(index, 0).setText(self._currentModuleConfigurations()[propertyName]['brief'])
+            self.pageContent.propertyTable.item(index, 0).setText(self._currentModuleConfigurations()[property_name]['brief'])
     
     def _showPropertyDescription(self):
         self._resetPropertyDescription()
@@ -208,7 +208,7 @@ class BModulePage(BWizardPage):
         self.connect(self.pageContent.moduleTree, SIGNAL("itemPressed(QTreeWidgetItem*, int)"), self._fillPropertyTable)
         self.connect(self.pageContent.moduleTree, SIGNAL("itemChanged(QTreeWidgetItem*, int)"), self._dependencyCheck)
         self.connect(self.pageContent.propertyTable, SIGNAL("itemSelectionChanged()"), self._showPropertyDescription)
-        self.connect(self._controlGroup, SIGNAL("stateChanged"), self._saveValue)
+        self.connect(self._control_group, SIGNAL("stateChanged"), self._saveValue)
     
     def _saveValue(self, index):
         property = qvariant_converter.getString(self.pageContent.propertyTable.item(index, 0).data(Qt.UserRole))
@@ -227,7 +227,7 @@ class BModulePage(BWizardPage):
     
     def _moduleSelectionChanged(self, index):
         module = unicode(self.pageContent.moduleTable.item(index, 1).text())
-        if self._buttonGroup.button(index).isChecked():
+        if self._button_group.button(index).isChecked():
             self._moduleSelected(module)
         else:
             self._moduleUnselected(module)
index 397be470a6684adbde69afb19cca125db5356df2..c8e22c9fe0625f2e9bf3e7ac53b3e207067ecae8 100644 (file)
@@ -31,10 +31,10 @@ class BOutputPage(BWizardPage):
         self.connect(self.pageContent.codeliteCheckBox, SIGNAL("stateChanged(int)"), lambda checked: self._modeChecked(checked, "codelite"))
     
     def _modeChecked(self, checked, value):
-        outputList = self._projectInfoRetrieve("OUTPUT")
+        output_list = self._projectInfoRetrieve("OUTPUT")
         if checked == Qt.Checked:
-            outputList.append(value)
+            output_list.append(value)
         else:
-            outputList.remove(value)
-        self._projectInfoStore("OUTPUT", outputList)
+            output_list.remove(value)
+        self._projectInfoStore("OUTPUT", output_list)
     
\ No newline at end of file
index 23c869b8b848a82dfdb563852c5483aa3852de6c..cc6f1c9ea75a04b4bd28800b5f49c29adf01ea3a 100644 (file)
@@ -35,10 +35,10 @@ class BStartPage(QDialog):
         self.connect(self.content.editButton, SIGNAL("clicked()"), self.editProject)
     
     def _initializeButtons(self):
-        self.buttonGroup = QButtonGroup()
-        self.buttonGroup.addButton(self.content.newButton)
-        self.buttonGroup.addButton(self.content.editButton)
-        self.buttonGroup.setExclusive(True)
+        self.button_group = QButtonGroup()
+        self.button_group.addButton(self.content.newButton)
+        self.button_group.addButton(self.content.editButton)
+        self.button_group.setExclusive(True)
         
     def newProject(self):
         self.close()
index 8a1edc1e43ddc8d0f9aa4bd9d6789868ae3bb87d..18935ec5f598db267642404576bacd0156429119 100644 (file)
@@ -24,7 +24,7 @@ class BToolchainPage(BWizardPage):
     def __init__(self):
         BWizardPage.__init__(self, UI_LOCATION + "/toolchain_select.ui")
         self.setTitle(self.tr("Select toolchain"))
-        self._validationProcess = None
+        self._validation_process = None
         self._updateUi()
         #self._populateToolchainList()
         self._connectSignals()
@@ -53,18 +53,18 @@ class BToolchainPage(BWizardPage):
             self.emit(SIGNAL("completeChanged()"))
     
     def _search(self):
-        dirList = self.searchDirList()
+        dir_list = self.searchDirList()
         if self.pathSearch():
-            dirList += [element for element in bertos_utils.getSystemPath()]
-        toolchainList = bertos_utils.findToolchains(dirList)
-        storedToolchains = self.toolchains()
-        for element in toolchainList:
-            if not element in storedToolchains.keys():
+            dir_list += [element for element in bertos_utils.getSystemPath()]
+        toolchain_list = bertos_utils.findToolchains(dir_list)
+        stored_toolchains = self.toolchains()
+        for element in toolchain_list:
+            if not element in stored_toolchains.keys():
                 item = QListWidgetItem(element)
                 item.setData(Qt.UserRole, qvariant_converter.convertStringDict({"path": element}))
                 self.pageContent.toolchainList.addItem(item)
-                storedToolchains[element] = False
-        self.setToolchains(storedToolchains)
+                stored_toolchains[element] = False
+        self.setToolchains(stored_toolchains)
         
     def _connectSignals(self):
         self.connect(self.pageContent.toolchainList, SIGNAL("itemSelectionChanged()"), self._selectionChanged)
@@ -75,9 +75,9 @@ class BToolchainPage(BWizardPage):
     
     def _validItem(self, index, infos):
         item = self.pageContent.toolchainList.item(index)
-        newData = qvariant_converter.getStringDict(self.pageContent.toolchainList.item(index).data(Qt.UserRole))
-        newData.update(infos)
-        item.setData(Qt.UserRole, qvariant_converter.convertStringDict(newData))
+        new_data = qvariant_converter.getStringDict(self.pageContent.toolchainList.item(index).data(Qt.UserRole))
+        new_data.update(infos)
+        item.setData(Qt.UserRole, qvariant_converter.convertStringDict(new_data))
         needed = self._projectInfoRetrieve("CPU_INFOS")
         if "target" in infos.keys() and infos["target"].find(needed["TOOLCHAIN"]) != -1:
             item.setIcon(QIcon(":/images/ok.png"))
@@ -132,16 +132,16 @@ class BToolchainPage(BWizardPage):
                 break
         ## Try to retrieve the informations about the toolchain only for the valid toolchains
         if valid:
-            self._validationProcess = QProcess()
-            self._validationProcess.start(filename, ["-v"])
-            self._validationProcess.waitForStarted(1000)
-            if self._validationProcess.waitForFinished(200):
-                description = str(self._validationProcess.readAllStandardError())
+            self._validation_process = QProcess()
+            self._validation_process.start(filename, ["-v"])
+            self._validation_process.waitForStarted(1000)
+            if self._validation_process.waitForFinished(200):
+                description = str(self._validation_process.readAllStandardError())
                 info = bertos_utils.getToolchainInfo(description)
                 if len(info.keys()) >= 4:
                     valid = True
             else:
-                self._validationProcess.kill()
+                self._validation_process.kill()
         ## Add the item in the list with the appropriate associate data.
         if valid:
             self._validItem(i, info)
index a9bff88f0990f5e4caf90bf2709301ef9194ac4e..221f320179d08be05ff843c79b62efd29a08e0a2 100644 (file)
@@ -45,9 +45,9 @@ class BWizard(QWizard):
         self.connect(self, SIGNAL("currentIdChanged(int)"), self._pageChanged)
     
     def _pageChanged(self, pageId):
-        prevPage = self.page(pageId - 1)
-        if prevPage is not None:
-            prevPage.saveData()
+        prev_page = self.page(pageId - 1)
+        if prev_page is not None:
+            prev_page.saveData()
         page = self.page(pageId)
         if page is not None:
             page.reloadData()
index f4732edebfba4d295e23c4a984290134b6e25c57..ceb75ab4306f106e6e954cba3ce9e51b9eae0d9c 100644 (file)
@@ -25,24 +25,24 @@ def isBertosDir(directory):
 def bertosVersion(directory):
    return open(directory + "/VERSION").readline().strip()
 
-def createBertosProject(projectInfo):
-    directory = projectInfo.info("PROJECT_PATH")
-    sourcesDir = projectInfo.info("SOURCES_PATH")
+def createBertosProject(project_info):
+    directory = project_info.info("PROJECT_PATH")
+    sources_dir = project_info.info("SOURCES_PATH")
     if not os.path.isdir(directory):
         os.mkdir(directory)
     f = open(directory + "/project.bertos", "w")
-    f.write(repr(projectInfo))
+    f.write(repr(project_info))
     f.close()
     ## Destination source dir
     srcdir = directory + "/bertos"
     shutil.rmtree(srcdir, True)
-    shutil.copytree(sourcesDir + "/bertos", srcdir)
+    shutil.copytree(sources_dir + "/bertos", srcdir)
     ## Destination makefile
     makefile = directory + "/Makefile"
     if os.path.exists(makefile):
         os.remove(makefile)
     makefile = open("mktemplates/Makefile").read()
-    makefile = makefileGenerator(projectInfo, makefile)
+    makefile = makefileGenerator(project_info, makefile)
     open(directory + "/Makefile", "w").write(makefile)
     ## Destination project dir
     prjdir = directory + "/" + os.path.basename(directory)
@@ -52,8 +52,8 @@ def createBertosProject(projectInfo):
     cfgdir = prjdir + "/cfg"
     shutil.rmtree(cfgdir, True)
     os.mkdir(cfgdir)
-    for key, value in projectInfo.info("CONFIGURATIONS").items():
-        string = open(sourcesDir + "/" + key, "r").read()
+    for key, value in project_info.info("CONFIGURATIONS").items():
+        string = open(sources_dir + "/" + key, "r").read()
         for parameter, infos in value.items():
             value = infos["value"]
             if "type" in infos["informations"] and infos["informations"]["type"] == "autoenabled":
@@ -68,49 +68,49 @@ def createBertosProject(projectInfo):
         f.close()
     ## Destinatio mk file
     makefile = open("mktemplates/template.mk", "r").read()
-    makefile = mkGenerator(projectInfo, makefile)
+    makefile = mkGenerator(project_info, makefile)
     open(prjdir + "/" + os.path.basename(prjdir) + ".mk", "w").write(makefile)
     ## Destination main.c file
     main = open("srctemplates/main.c", "r").read()
     open(prjdir + "/main.c", "w").write(main)
-    if "codelite" in projectInfo.info("OUTPUT"):
-        workspace = codeliteWorkspaceGenerator(projectInfo)
+    if "codelite" in project_info.info("OUTPUT"):
+        workspace = codeliteWorkspaceGenerator(project_info)
         open(directory + "/" + os.path.basename(prjdir) + ".workspace", "w").write(workspace)
-        project = codeliteProjectGenerator(projectInfo)
+        project = codeliteProjectGenerator(project_info)
         open(directory + "/" + os.path.basename(prjdir) + ".project", "w").write(project)
 
-def mkGenerator(projectInfo, makefile):
+def mkGenerator(project_info, makefile):
     """
     Generates the mk file for the current project.
     """
-    mkData = {}
-    mkData["$pname"] = os.path.basename(projectInfo.info("PROJECT_PATH"))
-    mkData["$cpuname"] = projectInfo.info("CPU_INFOS")["CORE_CPU"]
-    mkData["$cflags"] = " ".join(projectInfo.info("CPU_INFOS")["C_FLAGS"])
-    mkData["$ldflags"] = " ".join(projectInfo.info("CPU_INFOS")["LD_FLAGS"])
-    mkData["$csrc"], mkData["$pcsrc"], mkData["$constants"] = csrcGenerator(projectInfo)
-    mkData["$prefix"] = projectInfo.info("TOOLCHAIN")["path"].split("gcc")[0]
-    mkData["$suffix"] = projectInfo.info("TOOLCHAIN")["path"].split("gcc")[1]
-    mkData["$cross"] = projectInfo.info("TOOLCHAIN")["path"].split("gcc")[0]
-    mkData["$main"] = os.path.basename(projectInfo.info("PROJECT_PATH")) + "/main.c"
-    for key in mkData:
+    mk_data = {}
+    mk_data["$pname"] = os.path.basename(project_info.info("PROJECT_PATH"))
+    mk_data["$cpuname"] = project_info.info("CPU_INFOS")["CORE_CPU"]
+    mk_data["$cflags"] = " ".join(project_info.info("CPU_INFOS")["C_FLAGS"])
+    mk_data["$ldflags"] = " ".join(project_info.info("CPU_INFOS")["LD_FLAGS"])
+    mk_data["$csrc"], mk_data["$pcsrc"], mk_data["$constants"] = csrcGenerator(project_info)
+    mk_data["$prefix"] = project_info.info("TOOLCHAIN")["path"].split("gcc")[0]
+    mk_data["$suffix"] = project_info.info("TOOLCHAIN")["path"].split("gcc")[1]
+    mk_data["$cross"] = project_info.info("TOOLCHAIN")["path"].split("gcc")[0]
+    mk_data["$main"] = os.path.basename(project_info.info("PROJECT_PATH")) + "/main.c"
+    for key in mk_data:
         while makefile.find(key) != -1:
-            makefile = makefile.replace(key, mkData[key])
+            makefile = makefile.replace(key, mk_data[key])
     return makefile
 
-def makefileGenerator(projectInfo, makefile):
+def makefileGenerator(project_info, makefile):
     """
     Generate the Makefile for the current project.
     """
     # TODO: write a general function that works for both the mk file and the Makefile
     while makefile.find("project_name") != -1:
-        makefile = makefile.replace("project_name", os.path.basename(projectInfo.info("PROJECT_PATH")))
+        makefile = makefile.replace("project_name", os.path.basename(project_info.info("PROJECT_PATH")))
     return makefile
 
-def csrcGenerator(projectInfo):
-    modules = projectInfo.info("MODULES")
-    files = projectInfo.info("FILES")
-    if "harvard" in projectInfo.info("CPU_INFOS")["CPU_TAGS"]:
+def csrcGenerator(project_info):
+    modules = project_info.info("MODULES")
+    files = project_info.info("FILES")
+    if "harvard" in project_info.info("CPU_INFOS")["CPU_TAGS"]:
         harvard = True
     else:
         harvard = False
@@ -120,76 +120,76 @@ def csrcGenerator(projectInfo):
     pcsrc = []
     ## constants to be included at the beginning of the makefile
     constants = {}
-    moduleFiles = set([])
-    dependencyFiles = set([])
+    module_files = set([])
+    dependency_files = set([])
     ## assembly sources
-    asmFiles = set([])
+    asm_files = set([])
     for module, information in modules.items():
         if information["enabled"]:
             if "constants" in information:
                 constants.update(information["constants"])
-            cfiles, sfiles = findModuleFiles(module, projectInfo)
-            moduleFiles |= set(cfiles)
-            asmFiles |= set(sfiles)
-            for fileDependency in information["depends"]:
-                if fileDependency in files:
-                    dependencyCFiles, dependencySFiles = findModuleFiles(fileDependency, projectInfo)
-                    dependencyFiles |= set(dependencyCFiles)
-                    asmFiles |= set(dependencySFiles)
-            for file in moduleFiles:
+            cfiles, sfiles = findModuleFiles(module, project_info)
+            module_files |= set(cfiles)
+            asm_files |= set(sfiles)
+            for file_dependency in information["depends"]:
+                if file_dependency in files:
+                    dependencyCFiles, dependencySFiles = findModuleFiles(file_dependency, project_info)
+                    dependency_files |= set(dependencyCFiles)
+                    asm_files |= set(dependencySFiles)
+            for file in module_files:
                 if not harvard or "harvard" not in information or information["harvard"] == "both":
                     csrc.append(file)
                 if harvard and "harvard" in information:
                     pcsrc.append(file)
-            for file in dependencyFiles:
+            for file in dependency_files:
                 csrc.append(file)
     csrc = " \\\n\t".join(csrc) + " \\"
     pcsrc = " \\\n\t".join(pcsrc) + " \\"
-    constants = "\n".join([os.path.basename(projectInfo.info("PROJECT_PATH")) + "_" + key + " = " + str(value) for key, value in constants.items()])
+    constants = "\n".join([os.path.basename(project_info.info("PROJECT_PATH")) + "_" + key + " = " + str(value) for key, value in constants.items()])
     return csrc, pcsrc, constants
     
-def findModuleFiles(module, projectInfo):
+def findModuleFiles(module, project_info):
     ## Find the files related to the selected module
     cfiles = []
     sfiles = []
     ## .c files related to the module and the cpu architecture
-    for filename, path in findDefinitions(module + ".c", projectInfo) + \
-            findDefinitions(module + "_" + projectInfo.info("CPU_INFOS")["TOOLCHAIN"] + ".c", projectInfo):
-        path = path.replace(projectInfo.info("SOURCES_PATH") + "/", "")
+    for filename, path in findDefinitions(module + ".c", project_info) + \
+            findDefinitions(module + "_" + project_info.info("CPU_INFOS")["TOOLCHAIN"] + ".c", project_info):
+        path = path.replace(project_info.info("SOURCES_PATH") + "/", "")
         cfiles.append(path + "/" + filename)
     ## .s files related to the module and the cpu architecture
-    for filename, path in findDefinitions(module + ".s", projectInfo) + \
-            findDefinitions(module + "_" + projectInfo.info("CPU_INFOS")["TOOLCHAIN"] + ".s", projectInfo) + \
-            findDefinitions(module + ".S", projectInfo) + \
-            findDefinitions(module + "_" + projectInfo.info("CPU_INFOS")["TOOLCHAIN"] + ".S", projectInfo):
-        path = path.replace(projectInfo.info("SOURCES_PATH") + "/", "")
+    for filename, path in findDefinitions(module + ".s", project_info) + \
+            findDefinitions(module + "_" + project_info.info("CPU_INFOS")["TOOLCHAIN"] + ".s", project_info) + \
+            findDefinitions(module + ".S", project_info) + \
+            findDefinitions(module + "_" + project_info.info("CPU_INFOS")["TOOLCHAIN"] + ".S", project_info):
+        path = path.replace(project_info.info("SOURCES_PATH") + "/", "")
         sfiles.append(path + "/" + filename)
     ## .c and .s files related to the module and the cpu tags
-    for tag in projectInfo.info("CPU_INFOS")["CPU_TAGS"]:
-        for filename, path in findDefinitions(module + "_" + tag + ".c", projectInfo):
-            path = path.replace(projectInfo.info("SOURCES_PATH") + "/", "")
+    for tag in project_info.info("CPU_INFOS")["CPU_TAGS"]:
+        for filename, path in findDefinitions(module + "_" + tag + ".c", project_info):
+            path = path.replace(project_info.info("SOURCES_PATH") + "/", "")
             cfiles.append(path + "/" + filename)
-        for filename, path in findDefinitions(module + "_" + tag + ".s", projectInfo) + \
-                findDefinitions(module + "_" + tag + ".S", projectInfo):
-            path = path.replace(projectInfo.info("SOURCES_PATH") + "/", "")
+        for filename, path in findDefinitions(module + "_" + tag + ".s", project_info) + \
+                findDefinitions(module + "_" + tag + ".S", project_info):
+            path = path.replace(project_info.info("SOURCES_PATH") + "/", "")
             sfiles.append(path + "/" + filename)
     return cfiles, sfiles
 
-def codeliteProjectGenerator(projectInfo):
+def codeliteProjectGenerator(project_info):
     template = open("cltemplates/bertos.project").read()
-    filelist = "\n".join(codelite_project.clFiles(codelite_project.findSources(projectInfo.info("PROJECT_PATH")), projectInfo.info("PROJECT_PATH")))
+    filelist = "\n".join(codelite_project.clFiles(codelite_project.findSources(project_info.info("PROJECT_PATH")), project_info.info("PROJECT_PATH")))
     while template.find("$filelist") != -1:
         template = template.replace("$filelist", filelist)
-    projectName = os.path.basename(projectInfo.info("PROJECT_PATH"))
+    project_name = os.path.basename(project_info.info("PROJECT_PATH"))
     while template.find("$project") != -1:
-        template = template.replace("$project", projectName)
+        template = template.replace("$project", project_name)
     return template
 
-def codeliteWorkspaceGenerator(projectInfo):
+def codeliteWorkspaceGenerator(project_info):
     template = open("cltemplates/bertos.workspace").read()
-    projectName = os.path.basename(projectInfo.info("PROJECT_PATH"))
+    project_name = os.path.basename(project_info.info("PROJECT_PATH"))
     while template.find("$project") != -1:
-        template = template.replace("$project", projectName)
+        template = template.replace("$project", project_name)
     return template
     
 def getSystemPath():
@@ -200,9 +200,9 @@ def getSystemPath():
         path = path.split(":")
     return path
 
-def findToolchains(pathList):
+def findToolchains(path_list):
     toolchains = []
-    for element in pathList:
+    for element in path_list:
         for toolchain in glob.glob(element+ "/" + const.GCC_NAME):
             toolchains.append(toolchain)
     return list(set(toolchains))
@@ -265,66 +265,66 @@ def getInfos(definition):
     return D
 
 def getCommentList(string):
-    commentList = re.findall(r"/\*{2}\s*([^*]*\*(?:[^/*][^*]*\*+)*)/", string)
-    commentList = [re.findall(r"^\s*\* *(.*?)$", comment, re.MULTILINE) for comment in commentList]
-    return commentList
+    comment_list = re.findall(r"/\*{2}\s*([^*]*\*(?:[^/*][^*]*\*+)*)/", string)
+    comment_list = [re.findall(r"^\s*\* *(.*?)$", comment, re.MULTILINE) for comment in comment_list]
+    return comment_list
 
 def loadModuleDefinition(first_comment):
-    toBeParsed = False
-    moduleDefinition = {}
+    to_be_parsed = False
+    module_definition = {}
     for num, line in enumerate(first_comment):
         index = line.find("$WIZ$")
         if index != -1:
-            toBeParsed = True
+            to_be_parsed = True
             try:
-                exec line[index + len("$WIZ$ "):] in {}, moduleDefinition
+                exec line[index + len("$WIZ$ "):] in {}, module_definition
             except:
                 raise ParseError(num, line[index:])
         elif line.find("\\brief") != -1:
-            moduleDefinition["module_description"] = line[line.find("\\brief") + len("\\brief "):]
-    moduleDict = {}
-    if "module_name" in moduleDefinition.keys():
-        moduleName = moduleDefinition[const.MODULE_DEFINITION["module_name"]]
-        del moduleDefinition[const.MODULE_DEFINITION["module_name"]]
-        moduleDict[moduleName] = {}
-        if const.MODULE_DEFINITION["module_depends"] in moduleDefinition.keys():
-            if type(moduleDefinition[const.MODULE_DEFINITION["module_depends"]]) == str:
-                moduleDefinition[const.MODULE_DEFINITION["module_depends"]] = (moduleDefinition[const.MODULE_DEFINITION["module_depends"]],)
-            moduleDict[moduleName]["depends"] = moduleDefinition[const.MODULE_DEFINITION["module_depends"]]
-            del moduleDefinition[const.MODULE_DEFINITION["module_depends"]]
+            module_definition["module_description"] = line[line.find("\\brief") + len("\\brief "):]
+    module_dict = {}
+    if "module_name" in module_definition.keys():
+        module_name = module_definition[const.MODULE_DEFINITION["module_name"]]
+        del module_definition[const.MODULE_DEFINITION["module_name"]]
+        module_dict[module_name] = {}
+        if const.MODULE_DEFINITION["module_depends"] in module_definition.keys():
+            if type(module_definition[const.MODULE_DEFINITION["module_depends"]]) == str:
+                module_definition[const.MODULE_DEFINITION["module_depends"]] = (module_definition[const.MODULE_DEFINITION["module_depends"]],)
+            module_dict[module_name]["depends"] = module_definition[const.MODULE_DEFINITION["module_depends"]]
+            del module_definition[const.MODULE_DEFINITION["module_depends"]]
         else:
-            moduleDict[moduleName]["depends"] = ()
-        if const.MODULE_DEFINITION["module_configuration"] in moduleDefinition.keys():
-            moduleDict[moduleName]["configuration"] = moduleDefinition[const.MODULE_DEFINITION["module_configuration"]]
-            del moduleDefinition[const.MODULE_DEFINITION["module_configuration"]]
+            module_dict[module_name]["depends"] = ()
+        if const.MODULE_DEFINITION["module_configuration"] in module_definition.keys():
+            module_dict[module_name]["configuration"] = module_definition[const.MODULE_DEFINITION["module_configuration"]]
+            del module_definition[const.MODULE_DEFINITION["module_configuration"]]
         else:
-            moduleDict[moduleName]["configuration"] = ""
-        if "module_description" in moduleDefinition.keys():
-            moduleDict[moduleName]["description"] = moduleDefinition["module_description"]
-            del moduleDefinition["module_description"]
-        if const.MODULE_DEFINITION["module_harvard"] in moduleDefinition.keys():
-            harvard = moduleDefinition[const.MODULE_DEFINITION["module_harvard"]]
+            module_dict[module_name]["configuration"] = ""
+        if "module_description" in module_definition.keys():
+            module_dict[module_name]["description"] = module_definition["module_description"]
+            del module_definition["module_description"]
+        if const.MODULE_DEFINITION["module_harvard"] in module_definition.keys():
+            harvard = module_definition[const.MODULE_DEFINITION["module_harvard"]]
             if harvard == "both" or harvard == "pgm_memory":
-                moduleDict[moduleName]["harvard"] = harvard
-            del moduleDefinition[const.MODULE_DEFINITION["module_harvard"]]
-        moduleDict[moduleName]["constants"] = moduleDefinition
-        moduleDict[moduleName]["enabled"] = False
-    return toBeParsed, moduleDict
+                module_dict[module_name]["harvard"] = harvard
+            del module_definition[const.MODULE_DEFINITION["module_harvard"]]
+        module_dict[module_name]["constants"] = module_definition
+        module_dict[module_name]["enabled"] = False
+    return to_be_parsed, module_dict
 
-def loadDefineLists(commentList):
-    defineList = {}
-    for comment in commentList:
+def loadDefineLists(comment_list):
+    define_list = {}
+    for comment in comment_list:
         for num, line in enumerate(comment):
             index = line.find("$WIZ$")
             if index != -1:
                 try:
-                    exec line[index + len("$WIZ$ "):] in {}, defineList
+                    exec line[index + len("$WIZ$ "):] in {}, define_list
                 except:
                     raise ParseError(num, line[index:])
-    for key, value in defineList.items():
+    for key, value in define_list.items():
         if type(value) == str:
-            defineList[key] = (value,)
-    return defineList
+            define_list[key] = (value,)
+    return define_list
 
 def getDescriptionInformations(comment): 
     """ 
@@ -369,46 +369,46 @@ def getDefinitionBlocks(text):
     return block
 
 def loadModuleData(project):
-    moduleInfoDict = {}
-    listInfoDict = {}
-    configurationInfoDict = {}
-    fileDict = {}
+    module_info_dict = {}
+    list_info_dict = {}
+    configuration_info_dict = {}
+    file_dict = {}
     for filename, path in findDefinitions("*.h", project) + findDefinitions("*.c", project) + findDefinitions("*.s", project) + findDefinitions("*.S", project):
-        commentList = getCommentList(open(path + "/" + filename, "r").read())
-        if len(commentList) > 0:
-            moduleInfo = {}
-            configurationInfo = {}
+        comment_list = getCommentList(open(path + "/" + filename, "r").read())
+        if len(comment_list) > 0:
+            module_info = {}
+            configuration_info = {}
             try:
-                toBeParsed, moduleDict = loadModuleDefinition(commentList[0])
+                to_be_parsed, module_dict = loadModuleDefinition(comment_list[0])
             except ParseError, err:
                 raise DefineException.ModuleDefineException(path, err.line_number, err.line)
-            for module, information in moduleDict.items():
+            for module, information in module_dict.items():
                 information["category"] = os.path.basename(path)
                 if "configuration" in information.keys() and len(information["configuration"]):
-                    configuration = moduleDict[module]["configuration"]
+                    configuration = module_dict[module]["configuration"]
                     try:
-                        configurationInfo[configuration] = loadConfigurationInfos(project.info("SOURCES_PATH") + "/" + configuration)
+                        configuration_info[configuration] = loadConfigurationInfos(project.info("SOURCES_PATH") + "/" + configuration)
                     except ParseError, err:
                         raise DefineException.ConfigurationDefineException(project.info("SOURCES_PATH") + "/" + configuration, err.line_number, err.line)
-            moduleInfoDict.update(moduleDict)
-            configurationInfoDict.update(configurationInfo)
-            if toBeParsed:
+            module_info_dict.update(module_dict)
+            configuration_info_dict.update(configuration_info)
+            if to_be_parsed:
                 try:
-                    listDict = loadDefineLists(commentList[1:])
-                    listInfoDict.update(listDict)
+                    list_dict = loadDefineLists(comment_list[1:])
+                    list_info_dict.update(list_dict)
                 except ParseError, err:
                     raise DefineException.EnumDefineException(path, err.line_number, err.line)
     for filename, path in findDefinitions("*_" + project.info("CPU_INFOS")["TOOLCHAIN"] + ".h", project):
-        commentList = getCommentList(open(path + "/" + filename, "r").read())
-        listInfoDict.update(loadDefineLists(commentList))
+        comment_list = getCommentList(open(path + "/" + filename, "r").read())
+        list_info_dict.update(loadDefineLists(comment_list))
     for tag in project.info("CPU_INFOS")["CPU_TAGS"]:
         for filename, path in findDefinitions("*_" + tag + ".h", project):
-            commentList = getCommentList(open(path + "/" + filename, "r").read())
-            listInfoDict.update(loadDefineLists(commentList))
-    project.setInfo("MODULES", moduleInfoDict)
-    project.setInfo("LISTS", listInfoDict)
-    project.setInfo("CONFIGURATIONS", configurationInfoDict)
-    project.setInfo("FILES", fileDict)
+            comment_list = getCommentList(open(path + "/" + filename, "r").read())
+            list_info_dict.update(loadDefineLists(comment_list))
+    project.setInfo("MODULES", module_info_dict)
+    project.setInfo("LISTS", list_info_dict)
+    project.setInfo("CONFIGURATIONS", configuration_info_dict)
+    project.setInfo("FILES", file_dict)
     
 def formatParamNameValue(text):
     """
@@ -432,28 +432,28 @@ def loadConfigurationInfos(path):
             "unsigned": boolean indicating if the num is an unsigned
             "value_list": the name of the enum for enum parameters
     """
-    configurationInfos = {}
+    configuration_infos = {}
     for comment, define in getDefinitionBlocks(open(path, "r").read()):
         name, value = formatParamNameValue(define)
         brief, description, informations = getDescriptionInformations(comment)
-        configurationInfos[name] = {}
-        configurationInfos[name]["value"] = value
-        configurationInfos[name]["informations"] = informations
-        if not "type" in configurationInfos[name]["informations"]:
-            configurationInfos[name]["informations"]["type"] = findParameterType(configurationInfos[name])
-        if ("type" in configurationInfos[name]["informations"].keys() and
-                configurationInfos[name]["informations"]["type"] == "int" and
-                configurationInfos[name]["value"].find("L") != -1):
-            configurationInfos[name]["informations"]["long"] = True
-            configurationInfos[name]["value"] = configurationInfos[name]["value"].replace("L", "")
-        if ("type" in configurationInfos[name]["informations"].keys() and
-                configurationInfos[name]["informations"]["type"] == "int" and
-                configurationInfos[name]["value"].find("U") != -1):
-            configurationInfos[name]["informations"]["unsigned"] = True
-            configurationInfos[name]["value"] = configurationInfos[name]["value"].replace("U", "")
-        configurationInfos[name]["description"] = description
-        configurationInfos[name]["brief"] = brief
-    return configurationInfos
+        configuration_infos[name] = {}
+        configuration_infos[name]["value"] = value
+        configuration_infos[name]["informations"] = informations
+        if not "type" in configuration_infos[name]["informations"]:
+            configuration_infos[name]["informations"]["type"] = findParameterType(configuration_infos[name])
+        if ("type" in configuration_infos[name]["informations"].keys() and
+                configuration_infos[name]["informations"]["type"] == "int" and
+                configuration_infos[name]["value"].find("L") != -1):
+            configuration_infos[name]["informations"]["long"] = True
+            configuration_infos[name]["value"] = configuration_infos[name]["value"].replace("L", "")
+        if ("type" in configuration_infos[name]["informations"].keys() and
+                configuration_infos[name]["informations"]["type"] == "int" and
+                configuration_infos[name]["value"].find("U") != -1):
+            configuration_infos[name]["informations"]["unsigned"] = True
+            configuration_infos[name]["value"] = configuration_infos[name]["value"].replace("U", "")
+        configuration_infos[name]["description"] = description
+        configuration_infos[name]["brief"] = brief
+    return configuration_infos
 
 def findParameterType(parameter):
     if "value_list" in parameter["informations"]:
index 6b0974b63851ef5ccccf44e27d0db6b736f0389b..f2003f448d6646c0974a73b5ecbd50ae43529a4c 100644 (file)
@@ -13,25 +13,25 @@ import os
 
 import const
 
-def clFiles(fileDict, directory):
+def clFiles(file_dict, directory):
     filelist = []
     filelist.append("<VirtualDirectory Name=\"%s\">" %os.path.basename(directory))
-    for f in fileDict[directory]["files"]:
+    for f in file_dict[directory]["files"]:
         filelist.append("<File Name=\"%s\"/>" %os.path.join(directory, f))
-    for d in fileDict[directory]["dirs"]:
-        filelist += clFiles(fileDict, os.path.join(directory, d))
+    for d in file_dict[directory]["dirs"]:
+        filelist += clFiles(file_dict, os.path.join(directory, d))
     filelist.append("</VirtualDirectory>")
     return filelist
 
 def findSources(path):
-    fileDict = {}
+    file_dict = {}
     for root, dirs, files in os.walk(path):
         if root.find("svn") == -1:
-            fileDict[root] = {"dirs": [], "files": []}
+            file_dict[root] = {"dirs": [], "files": []}
             for dir in dirs:
                 if dir.find("svn") == -1:
-                    fileDict[root]["dirs"].append(dir)
+                    file_dict[root]["dirs"].append(dir)
             for file in files:
                 if file.endswith(const.EXTENSION_FILTER):
-                    fileDict[root]["files"].append(file)
-    return fileDict
+                    file_dict[root]["files"].append(file)
+    return file_dict