def __init__(self):
super(Calculator, self).__init__()
self.ui = Window()
self.ui.setup_ui(self)
self.text_list = []
self.sign_operation = ''
self.operation = None
self.text = ''
self.ui.zero.clicked.connect(lambda: self.numbers('0'))
self.ui.one.clicked.connect(lambda: self.numbers('1'))
self.ui.two.clicked.connect(lambda: self.numbers('2'))
self.ui.three.clicked.connect(lambda: self.numbers('3'))
self.ui.four.clicked.connect(lambda: self.numbers('4'))
self.ui.five.clicked.connect(lambda: self.numbers('5'))
self.ui.six.clicked.connect(lambda: self.numbers('6'))
self.ui.seven.clicked.connect(lambda: self.numbers('7'))
self.ui.eight.clicked.connect(lambda: self.numbers('8'))
self.ui.nine.clicked.connect(lambda: self.numbers('9'))
self.ui.addition.clicked.connect(lambda: self.addiction())
self.ui.subtraction.clicked.connect(lambda: self.subtraction())
self.ui.multiply.clicked.connect(lambda: self.multiply())
self.ui.division.clicked.connect(lambda: self.division())
self.ui.radical.clicked.connect(lambda: self.radical())
self.ui.power.clicked.connect(lambda: self.power())
self.ui.factorial.clicked.connect(lambda: self.factorial())
self.ui.num_sign.clicked.connect(lambda: self.num_sign())
self.ui.point.clicked.connect(lambda: self.point())
self.ui.delete_last.clicked.connect(lambda: self.delete_last())
self.ui.delete_all.clicked.connect(lambda: self.delete_all())
self.ui.result.clicked.connect(lambda: self.print_result())
def main():
#set the node name
rospy.init_node(NODE.GUI, anonymous=False)
app = QtGui.QApplication(sys.argv) #gui app init
#window object
window = Window(None)
window.show() #Initialize Window, with disabled objects
#init rov object
rov = ROV(window)
#init a thread passing window object as argument
try:
thread.start_new_thread(initAndSend, (window, rov, ))
except:
print("Unable to start the commands thread. Exit")
exit(-1)
#start the gui app
n=app.exec_()
sys.exit(n)
def main():
#send ??? to "active" topics
for i in range(1, 10):
errors_pub.publish("???")
messages_pub.publish("???")
sleep(0.2)
app = QtGui.QApplication(sys.argv) #gui app init
#window object
window = Window(None)
window.show() #Initialize Window, with disabled objects
#Initialize the ROV
rov = ROV(window)
#init a thread passing window and rov as arguments
try:
thread.start_new_thread(initAndSend, (
window,
rov,
))
except:
print("Unable to start the commands thread. Exit")
sys.exit(-1)
#start the gui app
n = app.exec_()
#when it will be closed, kill other processes and exit
os.kill(int(sys.argv[1]), signal.SIGKILL)
os.kill(int(sys.argv[2]), signal.SIGKILL)
sys.exit(n)
def main():
app = QtGui.QApplication(sys.argv) #gui app init
#window object
window = Window(None)
window.show() #Initialize Window, with disabled objects
#Initialize the ROV
rov = ROV(window)
#init a thread passing window and rov as arguments
try:
thread.start_new_thread(initAndSend, (
window,
rov,
))
except:
print("Unable to start the commands thread. Exit")
sys.exit(-1)
#start the gui app
n = app.exec_()
#when it will be closed, kill other processes and exit
os.kill(int(sys.argv[1]), signal.SIGKILL)
os.kill(int(sys.argv[2]), signal.SIGKILL)
sys.exit(n)
def main():
app = QtGui.QApplication(sys.argv) #gui app init
#window object
window = Window(None)
window.show() #Initialize Window, with disabled objects
#init rov object
rov = ROV(window)
#init a thread passing window object as argument
try:
thread.start_new_thread(initAndSend, (
window,
rov,
))
except:
print("Unable to start the commands thread. Exit")
exit(-1)
#start the gui app
n = app.exec_()
#when it's closed, send stop signal to the ROV
rov.sendCommand("SSS")
exit(n)
def __init__(self,
look_ahead=4,
skip_to_page=0,
feats=10,
max_q_sz=100,
base_url="http://www.xvideos.com/c/{0}/anal-12"):
# Let's set this up so gathering new videos can happen in the background.
self.scraped_videos = {}
gather_args = (look_ahead, skip_to_page, feats, max_q_sz)
self.gather_process = Thread(target=self.gather,
args=gather_args,
daemon=True)
self.scr = Scraper(base_url=base_url, pg_n=skip_to_page)
self.db = Database()
self.ai = Brain(self)
self.win = Window(self)
self.currently_loaded_video_data = {}
self.feats = feats
self.q = PriorityQueue(maxsize=max_q_sz)
self.lock = RLock()
if "brain.pkl" in os.listdir():
self.train()
self.get_next()
def main():
game = TicTacToe()
gui = TicTacToeGui(0, 0, 500, 500, game)
win = Window(title="Ultimate Tic Tac Toe",
flags=["SCALED"],
gui_objects=[gui])
win.start()
def main():
# Every Qt application must have one instance of QApplication.
global APP # Use global to prevent crashing on exit
APP = QApplication(sys.argv)
window = Window(0, 0, 0)
window.show()
# Start the Qt event loop. (i.e. make it possible to interact with the gui)
sys.exit(APP.exec_())
def __init__(self):
self.resource_spawn_rate = BASE_CHANCE//20
self.num_species = 2
self.num_members = 3
self.num_resources = 15
self.user_skill = 0
self.user_speed = 0
self.user_strength = 0
self.user_params()
self.map_obj = Map(width=self.width,height=self.height)
self.pos_set = set([(i,j)
for i in range(self.height) for j in range(self.width)])
self.win = Window()
self.init_map();
def main():
# Initializes pygame, window
pygame.init()
window = pygame.display.set_mode(
(globals.SCREEN_WIDTH, globals.SCREEN_HEIGHT))
input_params = Inputs()
clock = pygame.time.Clock()
app = QApplication(sys.argv)
param_win = Window()
param_win.show()
# Polygon to be controlled by arrows
polygon = Polygon(np.array([800, 500]), 30, 3, 10, (255, 255, 255))
space = Space(polygon)
while globals.RUN:
# Drawing shapes
space.draw(window)
# Adding force to main polygon
if input_params.is_left():
polygon.add_force(np.array([-globals.KEY_FORCE, 0.]))
elif input_params.is_right():
polygon.add_force(np.array([globals.KEY_FORCE, 0.]))
if input_params.is_up():
polygon.add_force(np.array([0., -globals.KEY_FORCE]))
elif input_params.is_down():
polygon.add_force(np.array([0., globals.KEY_FORCE]))
# Add shape on left click
if input_params.mouse_left_click():
space.add_shape(globals.NEW_SHAPE_TYPE, input_params.mouse_pos,
globals.NEW_SHAPE_RADIUS, globals.NEW_SHAPE_MASS,
globals.NEW_SHAPE_DEGREE)
# Remove shape on right click
if input_params.mouse_right_click():
space.remove_shape(input_params.mouse_pos)
if input_params.is_clear():
space.shapes = []
clock.tick(globals.FPS)
elapsed_time = clock.get_time()
# Update shapes in space class for movement, rotarion...
space.update(window, elapsed_time)
# Check for mouse of keyboard click
input_params.update()
pygame.display.update()
pygame.display.set_caption(str(clock.get_fps()))
sys.exit(app.exec_())
def wydrukuj(self):
poz_lista = [
'Wykaz narzędzi ' + self.pozycja,
"SELECT * FROM '" + self.pozycja + "'",
'Baza nie zawiera żadnych pozycji. Plik nie zostanie zapisany.',
]
from gui import Window
if self.pozycja != 'Brak':
Window.export(self, poz_lista)
self.parent.statusBar().showMessage("Wyeksportowano do pliku",
10000)
else:
QMessageBox.critical(self, 'Wybierz pozycję',
'Nie wybrano żadnej pozycji!', QMessageBox.Ok,
QMessageBox.Ok)
def __init__(self):
# GUI basic setup stuff
super().__init__()
self.ui = Window()
self.ui.setupUi(self)
self.show()
# Multithreading setup
self.threadpool = QThreadPool()
self.threadpool.setMaxThreadCount(int(self.threadpool.maxThreadCount()*0.75))
print("Multithreading with maximum %d threads" % int(self.threadpool.maxThreadCount()*0.75))
# Set up directory structure
self.directories = [
[self.ui.g_f_gps, "gps"],
[self.ui.g_f_lms_front, "lms_front"],
[self.ui.g_f_models, "Models"],
[self.ui.g_f_stereo, "stereo"],
[self.ui.g_f_left, "stereo/left"],
[self.ui.g_f_centre, "stereo/centre"],
[self.ui.g_f_right, "stereo/right"],
[self.ui.g_f_lmsTime, "lms_front.timestamps"],
[self.ui.g_f_stereoTime, "stereo.timestamps"]
]
# GUI connections
self.ui.browseButton.clicked.connect(self.browse_folder)
self.ui.folderLine.returnPressed.connect(self.manual_line_change)
def main():
try:
import mrx
except ImportError:
print(
"Failed to load Mr. X AI. Make sure it is in this directory and named 'mrx.py'"
)
exit(1)
try:
import detectives
except ImportError:
print(
"Failed to load the detective AI. Make sure it is in this directory and named 'detectives.py'"
)
exit(1)
the_game = Game(mrx, detectives)
win = Window(the_game)
win.mainloop()
def main():
"""Main function"""
# Extract arguments or get random SMILES
smiles = None
informalName = None
ex = get_example(None if len(sys.argv) < 2 else sys.argv[1])
if not ex:
smiles = sys.argv[1]
print "\n>>> Using input `%s` as SMILES.\n" % smiles
else:
informalName = ex[1]
smiles = ex[2]
print "\n>>> Using %s per argument.\n" % informalName
# Init GUI.
win = Window('Chemical Structure Diagram Generation (WIP)')
# Set globals.
Globals.drawable = win.drawable
Globals.debugText = win.debugText
Globals.window = win
Globals.ringGroups = None
Globals.molecule = None
# Set callbacks.
win.drawCallback = gui_draw_callback
win.smilesCallback = gui_smiles_text_callback
# Process initial data.
parse_smiles_text(smiles, informalName)
try:
# Run GUI.
win.run()
except KeyboardInterrupt:
print ""
def run(self):
window = Window(theme="black")
window.init(self.container, self._chatReceiver.updateCoords, self.pause, self.refreshing, self._speaker)
screen_reader_thread = Thread(target=self.run_loop, args=(window.refresh,), daemon=True)
voice_thread = Thread(target=self._speaker.loop, daemon=True)
voice_thread.start()
screen_reader_thread.start()
window.mainloop()
self.terminate.set()
screen_reader_thread.join()
self.container.saveConfig()
def robot():
'''
# 简单机器人实现
'''
qq = SmartQQ()
w = Window(qq)
qq.login() # 登录验证
slf = qq.get_self_info() # 获取个人信息，主要是获取gid,发送信息会用到。
friends = qq.get_friends_info() # 获取好友列表
groups = qq.get_group_list() # 获取群列表
onli = qq.get_online_buddies2() # 获取在线好友
rev = qq.get_recent_list2() # 获取最近列表
img = qq.get_self_img() # 获取个人头像
w.show_self_info(img=img, data=slf) # 显示个人信息
gui.groups = groups
gui.friends = friends
# 循环主题
def recv_func():
while 1:
get_msg = qq.get_chat_msg()
print("get_msg %s" % get_msg)
if get_msg != None:
send_msg = "我不明白你的意思."
if get_msg["poll_type"] == "group_message":
w.group_msg_handle(get_msg["from_uin"], get_msg["send_uin"], get_msg["content"])
if get_msg["content"].find("@"+qq.qqname) >= 0 and gui.auto_send_name['group'] != None and \
get_msg["from_uin"] == groups[gui.auto_send_name['group']]['gid']:
if get_msg["content"].find("自动回复") >= 0:
send_msg = messge_text.messge_re[random.randint(0, 53)]
qq.send_qun_msg(groups[gui.auto_send_name['group']]['gid'], send_msg)
print("机器人回复 : %s" % send_msg)
if get_msg["poll_type"] == "message" :
w.friend_msg_handle(get_msg["from_uin"], get_msg["content"])
if gui.auto_send_name['friend'] != None and get_msg["from_uin"] == friends[gui.auto_send_name['friend']]['uin']:
if get_msg["content"].find("自动回复") >= 0:
send_msg = messge_text.messge_re[random.randint(0, 53)]
qq.send_buddy_msg(friends[gui.auto_send_name['friend']]['uin'], send_msg)
print("机器人回复 : %s" % send_msg)
w.friend_msg_handle(get_msg["from_uin"], send_msg,True)
time.sleep(1)
t = threading.Thread(target=recv_func)
t.start()
w.run()
def __init__(self, look_ahead=4, skip_to_page=0, feats=10, max_q_sz=100,
base_url="http://www.xvideos.com/c/{0}/anal-12"):
# Let's set this up so gathering new videos can happen in the background.
self.scraped_videos = {}
gather_args = (look_ahead, skip_to_page, feats, max_q_sz)
self.gather_process = Thread(target = self.gather,
args = gather_args,
daemon = True)
self.scr = Scraper(base_url=base_url, pg_n=skip_to_page)
self.db = Database()
self.ai = Brain(self)
self.win = Window(self)
self.currently_loaded_video_data = {}
self.feats = feats
self.q = PriorityQueue(maxsize=max_q_sz)
self.lock = RLock()
if "brain.pkl" in os.listdir():
self.train()
self.get_next()
def main():
"""Main function"""
# Extract arguments or get random SMILES
smiles = None
informalName = None
ex = get_example(None if len(sys.argv) < 2 else sys.argv[1])
if not ex:
smiles = sys.argv[1]
print "\n>>> Using input `%s` as SMILES.\n" % smiles
else:
informalName = ex[1]
smiles = ex[2]
print "\n>>> Using %s per argument.\n" % informalName
# Init GUI.
win = Window('Chemical Structure Diagram Generation (WIP)')
# Set globals.
Globals.drawable = win.drawable
Globals.debugText = win.debugText
Globals.window = win
Globals.ringGroups = None
Globals.molecule = None
# Set callbacks.
win.drawCallback = gui_draw_callback
win.smilesCallback = gui_smiles_text_callback
# Process initial data.
parse_smiles_text(smiles, informalName)
try:
# Run GUI.
win.run()
except KeyboardInterrupt:
print ""
#!/usr/bin/env python3
from chess import Chessboard
from gui import Window
from gl_data import geometries
from PyQt4.QtGui import QApplication
import sys
if __name__ == "__main__":
board = Chessboard()
app = QApplication(sys.argv)
window = Window(geometries, board)
window.show()
sys.exit(app.exec_())
from gui import Window from PyQt4 import QtGui import sys app = QtGui.QApplication(sys.argv) #initialize the main window window = Window(app) Window.w = window #make sure wait message is set before connecting procedure starts app.processEvents() #because initializing client will take some time window.initClient(True) sys.exit(app.exec_())
parser.add_argument('--version', '-v', action='version',
version='%(prog)s ' + prog_version)
options = Options(parser.parse_args())
if options.debug_mode:
print('debug mode =', options.debug_mode)
print('one_running =', options.one_running)
print('elapsed_time =', options.elapsed_time)
print('pictures =', options.pictures)
app = QtGui.QApplication(sys.argv)
if not QtGui.QSystemTrayIcon.isSystemTrayAvailable():
QtGui.QMessageBox.critical(None, "lkwpchanger",
"The application couldn't start.")
sys.exit(1)
QtGui.QApplication.setQuitOnLastWindowClosed(False)
pictures = Pictures(options)
window = Window(pictures)
timer = TimerThread(args=(window))
if options.one_running:
window.change_background()
else:
timer.start()
sys.exit(app.exec_())
from gui import Window
from game import Game
if __name__ == "__main__":
game = Game()
window = Window(game)
window.start()
import sys
from PySide2.QtWidgets import QApplication
from PySide2.QtCore import QTranslator, QLocale, QLibraryInfo
from gui import Window
if __name__ == '__main__':
app = QApplication(sys.argv)
traductor = QTranslator()
traductor.load("qtbase_" + QLocale.system().name(),
QLibraryInfo.location(QLibraryInfo.TranslationsPath))
app.installTranslator(traductor)
win = Window()
win.parent = app
win.show()
sys.exit(app.exec_())
parser.add_option(
'--random',
metavar='NUMBER',
type=int,
help='Make it so you answer a question incorrectly every X questions.',
default=0)
(options, args) = parser.parse_args()
if __name__ == '__main__':
try:
from gui import Window
app = QApplication(sys.argv)
win = Window(show_stats=not options.no_stats, close=options.close)
if not options.gui_frameless:
win.show()
if options.username != '':
win.ui.emailTassomai.setText(options.username)
if options.password != '':
win.ui.passwordTassomai.setText(options.password)
if options.delay != 'none':
win.ui.delay.setChecked(True)
if options.delay in ['quiz', 'question']:
win.ui.whenDelay.setCurrentText(options.delay)
if options.delay_amount != "0":
if ',' in options.delay_amount:
try:
v1, v2 = tuple(
def main():
app = QApplication([])
win = Window()
win.show()
sys.exit(app.exec())
state = State(psi * target_norm / np.linalg.norm(psi)).to_basis(energy)
def evolve(time):
"""Evolve the current state forward in time by given duration."""
state_multiplier = np.exp((-1j / h_bar * time) * energy.eigenvalues)
state.vector *= state_multiplier
# Graphics
plot = Plot(state,
basis=position,
potential=potential,
potential_scale=potential_scale)
main_window = Window('Quantum Simulation')
main_window.add_widget(plot)
main_window.add_widget(simulation_speed)
main_window.add_widget(potential_scale)
measurement_panel = QWidget()
measurement_layout = QHBoxLayout(measurement_panel)
measurement_layout.addWidget(ObservableWidget(position, state, plot))
measurement_layout.addWidget(ObservableWidget(momentum, state, plot))
measurement_layout.addWidget(ObservableWidget(energy, state, plot))
main_window.add_widget(measurement_panel)
# Animation
def update_animation():
create_graph(hexyne)
create_graph(isohex)
surface = ImageSurface(FORMAT_ARGB32, 500, 500)
ctx = Context(surface)
# Background
height = 500
pat = SolidPattern(1.0, 1.0, 1.0, 0.9)
ctx.rectangle (0,0, 500, 500)
ctx.set_source (pat)
ctx.fill ()
"""
win = Window("Testing")
win.setText(hexane)
win.run()
def draw_line(x1, y1, x2, y2):
ctx.new_path()
ctx.set_source_rgb(0.0, 0.0, 0.0)
ctx.move_to(x1, y1)
ctx.line_to(x2, y2)
ctx.close_path()
ctx.stroke()
class Mediator:
"""Handles communication between objects."""
def __init__(self, look_ahead=4, skip_to_page=0, feats=10, max_q_sz=100,
base_url="http://www.xvideos.com/c/{0}/anal-12"):
# Let's set this up so gathering new videos can happen in the background.
self.scraped_videos = {}
gather_args = (look_ahead, skip_to_page, feats, max_q_sz)
self.gather_process = Thread(target = self.gather,
args = gather_args,
daemon = True)
self.scr = Scraper(base_url=base_url, pg_n=skip_to_page)
self.db = Database()
self.ai = Brain(self)
self.win = Window(self)
self.currently_loaded_video_data = {}
self.feats = feats
self.q = PriorityQueue(maxsize=max_q_sz)
self.lock = RLock()
if "brain.pkl" in os.listdir():
self.train()
self.get_next()
def start_gathering(self):
self.gather_process.start()
def get_next(self):
"""Determine which video should be selected, then update window."""
# Get the video likely to have the best rating
if self.q.qsize():
self.lock.acquire()
to_show_url = self.q.get()
self.lock.release()
scraped_data, preview_pic_url, guessed_rating = self.scraped_videos[to_show_url]
self.currently_loaded_video_data = scraped_data
pic1, pic2, pic3 = self.scr.load_pics(preview_pic_url)
self.win.update_images(pic1, pic2, pic3)
url = scraped_data["url"]
print("\n")
print("\ttitle:\t", scraped_data["title"])
print("\tlength:\t", scraped_data["duration"])
print("\tguessed rating:\t", guessed_rating)
print("\ttags:\t", " ".join(scraped_data["tags"]))
print()
else:
print("Error: still gathering videos.")
def gather(self, look_ahead, skip_to_page, feats, max_q_sz):
""" Add videos to the priority queue independently
of rating and loading videos. """
while True:
if self.q.qsize() < max_q_sz:
for i in range(look_ahead):
self.scr.next()
if self.db.has_video(self.scr.cur_vid):
# make sure we only work on unrated videos
print(".", end="")
continue
scraped_data = self.scr.scrape_video()
pred_rating = self.ai.predict(scraped_data)
self.scraped_videos[self.scr.cur_vid] = (scraped_data,
self.scr.cur_pic,
pred_rating)
self.lock.acquire()
self.q.put(self.scr.cur_vid, -pred_rating)
self.lock.release()
print(":", end="")
def save(self, rating):
"""Save the data scraped from the current video then get next video."""
self.currently_loaded_video_data["loved"] = rating
sys.stdout.flush()
self.db.save(self.currently_loaded_video_data)
self.get_next()
def open_vid(self):
webbrowser.open(self.scr.cur_vid)
def train(self):
tags, ratings, tag_to_vec = self.db.vectorize_tags(self.feats)
self.ai.train(tags, ratings, tag_to_vec)
def close_db(self):
"""When a window closes, disconnect from a database."""
self.db.cnx.close()
def submit():
payload['end'] = datetime.now(tz=timezone.utc).isoformat().replace(
"+00:00", "Z")
payload['description'] = ticket.get()
time_entry_endpoint = endpoint_config.default_endpoint + f"workspaces/{workspaceId}/time-entries"
requests.post(time_entry_endpoint,
headers=endpoint_config.header,
json=payload)
clear_data()
toggle_client_selection_on()
button_frame.lift()
main_window = Window(f'{user.name} Ticket Tracker', '750x425')
main_frame = WindowFrame(main_window, borderwidth=5)
main_frame.grid(row=0, rowspan=3, column=0, columnspan=3)
button_frame = ButtonFrame(main_frame, borderwidth=5, relief="sunken")
button_frame.grid(row=0, column=0, padx=10, pady=10, sticky=tk.NSEW)
client_frame = ProjectButtons(button_frame, borderwidth=5)
client_frame.grid(row=0, column=0, sticky=tk.NSEW)
client_buttons = [
ttk.Button(client_frame,
text=client,
command=lambda client=client: select_client(client))
for client in clients.clients
class MediaPlayer:
def __init__(self):
self.DefineFunctionArgList()
self.service = pydbus.SystemBus().get('org.bluez', '/')
self.Update_obj_list()
self.player_connected = False
self.TerminateFlag = False
self.obj_list_updater_thread = Thread(target=self.ObjListUpdater)
self.track_info_updater_thread = Thread(target=self.TrackInfoUpdater)
self.obj_list_updater_thread.start()
self.track_info_updater_thread.start()
self.Start()
def ObjListUpdater(self):
self.system_bus = pydbus.SystemBus()
self.system_bus.subscribe(sender='org.bluez',
signal='PropertiesChanged',
signal_fired=self.Update_obj_list)
loop = MainLoop()
timeout_add(100, self.checkTerminate, loop)
loop.run()
def Update_obj_list(self, *args):
self.obj_list = self.service.GetManagedObjects()
def TrackInfoUpdater(self):
while self.TerminateFlag is False:
try:
self.track_info = self.media_player.Get(
'org.bluez.MediaPlayer1', 'Track')
self.track_info['Position'] = self.media_player.Get(
'org.bluez.MediaPlayer1', 'Position')
self.track_info['Status'] = self.media_player.Get(
'org.bluez.MediaPlayer1', 'Status')
except:
self.track_info = {
'Title': '',
'Album': '',
'Artist': '',
'Genre': '',
'Duration': 0,
'Position': 0,
'Status': 'stopped'
}
sleep(0.2)
def GetTrackInfo(self):
return self.track_info
def Start(self):
self.ConnectMediaPlayer()
def ConnectMediaPlayer(self):
while self.player_connected is not True:
for obj_path in self.obj_list.keys():
if "player" in obj_path:
self.player_path = obj_path
self.device_path = self.obj_list[
self.player_path]['org.bluez.MediaPlayer1']['Device']
self.device_name = self.obj_list[
self.device_path]['org.bluez.Device1']['Alias']
self.player_connected = self.obj_list[self.device_path][
'org.bluez.MediaControl1']['Connected']
break
sleep(0.2)
self.media_player = pydbus.SystemBus().get('org.bluez',
self.player_path)
self.CreateWindow()
def CheckConnection(self):
if self.player_path not in self.obj_list and \
self.obj_list[self.device_path]['org.bluez.MediaControl1']['Connected'] is False:
self.player_connected = False
self.root.destroy()
self.Start()
def isPlayerConnected(self):
return self.player_connected
def Play(self):
self.media_player.Play()
def Pause(self):
self.media_player.Pause()
def Next(self):
self.media_player.Next()
def Previous(self):
self.media_player.Previous()
def Terminate(self):
self.TerminateFlag = True
def checkTerminate(self, loop):
if self.TerminateFlag is True:
loop.quit()
else:
timeout_add(100, self.checkTerminate, loop)
def DefineFunctionArgList(self):
self.func_list = {
'Terminate': self.Terminate,
'Play': self.Play,
'Pause': self.Pause,
'Next': self.Next,
'Previous': self.Previous,
'isPlayerConnected': self.isPlayerConnected,
'CheckConnection': self.CheckConnection,
'GetTrackInfo': self.GetTrackInfo
}
def CreateWindow(self):
self.root = Window(self.func_list)
self.root.run()
def graphical_version(flac_file, output):
app = QApplication(sys.argv)
window = Window(flac_file, output)
sys.exit(app.exec_())
class Simulator:
def __init__(self):
self.resource_spawn_rate = BASE_CHANCE//20
self.num_species = 2
self.num_members = 3
self.num_resources = 15
self.user_skill = 0
self.user_speed = 0
self.user_strength = 0
self.user_params()
self.map_obj = Map(width=self.width,height=self.height)
self.pos_set = set([(i,j)
for i in range(self.height) for j in range(self.width)])
self.win = Window()
self.init_map();
def create_species(self):
'''Takes in user specifications for strength/speed of species
they are rooting for on the board'''
print("You will be species 0.")
self.user_speed = float(input("Enter speed of your species (0-3): ")
or uniform(0,3))
self.user_strength = float(input(
"Enter strength of your species (0-10): ")
or uniform(0,10))
def user_params(self):
'''Initializes simulation data with user preferences.'''
self.num_species = int(input(
"Enter number of species on board (Default: 3): ")
or 3)
self.num_members = int(input(
"Enter number of members per species (Default: 2): ")
or 2)
self.num_resources = int(input(
"Enter number of resources on the board (Default: 15) : ")
or 15)
if input("Would you like to create a species? ") == 'Y':
self.create_species()
else:
self.user_speed = uniform(0,3)
self.user_strength = uniform(0,10)
dimension = int(math.ceil(math.sqrt(
self.num_resources + self.num_species
* self.num_members * 1.5)))
self.width = 0
self.height = 0
print(f"Minimum Number of Spaces: {dimension**2}")
while(self.width*self.height < dimension**2):
self.width = int(input("Enter width of the board") or dimension)
self.height = int(input("Enter height of the board") or dimension)
if self.width*self.height < dimension**2:
print("Not enough space on board for specified items!")
def init_map(self):
'''Creates members of each species, with
random attributes characteristic to each species.
Places members and resources on the map.'''
for i in range(self.num_members):
#Creates members of species user is rooting for.
skill= Skill(strength=self.user_strength, speed=self.user_speed)
m = Member(
draw_fn=self.draw,
map_obj=self.map_obj,
skill=skill,
species_id=0,
reproduction_chance=BASE_CHANCE//10)
pos = choice(list(self.pos_set))
self.pos_set.remove(pos)
self.map_obj.add(m, pos)
for i in range(1, self.num_species):
for j in range(self.num_members):
skill=Skill(strength=uniform(0,10), speed=uniform(0,3))
m = Member(
draw_fn=self.draw,
map_obj=self.map_obj,
skill=skill,
species_id=i,
reproduction_chance=BASE_CHANCE//10)
pos = choice(list(self.pos_set))
self.pos_set.remove(pos)
self.map_obj.add(m, pos)
for _ in range(self.num_resources):
r = Resource(
strength=1+random.random(),
speed=1+random.random())
#Add extra types of skills to the resource at random
if random.random() > 0.75:
r.add_to_bag()
pos = choice(list(self.pos_set))
self.pos_set.remove(pos)
self.map_obj.add(r, pos)
def members(self):
return [self.map_obj.at(pos) for pos in self.map_obj.members.values()]
def _random_resource_inclusion_thread(self):
'''Adds resources with random attributes to the board at a rate
determined by the resource spawn rate and simulation speed'''
while True:
with self.map_obj.lock:
if self.map_obj.is_game_over:
break
r = Resource(
strength=1+random.random(),
speed=1+random.random())
if random.random() > 0.75:
r.add_to_bag()
pos = choice(list(self.map_obj.empty_pos))
self.map_obj.add(r, pos)
sleep(uniform(
0, BASE_CHANCE/self.resource_spawn_rate)/SIM_SPEED_MULT)
def _ctrlc_handler(self, signal_received, frame):
'''Allows simulation to quit cleanly if interrupted before it ends'''
with self.map_obj.lock:
self.map_obj.game_over = True
def print_end_state(self):
'''Prints the winning species/ result of the simulation.
The simulation is over if there are 1 or 0 species left on the board.'''
counts = list(self.map_obj.species_counts.items())
if len(counts) == 1:
print(f'Species {counts[0][0]} wins!')
elif len(counts) == 0:
print(f'All species dead.')
def draw(self):
'''renders map object for GUI.'''
self.win.draw(self.map_obj)
def start(self):
'''Starts threads for members, and resource inclusion thread. Renders
GUI until the simulation is over.'''
self.win.start()
signal(SIGINT, self._ctrlc_handler)
for m in self.members():
m._thread.start()
Thread(target=self._random_resource_inclusion_thread).start()
while True:
with self.map_obj.lock:
if self.map_obj.is_game_over:
break
self.draw()
sleep(.2)
self.win.stop()
self.print_end_state()
#!/usr/bin/python
import sys
from PyQt5.QtWidgets import QApplication
from gui import Window
if __name__ == "__main__":
app = QApplication(sys.argv)
win = Window()
w, h = 480, 640
win.setMinimumSize(w, h)
win.show()
sys.exit(app.exec_())
class Mediator:
"""Handles communication between objects."""
def __init__(self,
look_ahead=4,
skip_to_page=0,
feats=10,
max_q_sz=100,
base_url="http://www.xvideos.com/c/{0}/anal-12"):
# Let's set this up so gathering new videos can happen in the background.
self.scraped_videos = {}
gather_args = (look_ahead, skip_to_page, feats, max_q_sz)
self.gather_process = Thread(target=self.gather,
args=gather_args,
daemon=True)
self.scr = Scraper(base_url=base_url, pg_n=skip_to_page)
self.db = Database()
self.ai = Brain(self)
self.win = Window(self)
self.currently_loaded_video_data = {}
self.feats = feats
self.q = PriorityQueue(maxsize=max_q_sz)
self.lock = RLock()
if "brain.pkl" in os.listdir():
self.train()
self.get_next()
def start_gathering(self):
self.gather_process.start()
def get_next(self):
"""Determine which video should be selected, then update window."""
# Get the video likely to have the best rating
if self.q.qsize():
self.lock.acquire()
to_show_url = self.q.get()
self.lock.release()
scraped_data, preview_pic_url, guessed_rating = self.scraped_videos[
to_show_url]
self.currently_loaded_video_data = scraped_data
pic1, pic2, pic3 = self.scr.load_pics(preview_pic_url)
self.win.update_images(pic1, pic2, pic3)
url = scraped_data["url"]
print("\n")
print("\ttitle:\t", scraped_data["title"])
print("\tlength:\t", scraped_data["duration"])
print("\tguessed rating:\t", guessed_rating)
print("\ttags:\t", " ".join(scraped_data["tags"]))
print()
else:
print("Error: still gathering videos.")
def gather(self, look_ahead, skip_to_page, feats, max_q_sz):
""" Add videos to the priority queue independently
of rating and loading videos. """
while True:
if self.q.qsize() < max_q_sz:
for i in range(look_ahead):
self.scr.next()
if self.db.has_video(self.scr.cur_vid):
# make sure we only work on unrated videos
print(".", end="")
continue
scraped_data = self.scr.scrape_video()
pred_rating = self.ai.predict(scraped_data)
self.scraped_videos[self.scr.cur_vid] = (scraped_data,
self.scr.cur_pic,
pred_rating)
self.lock.acquire()
self.q.put(self.scr.cur_vid, -pred_rating)
self.lock.release()
print(":", end="")
def save(self, rating):
"""Save the data scraped from the current video then get next video."""
self.currently_loaded_video_data["loved"] = rating
sys.stdout.flush()
self.db.save(self.currently_loaded_video_data)
self.get_next()
def open_vid(self):
webbrowser.open(self.scr.cur_vid)
def train(self):
tags, ratings, tag_to_vec = self.db.vectorize_tags(self.feats)
self.ai.train(tags, ratings, tag_to_vec)
def close_db(self):
"""When a window closes, disconnect from a database."""
self.db.cnx.close()
data = s.recv(32768)
if len(data) > 0:
client_socket.send(data)
else:
break
s.close()
except socket.error as sock_err:
print(os.strerror(sock_err.errno))
print("Connection refused!")
if s is not None:
s.close()
def _is_filtered(self, webserver):
for cat in self.webservers_categories:
if cat[1]:
for f_ws in cat[2]:
if f_ws == webserver[-len(f_ws):]:
return True
return False
def on_exit(self):
if self.serverSocket is not None:
self.serverSocket.close()
if __name__ == '__main__':
proxy = Proxy()
proxy.wait_clients()
window = Window(proxy)
window.show()
def CreateWindow(self):
self.root = Window(self.func_list)
self.root.run()
