testexecutor-ui 0.6.1__py3-none-any.whl

testexecutor/model/selector/FilterModel.py

@@ -0,0 +1,251 @@
+"""
+
+An object which provides filtering information.
+Each filter has
+ - a list of allowable filter items
+ - a list of active filter items
+
+Copyright (c) 2020- Sipke Vriend
+Licensed under BSD-3-Clause, refer LICENSE
+"""
+
+import threading
+from PySide6.QtCore import QObject
+from PySide6.QtCore import QStringListModel, QAbstractListModel, Qt, QModelIndex
+from PySide6.QtCore import Signal, Property, Slot
+
+"""
+class SelectionList(QStringListModel):
+    def __init__(self):
+        QStringListModel.__init__(self)
+
+    @Slot(str)
+    def prepend(self, data):
+        print("prepend", data)
+        if self.insertRow(0):
+            index = self.index(0)
+            self.setData(index, data)
+"""
+
+class ItemList(QAbstractListModel):
+
+    ItemRole = Qt.UserRole
+    ItemKey = b"item"
+
+    _roles = {
+              ItemRole: ItemKey
+             }
+
+    def __init__(self, parent=None):
+        QAbstractListModel.__init__(self, parent)
+        self._datas = []
+
+    def addData(self, data):
+        index = QModelIndex()
+        row = self.rowCount()
+        self.beginInsertRows(index, row, row)
+        self._datas.append(data)
+        self.endInsertRows()
+        self.dataChanged.emit(row, row, self._roles)
+        self.changed.emit()
+
+    def setData(self, index, value, role):
+        ret = False
+        try:
+            data = self._datas[index.row()]
+        except IndexError:
+            return ret
+        if role == self.ItemRole:
+            self._datas[index.row()] = value
+            self.dataChanged.emit(index, index, {self.ItemRole: self.ItemKey})
+            self.changed.emit()
+            ret = True
+        return ret
+
+    def rowCount(self, parent=QModelIndex()):
+        return len(self._datas)
+
+    def data(self, index, role=Qt.DisplayRole):
+        try:
+            data = self._datas[index.row()]
+        except IndexError:
+            return None
+
+        if role == self.ItemRole:
+            return data
+
+        return None
+
+    def roleNames(self):
+        return self._roles
+
+    def removeRows(self, position, rows, parent=QModelIndex()):
+        self.beginRemoveRows(parent, position, position + rows - 1)
+        del self._datas[position:position + rows]
+        self.endRemoveRows()
+        self.dataChanged.emit(0, self.rowCount(), self._roles)
+        self.changed.emit()
+        #self.dataChanged.emit(0, self.rowCount(), self._roles)
+        return True
+
+    def getItems(self):
+        """
+        Returns dictionary with key:value pairs as string:string. Note the label is not included.
+        :return: Returns dictionary with key:value pairs
+        """
+        values = []
+        for row in range(len(self._datas)):
+            item = self._datas[row]
+            values.append(item)
+        return values
+
+    def updateItems(self, content_list):
+        """
+        Update the items to match data, ensuring we remove and add rather than dump the whole set and replace.
+        :param content_list: the new content to be added
+        :return:
+        """
+        rowCount = self.rowCount()
+        alreadyPresent = []
+        indexes_to_remove = []
+        for i in range(rowCount):
+            existing_index = self.index(i, 0)
+            existingItem = existing_index.data(self.ItemRole)
+            if existingItem not in content_list:
+                indexes_to_remove.insert(0, existing_index)
+            elif existingItem in content_list:
+                alreadyPresent.append(existingItem)
+        for index in indexes_to_remove:
+            self.removeRows(index.row(), 1)
+        for item in content_list:
+            if item not in alreadyPresent:
+                row = self.rowCount()
+                self.beginInsertRows(QModelIndex(), row, row)
+                self.addData(item)
+                self.endInsertRows()
+        #self.dataChanged.emit(0, self.rowCount(), self._roles)
+        self.dataChanged.emit(0, self.rowCount(), self._roles)
+        self.changed.emit()
+
+    @Slot()
+    def clear(self):
+        rowCount = self.rowCount(QModelIndex())
+        if rowCount:
+            self.beginRemoveRows(QModelIndex(), 0, rowCount - 1)
+            self._datas.clear()
+            self.endRemoveRows()
+            self.dataChanged.emit(0, self.rowCount(), self._roles)
+            self.changed.emit()
+
+    @Slot(str)
+    def prepend(self, data):
+        index = QModelIndex()
+        self.beginInsertRows(index, 0, 0)
+        self._datas.insert(0, data)
+        self.endInsertRows()
+        self.changed.emit()
+
+    @Slot(int)
+    def remove(self, i):
+        index = QModelIndex()
+        self.beginRemoveRows(index, i, i)
+        del self._datas[i]
+        self.endRemoveRows()
+        self.changed.emit()
+
+    changed = Signal()
+
+
+class FilterModel(QObject):
+    
+    def __init__(self, name=None, allowable=None):
+        QObject.__init__(self)
+        if not allowable:
+            allowable = []
+        self._proposed = QStringListModel()
+        self._proposed.setStringList(allowable)
+        self._selected = ItemList()
+        self._selected.changed.connect(self._onSelectedChanged, Qt.QueuedConnection)
+        self._name = name
+        self.lock = threading.RLock()
+
+    def _setproposed(self, proposed):
+        """ Setter for proposed Property """
+        changed = False
+        with self.lock:
+            if self._proposed != proposed:
+                self._proposed = proposed
+                changed = True
+        if changed:
+            self.proposed_changed.emit()
+
+    def _getproposed(self):
+        """
+        Getter for proposed Property
+        """
+        proposed = None
+        with self.lock:
+            proposed = self._proposed
+        return proposed
+
+    """
+    proposed is a list of possible filter values that can be used to control the suite filtering.
+    """
+    proposed_changed = Signal()
+    proposed = Property(QObject, _getproposed, _setproposed, notify=proposed_changed)
+    
+    def _setselected(self, selected):
+        """ Setter for selected Property """
+        changed = False
+        with self.lock:
+            if self._selected != selected:
+                self._selected = selected
+                changed = True
+        if changed:
+            self.selected_changed.emit()
+
+    def _getselected(self):
+        """
+        Getter for selected Property
+        """
+        selected = None
+        with self.lock:
+            selected = self._selected
+        return selected
+
+    """
+    selected is a list of chosen filter values
+    """
+    selected_changed = Signal()
+    selected = Property(QObject, _getselected, _setselected, notify=selected_changed)
+
+    @Slot(str, object)
+    def _onSelectedChanged(self):
+        self.updated_selected.emit(self.name, self.selected)
+
+    updated_selected = Signal(str, QObject)
+
+    def _setname(self, name):
+        """ Setter for name Property """
+        changed = False
+        with self.lock:
+            if self._name != name:
+                self._name = name
+                changed = True
+        if changed:
+            self.name_changed.emit()
+
+    def _getname(self):
+        """
+        Getter for name Property
+        """
+        name = None
+        with self.lock:
+            name = self._name
+        return name
+
+    """
+    name is a list of chosen filter values
+    """
+    name_changed = Signal()
+    name = Property(str, _getname, _setname, notify=name_changed)

