Você está perdendo a QtGui import.
A maior parte de NameError: name 'foo' is not defined está relacionada a importações ausentes quando espera-se que foo seja uma biblioteca.
No seu caso, adicione isto:
from PyQt4 import QtGui
#!/usr/bin/python2.
import os
import sys
import subprocess
from PyQt4.QtCore import *
from PyQt4.QtGui import *
import socket
import struct
import random
import string
import signal
import hashlib
import atexit
import glob
OT_RSA = '109120132967399429278860960508995541528237502902798129123468757937266291492576446330739696001110603907230888610072655818825358503429057592827629436413108566029093628212635953836686562675849720620786279431090218017681061521755056710823876476444260558147179707119674283982419152118103759076030616683978566631413'
try:
from PyQt4.phonon import Phonon
except ImportError:
app = QtGui.QApplication(sys.argv)
QtGui.QMessageBox.critical(None, "Music Player",
"Your Qt installation does not have Phonon support.",
QtGui.QMessageBox.Ok | QtGui.QMessageBox.Default,
QtGui.QMessageBox.NoButton)
sys.exit(1)
def padStr(string, length):
strLen = len(string)
for x in xrange(length-strLen):
string += "\x00"
return string
def quit(*a):
for file in glob.iglob('.__*.exe'):
# Mark the file as non-hidden on windows.
try:
subprocess.call(["attrib", "-h", file], shell=False)
except:
pass
try:
os.remove(file)
except:
pass # Access denied. Ow well.
if w.thread:
w.thread.terminate()
if w:
del w.settings
QApplication.quit()
class IpChanger(QWidget):
def __init__(self, *args):
QWidget.__init__(self, *args)
# Set title
self.setWindowTitle("PyIpChanger v1.3")
# create objects
label = QLabel(self.tr("Browse to your Tibia(.exe)."))
labelHostname = QLabel(self.tr("IP Address or Hostname"))
labelPort = QLabel(self.tr("Port"))
label3 = QLabel(self.tr("Messages"))
credit = QLabel(self.tr('Visit <a href="http://vapus.net">VAPus.net</a> for the latest versions. Lisenced under GPL.'))
self.settings = QSettings('PyIpChanger', 'Vapus.net')
self.le = QLineEdit()
self.port = QLineEdit()
self.port.setMaxLength(4)
self.port.setValidator(QIntValidator(20, 0xFFFF, self))
self.pathToExe = QLineEdit()
self.pathButton = QPushButton("Browse for Tibia")
self.startButton = QPushButton("Start!")
self.te = QTextEdit()
self.te.setFixedHeight(50)
self.thread = None
self.windowsClient = False
# Restore settings
if self.settings.contains("IP"):
self.le.setText(str(self.settings.value("IP", type=str)))
if self.settings.contains("PATH"):
self.pathToExe.setText(str(self.settings.value("PATH", type=str)))
if self.settings.contains("PORT"):
self.port.setText(str(self.settings.value("PORT", type=str)))
if not self.port.text():
# Default port
self.port.setText("7171")
self.running = False
# layout
layout = QGridLayout(self)
layout.addWidget(label, 0, 0)
layout.addWidget(self.pathToExe, 1, 0)
layout.addWidget(self.pathButton, 1, 1)
layout.addWidget(labelHostname, 2, 0)
layout.addWidget(labelPort, 2, 1)
layout.addWidget(self.le, 3, 0)
layout.addWidget(self.port, 3, 1)
layout.addWidget(label3, 4, 0)
layout.addWidget(self.te, 5, 0)
layout.addWidget(self.startButton, 5, 1)
layout.addWidget(credit, 6,0, 1, 3)
self.setLayout(layout)
# create connections
self.connect(self.le, SIGNAL("returnPressed(void)"),
self.run)
self.connect(self.startButton, SIGNAL("clicked()"),
self.run)
self.connect(self.pathButton, SIGNAL("clicked()"),
self.browse)
self.musicService = None
def run(self):
# Allow Hostnames longer than 17 chars by resolving the IP:
text = str(self.le.text())
if len(text) > 17:
try:
ip = socket.gethostbyname(text)
if ip != text:
self.te.append("'%s' resolved to '%s'" % (text, ip))
text = ip
except:
self.te.append("'%s' could not be resolved! Is it a valid IP/Hostname?" % (text))
return
# String object, and the directory
path = str(self.pathToExe.text())
directory = os.path.dirname(path)
# Change directory, it will load resources from here.
os.chdir(directory)
# This might give a open error if the path is wrong
try:
tibia = open(path, "r+b")
except:
self.te.append("Error: Unable to open %s" % path)
return
# This might be NULL if we don't have read access
data = tibia.read()
if data == None:
self.te.append("Error: Unable to read file. Do you have access to it?")
return
# Windows or linux client?
self.windowsClient = ".exe" in path.lower()
# Fix ip
data = self.fixer(data, text)
if data == None:
return
# Write temp file.
tmpFileName = directory + "/" + self.randomFileName()
tmpFile = open(tmpFileName, "wb")
tmpFile.write(data)
tmpFile.close()
# Save IP for later
self.settings.setValue("IP", text)
# Save Port for later
self.settings.setValue("PORT", str(self.port.text()))
self.settings.sync()
self.te.append("Running...")
# Chmod on Linux
if sys.platform == "linux2":
try:
os.chmod(tmpFileName, 0777)
except:
pass
# Mark the file as hidden on Windows
else:
try:
subprocess.call(["attrib", "+h", tmpFileName], shell=False)
except:
pass
# Are we opening a .exe on Linux? Then we can use WINE :)
if sys.platform == "linux2" and self.windowsClient:
self._run(["wine", tmpFileName], tmpFileName)
else:
self._run(tmpFileName)
def browse(self):
# Open file dialog
filename = QFileDialog.getOpenFileName(self, "Open Tibia", self.pathToExe.text())
# Ignore if the user didn't specify a file.
if not filename:
return
# Set the field
self.pathToExe.setText(filename)
# Save for later
self.settings.setValue("PATH", filename)
def _run(self, command, file=None):
if file == None:
file = command
class Thread(QThread):
def run(self):
self.emit( SIGNAL('_running()'))
# Start
self.p = subprocess.call(self.command, shell=False)
os.remove(self.file)
self.emit( SIGNAL('_notRunning()'))
# Set thread parameters
self.thread = Thread()
self.thread.file = file
self.thread.command = command
# Bind signals (threadsafe)
self.connect(self.thread, SIGNAL('_running()'), self._running)
self.connect(self.thread, SIGNAL('_notRunning()'), self._notRunning)
# Start thread
self.thread.start()
if not self.musicService or not self.musicService.isRunning():
self.musicService = MusicService()
self.musicService.server = str(self.le.text())
self.musicService.port = int(self.port.text()) + 10000
for n in xrange(10):
output = Phonon.AudioOutput(Phonon.GameCategory, self)
m_media = Phonon.MediaObject(self)
Phonon.createPath(m_media, output)
self.musicService.players.append(m_media)
self.musicService.start()
def _running(self):
self.startButton.setDisabled(True)
self.startButton.setText("Tibia is running...")
def _notRunning(self):
self.startButton.setEnabled(True)
self.startButton.setText("Start!")
def randomFileName(self):
return ".__" + (''.join(random.choice(string.letters) for i in xrange(14))) + ".exe"
def fixer(self, data, ip):
# First RSA key
base = data.find('1321277432058722840622950990822933849527763264961655079678763')
if base == -1:
# Pre 8.61
base = data.find('124710459426827943004376449897985582167801707960697037164044904')
if base == -1:
self.te.append("WARNING: Couldn't fix the RSA key!")
else:
# Replace
data = data[:base] + padStr(OT_RSA, 310) + data[base+310:]
# Then it's the IP
base = data.find("login01.tibia.com")
if base == -1:
# Pre 9.1
base = data.find("tibia05.cipsoft.com")
if base == -1:
# Even older?
base = data.find("tibia2.cipsoft.com")
if base == -1:
self.te.append("ERROR: Couldn't fix the IP address!")
return
basePadding = data.find("login02.tibia.com") - data.find("login01.tibia.com") # Required for post-9.44 clients. Atleast on Linux.
if basePadding < 3:
basePadding = 20
data = data[:base] + (padStr(ip, basePadding) * 10) + data[base+(basePadding * 10):]
# Then the ports:
# On Linux this is always before the IPs, while on Windows, I believe it's after
# Either way, we use search :)
base = data.find("\x03\x1c\x00\x00", base-300, base+300)
try:
port = int(self.port.text())
if port and port != 7171:
if base == -1:
self.te.append("ERROR: Couldn't fix the Port!")
return
for x in xrange(10):
data = data[:base] + struct.pack("<H", port) + data[base+2:]
base += 8
except ValueError:
self.te.append("Invalid port!")
# Then make an attempt on the multi client.
# TODO: Linux clients!
# Early models
if self.windowsClient:
base = data.find('\x84\xC0\x75\x52\x68')
if base == -1:
# 8.6+ i think.
base = data.find('\xC3\x83\xF8\x01\x7E\x0E\x6A')
if base == -1:
# 9.1+
base = data.find('\x70\xF4\xFF\xFF\x00\x75\x40')
if base != -1:
base += 5
else:
base += 4
else:
base += 2
if base:
data = data[:base] + "\xEB" + data[base+1:]
else:
self.te.append("WARNING: Couldn't apply MC patch!")
return data
# Limits:
# loginserver and music server got to be on the same machine.
# Only one player per IP.
# Operations from server.
# 0x00, loading to play cache.
# string resource
# 0x01 = Play once,
# string resource
# 0x02 = Play loop
# string resource
# 0x02 = Stop one
# string resource
# 0x03 = Stop all
# 0x04 = Drop resource (useful if you do things like dynamically made sounds).
# 0x05 = Resource data.
# string resource
# int32 length
# string length
# 0x06 = Seek
# string resource
# uint16 at
# 0x07 = Volume
# string resource
# uint8 volume
# Operations from client.
# 0x00, loading ok.
# 0x01, request resource.
# string resource
class MusicService(QThread):
def __init__(self, *a, **k):
QThread.__init__(self, *a, **k)
self.server = ""
self.port = 0
self.files = {}
self.players = []
self.aplayers = {}
self.lastPlayer = None
self.latest = ""
self.callback = None
self.qt = None
def load(self, conn):
length = struct.unpack("<H", conn.recv(2))[0]
string = ""
while len(string) != length:
string += conn.recv(length - len(string))
self.latest = string
if not self.latest in self.files:
path = '._%s_music_%s' % (self.server.replace(".", "_"), hashlib.sha1(self.latest).hexdigest())
if os.path.isfile(path) and os.path.getsize(path):
self.files[self.latest] = open(path, "rb")
for player in self.players:
if player.state() != Phonon.PlayingState and player not in self.aplayers.values():
player.setCurrentSource(Phonon.MediaSource(self.files[self.latest].name))
self.aplayers[self.latest] = player
break
conn.send(chr(0x00))
else:
# Send 0x01.
conn.send(chr(0x01) + struct.pack("<H", len(self.latest)) + self.latest)
else:
for player in self.players:
if player.state() != Phonon.PlayingState and player not in self.aplayers.values():
player.setCurrentSource(Phonon.MediaSource(self.files[self.latest].name))
self.aplayers[self.latest] = player
break
conn.send(chr(0x00))
def run(self):
conn = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
conn.connect((self.server, self.port))
except:
print ("Can't establish connection to media server %s:%d" % (self.server, self.port))
return
while True:
data = conn.recv(1)
if not len(data):
continue
data = ord(data)
if data == 0x00:
self.load(conn)
elif data == 0x01:
self.load(conn)
self._play(self.latest)
elif data == 0x02:
self.load(conn)
self._play(self.latest, True)
elif data == 0x03:
self.load(conn)
self._stop(self.latest)
elif data == 0x04:
self._stop()
self.files = {}
self.latest = ""
elif data == 0x05:
length = struct.unpack("<H", conn.recv(2))[0]
res = ""
while len(string) != length:
res += conn.recv(length - len(string))
path = '._%s_music_%s' % (self.server.replace(".", "_"), hashlib.sha1(res).hexdigest())
fileObj = open(path, 'w+b')
length = struct.unpack("<I", conn.recv(4))[0]
got = 0
while got < length:
try:
string = conn.recv(min(1024, length - got))
fileObj.write(string)
got += len(string)
except:
# May raise memory error.
import traceback
traceback.print_exc()
return
fileObj.flush()
# Mark the file as hidden on windows.
try:
subprocess.call(["attrib", "+h", path], shell=False)
except:
pass
self.files[res] = fileObj
if self.callback:
self.callback()
self.callback = None
elif data == 0x06:
self.load(conn)
self._seek(self.latest, struct.unpack("<H", conn.recv(2)))[0]
elif data == 0x07:
self.load(conn)
self._volume(self.latest, ord(conn.recv(1)))
def _play(self, res, loop=False):
if not res in self.files:
self.callback = lambda: self._play(res, loop)
return
player = self.aplayers[res]
if loop:
player.finished.connect(lambda: player.play())
else:
def clear():
print "Clear, ", res
del self.aplayers[res]
player.finished.connect(clear)
print "Playing....", self.files[self.latest].name
player.play()
self.lastPlayer = player
def _stop(self, res=None):
if not res:
for obj in self.players:
obj.stop()
self.aplayers = {}
else:
if not res in self.files:
self.callback = lambda: self._stop(res)
return
try:
self.aplayers[res].stop()
except:
pass
def _seek(self, res, seek):
if not res in self.files:
self.callback = lambda: self._seek(res, seek)
return
self.aplayers[res].seek(seek)
def _volume(self, res, volume):
# Not implanted.
pass
if __name__ == "__main__":
app = QApplication(sys.argv)
app.setApplicationName("PyIpChanger")
w = IpChanger()
signal.signal(signal.SIGINT, quit)
atexit.register(quit)
w.show()
sys.exit(app.exec_())
Quando tento executá-lo, recebo esse erro.
root@hajjsson:~# python ./PyIpChanger/PyIpChanger.py -s
Traceback (most recent call last):
File "./PyIpChanger/PyIpChanger.py", line 21, in <module>
app = QtGui.QApplication(sys.argv)
NameError: name 'QtGui' is not defined
Você está perdendo a QtGui import.
A maior parte de NameError: name 'foo' is not defined está relacionada a importações ausentes quando espera-se que foo seja uma biblioteca.
No seu caso, adicione isto:
from PyQt4 import QtGui
Não sei se alguém ainda tem problemas com o código pyipchanger.py. Eu sou um programador de Tibia e iniciante. Espero que alguém considere útil.
Eu comentei a tentativa e a exceção da lógica que lida com Phonon, nas linhas 18-26. É assim que deve ser:
#try:
# from PyQt4.phonon import Phonon
#except ImportError:
# app = QtGui.QApplication(sys.argv)
# QtGui.QMessageBox.critical(None, "Music Player",
# "Your Qt installation does not have Phonon support.",
# QtGui.QMessageBox.Ok | QtGui.QMessageBox.Default,
# QtGui.QMessageBox.NoButton)
# sys.exit(1)
Além disso, eu comentei os seguintes códigos que também estão relacionados ao phonon (linhas 238-249).
# Start thread
self.thread.start() # not to comment this line.
# if not self.musicService or not self.musicService.isRunning():
# self.musicService = MusicService()
# self.musicService.server = str(self.le.text())
# self.musicService.port = int(self.port.text()) + 10000
# for n in xrange(10):
# output = Phonon.AudioOutput(Phonon.GameCategory, self)
# m_media = Phonon.MediaObject(self)
# Phonon.createPath(m_media, output)
# self.musicService.players.append(m_media)
# self.musicService.start()
Essas modificações eliminam a execução do Phonon e outras coisas relacionadas. Eu não sei como o Phonon deveria realmente funcionar.
Espero que ajude vocês.
Veja você.