pyqttoolkit 0.9.1__py3-none-any.whl

pyqttoolkit/metadata/dict_metadata_manager.py

@@ -0,0 +1,63 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+from enum import Enum
+from copy import deepcopy
+
+from .metadata_manager_base import MetadataManagerBase
+
+class DictMetadataManager(MetadataManagerBase):
+    def __init__(self, application):
+        MetadataManagerBase.__init__(self, application)
+
+    def get_property(self, id_, property_):
+        if not isinstance(property_, Enum):
+            raise TypeError('Property must be enum type')
+        return deepcopy(self.metadata.get(self._get_property_type_key(type(property_)), {}).get(id_, {}).get(property_.name, None))
+    
+    def set_property(self, id_, property_, value):
+        if not isinstance(property_, Enum):
+            raise TypeError('Property must be enum type')
+        if id_ is None:
+            raise ValueError('Must specify an ID')
+        property_type = type(property_)
+        property_type_key = self._get_property_type_key(property_type)
+        self.metadata.setdefault(property_type_key, {}).setdefault(id_, self.default_properties(property_type))[property_.name] = value
+    
+    def get_properties(self, id_, property_type):
+        return deepcopy(self.metadata.get(self._types.get(property_type), {}).get(id_, None))
+    
+    def add_properties(self, id_, property_type, properties=None):
+        if id_ is None:
+            raise ValueError('Must specify an ID')
+        self.metadata.setdefault(self._get_property_type_key(property_type), {}).setdefault(id_, properties or self.default_properties(property_type))
+    
+    def delete_properties(self, id_, property_type):
+        if id_ is None:
+            raise ValueError('Must specify an ID')
+        metadata = self.metadata.get(self._get_property_type_key(property_type), {})
+        if id_ in metadata:
+            del metadata[id_]
+    
+    def get_metadata(self, property_type):
+        return deepcopy(self.metadata.get(self._get_property_type_key(property_type)))
+    
+    def set_metadata(self, property_type, value):
+        self.metadata[self._get_property_type_key(property_type)] = deepcopy(value)
+
+    @staticmethod
+    def default_properties(property_type):
+        return {p.name: None for p in property_type}

pyqttoolkit/metadata/id_generator.py

@@ -0,0 +1,20 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+def next_id(root, existing):
+    current_ids = sorted(int(i.replace(root, '')) for i in existing if root in i)
+    last_id = current_ids[-1] if current_ids else 0
+    return f'{root}{last_id + 1}'

pyqttoolkit/metadata/metadata_manager_base.py

@@ -0,0 +1,54 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+class MetadataManagerBase:
+    def __init__(self, project_manager):
+        self._project_manager = project_manager
+        self._types = {}
+
+    def get_property(self, id_, property_):
+        raise NotImplementedError()
+    
+    def set_property(self, id_, property_, value):
+        raise NotImplementedError()
+    
+    def get_properties(self, id_, property_type):
+        raise NotImplementedError()
+    
+    def add_properties(self, id_, property_type, properties=None):
+        raise NotImplementedError()
+    
+    def delete_properties(self, id_, property_type):
+        raise NotImplementedError()
+    
+    def get_metadata(self, property_type):
+        raise NotImplementedError()
+    
+    def set_metadata(self, property_type, value):
+        raise NotImplementedError()
+
+    def _get_property_type_key(self, property_type):
+        property_type_key = self._types.get(property_type)
+        if not property_type_key:
+            raise ValueError(f'Property type {property_type} not found')
+        return property_type_key
+
+    @property
+    def metadata(self):
+        return self._project_manager.project.metadata
+
+    def register_type(self, type_, key):
+        self._types[type_] = key

pyqttoolkit/models/__init__.py