testexecutor/model/selector/MultiSelectDetails.py

@@ -0,0 +1,106 @@
+#  Copyright 2021 Direkt Embedded Pty Ltd
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+
+import threading
+from PySide6.QtCore import Signal
+from PySide6.QtCore import Property
+from PySide6.QtCore import QObject
+
+
+class MultiSelectDetails(QObject):
+
+    def __init__(self, name, description, owner="default"):
+        QObject.__init__(self)
+        self.lock = threading.RLock()
+        self._name = name
+        self._owner = owner
+        self._selected = False
+        self._description = description
+
+    def _set_name(self, name):
+        """ Setter for name Property """
+        changed = False
+        with self.lock:
+            if self._name != name:
+                self._name = name
+                changed = True
+        if changed:
+            self.name_changed.emit()
+
+    def _get_name(self):
+        """ Getter for name Property """
+        with self.lock:
+            v = self._name
+        return v
+
+    name_changed = Signal()
+    name = Property(str, _get_name, _set_name, notify=name_changed)
+
+    def _set_owner(self, owner):
+        """ Setter for owner Property """
+        changed = False
+        with self.lock:
+            if self._owner != owner:
+                self._owner = owner
+                changed = True
+        if changed:
+            self.owner_changed.emit()
+
+    def _get_owner(self):
+        """ Getter for owner Property """
+        with self.lock:
+            v = self._owner
+        return v
+
+    owner_changed = Signal()
+    owner = Property(str, _get_owner, _set_owner, notify=owner_changed)
+
+    def _set_description(self, description):
+        """ Setter for description Property """
+        changed = False
+        with self.lock:
+            if self._description != description:
+                self._description = description
+                changed = True
+        if changed:
+            self.description_changed.emit()
+
+    def _get_description(self):
+        """ Getter for description Property """
+        with self.lock:
+            v = self._description
+        return v
+
+    description_changed = Signal()
+    description = Property(str, _get_description, _set_description, notify=description_changed)
+
+    def _set_selected(self, selected):
+        """ Setter for selected Property """
+        changed = False
+        with self.lock:
+            if self._selected != selected:
+                self._selected = selected
+                changed = True
+        if changed:
+            self.selected_changed.emit()
+
+    def _get_selected(self):
+        """ Getter for selected Property """
+        with self.lock:
+            v = self._selected
+        return v
+
+    selected_changed = Signal()
+    selected = Property(bool, _get_selected, _set_selected, notify=selected_changed)

