def main(_):
args = utils.parse_command_line()
# utils.clear_summaries()
if 'seq2seq' not in args.model:
run_rnn_rcnn(args)
else:
setup_actor_critic_model(args)
def update_round_time(socks,addresses):
while True:
one_way_time = []
for sock,address in zip(socks,address):
cur_serv_time = current_milli_time()
sock.send(struct.pack(">LL",0,cur_serv_time))
time_taken = utils.recv_until(sock,b'?').decode('utf-8')
time_taken = int(time_taken[:len(time_taken)-1])
one_way_time.append((time_taken,address[1])
one_way_time.sort()
time_ref = one_way_time[0]
one_way_time = [x-time_ref for x in one_way_time]
for tup in one_way_time:
server_global.subflow_wait_time[tup[1]] = tup[0]
if __name__ == '__main__':
server_global.init()
addresses,file_name = utils.parse_command_line("Multiple sockets server")
print('Streaming:' + file_name)
listeners = map(utils.create_srv_socket,addresses)
cap = cv2.VideoCapture(str(file_name))
time_ref = current_milli_time()
for address,listener in zip(addresses,listeners):
start_thread(listener,address)
while(cap.isOpened()):
ret,frame = cap.read()
timestamp = current_milli_time()-time_ref
if ret:
ret,image = cv2.imencode('.jpg',frame,encode_param)
if(ret==False):
break
data = pickle.dumps(image)
sze = len(data)
print("Main Thread: Appended " + str(sze) + " bytes, with timestamp:" + str(timestamp))
server_global.qu.append(struct.pack(">LL",sze,timestamp)+data)
#time.sleep(10)
cap.release()
cv2.destroyAllWindows()
print("Main Thread exiting")
heapq.heappush(qu, tup)
print('heappushed {} bytes frame,timestamp:{} recv from {}'.format(
msg_size, timestamp, address))
#time.sleep(10)
def start_thread(sock, address):
t = (
sock,
address,
)
Thread(target=fill_qu, args=t).start()
if __name__ == '__main__':
addresses, file_name = utils.parse_command_line("Multiple sockets client")
socks = []
for address in addresses:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(address)
socks.append(sock)
for sock, address in zip(socks, addresses):
start_thread(sock, address)
time.sleep(60)
passed_time = 0
while True:
import os import utils from sensitive_settings import ACCOUNT_ID # RETRY STRATEGY RETRY_COUNT = 4 RETRY_TIMEOUT = 2 RETRY = True REPEAT_TIMEOUT = 2 RETRY_CODES = [413, 429, 500, 502, 503, 504] # ENDPOINTS API_ENDPOINT = 'https://dev-100-api.huntflow.ru/' FILENAME = 'Тестовая база.xlsx' TOKEN, EXCEL_FOLDER = utils.parse_command_line() EXCEL_FILE = os.path.join(EXCEL_FOLDER, FILENAME)
print('Data received: {!r}'.format(message))
print('Send: {!r}'.format(message))
self.transport.write(data)
print('Close the client socket')
self.transport.close()
def connection_lost(self, exc):
if exc:
print('Client {} error: {}'.format(self.address, exc))
elif self.data:
print('Client {} sent {} but then closed'.format(
self.address, self.data))
else:
print('Client {} closed socket'.format(self.address))
if __name__ == '__main__':
address = utils.parse_command_line('Echo server')
loop = asyncio.get_event_loop()
coro = loop.create_server(Server, *address)
server = loop.run_until_complete(coro)
print('Listening at {}'.format(address))
try:
loop.run_forever()
finally:
server.close()
loop.close()
import numpy as np
import cv2, pickle
import sys, struct
import utils
encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), 90]
if __name__ == '__main__':
address, fileName = utils.parse_command_line('simple server')
print(fileName)
listener = utils.create_srv_socket(address)
#utils.accept_connections_forever(listener)
client_sock, client_address = listener.accept()
print('Accepted connection from {}'.format(client_address))
cap = cv2.VideoCapture(str(fileName))
while (cap.isOpened()):
ret, frame = cap.read()
#gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
if ret:
ret, image = cv2.imencode('.jpg', frame, encode_param)
if (ret == False):
break
#cv2.imshow('frame',frame)
print((sys.getsizeof(image)))
data = pickle.dumps(image)
sze = len(data)
resp = client_sock.sendall(struct.pack(">L", sze) + data)
#if cv2.waitKey(1) & 0xFF == ord('q'):
#break
import torch
import torch.optim as optim
from os import path
import planning
import utils
from dataloader import DataLoader
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
#################################################
# Train a policy / controller
#################################################
opt = utils.parse_command_line()
# Create file_name
opt.model_file = path.join(opt.model_dir, 'policy_networks',
'MPUR-' + opt.policy)
utils.build_model_file_name(opt)
os.system('mkdir -p ' + path.join(opt.model_dir, 'policy_networks'))
random.seed(opt.seed)
numpy.random.seed(opt.seed)
torch.manual_seed(opt.seed)
# Define default device
opt.device = torch.device(
'cuda' if torch.cuda.is_available() and not opt.no_cuda else 'cpu')
import asyncio
class EchoClientProtocol(asyncio.Protocol):
def __init__(self, message, loop):
self.message = message
self.loop = loop
def connection_made(self, transport):
transport.write(self.message.encode())
print('Data sent: {!r}'.format(self.message))
def data_received(self, data):
print('Data received: {!r}'.format(data.decode()))
def connection_lost(self, exc):
print('The server closed the connection')
print('Stop the event loop')
self.loop.stop()
if __name__ == '__main__':
address = utils.parse_command_line('client')
loop = asyncio.get_event_loop()
message = input('Enter your message to server: ')
coro = loop.create_connection(lambda: EchoClientProtocol(message, loop),
address[0], address[1])
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
import utils
import asyncio
class EchoClientProtocol(asyncio.Protocol):
def __init__(self, message, loop):
self.message = message
self.loop = loop
def connection_made(self, transport):
transport.write(self.message.encode())
print('Data sent: {!r}'.format(self.message))
def data_received(self, data):
print('Data received: {!r}'.format(data.decode()))
def connection_lost(self, exc):
print('The server closed the connection')
print('Stop the event loop')
self.loop.stop()
if __name__ == '__main__':
address = utils.parse_command_line('client')
loop = asyncio.get_event_loop()
message = input('Enter your message to server: ')
coro = loop.create_connection(lambda: EchoClientProtocol(message, loop), address[0] , address[1])
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
def data_received(self, data):
message = data.decode()
print('Data received: {!r}'.format(message))
print('Send: {!r}'.format(message))
self.transport.write(data)
print('Close the client socket')
self.transport.close()
def connection_lost(self, exc):
if exc:
print('Client {} error: {}'.format(self.address, exc))
elif self.data:
print('Client {} sent {} but then closed'.format(self.address, self.data))
else:
print('Client {} closed socket'.format(self.address))
if __name__ == '__main__':
address = utils.parse_command_line('Echo server')
loop = asyncio.get_event_loop()
coro = loop.create_server(Server, *address)
server = loop.run_until_complete(coro)
print('Listening at {}'.format(address))
try:
loop.run_forever()
finally:
server.close()
loop.close()