@@ -0,0 +1,26 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+from .validation import ValidationModel
+from .json_text import JsonTextModel
+from .code_text import CodeTextModel
+from .list_model import ListModel, StringListModel, ToolTipStringListModel
+from .dataframetable import DataFrameTableModel
+from .dictpropertytree import DictPropertyTreeModel
+from .dicttable import DictTableModel
+from .series_data import SeriesDataModel
+from .span import SpanModel
+from .module import ModuleModel

pyqttoolkit/models/code_text.py

@@ -0,0 +1,43 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+from PyQt5.QtCore import QObject, pyqtSignal
+
+from pyqttoolkit.properties import AutoProperty
+from pyqttoolkit.logs import LogStream
+
+class CodeTextModel(QObject):
+    def __init__(self, parent, validator):
+        QObject.__init__(self, parent)
+        self.textChanged.connect(self._validate)
+        self._validator = validator
+        self.text = ''
+        self.output = LogStream(self._handle_output_buffer_changed)
+
+    textChanged = pyqtSignal(str)
+    outputChanged = pyqtSignal(LogStream)
+    validationMessageChanged = pyqtSignal(str)
+
+    text = AutoProperty(str)
+    output = AutoProperty(LogStream)
+    validationMessage = AutoProperty(str)
+
+    def _validate(self, value):
+        validation_model = self._validator(value)
+        self.validationMessage = validation_model.error if validation_model else ''
+
+    def _handle_output_buffer_changed(self):
+        self.outputChanged.emit(self.output)

pyqttoolkit/models/dataframetable.py

@@ -0,0 +1,135 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+from PyQt5.QtCore import pyqtSignal, QAbstractTableModel, Qt, QVariant, QModelIndex, QItemSelectionModel
+
+class DataFrameTableModel(QAbstractTableModel):
+    def __init__(self, parent, data, display_column=None, editable=False, row_headers=False):
+        QAbstractTableModel.__init__(self, parent)
+        self._data = data.copy()
+        self._display_column_index = (
+            0 if display_column is None
+            else data.columns.get_loc(display_column)
+        )
+        self._selection_model = QItemSelectionModel(self)
+        self._editable = editable
+        self._row_headers = row_headers
+
+    dataUpdated = pyqtSignal()
+
+    def data(self, index, role=Qt.DisplayRole):
+        if role in [Qt.DisplayRole, Qt.EditRole, Qt.ToolTipRole]:
+            column = self._data.columns[index.column()]
+            return str(self._data[column].iloc[index.row()])
+        return QVariant()
+    
+    def headerData(self, section, orientation, role=None):
+        role = role or Qt.DisplayRole
+        if role == Qt.DisplayRole:
+            if orientation == Qt.Horizontal:
+                return str(self._data.columns[section])
+            elif self._row_headers:
+                return str(self._data.index[section])
+        return None
+    
+    def flags(self, _index):
+        flags = Qt.ItemIsSelectable | Qt.ItemIsEnabled
+        if self._editable:
+            flags |= Qt.ItemIsEditable
+        return flags
+
+    def setData(self, index, value, role=Qt.EditRole):
+        if role == Qt.EditRole:
+            column = self._data.columns[index.column()]
+            self._data[column][index.row()] = value
+            self.dataUpdated.emit()
+            return True
+        return False
+
+    def columnCount(self, _parent=None):
+        return len(self._data.columns)
+
+    def rowCount(self, _parent=None):
+        return len(self._data)
+
+    def insertRows(self, row, count, parent=None, gen_row=None):
+        parent = parent or QModelIndex()
+        if row != self.rowCount(parent):
+            return False
+        if count != 1:
+            raise ValueError('Cannot insert more than 1 row')
+
+        gen_row = gen_row or (lambda: {n: '' for n in self._data.columns})
+
+        self.beginInsertRows(parent, row, row)
+        self._data.loc[row] = gen_row()
+        self.dataUpdated.emit()
+        self.endInsertRows()
+        return True
+
+    def removeRows(self, row, count, parent=None):
+        parent = parent or QModelIndex()
+        if count != 1:
+            raise ValueError('Cannot remove more than 1 row')
+        
+        self.beginRemoveRows(parent, row, row)
+        self._data.drop(row, inplace=True)
+        self._data.reset_index(drop=True, inplace=True)
+        self.dataUpdated.emit()
+        self.endRemoveRows()
+        return True
+
+    def moveRows(self, source_parent, source_row, count, dest_parent, dest_row):
+        if count != 1:
+            raise ValueError('Cannot move more than 1 row')
+        dest_row = min(dest_row, len(self._data) - 1)
+        dest_row = max(dest_row, 0)
+        if dest_row == source_row:
+            return False
+        self.beginMoveRows(source_parent, source_row, source_row + count, dest_parent, dest_row)
+        temp = self._data.iloc[dest_row].copy()
+        self._data.iloc[dest_row] = self._data.iloc[source_row]
+        self._data.iloc[source_row] = temp
+        self.endMoveRows()
+        self.dataUpdated.emit()
+        self.selectionModel.setCurrentIndex(self.createIndex(dest_row, 0), QItemSelectionModel.ClearAndSelect | QItemSelectionModel.Rows)
+        return True
+
+    def removeSelected(self):
+        selected_rows = {i.row() for i in self._selection_model.selectedIndexes()}
+        if len(selected_rows) > 1:
+            raise ValueError('Removal of more than one row not currently supported')
+        for row in selected_rows:
+            self.removeRows(row, 1)
+
+    @property
+    def dataFrame(self):
+        return self._data
+
+    @dataFrame.setter
+    def dataFrame(self, value):
+        if self._data.size != value.size or not (self._data == value).all().all():
+            self.beginResetModel()
+            self._data = value.copy()
+            self.endResetModel()
+
+    @property
+    def displayColumnIndex(self):
+        return self._display_column_index
+
+    @property
+    def selectionModel(self):
+        return self._selection_model

