MainController.docPath() - Code Metrics - Inspection of "actions and selection (#48)" - QTodoTxt/QTodoTxt2 - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — qml ( 20a369...8836e5 )

by Olivier

created 2017-06-18 15:29 UTC

MainController.docPath() A

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
c	1
b	0
f	0
dl	0
loc	3
rs	10

import logging
import os
import string

from PyQt5 import QtCore

from qtodotxt2.lib import tasklib
from qtodotxt2.lib.file import File
from qtodotxt2.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.fileExternallyModified.connect(self.fileExternallyModified)
        self._file.fileModified.connect(self._fileModified)
        self.filtersController = FiltersController()
        self._title = "QTodoTxt"
        self._recentFiles = self._settings.value("recent_files", [])
        self._updateCompletionStrings()
        self._forced = None

    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

    @QtCore.pyqtProperty('QStringList', notify=completionChanged)
    def calendarKeywords(self):
        return ['due:', 't:']

    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]]
        keywords = ['rec:', 'h:1'] #['due:', 't:', 'rec:', 'h:1']
        self._completionStrings = contexts + projects + priorities + self.calendarKeywords + keywords
        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()
        if after is None:
            after = len(self._filteredTasks) - 1
        #self._file.addTask(task)
        self._filteredTasks.insert(after + 1, task)  # force the new task to be visible
        self._file.tasks.append(task)

        self._file.connectTask(task)  #Ensure task will be added
        self.filteredTasksChanged.emit()
        return after + 1

    @QtCore.pyqtSlot('QModelIndexList')
    @QtCore.pyqtSlot('QVariantList')
    def deleteTasks(self, tasks):
        new_tasks = []
        for task in tasks:
            if isinstance(task, tasklib.Task):
                t = task
            else:
                t = self._filteredTasks[int(task)]
            new_tasks.append(t)
        for task in new_tasks:
            self._file.deleteTask(task)

    @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()

    showHiddenChanged = QtCore.pyqtSignal('bool')

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

    @showHidden.setter
    def showHidden(self, val):
        self.filtersController.showHidden = val
        self.showHiddenChanged.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)
        print("filteredTasks about to change in python")
        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.deleteTask(task)
        self.applyFilters()
        self.auto_save()

    modifiedChanged = QtCore.pyqtSignal(bool)

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

    def _fileModified(self, val=True):
        if val:
            self.auto_save()
            self.applyFilters()
            self._updateCompletionStrings()
            self._updateFilterTree()
        self._updateTitle()
        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()

    def _updateTitle(self):
        title = 'QTodoTxt - '
        if self._file.filename:
            filename = os.path.basename(self._file.filename)
            title += filename
        else:
            title += 'Untitled'
        if self._file.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._file.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)
        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.applyFilters()
        self._updateCompletionStrings()
        self._updateFilterTree()

    @QtCore.pyqtSlot('QModelIndexList')
    @QtCore.pyqtSlot('QVariantList')
    def completeTasks(self, tasks):
        for task in tasks:
            if not isinstance(task, tasklib.Task):
                # if task is not a task assume it is an int
                task = self._filteredTasks[int(task)]
            if not task.is_complete:
                if task.recursion is not None and task.due is not None:
                    new_task = tasklib.recurTask(task)
                    self._file.addTask(new_task)
                task.setCompleted()
            else:
                task.setPending()

    docPathChanged = QtCore.pyqtSignal()

    @QtCore.pyqtProperty('QUrl', notify=docPathChanged)
    def docPath(self):
        return QtCore.QUrl(QtCore.QStandardPaths.writableLocation(QtCore.QStandardPaths.DocumentsLocation))




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

QTodoTxt / QTodoTxt2

Push — qml ( 20a369...8836e5 )

MainController.docPath() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like