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()
