Game v2

.gitignore

@@ -2,7 +2,6 @@
 __pycache__/
 *.py[cod]
 *$py.class
-
 # C extensions
 *.so
 
@@ -158,3 +157,7 @@ cython_debug/
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
 .idea/
+
+#streamlit
+.streamlit
+.streamlit/secrets.toml

data/sample_data/.gitignore

@@ -2,6 +2,4 @@
 /lyrics_vectorized.npy
 /top_300_spotify.json
 /top_10_spotify_translated.json
-/top_300_spotify_translated.json
 /top_300_spotify_with_embeddings.json
-/top_300_spotify_cleaned_and_translated.json

src/game_data_manager.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass
+from random import choice
+from random import randint
+
+import streamlit as st
+
+INVALID_PATTERN: str = r"\([^)]*\)"
+JSON_DATA: str = "data/sample_data/top_300_spotify_cleaned_and_translated.json"
+
+
+@dataclass(slots=True, init=False, repr=False)
+class Lyrics:
+    bars: list[str]
+    translated_bars: list[str]
+
+    def __init__(self, lyrics: str, translated_lyrics: str) -> None:
+        self.bars: list[str] = []
+        self.translated_bars: list[str] = []
+        self._load_lyrics(lyrics, translated_lyrics)
+
+    def _load_lyrics(self, lyrics: str, translated_lyrics: str) -> None:
+        for bar in translated_lyrics.split("\n"):
+            if not bar: continue
+            self.translated_bars.append(bar)
+
+        for bar in lyrics.split("\n"):
+            if not bar: continue
+            if len(self.bars) == len(self.translated_bars):
+                break
+            self.bars.append(bar)
+
+        assert len(self.bars) == len(self.translated_bars)
+
+    def get_random_bars(self, n: int = 1) -> list[str]:
+        if n == 0: return []
+        index_offset: int = randint(0, len(self.bars) - n)
+        return self.bars[index_offset: index_offset + n]
+
+    def __repr__(self) -> str:
+        return f"{len(self.bars)}: bars, {len(self.translated_bars)}: translated bars"
+
+
+@dataclass(slots=True, init=False, repr=False)
+class Song:
+    name: str
+    artist: str
+    lyrics: Lyrics
+
+    def __init__(self, name: str, artist: str, lyrics: str,
+                 translated_lyrics: str) -> None:
+        self.name: str = name
+        self.artist: str = artist
+        self.lyrics: Lyrics = Lyrics(lyrics, translated_lyrics)
+        self.format_name()
+
+    def format_name(self) -> None:
+        result: list[str] = re.split(INVALID_PATTERN, self.name)
+        assert len(result) >= 1
+        self.name = result[0].strip()
+
+    def __repr__(self) -> str:
+        return f"{self.name} : {self.artist}"
+
+
+class DataManager:
+    manager: DataManager | None = None
+
+    @staticmethod
+    def get() -> DataManager:
+        if DataManager.manager is None:
+            DataManager.manager = DataManager()
+
+        return DataManager.manager
+
+    @staticmethod
+    @st.cache_data
+    def get_json_data() -> list[dict[str, str]]:
+        return json.load(open(JSON_DATA))
+
+    def __init__(self) -> None:
+        self.data: list[Song] = []
+        self.load_json_data()
+
+    def load_json_data(self) -> None:
+        for song_dict in DataManager.get_json_data():
+            name: str | None = song_dict.get("song_name")
+            artist: str | None = song_dict.get("artist_name")
+            lyrics: str | None = song_dict.get("lyrics")
+            translated_lyrics: str | None = song_dict.get("translated_lyrics")
+            if not all([name, artist, lyrics, translated_lyrics]): continue
+            self.data.append(Song(name, artist, lyrics, translated_lyrics))
+
+    def get_songs(self, n=1) -> list[Song]:
+        songs: list[Song] = []
+        if len(self.data) < n:
+            raise Exception("ran out of songs :(")
+
+        while len(songs) < n:
+            song: Song = choice(self.data)
+            songs.append(song)
+            self.data.remove(song)
+
+        return songs

src/game_database.py

@@ -0,0 +1,45 @@
+from typing import TypedDict
+
+from pymongo import MongoClient
+from pymongo.collection import Collection
+from streamlit import secrets
+
+MAIN: str = "Main"
+SCORE: str = "Score"
+
+
+class Score(TypedDict):
+    username: str
+    score: int
+    datetime: str
+
+
+class GameDB:
+
+    @staticmethod
+    def get_db_uri() -> str:
+        user_name: str = secrets["mongo"]["username"]
+        user_pass: str = secrets["mongo"]["password"]
+
+        uri: str = f"mongodb+srv://{user_name}:" \
+                   f"{user_pass}@cluster0.ec67wlo.mongodb.net/?retryWrites" \
+                   "=true&w=majority"
+
+        return uri
+
+    def __init__(self) -> None:
+        self.client: MongoClient = MongoClient(GameDB.get_db_uri())
+        assert self.is_connected(), "not connected to database"
+
+    def is_connected(self) -> bool:
+        try:
+            self.client.admin.command('ping')
+            print("You successfully connected to MongoDB!")
+        except Exception as e:
+            print(e)
+            return False
+        else:
+            return True
+
+    def score(self) -> Collection:
+        return self.client[MAIN][SCORE]

src/game_markdown.py

@@ -0,0 +1,37 @@
+import streamlit as st
+from streamlit.components.v1 import html
+
+
+def centered_title(title: str, color: str = "black", size: int = 45) -> None:
+    style: str = "<style>" \
+                 ".centered-title {" \
+                 "text-align: center;" \
+                 "}" \
+                 "</style>"
+    st.markdown(style, unsafe_allow_html=True)
+    st.markdown(f"<h1 style='color: {color}; font-size: {size}px' "
+                f"class='centered-title'"
+                f">{title}</h1>", unsafe_allow_html=True)
+
+
+def separator() -> None:
+    st.markdown("----", unsafe_allow_html=True)
+
+
+def empty_space() -> None:
+    st.markdown("##")
+
+
+def get_colored_text(text: str, color: str) -> str:
+    return f"<span style='color: {color}'>{text}</span>"
+
+
+def scroll_text(height: int, text: str) -> None:
+    html_text: str = f"""
+    <center>
+    <p style="font-size:25px; font-family:verdana">
+    {text}
+    </p>
+    </center>
+"""
+    html(html_text, height=height, scrolling=True)