Upload folder using huggingface_hub

.gitignore

@@ -0,0 +1,223 @@
+*/*.DS_Store
+.DS_Store
+
+ssl/
+problemsets_*
+
+user_outputs/
+
+.idea/
+
+# Created by https://www.gitignore.io/api/macos,linux,django,python,pycharm
+
+### Django ###
+*.log
+*.pot
+*.pyc
+__pycache__/
+local_settings.py
+db.sqlite3
+media
+
+### Linux ###
+*~
+
+# temporary files which can be created if a process still has a handle open of a deleted file
+.fuse_hidden*
+
+# KDE directory preferences
+.directory
+
+# Linux trash folder which might appear on any partition or disk
+.Trash-*
+
+# .nfs files are created when an open file is removed but is still being accessed
+.nfs*
+
+### macOS ###
+*.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+### PyCharm ###
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and Webstorm
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff:
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/dictionaries
+
+# Sensitive or high-churn files:
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.xml
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+
+# Gradle:
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# CMake
+cmake-build-debug/
+
+# Mongo Explorer plugin:
+.idea/**/mongoSettings.xml
+
+## File-based project format:
+*.iws
+
+## Plugin-specific files:
+
+# IntelliJ
+/out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+### PyCharm Patch ###
+# Comment Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-215987721
+
+# *.iml
+# modules.xml
+# .idea/misc.xml
+# *.ipr
+
+# Sonarlint plugin
+.idea/sonarlint
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*,cover
+.hypothesis/
+
+# Translations
+*.mo
+
+# Django stuff:
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# dotenv
+.env
+*.env
+
+# virtualenv
+.venv
+venv/
+ENV/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# End of https://www.gitignore.io/api/macos,linux,django,python,pycharm

README.md

@@ -1,12 +1,29 @@
 ---
-title: Textgames
-emoji: 📉
-colorFrom: blue
-colorTo: red
+title: textgames
+app_file: play_gradio.py
 sdk: gradio
-sdk_version: 5.12.0
-app_file: app.py
-pinned: false
+sdk_version: 5.8.0
 ---
+# TextGames
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## Setup
+```
+❱❱❱ pip install -r requirements.txt
+```
+
+## Play (Terminal)
+```
+❱❱❱ python play.py
+```
+
+## Play (Web UI)
+```
+❱❱❱ pip install gradio
+❱❱❱ GRADIO_SERVER_PORT=1080  python play_gradio.py
+```
+Open `localhost:1080` to access.
+
+## Optional Environment Varibles
+```
+TEXTGAMES_SHOW_HIDDEN_LEVEL=1
+```

Try Gemma-2-9B.ipynb

@@ -0,0 +1,218 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+  "colab": {
+   "private_outputs": true,
+   "provenance": [],
+   "authorship_tag": "ABX9TyPmvDoFpmwAf1QFBJZy7XSQ"
+  },
+  "kernelspec": {
+   "name": "python3",
+   "display_name": "Python 3"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "Rli_enT6lBDT"
+   },
+   "outputs": [],
+   "source": [
+    "##%%\n",
+    "import os\n",
+    "import torch\n",
+    "import random\n",
+    "import numpy as np\n",
+    "import argparse\n",
+    "import json\n",
+    "import cohere\n",
+    "from openai import OpenAI\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "source": [
+    "##%%\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "from collections import Counter\n",
+    "\n",
+    "from transformers import LlamaForCausalLM, AutoTokenizer, AutoModelForCausalLM, AutoModelForSeq2SeqLM\n",
+    "import hashlib\n",
+    "\n",
+    "from textgames import GAME_NAMES, GAME_IDS, LEVELS, LEVELS_HIDDEN, LEVEL_IDS, new_game\n"
+   ],
+   "metadata": {
+    "id": "dp1F32B8oSfD"
+   },
+   "execution_count": null,
+   "outputs": []
+  },
+  {
+   "cell_type": "code",
+   "source": [
+    "##%%\n",
+    "gen_model_checkpoint = \"google/gemma-2-9b-it\"\n",
+    "quantize = True"
+   ],
+   "metadata": {
+    "id": "jZF8bkUcojTX"
+   },
+   "execution_count": null,
+   "outputs": []
+  },
+  {
+   "cell_type": "code",
+   "source": [
+    "kwargs = {\n",
+    "    \"device_map\": \"auto\",\n",
+    "} if quantize else {}"
+   ],
+   "metadata": {
+    "id": "VAF5sR9arYzS"
+   },
+   "execution_count": null,
+   "outputs": []
+  },
+  {
+   "cell_type": "code",
+   "source": [
+    "##%%\n",
+    "gen_model = AutoModelForCausalLM.from_pretrained(gen_model_checkpoint, **kwargs)\n",
+    "tokenizer = AutoTokenizer.from_pretrained(gen_model_checkpoint, **kwargs)"
+   ],
+   "metadata": {
+    "id": "tzqldl8ooRVL"
+   },
+   "execution_count": null,
+   "outputs": []
+  },
+  {
+   "cell_type": "code",
+   "source": [
+    "gen_model.device"
+   ],
+   "metadata": {
+    "id": "FeBUXdkWsWrL"
+   },
+   "execution_count": null,
+   "outputs": []
+  },
+  {
+   "cell_type": "code",
+   "source": [
+    "def get_gemma_response(text):\n",
+    "    # global gen_model, tokenizer\n",
+    "    messages = [\n",
+    "        {\"role\": \"user\", \"content\": text},\n",
+    "    ]\n",
+    "\n",
+    "    input_ids = tokenizer.apply_chat_template(\n",
+    "        messages,\n",
+    "        add_generation_prompt=True,\n",
+    "        return_tensors=\"pt\"\n",
+    "    ).to(gen_model.device)\n",
+    "\n",
+    "    terminators = [\n",
+    "        tokenizer.eos_token_id,\n",
+    "        tokenizer.convert_tokens_to_ids(\"<|eot_id|>\")\n",
+    "    ]\n",
+    "\n",
+    "    outputs = gen_model.generate(\n",
+    "        input_ids,\n",
+    "        max_new_tokens=100,\n",
+    "        eos_token_id=terminators,\n",
+    "        do_sample=True,\n",
+    "        temperature=0.2,\n",
+    "        top_p=1\n",
+    "    )\n",
+    "\n",
+    "    response = outputs[0][input_ids.shape[-1]:]\n",
+    "    return tokenizer.decode(response, skip_special_tokens=True)"
+   ],
+   "metadata": {
+    "id": "R5D4K-P2sPaj"
+   },
+   "execution_count": null,
+   "outputs": []
+  },
+  {
+   "cell_type": "code",
+   "source": [
+    "text = \\\n",
+    "\"\"\"\n",
+    "Given a set of rules to calculate point, sort the set of words in decreasing order.\n",
+    "When there 2 or more words with same point, sort lexicographically.\n",
+    "\n",
+    "Rules:\n",
+    "- every pair of consecutive consonant gets 5 points\n",
+    "- every pair of consecutive vowel gets 3 points\n",
+    "- add 1 point if there exists exactly 1 'g' in the word\n",
+    "- word less than 5 characters gets 10 points\n",
+    "- word starts with gen gets 100 points\n",
+    "- word ends with ta gets -1000 point\n",
+    "\n",
+    "Words:\n",
+    "- genta\n",
+    "- winata\n",
+    "- hudi\n",
+    "- alham\n",
+    "- aji\n",
+    "- ruochen\n",
+    "\n",
+    "Print only the answer.\n",
+    "\"\"\"\n",
+    "\n",
+    "# Answer:\n",
+    "# - aji      10\n",
+    "# - hudi     10\n",
+    "# - ruochen   5  3\n",
+    "# - alham     5\n",
+    "# - genta     5  1  100 -1000\n",
+    "# - winata  -1000"
+   ],
+   "metadata": {
+    "id": "T_tk4hTGsxsR"
+   },
+   "execution_count": null,
+   "outputs": []
+  },
+  {
+   "cell_type": "code",
+   "source": [
+    "print(get_gemma_response(text))"
+   ],
+   "metadata": {
+    "id": "05OI36v6vGoY"
+   },
+   "execution_count": null,
+   "outputs": []
+  },
+  {
+   "cell_type": "code",
+   "source": [
+    "print(get_gemma_response(text))"
+   ],
+   "metadata": {
+    "id": "riwXqTc-tmNr"
+   },
+   "execution_count": null,
+   "outputs": []
+  },
+  {
+   "cell_type": "code",
+   "source": [],
+   "metadata": {
+    "id": "T72sUG4_vYUa"
+   },
+   "execution_count": null,
+   "outputs": []
+  }
+ ]
+}

