def process_input(self, events, pressed_keys):
for event in events:
if event.type == pygame.KEYDOWN:
if not self.changing:
# Select option
if event.key == settings.get_key("up"):
self.index = (len(self.options) -
1 if self.index == 0 else self.index - 1)
resources.get_sound("menu-sel").stop()
resources.get_sound("menu-sel").play()
elif event.key == settings.get_key("down"):
self.index = (0 if self.index == len(self.options) -
1 else self.index + 1)
resources.get_sound("menu-sel").stop()
resources.get_sound("menu-sel").play()
# Modify option
elif event.key == settings.get_key("accept"):
resources.get_sound("menu-accept").stop()
resources.get_sound("menu-accept").play()
# Enter 'change key' mode
if self.index != len(self.options) - 1:
self.changing = True
# Save and Return to Main Menu
else:
self.save_config()
self.switch_to_scene(SceneMenu)
else:
# Change key bind
self.change_key(event.key)
def render(self, screen: pygame.Surface):
width, height = pygame.display.get_surface().get_size()
# Display gameover message
screen.fill(BGCOLOR)
text_surf, text_rect = render_text("YOU LOST",
resources.get_font("title100"),
WHITE)
text_rect.centerx, text_rect.y = width // 2, 110
screen.blit(text_surf, text_rect)
text_surf, text_rect = render_text(f"Your score was {self.score}",
resources.get_font("round30"),
WHITE)
text_rect.centerx, text_rect.y = width // 2, 270
screen.blit(text_surf, text_rect)
if not self.record:
accept = pygame.key.name(settings.get_key("accept"))
finish = pygame.key.name(settings.get_key("pause"))
text = (f"({accept.upper()} to replay,"
f" {finish.upper()} to exit menu)")
text_surf, text_rect = render_text(text,
resources.get_font("round30"),
WHITE)
text_rect.centerx, text_rect.y = width // 2, 325
screen.blit(text_surf, text_rect)
else:
# Highscore message
text_surf, text_rect = render_text("New record!",
resources.get_font("round30"),
WHITE)
text_rect.centerx, text_rect.y = width // 2, 345
screen.blit(text_surf, text_rect)
text_surf, text_rect = render_text("Enter your initials: ",
resources.get_font("round30"),
WHITE)
text_rect.centerx, text_rect.y = width // 2 - 58, 420
screen.blit(text_surf, text_rect)
# Textbox
input_box = pygame.Rect(width // 2 + 82, 415, 100, 35)
screen.fill(BLACK, input_box)
resources.get_font("round30").render_to(
screen, (input_box.x + 15, input_box.y + 5), self.initials,
WHITE)
# Pun
text_surf, text_rect = render_wrapped_text(
self.joke, resources.get_font("normal25"), WHITE, True, 10,
width - 150)
text_rect.centerx, text_rect.y = width // 2, height - 130
screen.blit(text_surf, text_rect)
def process_input(self, events, pressed_keys):
for event in events:
if event.type == pygame.KEYDOWN:
# Select option
if event.key == settings.get_key("up"):
self.index = (len(self.options) -
1 if self.index == 0 else self.index - 1)
resources.get_sound("menu-sel").stop()
resources.get_sound("menu-sel").play()
elif event.key == settings.get_key("down"):
self.index = (0 if self.index == len(self.options) -
1 else self.index + 1)
resources.get_sound("menu-sel").stop()
resources.get_sound("menu-sel").play()
# Modify option
elif event.key == settings.get_key("left"):
if self.index == 0:
self.sound -= (0.1 if self.sound >= 0.1 else 0)
self.test_volume(self.sound)
elif self.index == 1:
self.music -= (0.1 if self.music >= 0.1 else 0)
self.test_volume(self.music)
elif self.index == 2:
resources.get_sound("menu-sel").stop()
resources.get_sound("menu-sel").play()
self.classic = not self.classic
elif event.key == settings.get_key("right"):
if self.index == 0:
self.sound += (0.1 if self.sound <= 0.9 else 0)
self.test_volume(self.sound)
elif self.index == 1:
self.music += (0.1 if self.music <= 0.9 else 0)
self.test_volume(self.music)
elif self.index == 2:
resources.get_sound("menu-sel").stop()
resources.get_sound("menu-sel").play()
self.classic = not self.classic
elif (event.key == settings.get_key("accept")
and 2 < self.index < 5):
resources.get_sound("menu-accept").stop()
resources.get_sound("menu-accept").play()
# Change controls
if self.index == 3:
self.save_config()
self.switch_to_scene(SceneSettingsControls)
# Return to Main Menu
elif self.index == len(self.options) - 1:
self.save_config()
self.switch_to_scene(SceneMenu)
def __start__():
global app
global logger
logger = logging.getLogger(__name__)
app.secret_key = settings.get_key('secret_key')
app.app_context().push()
def fetch_local_art(album: Album):
"""
Finds the first matching image for an album found in
the music library.
Loops through each track, and checks each file in the track
directory until one of them is a valid image file.
:param album: The album to fetch art for
:return: The image file binary
"""
music_path = settings.get_key('plugins.base.music.path')
valid_extensions = ['.jpg', '.gif', '.png', '.tga', '.bmp']
visited_paths = []
for track in album.tracks:
folder = path.join(music_path, path.dirname(track.path))
if folder in visited_paths:
continue
visited_paths.append(folder)
for file in listdir(folder):
ext = path.splitext(file)[1]
if ext.lower() not in valid_extensions:
continue
img_path = path.join(folder, file)
with open(img_path, 'rb') as f:
return io.BytesIO(f.read())
return None
def process_input(self, events, pressed_keys):
for event in events:
if event.type == pygame.KEYDOWN:
if event.key == settings.get_key("accept"):
resources.get_sound("menu-accept").stop()
resources.get_sound("menu-accept").play()
self.switch_to_scene(SceneMenu)
def process_input(self, events, pressed_keys):
for event in events:
if event.type == pygame.KEYDOWN:
if event.key == settings.get_key("up"):
self.index = (len(self.options) -
1 if self.index == 0 else self.index - 1)
resources.get_sound("menu-sel").stop()
resources.get_sound("menu-sel").play()
elif event.key == settings.get_key("down"):
self.index = (0 if self.index == len(self.options) -
1 else self.index + 1)
resources.get_sound("menu-sel").stop()
resources.get_sound("menu-sel").play()
elif event.key == settings.get_key("accept"):
resources.get_sound("menu-accept").stop()
resources.get_sound("menu-accept").play()
self.selected = True
def process_input(self, events, pressed_keys):
for event in events:
if not self.has_crashed:
if self.is_paused:
if (event.type == pygame.KEYDOWN
and event.key == settings.get_key("pause")):
self.unpause()
else:
if event.type == pygame.KEYDOWN:
# Snake control, add new direction to queue
if event.key in settings.get_key("direction"):
self.sneik.queue_direction(
event, settings.get_key("direction"))
# UI control
elif event.key == settings.get_key("grid"):
self.show_grid = not self.show_grid
elif event.key == settings.get_key("pause"):
self.pause()
def fetch_genius_lyrics(track: Track):
api_key = settings.get_key('plugins.base_extra.music.lyrics.genius.api_key')
genius = lyricsgenius.Genius(api_key)
try:
song = genius.search_song(track.name, track.artist.name)
if song:
return song.lyrics
return None
except ConnectionError:
return None
def run_game(width: int, height: int, fps: int, starting_scene: SceneBase):
"""Main function that moves everything. Don't delete it."""
pygame.mixer.pre_init(44100, -16, 2, 1024)
os.environ['SDL_VIDEO_CENTERED'] = "1"
pygame.init()
screen = pygame.display.set_mode((width, height))
game_icon = pygame.image.load("assets/images/icon.png")
pygame.display.set_icon(game_icon)
pygame.mouse.set_visible(False)
clock = pygame.time.Clock()
# Load game data
resources.load_assets()
settings.load_config()
settings.load_jokes()
# Start first scene
active_scene = starting_scene()
while active_scene is not None:
# Handle events
pressed_keys = pygame.key.get_pressed()
filtered_events = []
for event in pygame.event.get():
quit_attempt = False
if event.type == pygame.QUIT:
quit_attempt = True
elif event.type == pygame.KEYDOWN:
alt_pressed = (pressed_keys[pygame.K_LALT]
or pressed_keys[pygame.K_RALT])
if event.key == settings.get_key("exit"):
quit_attempt = True
elif event.key == pygame.K_F4 and alt_pressed:
quit_attempt = True
if quit_attempt:
active_scene.terminate()
else:
filtered_events.append(event)
# Scene does its stuff
active_scene.process_input(filtered_events, pressed_keys)
now = pygame.time.get_ticks()
active_scene.update(now)
active_scene.render(screen)
# To next scene or continue in the same
active_scene = active_scene.next
pygame.display.flip()
clock.tick(fps)
pygame.display.set_caption(f"Snake - {clock.get_fps():2.0f} fps")
def process_input(self, events: List[pygame.event.EventType],
pressed_keys: List[bool]):
for event in events:
if event.type == pygame.KEYDOWN:
if not self.record:
if event.key == settings.get_key("accept"):
# Replay
self.switch_to_scene(SceneGame)
elif event.key == settings.get_key("pause"):
# To menu
self.switch_to_scene(SceneMenu)
else:
if event.key == settings.get_key("accept"):
# confirm entered text
self.add_highscore()
self.record = False
elif event.key == pygame.K_BACKSPACE:
# delete letter
self.initials = self.initials[:-1]
elif len(self.initials) < 3 and event.unicode.isalnum():
# write letter
self.initials += event.unicode.upper()
def watch_movies():
global observer
global logger
logger = logging.getLogger(__name__)
path = os.path.expanduser(settings.get_key('plugins.base.movies.path'))
logger.debug('Starting movies filewatcher on \'%s\'' % path)
event_handler = MediaEventHandler(path, import_movie, Movie)
observer = Observer()
observer.schedule(event_handler, path, recursive=True)
observer.start()
def import_track(full_path: str, track: Track = None):
music_path = os.path.expanduser(
settings.get_key('plugins.base.music.path'))
tags = File(full_path)
if tags is None:
return
relative_path = full_path.replace('%s/' % music_path, '')
name = get_name(tags)
name_sort = get_name_sort(name)
artist = get_artist(get_artist_name(tags))
album_artist = get_artist(get_album_artist_name(tags))
album = get_album(get_album_name(tags), get_release_date(tags),
get_genres(tags), artist, album_artist)
duration = get_duration(tags)
track_num = get_track_num(tags)
disc_num = get_disc_num(tags)
disc_name = get_disc_name(tags)
format = relative_path.split('.')[-1]
size = os.path.getsize(full_path)
bitrate = tags.info.bitrate
add = False
if track is None:
track = Track()
add = True
track.name = name
track.name_sort = name_sort
track.artist = artist
track.album = album
track.duration = duration
track.track_num = track_num
track.disc_num = disc_num
track.disc_name = disc_name
track.path = relative_path
track.format = format
track.bitrate = bitrate
track.size = size
if add:
database.db.session.add(track)
def import_movies():
movies_path = os.path.expanduser(settings.get_key('plugins.base.movies.path'))
for root, dirs, files in os.walk(movies_path):
for file in files:
full_path = os.path.join(root, file)
relative_path = full_path.replace('%s/' % movies_path, '')
print(relative_path)
import_movie(full_path)
database.db.session.commit()
return jsonify({'message': 'Import successful'}), 201
def _load_modules():
global _loaded_modules
modules = settings.get_key('plugins')
for module in modules:
plugin = importlib.import_module('plugins.%s' % module)
# Every plugin should have an init entry point
plugin.init()
_loaded_modules.append(module)
if hasattr(sys.modules[plugin.__name__], '__blueprints__'):
for bp in plugin.__blueprints__:
server.app.register_blueprint(plugin.__blueprints__[bp])
def import_music():
music_path = os.path.expanduser(
settings.get_key('plugins.base.music.path'))
total_num = len([*os.walk(music_path)])
num = 0
for root, dirs, files in os.walk(music_path):
num += 1
for file in files:
print('[%r%%] %s' % (round(
(num / total_num) * 100, 1), os.path.join(root, file)))
import_track(os.path.join(root, file))
database.db.session.commit()
return jsonify({'message': 'Import successful'}), 201
def import_tv():
tv_path = os.path.expanduser(settings.get_key('plugins.base.tv.path'))
for root, dirs, files in os.walk(tv_path):
for file in files:
show_name, season_num, episode_num, episode_name = get_details_from_filename(
file)
full_path = os.path.join(root, file)
relative_path = full_path.replace('%s/' % tv_path, '')
print(relative_path)
media_info = MediaInfo.parse(full_path)
tracks = [
track for track in media_info.tracks
if track.track_type == 'Video'
]
if not len(tracks):
continue
track = tracks[0]
show = get_show(show_name)
season = get_season('Season %s' % season_num, season_num, show)
episode = Episode(name=episode_name,
name_sort=get_name_sort(episode_name),
number=episode_num,
path=relative_path,
duration=track.duration,
size=os.path.getsize(full_path),
format=track.format,
width=track.width,
height=track.height,
show=show,
season=season)
database.db.session.add(episode)
database.db.session.commit()
return jsonify({'message': 'Import successful'}), 201
def import_movie(path: str, movie: Movie = None):
movies_path = os.path.expanduser(settings.get_key('plugins.base.movies.path'))
relative_path = path.replace('%s/' % movies_path, '')
path_split = relative_path.split('/')
media_info = MediaInfo.parse(path)
tracks = [track for track in media_info.tracks if track.track_type == 'Video']
if not len(tracks):
return
for track in tracks:
name, release = get_name_and_release(path_split)
if release:
release = release.replace('(', '').replace(')', '')
release = datetime.strptime(release, '%Y')
add = False
if not movie:
movie = Movie()
add = True
name = name.strip()
movie.name = name
movie.name_sort = get_name_sort(name)
movie.path = relative_path
movie.release_date = release
movie.duration = track.duration
movie.size = os.path.getsize(path)
movie.format = track.format
movie.width = track.width
movie.height = track.height
if add:
database.db.session.add(movie)
def test_register_key():
settings.register_key('test.default', 'Hello World')
assert settings.get_key('test.default') == 'Hello World'
def test_database_key():
database = settings.get_key('database')
assert database is not None
assert type(database) == str
def get_key(self):
"""Return the encryption key.
Use function from settings.
"""
return settings.get_key()
def test_plugins_key():
plugins = settings.get_key('plugins')
assert plugins is not None
assert type(plugins) == dict
def test_secret_key():
secret = settings.get_key('secret_key')
assert secret is not None
assert type(secret) == str
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.primitives.serialization import Encoding, PublicFormat
from server import app
from decrypter import Decrypter
import base64
import unittest
import os
import json
import settings
import jwt
KID = 'SDE'
TEST_EQ_PRIVATE_KEY = settings.get_key("./jwt-test-keys/sdc-submission-signing-sr-private-key.pem")
class Encrypter (object):
def __init__(self):
private_key_bytes = self._to_bytes(TEST_EQ_PRIVATE_KEY)
self.private_key = serialization.load_pem_private_key(private_key_bytes,
password=self._to_bytes(settings.PRIVATE_KEY_PASSWORD),
backend=backend)
private_decryption_key = serialization.load_pem_private_key(
settings.PRIVATE_KEY.encode(),
password=self._to_bytes(settings.PRIVATE_KEY_PASSWORD),
backend=backend
)
def test_set_key():
settings.set_key('test.key', 'Hello World')
assert settings.get_key('test.key') == 'Hello World'
def test_register_existing_key():
settings.register_key('test.key', 'Something Different')
assert settings.get_key('test.key') == 'Hello World'
