QUiLoader RuntimeError: Unable to open/read ui device

# -*- coding: utf-8 -*-
from PySide.QtCore import *
from PySide.QtGui import *
from PySide.QtUiTools import *
from PySide.phonon import Phonon
#from fileFinder import Finder
#from videoViewer import VideoViewer
#from playlist import playListStructure
 
import os
 
import sys
import time
 
 
class Updater(QObject):
    def __init__(self, updateFunc):
        super(Updater, QObject.__init__(self))
        
        self.text = ""
        self.maximum = 100
        
        self.index = 0
        
        self.func = updateFunc
        
        self.timer = QTimer()
        self.timer.setSingleShot(False)
        self.connect(self.timer, SIGNAL("timeout()"), self.on_timeout)
        
    def on_timeout(self):      
        text = ' ' * self.maximum + self.text
        
        self.index += 1
        if self.index > len(text)+1:
            self.index = 1
            
        self.func(text[self.index:self.index+self.maximum])
        
    def start(self, interval):
        self.timer.start(interval)
        
    def setText(self, text):
        self.timer.stop()
        self.func('')
        self.index = 0
        self.text = text
        self.timer.start()
        
    def setMaximum(self, maximum):
        self.timer.stop()
        self.func('')
        self.index = 0
        self.maximum = maximum
        self.timer.start()    
        
 
class WPlayer():       
    def __init__(self, parent):
        self.parent = parent
        
        self.lastVolume = 0
        
        #self.addToListDilog = Finder()
        
        #for i in range(10):
        #    playListStructure(parent.playListsView)
        
        
        self.updateTimer = Updater(self.setText)
        
        #self.updateTimer.setText('TEST TEST TEST')# задать новый текст
        #self.updateTimer.setMaximum(100)# задать количество пробелов перед текстом
        #self.updateTimer.start(20)# запуск таймера на 20 миллисекунд
        
        #self.videoWindow = VideoViewer()
        
        self.m_media = Phonon.MediaObject()
        self.audioOutput = Phonon.AudioOutput(Phonon.MusicCategory)
        Phonon.createPath(self.m_media, self.audioOutput)
        self.m_media.setCurrentSource(
            Phonon.MediaSource("./03-Heart-Shaped Box.mp3"))
        #self.m_media.play()
        
        self.setupActions()
        
        self.parent.play.setDefaultAction(self.playAction)
        self.parent.pause.setDefaultAction(self.pauseAction)
        self.parent.stop.setDefaultAction(self.stopAction)
        self.parent.back.setDefaultAction(self.backwardAction)
        self.parent.next.setDefaultAction(self.forwardAction)
        self.parent.volume.setDefaultAction(self.volumeAction)
        
        self.parent.show_hidePlayList.clicked.connect(self.show_hidePlayListClicked)
        
        self.parent.volumeSlider.valueChanged[int].connect(self.volumeStateChange)
        #self.parent.volumeSlider.setMediaObject(self.m_media)
        
        #self.parent.volumeSlider.setAudioOutput(self.audioOutput)
        self.parent.volumeSlider.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum)
        
        self.parent.volume.clicked.connect(self.volumeOnOff)
        
        self.parent.AddToList.triggered.connect(self.addToListDilog.show)
        
        self.parent.Video.triggered.connect(self.viewVideoWindow)
        
        
 
        #self.window.playlist.setSelectionMode(QtGui.QAbstractItemView.SingleSelection)
        #self.window.playlist.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
        self.parent.timePanel.display('00:00')
        ########################################
        #self.window.playlist.setDragDropMode(QtGui.QAbstractItemView.DragDrop)
        #self.window.playlist.setDragEnabled(True)
        #self.window.playlist.setAcceptDrops(True)
        ########################################
        #self.window.playlist.cellDoubleClicked.connect(self.tableClicked)
        
        
        self.parent.OpenPlayList.triggered.connect(self.openFile)
        self.parent.About.triggered.connect(self.about)
        
        
    def setupActions(self):
        self.playAction = QAction(            
            self.parent.style().standardIcon(QStyle.SP_MediaPlay), "Воспроизвести",
            self.parent, shortcut="X", enabled=True,
            triggered=self.m_media.play)
        
        self.pauseAction = QAction(            
            self.parent.style().standardIcon(QStyle.SP_MediaPause), "Простановить",
            self.parent, shortcut="C", enabled=True,
            triggered=self.m_media.pause)
        
        self.stopAction = QAction(            
            self.parent.style().standardIcon(QStyle.SP_MediaStop), "Остановить",
            self.parent, shortcut="V", enabled=True,
            triggered=self.m_media.stop)
        
        self.backwardAction = QAction(            
            self.parent.style().standardIcon(QStyle.SP_MediaSkipBackward), "Предыдуший трек",
            self.parent, shortcut="Z", enabled=True,
            triggered=self.prevTrack)
        
        self.forwardAction = QAction(            
            self.parent.style().standardIcon(QStyle.SP_MediaSkipForward), "Следующий трек",
            self.parent, shortcut="B", enabled=True,
            triggered=self.nextTrack)
 
        self.volumeAction = QAction(            
            self.parent.style().standardIcon(QStyle.SP_MediaVolume), "Звук[Вкл.]",
            self.parent, enabled=True,
            triggered=self.volumeOnOff)
            
        
 
    def setText(self, text):
            self.parent.runString.setText(text)
            self.parent.repaint()
        
        
        
    def nextTrack(self):
        pass
        
    def prevTrack(self):
        pass
    
    def volumeStateChange(self, value):
        val = "Громкость %d " % value 
        self.parent.volumeSlider.setToolTip(val + chr(37))
        if self.parent.volume.toolTip() == "Звук[Выкл.]":
            self.parent.volume.setToolTip("Звук[Вкл.]")
        
    def volumeOnOff(self):
        if self.parent.volume.toolTip() == "Звук[Вкл.]":
            self.lastVolume = self.parent.volumeSlider.value()
            self.parent.volumeSlider.setValue(0)
            self.parent.volume.setToolTip("Звук[Выкл.]")
            self.parent.volume.setIcon(self.parent.style().standardIcon(QStyle.SP_MediaVolumeMuted))            
        else:
            self.parent.volume.setToolTip("Звук[Вкл.]")
            self.parent.volumeSlider.setValue(self.lastVolume)
            self.parent.volume.setIcon(self.parent.style().standardIcon(QStyle.SP_MediaVolume))
    
    def show_hidePlayListClicked(self):
        if self.parent.show_hidePlayList.arrowType() == Qt.UpArrow:
            self.parent.show_hidePlayList.setToolTip("Спрятать плейлист")
            self.parent.show_hidePlayList.setArrowType(Qt.DownArrow)
            
            height = self.parent.height() + 400
            self.parent.setFixedHeight(height)# это розвертаю
        else:
            self.parent.show_hidePlayList.setToolTip("Показать плейлист")
            self.parent.show_hidePlayList.setArrowType(Qt.UpArrow)
            
            height = self.parent.height() - 400
            self.parent.setFixedHeight(height)# это типа свертываю 
        self.parent.update()
        
    def viewVideoWindow(self):
        self.videoWindow.playVideo("./test.avi")
        
        
        
    def tableClicked(self, row, column):
        print("last=>", self.last)
        print("row=>", row)
        print("column=>", column)
        self.setback(self.last, "black")
        self.setback(row, "blue")
 
        
        wasPaused = (self.mediaObject.state() == Phonon.PausedState)
        print("wasPaused=>", wasPaused)
 