environment.yml

@@ -0,0 +1,9 @@
+# conda env create -f <this_file>
+name: textgame
+channels:
+- conda-forge
+dependencies:
+- python=3.11
+- pip
+- pip:
+  - -r requirements.txt

gdrive_try.ipynb

@@ -0,0 +1 @@
+{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"provenance":[]},"kernelspec":{"name":"python3","display_name":"Python 3"},"language_info":{"name":"python"}},"cells":[{"cell_type":"code","source":["# %load_ext autoreload\n","# %autoreload 2"],"metadata":{"id":"mAaspsfqKYkA"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["# %load_ext gradio"],"metadata":{"id":"8fBrlr18CB3F"},"execution_count":null,"outputs":[]},{"cell_type":"code","execution_count":null,"metadata":{"id":"6l8QdIpAB5j_"},"outputs":[],"source":["# %%blocks\n","\n","# from play_gradio import demo"]},{"cell_type":"markdown","source":["---"],"metadata":{"id":"2KNPZna6wl7f"}},{"cell_type":"code","source":["# !pip install -U google-api-python-client google-auth-httplib2 google-auth-oauthlib"],"metadata":{"id":"ExtfLnlMprwD"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["import os.path\n","\n","from google.auth.transport.requests import Request\n","from google.oauth2.credentials import Credentials\n","from google_auth_oauthlib.flow import InstalledAppFlow\n","from googleapiclient.discovery import build\n","from googleapiclient.errors import HttpError"],"metadata":{"id":"ADy9dN7bo_TC"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["# If modifying these scopes, delete the file token.json.\n","SCOPES = [\"https://www.googleapis.com/auth/drive.metadata.readonly\"]"],"metadata":{"id":"-1BrLvGaWxZ2"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["def main():\n","  \"\"\"Shows basic usage of the Drive v3 API.\n","  Prints the names and ids of the first 10 files the user has access to.\n","  \"\"\"\n","  creds = None\n","  # The file token.json stores the user's access and refresh tokens, and is\n","  # created automatically when the authorization flow completes for the first\n","  # time.\n","  if os.path.exists(\"token.json\"):\n","    creds = Credentials.from_authorized_user_file(\"token.json\", SCOPES)\n","  # If there are no (valid) credentials available, let the user log in.\n","  if not creds or not creds.valid:\n","    if creds and creds.expired and creds.refresh_token:\n","      creds.refresh(Request())\n","    else:\n","      flow = InstalledAppFlow.from_client_secrets_file(\n","          \"credentials.json\", SCOPES\n","      )\n","      creds = flow.run_local_server(port=0)\n","    # Save the credentials for the next run\n","    with open(\"token.json\", \"w\") as token:\n","      token.write(creds.to_json())\n","\n","  try:\n","    service = build(\"drive\", \"v3\", credentials=creds)\n","\n","    # Call the Drive v3 API\n","    results = (\n","        service.files()\n","        .list(pageSize=10, fields=\"nextPageToken, files(id, name)\")\n","        .execute()\n","    )\n","    items = results.get(\"files\", [])\n","\n","    if not items:\n","      print(\"No files found.\")\n","      return\n","    print(\"Files:\")\n","    for item in items:\n","      print(f\"{item['name']} ({item['id']})\")\n","  except HttpError as error:\n","    # TODO(developer) - Handle errors from drive API.\n","    print(f\"An error occurred: {error}\")"],"metadata":{"id":"-qwFweRKqBZ0"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["main()"],"metadata":{"id":"x62A2GyFqH19"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["if __name__ == \"__main__\":\n","  main()"],"metadata":{"id":"6mwHQ-vFqF-y"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":[],"metadata":{"id":"xqVim7U8qBRn"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":[],"metadata":{"id":"KrIr5DqVwFPR"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["import google.auth\n","from googleapiclient.discovery import build\n","from googleapiclient.errors import HttpError\n","from googleapiclient.http import MediaFileUpload"],"metadata":{"id":"bKn3EWoHtIw3"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["creds, _ = google.auth.default()"],"metadata":{"id":"siH9BRzptIhS"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["creds"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"Bhz_xW99tLDS","executionInfo":{"status":"ok","timestamp":1736790633770,"user_tz":-540,"elapsed":8,"user":{"displayName":"Frederikus Hudi","userId":"06823040510862360282"}},"outputId":"3271b64c-82cd-466f-8321-b5d0ddc884d6"},"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":["<google.oauth2.service_account.Credentials at 0x108b81d90>"]},"metadata":{},"execution_count":3}]},{"cell_type":"code","source":["service = build(\"drive\", \"v3\", credentials=creds)"],"metadata":{"id":"Z3UPsS57tIaP"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["service"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"FhPuaL29ziYw","executionInfo":{"status":"ok","timestamp":1736791252169,"user_tz":-540,"elapsed":9,"user":{"displayName":"Frederikus Hudi","userId":"06823040510862360282"}},"outputId":"66e7a320-3133-4647-9a73-94b4f65ca898"},"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":["<googleapiclient.discovery.Resource at 0x108b8f550>"]},"metadata":{},"execution_count":11}]},{"cell_type":"code","source":["file_metadata = {\"name\": \"wow.txt\"}\n","media = MediaFileUpload(\"wow.txt\")"],"metadata":{"id":"sckvnGYtqBKw"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["media"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"xjvE-Mva03L0","executionInfo":{"status":"ok","timestamp":1736791259359,"user_tz":-540,"elapsed":9,"user":{"displayName":"Frederikus Hudi","userId":"06823040510862360282"}},"outputId":"5eac30fc-1da6-48c3-93ca-40e0174d1816"},"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":["<googleapiclient.http.MediaFileUpload at 0x108c223d0>"]},"metadata":{},"execution_count":12}]},{"cell_type":"code","source":["dir(media)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"qK-N7udo7u1i","executionInfo":{"status":"ok","timestamp":1736793093612,"user_tz":-540,"elapsed":27,"user":{"displayName":"Frederikus Hudi","userId":"06823040510862360282"}},"outputId":"a961fd11-4fae-4473-94ab-9bc775a6335e"},"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":["['__class__',\n"," '__del__',\n"," '__delattr__',\n"," '__dict__',\n"," '__dir__',\n"," '__doc__',\n"," '__eq__',\n"," '__format__',\n"," '__ge__',\n"," '__getattribute__',\n"," '__getstate__',\n"," '__gt__',\n"," '__hash__',\n"," '__init__',\n"," '__init_subclass__',\n"," '__le__',\n"," '__lt__',\n"," '__module__',\n"," '__ne__',\n"," '__new__',\n"," '__reduce__',\n"," '__reduce_ex__',\n"," '__repr__',\n"," '__setattr__',\n"," '__sizeof__',\n"," '__str__',\n"," '__subclasshook__',\n"," '__weakref__',\n"," '_chunksize',\n"," '_fd',\n"," '_filename',\n"," '_mimetype',\n"," '_resumable',\n"," '_size',\n"," '_to_json',\n"," 'chunksize',\n"," 'from_json',\n"," 'getbytes',\n"," 'has_stream',\n"," 'mimetype',\n"," 'new_from_json',\n"," 'resumable',\n"," 'size',\n"," 'stream',\n"," 'to_json']"]},"metadata":{},"execution_count":49}]},{"cell_type":"code","source":["f = (\n","        service.files()\n","        .create(body=file_metadata, media_body=media, fields=\"id\")\n","        .execute()\n","    )\n","print(f'File ID: {file.get(\"id\")}')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"HipJX087zir2","executionInfo":{"status":"ok","timestamp":1736792615979,"user_tz":-540,"elapsed":2189,"user":{"displayName":"Frederikus Hudi","userId":"06823040510862360282"}},"outputId":"19a11b14-cc18-455a-a4f1-d1a69f69c72f"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["File ID: 1Rnx0_wttlDG8XiyA_44yHBJeQBHvR_xh\n"]}]},{"cell_type":"code","source":["f.get(\"id\"), type(f)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"GoMMo7qX5-OH","executionInfo":{"status":"ok","timestamp":1736792629838,"user_tz":-540,"elapsed":10,"user":{"displayName":"Frederikus Hudi","userId":"06823040510862360282"}},"outputId":"ade9f343-a514-4e61-97f9-2550ed55223c"},"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":["('1rE4uYBWAQBFVVB6m7jGqAJncIohTJrWp', dict)"]},"metadata":{},"execution_count":22}]},{"cell_type":"code","source":["f = file.get(\"id\")"],"metadata":{"id":"usWmDGQjzijj"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["f"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"PFCzbG0v0nZ-","executionInfo":{"status":"ok","timestamp":1736791193891,"user_tz":-540,"elapsed":4,"user":{"displayName":"Frederikus Hudi","userId":"06823040510862360282"}},"outputId":"9c8456bd-9996-40a4-e3e6-1e3eb0aafbe9"},"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":["'1Rnx0_wttlDG8XiyA_44yHBJeQBHvR_xh'"]},"metadata":{},"execution_count":9}]},{"cell_type":"code","source":["files = service.files()"],"metadata":{"id":"oh18pUBj3Hn4"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["dir(service)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"LRsVc6pQ6c_1","executionInfo":{"status":"ok","timestamp":1736792725586,"user_tz":-540,"elapsed":4,"user":{"displayName":"Frederikus Hudi","userId":"06823040510862360282"}},"outputId":"c9ba40eb-f159-4f05-f5b1-53e5e81916da"},"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":["['__class__',\n"," '__delattr__',\n"," '__dict__',\n"," '__dir__',\n"," '__doc__',\n"," '__enter__',\n"," '__eq__',\n"," '__exit__',\n"," '__format__',\n"," '__ge__',\n"," '__getattribute__',\n"," '__getstate__',\n"," '__gt__',\n"," '__hash__',\n"," '__init__',\n"," '__init_subclass__',\n"," '__le__',\n"," '__lt__',\n"," '__module__',\n"," '__ne__',\n"," '__new__',\n"," '__reduce__',\n"," '__reduce_ex__',\n"," '__repr__',\n"," '__setattr__',\n"," '__setstate__',\n"," '__sizeof__',\n"," '__str__',\n"," '__subclasshook__',\n"," '__weakref__',\n"," '_add_basic_methods',\n"," '_add_nested_resources',\n"," '_add_next_methods',\n"," '_baseUrl',\n"," '_credentials_validated',\n"," '_developerKey',\n"," '_dynamic_attrs',\n"," '_http',\n"," '_model',\n"," '_requestBuilder',\n"," '_resourceDesc',\n"," '_rootDesc',\n"," '_schema',\n"," '_set_dynamic_attr',\n"," '_set_service_methods',\n"," '_universe_domain',\n"," '_validate_credentials',\n"," 'about',\n"," 'accessproposals',\n"," 'apps',\n"," 'changes',\n"," 'channels',\n"," 'close',\n"," 'comments',\n"," 'drives',\n"," 'files',\n"," 'new_batch_http_request',\n"," 'operation',\n"," 'operations',\n"," 'permissions',\n"," 'replies',\n"," 'revisions',\n"," 'teamdrives']"]},"metadata":{},"execution_count":31}]},{"cell_type":"code","source":["dir(service.files())"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"40nai28V7Q9B","executionInfo":{"status":"ok","timestamp":1736792941319,"user_tz":-540,"elapsed":14,"user":{"displayName":"Frederikus Hudi","userId":"06823040510862360282"}},"outputId":"4e9488bc-9370-44a3-c5cc-8d009630dc2c"},"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":["['__class__',\n"," '__delattr__',\n"," '__dict__',\n"," '__dir__',\n"," '__doc__',\n"," '__enter__',\n"," '__eq__',\n"," '__exit__',\n"," '__format__',\n"," '__ge__',\n"," '__getattribute__',\n"," '__getstate__',\n"," '__gt__',\n"," '__hash__',\n"," '__init__',\n"," '__init_subclass__',\n"," '__le__',\n"," '__lt__',\n"," '__module__',\n"," '__ne__',\n"," '__new__',\n"," '__reduce__',\n"," '__reduce_ex__',\n"," '__repr__',\n"," '__setattr__',\n"," '__setstate__',\n"," '__sizeof__',\n"," '__str__',\n"," '__subclasshook__',\n"," '__weakref__',\n"," '_add_basic_methods',\n"," '_add_nested_resources',\n"," '_add_next_methods',\n"," '_baseUrl',\n"," '_credentials_validated',\n"," '_developerKey',\n"," '_dynamic_attrs',\n"," '_http',\n"," '_model',\n"," '_requestBuilder',\n"," '_resourceDesc',\n"," '_rootDesc',\n"," '_schema',\n"," '_set_dynamic_attr',\n"," '_set_service_methods',\n"," '_universe_domain',\n"," '_validate_credentials',\n"," 'close',\n"," 'copy',\n"," 'create',\n"," 'delete',\n"," 'download',\n"," 'emptyTrash',\n"," 'export',\n"," 'export_media',\n"," 'generateIds',\n"," 'get',\n"," 'get_media',\n"," 'list',\n"," 'listLabels',\n"," 'listLabels_next',\n"," 'list_next',\n"," 'modifyLabels',\n"," 'update',\n"," 'watch']"]},"metadata":{},"execution_count":34}]},{"cell_type":"code","source":["files.delete(fileId=\"1Rnx0_wttlDG8XiyA_44yHBJeQBHvR_xh\").execute()"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"9zlanjZ96Yz9","executionInfo":{"status":"ok","timestamp":1736793000575,"user_tz":-540,"elapsed":896,"user":{"displayName":"Frederikus Hudi","userId":"06823040510862360282"}},"outputId":"d6ed9310-2efb-48d1-90e5-d5b0bd9536f6"},"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":["''"]},"metadata":{},"execution_count":40}]},{"cell_type":"code","source":["files.list().execute()"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"4guAyYqt7ehH","executionInfo":{"status":"ok","timestamp":1736793001570,"user_tz":-540,"elapsed":441,"user":{"displayName":"Frederikus Hudi","userId":"06823040510862360282"}},"outputId":"d96fe0c6-71b7-4bc3-8add-afbff7bbb054"},"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":["{'kind': 'drive#fileList',\n"," 'incompleteSearch': False,\n"," 'files': [{'kind': 'drive#file',\n","   'mimeType': 'application/vnd.google-apps.folder',\n","   'id': '1qStKuVerAQPsXagngfzlNg8PdAR5hupA',\n","   'name': 'afureteshimau'}]}"]},"metadata":{},"execution_count":41}]},{"cell_type":"code","source":["ret = (\n","    files\n","    .create(body=, media_body=media)\n","    .execute()\n",")"],"metadata":{"id":"qS4ithoH7lBq"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["results = (\n","        service.files()\n","        .list(pageSize=10, fields=\"nextPageToken, files(id, name)\")\n","        .execute()\n","    )"],"metadata":{"id":"DJQwlCAq1IDz"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["results.get(\"files\", [])"],"metadata":{"id":"kKSZI82R1J2s"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":[],"metadata":{"id":"qED1Eo_zKI4o"},"execution_count":null,"outputs":[]}]}

generate.py

@@ -0,0 +1,51 @@
+import os
+import random
+import numpy as np
+import torch
+import json
+
+from tqdm import tqdm
+from pathlib import Path
+from textgames import GAME_NAMES, LEVEL_IDS, new_game, game_filename
+
+
+def set_seed(seed):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed(seed)
+
+
+#generate()
+if __name__ == '__main__':
+    outdir = Path(os.getenv("TEXTGAMES_LOADGAME_DIR", "problemsets"))
+    # os.system(f"rm -rfd {outdir}")
+    os.makedirs(outdir, exist_ok=False)    # exists_ok is set to False, making sure regeneration.
+    set_seed(42)
+
+    # level_ids = LEVEL_IDS
+    level_ids = ["1", "2", "3"]
+    session_ids = [
+        f"session_{sid:04}" for sid in range(os.getenv("TEXTGAMES_GENERATE_N", 1000))
+    ]
+
+    count_duplicate = 0
+    for game_name in GAME_NAMES:
+        prompts_map = dict()
+        for level_id in level_ids:
+            os.environ["TEXTGAMES_NEWGAME_ERRFILE"] = f"{outdir}/{game_filename(game_name)}_{level_id}.err"
+            for sid in tqdm(session_ids, desc=f"{game_name}_{level_id}"):
+                while True:
+                    cur_game = new_game(game_name, level_id)
+                    prompt = cur_game._get_prompt()
+                    if prompt not in prompts_map:
+                        break
+                    count_duplicate += 1
+                prompts_map[prompt] = sid
+            print(f"[{game_name}_{level_id}]  Duplicate #: {count_duplicate:-4}")
+
+            json_object = json.dumps({sid: prompt for prompt, sid in prompts_map.items()}, indent=4)
+            with open(outdir / f"{game_filename(game_name)}_{level_id}.json", "w") as outfile:
+                outfile.write(json_object)
+
+    print(f"duplicates:{count_duplicate}")

oauth_environ_google.sh

@@ -0,0 +1 @@
+export $(cat oauth_environ_google.env | xargs)

play.py

@@ -0,0 +1,89 @@
+from termcolor import colored
+from textgames import GAME_IDS, GAME_NAMES, LEVEL_IDS, LEVELS, new_game, LEVELS_HIDDEN, SINGLE_LINE_GAME_IDS
+
+import os
+
+
+def print_text_green(string):
+    print(colored(string, "light_green"))
+
+def print_text_cyan(string):
+    print(colored(string, "cyan"))
+
+def print_text_white(string):
+    print(colored(string, "white"))
+
+
+if __name__ == "__main__":
+    print_text_green("#" * 20)
+    print_text_cyan("    Welcome to")
+    print("   🎮 " + colored("Text", "white")+ colored("Games", "yellow"))
+    print_text_green("#" * 20)
+    print_text_green("Games:")
+    for i, game_name in zip(range(len(GAME_NAMES)), GAME_NAMES):
+        print_text_green(f"{i+1}. {game_name}")
+    print_text_green("#" * 20)
+
+    cur_game_id = os.getenv("GAME_ID", None)
+    difficulty_level = os.getenv("GAME_LEVEL", None)
+    while cur_game_id is None:
+        user_input = str(input(f"Choose the game> "))
+
+        if user_input in GAME_IDS:
+            cur_game_id = user_input
+
+            print_text_green("#" * 20)
+            print_text_green("Difficulty Levels:")
+            for i, l in zip(LEVEL_IDS, LEVELS):
+                print_text_green(f"{i}. {l}")
+            print_text_green("#" * 20)
+
+            while difficulty_level is None:
+                user_input = str(input(f"Choose the difficulty level> "))
+                if user_input in LEVEL_IDS:
+                    difficulty_level = user_input
+                else:
+                    print("The difficulty level option is not available.")
+        else:
+            arr = user_input.split("-")
+            if len(arr) == 2 and isinstance(arr[0], str) and isinstance(arr[1], str):
+                if arr[0] in GAME_IDS and arr[1] in LEVEL_IDS:
+                    cur_game_id = arr[0]
+                    difficulty_level = arr[1]
+            else:
+                print("The game option is not available.")
+                cur_game = None
+
+    this_game_name = GAME_NAMES[GAME_IDS.index(cur_game_id)]
+    this_difficulty_level = (LEVELS + LEVELS_HIDDEN)[LEVEL_IDS.index(difficulty_level)].replace("\t", " ")
+    print_text_green(f"Game chosen: {this_game_name} and Difficulty Level: {this_difficulty_level}")
+
+    solved = False
+    cur_game = new_game(this_game_name, difficulty_level)
+    print(colored("########  Game Start !!  ########", "light_green"))
+    print(cur_game.get_prompt())
+    while not solved:
+        contents = []
+        while True:
+            try:
+                line = str(input("\t" if contents else f"Guess>\t"))
+                # automatic break for some games:
+                if cur_game_id in SINGLE_LINE_GAME_IDS:
+                    contents.append(line)
+                    break
+                if len(line) == 0:
+                    break
+            except EOFError:
+                break
+            contents.append(line)
+
+        user_input = '\n'.join(contents)
+        solved, val_msg = cur_game.validate(user_input)
+        if val_msg:
+            print(val_msg)
+        print(f"Attempt #{len(cur_game.attempt_timestamps)}:", "Correct guess" if solved else "Bad guess", end="\n\n")
+
+    print(f"Time to solve: {round(cur_game.attempt_timestamps[-1] - cur_game.start_timestamp, 1)}s")
+    print("Thank you for playing!")
+            
+

play.sh

@@ -0,0 +1,3 @@
+cur_datetime="$(date '+%Y%m%d_%H%M%S')";
+echo "Current Time: ${cur_datetime}";
+python -u play_gradio.py  |  tee "log/run_${cur_datetime}.log"

play_gradio.py

@@ -0,0 +1,77 @@
+#%%
+import os
+# os.environ.setdefault("GRADIO_SERVER_PORT", "1080")
+# os.environ.setdefault("TEXTGAMES_SHOW_HIDDEN_LEVEL", "1")
+os.environ.setdefault("TEXTGAMES_LOADGAME_DIR", "problemsets")
+os.environ.setdefault("TEXTGAMES_LOADGAME_ID", "42")
+os.environ.setdefault("TEXTGAMES_MOCKUSER", "")
+os.environ.setdefault("TEXTGAMES_OUTPUT_DIR", "user_outputs")
+favicon_path = "textgames-scrabble-black2-ss.png"
+
+#%%
+from play_helper import css, declare_components, start_new_game, download_from_drive
+import pandas as pd
+import gradio as gr
+
+
+#%%
+fp_user_auth = f"{os.getenv('TEXTGAMES_OUTPUT_DIR')}/textgames_userauth.tsv"
+# fp_user_auth_id = "13RLyxV3ys5DGgRIJt5_tO-ILllJ1LDPGasobagZyVLU"
+fp_user_auth_mime_type = "text/tab-separated-values"
+
+
+#%%
+def file_based_auth(username, password):
+    if os.getenv('TEXTGAMES_MOCKUSER', ''):
+        return True
+    download_from_drive(fp_user_auth, mime_type=fp_user_auth_mime_type)
+    df_auth = pd.read_csv(fp_user_auth, sep="\t").dropna(how="any")
+    return len(df_auth.loc[(df_auth.EMAIL == username) & (df_auth.PASSWORD == password)]) > 0
+
+
+#%%
+def greet(request: gr.Request):
+    email = os.getenv('TEXTGAMES_MOCKUSER', '')
+    if email:
+        user = {'email': email, 'name': "mockuser"}
+    else:
+        df_auth = pd.read_csv(fp_user_auth, sep="\t").dropna(how="any").drop_duplicates(subset=['EMAIL'])
+        r = df_auth.loc[df_auth.EMAIL == request.username].iloc[0]
+        user = {'email': r.EMAIL, 'name': r.NAME}
+    return f"""
+        Welcome to TextGames, {user['name']}!<br/><{user['email'].replace('@', '{at}')}>
+    """, user, user['email']
+
+    # return f"""
+    #     Welcome to TextGames, {user['name']}!<br />
+    #     <{user['email'].replace('@', '{at}')}> ({'' if user['email_verified'] else 'NON-'}verified email)
+    # """, None, None
+
+
+#%%
+with gr.Blocks(title="TextGames", css=css, delete_cache=(3600, 3600)) as demo:
+    ((m, logout_btn, solved_games_df, game_radio, level_radio, new_game_btn, render_toggle),
+     (session_state, is_solved, solved_games, user_state, uid_state),
+     ) = declare_components(demo, greet)
+
+    @gr.render(inputs=[game_radio, level_radio, user_state, session_state, uid_state], triggers=[render_toggle.change])
+    def _start_new_game(game_name, level, user, _session_state, _uid_state):
+        if _session_state in [1, 2]:
+            start_new_game(game_name, level, session_state, is_solved, solved_games, user=user, uid=_uid_state)
+
+demo.launch(
+    auth=file_based_auth,
+    favicon_path=favicon_path if os.path.exists(favicon_path) else None,
+    share=True,
+)
+
+
+#%%
+
+
+#%%
+
+
+#%%
+
+

play_helper.py

@@ -3,11 +3,8 @@ import os
 import time
 import pandas as pd
 import gradio as gr
-
-import google.auth
-from googleapiclient.discovery import build
-from googleapiclient.errors import HttpError
-from googleapiclient.http import MediaFileUpload
+import hashlib
+from io import BytesIO
 
 from textgames import GAME_NAMES, LEVEL_IDS, LEVELS, new_game, preload_game, game_filename
 from textgames.islands.islands import Islands
@@ -17,7 +14,14 @@ from textgames.ordering_text.ordering_text import OrderingTextGame
 
 
 # %%
-def declare_components():
+import google.auth
+from googleapiclient.discovery import build
+from googleapiclient.errors import HttpError
+from googleapiclient.http import MediaFileUpload, MediaIoBaseDownload
+
+
+# %%
+def declare_components(demo, greet):
     with gr.Row():
         with gr.Column(scale=1):
             m = gr.Markdown("Welcome to TextGames!", elem_id="md-greeting")
@@ -29,10 +33,44 @@ def declare_components():
     level_radio = gr.Radio(LEVELS, label="Level", elem_id="radio-level-name")
     new_game_btn = gr.Button("Start Game", elem_id="btn-start-game")
     render_toggle = gr.Checkbox(False, visible=False, interactive=False)
-    return m, logout_btn, solved_games_df, game_radio, level_radio, new_game_btn, render_toggle
+
+    # cur_game_start = gr.BrowserState()
+    session_state = gr.State(0)    # 0: menu selection, 1: game is ongoing, 2: game is solved.
+    is_solved = gr.State(0)
+    solved_games = gr.State({g: [] for _, g in game_radio.choices})
+    user_state = gr.State()
+    uid_state = gr.State()
+
+    session_state.change(
+        lambda s: session_state_change_fn(s, 2, 0, 2, 0),
+        [session_state], [game_radio, level_radio, new_game_btn, logout_btn], js=js_remove_input_helper,
+    )
+    new_game_btn.click(check_to_start_new_game, [game_radio, level_radio, user_state, uid_state], [session_state])
+    solved_games.change(solved_games_change_fn, solved_games, solved_games_df)
+    session_state.change(lambda s, r: (not r if s in [0, 1] else r), [session_state, render_toggle], [render_toggle])
+
+    demo.load(
+        greet, None, [m, user_state, uid_state], js=js_solved_games_df_and_remove_footers
+    ).then(
+        lambda: gr.update(interactive=False), None, [new_game_btn],
+    ).then(
+        check_played_game, [solved_games, uid_state], [solved_games, solved_games_df]
+    ).then(
+        lambda: gr.update(interactive=True), None, [new_game_btn],
+    )
+
+    return (
+        (m, logout_btn, solved_games_df, game_radio, level_radio, new_game_btn, render_toggle),
+        (session_state, is_solved, solved_games, user_state, uid_state),
+    )
 
 
 # %%
+_cksm_methods, _cksm_methods_str = (
+    [hashlib.md5, hashlib.sha1], "md5Checksum, sha1Checksum",
+    # [hashlib.md5, hashlib.sha1, hashlib.sha256], "md5Checksum, sha1Checksum, sha256Checksum",
+)
+_folder_id = "1qStKuVerAQPsXagngfzlNg8PdAR5hupA"
 _creds_dict = {
   "type": "service_account",
   "project_id": os.getenv("GOOGLE_AUTH_CREDS_PROJECT_ID", ""),
@@ -51,6 +89,14 @@ _service = build("drive", "v3", credentials=_creds)
 _files = _service.files()
 
 
+#%%
+css = """
+#lintao-helper-btn {background: darkgreen; color: white;}
+.lintao-cell-highlight {background: var(--border-color-primary);}
+//.lintao-border {border-style: solid; border-color: var(--body-text-color-subdued);}
+"""
+
+
 # %%
 js_remove_input_helper = """(s) => {
         var el = document.getElementById('lintao-container');
@@ -84,9 +130,10 @@ function island() {{
     container.style.display = 'grid';
     container.style.gridTemplateColumns = container.style.gridTemplateRows = `repeat(${{grid_N}}, ${{grid_px}}px)`;
     container.style.gap = '1px';
-    container.style.border = '2px solid black';
+    container.style.border = '2px solid';
     container.style.width = 'max-content';
     container.style.margin = '5px 0px 5px 40px';
+    container.style.padding = '1px';
     container.id = 'lintao-container';
 
     for (let i = 0; i < grid_N; ++i) {{
@@ -98,7 +145,7 @@ function island() {{
             cell.style.alignItems = 'center';
             cell.style.justifyContent = 'center';
             cell.style.fontSize = `${{grid_px/2}}px`;
-            cell.style.border = '1px solid gray';
+            cell.style.border = '1px solid var(--body-text-color-subdued)';
             cell.style.cursor = 'pointer';
             cell.id = `lintao-cell-${{i}}-${{j}}`;
 
@@ -130,6 +177,8 @@ function island() {{
 
 js_island_submit = """
 function island_submit(textarea, io_history) {{
+    const container = document.getElementById("lintao-container")
+    if (container === null) return [textarea, io_history];
     const grid_N = {N};
     var ret = "";
     for (let i = 0; i < grid_N; ++i) {{
@@ -149,7 +198,7 @@ function sudoku() {{
     const N = {N};
     const grid_N = N*N,
           grid_px = 50,
-          border_px = 3;
+          border_px = 2;
     const mat = {mat};
 
     let is_numeric_sudoku = false;
@@ -165,16 +214,17 @@ function sudoku() {{
     const container = document.createElement('div');
     container.style.display = 'grid';
     container.style.gridTemplateColumns = container.style.gridTemplateRows = `repeat(${{grid_N}}, ${{grid_px}}px)`;
-    container.style.gap = '1px';
-    container.style.border = '${{border_px}}px solid white';
+    container.style.border = `${{border_px}}px solid`;
     container.style.width = 'max-content';
     container.style.margin = '5px 0px 5px 40px';
+    container.style.padding = '0px';
     container.id = 'lintao-container';
 
     // Generate the grid
+    const highlightClass = 'lintao-cell-highlight';
     for (let i = 0; i < grid_N; ++i) {{
         for (let j = 0; j < grid_N; ++j) {{
-            const cell = document.createElement('input');
+            const cell = document.createElement('div');
             cell.type = 'text';
             cell.maxLength = 1;
             cell.style.width = cell.style.height = `${{grid_px}}px`;
@@ -183,32 +233,35 @@ function sudoku() {{
             cell.style.justifyContent = 'center';
             cell.style.textAlign = 'center';
             cell.style.fontSize = `${{grid_px/2}}px`;
-            cell.style.border = '1px solid #c0c0c0';
-            cell.style.backgroundColor = 'black'
-            cell.style.cursor = 'pointer';
+            cell.style.border = '1px solid var(--body-text-color-subdued)';
+            cell.style.margin = '0px';
+            //cell.style.outline = 'none';
+            //cell.style.color = 'var(--body-text-color)';
+            //cell.style.backgroundColor = 'black';
             cell.id = `lintao-cell-${{i}}-${{j}}`;
 
             if (mat[i][j] != '_') {{
-                cell.value = mat[i][j];
-                cell.style.color = '#D0D0D0'
+                cell.textContent = mat[i][j];
+                cell.style.color = 'var(--block-title-text-color)';
                 cell.disabled = true;
+            }} else {{
+                cell.style.cursor = 'pointer';
+                cell.contentEditable = "true";
             }}
 
-            //cell.style.color = 'black';
-            //cell.style.outline = 'none';
 
-            if (j % N === 0) cell.style.borderLeft = `${{border_px}}px solid white`;
-            if (j % N === (N-1)) cell.style.borderRight = `${{border_px}}px solid white`;
-            if (i % N === 0) cell.style.borderTop = `${{border_px}}px solid white`;
-            if (i % N === (N-1)) cell.style.borderBottom = `${{border_px}}px solid white`;
+            if (j % N === 0) cell.style.borderLeft = `${{border_px}}px solid var(--body-text-color)`;
+            if (j % N === (N-1)) cell.style.borderRight = `${{border_px}}px solid var(--body-text-color)`;
+            if (i % N === 0) cell.style.borderTop = `${{border_px}}px solid var(--body-text-color)`;
+            if (i % N === (N-1)) cell.style.borderBottom = `${{border_px}}px solid var(--body-text-color)`;
 
             // Allow only numbers 1-9 or A-I
             cell.addEventListener('input', (e) => {{
-                if ((N === 2  &&  (!(is_numeric_sudoku?/^[1-4]$/:/^[A-Da-d]$/).test(e.target.value))) || 
-                    (N === 3  &&  (!(is_numeric_sudoku?/^[1-9]$/:/^[A-Ia-i]$/).test(e.target.value)))) {{
-                    e.target.value = '';
+                if ((N === 2  &&  (!(is_numeric_sudoku?/^[1-4]$/:/^[A-Da-d]$/).test(e.target.textContent))) || 
+                    (N === 3  &&  (!(is_numeric_sudoku?/^[1-9]$/:/^[A-Ia-i]$/).test(e.target.textContent)))) {{
+                    e.target.textContent = '';
                 }}
-                e.target.value = e.target.value.toUpperCase();
+                e.target.textContent = e.target.textContent.toUpperCase();
             }});
 
             container.appendChild(cell);
@@ -228,16 +281,16 @@ function sudoku() {{
             const currentCol = i % grid_N;
 
             if (currentRow === row || currentCol === col || (Math.floor(currentRow / N) === Math.floor(row / N) && Math.floor(currentCol / N) === Math.floor(col / N))) {{
-                cell.style.backgroundColor = '#303039';
+                cell.classList.add(highlightClass);
             }} else {{
-                cell.style.backgroundColor = 'black';
+                cell.classList.remove(highlightClass);
             }}
         }}
     }});
 
     container.addEventListener('focusout', () => {{
         for (let i = 0; i < grid_N * grid_N; i++) {{
-            container.children[i].style.backgroundColor = 'black';
+            container.children[i].classList.remove(highlightClass);
         }}
     }});
 
@@ -248,13 +301,15 @@ function sudoku() {{
 
 js_sudoku_submit = """
 function sudoku_submit(textarea, io_history) {{
+    const container = document.getElementById("lintao-container")
+    if (container === null) return [textarea, io_history];
     const N = {N};
     const grid_N = N*N;
     var ret = "";
     for (let i = 0; i < grid_N; ++i) {{
         if (i > 0) ret += '\\n';
         for (let j = 0; j < grid_N; ++j) {{
-            ret += document.getElementById(`lintao-cell-${{i}}-${{j}}`).value;
+            ret += document.getElementById(`lintao-cell-${{i}}-${{j}}`).textContent;
         }}
     }}
     return [ret, io_history];
@@ -272,9 +327,10 @@ function crossword() {{
     container.style.display = 'grid';
     container.style.gridTemplateColumns = container.style.gridTemplateRows = `repeat(${{grid_N}}, ${{grid_px}}px)`;
     container.style.gap = '1px';
-    container.style.border = '2px solid white';
+    container.style.border = '2px solid';
     container.style.width = 'max-content';
     container.style.margin = '5px 0px 5px 40px';
+    container.style.padding = '1px';
     container.id = 'lintao-container';
 
     // Generate the grid
@@ -290,8 +346,8 @@ function crossword() {{
             cell.style.justifyContent = 'center';
             cell.style.textAlign = 'center';
             cell.style.fontSize = `${{grid_px/2}}px`;
-            cell.style.border = '1px solid #c0c0c0';
-            cell.style.backgroundColor = 'black'
+            cell.style.border = '1px solid var(--body-text-color-subdued)';
+            cell.style.backgroundColor = 'var(--body-background-fill)';
             cell.style.cursor = 'pointer';
             cell.id = `lintao-cell-${{i}}-${{j}}`;
 
@@ -313,6 +369,8 @@ function crossword() {{
 
 js_crossword_submit = """
 function crossword_submit(textarea, io_history) {{
+    const container = document.getElementById("lintao-container")
+    if (container === null) return [textarea, io_history];
     const grid_N = {N};
     var ret = "";
     for (let i = 0; i < grid_N; ++i) {{
@@ -333,7 +391,7 @@ function ordering() {{
     listContainer.style.listStyle = 'none';
     listContainer.style.padding = '0';
     listContainer.style.width = '20em';
-    listContainer.style.border = '2px solid white';
+    listContainer.style.border = '2px solid';
     listContainer.style.margin = '5px 0px 5px 40px';
     listContainer.id = 'lintao-container';
 
@@ -346,9 +404,9 @@ function ordering() {{
         listItem.textContent = itemText;
         listItem.draggable = true;
         listItem.style.padding = '10px';
-        listItem.style.border = '1px solid #c0c0c0';
+        listItem.style.border = '1px solid';
         listItem.style.margin = '3px';
-        listItem.style.backgroundColor = 'black';
+        //listItem.style.backgroundColor = 'var(--body-background-fill)';
         listItem.style.cursor = 'grab';
         listItem.id = `lintao-item-${{index}}`;
 
@@ -356,16 +414,16 @@ function ordering() {{
         listItem.addEventListener('dragstart', (e) => {{
             const draggedIndex = Array.from(listContainer.children).indexOf(listItem);
             e.dataTransfer.setData('text/plain', draggedIndex);
-            listItem.style.backgroundColor = '#1f1811';
+            listItem.style.backgroundColor = 'var(--block-background-fill)';
         }});
 
         listItem.addEventListener('dragover', (e) => {{
             e.preventDefault();
-            listItem.style.backgroundColor = '#303030';
+            listItem.style.backgroundColor = 'var(--border-color-primary)';
         }});
 
         listItem.addEventListener('dragleave', () => {{
-            listItem.style.backgroundColor = 'black';
+            listItem.style.backgroundColor = 'var(--body-background-fill)';
         }});
 
         listItem.addEventListener('drop', (e) => {{
@@ -379,11 +437,11 @@ function ordering() {{
                 listContainer.insertBefore(draggedItem, targetIndex > draggedIndex ? listItem.nextSibling : listItem);
             }}
 
-            listItem.style.backgroundColor = 'black';
+            listItem.style.backgroundColor = 'var(--body-background-fill)';
         }});
 
         listItem.addEventListener('dragend', () => {{
-            listItem.style.backgroundColor = 'black';
+            listItem.style.backgroundColor = 'var(--body-background-fill)';
         }});
 
         listContainer.appendChild(listItem);
@@ -396,9 +454,10 @@ function ordering() {{
 
 js_ordering_submit = """
 function ordering_submit(textarea, io_history) {{
+    const container = document.getElementById("lintao-container")
+    if (container === null) return [textarea, io_history];
     var ret = "";
-    const container = 
-    document.getElementById("lintao-container").childNodes.forEach(
+    container.childNodes.forEach(
         (c, i) => {{
             if (i>0) ret += '\\n';
             ret += c.textContent;
@@ -424,6 +483,68 @@ def _get_file_output(game_name, level_id, fn_prefix):
     return f"{fd}/{fn_prefix}_-_{game_filename(game_name)}_{level_id}.pkl"
 
 
+# %%
+def _is_checksum_same(fp_out, matches=None, mime_type="application/octet-stream"):
+    if matches is None:
+        matches = _files.list(
+            q=f"'{_folder_id}' in parents and mimeType='{mime_type}' and name = '{fp_out.rsplit('/', 1)[-1]}'",
+            fields=f"files(name, id, {_cksm_methods_str})",
+        ).execute()['files']
+    if not os.path.exists(fp_out):
+        return None, None, matches
+    with open(fp_out, "rb") as o:
+        _local = BytesIO(o.read()).getvalue()
+    _local_hash = [m(_local).hexdigest() for m in _cksm_methods]
+    for i, match in enumerate(matches):
+        if all(a == b for a, b in zip(_local_hash, [match[k] for k in _cksm_methods_str.split(", ")])):
+            return True, i, matches
+    return False, -1, matches
+
+
+# %%
+def upload_to_drive(fp_out, matches=None, mime_type="application/octet-stream", compare_checksum=True):
+    if compare_checksum:
+        same_checksum, _, _ = _is_checksum_same(fp_out, matches, mime_type)
+        # same_checksum, _, _ = _is_checksum_same(
+        #     fp_out, **{k: v for k, v in [('matches', matches), ('mime_type', mime_type)] if v})
+        if same_checksum:
+            return
+    fn = fp_out.rsplit("/", 1)[-1]
+    file_metadata = {"name": fn, "parents": [_folder_id]}
+    media = MediaFileUpload(fp_out)
+    try:
+        _files.create(body=file_metadata, media_body=media).execute()
+    except HttpError as error:
+        msg = f"Failed to upload the file, error: {error}"
+        print(msg)
+        gr.Error(msg)
+
+
+# %%
+def download_from_drive(fp_out, matches=None, mime_type="application/octet-stream", compare_checksum=True):
+    if compare_checksum and os.path.exists(fp_out):
+        same_checksum, i, matches = _is_checksum_same(fp_out, matches, mime_type)
+        if same_checksum:
+            return
+    if matches is None:
+        _, _, matches = _is_checksum_same(fp_out, matches, mime_type)
+    if len(matches) == 0:
+        return
+    else:
+        if len(matches) > 1:
+            gr.Warning(f"Multiple matches found! {fp_out.rsplit('/', 1)[-1].split('_-_', 1)[-1]}")
+        b_io, request = BytesIO(), _files.get_media(fileId=matches[0]['id'])
+        downloader = MediaIoBaseDownload(b_io, request)
+        if os.path.exists(fp_out):
+            print(f"Deleting and re-download... ({fp_out})")
+            os.remove(fp_out)
+        done = False
+        while not done:
+            status, done = downloader.next_chunk()
+            with open(fp_out, "ab") as o:
+                o.write(b_io.getvalue())
+
+
 # %%
 def start_new_game(game_name, level, session_state_component, is_solved_component, solved_games_component,
                    user=None, show_timer=False, uid=None):
@@ -441,9 +562,12 @@ def start_new_game(game_name, level, session_state_component, is_solved_componen
         preload_game(game_name, difficulty_level, user)
     )
     cur_game.attach_stats_output_(fp_out)
-    cur_game.flush_stats_(user=user)
+    cur_game.flush_stats_(user_info_to_flush=user)
 
     def add_msg(new_msg, prev_msg):
+        if len(new_msg) > 200:
+            new_msg = new_msg[:200]
+            gr.Warning("your input is too long! It has been truncated.")
         user_input = '\n'.join(new_msg.split())
         solved, val_msg = cur_game.validate(user_input)
         response = ("Correct guess" if solved else "Bad guess (Wrong Answer)") + "\n" + val_msg
@@ -455,10 +579,8 @@ def start_new_game(game_name, level, session_state_component, is_solved_componen
 
     gr.Markdown(
         """
-        > ### ‼️ Do ***NOT*** refresh this page. ‼️<br>
+        > ### ‼️ Do ***<span style="color:red">NOT</span>*** refresh this page. ‼️<br>
         > #### ⚠️ Refreshing the page equals "Give-up 😭" ⚠️
-        
-        
         """
     )
     showhide_helper_btn = gr.Button("Show Input Helper (disabling manual input)", elem_id="lintao-helper-btn")
@@ -500,48 +622,52 @@ def start_new_game(game_name, level, session_state_component, is_solved_componen
 
     def _forfeiting(confirmed, _solved_games):
         if confirmed:
+            gr.Info("Sad to see you go... Wrapping things up...")
             cur_game.finish_stats_(forfeit=True)
-            if level in LEVELS[1:4] and level not in _solved_games[game_name]:
+            if level in LEVELS and level not in _solved_games[game_name]:
                 _solved_games[game_name].append(level)
+            upload_to_drive(fp_out)
             return 0, _solved_games
         return 1, _solved_games
-    give_up_checkbox.change(_forfeiting, [give_up_checkbox, solved_games_component],
-                            [session_state_component, solved_games_component])
+    give_up_checkbox.change(
+        lambda: (gr.update(interactive=False), gr.update(interactive=False)), None, [submit_btn, give_up_btn]
+    ).then(
+        _forfeiting, [give_up_checkbox, solved_games_component], [session_state_component, solved_games_component]
+    ).then(
+        lambda: (gr.update(interactive=True), gr.update(interactive=True)), None, [submit_btn, give_up_btn]
+    )
 
-    def game_is_solved(_is_solved, _session_state, _solved_games):
+    def game_is_solved(_is_solved, _session_state, _solved_games, progress=gr.Progress()):
         if _is_solved:
-            if level in LEVELS[1:4] and level not in _solved_games[game_name]:
+            if level in LEVELS and level not in _solved_games[game_name]:
                 _solved_games[game_name].append(level)
             return (
                 2,
                 gr.update(visible=False, interactive=False),
                 gr.update(visible=False, interactive=False),
-                gr.update(visible=True, interactive=True),
                 _solved_games,
+                gr.update(visible=True, interactive=False),
             )
         else:
             return (
-                _session_state, gr.update(), gr.update(), gr.update(), _solved_games
+                _session_state, gr.update(), gr.update(), _solved_games, gr.update()
             )
 
-    def upload_to_drive():
-        fn = fp_out.rsplit("/", 1)[-1]
-        file_metadata = {"name": fn, "parents": ["1qStKuVerAQPsXagngfzlNg8PdAR5hupA"]}
-        media = MediaFileUpload(fp_out)
-        # print(f"{file_metadata}\n{fn}")
-        try:
-            _files.create(body=file_metadata, media_body=media).execute()
-        except HttpError as error:
-            print(f"An error occurred: {error}")
+    def finalize_game(_is_solved):
+        if _is_solved:
+            gr.Info("Reporting... Please click the button when available...")
+            upload_to_drive(fp_out)
+            return gr.update(interactive=True)
+        return gr.update()
 
     is_solved_component.change(
         game_is_solved,
         [is_solved_component, session_state_component, solved_games_component],
-        [session_state_component, submit_btn, give_up_btn, finish_btn, solved_games_component],
+        [session_state_component, submit_btn, give_up_btn, solved_games_component, finish_btn],
+    ).then(
+        finalize_game, [is_solved_component], [finish_btn],
     )
     finish_btn.click(
-        upload_to_drive, None, None,
-    ).then(
         lambda: (0, 0), None, [session_state_component, is_solved_component]
     )
 
@@ -556,24 +682,34 @@ def check_to_start_new_game(game_name, level, user=None, uid=None):
         raise gr.Error(f"You have done this game already.<br/>{game_name} - {level}")
     if user is None:
         gr.Warning("no user, game will be generated randomly")
-    else:
-        if not user['email_verified']:
-            gr.Warning("please verify your email address")
-        elif user['email_verified'] == "mockuser":
-            gr.Info("game will load with a mocked-up user")
+    # else:
+    #     if not user['email_verified']:
+    #         gr.Warning("please verify your email address")
+    #     elif user['email_verified'] == "mockuser":
+    #         gr.Info("game will load with a mocked-up user")
     return 1
 
 
 # %%
-def check_played_game(solved_games, uid):
+def check_played_game(solved_games, uid, progress=gr.Progress()):
+    matches = _files.list(
+        q=f"'{_folder_id}' in parents and mimeType='application/octet-stream' and name contains '{uid}_-_'",
+        fields=f"files(name, id, {_cksm_methods_str})",
+    ).execute()['files']
     ret = dict()
     for game_name in solved_games.keys():
         cur = []
-        for level, level_id in zip(LEVELS[1:4], LEVEL_IDS[1:4]):
-            if os.path.exists(_get_file_output(game_name, level_id, uid)):
+        for level, level_id in zip(LEVELS, LEVEL_IDS):
+            fp_out = _get_file_output(game_name, level_id, uid)
+            _matches = list(filter(lambda m: fp_out.endswith(m['name']), matches))
+            if os.path.exists(fp_out):
+                upload_to_drive(fp_out, _matches)
+            else:
+                download_from_drive(fp_out, _matches)
+            if os.path.exists(fp_out):
                 cur.append(level)
         ret[game_name] = cur
-    return ret
+    return ret, gr.update()
 
 
 # %%

play_with_auth.py

@@ -0,0 +1,158 @@
+import os
+
+# os.environ.setdefault("GRADIO_SERVER_PORT", "1080")
+# os.environ.setdefault("TEXTGAMES_SHOW_HIDDEN_LEVEL", "1")
+os.environ.setdefault("TEXTGAMES_LOADGAME_DIR", "problemsets")
+os.environ.setdefault("TEXTGAMES_LOADGAME_ID", "42")
+os.environ.setdefault("TEXTGAMES_MOCKUSER", "")
+os.environ.setdefault("TEXTGAMES_OUTPUT_DIR", "user_outputs")
+os.environ.setdefault("TEXTGAMES_HASH_USER", "")
+favicon_path = "textgames-scrabble-black2-ss.png"
+
+#%%
+from play_helper import css, declare_components, start_new_game
+from typing import Optional
+import gradio as gr
+import hashlib
+
+
+#%%
+import uvicorn
+from fastapi import FastAPI, Depends, Request
+from starlette.config import Config
+from starlette.responses import RedirectResponse, FileResponse
+from starlette.middleware.sessions import SessionMiddleware
+from authlib.integrations.starlette_client import OAuth, OAuthError
+
+app = FastAPI()
+
+# Replace these with your own OAuth settings
+GOOGLE_CLIENT_ID = os.environ.get("GOOGLE_CLIENT_ID")
+GOOGLE_CLIENT_SECRET = os.environ.get("GOOGLE_CLIENT_SECRET")
+SECRET_KEY = os.environ.get("SECRET_KEY", "a_very_secret_key")
+
+# Set up OAuth
+config_data = {'GOOGLE_CLIENT_ID': GOOGLE_CLIENT_ID, 'GOOGLE_CLIENT_SECRET': GOOGLE_CLIENT_SECRET}
+starlette_config = Config(environ=config_data)
+oauth = OAuth(starlette_config)
+oauth.register(
+    name='google',
+    server_metadata_url='https://accounts.google.com/.well-known/openid-configuration',
+    client_kwargs={'scope': 'openid email profile'},
+)
+
+app.add_middleware(SessionMiddleware, secret_key=SECRET_KEY)
+
+_HASHER = (hashlib.blake2b, {"digest_size": 16, "key": SECRET_KEY.encode('utf-8')})
+
+
+def _hash_msg(msg):
+    if isinstance(msg, str):
+        msg = msg.encode('utf-8')
+    m = _HASHER[0](**_HASHER[1])
+    m.update(msg)
+    return m.hexdigest()
+
+
+# Dependency to get the current user
+def get_user(request: Request) -> Optional[dict]:
+    if user := request.session.get('user'):
+        return user
+    elif username := os.getenv("TEXTGAMES_MOCKUSER", ""):
+        return {'name': username, 'email': username, 'email_verified': False}
+    else:
+        return
+
+
+def get_username(request: Request):
+    user = get_user(request)
+    if user:
+        return user['email']
+    return None
+
+
+@app.get('/favicon.ico', include_in_schema=False)
+async def favicon():
+    return FileResponse(favicon_path)
+
+
+@app.get('/')
+def public(user: str = Depends(get_username)):
+    if user:
+        return RedirectResponse(url='/TextGames')
+    else:
+        return RedirectResponse(url='/login')
+
+
+@app.route('/logout')
+async def logout(request: Request):
+    request.session.pop('user', None)
+    if os.getenv('TEXTGAMES_MOCKUSER', ''):
+        os.environ['TEXTGAMES_MOCKUSER'] = ''
+    return RedirectResponse(url='/')
+
+
+@app.route('/do-login')
+async def login(request: Request):
+    redirect_uri = request.url_for('auth')
+    # If your app is running on https, you should ensure that the
+    # `redirect_uri` is https, e.g. uncomment the following lines:
+
+    from urllib.parse import urlparse, urlunparse
+    redirect_uri = urlunparse(urlparse(str(redirect_uri))._replace(scheme='https'))
+    return await oauth.google.authorize_redirect(request, redirect_uri)
+
+
+@app.route('/auth')
+async def auth(request: Request):
+    try:
+        access_token = await oauth.google.authorize_access_token(request)
+    except OAuthError:
+        return RedirectResponse(url='/')
+    request.session['user'] = dict(access_token)["userinfo"]
+    return RedirectResponse(url='/')
+
+
+def greet(request: gr.Request):
+    user = get_user(request.request)
+    uid = _hash_msg(user['email']) if os.getenv("TEXTGAMES_HASH_USER", "") else user['email']
+    return f"""
+        Welcome to TextGames, {user['name']}!<br />
+        <{user['email'].replace('@', '{at}')}> ({'' if user['email_verified'] else 'NON-'}verified email)
+    """, user, uid
+
+
+with gr.Blocks(title="TextGames") as login_demo:
+    gr.Markdown("Welcome to TextGames!")
+    # gr.Button("Login", link="/do-login")
+    gr.Button("🚪\tLogin", link="/do-login", icon=None)
+
+app = gr.mount_gradio_app(app, login_demo, path="/login")
+
+with gr.Blocks(title="TextGames", css=css, delete_cache=(3600, 3600)) as demo:
+    ((m, logout_btn, solved_games_df, game_radio, level_radio, new_game_btn, render_toggle),
+     (session_state, is_solved, solved_games, user_state, uid_state),
+     ) = declare_components(demo, greet)
+
+    @gr.render(inputs=[game_radio, level_radio, user_state, session_state, uid_state], triggers=[render_toggle.change])
+    def _start_new_game(game_name, level, user, _session_state, _uid_state):
+        if _session_state in [1, 2]:
+            start_new_game(game_name, level, session_state, is_solved, solved_games, user=user, uid=_uid_state)
+
+
+app = gr.mount_gradio_app(app, demo, path="/TextGames", auth_dependency=get_username)
+
+if __name__ == '__main__':
+    uvicorn.run(app,
+                port=int(os.getenv("GRADIO_SERVER_PORT", "7860")),
+                host=os.getenv("UVICORN_SERVER_HOST", "127.0.0.1"),
+                ssl_keyfile=os.getenv("SSL_KEYFILE", None),
+                ssl_certfile=os.getenv("SSL_CERTFILE", None),
+                )
+
+
+#%%
+
+
+#%%
+

read_pkl.py

@@ -0,0 +1,11 @@
+import pickle
+
+def read_pkl(fp):
+    with open(fp, "rb") as f:
+        data = []
+        try:
+            while True:
+                data.append(pickle.load(f))
+        except EOFError as e:
+            pass
+    return data

textgames/__init__.py

@@ -34,9 +34,9 @@ SINGLE_LINE_GAME_IDS = list(map(lambda g: GAME_IDS[GAME_NAMES.index(g.get_game_n
                                 [PasswordGame, BracketGame, StringSearch, AnagramScribble]
                                 ))
 
-LEVEL_IDS = ["0", "1", "2", "3", "4", "00"]
-LEVELS = ["🔰\tSample #1", "🚅\tEasy", "🚀\tMedium", "🛸\tHard"]
-LEVELS_HIDDEN = ["🌌\tInsane", "🔰\tSample #2"]
+LEVEL_IDS = ["1", "2", "3", "4", "0", "00"]
+LEVELS = ["🚅\tEasy", "🚀\tMedium", "🛸\tHard"]
+LEVELS_HIDDEN = ["🌌\tInsane", "🔰\tSample #1", "🔰\tSample #2"]
 _show_hidden_level_ = os.getenv("TEXTGAMES_SHOW_HIDDEN_LEVEL", False)
 if _show_hidden_level_:
     LEVELS, LEVELS_HIDDEN = LEVELS + LEVELS_HIDDEN, []
@@ -62,14 +62,16 @@ def _game_class_from_name(game_name):
 
 def preload_game(game_name, level_id, user):
     game_cls = _game_class_from_name(game_name)
-    email_sid_dict = read_csv("session_email.csv").dropna().set_index("EMAIL").SID.to_dict()
+    email_sid_dict = read_csv(
+        f"{os.getenv('TEXTGAMES_OUTPUT_DIR')}/textgames_userauth.tsv", sep='\t'
+    ).dropna().set_index("EMAIL").SID.to_dict()
     sid = email_sid_dict.get(user["email"])
-    print(f"preload_game('{game_name}', '{level_id}', '{user['email']}')", game_cls, sid, sep="\n\t")
+    print(f"preload_game('{game_name}', '{level_id}', '{user['email']}') on {sid}")
 
     with open(f"problemsets/{game_filename(game_name)}_{level_id}.json", "r", encoding="utf8") as f:
         sid_prompt_dict = json.load(f)
     prompt = sid_prompt_dict.get(sid)
-    print("Loaded prompt:", prompt, sep="\n")
+    # print("Loaded prompt:", prompt, sep="\n")
 
     return _reload(prompt, game_cls)
 

textgames/base_game.py

@@ -42,11 +42,11 @@ class BaseGame:
         assert not self.stats_filepath
         self.stats_filepath = filepath
 
-    def flush_stats_(self, user=None):
+    def flush_stats_(self, user_info_to_flush=None):
         if self.stats_filepath:
             with open(self.stats_filepath, mode='ab') as o:
-                if user:
-                    pickle.dump((time.time(), user), o)
+                if user_info_to_flush:
+                    pickle.dump((time.time(), user_info_to_flush), o)
                 else:
                     pickle.dump((
                         time.time(),
@@ -112,7 +112,4 @@ def _is_game_reloadable(original_game: BaseGame) -> bool:
     original_game_states = {k: v for k, v in vars(original_game).items() if k not in exclude_states}
     loaded_game_states = {k: v for k, v in vars(loaded_game).items() if k not in exclude_states}
 
-    ret = (original_game_states == loaded_game_states) and (original_game.get_prompt() == loaded_game.get_prompt())
-    if not ret:
-        pass
-    return ret
+    return (original_game_states == loaded_game_states) and (original_game.get_prompt() == loaded_game.get_prompt())

textgames/ordering_text/ordering_text.py

@@ -170,7 +170,7 @@ class ConsecutiveScoring(Scoring):
                     pattern += cur_pattern
                     pattern += f"{{{n}}}" if (n > 1) else ""
                 n = 1
-        self._pattern = re.compile(pattern)
+        self._pattern = re.compile(f"(?=({pattern}))")
 
         self.prompt = None
 

textgames_userauth_generate.py

@@ -0,0 +1,44 @@
+import os
+import pandas as pd
+from dotenv import load_dotenv
+
+# %%
+load_dotenv("oauth_environ_google.env")
+
+# %%
+os.system("python ~/pwd_generator.py --spchar \"+()!#$%&@?.;/\" -n 1000 -r 3 -l 24 > textgames_passwords.txt")
+
+# %%
+with open("textgames_passwords.txt", "r", encoding="utf8") as i:
+    passwords = [("", "", l.strip(), f"session_{k:04}") for k, l in enumerate(i)]
+
+# %%
+df = pd.DataFrame(passwords, columns=["EMAIL", "NAME", "PASSWORD", "SID"])
+
+# %%
+df.to_csv("textgames_userauth.tsv", index=False, sep="\t")
+
+# %%
+
+
+# %%
+
+
+# %%
+
+
+# %%
+
+
+# %%
+
+
+# %%
+
+
+# %%
+
+
+# %%
+
+