class MyPixmap(QtGui.QGraphicsPixmapItem):
def __init__(self, parent):
QtGui.QGraphicsPixmapItem.__init__(self)
self.parent = parent
self.currentSide = 0
self.thread = MyThread(self.parent, self.parent.getRandom)
self.thread.finished.connect(self.parent.errorHandler)
self.timer = QtCore.QTimer()
self.timer.timeout.connect(self.swapCoin)
def mousePressEvent(self, e):
if self.thread.isRunning() and self.timer.isActive():
e.ignore()
else:
self.parent.hint.hide()
self.count = 0 # counter for coin's swaping
self.timer.start(50)
self.thread.start()
e.accept()
def swapCoin(self):
if self.count < 50 or self.thread.isRunning():
self.currentSide = int(not self.currentSide) # 1 turns to 0, 0 to 1
self.setPixmap (self.parent.comboBox.itemData(self.parent.comboBox.currentIndex())[ self.currentSide ])
self.count += 1
else:
self.timer.stop()
if not self.parent.error and self.parent.result:
self.setPixmap (self.parent.comboBox.itemData(self.parent.comboBox.currentIndex())[ int(self.parent.result[0]) ]) # SHOW RESULT!
self.parent.log(error=self.parent.error) # log into journal
def main(): nfuncs = range(len(funcs)) print '*** SINGLE THREAD' for i in nfuncs: print 'staring', funcs[i].__name__, 'at:', ctime() print funcs[i](n) print funcs[i].__name__, 'finished at:', ctime() print '\n*** MULTIPLE THREADS' threads = [] for i in nfuncs: t = MyThread(funcs[i], (n,), funcs[i].__name__) # (n,) ,means it's a tuple threads.append(t) for i in nfuncs: threads[i].start() for i in nfuncs: threads[i].join() print threads[i].getResult() for t in threads: print t.getName(), t.isAlive(), t.isDaemon() print 'all Done'
def stockPriceAlert(stockNum,priceAlert,type=-1):
print stockNum,priceAlert,type
priceAlert = float(priceAlert)
type = int(type)
stockName,nowPrice,yesterdayPrice,maxPrice,minPrice,changeRate = stockDetail(stockNum)
#print stockName,nowPrice,yesterdayPrice,maxPrice,minPrice,changeRate
msg = ''
if (type == -1) and (priceAlert >= float(nowPrice)):
msg = stockNum + ' fall bellow ' + str(priceAlert) + ',Now:' + str(nowPrice)
elif (type == 1) and (priceAlert <= float(nowPrice)):
msg = stockNum + ' goes over ' + str(priceAlert) + ',Now:' + str(nowPrice)
if msg != '':
print msg
smsHandle.sendSMS(msg)
#stockPriceAlert(stockNum,priceAlert*(1-1/100.0),-1)
threads=[]
t = MyThread(stockPriceAlert,(stockNum,priceAlert*(1-1/100.0),-1),stockPriceAlert.__name__)
threads.append(t)
t = MyThread(stockPriceAlert,(stockNum,priceAlert*(1+1/100.0),1),stockPriceAlert.__name__)
threads.append(t)
for i in threads:
i.start()
else:
sleep(5)
stockPriceAlert(stockNum,priceAlert,type)
def _main():
nProduce = randint(1, 4)
nConsume = randint(1, 3)
nloops = randint(2, 4)
q = Queue(100)
threads = []
numThreads = nProduce + nConsume
print(numThreads, nProduce, nConsume)
# 创建生产者线程
for i in range(nProduce):
t = MyThread(funcs[0], (q, nloops), funcs[0].__name__)
threads.append(t)
for i in range(nConsume):
t = MyThread(funcs[1], (q, nloops), funcs[1].__name__)
threads.append(t)
# for i in nfuncs:
# t = MyThread(funcs[i], (q, nloops), funcs[i].__name__)
# threads.append(t)
for i in range(numThreads):
# print('xxx')
threads[i].start()
for i in range(numThreads):
threads[i].join()
print("all done")
def main():
logConfig()
handle = open("./resultChen.csv", "w")
f = open("./top5k.csv")
threads = []
while 1:
line = f.readline().strip()
if not line:
break
lineList = line.split(",") #line: "1,google.com"
if len(threads) < 10:
mt = MyThread(process, (lineList, handle))
mt.start()
time.sleep(1)
threads.append(mt)
for thread in threads:
if thread.isAlive():
continue
else:
threads.remove(thread)
for thread in threads:
thread.join()
f.close()
handle.close()
class Controller:
def __init__(self):
self.clock_block = threading.Event()
self.person_detection_block = threading.Event()
self.face_detection_block = threading.Event()
self.pose_detection_block = threading.Event()
self.emotion_detection_block = threading.Event()
self.face_direction_block = threading.Event()
self.face_recognition_block = threading.Event()
self.students = []
self.faces = []
self.poses = []
self.names = []
self.emo = []
self.face_dir = []
self.faceDetector = DetectFace()
self.recognitionFace = RecognitionFace()
def process_frame(self, frame):
# clear all events
self.person_detection_block.clear()
self.face_detection_block.clear()
self.pose_detection_block.clear()
self.emotion_detection_block.clear()
self.face_direction_block.clear()
self.face_recognition_block.clear()
# frame = cv2.imread(framePath, cv2.IMREAD_COLOR)
# init all threads
self.faceDetectorThread = MyThread(
name="faceDetectorThread",
processor=self.faceDetector,
other_events=[self.face_detection_block],
args=frame)
self.faceRecogThread = MyThread(
name="faceRecognitionThread",
other_events=[self.face_recognition_block],
processor=self.recognitionFace,
args=self.faces)
# start all threads
self.faceDetectorThread.start()
self.faceRecogThread.start()
# waiting all events
self.face_detection_block.wait()
self.face_recognition_block.wait()
# take res from threads
self.faces = self.faceDetectorThread.mydata
self.names = self.faceRecogThread.mydata
# return last res
return self.names
def queue_standby_Th(q, judArr, masterArr):
thQueue = MyThread(savedQueue, (q, judArr))
thStandby = MyThread(standby, masterArr)
thQueue.start()
thStandby.start()
thQueue.join()
thStandby.join()
class MyWidget(QtGui.QWidget, Ui_MyWidget, ResultTable):
def __init__(self, parent=None, master=None):
QtGui.QWidget.__init__(self, parent)
self.master = master
self.error = self.result = self.model = None
self.column = 1
self.setupUi(self) # set UI (method from Ui_MyWidget)
ResultTable.__init__(self) # set UI for result group widget (result table etc...)
self.btnGenerate.clicked.connect(self.generate)
self.spinCol.valueChanged["int"].connect(self.changeColumn)
self.btnClear.clicked.connect(self.clearTable)
self.btnCopy.clicked.connect(self.copyResult)
self.btnSave.clicked.connect(self.saveResult)
self.thread = MyThread(self, self.getRandom)
self.thread.finished.connect(self.errorHandler)
def generate(self):
self.btnGenerate.setDisabled(True)
self.thread.start()
def getRandom(self):
fract = self.spinFract.value()
num = self.spinNum.value()
min = self.spinMin.value()
max = self.spinMax.value()
# list with only integers (0, 2, 5, 17...)
intResult = [min]*num if (min == max-1) else self.master.random.integers(num=num, min=min, max=max-1, base='10', col=1, format='plain', rnd='new')
# list with only decimals (100, 225, 50, 4...)
fractResult = self.master.random.integers(num=num, min=0, max=(10**fract)-1, base='10', col=1, format='plain', rnd='new')
# merge 2 lists together (0.100, 2.225, 5.050, 17.004...)
result = ["{0:.{1}f}".format(int(intResult[i]) + (int(fractResult[i]) / 10**fract), fract) for i in range(num)] # 1 and 23 -> 1.00023 if fract is 5
if self.checkAdd.isChecked() and type(self.result) is list:
self.result.extend(result)
else:
self.result = result
self.makeTable()
def log(self, error=None):
from time import strftime
self.master.logs.addRow(strftime("%d-%m-%Y"),
strftime("%H:%M:%S"),
self.master.random.__class__.__name__,
"Floats Generator",
error if error else "Generated: num=%s min=%s max=%s ndigits=%s" % (self.spinNum.value(), self.spinMin.value(), self.spinMax.value(), self.spinFract.value()))
def main():
argv = sys.argv[1:]
numS = [ int(argv[0][i:i+2], 16) for i in range(0,len(argv[0]),2) ]
numD = [ int(argv[1][i:i+2], 16) for i in range(0,len(argv[1]),2) ]
src = ''
dst = ''
for i in numS:
src += struct.pack('!B', i)
for i in numD:
dst += struct.pack('!B', i)
back = MyThread(thread_func, [])
back.start()
#back.join()
back2 = MyThread(thread_func2, [])
back2.start()
cheat2 = eapauth.EAPAuth(['1','1','eth1'])
cheat2.set_fake(src, dst)
cheat2.send_failure()
while True:
try:
print "ok"
packet = cheat2.client.recv(1600)
print "ok2"
print repr(packet)
#cheat2.send_request_pass()
#packet = cheat2.client.recv(1600)
#print repr(packet)
except:
print "error"
pass
class MyWidget(QtGui.QWidget, Ui_MyWidget, ResultTable):
def __init__(self, parent=None, master=None):
QtGui.QWidget.__init__(self, parent)
self.master = master
self.error = self.result = self.model = None
self.column = 1
self.setupUi(self) # set UI (method from Ui_MyWidget)
ResultTable.__init__(self) # set UI for result group widget (result table etc...)
self.btnGenerate.clicked.connect(self.generate)
self.spinCol.valueChanged["int"].connect(self.changeColumn)
self.btnClear.clicked.connect(self.clearTable)
self.btnCopy.clicked.connect(self.copyResult)
self.btnSave.clicked.connect(self.saveResult)
self.thread = MyThread(self, self.getRandom)
self.thread.finished.connect(self.errorHandler)
def generate(self):
self.btnGenerate.setDisabled(True)
self.thread.start()
def getRandom(self):
result = self.master.random.strings(num = self.spinNum.value(),
len = self.spinLen.value(),
loweralpha = "on" if self.checkLower.isChecked() else "off",
digits = "on" if self.checkDigits.isChecked() else "off",
upperalpha = "on" if self.checkUpper.isChecked() else "off",
unique = "on" if self.checkUnique.isChecked() else "off",
format='plain', rnd='new')
if self.checkAdd.isChecked() and type(self.result) is list:
self.result.extend(result)
else:
self.result = result
# print(self.result)
self.makeTable()
def log(self, error=None):
from time import strftime
self.master.logs.addRow(strftime("%d-%m-%Y"),
strftime("%H:%M:%S"),
self.master.random.__class__.__name__,
"Strings Generator",
error if error else "Generated: num=%s len=%s" % (self.spinNum.value(),
self.spinLen.value()))
def main():
"""Main function."""
nfuncs = range(len(funcs))
print '*** Single thread.'
for i in nfuncs:
print 'starting', funcs[i].__name__, 'at:',\
ctime()
print funcs[i](n)
print funcs[i].__name__, 'finished at"',\
ctime()
print '\n*** Multiple threads.'
threads = []
for i in nfuncs:
t = MyThread(funcs[i], (n, ), funcs[i].__name__)
threads.append(t)
for i in nfuncs:
threads[i].start()
for i in nfuncs:
threads[i].join()
print threads[i].get_result()
print 'all DONE'
def main():
try:
print(sys.argv[1])
filename = sys.argv[1]
word_to_search = sys.argv[2]
print(word_to_search)
except IndexError:
print("Usage: ex_18_4.py <filename> <word>")
sys.exit()
total_size = os.path.getsize(filename)
partitions = get_partitions(total_size, NUM_OF_THREADS)
funcs = [process_file]
nfuncs = range(len(funcs))
threads = []
for i in nfuncs:
for shard_index, end_offset in partitions.items():
t = MyThread(funcs[i],
(filename, shard_index, end_offset, word_to_search),
funcs[i].__name__)
threads.append(t)
for i in nfuncs:
threads[i].start()
for i in nfuncs:
threads[i].join()
def main():
threads=[]
t = MyThread(stockPriceAlert,('bidu',172.5,-1),stockPriceAlert.__name__)
threads.append(t)
t = MyThread(stockPriceAlert,('bidu',177.5,1),stockPriceAlert.__name__)
threads.append(t)
t = MyThread(stockPriceAlert,('yy',58.5,1),stockPriceAlert.__name__)
threads.append(t)
t = MyThread(stockPriceAlert,('yy',56.2,-1),stockPriceAlert.__name__)
threads.append(t)
#t = MyThread(stockPriceAlert,('qihu',81.5,1),stockPriceAlert.__name__)
#threads.append(t)
#t = MyThread(stockPriceAlert,('bidu',176,-1),stockPriceAlert.__name__)
#threads.append(t)
for i in threads:
i.start()
def main():
num = len(funcs)
print '*** Single Thread'
for i in range(num):
print funcs[i].__name__, 'start at:', ctime()
print funcs[i](n)
print funcs[i].__name__, 'done at:', ctime()
print '\n*** Multi Thread'
threads = []
for i in range(num):
thread = MyThread(funcs[i], (n,), funcs[i].__name__)
threads.append(thread)
for i in range(num):
threads[i].start()
for i in range(num):
threads[i].join()
print threads[i].getResult()
print 'all Done'
def __init__(self, parent=None, master=None):
QtGui.QWidget.__init__(self, parent)
self.master = master
self.error = self.result = self.model = None
self.column = 1
self.setupUi(self) # set UI (method from Ui_MyWidget)
ResultTable.__init__(self) # set UI for result group widget (result table etc...)
self.tableResult.setSortingEnabled(False) # disable column sorting (keep the items mixed is the point)
self.listModel = MyModel(1, 1, self.lblInfo)
self.tableCustomList.setModel(self.listModel)
self.tableCustomList.setEditTriggers(QtGui.QAbstractItemView.AllEditTriggers)
self.tableCustomList.horizontalHeader().hide()
self.tableCustomList.setColumnWidth(0, 150)
self.fillPresetsList()
# one groupPanel disables the other
self.groupGenerate.toggled.connect(lambda checked: self.groupLoad.setChecked(not checked))
self.groupLoad.toggled.connect(lambda checked: self.groupGenerate.setChecked(not checked))
self.btnGenerate.clicked.connect(self.generate)
self.comboPresets.activated["int"].connect(self.setPreset)
self.btnLoad.clicked.connect(self.loadList)
self.btnListClear.clicked.connect(lambda: self.listModel.clear())
self.spinCol.valueChanged["int"].connect(self.changeColumn)
self.btnClear.clicked.connect(self.clearTable)
self.btnCopy.clicked.connect(self.copyResult)
self.btnSave.clicked.connect(self.saveResult)
self.thread = MyThread(self, self.getRandom)
self.thread.finished.connect(self.errorHandler)
def main():
nfuncs = range(len(funcs))
#print '*** SINGLE THREAD'
#for i in nfuncs:
# print 'starting', funcs[i].__name__, 'at:', ctime()
# print funcs[i](n)
# print funcs[i].__name__, 'finished at:', ctime()
print '\n*** MULTIPLE THREADS'
threads = []
for i in nfuncs:
t = MyThread(funcs[i], (n, ), funcs[i].__name__, verb=True)
threads.append(t)
for i in nfuncs:
threads[i].start()
for i in nfuncs:
threads[i].join()
for i in nfuncs:
print threads[i].getResult()
print 'all DONE'
def main():
nfuncs = range(len(funcs))
print('*** SINGLE THREAD')
for i in nfuncs:
print ('starting', funcs[i].__name__, \
'at:', ctime())
print(funcs[i](n))
print (funcs[i].__name__, 'finished at:', \
ctime())
print('\n*** MULTIPLE THREADS')
threads = []
for i in nfuncs:
t = MyThread(funcs[i], (n, ), funcs[i].__name__)
threads.append(t)
for i in nfuncs:
threads[i].start()
for i in nfuncs:
threads[i].join()
print(threads[i].getResult())
print('all DONE')
def main():
funcs = [fib, fac, sum]
n = 12
nfuncs = range(len(funcs))
print '*** SINGLE THREAD all starting at:%s ***' % time.strftime('%Y-%m-%d %H:%M:%S')
for i in nfuncs:
print 'starting %s, at:%s' % (funcs[i].__name__, time.strftime('%Y-%m-%d %H:%M:%S'))
print funcs[i](n)
print '%s finished at:%s' % (funcs[i].__name__, time.strftime('%Y-%m-%d %H:%M:%S'))
print '*** SINGLE THREAD all done at:%s ***' % time.strftime('%Y-%m-%d %H:%M:%S')
print '*** MULTIPLE THREAD all starting at:%s ***' % time.strftime('%Y-%m-%d %H:%M:%S')
threads = []
for i in nfuncs:
thread = MyThread(funcs[i], (n,), funcs[i].__name__)
threads.append(thread)
for i in threads:
i.start()
for i in threads:
i.join()
print i.getResult()
print '*** MULTIPLE THREAD all starting at:%s ***' % time.strftime('%Y-%m-%d %H:%M:%S')
def ServerStart(self, port):
# 创建一个监听套接字
print("server：创建了监听套接字")
self.__server_socket = socket.socket(
socket.AF_INET, socket.SOCK_STREAM) # 创建用于监听的socket
self.__server_socket.setblocking(False) # 配置为非阻塞的socket
self.__server_is_listening = False
# 设置并绑定监听的端口
print("server：设置并绑定port:{}".format(port))
self.__server_socket.bind(("", port))
self.__port = port
# 启动监听线程
self.__sub_thread.clear() # 清空子线程记录
self.__listenThread = MyThread("监听线程", self.Listen)
self.__listenThread.setDaemon(True) #设置为守护线程，程序结束时强行结束监听
self.__listenThread.start()
def __init__(self, parent):
QtGui.QGraphicsPixmapItem.__init__(self)
self.parent = parent
self.currentSide = 0
self.thread = MyThread(self.parent, self.parent.getRandom)
self.thread.finished.connect(self.parent.errorHandler)
self.timer = QtCore.QTimer()
self.timer.timeout.connect(self.swapCoin)
def process_frame(self, frame):
# frame = cv2.imread(framePath, cv2.IMREAD_COLOR)
self.faceDetectorThread = MyThread(
name="faceDetectorThread",
processor=self.faceDetector,
event=None,
other_events=[self.face_recognition_block],
args=frame)
self.faceRecogThread = MyThread(
name="faceRecognitionThread",
processor=self.recognitionFace,
event=self.face_recognition_block,
other_events=[self.emotion_detection_block],
args=self.faceDetectorThread.mydata)
self.faceDetectorThread.start()
self.faceRecogThread.start()
self.emotion_detection_block.wait()
return self.faceRecogThread.mydata
def main():
nloops = int(argv[1])
q = Queue(32)
nconsumers = int(argv[2])
if nloops < nconsumers:
print("Too many threads for %s loops. Use less threads." % nloops)
return
threads = [MyThread(writer, (q, nloops), writer.__name__)]
for i in range(nconsumers):
t = MyThread(reader, (q, nloops//nconsumers), 'consumer %s' % i)
threads.append(t)
for thread in threads:
thread.start()
for thread in threads:
thread.join()
print("all DONE")
def main():
nloops = randint(2, 5)
q = Queue(32)
threads = []
for i in nfuncs:
t = MyThread(funcs[i], (q, nloops), funcs[i].__name__)
threads.append(t)
for i in nfuncs:
threads[i].start()
for i in nfuncs:
threads[i].join()
print 'all done'
def main(): q=Queue(32) threads=[] loops=randint(2,5) for i in nfuncs: t=MyThread(funcs[i],(q,loops,),funcs[i].__name__) threads.append(t) for i in nfuncs: threads[i].start() for i in nfuncs: threads[i].join() print 'all DONE'
def main():
q = Queue(1)
threads = []
for i in nfuncs:
t = MyThread(funcs[i], (q, ), funcs[i].__name__)
threads.append(t)
for i in nfuncs:
threads[i].start()
sleep(0.1)
for i in nfuncs:
threads[i].join()
print 'Happy!'
def main():
nfuncs = range(len(funcs))
threads = []
for i in nfuncs:
t = MyThread(funcs[i], x[i], funcs[i].__name__)
threads.append(t)
for i in nfuncs:
threads[i].start()
# for i in nfuncs:
# threads[i].join()
# print(threads[i].getResult())
print("all over!")
def Listen(self):
print("server：开始监听")
self.__server_socket.listen(128)
self.__server_is_listening = True
while self.__server_is_listening:
try:
client_socket, client_addr = self.__server_socket.accept(
) # 设置setblocking(False)后, accept不再阻塞
print("连接成功，客户端ip:{}，port:{}".format(client_addr[0],
client_addr[1]))
# 一旦连接成功，开一个子线程进行通信
client_socket.setblocking(False) # 子线程是非阻塞模式的(需要循环判断监听线程退出)
client_socket.settimeout(5) # 超时值设为5s
self.__running_client_cnt += 1
self.__thread_cnt += 1
self.new_client_signal.emit(
self.__running_client_cnt) # 向ui发信号，更新ui
client_name = "client{}".format(self.__thread_cnt) # 创建子线程
client_thread = MyThread(client_name, self.SubClientThread,
[client_socket, client_name])
client_thread.setDaemon(True) # 子线程配置为守护线程，主线程结束时强制结束
client_thread.start() # 子线程启动
except BlockingIOError:
pass
def main():
loops=randint(3,6)
q=Queue(32)
threads=[]
for i in nfuncs:
for j in pool:
t=MyThread(funcs[i],(q,loops),funcs[i].__name__)
threads.append(t)
for thread in threads:
thread.start()
for thread in threads:
thread.join()
print('all done')
class Controller:
def __init__(self):
self.person_detection_block = threading.Event()
self.face_detection_block = threading.Event()
self.pose_detection_block = threading.Event()
self.emotion_detection_block = threading.Event()
self.face_direction_block = threading.Event()
self.face_recognition_block = threading.Event()
self.students = []
self.faces = []
self.poses = []
self.names = []
self.emo = []
self.face_dir = []
self.faceDetector = DetectFace()
self.recognitionFace = RecognitionFace()
def process_frame(self, frame):
# frame = cv2.imread(framePath, cv2.IMREAD_COLOR)
self.faceDetectorThread = MyThread(
name="faceDetectorThread",
processor=self.faceDetector,
event=None,
other_events=[self.face_recognition_block],
args=frame)
self.faceRecogThread = MyThread(
name="faceRecognitionThread",
processor=self.recognitionFace,
event=self.face_recognition_block,
other_events=[self.emotion_detection_block],
args=self.faceDetectorThread.mydata)
self.faceDetectorThread.start()
self.faceRecogThread.start()
self.emotion_detection_block.wait()
return self.faceRecogThread.mydata
def mFunc(func, fileUrls):
urlslen = range(len(fileUrls))
mThread = []
for i in urlslen:
t = MyThread(func, (fileUrls[i],), func.__name__)
mThread.append(t)
for i in urlslen:
mThread[i].start()
for i in urlslen:
mThread[i].join()
writeFile(fileUrls[i].replace('http://',os.getcwd()), mThread[i].getResult())
def multiFunc(nfuncs):
print('\n*** MULTIPLE THREADS')
threads = []
for i in nfuncs:
t = MyThread(funcs[i], (n, ), funcs[i].__name__)
threads.append(t)
for i in nfuncs:
threads[i].start()
for i in nfuncs:
threads[i].join()
print(threads[i].getResult())
def multi_thread(funcs, nfuncs):
print("*** MULTI THREAD")
threads = []
for i in nfuncs:
t = MyThread(funcs[i], n, funcs[i].__name__)
threads.append(t)
for i in nfuncs:
threads[i].start()
for i in nfuncs:
threads[i].join()
print(threads[i].getResult())
def main():
print 'starting...\n'
q = Queue(100)
funcs = [writeEmails, readEmails]
nfuncs = range(len(funcs))
threads = []
for i in nfuncs:
t = MyThread(funcs[i], (q, ), funcs[i].__name__)
threads.append(t)
for i in nfuncs:
threads[i].start()
for i in nfuncs:
threads[i].join()
print 'DONE'
def _main():
nloops = randint(2, 5)
q = Queue(maxsize=32)
threads = []
for i in nfuncs:
t = MyThread(funcs[i], (q, nloops), funcs[i].__name__)
threads.append(t)
for i in nfuncs:
threads[i].start()
for i in nfuncs:
threads[i].join()
def mFunc(func, tn):
mThread = []
for i in range(tn):
print('append: ', i)
t = MyThread(func, (tn, ), fib.__name__)
mThread.append(t)
for i in range(tn):
print('start:', i)
mThread[i].start()
for i in range(tn):
print('join: ', i)
mThread[i].join()
print(mThread[i].getResult())
def main():
print '*** MULTIPLE THREADS'
threads = []
for i in range(3):
t = MyThread(ct, (
filename,
datapat,
), ct.__name__)
threads.append(t)
for i in range(3):
threads[i].start()
for i in range(3):
threads[i].join
def __init__(self, parent=None, master=None):
QtGui.QWidget.__init__(self, parent)
self.master = master
self.error = self.result = self.model = None
self.column = 1
self.setupUi(self) # set UI (method from Ui_MyWidget)
ResultTable.__init__(self) # set UI for result group widget (result table etc...)
self.btnGenerate.clicked.connect(self.generate)
self.checkIsSeconds.toggled.connect(self.allowSeconds)
self.checkIsMili.toggled.connect(self.allowMiliseconds)
self.thread = MyThread(self, self.getRandom)
self.thread.finished.connect(self.errorHandler)
def main():
print('starting at: ', ctime())
threads = []
nloops = range(len(loops))
for i in nloops:
t = MyThread(loop, (i, loops[i]), loop.__name__)
threads.append(t)
for i in nloops:
threads[i].start()
for i in nloops:
threads[i].join()
print('all Done at: ', ctime())
def __init__(self, parent=None, master=None):
QtGui.QWidget.__init__(self, parent)
self.master = master
self.error = self.result = self.model = None
self.column = 1
self.setupUi(self) # set UI (method from Ui_MyWidget)
ResultTable.__init__(self) # set UI for result group widget (result table etc...)
self.btnGenerate.clicked.connect(self.generate)
self.spinCol.valueChanged["int"].connect(self.changeColumn)
self.btnClear.clicked.connect(self.clearTable)
self.btnCopy.clicked.connect(self.copyResult)
self.btnSave.clicked.connect(self.saveResult)
self.thread = MyThread(self, self.getRandom)
self.thread.finished.connect(self.errorHandler)
def __init__(self, parent=None, master=None):
QtGui.QWidget.__init__(self, parent)
self.master = master
self.error = self.result = self.model = None
self.base = "10"
self.column = 1
self.setupUi(self) # set UI (method from Ui_MyWidget)
ResultTable.__init__(self) # set UI for result group widget (result table etc...)
self.fillPresetsList()
self.btnGenerate.clicked.connect(self.generate)
self.radioBin.clicked.connect(lambda: setattr(self, "base", "2")) # in lambda can't use '=' operator
self.radioOct.clicked.connect(lambda: setattr(self, "base", "8"))
self.radioDec.clicked.connect(lambda: setattr(self, "base", "10"))
self.radioHex.clicked.connect(lambda: setattr(self, "base", "16"))
self.comboPresets.activated["int"].connect(self.setPreset)
self.thread = MyThread(self, self.getRandom)
self.thread.finished.connect(self.errorHandler)
def __init__(self, parent=None, master=None):
QtGui.QWidget.__init__(self, parent)
self.master = master
self.error = self.result = self.model = None
self.daysOfWeek = [0,1,2,3,4]
self.column = 1
self.setupUi(self) # set UI (method from Ui_MyWidget)
ResultTable.__init__(self) # set UI for result group widget (result table etc...)
self.btnGenerate.clicked.connect(self.generate)
self.chkMon.toggled.connect(lambda x: self.updateDaysOfWeek(x, 0))
self.chkTue.toggled.connect(lambda x: self.updateDaysOfWeek(x, 1))
self.chkWed.toggled.connect(lambda x: self.updateDaysOfWeek(x, 2))
self.chkThr.toggled.connect(lambda x: self.updateDaysOfWeek(x, 3))
self.chkFri.toggled.connect(lambda x: self.updateDaysOfWeek(x, 4))
self.chkSut.toggled.connect(lambda x: self.updateDaysOfWeek(x, 5))
self.chkSun.toggled.connect(lambda x: self.updateDaysOfWeek(x, 6))
self.thread = MyThread(self, self.getRandom)
self.thread.finished.connect(self.errorHandler)
def main():
threads = []
page_response = Requests_Html(url)
tree = html.fromstring(page_response.text)
page_index = tree.xpath('/html/body//blockquote/p/a/@href')
for index, html_index in enumerate(page_index):
html_ = base_url + html_index
t = MyThread(Requests_Html, (html_,), html_)
threads.append(t)
for i in threads:
i.start()
for j in threads:
j.join()
# pages[k] = i.getResult()
page = MyThread.getResult()
print page.qsize()
for i in range(page.qsize()):
pages[i] = page.get()
def showQuota(self):
thread = MyThread(self, lambda: self.sb.label2.setText("Your quota (random bits for today): %s" % self.random.quota(format='plain')[0]))
thread.finished.connect(self.errorHandler)
thread.start()
class MyWidget(QtGui.QWidget, Ui_MyWidget, ResultTable):
def __init__(self, parent=None, master=None):
QtGui.QWidget.__init__(self, parent)
self.master = master
self.error = self.result = self.model = None
self.base = "10"
self.column = 1
self.setupUi(self) # set UI (method from Ui_MyWidget)
ResultTable.__init__(self) # set UI for result group widget (result table etc...)
self.fillPresetsList()
self.btnGenerate.clicked.connect(self.generate)
self.radioBin.clicked.connect(lambda: setattr(self, "base", "2")) # in lambda can't use '=' operator
self.radioOct.clicked.connect(lambda: setattr(self, "base", "8"))
self.radioDec.clicked.connect(lambda: setattr(self, "base", "10"))
self.radioHex.clicked.connect(lambda: setattr(self, "base", "16"))
self.comboPresets.activated["int"].connect(self.setPreset)
self.thread = MyThread(self, self.getRandom)
self.thread.finished.connect(self.errorHandler)
def fillPresetsList(self):
for preset in PRESETS["Integers"]:
title = "%s - %s" % (preset, repr(PRESETS["Integers"][preset]))
self.comboPresets.addItem(title, PRESETS["Integers"][preset])
def setPreset(self, index):
if index == 0: return
# tuple stored in comboBox itemData - (a, b) where a-min, b-max
self.spinMin.setValue(self.comboPresets.itemData(index)[0])
self.spinMax.setValue(self.comboPresets.itemData(index)[1])
def generate(self):
self.btnGenerate.setDisabled(True)
self.thread.start()
def getRandom(self):
result = self.master.random.integers(num=self.spinNum.value(),
min=self.spinMin.value(),
max=self.spinMax.value(),
base=self.base,
col=1, format='plain', rnd='new')
if self.checkAdd.isChecked() and type(self.result) is list:
self.result.extend(result)
else:
self.result = result
# print(self.result)
self.makeTable()
def log(self, error=None):
from time import strftime
self.master.logs.addRow(strftime("%d-%m-%Y"),
strftime("%H:%M:%S"),
self.master.random.__class__.__name__,
"Integers Generator",
error if error else "Generated: num=%s min=%s max=%s" % (self.spinNum.value(),
self.spinMin.value(),
self.spinMax.value()))
class MyWidget(QtGui.QWidget, Ui_MyWidget, ResultTable):
def __init__(self, parent=None, master=None):
QtGui.QWidget.__init__(self, parent)
self.master = master
self.error = self.result = self.model = None
self.column = 1
self.setupUi(self) # set UI (method from Ui_MyWidget)
ResultTable.__init__(self) # set UI for result group widget (result table etc...)
self.tableResult.setSortingEnabled(False) # disable column sorting (keep the items mixed is the point)
self.listModel = MyModel(1, 1, self.lblInfo)
self.tableCustomList.setModel(self.listModel)
self.tableCustomList.setEditTriggers(QtGui.QAbstractItemView.AllEditTriggers)
self.tableCustomList.horizontalHeader().hide()
self.tableCustomList.setColumnWidth(0, 150)
self.fillPresetsList()
# one groupPanel disables the other
self.groupGenerate.toggled.connect(lambda checked: self.groupLoad.setChecked(not checked))
self.groupLoad.toggled.connect(lambda checked: self.groupGenerate.setChecked(not checked))
self.btnGenerate.clicked.connect(self.generate)
self.comboPresets.activated["int"].connect(self.setPreset)
self.btnLoad.clicked.connect(self.loadList)
self.btnListClear.clicked.connect(lambda: self.listModel.clear())
self.spinCol.valueChanged["int"].connect(self.changeColumn)
self.btnClear.clicked.connect(self.clearTable)
self.btnCopy.clicked.connect(self.copyResult)
self.btnSave.clicked.connect(self.saveResult)
self.thread = MyThread(self, self.getRandom)
self.thread.finished.connect(self.errorHandler)
def fillPresetsList(self):
for preset in sorted(PRESETS["Sequences"]):
self.comboPresets.addItem(preset[1:], PRESETS["Sequences"][preset])
def loadList(self):
file = QtGui.QFileDialog.getOpenFileName(
parent=self, caption="Load data from file", directory=QtCore.QDir.currentPath(),
filter="CSV and text files (*.csv *.txt)")
if file:
sep = QtGui.QInputDialog.getText(self, "Type separator", "Type symbol that will be use for split text data", text=",")
if not all(sep): return
data = open(file, 'r').read()
res=[]
for l in data.split('\n'):
res.extend(l.split(sep[0]))
res = list( filter(lambda x: x.lstrip(), res) )
self.listModel.clear()
for row in range(len(res)):
item = QtGui.QStandardItem(res[row])
self.listModel.setItem(row, 0, item)
self.tableCustomList.setColumnWidth(0, 150)
self.log(file=file)
def setPreset(self, index):
self.listModel.clear()
if index == 0: return
# list stored in comboBox itemData
l = self.comboPresets.itemData(index)
for i in range(len(l)):
item = QtGui.QStandardItem(l[i])
self.listModel.setItem(i, 0, item)
self.tableCustomList.setColumnWidth(0, 150)
def generate(self):
self.btnGenerate.setDisabled(True)
self.thread.start()
def getRandom(self):
if self.groupGenerate.isChecked(): # generate sequence
min = self.spinMin.value()
max = self.spinMax.value()
else: # shuffle existing list
if self.listModel.rowCount() < 2: return
min = 0
max = self.listModel.rowCount()-2
result = self.master.random.sequences(min=min, max=max, col=1, format='plain', rnd='new')
if self.groupLoad.isChecked(): # shuffle custom list
customList = [self.listModel.index(i,0).data() for i in range(max+1)]
result = [customList[int(i)] for i in result]
if self.checkAdd.isChecked() and type(self.result) is list:
self.result.extend(result)
else:
self.result = result
self.makeTable()
def log(self, error=None, file=None):
from time import strftime
from os.path import basename
if file:
msg = "Custom list (%s elem.) was loaded from '%s' for shuffling" % (self.listModel.rowCount()-1, basename(file))
elif self.groupLoad.isChecked():
msg = "Custom list with %s element(s) was shuffled" % (self.listModel.rowCount()-1)
else:
msg = "Sequence was generated: min=%s max=%s" % (self.spinMin.value(), self.spinMax.value())
self.master.logs.addRow(
strftime("%d-%m-%Y"), strftime("%H:%M:%S"), self.master.random.__class__.__name__,
"Sequences Generator/Shuffler", error if error else msg)
class MyWidget(QtGui.QWidget, Ui_MyWidget, ResultTable):
def __init__(self, parent=None, master=None):
QtGui.QWidget.__init__(self, parent)
self.master = master
self.error = self.result = self.model = None
self.daysOfWeek = [0,1,2,3,4]
self.column = 1
self.setupUi(self) # set UI (method from Ui_MyWidget)
ResultTable.__init__(self) # set UI for result group widget (result table etc...)
self.btnGenerate.clicked.connect(self.generate)
self.chkMon.toggled.connect(lambda x: self.updateDaysOfWeek(x, 0))
self.chkTue.toggled.connect(lambda x: self.updateDaysOfWeek(x, 1))
self.chkWed.toggled.connect(lambda x: self.updateDaysOfWeek(x, 2))
self.chkThr.toggled.connect(lambda x: self.updateDaysOfWeek(x, 3))
self.chkFri.toggled.connect(lambda x: self.updateDaysOfWeek(x, 4))
self.chkSut.toggled.connect(lambda x: self.updateDaysOfWeek(x, 5))
self.chkSun.toggled.connect(lambda x: self.updateDaysOfWeek(x, 6))
self.thread = MyThread(self, self.getRandom)
self.thread.finished.connect(self.errorHandler)
def updateDaysOfWeek(self, isChecked, day):
if isChecked: self.daysOfWeek.append(day)
else: self.daysOfWeek.remove(day)
def generate(self):
self.btnGenerate.setDisabled(True)
self.thread.start()
def getRandom(self):
assert self.daysOfWeek, "Error: You should choose at least one day of the week"
from datetime import date, timedelta
day = timedelta(days=1)
num = self.spinNum.value()
date1 = currDate = self.dateEdit.date().toPyDate()
date2 = self.dateEdit_2.date().toPyDate()
format = self.comboFormat.itemData(self.comboFormat.currentIndex())
assert date2 > date1, "Error: Second date must be greater than first one"
allDaysList = []
while currDate != date2:
if currDate.weekday() in self.daysOfWeek:
allDaysList.append(currDate)
currDate += day
assert num <= len(allDaysList), "Error: There are only %s acceptable dates, when you need %s" % (len(allDaysList), num)
result = []
if len(allDaysList) == num:
result = allDaysList
else:
while len(result) < num:
result.append(
allDaysList.pop(
int( self.master.random.integers(num=1, min=0, max=len(allDaysList)-1, base='10', col=1, format='plain', rnd='new')[0] )
)
)
result = [d.strftime(format) for d in result]
if self.checkAdd.isChecked() and type(self.result) is list:
self.result.extend(result)
else:
self.result = result
# print(self.result)
self.makeTable()
def log(self, error=None):
from time import strftime
self.master.logs.addRow(strftime("%d-%m-%Y"),
strftime("%H:%M:%S"),
self.master.random.__class__.__name__,
"Date Generator",
error if error else "Generated %s date(s) between %s and %s" % (
self.spinNum.value(),
self.dateEdit.textFromDateTime(self.dateEdit.dateTime()),
self.dateEdit_2.textFromDateTime(self.dateEdit_2.dateTime()))
)
class MyWidget(QtGui.QWidget, Ui_MyWidget, ResultTable):
def __init__(self, parent=None, master=None):
QtGui.QWidget.__init__(self, parent)
self.master = master
self.error = self.result = self.model = None
self.column = 1
self.setupUi(self) # set UI (method from Ui_MyWidget)
ResultTable.__init__(self) # set UI for result group widget (result table etc...)
self.btnGenerate.clicked.connect(self.generate)
self.checkIsSeconds.toggled.connect(self.allowSeconds)
self.checkIsMili.toggled.connect(self.allowMiliseconds)
self.thread = MyThread(self, self.getRandom)
self.thread.finished.connect(self.errorHandler)
# secToTime(64835555, True, True) -> QTime(18, 0, 35, 555)
# secToTime(64835, True, False) -> QTime(18, 0, 35)
# secToTime(1080, False, False) -> QTime(18, 0)
def secToTime(self, units, isSeconds=True, isMilisec=True): # miliseconds to QTime (65482833 -> QTime(18, 11, 22, 833) 18:11:22.833)
hour = min = sec = msec = 0
if isMilisec:
msec = units % 1000
units /= 1000
if isSeconds:
sec = units % 60
units /= 60
min = units % 60
units /= 60
hour = units
return QtCore.QTime(hour, min, sec, msec)
# timeToSec(QTime(18, 0, 35, 555), True, True) -> 64835555
# timeToSec(QTime(18, 0, 35, 555), True, False) -> 64835
# timeToSec(QTime(18, 0, 35, 555), False, False) -> 1080
def timeToSec(self, qTime, isSeconds=True, isMilisec=True): # QTime to miliseconds (QTime(23, 59, 59, 999) -> 86399999)
if isSeconds:
if isMilisec:
return (qTime.hour()*3600 + qTime.minute()*60 + qTime.second())*1000 + qTime.msec()
return qTime.hour()*3600 + qTime.minute()*60 + qTime.second()
return qTime.hour()*60 + qTime.minute()
# formatTime(QTime(18, 0, 35, 555)) -> 18:00:35.555
# formatTime(QTime(18, 0)) -> 18:00
def formatTime(self, qTime):
format = self.timeEditFrom.displayFormat()
return qTime.toString(format)
def allowSeconds(self, isChecked):
self.checkIsMili.setCheckState(QtCore.Qt.Unchecked)
self.checkIsMili.setDisabled(not isChecked)
if isChecked:
self.timeEditFrom.setDisplayFormat("H:mm:ss")
self.timeEditTo.setDisplayFormat("H:mm:ss")
else:
self.timeEditFrom.setDisplayFormat("H:mm")
self.timeEditTo.setDisplayFormat("H:mm")
def allowMiliseconds(self, isChecked):
if isChecked:
self.timeEditFrom.setDisplayFormat("H:mm:ss.zzz")
self.timeEditTo.setDisplayFormat("H:mm:ss.zzz")
else:
self.timeEditFrom.setDisplayFormat("H:mm:ss")
self.timeEditTo.setDisplayFormat("H:mm:ss")
def generate(self):
self.btnGenerate.setDisabled(True)
self.thread.start()
def getRandom(self):
num = self.spinNum.value()
isSec = self.checkIsSeconds.isChecked()
isMsec = self.checkIsMili.isChecked()
interval = self.comboTimeInterval.itemData(self.comboTimeInterval.currentIndex())
timeStart = time1 = self.timeToSec( self.timeEditFrom.time(), isSec, isMsec )
timeEnd = time2 = self.timeToSec( self.timeEditTo.time(), isSec, isMsec )
if interval:
if isMsec: coef = interval * 60 * 1000
elif isSec: coef = interval * 60
else: coef = interval
time1 = 0
time2 = (timeEnd-timeStart) // coef
result = self.master.random.integers(num=num, min=time1, max=time2,
base='10', col=1, format='plain', rnd='new') # ['64835555', '573755', '73753'...]
if interval:
result = list( map(lambda x: self.secToTime(timeStart + int(x)*coef, isSec, isMsec), result) ) # [QTime(18, 0, 35, 555), QTime(01, 10, 35, 105)...]
else:
result = list( map(lambda x: self.secToTime(int(x), isSec, isMsec), result) ) # [QTime(18, 0, 35, 555), QTime(01, 10, 35, 105)...]
result = list( map(self.formatTime, result) ) # ['18:00:35.555', '01:10:35.105'...]
if self.checkAdd.isChecked() and type(self.result) is list:
self.result.extend(result)
else:
self.result = result
# print(self.result)
self.makeTable()
def log(self, error=None):
from time import strftime
self.master.logs.addRow(strftime("%d-%m-%Y"),
strftime("%H:%M:%S"),
self.master.random.__class__.__name__,
"Time Generator",
error if error else "Generated %s clock time(s) between %s and %s with interval %s" % (
self.spinNum.value(),
self.timeEditFrom.textFromDateTime(self.timeEditFrom.dateTime()),
self.timeEditTo.textFromDateTime(self.timeEditTo.dateTime()),
self.comboTimeInterval.currentText())
)
def thFertilizer(num, delay, arr):
fer = MyThread(fertilizer, (num, delay, arr))
fer.start()
fer.join()
