def producer(self, producer_id):
"""Creates an instance of myanimelist.Producer with the given ID.
:type producer_id: int
:param producer_id: The desired producer's ID.
:rtype: :class:`myanimelist.producer.Producer`
:return: A new Producer instance with the given ID.
"""
return producer.Producer(self, producer_id)
def main():
parser = argparse.ArgumentParser('\n\t组成数字的长条的宽（w）高（h）比为 k（暂时写死为 2）\n\
\t生成图片宽高计算公式如下：\n\t W = (k+4)*h\n\t H = (2k+5)*h\n')
parser.add_argument('num', type=int)
parser.add_argument('h', type=int, help='尽量使用偶数')
parser.add_argument('--zfill',
default=False,
type=int,
help='数字总位数（不足前补0）')
# parser.add_argument('--padding', default=20, type=int, help='数字和边框的间距')
args = parser.parse_args()
if args.zfill:
num_fromat = '{:0>' + str(args.zfill) + 'd}'
num_str = num_fromat.format(args.num)
else:
num_str = str(args.num)
print 'num str to produce "{}"'.format(num_str)
num_blocks = []
pder = producer.Producer(args.h)
for num in num_str:
num_blocks.append(pder.produce(num))
nums_block = None
for num_block in num_blocks:
if nums_block is None:
nums_block = num_block
continue
nums_block = numpy.column_stack((nums_block, num_block))
nums_block_shape = nums_block.shape
# 暂定 20 像素
padding = 20
frame_block = numpy.zeros((nums_block_shape[0] + padding * 2,
nums_block_shape[1] + padding * 2, 3),
dtype=numpy.uint8)
frame_block.fill(255)
numpy.copyto(frame_block[padding:padding + nums_block_shape[0],
padding:padding + nums_block_shape[1]],
nums_block,
casting='same_kind')
# cv2.imshow('s', frame_block)
# cv2.waitKey()
output_dir = './masks'
if not os.path.exists(output_dir):
os.mkdir(output_dir)
cv2.imwrite('{}/{}.bmp'.format(output_dir, num_str), frame_block)
def __init__(self):
"""
Initializes the queue, the file, the Consumer and the Producer and calls the start_threads() method
"""
self.queue = queue.Queue()
self.file = open("prime_numbers.txt", 'w')
self.t_producer = producer.Producer(self.queue)
self.t_consumer = consumer.Consumer(self.queue, self.file)
self.start_threads()
def main():
queue = taskqueue.TaskQueue(100)
producer = p.Producer(queue=queue, start_date=start, end_date=end)
consumer_1 = c.Consumer(queue=queue)
consumer_2 = c.Consumer(queue=queue)
consumer_3 = c.Consumer(queue=queue)
consumer_4 = c.Consumer(queue=queue)
producer.start()
consumer_1.start()
consumer_2.start()
consumer_3.start()
consumer_4.start()
def ChunkSeq_to_workload2(chkseq, rootdir, tofile):
assert chkseq['!class'] == 'ChunkSeq'
prd = producer.Producer(
rootdir = rootdir,
tofile = tofile)
for chkbox in chkseq['seq']:
if chkbox['chunk'].has_key('filepath'):
filepath= chkbox['chunk']['filepath']
if chkbox['chunk'].has_key('writer_pid'):
writer_pid = chkbox['chunk']['writer_pid']
for op in chkbox['opseq']:
if op['opname'] == 'open' and op['opvalue'] == True:
prd.addUniOp2('open', pid=writer_pid, path=filepath)
elif op['opname'] == 'chunk':
prd.addReadOrWrite2('write',
pid=writer_pid,
path=filepath,
off=chkbox['chunk']['offset'],
len=chkbox['chunk']['length'])
elif op['opname'] == 'fsync' and op['opvalue'] == True:
prd.addUniOp2('fsync', pid=writer_pid, path=filepath)
elif op['opname'] == 'close' and op['opvalue'] == True:
prd.addUniOp2('close', pid=writer_pid, path=filepath)
elif op['opname'] == 'sync' and op['opvalue'] == True:
prd.addOSOp('sync', pid=writer_pid)
elif op['opname'] == 'sched_setaffinity' and \
op['opvalue'] != -1:
prd.addSetaffinity(pid=writer_pid, cpuid=op['opvalue'])
elif op['opname'] == 'mkdir':
prd.addDirOp2(op='mkdir', pid=0, path=op['opvalue'])
#prd.display()
#exit(0)
prd.saveWorkloadToFile()
return True
def producer_create_if_needed(requested_name, type_if_new):
"""
Returns a producer with requested_name. If no producer
with requested_name exists, a new one will be created
with type set as type_if_new.
Args:
requested_name (str): The name of the producer
to be returned.
type_if_new (str): If the producer didn't exist,
this will be the type of the new one.
Returns: The requested producer.
"""
try:
return get_producer(requested_name)
except NotInDatabase:
new_producer = producer.Producer(name=requested_name,
type_of=type_if_new)
new_producer.save()
return new_producer
import time
import producer
import progress_monitor
import sender
if __name__ == '__main__':
start = time.time()
prod = producer.Producer(num_messages=100)
# mean_wait_time (in sec.), fail_rate (probablity 0-1), max_wait (in sec.)
send1 = sender.Sender(3, 0.1, max_wait=5)
send2 = sender.Sender(0.5, 0.25, max_wait=2)
pro_mon = progress_monitor.ProgressMonitor(prod, [send1, send2],
refresh_rate=1)
pro_mon.exec()
print(f'realtime elapsed: {time.time() - start}')
group1 = group.Group(name="KTH",
owner=user1,
tags=[tag1, tag2],
time_created=datetime.\
datetime.now())
info1 = information.Information(title="dnledare",
url="dn.se/ledare",
time_published=datetime.datetime.now(),
tags=[tag1])
info2 = information.Information(title="SvDledare",
url="svd.se/ledare",
references=[info1],
time_punlished=datetime.datetime.now(),
tags=[tag1, tag2])
prod1 = producer.Producer(name="DN",
type_of="newspaper")
prod2 = producer.Producer(name="SvD",
type_of="newspaper")
info_rating1 = producer.InformationRating(rating=4,
information=info1)
source_rating1 = producer.SourceRating(rating=3, source=prod2,
tag=tag1)
prod2.info_ratings.append(info_rating1)
prod1.source_ratings.append(source_rating1)
group1.save()
info1.save()
info2.save()
prod2.save()
prod1.save()
def main():
rabbitmq_host = sys.argv[1]
producer1 = producer.Producer(rabbitmq_host)
producer1.produce(sys.argv[2],sys.argv[3],sys.argv[4])
"""
@author: Filip Scopulovic
@date: 21-11-2016
@use: starting script for the project A08_Thread_Synch
"""
import watch_dog, consumer, producer, queue
#Empty list of threads
threads = []
#Initalizes the queue
qu = queue.Queue()
#Sets the maximum size for the queue at 20
qu.maxsize = 20
#Initalizes the Producer
p1 = producer.Producer(qu)
p2 = producer.Producer(qu)
#Initalizes the Consumers
c1 = consumer.Consumer(qu)
c2 = consumer.Consumer(qu)
#Adds all the threads together
threads.append(p1)
threads.append(p2)
threads.append(c1)
threads.append(c2)
running_time = 2
#Initializes the watch dog
w = watch_dog.WatchDog(running_time, *threads)
w.start()
for thread in threads:
thread.start()
def setUp(self):
self.tearDown()
self.tag1 = tag.Tag(name="Gardening")
self.tag1.save()
self.tag2 = tag.Tag(name="Cooking")
self.tag2.save()
self.tag2.parent.append(self.tag1)
self.tag2.save()
self.user1 = user.User(name="alfred", password="******")
self.user1.save()
self.user1.create_group("Group1", "Gardening")
self.user1.save()
self.user2 = user.User(name="fredrik", password="******")
self.user2.save()
self.user2.create_group("Group2", "Cooking")
self.user2.save()
self.group1 = extractor.get_group(self.user1.name, "Group1")
self.group2 = extractor.get_group(self.user2.name, "Group2")
self.info1 = information.Information(
title="dn_ledare1",
url="www.dn.se",
time_published=datetime.datetime.now())
self.info1.tags.append(self.tag1)
self.info1.save()
self.info2 = information.Information(
title="svd_ledare1",
url="www.svd.se",
time_published=datetime.datetime.now())
self.info3 = information.Information(
title="cnn_article",
url="www.cnn.com",
time_published=datetime.datetime.now())
self.info2.tags.append(self.tag1)
self.info2.tags.append(self.tag2)
self.info2.save()
self.info3.tags.append(self.tag2)
self.info3.save()
self.prod1 = producer.Producer(name="DN", type_of="newspaper")
self.prod1.save()
self.prod2 = producer.Producer(name="SvD", type_of="newspaper")
self.prod2.save()
self.prod3 = producer.Producer(name="Aftonbladet", type_of="newspaper")
self.prod3.save()
self.prod3.rate_source(self.prod2, self.tag2, 5)
self.prod3.save()
self.prod1.rate_source(self.prod2, self.tag1, 2)
self.prod1.rate_information(self.info1, 5)
self.prod2.rate_information(self.info1, 4)
self.prod3.rate_information(self.info1, 3)
self.prod1.save()
self.prod2.save()
self.prod3.save()
self.prod4 = producer.Producer(name="Expressen", type_of="newspaper")
self.prod4.save()
self.prod4.rate_information(self.info1, 1)
self.prod4.rate_information(self.info2, 2)
self.prod4.rate_information(self.info3, 6)
self.prod4.save()
self.prod5 = producer.Producer(name="RealClear", type_of="newspaper")
self.prod5.save()
self.prod6 = producer.Producer(name="TheSun", type_of="newspaper")
self.prod6.save()
self.user2.add_to_group(self.group2.name, self.prod5)
self.user2.add_to_group(self.group2.name, self.prod6)
self.user2.save()
self.user2.rate_group(str(self.group2.name), 4)
self.user2.save()
def _create_producer(self) -> producer.Producer:
return producer.Producer(self._host, self._port, self._user_token,
self._password_token)
def prod(request):
return producer.Producer()
def times(request):
prod = producer.Producer(num_messages=num_messages)
send = sender.Sender(mean, fail_rate, max_wait)
return [send.send_message(i, test=True) for i in prod.messages]
# -*- coding: utf-8 -*-
import producer
import consumer
import threading
import Queue
if __name__ == "__main__":
#初始化
q_data = Queue.Queue()
#event=threading.Event()
#lock=threading.Lock()
t_num = 4 #待测试最优线程数
for each in range(t_num):
c = consumer.Consumer(each, q_data)
c.start()
p = producer.Producer('D:\\cicv\\test data', '-Watchdog', q_data)
p.start()
#q_data.join()
"""
若进程中断，则可比较源文件和已转换文件名，将未转换文件转换
"""
