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 __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 __init__(self, root): Client.__init__(self) Frame.__init__(self, root) self.start() self.root = root self.frame = Frame(self.root) self.frame.grid() self.grid() self.host_entry_text = StringVar() self.port_entry_text = StringVar() self.chat_entry_text = StringVar() self.chat_window = Text(self.frame, width=64, height=20, bg='white') self.chat_window.insert(END, '[!] NOT CONNECTED\n') self.chat_window.configure(state=DISABLED) self.build_gui() self.connect_request = Message('CONN', ('string',)) self.chat_message = Message('CHAT', ('string', 'string')) self.name = None @self.message('CHAT') def chat_recv(message, addr): try: _, name, m = self.chat_message.unpack(message) self.print_chat_message(name, m) except Exception as err: print(err)
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_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_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_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 __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 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_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)
class App(): 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 run(self): print(self.client.get_name()) print(self.client.get_content())
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 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 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 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 __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 _fetch_fc_data(cls, fc_id: int, client: Client): """ Class method to fetch FC's data :param fc_id: int of fc_id either known or fetched by FreeCompany._fetch_fc_id :param client: src.client.Client object :return: JSON response returned by making an HTTP request with correct params """ return client.fc_by_id(fc_id=fc_id, fc_members=True)
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 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_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 _fetch_fc_id(cls, identifier: List[str], client: Client) -> int: """ Class method to fetch FC's Lodestone ID :param identifier: a list with [server, FC name] :param client: src.client.Client object :return: Lodestone ID of FC as int """ fc = client.fc_by_name(server=identifier[0], name=identifier[1]) return fc.get("Results")[0].get("ID")
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 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 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 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_build_access_payload(self): expected = { 'grant_type': 'client_credentials', 'client_id': 'test-pub-key', 'client_secret': 'test-priv-key' } self.assertEqual( Client.build_access_payload(self.credentials['PUB_KEY'], self.credentials['PRIV_KEY']), expected)
class Game: def __init__(self, *args, **kwargs): self.running = False self.window_surface = None self.clock = pygame.time.Clock() 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 render(self): pygame.display.set_caption( f"RxGame (FPS: {round(self.clock.get_fps(), 2)})") self.player_group.draw(self.window_surface) for _, (px, py) in self.client.other_players.items(): pygame.draw.rect(self.window_surface, BLUE, (px, py, 32, 32)) def update(self): self.player_group.update() self.client.update() def handle_event(self, event): if event.type == pygame.QUIT: self.running = False def cleanup(self): pygame.quit() def execute(self): self.start() while self.running: for event in pygame.event.get(): self.handle_event(event) self.window_surface.fill(BLACK) self.render() self.update() pygame.display.flip() self.clock.tick(FPS) self.cleanup()
def __init__(self): Client.__init__(self) self.window = pygame.display.set_mode((640, 480)) self.clock = pygame.time.Clock() self.window.fill((255, 255, 255)) self.mouse_pos = None self.client_color = (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255)) self.is_drawing = False self.connect_request = Message('CONN', ('string',)) self.draw_message = Message('DRAW', ('int', 'int', 'int', 'int', 'int')) @self.message('DRAW') def draw_recv(message, addr): _, x, y, c0, c1, c2 = self.draw_message.unpack(message) pygame.draw.circle(self.window, (c0, c1, c2), (x, y), 5) self.set_server_addr(SERVER_ADDR) self.start()
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_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 == {})