def update(instance):
print(Window.is_hide)
#self.root.get_root_window().hide()
Window.hide()
#value
Clock.schedule_once(show, 5)
pass
def on_request_close(self, args):
if self.startmodus[:6] == 'hidden':
if self.edit_modus:
w_main.editbtn.state = 'normal'
self.btn_toggle_edit()
Window.hide()
print('[HIDDEN ]')
return True # daemon mode, impossible to close normally
def run(self):
Window.hide()
generate = 1
while generate:
generate = self.task_queue.get()
print("Process - " + str(generate))
time.sleep(1)
self.task_queue.task_done()
self.result_queue.put([generate, generate, generate])
def server(q):
async def get_url(websocket, path):
while True:
url = await websocket.recv()
url = str(url).split('/')
q.put_nowait(url[2])
Window.hide()
start_server = websockets.serve(get_url, '127.0.0.1', 8080)
asyncio.get_event_loop().run_until_complete(start_server)
asyncio.get_event_loop().run_forever()
def do_loop(self, midi_input_queue, input_port_name_queue):
Window.hide()
try:
input_port = None
# if input_port_name:
# print("opening {}".format(input_port_name))
# input_port = mido.open_output('IAC Driver Bus 1', autoreset=True)
last_port_name = None
input_port_name = None
while True:
# new_state = input_queue.get_nowait()
# if new_state:
# player_state = new_state
# print("midi_player state is {} and port {}".format(player_state.value, "what"))
try:
# input_port_name = input_port_name_queue.get(block=True, timeout=3)
input_port_name = input_port_name_queue.get_nowait()
except queue.Empty:
input_port_name = None
pass
if input_port_name:
if input_port_name == '##done##':
return
try:
if not input_port or (
input_port_name
and input_port_name != last_port_name):
print("input_port is {}".format(input_port_name))
print("opening {}".format(input_port_name))
if input_port:
input_port.close()
# input_port = mido.open_input(name=input_port_name,callback=self.midi_message_received)
input_port = mido.open_input(name=input_port_name)
last_port_name = input_port_name
except Exception as e:
print("Couldn't open port {}: {}".format(
input_port_name, str(e)))
midi_input_queue.put_nowait(e)
input_port = None
if input_port:
# TODO: it sucks that there isn't a timeout allowed here!!
msg = input_port.receive(timeout=5)
if msg:
midi_input_queue.put_nowait(msg)
except Exception as ex:
print("MidiPlayer exception {}".format(ex))
def _on_keyboard_down(self, keyboard, keycode, text, modifiers):
print('The key', keycode, 'have been pressed')
print(' - text is %r' % text)
print(' - modifiers are %r' % modifiers)
# Keycode is composed of an integer + a string
# If we hit escape, release the keyboard
if keycode[1] == 'escape':
keyboard.release()
if keycode[1] == 'h':
Window.hide()
if keycode[1] == 'enter':
self.capture()
# Return True to accept the key. Otherwise, it will be used by
# the system.
return True
def main_thread_updates(self, dt):
"""
This method updates some graphic properties of the windows.
I could set this changes using bindings but some windows
properties can only be touched from the main Thread.
All the sensitive updates to be done in the main Thread
are collected within this method
"""
# Replaced with the window_util.move_window method because faster and less cpu consuming
# Window moving logic
# if self.WindowYPosVelocity != 0:
# Window.top += self.WindowYPosVelocity
# if self.WindowXPosVelocity != 0:
# Window.left += self.WindowXPosVelocity
# Window hiding/showing logic
if self.is_in_pause != self.is_hide:
if self.is_in_pause:
Window.hide()
else:
Window.show()
self.is_hide = not self.is_hide
def on_minimize(self, window):
self.window_minimized = True
if self.config.getboolean("Settings",
"minimizetray") and self.tray is not None:
Window.hide()
def hide(self, _ = None, source = None): Window.hide() return True
def show(self): Window.hide() Window.show()
def on_request_close(self, *args):
from kivy.core.window import Window
Window.hide()
#!/usr/bin/env python3
import os
os.environ["KIVY_NO_CONSOLELOG"] = "1"
from kivy.config import Config
Config.set('graphics', 'resizable', '0')
Config.set('graphics', 'width', '400')
Config.set('graphics', 'height', '770')
from kivy.core.window import Window
Window.hide()
from kivy.app import App
from kivy.uix.widget import Widget
from kivy.uix.textinput import TextInput
from kivy.uix.floatlayout import FloatLayout
from kivy.uix.label import Label
from kivy.uix.button import Button
from kivy.uix.image import Image
import commands
import nltk
widget_set = {}
class ProBot(App):
def on_focus(instance, value):
global widget_set
instance.foreground_color = 'white'
instance.text = ""
if not value:
instance.foreground_color = 'gray'
instance.text = "Enter a message..."
def program(q):
Window.hide()
first_window = window_search()
window_start_time = str(datetime.now().time().strftime("%H:%M:%S"))
add_window(first_window, window_start_time, '', '')
sql_insert(first_window)
global window_dict, url_dict, time_to_idle_m, idle_start, browsers
url = 0
while True:
if (not q.empty()) & (first_window != browser_search()) & (
window_search() != "Windows") & (window_search() in browsers):
new_time()
idle(idle_start)
if not first_window.split(' - ')[-1] in browsers:
get_w = window_dict.get(first_window)
if isinstance(get_w, list) & (skip != 1):
update(first_window, get_w[0])
if first_window.split(' - ')[-1] in browsers:
get_w = window_dict.get(url)
if isinstance(get_w, list) & (skip != 1):
update(url, get_w[0])
url = q.get_nowait()
first_window = browser_search()
if check_window(url):
add_window(url,
str(datetime.now().time().strftime("%H:%M:%S")), '',
'')
if (first_window != window_search()) & (
window_search() != "Windows") & (not window_search()
in browsers):
new_time()
idle(idle_start)
if not first_window.split(' - ')[-1] in browsers:
get_w = window_dict.get(first_window)
if isinstance(get_w, list) & (skip != 1):
update(first_window, get_w[0])
if first_window.split(' - ')[-1] in browsers:
get_w = window_dict.get(url)
if isinstance(get_w, list) & (skip != 1):
update(url, get_w[0])
first_window = window_search()
if check_window(first_window):
add_window(first_window,
str(datetime.now().time().strftime("%H:%M:%S")), '',
'')
for m in mas:
state_left = win32api.GetKeyState(m)
if state_left != first[hex(m)][1]:
first[hex(m)][1] = state_left
if state_left < 0:
idle(idle_start)
# file.write("\n" + first[hex(m)][0])
new_time()
min_ = 60 - int(time_to_idle_m)
if min_ <= 1:
idle_time = 0
else:
min_ = 0
idle_time = int(time_to_idle_m)
if ((int(time.strftime("%M")) + min_ - 1) == idle_time) & (
int(time_to_idle_s) == int(time.strftime("%S"))):
idle_start = str(datetime.now().time().strftime("%H:%M:%S"))
get_w = window_dict.get(first_window)
time_now = datetime.now().time().strftime("%H:%M:%S")
time_all = datetime.strptime(time_now,
'%H:%M:%S') - datetime.strptime(
get_w[0], '%H:%M:%S')
add_window(first_window, str(get_w[0]), str(time_all),
str(time_now))
sql_update(first_window, time_all)
sql_insert("IDLE режим")
time_to_idle_m = 0
def run(self):
globalVars.init()
Window.hide()
self.noOfSnakes, self.selectionRate, self.mutationRate, self.noOfNeuron1Layer, self.noOfNeuron2Layer, self.fileName, self.fileDateTime, fieldSize = self.task_queue.get(
)
globalVars.fieldSize = fieldSize
self.task_queue.task_done()
self.result_queue.put(1)
generate = 1
bestSnakes = []
self.bestScore = []
self.bestFitness = []
counterGen = 0
startTime = 0
while generate:
generate = self.task_queue.get()
if counterGen == 0:
generation = Generation(noOfSnakes=self.noOfSnakes * 10,
selectionRate=self.selectionRate / 10,
noNeuron1Layer=self.noOfNeuron1Layer,
noNeuron2Layer=self.noOfNeuron2Layer)
startTime = time.time()
generation.live()
bestSnakes = generation.exportBest()
score, fitness = generation.bestScoreFitness()
noOfInputs, noOfNeuron1Layer, noOfNeuron2Layer = bestSnakes[
0].exportDimBrain()
self.saveDataCsv(noOfInputs=noOfInputs,
noOfNeuron1Layer=noOfNeuron1Layer,
noOfNeuron2Layer=noOfNeuron2Layer)
self.saveWeightsCsv(generation.bestWeights())
actualTime = time.time() - startTime
self.writeDataGraphs(score, counterGen, fitness, actualTime)
self.openGraphs(0)
del generation
else:
generation = Generation(noOfSnakes=self.noOfSnakes,
selectionRate=self.selectionRate,
noNeuron1Layer=self.noOfNeuron1Layer,
noNeuron2Layer=self.noOfNeuron2Layer,
mutationRate=self.mutationRate)
generation.live(parents=bestSnakes)
bestSnakes = generation.exportBest()
score, fitness = generation.bestScoreFitness()
self.saveWeightsCsv(generation.bestWeights())
actualTime = time.time() - startTime
self.writeDataGraphs(score, counterGen, fitness, actualTime)
del generation
self.bestScore.append(score)
self.bestFitness.append(fitness)
counterGen += 1
self.task_queue.task_done()
self.result_queue.put([counterGen, score, fitness])
self.saveBestScoreCsv()
if os.path.exists(self.graphName):
os.remove(self.graphName)
def minimize_screenshot(self, *args):
CoreWindow.hide()
Clock.schedule_once(lambda *args: self.take_whole_screen_screenshot(),
0.1)
Clock.schedule_once(lambda *args: CoreWindow.show(), 0.2)
def do_loop(self, input_queue, midi_metadata_queue, player_state,
output_port_queue):
Window.hide()
try:
output_port = None
# if output_port_name:
# print("opening {}".format(output_port_name))
# output_port = mido.open_output('IAC Driver Bus 1', autoreset=True)
last_port_name = None
output_port_name = None
while player_state.value != PLAYER_STATE_KILLED:
# new_state = input_queue.get_nowait()
# if new_state:
# player_state = new_state
# print("midi_player state is {} and port {}".format(player_state.value, "what"))
if player_state.value == PLAYER_STATE_PLAYING:
try:
output_port_name = output_port_queue.get_nowait()
except queue.Empty:
pass
print("playing bich")
try:
print("output_port is {}".format(output_port_name))
if not output_port or (
output_port_name
and output_port_name != last_port_name):
print("opening {}".format(output_port_name))
if output_port:
output_port.close()
output_port = mido.open_output(
name=output_port_name, autoreset=True)
last_port_name = output_port_name
if output_port:
while True:
if player_state.value == PLAYER_STATE_PAUSED:
sleep(0.1)
continue
elif player_state.value == PLAYER_STATE_STOPPED:
print("emptying and resetting.....")
empty_queue(input_queue)
output_port.reset()
break
elif player_state.value == PLAYER_STATE_KILLED:
return
try:
msg = input_queue.get(True, 1)
if msg.type == 'stop':
midi_metadata_queue.put_nowait(
'##done##')
continue
# print("got mussuj {}".format(msg))
sleep(msg.time)
play_message(msg, midi_metadata_queue,
output_port)
except queue.Empty:
pass
except Exception as e:
print("Couldn't open port {}: {}".format(
output_port_name, str(e)))
sleep(0.1)
except Exception as ex:
print("MidiPlayer exception {}".format(ex))
