def test_laod_data_read_data(self): client1 = Client(self.host, self.port, timeout=5) client2 = Client(self.host, self.port, timeout=5) try: client1.put("k.1", 0.25, timestamp=1) client2.put("k.1", 2.156, timestamp=2) client1.put("k.1", 0.35, timestamp=3) client2.put("k.2", 30, timestamp=4) client1.put("k.2", 40, timestamp=5) client1.put("k.2", 41, timestamp=5) except Exception as err: self.assertTrue( False, f"Ошибка вызова client.put(...) {err.__class__}: {err}") expected_metrics = { "k.1": [(1, 0.25), (2, 2.156), (3, 0.35)], "k.2": [(4, 30.0), (5, 41.0)], } #import pdb; pdb.set_trace() metrics = client1.get("*") self.assertTrue(metrics == expected_metrics) expected_metrics = {"k.2": [(4, 30.0), (5, 41.0)]} metrics = client2.get("k.2") self.assertTrue(metrics == expected_metrics) expected_metrics = {} metrics = client1.get("k.3") self.assertTrue(metrics == expected_metrics)
def start(): di.get("Logger").info("Starting Client..") client = Client() reporter = Reporter() exm = Exms() threads = [] x = threading.Thread(target=client.loop, args=()) threads.append(x) x2 = threading.Thread(target=reporter.loop, args=()) threads.append(x2) for thread in exm.loop(): t = threading.Thread(target=thread.start, args=()) t.start() threads.append(t) # print(exm.loop()) di.get("Logger").info("Main : before running thread") x.start() x2.start() # x3.start() import time print(threads) while True: time.sleep(1)
def progress(port, mode, record): # print(cap) cameList, number = CameraList( record=record) # set the input, from camera or Video with tf.Graph().as_default(): gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.2) sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options, log_device_placement=False)) with sess.as_default(): detect = FaceDetect(sess) # face detect class classifier = Classifier(sess, mode=mode) # face recognition class if (mode == 2): classifier.train() # if mode is 2, train svm return 0 client = Client(port) # if we need send data by UDP, set it. while True: for cam in cameList: # from camera get frame and progress it in detect and recognition face ret, frame = cam.capFrame() # get face from class camera if not ret: cam.release() frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) # BGR into RGB res = reg_face(frame, detect, classifier, client, cam, mode) # main progress res = cv2.cvtColor(res, cv2.COLOR_RGB2BGR) # RGB into BGR if record: cam.writeFrame(res) cv2.imshow(cam.getLabel(), res) # show result cv2.waitKey(1)
def create_client(self): return Client(self.host, self.port, self.database, self.user, self.password, compression=self.compression)
def __init__(self): # get current day of week name today = datetime.date.today() self.today_name = calendar.day_name[today.weekday()].upper() self.root_path = os.path.dirname( os.path.dirname(os.path.abspath(__file__))) # Make sure '.swell_user_data' directory exists, if not create self.user_directory = str(os.getenv("HOME")) + "/.swell_user_data" try: os.stat(self.user_directory) except: os.mkdir(self.user_directory) # Initialize data sets and swell client self.swellFile = self.user_directory + '/swell.json' self.user_data = self.read_json(self.swellFile) self.init_data = {'favorites': []} self.request_handler = RequestHandler() self.swell = Client(self.request_handler) self.nicknameList = [] self.flags = None self.arg = None self.nickname = None self.args = sys.argv self.args.pop(0) # Remove first arg (script) for simplicity
def start(self): pygame.init() self.running = True self.window_surface = pygame.display.set_mode((WIDTH, HEIGHT)) self.player_group = pygame.sprite.GroupSingle() self.player = Player(self, WIDTH // 2, HEIGHT // 2) self.client = Client(self.player)
def run(self): self.socket.listen(10) while True: handler, addr = self.socket.accept() self.commands.bind(self, Client(handler, addr)) self.commands.verify()
def setUp(self): client = Client("Pingoo", "Stéphane") produit = Produit("AndroidOne", 355) produit2 = Produit("LinuxPhone", 241) self.facture = Facture(client) self.facture.ajouter_ligne_produit(LigneFacture(produit, 2)) self.facture.ajouter_ligne_produit(LigneFacture(produit2, 1))
def test_put_cmd_bad_timestamp(self): key = 'cpu.cpu' bad_stamps = [-100, -1, 0] value = 2 client = Client() for bad_stamp in bad_stamps: with self.assertRaises(ClientError): client.put(key, value, bad_stamp)
def test_put_cmd_bad_key(self): bad_keys = ['cpucpu', 'cpu cpu', 'cpu.cpu.cpu', None, '*'] value = 2 timestamp = 1 client = Client() for bad_key in bad_keys: with self.assertRaises(ClientError): client.put(bad_key, value, timestamp)
def test_get_cmd_good_key(self): keys = ['cpu.usage', 'cpu.temp', 'mem.usage', '*'] client = Client() for key in keys: try: client.get(key) except ClientError: self.assertTrue(False)
async def main(): from dotenv import load_dotenv load_dotenv() from src.client import Client import os for token in os.environ.get('DISCORD_SELFBOT_TOKENS').split(';'): client = Client() client.loop.create_task(client.start(token, bot=False))
def test_put_cmd_bad_value(self): key = 'cpu.cpu' timestamp = 132432 bad_values = ['434', 'fdf', '', None, 2 + 3j] client = Client() for bad_value in bad_values: with self.assertRaises(ClientError): #import pdb; pdb.set_trace() client.put(key, bad_value, timestamp)
def main(stdscr): start_time = time.time() recent_trades = init() client = Client(recent_trades) while True: recent_trades.run_calculations() update_display(stdscr, recent_trades, start_time) time.sleep(1)
def __init__(self): parser = argparse.ArgumentParser() parser.add_argument('--type', '-t', required=True, help='1 and 2 product type are available.', choices=['1', '2']) args = parser.parse_args() self.client = Client(int(args.type))
def arriba(self): """sube el servidor""" while self.aceptarClientes: connection, address = self.server.accept() client = Client(None, connection, address) print('Acaba de conectarse ', address) self.clients.append(client) serverThread = threading.Thread(target = self.receive_message, args=(client,)) serverThread.start()
def makeSudo(request): global users client = Client() api = client.api api.createUser(users[0]['userName'],users[0]['password'],'admin') users[0]['userId'] = api.getUserId(users[0]['userName']) def teardown(): api.deleteUser(users[0]['userId']) request.addfinalizer(teardown) return api
def build(self): Config.set('graphics', 'width', '690') Config.set('graphics', 'height', '340') self.root = T1Root() self.client = Client('*****@*****.**', 'mmw835601') self.root.app = self self.client.app = self return self.root
def test_put_cmd_good_args(self): keys = ['cpu.usage', 'cpu.temp', 'mem.usage'] timestamps = [132432, 4324, 432432432] values = [1, 2, 35, 2.0, -5.0, 1e6, -1e-5, -1e10] client = Client() for key in keys: for value in values: for timestamp in timestamps: try: client.put(key, value, timestamp) except ClientError: self.assertTrue(False)
def test_get_same_key_two_clients(self): client1 = Client(self.host, self.port, timeout=5) client2 = Client(self.host, self.port, timeout=5) command = 'some_key' data_1 = None data_2 = None try: data_1 = client1.get(command) data_2 = client1.get(command) except ClientError: print( 'Сервер вернул ответ на валидный запрос, который клиент определил, ' 'как не корректный.. ') except BaseException as err: self.assertTrue( False, f"Сервер должен поддерживать соединение с клиентом между запросами, " f"повторный запрос к серверу завершился ошибкой: {err.__class__}: {err}" ) self.assertTrue(data_1 == data_2 == {})
def test_exception_on_hello_packet(self): client = Client(self.host, self.port, self.database, 'wrong_user') with self.assertRaises(errors.ServerException) as e: client.execute('SHOW TABLES') client.disconnect() # Simple exception formatting checks exc = e.exception self.assertIn('Code:', str(exc)) self.assertIn('Stack trace:', str(exc))
def test_get_parses_empty_metrics(self): key = '*' client = Client() server_response = 'ok\n\n'.encode() sock_instance = self.MockClass.return_value sock_instance.recv = unittest.mock.Mock(return_value=server_response) metrics_expected = {} #import pdb; pdb.set_trace() metrics_received = client.get(key) self.assertTrue(metrics_expected == metrics_received)
def __init__(self, chat_addr=None, server_port=None): if chat_addr is None and server_port is None: server_port, chat_addr = self.get_port_and_ip() self.buttons = [] self.root = None self.main_frame = None self.messages_box = None self.message_input_box = None self.client = None self.refresher = utils.Daemon(name='refreshing', target=self.refresh, timeout=0.1) self.users_list = None if server_port is None: self.close() return nickname = self.get_nickname() self.client = Client(nickname, chat_addr, server_port)
def test_get_parses_metrics(self): key = '*' client = Client() server_response = 'ok\ncpu.cpu 5 543543\ncpu.usage 3 4354325\n\n'.encode( ) sock_instance = self.MockClass.return_value sock_instance.recv = unittest.mock.Mock(return_value=server_response) metrics_expected = { 'cpu.cpu': [(543543, 5)], 'cpu.usage': [(4354325, 3)] } #import pdb; pdb.set_trace() metrics_received = client.get(key) self.assertTrue(metrics_expected == metrics_received)
def test_get_parses_metrics2(self): key = '*' client = Client() server_response = 'ok\npalm.cpu 10.5 1501864247\neardrum.cpu 15.3 1501864259\npalm.cpu 8.3 1501864340\neardrum.memory 200 1501861111\n\n'.encode( ) sock_instance = self.MockClass.return_value sock_instance.recv = unittest.mock.Mock(return_value=server_response) metrics_expected = { 'palm.cpu': [(1501864247, 10.5), (1501864340, 8.3)], 'eardrum.memory': [(1501861111, 200)], 'eardrum.cpu': [(1501864259, 15.3)] } metrics_received = client.get(key) self.assertTrue(metrics_expected == metrics_received)
def test_get_sends_byte_str_command(self): key = 'cpu.cpu' cmd_bytes = 'get {}\n'.format(key).encode() client = Client() #import pdb; pdb.set_trace() client.get(key) sock_instance = self.MockClass.return_value sock_instance.connect.assert_called() first_call = 0 positional_args = 0 call_args = sock_instance.sendall.call_args_list[first_call][ positional_args] sended_str = call_args[0] self.assertTrue(cmd_bytes == sended_str)
def makeList(request): global listName, listId, todoContents, userId, userName, userPassword client = Client() client.api.createUser(userName, userPassword) userId = client.api.getUserId("travis") client.api.createList("pyTestList", userId) listId = client.api.getListId("pyTestList") client.api.saveListItem(listId, todoContents, 0) def removeList(): #Remove todo first to stop foreign key error client.api.removeListItem(todoId[0][0]) client.api.removeList(listId) client.api.deleteUser(userId) client.api.closeConnection() request.addfinalizer(removeList) return client.api
def test_put_sends_byte_str_command(self): key = 'cpu.cpu' value = 54.0 timestamp = 5435433 cmd_bytes = 'put {} {:} {:d}\n'.format(key, str(value), timestamp).encode() client = Client() #import pdb; pdb.set_trace() client.put(key, value, timestamp) sock_instance = self.MockClass.return_value sock_instance.connect.assert_called() first_call = 0 positional_args = 0 call_args = sock_instance.sendall.call_args_list[first_call][ positional_args] sended_str = call_args[0] #import pdb; pdb.set_trace() self.assertTrue(cmd_bytes == sended_str)
def test_network_error(self): client = Client('bad-address') with self.assertRaises(errors.NetworkError): client.execute('SHOW TABLES')
from src.client import Client from testEnv import SERVER_NAME, SERVER_PORT, BUFFER_SIZE client = Client(SERVER_NAME, SERVER_PORT, BUFFER_SIZE) client.start()