Привязка scrollbar к spinbox

import sys
import wave
import numpy as np
import pyqtgraph as pg
#import matplotlib.pyplot as plt
#import plotly.graph_objects as go
#import numba #библиотека куды на питоне
 
 
from PyQt5 import QtWidgets
from PyQt5.QtWidgets import QDialog, QApplication, QFileDialog, QMessageBox
from PyQt5.uic import loadUi
from scipy import signal
 
from new_win import Ui_Dialog
#from pyqtgraph import PlotWidget, plot
 
 
 
class Spectroscope(QDialog):
 
    def __init__(self):
        super(Spectroscope, self).__init__()
        loadUi('gui1.ui', self)
        self.progress.setValue(0)
 
        self.choose.clicked.connect(self.browsefiles)
        self.choose2.clicked.connect(self.getnumber)
        self.plot_gr.clicked.connect(self.graf)
        self.call.clicked.connect(self.calculate)
        self.combo.activated[str].connect(self.getnumber)
        self.choose2.setDisabled(True)
        self.call.setDisabled(True)
        self.plot_gr.setDisabled(True)
        self.ScrollBar.valueChanged.connect(self.slide)
        self.win2.clicked.connect(self.gotowin2)
 
        self.spinBox.setRange(0, 1023)
 
#два окна для постройки графиков
 
 
        grid = QtWidgets.QGridLayout(self.widget)
        grid.addWidget(self.widget, 0, 0)
        grid = QtWidgets.QGridLayout(self.widget_2)
        grid.addWidget(self.widget_2, 0, 0)
        self.widget.showGrid(x=True, y=True)#сетка
        self.widget_2.showGrid(x=True, y=True)#сетка
        self.pen = pg.mkPen(color=(255, 0, 0))#указка
 
 
    def gotowin2(self):
        self.window = QtWidgets.QDialog()
        self.ui = Ui_Dialog()
        self.ui.setupUi(self.window)
        self.window.show()
 
 
 
    def calculate(self):
        self.message = 'ВНИМАНИЕ!   Было изменено значение конечного аргумента на минимально возможное: "значение начала" + размер блока. Вы уверены что хотите продолжить?'
        if (self.end <= (self.begin + 1024)) & (self.file.getnchannels() == 1):
            self.end = self.begin + 1024
            self.reply = QMessageBox.question(self, 'Уведомление', self.message)
        if (self.end <= (self.begin + 2048)) & (self.file.getnchannels() == 2):
            self.end = self.begin + 2048
            self.reply = QMessageBox.question(self, 'Уведомление', self.message)
        self.plot_gr.setDisabled(False)
        self.count_block = int((self.end - self.begin) / self.temp)  # колличество блоков
        self.count_block = int((self.end - self.begin + self.count_block * self.p) / self.temp)  # колличество блоков с учетом перекрытий
        self.count_block2 = int((self.end - self.begin) / self.temp2)  # колличество блоков
        self.count_block2 = int((self.end - self.begin + self.count_block2 * self.p) / self.temp2)  # колличество блоков с учетом перекрытий
 
 
 
 
    def browsefiles(self):
        # обьявление переменных
        self.widget.clear()
        self.widget_2.clear()
        self.fname = QFileDialog.getOpenFileName(self, 'Open file', 'C:\\Qt\\WORKED', 'Wave files(*.wav)')
        self.filename.setText(self.fname[0])
        self.file = wave.open(self.fname[0], 'r')
        self.len_file = self.file.getnframes()
        self.label_6.setText(str(self.len_file))
        self.begining.setRange(0, self.len_file - 1024)
        self.begin = self.begining.value()
        self.ending.setRange(self.begin + 1, self.len_file)
        self.end = self.ending.value()
        self.p = self.spinBox.value()
        self.choose2.setDisabled(False)
        # self.progress.setValue(5)
 
 
    def getnumber(self):
        self.begin = self.begining.value()
        self.end = self.ending.value()
        self.p = self.spinBox.value()
        print(self.p)
        print(self.begin)
        print(self.end)
        self.temp = 1024  # размер блока для моно
        self.temp2 = 2048  # размер блока для стерео
        self.file = wave.open(self.fname[0], 'r')  # открытие файла на чтение
        # Массивы
        self.Y = np.zeros(self.temp)
        self.result = np.zeros(self.temp)  # массив перемноженных отсчетов сигнала на отсчеты окна чебышева
        self.G = []
 
        # отсчеты окна чебышева, их должно быть temp-штук
        db = int(self.combo.currentText())
        N = 1024
 
        self.cheb = signal.windows.chebwin(N, db)
        # self.progress.setValue(10)
        self.call.setDisabled(False)
 
 
    def slide(self):
        kup = self.ScrollBar.orientation()
        #kdown = self.ScrollBar.value()
        self.begin =self.begining.value() + kup
        self.end = self.ending.value() + kup
        self.begining.setValue(self.begin)
        self.ending.setValue(self.end)
 
    def graf(self):
 
        if self.file.getnchannels() == 1:
 
            for t in range(0, self.count_block):
 
                if t == 0:
                    self.progress.setValue(5)
                    self.file.setpos(0)
                    raw = self.file.readframes(self.temp)
                    raw = np.frombuffer(raw, 'int16')
 
 
                else:
                    self.progress.setValue(int(t / self.count_block * 100))
 
                    i = self.begin + t * (self.temp - self.p)
                    self.file.setpos(i)
                    raw = self.file.readframes(self.temp)
                    raw = np.frombuffer(raw, 'int16')
                i = 0
 
                while (i < self.temp):
                    self.result[i] = raw[i] * self.cheb[i]
                    i += 1
                    self.Y = self.Y + np.fft.fft(self.result) / self.temp
 
                self.t = int(self.p / 2)
 
                while (self.t < self.temp-self.p / 2) & (self.t >= self.p / 2):
                    self.G.append(self.result[self.t])
                    self.t += 1
 
            for i in range(0, 1023):
                #self.Y[i] = self.Y[i] / (self.count_block)
                self.Y[i] = 20 * np.log10(self.Y[i] / (self.count_block))
            n = len(self.result)  # length of the signal
            Fs = self.file.getframerate()
            k = np.arange(n)
            T = n / Fs
            T1 = len(self.G)
            frq = k / T  # two sides frequency range
            frq = frq[range(0, int(n / 2))]  # one side frequency range
            self.Y = self.Y[range(int(n / 2))]
            Time = np.arange(float(0),T1/Fs, 1/Fs)
            print(Time)
            # fig = go.Figure()
            #
            # fig.add_trace(
            #     go.Scatter(x=frq, y=abs(self.Y)))
            #
            # fig.update_layout(
            #     xaxis=dict(
            #         rangeselector=dict(
            #         ),
            #         rangeslider=dict(
            #             visible=True
            #         ),
            #
            #     )
            # )
            # fig.show()
 
            # fig, [ax1, ax2] = plt.subplots(nrows=2, ncols=1)
            # # # ax2.plot(frq, abs(self.Y), 'r')
            # # #ax2.fill_between(frq, abs(self.Y), color='red')  # построить с заполнением
            # ax2.plot(frq, abs(self.Y), color='red')
            # ax1.plot(self.G, color='blue')
            # plt.show()
            self.widget.setLabel("left", "Амплитуда (дб)")
            self.widget.setLabel("bottom", "Частота (Гц)")
            self.widget_2.setLabel("left", "Амплитуда")
            self.widget_2.setLabel("bottom", "Время (сек)")
 
            self.widget.plot(frq, abs(self.Y),  pen= self.pen)
            self.widget_2.plot(Time, self.G, pen= self.pen)
 
            # self.widget.plot(frq, abs(self.Y))
            # self.widget_2.plot(self.G)
            self.progress.setValue(100)
 
 
        elif self.file.getnchannels() == 2:
            result1 = np.zeros(self.temp)
            result0 = np.zeros(self.temp)
            G1 = []
            G0 = []
            Y1 = np.zeros(self.temp)
            Y0 = np.zeros(self.temp)
            j = 0
            k = 0
            for t in range(0, self.count_block2):
                if t == 0:
 
                    self.progress.setValue(5)
 
                    # self.file.setpos(0)
                    raw = self.file.readframes(self.temp)
                    raw = np.frombuffer(raw, 'int16')
                    for i in range(0, 2047):
                        if i % 2 == 0:
                            result0[j] = raw[i]
                            j += 1
                        elif i % 2 == 1:
                            result1[k] = raw[i]
                            k += 1
 
 
                else:
                    self.progress.setValue(int(t / self.count_block2 * 100))
 
                    i = self.begin + t * (self.temp - self.p)
                    self.file.setpos(i)
                    raw = self.file.readframes(self.temp)
                    raw = np.frombuffer(raw, 'int16')
                    j = 0
                    k = 0
                    for i in range(0, 2047):
                        if i % 2 == 0:
                            result0[j] = raw[i]
                            j += 1
                        elif i % 2 == 1:
                            result1[k] = raw[i]
                            k += 1
                i = 0
 
                while (i < self.temp):
                    result1[i] = result1[i] * self.cheb[i]
                    Y1 = Y1 + np.fft.fft(result1) / self.temp
                    result0[i] = result0[i] * self.cheb[i]
                    Y0 = Y0 + np.fft.fft(result0) / self.temp
                    i += 1
                self.t = int(self.p / 2)
 
                while (self.t < self.temp-self.p / 2) & (self.t >= self.p / 2):
 
                    G1.append(result1[self.t])
                    G0.append(result0[self.t])
                    self.t += 1
 
 
 
            for i in range(0, 1023):
                # Y0[i] = Y0[i] / (self.count_block)
                Y0[i] = 20 * np.log10(Y0[i] / (self.count_block2))
                # Y1[i] = Y1[i] / (self.count_block)
                Y1[i] = 20 * np.log10(Y1[i] / (self.count_block2))
            n0 = len(result0)  # length of the signal
            n1 = len(result1)
            Fs = self.file.getframerate()
            k0 = np.arange(n0)
            k1 = np.arange(n1)
            T0 = n0 / Fs
            T1 = n1 / Fs
 
 
            frq0 = k0 / T0  # two sides frequency range
            frq0 = frq0[range(0, int(n0 / 2))]  # one side frequency range
            frq1 = k1 / T1  # two sides frequency range
            frq1 = frq1[range(0, int(n1 / 2))]  # one side frequency range
            Y0 = Y0[range(int(n0 / 2))]
            Y1 = Y1[range(int(n1 / 2))]
 
            # self.widget.plot(frq0, abs(Y0))
            # self.widget_2.plot(frq1, abs(Y1))
            self.widget.setLabel("left", "Амплитуда (дб)")
            self.widget.setLabel("bottom", "Частота (Гц)")
            self.widget_2.setLabel("left", "Амплитуда (дб)")
            self.widget_2.setLabel("bottom", "Частота (Гц)")
            self.widget.plot(frq0, abs(Y0), pen=self.pen)
            self.widget_2.plot(frq1, abs(Y1), pen=self.pen)
 
            self.progress.setValue(100)
            # fig = go.Figure()
            # fig.add_trace(
            #     go.Scatter(x=frq0, y=abs(Y1)))
            # fig.add_trace(
            #     go.Scatter(x=frq1, y=abs(Y0)))
            # fig.update_layout(
            #     xaxis=dict(
            #
            #         rangeslider=dict(
            #             visible=True
            #         ),
            #
            #     )
            # )
            # fig.show()
 
 
            # fig, [ax1, ax2, ax3] = plt.subplots(nrows=3, ncols=1)
            # # ax3.fill_between(frq1, abs(Y1), alpha=0.5, color='y') # построить с заполнением
            # ax3.plot(frq1, abs(Y1), alpha=0.5, color='y')
            # # ax3.fill_between(frq0, abs(Y0), alpha=0.2, color='r')  # построить с заполнением
            # ax3.plot(frq0, abs(Y0), alpha=0.2, color='r')
            # ax1.plot(G1, color='y')
            # ax2.plot(G0, color='r')
            # plt.show()
 
 
app = QApplication(sys.argv)
spectroscope = Spectroscope()
widget = QtWidgets.QStackedWidget()
widget.addWidget(spectroscope)
widget.setFixedWidth(1264)
widget.setFixedHeight(871)
 
 
 
widget.show()
sys.exit(app.exec_())