MainController.applyFilters() - Code Metrics - Inspection of "rename file" - QTodoTxt/QTodoTxt2 - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — qml (e78c5d)

by Olivier

created 2017-05-05 19:56 UTC

MainController.applyFilters() A

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
cc	2
c	1
b	0
f	1
dl	0
loc	7
rs	9.4285

import logging
import os
import string

from PyQt5 import QtCore

from qtodotxt.lib import tasklib
from qtodotxt.lib.file import File

from qtodotxt.filters_controller import FiltersController

logger = logging.getLogger(__name__)


class MainController(QtCore.QObject):

    error = QtCore.pyqtSignal(str, arguments=["msg"])
    fileExternallyModified = QtCore.pyqtSignal()

    def __init__(self, args):
        super(MainController, self).__init__()
        self._args = args
        self._filteredTasks = []
        self._sortingMode = "default"
        # use object variable for setting only used in this class
        # others are accessed through QSettings
        self._settings = QtCore.QSettings()
        self._file = File()
        self._file.fileModified.connect(self.fileExternallyModified)
        self._modified = False
        self.filtersController = FiltersController()
        self._title = "QTodoTxt"
        self._recentFiles = self._settings.value("recent_files", [])
        self._updateCompletionStrings()

    def _taskModified(self, task):
        self.setModified()
        self.auto_save()
        if not task.text:
            self.deleteTask(task)
            return
        self.applyFilters()

    def showError(self, msg):
        logger.debug("ERROR: %s", msg)
        self.error.emit(msg)

    completionChanged = QtCore.pyqtSignal()

    @QtCore.pyqtProperty('QStringList', notify=completionChanged)
    def completionStrings(self):
        return self._completionStrings

    def _updateCompletionStrings(self):
        contexts = ['@' + name for name in self._file.getAllContexts()]
        projects = ['+' + name for name in self._file.getAllProjects()]
        lowest_priority = self._settings.value("lowest_priority", "D")
        idx = string.ascii_uppercase.index(lowest_priority) + 1
        priorities = ['(' + val + ')' for val in string.ascii_uppercase[:idx]]
        self._completionStrings = contexts + projects + priorities + ['due:']
        self.completionChanged.emit()

    @QtCore.pyqtSlot('QModelIndexList')
    def filterByIndexes(self, idxs):
        self.filtersController.setFiltersByIndexes(idxs)
        self.applyFilters()

    @QtCore.pyqtSlot('QString', 'int', result='int')
    def newTask(self, text='', after=None):
        task = tasklib.Task(text)
        if bool(self._settings.value("Preferences/add_creation_date", False, type=bool)):
            task.addCreationDate()
        task.modified.connect(self._taskModified)
        if after is None:
            after = len(self._filteredTasks) - 1
        self._file.tasks.append(task)
        self._filteredTasks.insert(after + 1, task)  # force the new task to be visible
        self.setModified()
        self.auto_save()
        self.filteredTasksChanged.emit()
        return after + 1

    @QtCore.pyqtSlot('QVariant')
    def deleteTask(self, task):
        if not isinstance(task, tasklib.Task):
            # if task is not a task assume it is an int
            task = self._filteredTasks[task]
        self._file.tasks.remove(task)
        self.setModified()
        self.auto_save()
        self.applyFilters()  # update filtered list for UI

    @property
    def allTasks(self):
        return self._file.tasks

    @allTasks.setter
    def allTasks(self, tasks):
        self._file.tasks = tasks

    filteredTasksChanged = QtCore.pyqtSignal()

    @QtCore.pyqtProperty('QVariant', notify=filteredTasksChanged)
    def filteredTasks(self):
        return self._filteredTasks

    showFutureChanged = QtCore.pyqtSignal('bool')

    @QtCore.pyqtProperty('bool', notify=showFutureChanged)
    def showFuture(self):
        return self.filtersController.showFuture

    @showFuture.setter
    def showFuture(self, val):
        self.filtersController.showFuture = val
        self.showFutureChanged.emit(val)
        self.applyFilters()

    sortingModeChanged = QtCore.pyqtSignal(str)

    @QtCore.pyqtProperty(str, notify=showFutureChanged)
    def sortingMode(self):
        return self._sortingMode

    @sortingMode.setter
    def sortingMode(self, val):
        self._sortingMode = val
        self.sortingModeChanged.emit(val)
        self.applyFilters()


    searchTextChanged = QtCore.pyqtSignal(str)

    @QtCore.pyqtProperty('QString', notify=searchTextChanged)
    def searchText(self):
        return self.filtersController.searchText

    @searchText.setter
    def searchText(self, txt):
        self.filtersController.searchText = txt
        self.applyFilters()
        self.searchTextChanged.emit(txt)

    showCompletedChanged = QtCore.pyqtSignal('bool')

    @QtCore.pyqtProperty('bool', notify=showCompletedChanged)
    def showCompleted(self):
        return self.filtersController.showCompleted

    @showCompleted.setter
    def showCompleted(self, val):
        self.filtersController.showCompleted = val
        self.showCompletedChanged.emit(val)
        self.applyFilters()

    def auto_save(self):
        if bool(self._settings.value("Preferences/auto_save", True, type=bool)):
            self.save()

    def start(self):
        if self._args.file:
            filename = self._args.file
        else:
            filename = self._settings.value("last_open_file")

        if filename:
            try:
                self.open(filename)
            except OSError as ex:
                self.showError(str(ex))

        self.applyFilters()
        self._updateTitle()

    filtersUpdated = QtCore.pyqtSignal()

    @QtCore.pyqtProperty('QVariant', notify=filtersUpdated)
    def filtersModel(self):
        return self.filtersController.model

    def _updateFilterTree(self):
        self.filtersController.updateFiltersModel(self._file)
        self.filtersUpdated.emit()

    def applyFilters(self, filters=None):
        if filters is not None:
            self.filtersController.setFilters(filters)
        tasks = self.filtersController.filter(self._file.tasks)
        tasks = getattr(tasklib.TaskSorter, self._sortingMode)(tasks)
        self._filteredTasks = tasks
        self.filteredTasksChanged.emit()

    @QtCore.pyqtSlot()
    def archiveCompletedTasks(self):
        done = [task for task in self._file.tasks if task.is_complete]
        for task in done:
            self._file.saveDoneTask(task)
            self._file.tasks.remove(task)
        self.applyFilters()
        self.setModified()
        self.auto_save()

    modifiedChanged = QtCore.pyqtSignal(bool)

    @QtCore.pyqtProperty('bool', notify=modifiedChanged)
    def modified(self):
        return self._modified

    def setModified(self, val=True):
        self._modified = val
        self._updateTitle()
        if val:
            self._updateCompletionStrings()
            self._updateFilterTree()
        self.modifiedChanged.emit(val)

    @QtCore.pyqtSlot("QUrl")
    @QtCore.pyqtSlot()
    def save(self, path=None):
        if not path:
            path = self._file.filename
        elif isinstance(path, QtCore.QUrl):
            path = path.toLocalFile()
        self._file.filename = path

        logger.debug('MainController, saving file: %s.', path)
        try:
            self._file.save(path)
        except OSError as ex:
            logger.exception("Error saving file %s", path)
            self.showError(ex)
            return
        self._settings.setValue("last_open_file", path)
        self._settings.sync()
        self.setModified(False)

    def _updateTitle(self):
        title = 'QTodoTxt - '
        if self._file.filename:
            filename = os.path.basename(self._file.filename)
            title += filename
        else:
            title += 'Untitled'
        if self._modified:
            title += ' (*)'
        self._title = title
        self.titleChanged.emit(self._title)

    titleChanged = QtCore.pyqtSignal(str)

    @QtCore.pyqtProperty('QString', notify=titleChanged)
    def title(self):
        return self._title

    @QtCore.pyqtSlot(result='bool')
    def canExit(self):
        self.auto_save()
        return not self._modified

    def new(self):
        if self.canExit():
            self._file = File()
            self._loadFileToUI()

    @QtCore.pyqtSlot()
    def reload(self):
        self.open(self._file.filename)

    @QtCore.pyqtSlot('QUrl')
    @QtCore.pyqtSlot('QString')
    def open(self, filename):
        if isinstance(filename, QtCore.QUrl):
            filename = filename.toLocalFile()
        logger.debug('MainController.open called with filename="%s"', filename)
        try:
            self._file.load(filename)
        except Exception as ex:
            self.showError(self.tr("Error opening file: {}.\n Exception:{}").format(filename, ex))
            return
        self._loadFileToUI()
        self._settings.setValue("last_open_file", filename)
        for task in self._file.tasks:
            task.modified.connect(self._taskModified)
        self.applyFilters()
        self.updateRecentFile()

    recentFilesChanged = QtCore.pyqtSignal()

    @QtCore.pyqtProperty('QVariant', notify=recentFilesChanged)
    def recentFiles(self):
        return self._recentFiles

    def updateRecentFile(self):
        if self._file.filename in self._recentFiles:
            self._recentFiles.remove(self._file.filename)
        self._recentFiles.insert(0, self._file.filename)
        self._recentFiles = self._recentFiles[:int(self._settings.value("max_recent_files", 6))]
        self._settings.setValue("recent_files", self._recentFiles)
        self.recentFilesChanged.emit()

    def _loadFileToUI(self):
        self.setModified(False)
        self.applyFilters()
        self._updateCompletionStrings()
        self._updateFilterTree()


