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 == {})
