def __init__(self):
QFrame.__init__(self)
SingleLinkableSetting.__init__(self, "api_key")
self.library = Library(get_setting("cache_dir"))
self.loadables_combobox = QComboBox(self)
self.loadables_combobox.setInsertPolicy(QComboBox.NoInsert)
for loadable in MainTab.LOADABLES_COMBOBOX_REGISTRY:
self.loadables_combobox.addItem(loadable, loadable)
self.loadables_combobox.activated.connect(self.add_loadable)
self.checks_combobox = QComboBox(self)
self.checks_combobox.setInsertPolicy(QComboBox.NoInsert)
for check in MainTab.CHECKS_COMBOBOX_REGISTRY:
self.checks_combobox.addItem(check, check)
self.checks_combobox.activated.connect(self.add_check)
self.loadables_scrollarea = QScrollArea(self)
self.loadables_scrollarea.setWidget(ScrollableLoadablesWidget())
self.loadables_scrollarea.setWidgetResizable(True)
self.checks_scrollarea = QScrollArea(self)
self.checks_scrollarea.setWidget(ScrollableChecksWidget())
self.checks_scrollarea.setWidgetResizable(True)
self.loadables = [] # for deleting later
self.checks = [] # for deleting later
self.print_results_signal.connect(self.print_results)
self.write_to_terminal_signal.connect(self.write)
self.q = Queue()
self.cg_q = Queue()
self.helper_thread_running = False
self.runs = [] # Run objects for canceling runs
self.run_id = 0
self.visualizer = None
terminal = QTextEdit(self)
terminal.setFocusPolicy(Qt.ClickFocus)
terminal.setReadOnly(True)
terminal.ensureCursorVisible()
self.terminal = terminal
self.run_button = QPushButton()
self.run_button.setText("Run")
self.run_button.clicked.connect(self.add_circleguard_run)
# disable button if no api_key is stored
self.on_setting_changed("api_key", get_setting("api_key"))
layout = QGridLayout()
layout.addWidget(self.loadables_combobox, 0, 0, 1, 4)
layout.addWidget(self.checks_combobox, 0, 8, 1, 4)
layout.addWidget(self.loadables_scrollarea, 1, 0, 4, 8)
layout.addWidget(self.checks_scrollarea, 1, 8, 4, 8)
layout.addWidget(self.terminal, 5, 0, 2, 16)
layout.addWidget(self.run_button, 7, 0, 1, 16)
self.setLayout(layout)
def logout(session_id):
url = settings.get_setting('BASE_URL') \
+ settings.get_setting('LOGOUT_URL')
try:
requestOp(op="post", url=url, headers=get_session_hdr(session_id))
except:
return
def __init__(self):
super().__init__()
self.result_frame = ResultsTab()
self.result_frame.results.info_label.hide()
self.map_id = None
self.q = Queue()
self.replays = []
cache_path = get_setting("cache_dir") + "circleguard.db"
self.cg = Circleguard(get_setting("api_key"), cache_path)
self.info = QLabel(self)
self.info.setText(
"Visualizes Replays. Has theoretically support for an arbitrary amount of replays."
)
self.label_map_id = QLabel(self)
self.update_map_id_label()
self.file_chooser = FolderChooser("Add Replays",
folder_mode=False,
multiple_files=True,
file_ending="osu! Replayfile (*osr)",
display_path=False)
self.file_chooser.path_signal.connect(self.add_files)
self.folder_chooser = FolderChooser("Add Folder", display_path=False)
self.folder_chooser.path_signal.connect(self.add_folder)
layout = QGridLayout()
layout.addWidget(self.info)
layout.addWidget(self.file_chooser)
layout.addWidget(self.folder_chooser)
layout.addWidget(self.label_map_id)
layout.addWidget(self.result_frame)
self.setLayout(layout)
def __init__(self, beatmap_info, replays=[], events=[], library=None):
speeds = get_setting("speed_options")
start_speed = get_setting("default_speed")
paint_info = get_setting("visualizer_info")
super().__init__(beatmap_info, replays, events, library, speeds,
start_speed, paint_info)
self.setWindowIcon(QIcon(resource_path("logo/logo.ico")))
def __init__(self):
super().__init__()
self.setupUi(self)
# INIT WIDGET
self.doubleSpinBoxFreq.setValue(
float(settings.get_setting(path_settings, 'Settings', 'freq')))
self.doubleSpinBoxPow.setValue(
float(settings.get_setting(path_settings, 'Settings', 'power')))
self.lineEditRds.setText(
settings.get_setting(path_settings, 'Settings', 'rds'))
# SLOTS
commun.signalT.connect(self.temperature)
self.doubleSpinBoxFreq.valueChanged.connect(self.freq)
self.doubleSpinBoxPow.valueChanged.connect(self.power)
self.pushButtonRds.clicked.connect(self.rds)
self.pushButtonTerminal.clicked.connect(self.terminal)
# QN8027
qn8027.init()
self.freq()
self.power()
self.rds()
#OVERHEAT
self.overheat = False
def setupUi(self, main_window):
super(Ui_MainWindow, self).setupUi(main_window)
self.main_window = main_window
self.init_combo_version()
self.wait_overlay = wait_overlay_widget.WaitOverlay(main_window,
opacity=50,
circle_size=15,
nb_dots=9,
dot_size=8,
color=QtGui.QColor(
98, 74, 91))
self.wait_overlay.hide()
self.text_log = QtWidgets.QTextEdit(self.verticalWidget)
palette = QtGui.QPalette()
brush = QtGui.QBrush(QtGui.QColor(98, 73, 91))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Base, brush)
brush = QtGui.QBrush(QtGui.QColor(98, 73, 91))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Base, brush)
brush = QtGui.QBrush(QtGui.QColor(178, 146, 169))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Base, brush)
self.text_log.setPalette(palette)
self.text_log.setObjectName("text_log")
self.horizontal_layout_log.addWidget(self.text_log)
self.text_log.hide()
self.checkbox_enterprise.stateChanged.connect(
self.onchange_checkbox_enterprise)
self.checkbox_enterprise.setChecked(
bool(settings.get_setting('USE_ENTERPRISE')))
self.onchange_checkbox_enterprise()
self.tool_menu = QtWidgets.QMenu(self.main_window)
self.action_select_database = QtWidgets.QAction(
_translate('MainWindow', 'Select database'))
self.tool_menu.addAction(self.action_select_database)
self.action_config_database = QtWidgets.QAction(
_translate('MainWindow', 'Database configuration'))
self.tool_menu.addAction(self.action_config_database)
self.push_tools.setMenu(self.tool_menu)
self.line_edit_enterprise_path.setText(
settings.get_setting('ENTERPRISE_PATH'))
self.push_button_start.setIcon(
svg_icon.get_svg_icon("/ui/img/play.svg"))
self.push_addons.setIcon(svg_icon.get_svg_icon("/ui/img/store.svg"))
self.push_update_all.setIcon(
svg_icon.get_svg_icon("/ui/img/refresh.svg"))
self.push_tools.setIcon(svg_icon.get_svg_icon("/ui/img/tools.svg"))
self.push_logs.setIcon(svg_icon.get_svg_icon("/ui/img/bug.svg"))
self.push_openugrade.setIcon(
svg_icon.get_svg_icon("/ui/img/upgrade.svg"))
self.push_logs.clicked.connect(self.show_logs)
self.push_addons.clicked.connect(self.show_dialog_addons)
def __init__(self, redirect_uri='', approval_prompt='auto', scope=''):
self.flow = OAuth2WebServerFlow(
client_id=get_setting('OAUTH2_CLIENT_ID'),
client_secret=get_setting(
'OAUTH2_CLIENT_SECRET'),
scope=scope,
redirect_uri=redirect_uri,
approval_prompt=approval_prompt)
def summary(results):
from settings import get_file
from settings import get_setting
data = get_setting('SUMMARY')
file_path = get_file('SUMMARY_FILE')
pipeline = get_setting('PIPELINE')
with open(file_path,'w') as f:
for number, key in data:
f.write('\n==== step %d - %s (module %s) ====\n' % (number, key, pipeline[number][0]))
f.write(format(results[number][key]))
def cg(self):
# if the user has changed their api key since we last retrieved our
# circleguard instance, recreate circleguard with the new key.
new_api_key = get_setting('api_key')
if new_api_key != self.old_api_key or not self._cg:
from circleguard import Circleguard
cache_path = get_setting("cache_dir") + "circleguard.db"
self._cg = Circleguard(new_api_key, cache_path)
self.old_api_key = new_api_key
return self._cg
def save_config(self):
"""Apply and save new settings."""
settings.set_settings("sound", round(self.sound, 1))
settings.set_settings("music", round(self.music, 1))
settings.set_settings("classic", self.classic)
settings.save_config()
# Set volumes
resources.set_volume(settings.get_setting("sound"))
pygame.mixer.music.set_volume(settings.get_setting("music"))
def __init__(self):
super().__init__()
self.index = 0
self.sound = settings.get_setting("sound")
self.music = settings.get_setting("music")
self.classic = settings.get_setting("classic")
self.options = [
"Sound Effects", "Music", "Graphics", "Change Controls",
"Save and Return to Main Menu"
]
# Create sliders
self.sound_slider = Slider(self.sound, 250)
self.music_slider = Slider(self.music, 250)
def __init__(self, beatmap_info, replays=[], events=[], library=None):
speeds = get_setting("speed_options")
start_speed = get_setting("default_speed")
snaps_args = {
"only_on_hitobjs": get_setting("ignore_snaps_off_hitobjs")
}
super().__init__(beatmap_info,
replays,
events,
library,
speeds,
start_speed,
snaps_args=snaps_args)
self.setWindowIcon(QIcon(resource_path("logo/logo.ico")))
def run(self):
exe = get_setting('CLUSTALW_PATH')
tree_file = get_file('CLUSTALW_NEWTREE', None)
if tree_file is None:
tree_file = create_tmp()
cline = ClustalwCommandline(exe, infile=self.input, newtree=tree_file)
build_tree_out, build_tree_err = cline()
result = {
'tree': Bio.Phylo.read(tree_file, 'newick'),
'tree_out': build_tree_out,
'tree_err': build_tree_err,
}
if self.only_tree:
return result
outfile = get_file('CLUSTALW_OUTFILE', None)
if outfile is None:
outfile = create_tmp()
cline = ClustalwCommandline(exe, infile=self.input, outfile=outfile)
###Fix "p.checker_function = lambda x: os.path.exists"
param = [i for i,p in enumerate(cline.parameters)
if 'usetree' in p.names]
cline.parameters[param[0]].checker_function = os.path.exists
###
setattr(cline, 'usetree', tree_file)
align_out, align_err = cline()
result.update({
'align_out': align_out,
'align_err': align_err,
'alignment': inout.AlignFileInput(file=outfile, format='clustal').read(),
})
return result
def song_search(bot, update, groups, lang):
switch_pm = (_('Searching only songs'), 'help_inline')
originals_only = get_setting('originals', bot, update)
return voca_db.songs(groups[0],
lang,
max_results=MAX_INLINE_RESULTS,
originals_only=originals_only), switch_pm
def _ratelimited(length):
message = get_setting("message_ratelimited")
ts = datetime.now()
self.write_to_terminal_signal.emit(
message.format(s=length, ts=ts))
self.update_label_signal.emit("Ratelimited")
self.update_run_status_signal.emit(run.run_id, "Ratelimited")
def emit(self, record):
message = self.format(record)
# replace api keys with asterisks if they get into the logs from eg a
# stacktrace
api_key = get_setting("api_key")
message = message.replace(api_key, "*" * len(api_key))
self.new_message.emit(message)
def format(value):
from settings import get_setting
summary_type = get_setting('SUMMARY_TYPE')
if summary_type == "HUMAN_READABLE":
return human_readable(value)
else:
return str(value)
def log(self, message):
"""
Message is the string message sent to the io stream
"""
# TERMINAL / BOTH
if get_setting("log_output") in [1, 3]:
self.main_window.main_tab.write(message)
# NEW WINDOW / BOTH
if get_setting("log_output") in [2, 3]:
if self.debug_window and self.debug_window.isVisible():
self.debug_window.write(message)
else:
self.debug_window = DebugWindow()
self.debug_window.show()
self.debug_window.write(message)
def validate_email(property, value):
value = value if value else None
if value is None:
return value
elif value[0] == u'\ufffd':
return value[1:].lower()
elif not re.match(get_setting('EMAIL_REGEXP'), value):
raise BadValueError
return value.lower()
def run_update_check(self):
last_check = datetime.strptime(get_setting("last_update_check"), get_setting("timestamp_format"))
next_check = last_check + timedelta(hours=1)
if next_check > datetime.now():
self.update_label(self.get_version_update_str())
return
try:
import requests
from requests import RequestException
# check for new version
git_request = requests.get("https://api.github.com/repos/circleguard/circleguard/releases/latest").json()
git_version = version.parse(git_request["name"])
set_setting("latest_version", git_version)
set_setting("last_update_check", datetime.now().strftime(get_setting("timestamp_format")))
except RequestException:
# user is probably offline
pass
self.update_label(self.get_version_update_str())
def start_ui(live_capture=False):
if live_capture:
# start up background thread to periodically update ui state.
ui_state_thread = threading.Thread(target=updater)
ui_state_thread.start()
else:
update_ui_state()
app.run_server(debug=get_setting('app', 'EnableDebugMode'))
def login(user='******', silent=False):
url = settings.get_setting('BASE_URL') \
+ settings.get_setting('LOGIN_URL')
try:
data = json.dumps({
"name": settings.get_setting(user),
"password": settings.get_setting('BDS_PASSWORD')
})
resp = requestOp(op="post", url=url, data=data)
if resp is None:
return ''
if resp.status_code == 201:
if not silent:
print "Logged in Session ID: %s" % (resp.headers["location"])
return resp.headers['location']
else:
return ''
except:
return ''
def _upload(self, file_path, metadata):
if self.uploader is None:
self.uploader = YouTubeUploader(get_setting('username'))
if self.uploader.username == "":
raise Exception("No user selected to upload to")
thread = UploadThread(self.uploader, file_path, metadata, self.on_done_uploading)
self.threads.append(thread)
if not self.uploading:
self.uploading = True
thread.start()
def _init_p0f(flag, value):
"""
Helper function for the init methods: performs most
of the work for setting up background process and
API socket database hook.
"""
global p0f_db, background_proc
if p0f_db:
raise RuntimeError("Attempted to double initialize p0f proxy.")
database_path = get_setting('p0f', 'DatabaseFilePath')
socket_path = get_setting('p0f', 'APISocketFilePath')
sys.stdout.flush()
background_proc = subprocess.Popen(
["p0f", "-f", database_path, "-s", socket_path, flag, value],
stdout=open(os.devnull, 'w'),
stderr=subprocess.STDOUT,
close_fds=True)
p0f_db = P0f(socket_path)
def __init__(self, input=None, sequences=None, only_tree=False, *args, **kwargs):
super(Alignment, self).__init__(*args, **kwargs)
from settings import get_setting
if sequences is not None:
input = create_tmp()
inout.FileOutput(input).write(sequences)
if input is None:
self.input = get_setting('INPUT_FILE')
else:
self.input = input
self.only_tree = only_tree
def url_scheme_called(self, url):
from circleguard import ReplayMap, Circleguard, Mod
# url is bytes, so decode back to str
url = url.decode()
# windows appends an extra slash even if the original url didn't have
# it, so remove it
url = url.strip("/")
# all urls can have any of the following parameters:
# * m - the map id
# * u - the first user's id
# * u2 - the second user's id
# * t - the timestamp to start at
# * m1 - the mods the first replay was played with
# * m2 - the mods the second replay was played with
# For example, a url might look like
# circleguard://m=221777&u=2757689&m1=HDHRu2=3219026&m2=HDHR
map_id = int(re.compile(r"m=(.*?)(&|$)").search(url).group(1))
user_id = int(re.compile(r"u=(.*?)(&|$)").search(url).group(1))
timestamp_match = re.compile(r"t=(.*?)(&|$)").search(url)
# start at the beginning if timestamp isn't specified
timestamp = int(timestamp_match.group(1)) if timestamp_match else 0
# mods is optional, will take the user's highest play on the map if not
# specified
mods1_match = re.compile(r"m1=(.*?)(&|$)").search(url)
mods1 = None
if mods1_match:
mods1 = mods1_match.group(1)
user_id_2_match = re.compile(r"u2=(.*?)(&|$)").search(url)
user_id_2 = None
if user_id_2_match:
user_id_2 = int(user_id_2_match.group(1))
mods2_match = re.compile(r"m2=(.*?)(&|$)").search(url)
mods2 = None
if mods2_match:
mods2 = mods2_match.group(1)
# convert the string into an actual mods object if we received it
mods1 = Mod(mods1) if mods1 else None
r = ReplayMap(map_id, user_id, mods1)
cg = Circleguard(get_setting("api_key"))
cg.load(r)
replays = [r]
if user_id_2:
mods2 = Mod(mods2) if mods2 else None
r2 = ReplayMap(map_id, user_id_2, mods2)
cg.load(r2)
replays.append(r2)
# open visualizer for the given map and user, and jump to the timestamp
result = URLAnalysisResult(replays, timestamp)
self.cg_classic.main_tab.url_analysis_q.put(result)
def start_oauth2_dance():
login_hint = ""
scope = ""
client = Client.get_by_id(1)
if not client:
# If client does not exist then create an empty one
client = Client(id=1)
client.put()
# Get the login hint from configuration
# approval_prompt = 'auto' if client.reseller_refresh_token else 'force'
# Always force to be sure to get valid refresh token
approval_prompt = "force"
login_hint = get_setting("OAUTH2_RESELLER_DOMAIN_USER")
scope = get_setting("OAUTH2_SCOPE")
redirect_uri = helpers.url_for("oauth_callback", _external=True)
oauth_helper = OAuthDanceHelper(scope=scope, redirect_uri=redirect_uri, approval_prompt=approval_prompt)
url = oauth_helper.step1_get_authorize_url()
# TODO: Add a random token to avoid forgery
return redirect("%s&login_hint=%s" % (url, login_hint))
def make_django_green(monkey_patch_done=False):
if not monkey_patch_done:
# Make python sockets green
from gevent import monkey
monkey.patch_all()
# Make other stuff green
for setting in get_setting('DJANGO_GEVENT_MAKE_GREEN'):
module_name = '.'.join(setting.split('.')[:-1])
function_name = setting.split('.')[-1]
make_green_function = getattr(import_module(module_name), function_name)
make_green_function()
def main(argv):
if len(argv) < 1 or len(argv) > 2:
usage()
sys.exit(2)
dataconn_path = argv[0]
obj_id = dataconn_path[len(settings.get_setting('DATACONN_URL')):]
rem_obj = "/" in obj_id
if len(argv) == 2:
if rem_obj:
usage()
sys.exit(2)
query = '?query=' + argv[1]
else:
if rem_obj:
query = ''
else:
query = '?query='
session_id = session.login()
print
url = settings.get_setting('BASE_URL') + dataconn_path + query
response = requests.get(url, headers=session.get_session_hdr(session_id))
if response.status_code == 404:
print "object not found"
else:
if rem_obj:
print_objinfo([response.json()])
else:
query_results = response.json()["_embedded"]["query_results"]
if "matching_objects" in query_results:
print_objinfo(query_results["matching_objects"])
else:
print "errors:"
for error in query_results["access_errors"]:
print " %s" % (error)
if json_debug:
print "debug:"
print " %s" % (response.json())
session.logout(session_id)
def search(bot, update, args, lang, songs=False, artists=False, albums=False, state=None):
query = args if type(args) == str else ' '.join(args)
if songs and artists and albums:
entries = voca_db.entries(query, lang)
elif songs:
originals_only = get_setting('originals', bot, update)
entries = voca_db.songs(query, lang, originals_only=originals_only)
elif artists:
entries = voca_db.artists(query, lang)
elif albums:
entries = voca_db.albums(query, lang)
else:
return None, None
return entries, state
def visualize(self, replays, beatmap_id, result):
# only run one instance at a time
if self.visualizer is not None:
self.visualizer.close()
snaps = []
if isinstance(result, CorrectionResult):
snaps = [snap.time for snap in result.snaps]
beatmap_info = BeatmapInfo(map_id=beatmap_id)
if not get_setting("render_beatmap"):
# don't give the visualizer any beatmap info if the user doesn't
# want it rendered
beatmap_info = BeatmapInfo()
self.visualizer = CGVisualizer(beatmap_info, replays, snaps, self.library)
self.visualizer.show()
def __init__(self):
super().__init__()
self._cg = None
self.visualizer = None
self.old_api_key = get_setting("api_key")
self.loadables_q = Queue()
# this thread continually checks for new loadables to load
self.cg_load_thread = threading.Thread(target=self._load_loadables)
# we never kill this thread, so allow the application to quit while it's
# still alive
self.cg_load_thread.daemon = True
self.cg_load_thread.start()
self.loadable_loaded = threading.Event()
self.show_visualizer_window.connect(self.show_visualizer)
self.show_exception_signal.connect(self.show_exception)
expanding = QSizePolicy()
expanding.setHorizontalPolicy(QSizePolicy.Expanding)
expanding.setVerticalPolicy(QSizePolicy.Expanding)
self.drop_area = ReplayDropArea()
self.drop_area.setSizePolicy(expanding)
da_scroll_area = QScrollArea(self)
da_scroll_area.setWidget(self.drop_area)
da_scroll_area.setWidgetResizable(True)
da_scroll_area.setFrameShape(QFrame.NoFrame)
self.replay_map_creation = ReplayMapCreation()
self.replay_map_creation.setSizePolicy(expanding)
rmc_scroll_area = QScrollArea(self)
rmc_scroll_area.setWidget(self.replay_map_creation)
rmc_scroll_area.setWidgetResizable(True)
rmc_scroll_area.setFrameShape(QFrame.NoFrame)
visualize_button = PushButton("Visualize")
visualize_button.setObjectName("bigButton")
visualize_button.clicked.connect(self.visualize)
font = visualize_button.font()
font.setPointSize(30)
visualize_button.setFont(font)
expanding = QSizePolicy()
expanding.setHorizontalPolicy(QSizePolicy.Expanding)
expanding.setVerticalPolicy(QSizePolicy.Expanding)
visualize_button.setSizePolicy(expanding)
layout = QGridLayout()
layout.addWidget(da_scroll_area, 0, 0, 6, 1)
layout.addWidget(rmc_scroll_area, 0, 1, 6, 1)
layout.addWidget(visualize_button, 6, 0, 2, 2)
self.setLayout(layout)
def set_camera(self, camera):
self.camera = camera
self.camera.PixelFormat = "BGR8"
self.input_res = settings.get_setting(
"input_resolution",
[self.camera.Width.Value, self.camera.Height.Value])
self.output_res = settings.get_setting(
"output_resolution",
[self.camera.Width.Value, self.camera.Height.Value])
self.fps = settings.get_setting("fps", 30)
self.camera.Width = self.input_res[0]
self.camera.Height = self.input_res[1]
self.camera.AcquisitionFrameRate = self.fps
self.camera.AcquisitionFrameRateEnable = True
self.camera.AutoExposureTimeUpperLimit = settings.get_setting(
"max_exposure_time", 15000)
self.virt_cam = pyvirtualcam.Camera(width=self.output_res[0],
height=self.output_res[1],
fps=self.fps,
print_fps=False,
fmt=pyvirtualcam.PixelFormat.BGR)
self.frame = np.full(
(self.camera.Height.Value, self.camera.Width.Value, 3), 255,
np.uint8)
def init_module():
"""
Initializes the geoip database reader.
"""
global geoip_db_reader
if geoip_db_reader:
raise RuntimeError("Attempted to double initialize geoip module")
database_path = get_setting('geoip', 'DatabaseFilePath')
geoip_db_reader = geoip2.database.Reader(database_path)
# Ensure the reader is properly initialized
try:
geoip_db_reader.country('127.0.0.1')
except geoip2.errors.AddressNotFoundError:
pass
def log(self, message):
"""
Message is the string message sent to the io stream
"""
log_output = get_setting("_log_output")
if log_output in ["terminal", "both"]:
self.cg_classic.main_tab.write(message)
if log_output in ["new_window", "both"]:
if self.debug_window and self.debug_window.isVisible():
self.debug_window.write(message)
else:
self.debug_window = DebugWindow()
self.debug_window.show()
self.debug_window.write(message)
def render(self, screen):
width, height = pygame.display.get_surface().get_size()
if not self.is_paused and (not self.has_crashed or
(self.has_crashed
and not self.event_painted)):
# Draw background
if not settings.get_setting("classic"):
screen.blit(self.background, (0, 0))
else:
# Classic look
screen.fill(BGCOLOR)
# Draw snake, apple, grid
self.sneik.draw(screen)
self.apple.draw(screen)
if self.show_grid:
self.draw_grid(screen)
if self.has_crashed:
self.event_painted = True
elif self.has_crashed:
# Add snake blood
self.sneik.draw_blood(screen)
# Paint pause screen once
elif not self.event_painted:
# Darken the screen
surf = get_surface((width, height), BLACK, 160)
screen.blit(surf, (0, 0))
# Show pause message
font = resources.get_font("title100")
text_surf, text_rect = render_text("Paused", font, WHITE)
text_rect.center = width // 2, 250
screen.blit(text_surf, text_rect)
font = resources.get_font("round30")
text_surf, text_rect = render_text(
f"Score: {len(self.sneik.body) - 2}", font, WHITE)
text_rect.center = width // 2, 330
screen.blit(text_surf, text_rect)
self.event_painted = True
def run(self):
try:
self.uploader = YouTubeUploader(
self.username,
self.jobs,
get_setting("headlessBrowser") ==
SETTINGS_VALUES.CheckBox.CHECKED,
)
self.uploader.upload_finished.connect(
lambda file_path, success: self.upload_finished.emit(
file_path, success))
self.uploader.log_message.connect(
lambda message, level: self.log_message.emit(message, level))
self.uploader.on_progress.connect(
lambda job_name, progress: self.on_progress.emit(
job_name, progress))
self.uploader.upload_all()
except Exception:
self.log_message.emit(traceback.format_exc(), logging.ERROR)
finally:
self.finished.emit()
def create_token(login, login_type):
if login_type == "jid":
login = resolve_alias(login)
tmp = tempfile.mktemp(suffix="", prefix="", dir="")
token = Token(token=tmp, login=login, login_type=login_type, active=1)
token.put(force_insert=True)
base_url = get_setting("web_api_root", "http://localhost:8080").rstrip("/")
url = "%s/api/auth?token=%s" % (base_url, tmp)
message = "A third-party application is requesting access to your account. If that was you, follow this link:\n%s\n" % url
if login_type == "jid":
msg = Message(re=login, message=message)
msg.put()
else:
run(["mail", "-s", "Your token", login], stdin_data=message)
commit()
return url
def search(bot,
update,
args,
lang,
songs=False,
artists=False,
albums=False,
state=None):
query = args if type(args) == str else ' '.join(args)
if songs and artists and albums:
entries = voca_db.entries(query, lang)
elif songs:
originals_only = get_setting('originals', bot, update)
entries = voca_db.songs(query, lang, originals_only=originals_only)
elif artists:
entries = voca_db.artists(query, lang)
elif albums:
entries = voca_db.albums(query, lang)
else:
return None, None
return entries, state
def become_site_admin(session_id, session_header):
site_admin_role_url = None
url = settings.get_setting('BASE_URL') \
+ settings.get_setting('ROLE_URL')
response = requestOp(op="get", url=url, headers=session_header)
if response is None:
print "Failed to perform requests.get"
sys.exit(2)
role_list = response.json()["_embedded"]["roles"]
for role in role_list:
if role["label"]["name"] == settings.get_setting(
'BDS_SITE_ADMIN_ROLE'):
site_admin_role_url = role["_links"]["self"]["href"]
if site_admin_role_url is None:
print "site admin role not found!"
sys.exit(2)
admin_tenant_url = None
url = settings.get_setting('BASE_URL') \
+ settings.get_setting('TENANT_URL')
response = requestOp(op="get", url=url, headers=session_header)
if response is None:
print "Failed to perform requests.get"
sys.exit(2)
tenant_list = response.json()["_embedded"]["tenants"]
for tenant in tenant_list:
if tenant["label"]["name"] == settings.get_setting('BDS_ADMIN_TENANT'):
admin_tenant_url = tenant["_links"]["self"]["href"]
if admin_tenant_url is None:
print "admin tenant not found!"
sys.exit(2)
url = settings.get_setting('BASE_URL') + session_id + '?tenant'
role_data = {"role": site_admin_role_url, "tenant": admin_tenant_url}
role_spec = json.dumps(role_data)
response = requestOp(op="put",
url=url,
data=role_spec,
headers=session_header)
if response is None:
print "Failed to perform requests.put"
sys.exit(2)
if response.status_code != 204:
print "taking site admin role failed!"
sys.exit(2)
def __init__(self, config_file=None):
settings.init(config_file)
self.host = settings.get_setting('ftp').get('host')
self.username = settings.get_setting('ftp').get('username')
self.password = settings.get_setting('ftp').get('password')
self.connection = None
def song_search(bot, update, groups, lang):
switch_pm = (_('Searching only songs'), 'help_inline')
originals_only = get_setting('originals', bot, update)
return voca_db.songs(groups[0], lang, max_results=MAX_INLINE_RESULTS, originals_only=originals_only), switch_pm
def getDirname(self):
assert self.type == "po"
# @TODO unix folder limits
return os.path.join(get_setting("STORE_PATH"), str(self.id))
