Beispiel #1
0
    def show_table_context_menu(self, position):
        col = self.dataWidget.columnAt(position.x())
        dialog = QDialog(self, Qt.Popup)
        schema_view = QTreeWidget(dialog)
        schema_view.headerItem().setText(0, "Field")
        schema_view.headerItem().setText(1, "Type")
        root = type_parser.parse(self.data_schema[col])
        schema_tree = self.type_tree(
            self.dataWidget.horizontalHeaderItem(col).text(), root)
        schema_view.addTopLevelItem(schema_tree)
        schema_view.expandToDepth(2)
        schema_view.header().setStretchLastSection(False)
        schema_view.setSizeAdjustPolicy(
            QAbstractScrollArea.AdjustToContentsOnFirstShow)
        schema_view.header().setSectionResizeMode(QHeaderView.ResizeToContents)
        schema_view.setMinimumHeight(30)
        schema_view.setMaximumHeight(400)
        schema_view.adjustSize()
        schema_view.setHeaderHidden(True)

        dialog.move(
            self.dataWidget.mapToGlobal(position) +
            QPoint(dialog.width() / 5 * 2,
                   dialog.height() + 5))
        dialog.adjustSize()
        dialog.show()
Beispiel #2
0
class Pytree(QMainWindow): 
    def __init__(self,parent=None):
        super(Pytree,self).__init__(parent)
        self.centralWidget = QWidget()
        self.setCentralWidget(self.centralWidget)
        self.setWindowTitle('Dynamic Categorizer')
        self.setMinimumWidth(600)
        self.removedmnemonicdict={}        
        self.layout = QHBoxLayout(self.centralWidget)

        self.setLayout(self.layout)
        self.tree=QTreeWidget()
        self.layout.addWidget(self.tree)

        self.select_btn= QPushButton("Select")
        self.layout.addWidget(self.select_btn)
        

        # self.treeview_dict={
        #     'MD':{
        #         'LWD':{
        #             'file4':['200-500','43','gr mfs'],
        #             'file5':['300-450','54','gr mfs']
        #         },
        #         'WireLine':{
        #             'file6':['450-670','2','gr mfs']
        #         }

        #     },
        #     'TVD':{
        #         'LWD':{
        #             'file1':['123-789','45','gr mfs'],
        #             'file2':['234-456','23','gr mfs']
        #         },
        #         'WireLine':{
        #             'file3':['124-789','12','gr mfs']
        #         }

        #     }
            
        # }
        # self.treeview_dict={'MD': {'LWD': {'W2_17in_APWD-Time_LAS.las': ["('465.29', '340.99')", '5', ''], 'W2_8in_Pilot_VISION_Resistivity_APWD_TIME_LAS.LAS': ["('118.14', '501.29')", '5', ''], 'W2_8in_Pilot_VISION_Resistivity_MD_LAS.LAS': ['(119.7864, 503.9868)', '5', 'GR,LLD,LLS,MSFL'], 'W2_VISION_RESISTIVITY-APWD_17in_RM_500-1445m.las': ['(499.872, 1445.2092)', '5', 'GR,LLD,LLS,MSFL']}, 'WireLine': {'W2_12in_DLIS_1430-3100m.las': ['(1429.9692, 3099.9684)', '5', 'GR,LLD,LLS,MSFL,RHOB,NPHI']}}, 'TVD': {}}
        # # item    = QTreeWidgetItem()
    
    def buildTree(self):    
        self.tree.headerItem().setText(0, "File name")
        self.tree.headerItem().setText(1, "Depth Range")
        self.tree.headerItem().setText(2, "No of useful Logs")
        self.tree.headerItem().setText(3, "Log Names")

        for key in self.treeview_dict:
            parent = QTreeWidgetItem(self.tree)
            parent.setText(0, key)
            # parent.setFlags(parent.flags() | Qt.ItemIsTristate )
            parent.setFlags(parent.flags())
            
            for subkey in self.treeview_dict[key]:
                child = QTreeWidgetItem(parent)
                child.setFlags(child.flags()  )
                # child.setFlags(child.flags() | Qt.ItemIsTristate | Qt.ItemIsUserCheckable)
                child.setText(0, subkey)
                # child.setCheckState(0, Qt.Unchecked)
                for thirdkey in self.treeview_dict[key][subkey]:
                    subchild = QTreeWidgetItem(child)
                    subchild.setFlags(child.flags()  | Qt.ItemIsUserCheckable)
                    subchild.setText(0, thirdkey)
                    subchild.setCheckState(0, Qt.Unchecked)

                    #create the checkbox
                    finaldict=self.treeview_dict[key][subkey][thirdkey]
                    subchild.setText(0, thirdkey)
                    # for fourthkey in finaldict:
                    for i,descr in enumerate(finaldict):
                        # if i < 3:
                        subchild.setText(i+1, descr)
                            # subchild.setCheckState(i, Qt.Unchecked)
                        # if i == 3:
                        #     subchild.setText(i, "Any Notes?")
                        #     subchild.setFlags(subchild.flags() | Qt.ItemIsEditable)
        self.tree.expandToDepth(1)
    def set_tree(self,treeview_dict):
        # self.tree.
        self.treeview_dict=treeview_dict
    def __init__(self):
        super().__init__()

        self.setWindowTitle('Drive Analysis Tool')
        # self.root_path = os.path.expanduser('~')  # BUG 2018-09-18: No permission to access certain files for os.stat
        self.root_path = os.path.expanduser('~\\Downloads')
        self.threadpool = QThreadPool()
        self.resize_mode = 'dynamic'

        with open(
                os.path.expanduser(
                    os.path.join('~', 'Dropbox', 'mcgill', 'File Zoomer',
                                 'code', 'drive_analysis_tool',
                                 'dir_dict.pkl')), 'rb') as ddf:
            dir_dict = pickle.load(ddf)

        test_btn = QPushButton()
        test_btn.setText('Run tests')
        test_btn.resize(test_btn.sizeHint())

        tree = QTreeWidget()
        tree.setColumnCount(2)
        tree.header().setSectionResizeMode(0, QHeaderView.ResizeToContents)
        tree.header().setSectionResizeMode(1, QHeaderView.ResizeToContents)

        anon_tree = QTreeWidget()
        anon_tree.setColumnCount(2)
        anon_tree.header().setSectionResizeMode(0,
                                                QHeaderView.ResizeToContents)
        anon_tree.header().setSectionResizeMode(1,
                                                QHeaderView.ResizeToContents)

        prev_item = None
        curr_item = None

        def append_all_children(dirkey, dir_dict, parent_item, checkable=True):
            if dirkey in dir_dict:
                # print(type(parent_item), parent_item.text(0))
                item = QTreeWidgetItem(parent_item, [
                    dir_dict[dirkey]['dirname'],
                    str(dir_dict[dirkey]['nfiles'])
                ])
                item.setData(0, Qt.UserRole, dirkey)
                if checkable:
                    item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
                    item.setCheckState(0, Qt.Checked)
                    # parent_item.setFlags(parent_item.flags() | Qt.ItemIsAutoTristate | Qt.ItemIsUserCheckable)
                    parent_item.setFlags(parent_item.flags()
                                         | Qt.ItemIsUserTristate
                                         | Qt.ItemIsUserCheckable)
                    # parent_item.setFlags(parent_item.flags() | Qt.ItemIsUserCheckable)
                parent_item.addChild(item)
                # print(type(item.parent()), type(parent_item))
                child_ix = parent_item.childCount() - 1
                # print(nchild, parent_item.child(nchild).text(0), type(parent_item.child(nchild)))
                parent_item = parent_item.child(child_ix)
                # print(type(parent_item))
                children_keys = dir_dict[dirkey]['childkeys']
                children_names = [
                    dir_dict[child]['dirname'].lower()
                    for child in children_keys
                ]
                for child_name, child_key in sorted(
                        zip(children_names, children_keys)):
                    append_all_children(child_key, dir_dict, parent_item,
                                        checkable)

        def on_current_item_change(item, previous_item):
            # tree.setCurrentItem(current_item)
            parent_item = item.parent()
            child_ix = parent_item.indexOfChild(item)
            item_checkstate = item.checkState(0)
            if previous_item is not None:
                if previous_item.parent() != item:
                    propagate_checkstate_child(parent_item, child_ix,
                                               item_checkstate)

        def on_item_change_old(item):
            if item.checkState(0) in (Qt.Checked, Qt.PartiallyChecked):
                # print(item.text(0))
                if item.parent() is not None:
                    if item.parent().checkState(
                            0) == Qt.Unchecked and item.checkState(
                                0) == Qt.PartiallyChecked:
                        # print('True!')
                        item.parent().setCheckState(Qt.PartiallyChecked)

        def on_item_change(item):
            #####
            ## This is meant to work with the following:
            ## -- in append_all_children:
            ##    parent_item.setFlags(parent_item.flags() | Qt.ItemIsUserTristate | Qt.ItemIsUserCheckable)
            ## -- the following functions are used:
            ##    propagate_checkstate_child, propagate_checkstate_parent
            ## -- Updating the parent from Qt.PartiallyChecked to Qt.Checked when all children are checked has not
            ##    been implemented.
            #####
            # tree.setCurrentItem(item)
            # curr_item = item
            item_checkstate = item.checkState(0)
            parent_item = item.parent()
            # print(type(item), type(parent_item))
            # print(item.text(0))
            if parent_item is None:
                # print(item.childCount())
                nchild = item.childCount()
                if nchild > 0:
                    for child_ix in range(nchild):
                        propagate_checkstate_child(item, child_ix,
                                                   item_checkstate)
            if parent_item is not None:
                child_ix = parent_item.indexOfChild(item)
                # print('child parent ix: ', child_ix)
                # if prev_item is not None:
                #     if curr_item != prev_item.parent():
                propagate_checkstate_child(
                    parent_item, child_ix, item_checkstate
                )  ### HOW DO I APPLY THIS TO THE ROOT ITEM AS WELL???? ###
                propagate_checkstate_parent(item, item_checkstate)
                # print(item.data(0, Qt.UserRole))
                # print("# selected items: ", len(tree.selectedItems()))
            unchecked_items_list = []
            list_unchecked(root_item, 0, unchecked_items_list)
            # print(unchecked_items_list)
            anon_tree.clear()
            anon_dir_dict = deepcopy(dir_dict)
            # print(unchecked_items_list)
            anon_dir_dict = anonymize_stat(anon_dir_dict, unchecked_items_list)
            # print(set(dir_dict.keys()).difference(anon_dir_dict.keys()))
            anon_root_item = QTreeWidget.invisibleRootItem(anon_tree)
            append_all_children(1,
                                anon_dir_dict,
                                anon_root_item,
                                checkable=False)
            anon_tree.expandToDepth(0)
            # prev_item = item

        def propagate_checkstate_child(parent_item, child_ix,
                                       parent_checkstate):
            # print('child ix: ', child_ix)
            if parent_checkstate != Qt.PartiallyChecked:
                parent_item.child(child_ix).setCheckState(0, parent_checkstate)
                # print(parent_item.child(child_ix).data(0, Qt.UserRole))
                parent_item = parent_item.child(child_ix)
                nchild = parent_item.childCount()
                if nchild > 0:
                    for child_ix in range(nchild):
                        propagate_checkstate_child(parent_item, child_ix,
                                                   parent_checkstate)

        def propagate_checkstate_child_root(item, item_checkstate):
            if item_checkstate != Qt.PartiallyChecked:
                item.setCheckState(0, item_checkstate)
                nchild = item.childCount()
                print(nchild)
                if nchild > 0:
                    for child_ix in range(nchild):
                        print(item.child(child_ix).text(0))
                #         propagate_checkstate_child_root(item, item_checkstate)

        def propagate_checkstate_parent(item, item_checkstate):
            parent_item = item.parent()
            if parent_item is not None:
                # print(all_sibling_checked(item))
                if all_sibling_checked(item):
                    parent_item.setCheckState(0, Qt.Checked)
                if item_checkstate == Qt.Checked and parent_item.checkState(
                        0) == Qt.Unchecked:
                    parent_item.setCheckState(0, Qt.PartiallyChecked)
                if item_checkstate == Qt.PartiallyChecked:
                    parent_item.setCheckState(0, Qt.PartiallyChecked)
                if item_checkstate in (
                        Qt.Unchecked, Qt.PartiallyChecked
                ) and parent_item.checkState(0) == Qt.Checked:
                    parent_item.setCheckState(0, Qt.PartiallyChecked)

        def all_sibling_checked(item):
            all_checked = True
            if item.parent() is not None:
                parent_item = item.parent()
                nchild = parent_item.childCount()
                for child_ix in range(nchild):
                    if parent_item.child(child_ix).checkState(0) in (
                            Qt.Unchecked, Qt.PartiallyChecked):
                        all_checked = False
                        break
            return all_checked

        def list_unchecked(parent_item, child_ix, unchecked_items):
            # the assumption is there are fewer deselected dirs than selected
            item = parent_item.child(child_ix)
            # print(item.checkState(0))
            # if item.checkState(0) in (Qt.Checked, Qt.PartiallyChecked):
            if item.checkState(0) == Qt.Unchecked:
                unchecked_items.append(item.data(0, Qt.UserRole))
            parent_item = parent_item.child(child_ix)
            nchild = parent_item.childCount()
            if nchild > 0:
                for child_ix in range(nchild):
                    list_unchecked(parent_item, child_ix, unchecked_items)

        def test_script():
            unchecked_items_list = []
            list_unchecked(root_item, 0, unchecked_items_list)
            print(set(dir_dict.keys()).difference(anon_dir_dict.keys()))
            print(unchecked_items_list)

        # root_item = QTreeWidgetItem(tree, [dir_dict[1]['dirname'], str(dir_dict[1]['nfiles'])])
        root_item = QTreeWidget.invisibleRootItem(tree)
        # hidden_item = QTreeWidgetItem(root_item, ['hello', 'world']).setHidden(False)
        # root_item.addChild(hidden_item)
        append_all_children(1, dir_dict, root_item)
        # print(type(root_item), root_item.childCount(), root_item.parent())
        tree.expandToDepth(0)
        tree.itemChanged.connect(on_item_change)
        # tree.currentItemChanged.connect(on_current_item_change)
        test_btn.clicked.connect(test_script)
        # print("n_child: ", root_item.childCount())
        # print("n_child: ", root_item.child(0).childCount())
        # print(root_item.child(0).indexOfChild(root_item.child(0).child(10)))
        # unchecked_items_list = []
        # list_unchecked(root_item, 0, unchecked_items_list)
        # print(unchecked_items_list)
        anon_dir_dict = deepcopy(dir_dict)
        anon_root_item = QTreeWidget.invisibleRootItem(anon_tree)
        # unchecked_items_list = [2, 10]
        # anon_dir_dict = anonymize_stat(anon_dir_dict, unchecked_items_list)
        append_all_children(1, anon_dir_dict, anon_root_item, checkable=False)
        anon_tree.expandToDepth(0)

        # self.ogtree = QTreeWidget(self)
        # self.ogtree.setColumnCount(2)
        # items = []
        # for i in range(10):
        #     items.append(QTreeWidgetItem(self.ogtree, [str(i), str(i)]))
        # self.ogtree.insertTopLevelItems(999, items)
        # self.ogtree.addTopLevelItems(items)
        # self.ogtree.addTopLevelItems(items)
        # self.ogtree.insertTopLevelItem(12123123, QTreeWidgetItem(self.ogtree, ['hello', 'world']))
        # self.ogtree.insertTopLevelItem(12123123, QTreeWidgetItem(self.ogtree, ['hello', 'world']))
        # print(self.ogtree.indexOfTopLevelItem(items[9]))
        # items[1].addChild(QTreeWidgetItem(items[1], ['bad', 'juju']))

        grid = QGridLayout()
        # grid.addWidget(self.ogtree, 0, 0, 1, 4)
        grid.addWidget(test_btn, 0, 0, 1, 1)
        grid.addWidget(tree, 1, 0, 1, 4)
        grid.addWidget(anon_tree, 1, 5, 1, 4)

        self.setLayout(grid)
        self.resize(640, 480)
        self.show()
