def __init__(self, queue_size=128):
self.stopped = False
self.config = Config()
self.packer = Packer()
self.init_config()
# self.Q = PriorityQueue(maxsize=self.queue_size)
self.Q = Queue(maxsize=self.queue_size)
self.img_Q = Queue(maxsize=self.queue_size)
self.piece_array = []
self.piece_time = int(time.time() * 1000)
self.piece_fps = 40
for i in range(self.packer.frame_pieces):
self.piece_array.append(None)
# init timestamp
self.frame = numpy.zeros(self.packer.frame_size_3d, dtype=numpy.uint8)
self.imshow = self.frame.reshape(self.packer.h, self.packer.w,
self.packer.d)
self.last_frame_time = int(time.time() * 1000)
self.require = True
self.time_delay = 0
self.delay_timer = int(time.time() * 1000)
self.lock = Lock()
def collate(self, batch, is_train=True):
if is_train:
packer = Packer([x['teller_tokens_in'] for x in batch])
return {
'packer':
packer,
'brw_teller_tokens_in':
packer.brw_from_list([x['teller_tokens_in']
for x in batch]).to(cuda_if_available),
'brw_teller_counts_in':
packer.brw_from_list([x['teller_counts_in']
for x in batch]).to(cuda_if_available),
'brw_teller_tokens_out':
packer.brw_from_list([x['teller_tokens_out']
for x in batch]).to(cuda_if_available),
'b_scene_tags':
torch.stack([x['scene_tags']
for x in batch]).to(cuda_if_available),
'b_scene_mask':
torch.stack([x['scene_mask']
for x in batch]).to(cuda_if_available),
'br_drawer_clipart_state':
packer.br_from_list([x['drawer_clipart_state']
for x in batch]).to(cuda_if_available),
}
else:
return {
'b_scene_tags':
torch.stack([x['scene_tags']
for x in batch]).to(cuda_if_available),
'b_scene_mask':
torch.stack([x['scene_mask']
for x in batch]).to(cuda_if_available),
}
def parse(path, f=None):
p = Parser(path=path)
p.parse_file()
j = Packer(parser=p)
if f is None:
return j.pack()
else:
j.pack(f=f)
def __init__(self, client, filenames, key):
super().__init__(filenames)
self._logger = logging.getLogger('DropboxBackup')
self._packer = Packer(key)
self._client = client
for f in self._filenames:
if not os.path.exists(f):
self.restore(f)
def processFile(path, f=None):
p = Parser(path=path)
p.parseFile()
a = Analyzer(parser=p)
a.analyze()
j = Packer(analyzer=a)
if f is None:
return j.pack()
else:
j.pack(f=f)
def processFile(path):
try:
p = Parser(path=path)
p.parseFile()
a = Analyzer(parser=p)
a.analyze()
j = Packer(analyzer=a)
return j.pack()
except:
print path
exit(1)
def __call__(self, ar): p = Packer(ar) for feature, size in self.features: p.addRoom(size) p.pack() for room, (feature, size) in zip(p.rooms, self.features): r = area.Area(room.left, room.top, room.right, room.bottom) for cell in feature(r): yield cell
def __init__(self, queue_size=128):
self.stopped = False
self.config = Config()
self.packer = Packer()
self.init_config()
# self.Q = PriorityQueue(maxsize=self.queue_size)
self.Q = Queue(maxsize=self.queue_size)
self.img_Q = Queue(maxsize=self.queue_size)
# init timestamp
self.frame = numpy.zeros(self.packer.frame_size_3d, dtype=numpy.uint8)
self.last_frame_time = int(time.time() * 1000)
self.require = True
def __init__(self, src="C:\\Tools\\titan_test.mp4"):
self.config = Config()
self.packer = Packer()
# initialize the file video stream along with the boolean
# used to indicate if the thread should be stopped or not
os.environ["OPENCV_VIDEOIO_DEBUG"] = "1"
os.environ["OPENCV_VIDEOIO_PRIORITY_MSMF"] = "0"
encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), 15]
self.stream = cv2.VideoCapture(src)
# while True:
# if cv2.waitKey(1) & 0xFF == ord('q'):
# break
# ret, frame = self.stream.read()
# if ret:
# # print(frame.shape)
# # frame = frame.reshape(self.packer.h, self.packer.w, self.packer.d)
# cv2.imshow('read video data.jpg', frame)
# self.stream.set(cv2.CAP_PROP_MODE, cv2.CAP_MODE_YUYV)
# print(self.stream.get(cv2.CAP_PROP_FPS)) # 默认帧率30
# self.stream.set(cv2.CAP_PROP_FPS, 20) # cv version is 3.4.2
self.stopped = False
self.requesting = False
self.request = False
self.quit = False
self.fps = 40
self.push_sleep = 0.01
self.push_sleep_min = 0.001
self.push_sleep_max = 0.2
self.piece_array = []
self.piece_time = int(time.time() * 1000)
self.piece_fps = 40
for i in range(self.packer.frame_pieces):
self.piece_array.append(None)
self.frame = numpy.zeros(self.packer.frame_size_3d, dtype=numpy.uint8)
self.imshow = self.frame.reshape(self.packer.h, self.packer.w,
self.packer.d)
self.frame_size = 0
self.piece_size = 0
self.frame_pieces = 0
self.init_config()
self.init_connection()
# intialize thread and lock
self.thread = Thread(target=self.update, args=())
self.thread.daemon = True
def main():
examples = []
examples.append(("-n test.cfg", "creates empty config file"))
examples.append(("-v sprite.cfg", "runs sprite.cfg with messages"))
ex_str = "\n".join(
[" %prog {0:<18}{1}".format(tup[0], tup[1]) for tup in examples])
usage = "Usage: %prog [options] <config file> [<config file> ...]\n\nExamples:\n{0}".format(
ex_str)
parser = OptionParser(usage=usage,
version="%prog {0}".format(Packer.version_str()))
parser.add_option("-v",
"--verbose",
action="store_true",
help="print messages to stdout",
dest="verbose")
parser.add_option(
"-n",
"--new-config",
action="store_true",
help=
"creates an empty config file; recommended way of creating a new sprite.",
dest="newcfg")
#parser.add_option("--hd", action="store_true", help="works only with -n, creates an empty config file perfect for generating ", dest="create-cfg")
(options, args) = parser.parse_args()
if args:
for arg in args:
packer = Packer(arg)
if options.newcfg:
packer.create_cfg(arg)
else:
for etype_and_msg in packer.run_with_messages():
etype, msg = etype_and_msg
if etype == ERROR:
sys.stderr.write(msg + "\n")
elif etype == MESSAGE and options.verbose:
print msg
if packer.error_msg():
sys.exit(1)
def _pack_test(self):
if len(self.textures) == 0:
return
from packer import PackingRectangle, Packer
# prepare rects
rects = []
rects2 = {}
for texture in self.textures:
r = PackingRectangle()
r.size = texture.get("img").size
rects.append(r)
rects2[r] = (texture.get("name"), texture.get("img"))
# pack
packer = Packer(rects)
res, area = packer.pack()
uvs = {}
w = 0
h = 0
for e in res:
w = max(w, e.right)
h = max(h, e.bottom)
for e in res:
rect = e.rect
uvs[rects2.get(e)[0]] = (rect[0] / float(w), rect[1] / float(h), rect[2] / float(w), rect[3] / float(h)) # u1, v1, u2, v2
print("packed into", w, h)
# generate new image
img = Image.new('RGBA', (w, h))
for e in res:
img.paste(rects2.get(e)[1], e.position)
self.textures = [{"path": "atlas.png", "name": "texture_atlas", "index": 0, "img": img}]
for spr in self.sprites:
uv = uvs.get(spr["texture_name"])
spr["uv"] = {"u1": float(uv[0]), "v1": float(uv[1]), "u2": float(uv[2]), "v2": float(uv[3])}
spr["texture_name"] = "texture_atlas"
def __init__(self, account):
self.username = account['username']
self.password = account['password']
self.server = account['server']
self.shipClasses = { }
self.ships = { }
self.fleets = [ None, None, None, None ]
self.expeditions = { }
self.repairYards = [ None, None, None, None ]
self.maxShipNum = 0
self.errorCodes = { }
self.packer = Packer(self)
Log.i('Initializing game...')
self.conn = Connection()
self.gameData = self.conn.get('/index/getInitConfigs/')
for shipClassData in self.gameData['shipCard']:
if int(shipClassData['npc']) == 0 and int(shipClassData['release']) == 1:
shipClass = self.packer.makeShipClass(shipClassData)
self.shipClasses[shipClass.id] = shipClass
for expeditionData in self.gameData['pveExplore']:
expedition = self.packer.makeExpedition(expeditionData)
self.expeditions[expedition.id] = expedition
Log.errorCodes = { int(k) : v for k, v in self.gameData['errorCode'].items() }
Log.i('Logging in...')
loginData = self.conn.httpsGet('/index/passportLogin/%s/%s/' % (self.username, self.password))
self.conn.setServer(self.server)
time.sleep(1)
self.conn.get('//index/login/' + loginData['userId'])
Log.i('Initializing user data...')
self.userData = self.conn.get('/api/initGame/')
self.conn.get('/pevent/getPveData/')
self.conn.get('/pve/getPveData/')
time.sleep(5)
self.conn.get('/active/getUserData/')
self.conn.get('/campaign/getUserData/')
self.conn.get('/pve/getUserData/')
for shipData in self.userData['userShipVO']:
ship = self.packer.makeShip(shipData)
self.ships[ship.id] = ship
for fleetData in self.userData['fleetVo']:
fleet = self.packer.makeFleet(fleetData)
self.fleets[fleet.id - 1] = fleet
for expStatusData in self.userData['pveExploreVo']['levels']:
exp = self.expeditions[int(expStatusData['exploreId'])]
fleet = self.fleets[int(expStatusData['fleetId']) - 1]
endTime = datetime.fromtimestamp(int(expStatusData['endTime']))
exp.setStatus(fleet, endTime)
for repairYardData in self.userData['repairDockVo']:
ry = self.packer.makeRepairYard(repairYardData)
self.repairYards[ry.id - 1] = ry
self.maxShipNum = int(self.userData['userVo']['detailInfo']['shipNumTop'])
Log.i('Done')
def main():
# Inicializa enlace ... variavel com possui todos os metodos e propriedades do enlace, que funciona em threading
com = Enlace(serialName) # repare que o metodo construtor recebe um string (nome)
# Ativa comunicacao
com.enable()
com.rx.clearBuffer()
my_server = Protocol.sever_number
packer = Packer()
unpacker = Unpacker()
file_num = 1
try_num = 1
# Log
print("-------------------------")
print("Comunicação inicializada")
print(" porta : {}".format(com.fisica.name))
print("-------------------------")
ocioso = True
serverReady_message_sent = False
count = 1
while(True):
# Server está ocioso
if ocioso:
dataRx = com.getData(Protocol.max_size, time.time())
data, code, kind, total, server, client = unpacker.unpack(dataRx, first=True)
# Server checa se o código e número de server da mensagem estão certos
if code == Protocol.type_client_call and server == my_server:
# Log do server é inicializado
log = open("log/fille{:02}log_try{:02}.txt".format(file_num, try_num),"w+")
# Server deixa de estar ocioso
ocioso = False
client_number = client
print("-------------------------")
print("Server chamado pelo client")
print("-------------------------")
log.write("Msg: {} – recebida: {} – remetente: {}\n".format(code, time.ctime(time.time()), client))
# Server não está mais ociono mas ainda não mandou uma mensagem com Código 2
elif serverReady_message_sent == False:
message = packer.pack_message(Protocol.type_server_ready, total, total, my_server, client_number)
com.sendData(message)
while(com.tx.getIsBussy()):
pass
serverReady_message_sent = True
log.write("Msg: {} – enviada: {} – destinatário: {}\n".format(Protocol.type_server_ready, time.ctime(time.time()), client_number))
print("-------------------------")
print("Total de pacotes a receber : {}".format(total))
print("Tipo de arquivo : {}".format(Protocol.from_kind[kind]))
print("-------------------------")
# Variáveis são iniciadas aqui para que não sejam mudadas indevidamente no loop de envio
recieved = bytes()
start = time.time()
time_out_time = time.time()
# Server recebe os pacotes e checa seus conteúdos
else:
# Enquanto todos os pacotes ainda não foram recebido, é checado se ainda não ocorreu um timeout
if count <= total and (time.time() - time_out_time) < Protocol.great_timeout:
dataRx = com.getData(Protocol.max_size, time.time())
data, code, atual, client = unpacker.unpack(dataRx)
print("-------------------------")
print("Pacote aberto")
print("Contador {} e atual {} e código {}".format(count, atual, code))
print("-------------------------")
log.write("Msg: {} – recebida: {} – remetente: {}\n".format(code, time.ctime(time.time()), client))
# Se o pacote recebido conter o código certo e seu número bater com o esperado,
# seu conteúdo é adicionado e uma mensagem de confirmação é enviada
if code == Protocol.type_package_delivery and atual == count and client == client_number:
print("-------------------------")
print("Pacote {} de {} recebido".format(atual, total))
print("-------------------------")
recieved += data
message = packer.pack_message(Protocol.type_package_ok, count, total, Protocol.sever_number, client_number)
com.sendData(message)
while(com.tx.getIsBussy()):
pass
count += 1
time_out_time = time.time()
log.write("Msg: {} – enviada: {} – destinatário: {}\n".format(Protocol.type_package_ok, time.ctime(time.time()), client_number))
# Se o pacote recebido não conter o código certo eou seu número não bater com o esperado,
# seu conteúdo é ignorado e uma mensage de erro com o pacote esperado é enviada
else:
print("-------------------------")
print("Erro")
print("Aguardando reenvio")
print("-------------------------")
message = packer.pack_message(Protocol.type_error, count, total, Protocol.sever_number, client_number)
com.sendData(message)
while(com.tx.getIsBussy()):
pass
log.write("Msg: {} – enviada: {} – destinatário: {}\n".format(Protocol.type_error, time.ctime(time.time()), client_number))
# Quando todos os pacotes forem recebidos o stuffing, se houver, é removido e o arquivo salvo
# O server volta para seu estado ocioso
elif count > total:
end = time.time() - start
print("-------------------------")
print("Pacotes recebidos com sucesso")
print("Taxa de recepção: {:02}".format(total*Protocol.max_size/end))
print("Salvando")
print("-------------------------")
to_save = unpacker.destuff(recieved)
open("recieved/recieved{:02}".format(file_num) + Protocol.from_kind[kind],"wb").write(to_save)
log.write("Salvo em: {}\n".format(time.ctime(time.time())))
log.close()
file_num += 1
print("-------------------------")
print("Aguardando novo envio")
print("-------------------------")
ocioso = True
serverReady_message_sent = False
com.rx.clearBuffer()
count = 1
try_num = 1
# Se mais tempo que o estipulado para um timeout passou, o server volta para seu estado ocioso
else:
print("-------------------------")
print("Timeout")
print("Aguardando novo envio")
print("-------------------------")
message = packer.pack_message(Protocol.type_time_out, count, total, my_server, client_number)
com.sendData(message)
while(com.tx.getIsBussy()):
pass
ocioso = True
serverReady_message_sent = False
count = 1
log.write("Msg: {} – enviada: {} – destinatário: {}\n".format(Protocol.type_time_out, time.ctime(time.time()), client_number))
log.write("Encerrado\n")
log.close()
from packer import Packer
import sys
import argparse
def create_arg_parser():
parser = argparse.ArgumentParser()
parser.add_argument('-o', '--output', default='')
parser.add_argument('-e', '--epsilon')
parser.add_argument('-n', '--length')
return parser
if __name__ == '__main__':
arg_parser = create_arg_parser()
namespace = arg_parser.parse_args(sys.argv[1:])
solver = Packer(namespace.output, int(namespace.epsilon),
int(namespace.lenght))
from packer import Packer
from unpacker import Unpacker
unp = Unpacker('/mnt/d/mobile/firm/T91_4_TF/T91_4.bin')
unp.export('/mnt/d/mobile/unpack', unpack_files=True, crc_check=True)
print(unp)
p = Packer('/mnt/d/mobile/test_firm')
p.export('/mnt/d/mobile/T91_4.bin.new')
from packer import Packer
from fdates import parse
P = Packer()
P.dataset(
1, {
"url": "https://www.betashares.com.au/files/nav/NDQ_History.csv",
"parse_as": "csv",
"name": "NAV History",
"index": "Date",
"subsets": ["NAV"],
"scrape_every": "1 day"
})
# toppling is the act of:
# 1. store index [0] of list as x
# 2. prepend x to list
# 3. pop last value off list
P.topple(1, "NAV")
P.dataset(
2, {
"url": "NDQ.AX.yfi",
"range": "daily",
"name": "NASDAQ ETF",
"index": "date",
"subsets": ["close"],
"scrape_every": "1 day"
})
# Consul
consul_config = config["consul"]
consul = Consul(
path=consul_config["path"],
repository_path=consul_config["repository_path"],
git_url=consul_config["git_url"],
minimum_version=consul_config["minimum_version"]
)
docs.append(consul)
# Packer
packer_config = config["packer"]
packer = Packer(
path=packer_config["path"],
repository_path=packer_config["repository_path"],
git_url=packer_config["git_url"],
minimum_version=packer_config["minimum_version"]
)
docs.append(packer)
# Terraform
terraform_config = config["terraform"]
terraform = Terraform(
path=terraform_config["path"],
repository_path=terraform_config["repository_path"],
git_url=terraform_config["git_url"]
)
docs.append(terraform)
# Vault
vault_config = config["vault"]
def main():
# Inicializa enlace ... variavel com possui todos os metodos e propriedades do enlace, que funciona em threading
com = Enlace(serialName)
# Ativa comunicacao
com.enable()
com.rx.clearBuffer()
packer = Packer()
unpacker = Unpacker()
# Log
run = True
call = True
response = False
serverReady_message_get = False
count = 1
while (run):
if not response:
if call:
selected = select_file()
print("-------------------------")
print("Gerando dados para transmissao :")
print("-------------------------")
data = open(selected, "rb").read()
delivery, total = packer.pack(data,
get_kind(selected),
Protocol.type_package_delivery,
get_total=True)
print("-------------------------")
print("Chamando o server para tranferência de dados")
print("-------------------------")
message_timeot = time.time()
call = False
else:
if (time.time() - message_timeot) < Protocol.great_timeout:
message = packer.pack_message(Protocol.type_client_call,
total, total,
Protocol.sever_number)
com.sendData(message)
while (com.tx.getIsBussy()):
pass
dataRx = com.getData(Protocol.max_size, time.time())
data, code, atual = unpacker.unpack(dataRx)
if code == Protocol.type_server_ready:
serverReady_message_get = True
response = True
print("-------------------------")
print("Server pronto, começando o envio")
print("-------------------------")
start = time.time()
time_out_time = time.time()
count = 1
else:
response = True
elif not call and serverReady_message_get:
if count <= total and (time.time() -
time_out_time) < Protocol.great_timeout:
print("-------------------------")
print("Envindo pacote {} de {}".format(count, total))
print("-------------------------")
com.sendData(delivery[count - 1])
while (com.tx.getIsBussy()):
pass
dataRx = com.getData(Protocol.max_size, time.time())
data, code, atual = unpacker.unpack(dataRx)
if code == Protocol.type_package_ok and atual == count:
print("-------------------------")
print("Pacote {} de {} enviado com sucesso".format(
count, total))
print("-------------------------")
count += 1
time_out_time = time.time()
else:
print("-------------------------")
print("Erro")
print("-------------------------")
if 1 <= atual <= total:
count = atual
elif count > total:
end = time.time() - start
print("-------------------------")
print("Pacotes enviados com sucesso")
print("Taxa de recepção: {:02}".format(
total * Protocol.max_size / end))
print("-------------------------")
print("-------------------------")
go_on = input(
"Se desejar um novo envio digite sim, caso contrário outro caractere: "
)
print("-------------------------")
call = True
serverReady_message_get = False
response = False
count = 1
if go_on != "sim":
print("-------------------------")
print("Até mais!")
print("-------------------------")
run = False
else:
print("-------------------------")
print("O server não respondeu e um timeout ocorreu")
print("-------------------------")
print("-------------------------")
go_on = input(
"Se desejar um novo envio digite sim, caso contrário outro caractere: "
)
print("-------------------------")
call = True
serverReady_message_get = False
response = False
count = 1
if go_on != "sim":
print("-------------------------")
print("Até mais!")
print("-------------------------")
run = False
else:
print("-------------------------")
print("O server não respondeu e um timeout ocorreu")
print("-------------------------")
print("-------------------------")
go_on = input(
"Se desejar um novo envio digite sim, caso contrário outro caractere: "
)
print("-------------------------")
call = True
serverReady_message_get = False
response = False
count = 1
if go_on != "sim":
print("-------------------------")
print("Até mais!")
print("-------------------------")
run = False
