Treeview

class Treeview(Base, ttk.Treeview):
    def __init__(self, parent, key, **kwargs):
        Base.__init__(self, parent, key, **kwargs)
        columns = dict(kwargs.get('settings', ())).get('columns', ())
        headings = dict(kwargs.get('settings', ())).get('headings', ())
        ttk.Treeview.__init__(self, parent, columns=tuple(range(1, len(columns))), **self.options_args)
        # self['columns'] = range(1, len(columns))
        self.column_sort = {}

        for index, column in enumerate(columns):
            self.column(f'#{index}', **dict(column))

        for index, heading in enumerate(headings):
            self.column_sort[f'#{index}'] = False
            self.heading(f'#{index}', **dict(heading))

        self.grid(**self.grid_args)
        parent.winfo_toplevel().style.configure("Treeview", fieldbackground="black")

        def on_click(event):
            region = self.identify("region", event.x, event.y)
            if region == "heading":
                column_number = self.identify_column(event.x)
                print(111, column_number)
                if self.column_sort[column]:
                    self.column_sort[column] = False
                else:
                    self.column_sort[column] = True

                self.sortit(column_number, self.column_sort[column])

            if region == "separator":
                column_number = self.identify_column(event.x)
                self.separator_double_click(column_number)

        self.bind("<Button-1>", on_click)

    def __str__(self):
        return str(self.get_nodes())

    def cut(self):
        self.copy()
        self.remove()

    def copy(self):
        data = self.get_nodes(self.selection()[0])
        if data:
            self.winfo_toplevel().clipboard_clear()
            self.winfo_toplevel().clipboard_append(str(data))

    def paste(self):
        try:
            data = literal_eval(self.winfo_toplevel().clipboard_get())
            self.populate(self.selection()[0], **data)
        except ValueError:
            pass

    def sortit(self, col, reverse):
        col = col.lstrip('#')

        column_data = []
        for k in self.get_children():
            column_data.append(k)
        column_data.sort(reverse=reverse)

        for index, k in enumerate(column_data):
            self.move(k, '', index)

        # reverse sort next time
        self.heading(col, command=lambda _col=col: self.sortit(_col, not reverse))

    def add(self, parent, index=tk.END, **kwargs):
        try:
            self.insert(parent, index, **kwargs)
        except TclError as err:
            if 'already exists' in str(err):
                messagebox.showerror(
                    title='Create Project',
                    message=f'The name you entered," {kwargs.get("text", "")}" already exists. '
                            f'Choose another name and try again.'
                    )

    def append(self, parent, **kwargs):
        self.add(parent, tk.END, **kwargs)

    def remove(self):
        selection = self.selection()[0]

        _prev = self.prev(selection)
        _next = self.next(selection)

        self.delete(selection)
        if _next:
            self.selection_set(_next)
        else:
            _next = '_'.join(selection.split('_')[:-1])
            if not self.next(_next):
                _next = '_'.join(_next.split('_')[:-1])
                if not self.next(_next):
                    self.select_tail()
            if self.next(_next):
                self.selection_set(self.next(_next))

    def populate(self, parent, index=tk.END, **data):
        _cache = Cache(**data)

        def walk(_cfg, iid, _parent):
            attrs = {}
            cfg = deepcopy(_cfg)

            for _key, value in _cfg.items():
                if not isinstance(value, dict):
                    attrs[_key] = cfg.pop(_key)

            iid = f'{_parent}_{iid.split("_")[-1]}'.lstrip('_')
            self.insert(_parent, index, iid=iid, **attrs)

            for _key, value in cfg.items():
                walk(value, f'{_key.split("_")[-1]}', iid)

        for key, node in data.items():
            walk(node, key, parent)

    def get_nodes(self, uri=None):
        data = Cache()

        def walk(*args):
            parent = args[0]
            children = args[1]

            for child in children:
                _uri = f'{parent}/{child}'
                data.set(_uri, **self.item(child))

                child_children = self.get_children(child)

                if child_children:
                    walk(_uri, child_children)

        if uri:
            data.set(uri, **self.item(uri))
            walk(uri, self.get_children(uri))
        else:
            for uri in self.get_children():
                data.set(uri, **self.item(uri))
                walk(uri, self.get_children(uri))

        return deepcopy(data.get())

    def separator_double_click(self, column):
        _cache = Cache(**self.get_nodes())

        _frame = ttk.Frame(self.winfo_toplevel())

        def walk(children, _maximum=0):

            for child in children:
                if not self.item(child)['open']:
                    continue
                if self.get_children(child):

                    for item in self.get_children(child):
                        parts = item.split('_')
                        _size = 20 * len(parts)
                        if column == '#0':
                            text = self.item(item).get('text', '')
                        else:
                            text = self.item(item).get('values', '')[int(column.lstrip('#'))]

                        x = tk.Label(_frame, text=text)
                        x.grid()
                        _frame.update_idletasks()
                        _size += x.winfo_width()

                        if _size > _maximum:
                            _maximum = _size
                    return walk(self.get_children(child), _maximum)

            return _maximum

        maximum = 0
        for uri in self.get_children():
            size = walk(self.get_children(uri), maximum)
            if size > maximum:
                maximum = size

        print(maximum)
        if self.column(column)['width'] == maximum:
            self.column(column, width=3)
        else:
            self.column(column, width=maximum)

    def select_tail(self):
        def walk(children):
            if children:
                child = list(children).pop()
                if self.item(child)['open']:
                    walk(self.get_children(child))
                    if len(self.get_children(child)) == 0:
                        self.selection_set(child)
                else:
                    self.selection_set(child)

        walk(self.get_children())