class DriveAnalysisWidget(QWidget):
    def __init__(self):
        super().__init__()

        self.setWindowTitle('Drive Analysis Tool')
        # self.root_path = os.path.expanduser('~')  # BUG 2018-09-18: No permission to access certain files for os.stat
        self.root_path = os.path.expanduser('~\\Downloads')
        self.threadpool = QThreadPool()
        self.resize_mode = 'dynamic'
        self.unchecked_items_list = []

        with open(
                os.path.expanduser(
                    os.path.join('~', 'Dropbox', 'mcgill', 'File Zoomer',
                                 'code', 'drive_analysis_tool',
                                 'dir_dict.pkl')), 'rb') as ddf:
            self.og_dir_dict = pickle.load(ddf)

        test_btn = QPushButton()
        test_btn.setText('Run tests')
        test_btn.resize(test_btn.sizeHint())
        test_btn.clicked.connect(self.test_script)

        self.og_tree = QTreeWidget()
        self.og_tree.setColumnCount(3)
        self.og_tree.header().setSectionResizeMode(
            0, QHeaderView.ResizeToContents)
        self.og_tree.header().setSectionResizeMode(
            1, QHeaderView.ResizeToContents)
        self.og_tree.header().setSectionResizeMode(
            2, QHeaderView.ResizeToContents)
        self.og_tree.setHeaderLabels(
            ['Folder', 'Renamed Folder', 'Number of Files'])

        self.anon_tree = QTreeWidget()
        self.anon_tree.setColumnCount(3)
        self.anon_tree.header().setSectionResizeMode(
            0, QHeaderView.ResizeToContents)
        self.anon_tree.header().setSectionResizeMode(
            1, QHeaderView.ResizeToContents)
        self.anon_tree.header().setSectionResizeMode(
            2, QHeaderView.ResizeToContents)
        self.anon_tree.setHeaderLabels(
            ['Folder', 'Renamed Folder', 'Number of Files'])

        self.og_root_item = QTreeWidget.invisibleRootItem(self.og_tree)
        self.append_all_children(1, self.og_dir_dict, self.og_root_item)
        self.og_tree.expandToDepth(0)
        self.og_tree.itemChanged.connect(self.on_item_change)
        self.anon_dir_dict = deepcopy(self.og_dir_dict)
        self.anon_root_item = QTreeWidget.invisibleRootItem(self.anon_tree)
        self.append_all_children(1,
                                 self.anon_dir_dict,
                                 self.anon_root_item,
                                 checkable=False)
        self.anon_tree.expandToDepth(0)

        grid = QGridLayout()
        grid.addWidget(test_btn, 0, 0, 1, 1)
        grid.addWidget(self.og_tree, 1, 0, 1, 4)
        grid.addWidget(self.anon_tree, 1, 5, 1, 4)

        self.setLayout(grid)
        self.resize(640, 480)
        self.show()

    def append_all_children(self,
                            dirkey,
                            dir_dict,
                            parent_item,
                            checkable=True):
        if dirkey in dir_dict:
            item = QTreeWidgetItem(parent_item, [
                dir_dict[dirkey]['dirname'], dir_dict[dirkey]['dirname'],
                str(dir_dict[dirkey]['nfiles'])
            ])
            item.setData(0, Qt.UserRole, dirkey)
            if checkable:
                item.setFlags(item.flags() | Qt.ItemIsUserCheckable
                              | Qt.ItemIsEditable)
                item.setCheckState(0, Qt.Checked)
                parent_item.setFlags(parent_item.flags()
                                     | Qt.ItemIsUserTristate
                                     | Qt.ItemIsUserCheckable)
            parent_item.addChild(item)
            child_ix = parent_item.childCount() - 1
            parent_item = parent_item.child(child_ix)
            children_keys = dir_dict[dirkey]['childkeys']
            children_names = [
                dir_dict[child]['dirname'].lower() for child in children_keys
            ]
            for child_name, child_key in sorted(
                    zip(children_names, children_keys)):
                self.append_all_children(child_key, dir_dict, parent_item,
                                         checkable)

    def on_item_change(self, item):
        item_checkstate = item.checkState(0)
        parent_item = item.parent()
        if parent_item is None:
            nchild = item.childCount()
            if nchild > 0:
                for child_ix in range(nchild):
                    self.propagate_checkstate_child(item, child_ix,
                                                    item_checkstate)
        if parent_item is not None:
            child_ix = parent_item.indexOfChild(item)
            self.propagate_checkstate_child(parent_item, child_ix,
                                            item_checkstate)
            self.propagate_checkstate_parent(item, item_checkstate)
        self.unchecked_items_list = []
        self.list_unchecked(self.og_root_item, 0, self.unchecked_items_list)
        self.anon_tree.clear()
        self.anon_dir_dict = deepcopy(self.og_dir_dict)
        self.anon_dir_dict = anonymize_stat(self.anon_dir_dict,
                                            self.unchecked_items_list)
        self.anon_root_item = QTreeWidget.invisibleRootItem(self.anon_tree)
        self.append_all_children(1,
                                 self.anon_dir_dict,
                                 self.anon_root_item,
                                 checkable=False)
        self.anon_tree.expandToDepth(0)

    def propagate_checkstate_child(self, parent_item, child_ix,
                                   parent_checkstate):
        if parent_checkstate != Qt.PartiallyChecked:
            parent_item.child(child_ix).setCheckState(0, parent_checkstate)
            parent_item = parent_item.child(child_ix)
            nchild = parent_item.childCount()
            if nchild > 0:
                for child_ix in range(nchild):
                    self.propagate_checkstate_child(parent_item, child_ix,
                                                    parent_checkstate)

    def propagate_checkstate_parent(self, item, item_checkstate):
        parent_item = item.parent()
        if parent_item is not None:
            if self.all_sibling_checked(item):
                parent_item.setCheckState(0, Qt.Checked)
            if item_checkstate == Qt.Checked and parent_item.checkState(
                    0) == Qt.Unchecked:
                parent_item.setCheckState(0, Qt.PartiallyChecked)
            if item_checkstate == Qt.PartiallyChecked:
                parent_item.setCheckState(0, Qt.PartiallyChecked)
            if item_checkstate in (
                    Qt.Unchecked, Qt.PartiallyChecked
            ) and parent_item.checkState(0) == Qt.Checked:
                parent_item.setCheckState(0, Qt.PartiallyChecked)

    def all_sibling_checked(self, item):
        all_checked = True
        if item.parent() is not None:
            parent_item = item.parent()
            nchild = parent_item.childCount()
            for child_ix in range(nchild):
                if parent_item.child(child_ix).checkState(0) in (
                        Qt.Unchecked, Qt.PartiallyChecked):
                    all_checked = False
                    break
        return all_checked

    def list_unchecked(self, parent_item, child_ix, unchecked_items):
        item = parent_item.child(child_ix)
        if item.checkState(0) == Qt.Unchecked:
            unchecked_items.append(item.data(0, Qt.UserRole))
        parent_item = parent_item.child(child_ix)
        nchild = parent_item.childCount()
        if nchild > 0:
            for child_ix in range(nchild):
                self.list_unchecked(parent_item, child_ix, unchecked_items)

    def test_script(self):
        unchecked_items_list = []
        self.list_unchecked(self.root_item, 0, unchecked_items_list)
        print(
            set(self.og_dir_dict.keys()).difference(self.anon_dir_dict.keys()))
        print(unchecked_items_list)