pyqttoolkit/models/dictpropertytree.py

@@ -0,0 +1,155 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+from enum import Enum
+
+from PyQt5.QtCore import Qt, QAbstractItemModel, pyqtSignal, QModelIndex, QVariant
+
+class DictPropertyTreeModel(QAbstractItemModel):
+    def __init__(self, parent, data):
+        QAbstractItemModel.__init__(self, parent)
+        self._data = data
+        self._nodes = []
+        self._indexes = {}
+    
+    propertyChanged = pyqtSignal(object, object)
+
+    @property
+    def value(self):
+        return self._data
+    
+    @value.setter
+    def value(self, value):
+        self._data = value
+        start_index = self.createIndex(0, 0)
+        end_index = self.createIndex(self.rowCount(), self.columnCount())
+
+        self.dataChanged.emit(start_index, end_index)
+    
+    def rowCount(self, parent=None):
+        keys = self._keys(parent)
+        return len(keys) if keys else 0
+    
+    def columnCount(self, _parent=None):
+        return 2
+    
+    def parent(self, index):
+        return self._nodes[index.internalId()] if index.isValid() else QModelIndex()
+    
+    def hasChildren(self, index):
+        return isinstance(self._property_type(index), dict)
+    
+    def index(self, row, column, parent):
+        if (row, column, parent) not in self._indexes:
+            internal_id = len(self._nodes)
+            self._nodes.append(parent)
+            self._indexes[(row, column, parent)] = self.createIndex(row, column, internal_id)
+        return self._indexes[(row, column, parent)]
+    
+    def flags(self, index):
+        if index.column() == 0 or isinstance(self._property_type(index), dict):
+            return Qt.ItemIsEnabled | Qt.ItemIsSelectable
+        return Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsEditable
+
+    def data(self, index, role=None):
+        role = role or Qt.DisplayRole
+        if role in [Qt.DisplayRole, Qt.EditRole]:
+            if index.column() == 0:
+                return self._property_name(index)
+            data = self._properties(index)
+            if isinstance(data, dict):
+                return None
+            return data and self._property_type(index)(data)
+        return None
+    
+    def setData(self, index, value, role=None):
+        role = role or Qt.EditRole
+        if role == Qt.EditRole:
+            if index.column() == 1:
+                self._set_property(index, value)
+                return True
+        return False
+    
+    def headerData(self, section, orientation, role=None):
+        role = role or Qt.DisplayRole
+        if role in [Qt.DisplayRole, Qt.EditRole] and orientation in [Qt.Horizontal]:
+            return self.tr('Property Name') if section == 0 else self.tr('Property Value')
+        return QVariant()
+
+    def _keys(self, parent=None):
+        types = self._property_type(parent)
+        return self._sort_keys(types) if isinstance(types, dict) else None
+    
+    def _properties(self, index):
+        properties = self._data
+        for property_ in self._property_path(index):
+            if properties is None:
+                break
+            properties = properties.get(property_.name, None)
+        return properties
+    
+    def _set_property(self, index, value):
+        property_path = self._property_path(index)
+        properties = self._data
+        for property_ in property_path[:-1]:
+            properties = properties.setdefault(property_.name, {})
+        type_ = self._property_type(index)
+        try:
+            value = type_(value)
+        except ValueError:
+            value = properties.get(property_path[-1].name)
+        properties[property_path[-1].name] = value
+        self.propertyChanged.emit(property_path[-1], value)
+    
+    def _property_name(self, index):
+        property_path = self._property_path(index)
+        property_enum = property_path[-1]
+        return self.propertyNames.get(property_enum, property_enum.name)
+    
+    def _property_key(self, properties, index):
+        return self._sort_keys(properties)[index.row()]
+    
+    def _property_type(self, index):
+        types = self.propertyTypes
+        for property_ in self._property_path(index):
+            types = types[property_]
+        return types
+    
+    def _property_path(self, parent):
+        ancestors = []
+        while parent is not None and parent.isValid():
+            ancestors.insert(0, parent)
+            parent = self.parent(parent)
+        properties = self.propertyTypes
+        property_path = []
+        for ancestor in ancestors:
+            property_keys = self._sort_keys(properties)
+            current_property = property_keys[ancestor.row()]
+            properties = properties[current_property]
+            property_path.append(current_property)
+        return property_path
+    
+    @property
+    def propertyNames(self):
+        raise NotImplementedError()
+    
+    @property
+    def propertyTypes(self):
+        raise NotImplementedError()
+
+    @staticmethod
+    def _sort_keys(dict_):
+        return list(sorted(dict_.keys(), key=lambda v: v.value if isinstance(v, Enum) else v))