##        self.mediaObject.stop()
        self.mediaObject.clearQueue()
 
        self.mediaObject.setCurrentSource(self.files[row])
        
##        self.mediaObject.play()
        
        if not wasPaused or column != -1:
            self.mediaObject.play()
##        else:
##            self.mediaObject.stop()
        self.last = row
        
    def handleStateChanged(self, newstate, oldstate):
        print(self.audioOutput.volumeDecibel())
        if newstate == Phonon.PlayingState:
            print('play')
            icon = QtGui.QIcon()
            icon.addPixmap(QtGui.QPixmap("Content/pause.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
            self.window.play_pause.setIcon(icon)
            self.window.play_pause.setIconSize(QtCore.QSize(30, 30))
            self.window.play_pause.setToolTip("Пауза")
            self.window.stop.setEnabled(True)            
        elif newstate == Phonon.StoppedState:
            print('stop in handleStateChanged')
            self.window.stop.setEnabled(False)
            icon = QtGui.QIcon()
            icon.addPixmap(QtGui.QPixmap("Content/play.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
            self.window.play_pause.setIcon(icon)
            self.window.play_pause.setIconSize(QtCore.QSize(30, 30))
            #self.mediaObject.stop()
            self.window.time.display('00:00')
        elif newstate == Phonon.PausedState:
            print('pause')
            icon = QtGui.QIcon()
            icon.addPixmap(QtGui.QPixmap("Content/play.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
            self.window.play_pause.setIcon(icon)
            self.window.play_pause.setIconSize(QtCore.QSize(30, 30))
            self.window.play_pause.setToolTip("Воспроизвести")
            #self.mediaObject.pause()
        elif newstate == Phonon.ErrorState:
            pass
        
    def sourceChanged(self, sourse):
        index = self.files.index(sourse)
        print(sourse.fileName())
        file = open("./file.dat", mode = "w")
        file.write(sourse.fileName())
        file.close()
        self.window.playlist.selectRow(index)
        self.setback(index, "blue")
        self.window.time.display('00:00')
        item = self.window.playlist.item(index, 0)
        print(item.text())
        self.parent.setWindowTitle(item.text() + " - PlayListUtill")
        
       
    def openFile(self):
        fileName = QFileDialog.getOpenFileName(self.parent, "Открыть список воспроизведеня", "")# All Playlists(*.m3u;m3u8;*.aimppl;*plc;*.pls)" 
        if fileName != ('', ''):
            fileName = fileName[0]
            print("Оброботка файла '%s'" % fileName)
            #self.mediaObject.stop()
            #self.m_media.playlist.setRowCount(0);
            #self.files = []
            #self.last = 0
            #self.readPlyList(fileName)
            #self.window.playlist.selectRow(0)
            #self.mediaObject.setCurrentSource(self.files[0])
            #self.setback(0, "blue")
            
    def readPlyList(self, fileName):
        ext = splitext(fileName)[1]
        if ext == ".pls": self.readPLSFile(fileName)
        #elif ext == ""
 
 
    def get_meta(self, file):
        meta = {}
        try:
            myfile = auto.File(file)
        except IOError:
            return meta
        if myfile.valid:
            meta["title"] = myfile.title
            meta["artist"] = myfile.artist
            meta["album"] = myfile.album
            meta["genre"] = myfile.genre
            meta["year"] = myfile.year
            meta["sample rate"] = myfile.sample_rate/1000
            meta["bitrate"] = myfile.bitrate
            meta["length"] = floor(myfile.duration/60), myfile.duration%60
            meta["size"] = myfile.size/1048576
        return meta
 
    @staticmethod
    def valid_time(timedata):
        result = prefix = ""
        for i in timedata:
            if i < 10: prefix = "0"
            result+= prefix + str(i) + ":"
            prefix = ""
        result = result[:5]
        return result
    
    def view_data(self, track):
        meta = self.get_meta(track)
        ####################Название
        fileitem = QtGui.QTableWidgetItem("%s — %s" % (meta["artist"], meta["title"]))
        fileitem.setFlags(fileitem.flags() ^ QtCore.Qt.ItemIsEditable)
        #fileitem.setCheckState(QtCore.Qt.Checked)
        ####################Длина
        length = self.valid_time(meta["length"])
        lengthitem = QtGui.QTableWidgetItem(length)
        lengthitem.setFlags(lengthitem.flags() ^ QtCore.Qt.ItemIsEditable)
            
        currentRow = self.window.playlist.rowCount()
        self.window.playlist.insertRow(currentRow)
        self.window.playlist.setItem(currentRow, 0, fileitem)
 
        self.window.playlist.setItem(currentRow, 1, lengthitem)
 
        self.window.playlist.resizeColumnsToContents()
        self.window.playlist.setColumnWidth(0, 300)
        self.parent.update()
                    
    def readPLSFile(self, file):
        print("*******************")
        print("Формат файла .pls")
        cfg = ConfigParser()
        cfg.read(file)
        count = cfg.getint("playlist", "NumberOfEntries")
        print("*******************")
        print("Количество треков: ", count)
        print("*******************")
        for i in range(1, count+1):
            track = cfg.get("playlist", "File%s" % i)
            self.files.append(Phonon.MediaSource(track))
            self.view_data(track)
            self.parent.update()
            
            
    def about(self):
        pass
    
def normalPath():
    os.path.split(sys.argv[0])[0].replace("\\", "/")
        
 
def main():
    app = QApplication(sys.argv)
    app.setApplicationName("WPlayer")
    window = QUiLoader().load("./UIs/WPlayer.ui")# На этом месте в Windows вылетает ошибка
    player = WPlayer(window)
    #window.setWindowIcon(QIcon('Icons/Logo.png'))
    height = window.height()
    window.setFixedWidth(370)
    #window.setFixedSize(370, height)
    
    window.show()
    app.exec_()    
 
if __name__ == '__main__':
    main()