1			import logging
2			import os
3			import string
4
5			from PyQt5 import QtCore
6
7			from qtodotxt.lib import tasklib
8			from qtodotxt.lib.file import File
9
10			from qtodotxt.filters_controller import FiltersController
11
12			logger = logging.getLogger(__name__)
13
14
15			class MainController(QtCore.QObject):
16
17			error = QtCore.pyqtSignal(str, arguments=["msg"])
18			fileExternallyModified = QtCore.pyqtSignal()
19
20			def __init__(self, args):
21			super(MainController, self).__init__()
22			self._args = args
23			self._filteredTasks = []
24			self._sortingMode = "default"
25			# use object variable for setting only used in this class
26			# others are accessed through QSettings
27			self._settings = QtCore.QSettings()
28			self._file = File()
29			self._file.fileModified.connect(self.fileExternallyModified)
30			self._modified = False
31			self.filtersController = FiltersController()
32			self._title = "QTodoTxt"
33			self._recentFiles = self._settings.value("recent_files", [])
34			self._updateCompletionStrings()
35
36			def _taskModified(self, task):
37			self.setModified()
38			self.auto_save()
39			if not task.text:
40			self.deleteTask(task)
41			return
42			self.applyFilters()
43
44			def showError(self, msg):
45			logger.debug("ERROR: %s", msg)
46			self.error.emit(msg)
47
48			completionChanged = QtCore.pyqtSignal()
49
50			@QtCore.pyqtProperty('QStringList', notify=completionChanged)
51			def completionStrings(self):
52			return self._completionStrings
53
54			def _updateCompletionStrings(self):
55			contexts = ['@' + name for name in self._file.getAllContexts()]
56			projects = ['+' + name for name in self._file.getAllProjects()]
57			lowest_priority = self._settings.value("lowest_priority", "D")
58			idx = string.ascii_uppercase.index(lowest_priority) + 1
59			priorities = ['(' + val + ')' for val in string.ascii_uppercase[:idx]]
60			self._completionStrings = contexts + projects + priorities + ['due:']
61			self.completionChanged.emit()
62
63			@QtCore.pyqtSlot('QModelIndexList')
64			def filterByIndexes(self, idxs):
65			self.filtersController.setFiltersByIndexes(idxs)
66			self.applyFilters()
67
68			@QtCore.pyqtSlot('QString', 'int', result='int')
69			def newTask(self, text='', after=None):
70			task = tasklib.Task(text)
71			if bool(self._settings.value("Preferences/add_creation_date", False, type=bool)):
72			task.addCreationDate()
73			task.modified.connect(self._taskModified)
74			if after is None:
75			after = len(self._filteredTasks) - 1
76			self._file.tasks.append(task)
77			self._filteredTasks.insert(after + 1, task) # force the new task to be visible
78			self.setModified()
79			self.auto_save()
80			self.filteredTasksChanged.emit()
81			return after + 1
82
83			@QtCore.pyqtSlot('QVariant')
84			def deleteTask(self, task):
85			if not isinstance(task, tasklib.Task):
86			# if task is not a task assume it is an int
87			task = self._filteredTasks[task]
88			self._file.tasks.remove(task)
89			self.setModified()
90			self.auto_save()
91			self.applyFilters() # update filtered list for UI
92
93			@property
94			def allTasks(self):
95			return self._file.tasks
96
97			@allTasks.setter
98			def allTasks(self, tasks):
99			self._file.tasks = tasks
100
101			filteredTasksChanged = QtCore.pyqtSignal()
102
103			@QtCore.pyqtProperty('QVariant', notify=filteredTasksChanged)
104			def filteredTasks(self):
105			return self._filteredTasks
106
107			showFutureChanged = QtCore.pyqtSignal('bool')
108
109			@QtCore.pyqtProperty('bool', notify=showFutureChanged)
110			def showFuture(self):
111			return self.filtersController.showFuture
112
113			@showFuture.setter
114			def showFuture(self, val):
115			self.filtersController.showFuture = val
116			self.showFutureChanged.emit(val)
117			self.applyFilters()
118
119			sortingModeChanged = QtCore.pyqtSignal(str)
120
121			@QtCore.pyqtProperty(str, notify=showFutureChanged)
122			def sortingMode(self):
123			return self._sortingMode
124
125			@sortingMode.setter
126			def sortingMode(self, val):
127			self._sortingMode = val
128			self.sortingModeChanged.emit(val)
129			self.applyFilters()
130
131
132			searchTextChanged = QtCore.pyqtSignal(str)
133
134			@QtCore.pyqtProperty('QString', notify=searchTextChanged)
135			def searchText(self):
136			return self.filtersController.searchText
137
138			@searchText.setter
139			def searchText(self, txt):
140			self.filtersController.searchText = txt
141			self.applyFilters()
142			self.searchTextChanged.emit(txt)
143
144			showCompletedChanged = QtCore.pyqtSignal('bool')
145
146			@QtCore.pyqtProperty('bool', notify=showCompletedChanged)
147			def showCompleted(self):
148			return self.filtersController.showCompleted
149
150			@showCompleted.setter
151			def showCompleted(self, val):
152			self.filtersController.showCompleted = val
153			self.showCompletedChanged.emit(val)
154			self.applyFilters()
155
156			def auto_save(self):
157			if bool(self._settings.value("Preferences/auto_save", True, type=bool)):
158			self.save()
159
160			def start(self):
161			if self._args.file:
162			filename = self._args.file
163			else:
164			filename = self._settings.value("last_open_file")
165
166			if filename:
167			try:
168			self.open(filename)
169			except OSError as ex:
170			self.showError(str(ex))
171
172			self.applyFilters()
173			self._updateTitle()
174
175			filtersUpdated = QtCore.pyqtSignal()
176
177			@QtCore.pyqtProperty('QVariant', notify=filtersUpdated)
178			def filtersModel(self):
179			return self.filtersController.model
180
181			def _updateFilterTree(self):
182			self.filtersController.updateFiltersModel(self._file)
183			self.filtersUpdated.emit()
184
185			def applyFilters(self, filters=None):
186			if filters is not None:
187			self.filtersController.setFilters(filters)
188			tasks = self.filtersController.filter(self._file.tasks)
189			tasks = getattr(tasklib.TaskSorter, self._sortingMode)(tasks)
190			self._filteredTasks = tasks
191			self.filteredTasksChanged.emit()
192
193			@QtCore.pyqtSlot()
194			def archiveCompletedTasks(self):
195			done = [task for task in self._file.tasks if task.is_complete]
196			for task in done:
197			self._file.saveDoneTask(task)
198			self._file.tasks.remove(task)
199			self.applyFilters()
200			self.setModified()
201			self.auto_save()
202
203			modifiedChanged = QtCore.pyqtSignal(bool)
204
205			@QtCore.pyqtProperty('bool', notify=modifiedChanged)
206			def modified(self):
207			return self._modified
208
209			def setModified(self, val=True):
210			self._modified = val
211			self._updateTitle()
212			if val:
213			self._updateCompletionStrings()
214			self._updateFilterTree()
215			self.modifiedChanged.emit(val)
216
217			@QtCore.pyqtSlot("QUrl")
218			@QtCore.pyqtSlot()
219			def save(self, path=None):
220			if not path:
221			path = self._file.filename
222			elif isinstance(path, QtCore.QUrl):
223			path = path.toLocalFile()
224			self._file.filename = path
225
226			logger.debug('MainController, saving file: %s.', path)
227			try:
228			self._file.save(path)
229			except OSError as ex:
230			logger.exception("Error saving file %s", path)
231			self.showError(ex)
232			return
233			self._settings.setValue("last_open_file", path)
234			self._settings.sync()
235			self.setModified(False)
236
237			def _updateTitle(self):
238			title = 'QTodoTxt - '
239			if self._file.filename:
240			filename = os.path.basename(self._file.filename)
241			title += filename
242			else:
243			title += 'Untitled'
244			if self._modified:
245			title += ' (*)'
246			self._title = title
247			self.titleChanged.emit(self._title)
248
249			titleChanged = QtCore.pyqtSignal(str)
250
251			@QtCore.pyqtProperty('QString', notify=titleChanged)
252			def title(self):
253			return self._title
254
255			@QtCore.pyqtSlot(result='bool')
256			def canExit(self):
257			self.auto_save()
258			return not self._modified
259
260			def new(self):
261			if self.canExit():
262			self._file = File()
263			self._loadFileToUI()
264
265			@QtCore.pyqtSlot()
266			def reload(self):
267			self.open(self._file.filename)
268
269			@QtCore.pyqtSlot('QUrl')
270			@QtCore.pyqtSlot('QString')
271			def open(self, filename):
272			if isinstance(filename, QtCore.QUrl):
273			filename = filename.toLocalFile()
274			logger.debug('MainController.open called with filename="%s"', filename)
275			try:
276			self._file.load(filename)
277			except Exception as ex:
278			self.showError(self.tr("Error opening file: {}.\n Exception:{}").format(filename, ex))
279			return
280			self._loadFileToUI()
281			self._settings.setValue("last_open_file", filename)
282			for task in self._file.tasks:
283			task.modified.connect(self._taskModified)
284			self.applyFilters()
285			self.updateRecentFile()
286
287			recentFilesChanged = QtCore.pyqtSignal()
288
289			@QtCore.pyqtProperty('QVariant', notify=recentFilesChanged)
290			def recentFiles(self):
291			return self._recentFiles
292
293			def updateRecentFile(self):
294			if self._file.filename in self._recentFiles:
295			self._recentFiles.remove(self._file.filename)
296			self._recentFiles.insert(0, self._file.filename)
297			self._recentFiles = self._recentFiles[:int(self._settings.value("max_recent_files", 6))]
298			self._settings.setValue("recent_files", self._recentFiles)
299			self.recentFilesChanged.emit()
300
301			def _loadFileToUI(self):
302			self.setModified(False)
303			self.applyFilters()
304			self._updateCompletionStrings()
305			self._updateFilterTree()
306

QTodoTxt / QTodoTxt2

Branch — qml (e78c5d)

MainController.applyFilters() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like