testexecutor/model/selector/MultiSelectListModel.py

@@ -0,0 +1,48 @@
+#  Copyright 2021 Direkt Embedded Pty Ltd
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+"""
+A class based on GenericListModel for use in a list with selected and owner as a properties.
+Where owner can be used as the listview section and selected used to define an item is selected or not.
+These properties can be accessed within qml models through model.item.<property_name>
+"""
+
+from PySide6.QtCore import Slot
+from ..GenericListModel import GenericListModel
+from .MultiSelectDetails import MultiSelectDetails
+
+
+class MultiSelectListModel(GenericListModel):
+
+    def __init__(self, parent=None):
+        GenericListModel.__init__(self, parent)
+
+    @Slot(str, result=int)
+    def selected_count(self, owner):
+        count = 0
+        for item in self._data:
+            if item.selected and item.owner == owner:
+                count = count + 1
+        return count
+
+    def appendChild(self, name, description, owner):
+        child = MultiSelectDetails(name, description, owner)
+        self.add(child)
+
+    def selectedItems(self):
+        selected_items = []
+        for item in self._data:
+            if item.selected:
+                selected_items.append(item)
+        return selected_items

testexecutor/ui/IdentificationWidget.qml

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2020 Direkt, Australia
+ * Copyright 2021 Direkt Embedded Pty Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import QtQuick
+import QtQuick.Layouts
+import QtQuick.Controls
+
+Item {
+    id: identificationWidget
+    property var identifiers
+    property var color: "#e5e2e2"
+    property alias itemConfig: identificationList.itemConfig
+
+    ColumnLayout {
+        id: identificationWidgetLayout
+        anchors.fill: parent
+
+        KeyValueList {
+            id: identificationList
+            keyvalues: identifiers
+            Layout.fillHeight: true
+            Layout.fillWidth: true
+        }
+    }
+}
+

testexecutor/ui/InputWidget.qml

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2022 Direkt Embedded Pty Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import QtQuick
+import QtQuick.Layouts
+import QtQuick.Controls
+
+Item {
+    id: inputWidget
+    property var color: "#e5e2e2"
+    property string inputid
+    property bool hidden: false
+
+    ColumnLayout {
+        id: inputWidgetLayout
+        anchors.fill: parent
+
+        Item {
+            // The Item wrapper is to allow TextField pixelSize to reference the parents height.
+            Layout.preferredHeight: parent.height
+            Layout.minimumHeight: parent.height * 0.15
+            Layout.maximumHeight: parent.height
+            Layout.fillWidth: true
+
+            TextField {
+                id: singleInputField
+                text: ""
+                topPadding: 0
+                bottomPadding: 0
+                anchors.fill: parent
+                horizontalAlignment: Text.AlignHCenter
+                placeholderText: "Input"
+                font.pixelSize: parent.height * 0.7
+                echoMode: inputWidget.hidden ? TextInput.Password : TextInput.Normal
+                // onAccepted is called when 'return' is entered.
+                onAccepted: {
+                    if (inputWidget.inputid === singleInputField.text) {
+                        inputWidget.inputid = ""
+                    }
+                    inputWidget.inputid = singleInputField.text
+                    singleInputField.text = ""
+                }
+                // Whenever a new line is detected we want to update input it also so the caller gets the scanned input
+                onTextEdited: {
+                    var str = singleInputField.text
+                    if (str.charAt(str.length - 1) === '\n') {
+                        if (inputWidget.inputid === singleInputField.text) {
+                            inputWidget.inputid = ""
+                        }
+                        inputWidget.inputid = singleInputField.text
+                        singleInputField.text = ""
+                    }
+                }
+            }
+        }
+    }
+    function inputFocus() {
+        singleInputField.forceActiveFocus();
+    }
+}
+