pyqttoolkit/models/dicttable.py

@@ -0,0 +1,140 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+from PyQt5.QtCore import Qt, QAbstractTableModel, pyqtSignal, QModelIndex
+
+from pyqttoolkit.models.roles import DataRole
+
+class DictTableModel(QAbstractTableModel):
+    def __init__(self, parent, value):
+        if not isinstance(value, dict):
+            raise TypeError('value must be dict')
+        QAbstractTableModel.__init__(self, parent)
+        self._value = value
+        self._pasting = False
+        self._pasted_properties = {}
+    
+    propertyChanged = pyqtSignal(str, object, object)
+    propertiesChanged = pyqtSignal(object)
+
+    @property
+    def value(self):
+        return self._value
+
+    def setValue(self, value):
+        if not isinstance(value, dict):
+            raise TypeError('value must be dict')
+        if self._value != value:
+            new_rows = len(value.keys()) - len(self._value.keys())
+            if new_rows > 0:
+                self.beginInsertRows(QModelIndex(), self.rowCount(), self.rowCount() + new_rows - 1)
+            elif new_rows < 0:
+                self.beginRemoveRows(QModelIndex(), self.rowCount() + new_rows, self.rowCount() - 1)
+    
+            self._value = value
+            start_index = self.createIndex(0, 0)
+            end_index = self.createIndex(self.rowCount(), self.columnCount())
+
+            self.dataChanged.emit(start_index, end_index)
+
+            if new_rows > 0:
+                self.endInsertRows()
+            elif new_rows < 0:
+                self.endRemoveRows()
+
+    def data(self, index, role=None):
+        role = role or Qt.DisplayRole
+        if role in [Qt.DisplayRole, Qt.EditRole]:
+            value = self._value[self._ids[index.row()]].get(self.displayProperties[index.column()])
+            if value is None:
+                return None
+            return self._format_value(value, index)
+        return None
+    
+    def _format_value(self, value, index):
+        if isinstance(value, float):
+            return '{:0.2f}'.format(value)
+        return value
+
+    def setData(self, index, value, role=None):
+        role = role or Qt.EditRole
+        if role == Qt.EditRole:
+            if index.row() >= self.rowCount() or index.column() >= self.columnCount():
+                return False
+            id_ = self._ids[index.row()]
+            property_ = self.displayProperties[index.column()]
+            type_ = self.valueTypes[self.propertyType[property_]]
+            try:
+                converted_value = type_(value)
+                self._value[id_][property_] = converted_value
+            except ValueError:
+                return False
+            if not self._pasting:
+                self.dataChanged.emit(index, index)
+                self.propertyChanged.emit(id_, self.propertyType[property_], converted_value)
+            else:
+                self._pasted_properties[(id_, self.propertyType[property_])] = converted_value
+            return True
+        return False
+    
+    def headerData(self, section, orientation, role=None):
+        role = role or Qt.DisplayRole
+        if role in [Qt.DisplayRole, DataRole]:
+            if orientation == Qt.Vertical:
+                return self._ids[section]
+            else:
+                return self.headings[self.propertyType[self.displayProperties[section]]]
+        return None
+    
+    def beginPaste(self):
+        self.blockSignals(True)
+        self._pasting = True
+    
+    def endPaste(self, from_index, to_index):
+        self._pasting = False
+        self.blockSignals(False)
+        self.dataChanged.emit(from_index, to_index)
+        self.propertiesChanged.emit(self._pasted_properties)
+        self._pasted_properties = {}
+    
+    def flags(self, _index):
+        return Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsEditable
+
+    def columnCount(self, _parent=None):
+        return len(self.displayProperties)
+    
+    def rowCount(self, _parent=None):
+        return len(self._ids)
+    
+    @property
+    def _ids(self):
+        return list(sorted(self._value.keys()))
+
+    @property
+    def propertyType(self):
+        raise NotImplementedError()
+    
+    @property
+    def displayProperties(self):
+        raise NotImplementedError()
+    
+    @property
+    def valueTypes(self):
+        raise NotImplementedError()
+    
+    @property
+    def headings(self):
+        raise NotImplementedError()

pyqttoolkit/models/json_text.py

@@ -0,0 +1,52 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+from json import loads, dumps, JSONDecodeError
+
+from PyQt5.QtCore import QObject, pyqtSignal
+
+from pyqttoolkit.properties import AutoProperty
+
+class JsonTextModel(QObject):
+    def __init__(self, parent):
+        QObject.__init__(self, parent)
+        self.textChanged.connect(self._set_data)
+        self._data = {}
+        self.text = '{}'
+
+    textChanged = pyqtSignal(str)
+    validationMessageChanged = pyqtSignal(str)
+
+    text = AutoProperty(str)
+    validationMessage = AutoProperty(str)
+
+    @property
+    def data(self):
+        return self._data
+    
+    @data.setter
+    def data(self, value):
+        self.text = dumps(
+            value, sort_keys=True,
+            indent=2, separators=(',', ': ')
+        )
+
+    def _set_data(self, value):
+        try:
+            self._data = loads(value)
+            self.validationMessage = ''
+        except JSONDecodeError:
+            self.validationMessage = self.tr('Error in JSON')