init

.flake8

@@ -0,0 +1,4 @@
+[flake8]
+# line length, space before binary op, line break before binary op, import not at top
+ignore = E501, E203, W503, E402
+exclude = .git,__pycache__,build,dist

.gitattributes

@@ -1,4 +1,11 @@
 *.7z filter=lfs diff=lfs merge=lfs -text
+katrain/KataGo/katago filter=lfs diff=lfs merge=lfs -text
+*.exe filter=lfs diff=lfs merge=lfs -text
+*.dll filter=lfs diff=lfs merge=lfs -text
+*.icns filter=lfs diff=lfs merge=lfs -text
+*.otf filter=lfs diff=lfs merge=lfs -text
+*.ttf filter=lfs diff=lfs merge=lfs -text
+*.ico filter=lfs diff=lfs merge=lfs -text
 *.arrow filter=lfs diff=lfs merge=lfs -text
 *.bin filter=lfs diff=lfs merge=lfs -text
 *.bz2 filter=lfs diff=lfs merge=lfs -text

.github/ISSUE_TEMPLATE/issue.md

@@ -0,0 +1,22 @@
+---
+name: Issue
+about: Standard issue template
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+Please read and fill in the appropriate template
+
+# I have a question about using the program, or need technical assistance
+
+Please use the Computer Go Community Discord (#gui) : http://discord.gg/AjTPFpN
+
+# I have a bug report
+
+Please include details of the settings you use, steps to reproduce the problem, and console output.
+
+# I have a feature request
+
+Go ahead, but keep in mind that the program is mostly in maintenance mode, and big changes are unlikely.

.github/actions/get-version/action.yml

@@ -0,0 +1,17 @@
+name: 'Get KaTrain Version'
+description: 'Extract version from katrain.core.constants'
+outputs:
+  version:
+    description: 'The version string'
+    value: ${{ steps.version.outputs.version }}
+
+runs:
+  using: 'composite'
+  steps:
+    - name: Get app version
+      id: version
+      shell: bash
+      run: |
+        version=$(python -c 'from katrain.core.constants import VERSION; print(VERSION)')
+        echo "version=$version" >> "$GITHUB_OUTPUT"
+        echo "KATRAIN_VERSION=$version" >> "$GITHUB_ENV" 

.github/actions/setup-python-uv/action.yml

@@ -0,0 +1,35 @@
+name: 'Setup Python and uv'
+description: 'Common setup for Python, uv, and dependencies'
+inputs:
+  python-version:
+    description: 'Python version to set up'
+    required: false
+    default: '3.11'
+  sync-groups:
+    description: 'uv sync groups'
+    required: false
+    default: ''
+
+runs:
+  using: 'composite'
+  steps:
+    - uses: actions/checkout@v4
+    
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ inputs.python-version }}
+
+    - name: Install uv
+      uses: astral-sh/setup-uv@v5
+      with:
+        version: "0.7.8"
+
+    - name: Install dependencies
+      shell: bash
+      run: |
+        if [ -n "${{ inputs.sync-groups }}" ]; then
+          uv sync --group ${{ inputs.sync-groups }}
+        else
+          uv sync
+        fi

.github/workflows/stale.yml

@@ -0,0 +1,21 @@
+name: "Close stale issues and PRs"
+on:
+  schedule:
+    - cron: "30 1 * * *"
+
+jobs:
+  stale:
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: write
+      issues: write
+    steps:
+      - uses: actions/stale@v8
+        with:
+          operations-per-run: 200
+          stale-issue-message: "This issue is stale because it has been open 90 days with no activity. Remove stale label or comment or this will be closed in 10 days."
+          close-issue-message: "This issue was closed because it has been stalled for 30 days with no activity."
+          days-before-stale: 90
+          days-before-close: 30
+          stale-pr-message: "This PR is stale because it has been open 90 days with no activity. Remove stale label or comment or this will be closed in 10 days."
+          close-pr-message: "This PR was closed because it has been stalled for 30 days with no activity."

.github/workflows/test_and_build.yaml

@@ -0,0 +1,218 @@
+# .github/workflows/test_and_build.yml
+
+name: Test, Build, and Release
+
+on:
+  pull_request:
+  workflow_dispatch:
+    inputs:
+      create_release:
+        description: 'Create draft release'
+        required: true
+        default: false
+        type: boolean
+      publish_pypi:
+        description: 'Publish to PyPI'
+        required: true
+        default: false
+        type: boolean
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
+jobs:
+  # This job runs first to prepare shared information for other jobs.
+  prepare:
+    runs-on: ubuntu-latest
+    outputs:
+      version: ${{ steps.version.outputs.version }}
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Get project version
+        id: version
+        uses: ./.github/actions/get-version
+
+  test:
+    needs: prepare
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ['3.9', '3.12', '3.13']
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    - name: Setup Python and uv
+      uses: ./.github/actions/setup-python-uv
+      with:
+        python-version: ${{ matrix.python-version }}
+        sync-groups: dev
+
+    - name: Run tests
+      run: uv run pytest tests
+
+    - name: Check I18N conversion
+      run: uv run python i18n.py -todo
+
+    - name: Check package can be built
+      run: uv build
+
+  build-windows:
+    needs: [prepare, test]
+    runs-on: windows-latest
+    env:
+      KATRAIN_VERSION: ${{ needs.prepare.outputs.version }}
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    - name: Setup Python, uv
+      uses: ./.github/actions/setup-python-uv
+
+    - name: Build executables with PyInstaller
+      run: uv run pyinstaller spec/katrain.spec --clean --noconfirm
+      shell: powershell
+
+    - name: Create archives
+      run: |
+        New-Item -ItemType Directory -Path "windows_exe" -Force
+        
+        # Copy the standalone KaTrain.exe
+        if (Test-Path "dist/KaTrain.exe") {
+            Copy-Item "dist/KaTrain.exe" "windows_exe/KaTrain.exe"
+        }
+        
+        # Create KaTrain.zip with debug executable inside
+        if (Test-Path "dist/KaTrain") {
+            # Copy the debug executable into the main KaTrain folder
+            if (Test-Path "dist/DebugKaTrain/KaTrain.exe") {
+                Copy-Item "dist/DebugKaTrain/KaTrain.exe" "dist/KaTrain/debugkatrain.exe"
+            }
+            # Create the zip file
+            Compress-Archive -Path "dist/KaTrain" -DestinationPath "windows_exe/KaTrain.zip"
+        }
+      shell: powershell
+
+    - name: Upload Windows artifacts
+      uses: actions/upload-artifact@v4
+      with:
+        name: KaTrainWindows-${{ env.KATRAIN_VERSION }}
+        path: windows_exe
+
+  build-macos:
+    needs: [prepare, test]
+    runs-on: macos-latest
+    env:
+      KATRAIN_VERSION: ${{ needs.prepare.outputs.version }}
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    - name: Setup Python, uv, and PyInstaller
+      uses: ./.github/actions/setup-python-uv
+      with:
+        install-pyinstaller: 'true'
+
+    - name: Install macOS dependencies
+      run: |
+        brew update
+        brew install libzip
+        brew install --build-from-source sdl2 sdl2_image sdl2_ttf sdl2_mixer
+
+    - name: Build KataGo
+      run: |
+        rm -f katrain/KataGo/katago katrain/KataGo/*.dll katrain/KataGo/katago.exe
+        git clone --depth 1 --branch stable https://github.com/lightvector/KataGo.git ../KataGo
+        pushd ../KataGo/cpp
+        cmake . -DUSE_BACKEND=OPENCL -DBUILD_DISTRIBUTED=1
+        make -j$(sysctl -n hw.ncpu)
+        cp katago ../../katrain/katrain/KataGo/katago-osx
+        popd
+
+    - name: Build app with PyInstaller
+      env:
+        KIVY_HEADLESS: 1
+        KIVY_NO_WINDOW: 1
+        KIVY_GL_BACKEND: mock
+      run: uv run pyinstaller spec/katrain.spec --clean --noconfirm
+
+    - name: Sign the app (ad-hoc)
+      run: codesign --force --deep --sign - dist/KaTrain.app
+
+    - name: Create DMG
+      run: |
+        mkdir -p dmg_temp
+        cp -R dist/KaTrain.app dmg_temp/
+        ln -s /Applications dmg_temp/Applications
+        hdiutil create -volname "KaTrain ${{ env.KATRAIN_VERSION }}" \
+                       -srcfolder dmg_temp \
+                       -ov \
+                       -format UDZO \
+                       "KaTrain-${{ env.KATRAIN_VERSION }}.dmg"
+        mkdir -p osx_app
+        mv "KaTrain-${{ env.KATRAIN_VERSION }}.dmg" osx_app/
+
+    - name: Upload macOS artifacts
+      uses: actions/upload-artifact@v4
+      with:
+        name: KaTrainMacOS-${{ env.KATRAIN_VERSION }}
+        path: osx_app
+
+  # This job publishes the package to PyPI.
+  publish-pypi:
+    needs: test
+    runs-on: ubuntu-latest
+    if: github.event_name == 'workflow_dispatch' && github.event.inputs.publish_pypi == 'true'
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    - name: Setup Python and uv
+      uses: ./.github/actions/setup-python-uv
+      with:
+        sync-groups: dev
+
+    - name: Finalize I18N for publishing
+      run: uv run python i18n.py
+
+    - name: Build and publish to PyPI
+      env:
+        UV_PUBLISH_TOKEN: ${{ secrets.PYPI_TOKEN }}
+      run: |
+        uv build
+        uv publish --verbose
+
+  # This job creates a draft release on GitHub.
+  create-release:
+    needs: [prepare, build-windows, build-macos]
+    runs-on: ubuntu-latest
+    if: github.event_name == 'workflow_dispatch' && github.event.inputs.create_release == 'true'
+    permissions:
+      contents: write # Required for softprops/action-gh-release
+    steps:
+    - name: Download all build artifacts
+      uses: actions/download-artifact@v4
+      with:
+        path: ./artifacts
+        pattern: KaTrain*
+        merge-multiple: true
+
+    - name: Create Draft Release
+      uses: softprops/action-gh-release@v2
+      with:
+        tag_name: "v${{ needs.prepare.outputs.version }}"
+        name: "KaTrain v${{ needs.prepare.outputs.version }}"
+        body: |
+          ## KaTrain v${{ needs.prepare.outputs.version }}
+          Auto-generated draft release from the latest main branch.
+          
+          ### Downloads
+          - **Windows**: Download the `.exe` files or `.zip` folders.
+          - **macOS**: Download the `.dmg` file.
+        files: ./artifacts/*
+        draft: true
+        prerelease: false

.gitignore

@@ -0,0 +1,158 @@
+dist_sgf
+sgftest
+
+# additions
+KataGoData
+katrain/KataGo/KataGoData
+experiments
+.idea
+.buildozer
+bin
+gtp.log
+log.txt
+sgfout
+sgf_selfplay
+sgf_ogs
+log*
+tmp.pickle
+my
+logs
+callgrind.*
+profile*
+cpp/out
+.vs
+dist_sgf
+
+
+# debug
+outdated_log.txt
+
+# too big
+models/*.bin.gz
+
+# standard python ignore
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# 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/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/

.python_version

@@ -0,0 +1 @@
+3.12

.vscode/launch.json

@@ -0,0 +1,15 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Python Debugger: Current File",
+            "type": "debugpy",
+            "request": "launch",
+            "program": "${file}",
+            "console": "integratedTerminal"
+        }
+    ]
+}

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "python-envs.defaultEnvManager": "ms-python.python:conda",
+    "python-envs.defaultPackageManager": "ms-python.python:conda",
+    "python-envs.pythonProjects": []
+}

CONTRIBUTIONS.md

@@ -0,0 +1,79 @@
+# Contributing 
+
+If you are a new contributor wanting to make a larger contribution,
+ please first discuss the change you wish to make via
+ an issue, reddit or discord before making a pull request.
+
+## Python contributions
+
+Python code is formatted using [black](https://github.com/psf/black) with the settings `-l 120`.
+This is not enforced, and contributions with incorrect formatting will be accepted, but formatting this way is appreciated.
+
+## Translations
+
+### Contributing to an existing translation
+
+* Go [here](https://github.com/sanderland/katrain/blob/master/katrain/i18n/locales/) and locate the `.po` file for your language. 
+  * Alternatively, find the same file in the branch for the next version. 
+* Correct the relevant `msgstr` entries.
+
+### Adding a translation
+
+Adding a translation requires making a new `.po` file with entries for that languages.
+
+* Copy the [English .po file](https://github.com/sanderland/katrain/blob/master/katrain/i18n/locales/en/LC_MESSAGES/katrain.po)
+* Change all the `msgstr` entries to your target language.
+    * Note that anything between `{}` should be left as-is.
+    * The information at the top of the file should also not be translated.
+
+You can send me the resulting `.po` file, and I will integrate it into the program.
+
+# Contributors 
+
+## Primary author and project maintainer:
+
+[Sander Land](https://github.com/sanderland/)
+
+## Contributors
+
+Many thanks to these additional authors:
+
+* Matthew Allred ("Kameone") for design of the v1.1 UI, macOS installation instructions, and working on promotion and YouTube videos.
+* "bale-go" for development and continued work on the 'calibrated rank' AI and rank estimation algorithm.
+* "Dontbtme" for detailed feedback and early testing of v1.0+.
+* "nowoowoo" for a fix to the parser for SGF files with extra line breaks.
+* "nimets123" for the timer sound effects and board/stone graphics.
+* Jordan Seaward for the stone sound effects.
+* "fohristiwhirl" for the Gibo and NGF formats parsing code.
+* "kaorahi" for bug fixes, SGF parser improvements, and tsumego frame code.
+* "ajkenny84" for the red-green colourblind theme.
+* Lukasz Wierzbowski for the ability to paste urls for sgfs and helping fix alt-gr issues.
+* Carton He for contributions to sgf parsing and handling.
+* "blamarche" for adding the board coordinates toggle.
+* "pdeblanc" for adding the ancient chinese scoring option, fixing a bug in query termination, and high precision score display.
+* "LiamHz" for adding the 'back to main branch' keyboard shortcut.
+* "xiaoyifang" for adding the reset analysis option, feature to save options on the loading screen, and scrolling through variations.
+* "electricRGB" for help with adding configurable keyboard shortcuts.
+* "milescrawford" for work on restyling the territory estimate.
+* "Funkenschlag1" for capturing stones sound and implementation, and board rotation.
+* "waltheri" for one of the wooden board textures.
+* Jacob Minsky ("jacobm-tech") for various contributions including analysis move range and improvements to territory display.
+
+## Translators
+
+Many thanks to the following contributors for translations.
+
+* French: "Dontbtme" with contributions from "wonderingabout"
+* Korean: "isty2e"
+* German: "nimets123", "trohde", "Harleqin" and "Sovereign"
+* Spanish: Sergio Villegas ("serpiente") with contributions from the Spanish OGS community
+* Russian: Dmitry Ivankov and Alexander Kiselev
+* Simplified Chinese: Qing Mu with contributions from "Medwin" and Viktor Lin
+* Japanese: "kaorahi"
+* Traditional Chinese: "Tony-Liou" with contributions from Ching-yu Lin
+
+## Additional thanks to
+
+* David Wu ("lightvector") for creating KataGo and providing assistance with making the most of KataGo's amazing capabilities.
+* "세븐틴" for including KaTrain in the Baduk Megapack and making explanatory YouTube videos in Korean.
+

ENGINE.md

@@ -0,0 +1,74 @@
+# KataGo troubleshooting
+
+This page lists common ways in which the provided KataGo fails to work out of the box, and how to resolve these issues.
+If you find your problem is not in here, you can ask on the [Leela Zero & Friends Discord](http://discord.gg/AjTPFpN) (use the #gui channel),
+ providing detailed information about your error.  
+
+
+* [General](#General)
+    * [GPU vs CPU](#CPU)
+* [Windows specific help](#Windows)
+* [MacOS specific help](#Mac)
+* [Linux specific help](#Linux)
+
+
+
+## <a name="General"></a> General
+
+###  <a name="CPU"></a> GPU vs CPU
+
+The standard executables assume you have a compatible graphics card (GPU). 
+If you don't, KataGo will fail to start in ways that are difficult for KaTrain to pick up.  
+
+On Windows and Linux, you should be able to resolve this by:
+
+* Going to general and engine settings (F8)
+* Click 'download katago versions' and wait for downloads to finish.
+* Select a CPU based KataGo version (named 'Eigen' after the library it uses).
+
+Keep in mind that a CPU based engine can be significantly slower, and you may want to set your maximum number of
+visits to a lower number to compensate for this.
+
+###  <a name="Models"></a> KataGo model versions
+
+KataGo models have changed over time, and selecting an older executable with a newer model can lead to errors.
+Of the provided binaries, this is typically the case for the 1.6.1 'bigger boards' binary, which should
+ only be used with the standard 15/20/30/40 block models, and not the newer distributed training models.
+
+
+## <a name="Mac"></a><img src="https://upload.wikimedia.org/wikipedia/commons/8/8a/Apple_Logo.svg" alt="macOs" height="35"/> For macOS users
+
+### Running from source
+
+Make sure you `brew install katago` or set the engine path to your own KataGo binary, as there is no executable included.
+
+### New Macs with M1 architecture
+
+Make sure you `brew install katago` as the provided executable does not work on rosetta.
+
+### Getting more information about errors
+
+On macOS, the .app distributable will not show a console, so you will need install using `pip` to see the console window.
+
+##  <a name="Windows"></a><img src="https://upload.wikimedia.org/wikipedia/commons/5/5f/Windows_logo_-_2012.svg" alt="Windows" height="35"/> For Windows users
+
+### Getting more information about errors
+
+Run DebugKaTrain.exe, which is released in the .zip file distributable in releases. This will show a console window
+ which typically tells you more.
+
+
+## <a name="Linux"></a><img src="https://upload.wikimedia.org/wikipedia/commons/a/ab/Linux_Logo_in_Linux_Libertine_Font.svg" alt="Linux" height="35"/> For Linux users
+
+### libzip compatibility
+
+The most common KataGo issue relates to incompatible library versions, leading to an "Error 127".
+
+* A good alternative is to go [here](https://github.com/lightvector/KataGo) and compile KataGo yourself.
+* Installing dependencies mentioned [here](INSTALL.md#LinuxTrouble) may also resolve certain issues with KataGo or the gui.
+
+
+### Getting more information about errors
+
+* Check the terminal output around startup time.
+* Start KataGo by itself using `katrain/KataGo/katago` when running from source and check output.

INSTALL.md

@@ -0,0 +1,161 @@
+# KaTrain Installation
+
+* [Quick install guide for MacOS](#MacQuick)
+    * [Troubleshooting and installation from sources](#MacSources)
+* [Quick install guide for Windows](#WindowsQuick)
+    * [Troubleshooting and installation from sources](#WindowsSources)
+* [Quick install guide for Linux](#LinuxQuick)
+    * [Troubleshooting and installation from sources](#LinuxSources)
+* [Configuring Multiple GPUS](#GPU)
+* [Troubleshooting KataGo](#KataGo)
+
+## <img src="https://upload.wikimedia.org/wikipedia/commons/8/8a/Apple_Logo.svg" alt="macOs" height="35"/> Installation for macOS users
+
+### <a name="MacQuick"></a>Quick install guide
+
+The easiest way to install is probably [brew](https://brew.sh/). Simply run `brew install katrain` and it will download and install the latest pre-built .app, and also install katago if needed.
+
+You can also find downloadable .app files for macOS [here](https://github.com/sanderland/katrain/releases). 
+Simply download, unzip the file, mount the .dmg and drag the .app file to your application folder, everything is included.
+The first time launching the application you may need to [control-click in finder to give permission for the 'unidentified' app to launch](https://support.apple.com/guide/mac-help/open-a-mac-app-from-an-unidentified-developer-mh40616/mac). This is simply a result of Apple charging $99/year to developers to be 'identified'.
+
+Users with the last generation M1 macs with different architecture should then `brew install katago` in addition to this. KaTrain will automatically detect this KataGo binary.
+
+### <a name="MacCommand"></a>Command line install guide
+
+[Open a terminal](https://support.apple.com/guide/terminal/open-or-quit-terminal-apd5265185d-f365-44cb-8b09-71a064a42125/mac) and enter the following commands:
+```bash
+/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install.sh)"
+brew install python3
+brew install katago
+pip3 install katrain
+```
+Now you can start KaTrain by simply typing `katrain` in a terminal after adding it to your path.
+
+These commands install [Homebrew](https://brew.sh), which simplifies installing packages,
+ followed by the programming language Python, the KataGo AI, and KaTrain itself.
+ 
+To upgrade to a newer version, simply run `pip3 install -U katrain`
+
+### <a name="MacSources"></a>Troubleshooting and Installation from sources
+
+Installation from sources is essentially the same as for Linux, see [here](#LinuxSources),
+ note that you will still need to install your own KataGo, using brew or otherwise. 
+
+If you encounter SSL errors on downloading model files, you may need to follow [these](https://stackoverflow.com/questions/52805115/certificate-verify-failed-unable-to-get-local-issuer-certificate) instructions to fix your certificates.
+
+## <img src="https://upload.wikimedia.org/wikipedia/commons/5/5f/Windows_logo_-_2012.svg" alt="Windows" height="35"/> Installation for Windows users
+
+### <a name="WindowsQuick"></a>Quick install guide
+
+You can find downloadable .exe files for windows [here](https://github.com/sanderland/katrain/releases). 
+Simply download and run, everything is included.
+
+### <a name="WindowsSources"></a>Installation from sources
+
+* Download the repository by clicking the green *Clone or download* on this page and *Download zip*. Extract the contents.
+* Make sure you have a python installation, I will assume Anaconda (Python 3.9 or later), available [here](https://www.anaconda.com/products/individual#download-section).
+* Open 'Anaconda prompt' from the start menu and navigate to where you extracted the zip file using the `cd <folder>` command.
+* Execute the command `pip3 install .`
+* Start the app by running `katrain` in the command prompt. 
+
+## <img src="https://upload.wikimedia.org/wikipedia/commons/a/ab/Linux_Logo_in_Linux_Libertine_Font.svg" alt="Linux" height="35"/> Installation for Linux users
+
+### <a name="LinuxQuick"></a>Quick install guide
+
+If you have a working Python 3.9 or later available, you should be able to simply:
+
+* Run `pip3 install -U katrain` to install or upgrade.
+* Run the program by executing `katrain` in a terminal.
+
+### <a name="LinuxSources"></a>Installation from sources 
+
+This section describes how to install KaTrain from sources,
+ in case you want to run it in a local directory or have more control over the process. 
+It assumes you have a working Python 3.9+ installation.
+
+* Open a terminal.
+* Run the command `git clone https://github.com/sanderland/katrain.git` to download the repository and 
+  change directory using `cd katrain`
+* Run the command `pip3 install .` to install the package globally, or use `--user` to install locally.
+* Run the program by typing `katrain` in the terminal.
+    * If you prefer not to install, run without installing using `python3 -m katrain` after installing the 
+    dependencies from `poetry.lock` with `poetry install`.
+
+A binary for KataGo is included, but if you have compiled your own, press F8 to open general settings and change the 
+ KataGo executable path to the relevant KataGo v1.4+ binary.
+
+### <a name="LinuxTrouble"></a>Troubleshooting and advanced installation from sources
+
+You can try to manually install dependencies to resolve some issues relating to missing dependencies,
+ e.g. the binary 'wheel' is not provided, KataGo is not starting, or sounds are not working.
+You can also follow these instructions if you don't want to install KaTrain, and just run it locally.
+
+First install the following packages, which are either required for building Kivy, 
+ or may help resolve missing dependencies for Kivy or KataGo.
+```bash
+sudo apt-get install python3-pip build-essential git python3 python3-dev ffmpeg libsdl2-dev libsdl2-image-dev\
+    libsdl2-mixer-dev libsdl2-ttf-dev libportmidi-dev libswscale-dev libavformat-dev libavcodec-dev zlib1g-dev\
+    libgstreamer1.0 gstreamer1.0-plugins-base gstreamer1.0-plugins-good libpulse\
+    pkg-config libgl-dev opencl-headers ocl-icd-opencl-dev libzip-dev
+```
+Then, try installing python package dependencies using:
+```bash
+pip3 install poetry
+poetry install
+pip3 install screeninfo # Skip on MacOS, not working
+```
+In case the sound is not working, or there is no available wheel for your OS or Python version, try building kivy locally using:
+```bash
+pip3 uninstall kivy
+pip3 install kivy --no-binary kivy
+```
+
+You can now start KaTrain by running `python3 -m katrain`
+
+In case KataGo does not start, an alternative is to go [here](https://github.com/lightvector/KataGo) and compile KataGo yourself.
+
+
+
+## <a name="GPU"></a> Configuring the GPU(s) KataGo uses
+
+In most cases KataGo detects your configuration correctly, automatically searching for OpenCL devices and select the highest scoring device. 
+However, if you have multiple GPUs or want to force a specific device you will need to edit the 'analysis_config.cfg' file in the KataGo folder.
+
+To see what devices are available and which one KataGo is using. Look for the following lines in the terminal after starting KaTrain:
+```
+    Found 3 device(s) on platform 0 with type CPU or GPU or Accelerator
+    Found OpenCL Device 0: Intel(R) Core(TM) i9-9880H CPU @ 2.30GHz (Intel) (score 102)
+    Found OpenCL Device 1: Intel(R) UHD Graphics 630 (Intel Inc.) (score 6000102)
+    Found OpenCL Device 2: AMD Radeon Pro 5500M Compute Engine (AMD) (score 11000102)
+    Using OpenCL Device 2: AMD Radeon Pro 5500M Compute Engine (AMD) OpenCL 1.2
+```
+
+The above devices were found on a 2019 MacBook Pro with both an on-motherboard graphics chip, and a separate AMD Radeon Pro video card.
+As you can see it scores about twice as high as the Intel UHD chip and KataGo has selected
+ it as it's sole device. You can configure KataGo to use *both* the AMD and the Intel devices to get the best performance out of the system.
+
+* Open the 'analysis_config.cfg' file in the `katrain/KataGo` folder in your python packages, or local sources.
+  If you can't find it, turn on `debug_level=1` in general settings and look for the command that is used to start KataGo.
+* Search for `numNNServerThreadsPerModel` (~line 108), uncomment the line by deleting the # and set the value to 2. The line should read `numNNServerThreadsPerModel = 2`.
+* Search for `openclDeviceToUseThread` (~line 164), uncomment by deleting the # and set the values to the device ID numbers identified in the terminal.
+  From the example above, we would want to use devices 1 and 2, for the Intel and AMD GPUs, but not device 0 (the CPU). In our case, the lines should read:
+```
+openclDeviceToUseThread0 = 1
+openclDeviceToUseThread1 = 2
+```
+* Run `katrain` and confirm that KataGo is now using both devices, by 
+ checking the output from the terminal, which should indicate two devices being used. For example:
+```
+    Found 3 device(s) on platform 0 with type CPU or GPU or Accelerator
+    Found OpenCL Device 0: Intel(R) Core(TM) i9-9880H CPU @ 2.30GHz (Intel) (score 102)
+    Found OpenCL Device 1: Intel(R) UHD Graphics 630 (Intel Inc.) (score 6000102)
+    Found OpenCL Device 2: AMD Radeon Pro 5500M Compute Engine (AMD) (score 11000102)
+    Using OpenCL Device 1: Intel(R) UHD Graphics 630 (Intel Inc.) OpenCL 1.2
+    Using OpenCL Device 2: AMD Radeon Pro 5500M Compute Engine (AMD) OpenCL 1.2
+```
+
+
+## <a name="KataGo"></a> Troubleshooting and advanced KataGo settings
+
+See [here](ENGINE.md) for an overview of how to resolve various issues with KataGo.

LICENSE

@@ -0,0 +1,40 @@
+This repository includes:
+
+1. Binaries for 'KataGo', which is Copyright David J Wu et al.
+For on related licenses for these binaries and libraries see https://github.com/lightvector/KataGo
+
+2. Icons from www.flaticon.com, used with permission with the following attributions:
+- Equalize icon and Thrash Icon: derived from work by bqlqn from www.flaticon.com
+- Other Menu icons, Finish, Collaboration and Flag icons: derived from work by Freepik from www.flaticon.com
+- Collapse branch icon: derived from work by Kirill Kazachek from www.flaticon.com
+- Prune icon: derived from work by Pixelmeetup from www.flaticon.com
+- Reset icon: derived from work by Pixel Perfect from www.flaticon.com
+- Rotate icon:  derived from work by Frey Wazza from www.flaticon.com
+
+3. The True Type Font DIGITAL-7 version 1.02 by Sizenko Alexander, which is free for non-commercial use.
+
+4. The Noto Sans fonts from google which are covered by the SIL open font license v1.1 included in the katrain/fonts directory.
+
+-----------------------------------------------------------------------------------------
+Aside from the above, the license for all other content in this repository is as follows:
+-----------------------------------------------------------------------------------------
+
+Copyright 2020 Sander Land and/or other authors of the content in this repository.
+(See 'CONTRIBUTIONS.md' file for a list of authors as well as other indirect contributors).
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+-----------------------------------------------------------------------------------------

QA.txt

@@ -0,0 +1,63 @@
+
+根据项目文件分析，这个 KaTrain 项目使用了现代的 Python 包管理工具 **uv**，以下是安装依赖的几种方法：
+
+## 推荐方法：使用 uv（现代包管理器）
+
+由于项目包含 `uv.lock` 文件和在 `pyproject.toml` 中配置了 uv，推荐使用 uv 来管理依赖：
+
+```bash
+# 安装 uv（如果还没有安装）
+pip install uv
+
+# 安装项目依赖（包括开发依赖）
+uv sync
+```
+
+或者如果只需要运行时依赖：
+```bash
+uv sync --no-dev
+```
+
+## 传统方法：使用 pip
+
+如果你更喜欢使用传统的 pip：
+
+```bash
+# 安装项目及其依赖
+pip install .
+
+# 或者安装开发依赖
+pip install -e ".[dev]"
+```
+
+## 直接从 PyPI 安装
+
+如果你只是想使用 KaTrain 而不是开发它：
+
+```bash
+pip install katrain
+```
+
+## 项目依赖说明
+
+根据 `pyproject.toml` 文件，主要依赖包括：
+- **kivy** (>=2.3.1) - GUI 框架
+- **kivymd** (==0.104.1) - Material Design 组件
+- **pygame** - 游戏开发库（仅 macOS）
+- **screeninfo** - 屏幕信息（非 macOS）
+- **chardet**, **docutils**, **ffpyplayer**, **urllib3** - 其他工具库
+
+开发依赖包括：
+- **black** - 代码格式化
+- **pytest** - 测试框架
+- **pyinstaller** - 打包工具
+- **polib** - 国际化工具
+
+## 注意事项
+
+1. **Python 版本要求**：需要 Python 3.9 到 3.13
+2. **KataGo 引擎**：项目包含了 KataGo 二进制文件，但在某些平台可能需要单独安装
+3. **系统依赖**：在 Linux 上可能需要安装额外的系统库（详见 INSTALL.md）
+
+推荐使用 `uv sync` 命令，因为它能更好地处理依赖锁定和环境隔离。
+        

README.md

@@ -0,0 +1,253 @@
+# <a name="manual"></a> KaTrain
+
+[![Latest Release](http://img.shields.io/github/release/sanderland/katrain?label=download)](http://github.com/sanderland/katrain/releases)
+[![License:MIT](http://img.shields.io/pypi/l/katrain)](http://en.wikipedia.org/wiki/MIT_License)
+[![GitHub Downloads](http://img.shields.io/github/downloads/sanderland/katrain/total?color=%23336699&label=github%20downloads)](http://github.com/sanderland/katrain/releases)
+[![PyPI Downloads](http://pepy.tech/badge/katrain)](http://pepy.tech/project/katrain)
+[![Discord](http://img.shields.io/discord/417022162348802048?logo=discord)](http://discord.com/channels/417022162348802048/629446365688365067)
+
+KaTrain is a tool for analyzing games and playing go with AI feedback from KataGo:
+
+* Review your games to find the moves that were most costly in terms of points lost.
+* Play against AI and get immediate feedback on mistakes with option to retry.
+* Play against a wide range of weakened versions of AI with various styles.
+* Automatically generate focused SGF reviews which show your biggest mistakes.
+
+## Manual
+
+<table>
+<td>
+
+- [ KaTrain](#-katrain)
+  - [Manual](#manual)
+  - [  Preview and Youtube Videos](#--preview-and-youtube-videos)
+  - [ Installation](#-installation)
+  - [  Configuring KataGo](#--configuring-katago)
+  - [ Play against AI](#-play-against-ai)
+    - [Instant feedback](#instant-feedback)
+    - [AIs](#ais)
+  - [ Analysis](#-analysis)
+  - [ Keyboard and mouse shortcuts](#-keyboard-and-mouse-shortcuts)
+  - [ Contributing to distributed training](#-contributing-to-distributed-training)
+  - [ Themes](#-themes)
+  - [ FAQ](#-faq)
+  - [ Support / Contribute](#-support--contribute)
+
+
+<td>
+
+<a href="http://github.com/sanderland/katrain/blob/master/README.md"><img alt="English" src="https://github.com/sanderland/katrain/blob/master/katrain/img/flags/flag-uk.png" width=50></a>
+<a href="http://translate.google.com/translate?sl=en&tl=de&u=https%3A%2F%2Fgithub.com%2Fsanderland%2Fkatrain%2Fblob%2Fmaster%2FREADME.md"><img alt="German" src="https://github.com/sanderland/katrain/blob/master/katrain/img/flags/flag-de.png" width=50></a>
+<a href="http://translate.google.com/translate?sl=en&tl=fr&u=https%3A%2F%2Fgithub.com%2Fsanderland%2Fkatrain%2Fblob%2Fmaster%2FREADME.md"><img alt="French" src="https://github.com/sanderland/katrain/blob/master/katrain/img/flags/flag-fr.png" width=50></a>
+<a href="http://translate.google.com/translate?sl=en&tl=uk&u=https%3A%2F%2Fgithub.com%2Fsanderland%2Fkatrain%2Fblob%2Fmaster%2FREADME.md"><img alt="Ukrainian" src="https://github.com/sanderland/katrain/blob/master/katrain/img/flags/flag-ua.png" width=50></a>
+<a href="http://translate.google.com/translate?sl=en&tl=ru&u=https%3A%2F%2Fgithub.com%2Fsanderland%2Fkatrain%2Fblob%2Fmaster%2FREADME.md"><img alt="Russian" src="https://github.com/sanderland/katrain/blob/master/katrain/img/flags/flag-ru.png" width=50></a>
+<br/>
+<a href="http://translate.google.com/translate?sl=en&tl=tr&u=https%3A%2F%2Fgithub.com%2Fsanderland%2Fkatrain%2Fblob%2Fmaster%2FREADME.md"><img alt="Turkish" src="https://github.com/sanderland/katrain/blob/master/katrain/img/flags/flag-tr.png" width=50></a>
+<a href="http://translate.google.com/translate?sl=en&tl=zh-CN&u=https%3A%2F%2Fgithub.com%2Fsanderland%2Fkatrain%2Fblob%2Fmaster%2FREADME.md"><img alt="Simplified Chinese" src="https://github.com/sanderland/katrain/blob/master/katrain/img/flags/flag-cn.png" width=50></a>
+<a href="http://translate.google.com/translate?sl=en&tl=zh-TW&u=https%3A%2F%2Fgithub.com%2Fsanderland%2Fkatrain%2Fblob%2Fmaster%2FREADME.md"><img alt="Traditional Chinese" src="https://github.com/sanderland/katrain/blob/master/katrain/img/flags/flag-tw.png" width=50></a>
+<a href="http://translate.google.com/translate?sl=en&tl=ko&u=https%3A%2F%2Fgithub.com%2Fsanderland%2Fkatrain%2Fblob%2Fmaster%2FREADME.md"><img alt="Korean" src="https://github.com/sanderland/katrain/blob/master/katrain/img/flags/flag-ko.png" width=50></a>
+<a href="http://translate.google.com/translate?sl=en&tl=ja&u=https%3A%2F%2Fgithub.com%2Fsanderland%2Fkatrain%2Fblob%2Fmaster%2FREADME.md"><img alt="Japanese" src="https://github.com/sanderland/katrain/blob/master/katrain/img/flags/flag-jp.png" width=50></a>
+
+</td>
+</table>
+
+## <a name="preview"></a>  Preview and Youtube Videos
+
+<img alt="screenshot" src="https://raw.githubusercontent.com/sanderland/katrain/master/screenshots/analysis.png" width="550">
+
+| **Local Joseki Analysis**                  | **Analysis Tutorial**                                                                              | **Teaching Game Tutorial**                                                                                   |
+|:-----------------------------------------------------------------------------------------------------:|:-----------------------------------------------------------------------------------------------------:|:------------------------------------------------------------------------------------------------------------:|
+| [![Local Joseki Analysis Video](http://i.imgur.com/YcpmSBx.png)](https://www.youtube.com/watch?v=tXniX57KtKk) | [![Analysis Tutorial](http://i.imgur.com/3EP4IEr.png)](http://www.youtube.com/watch?v=qjxkcKgrsbU) | [![ Teaching Game Tutorial](http://i.imgur.com/jAdcSL5.png)](http://www.youtube.com/watch?v=wFl4Bab_eGM)   |
+
+
+
+## <a name="install"></a> Installation
+* See the [releases page](http://github.com/sanderland/katrain/releases) for downloadable executables for Windows and macOS.
+* Alternatively use `pipx install katrain` to install the latest version from PyPI on any 64-bit OS in an isolated environment.
+* On macOS, you can also use `brew install katrain` to install the app.
+* [This page](https://github.com/sanderland/katrain/blob/master/INSTALL.md) has detailed instructions for Window, Linux and macOS,
+  as well as troubleshooting and setting up KataGo to use multiple GPUs.
+
+## <a name="kata"></a>  Configuring KataGo
+
+KaTrain comes pre-packaged with a working KataGo (OpenCL version) for Windows, Linux, and pre-M1 Mac operating systems, and the rather old 15 block model.
+
+To change the model, open 'General and Engine settings' in the application and 'Download models'. You can then select the model you want from the dropdown menu.
+
+To change the katago binary, e.g. to the Eigen/CPU version if you don't have a GPU, click 'Download KataGo versions'.
+  You can then select the KataGo binary from the dropdown menu.
+There are also CUDA and TensorRT versions available on [the KataGo release site](https://github.com/lightvector/KataGo/releases). Particularly the latter may offer much better performance on NVIDIA GPUs, but will be harder to 
+set up: [see here for more details](https://github.com/lightvector/KataGo#opencl-vs-cuda-vs-tensorrt-vs-eigen).
+
+Finally, you can override the entire command used to start the analysis engine, which 
+ can be useful for connecting to a remote server. Do keep in mind that KaTrain uses the *analysis engine*
+ of KataGo, and not the GTP engine.
+
+
+## <a name="ai"></a> Play against AI
+
+* Select the players in the main menu, or under 'New Game'.
+* In a teaching game, KaTrain will analyze your moves and automatically undo those that are sufficiently bad.
+* When playing against AI, note that the "Undo" button will undo both the AI's last move and yours.
+
+### Instant feedback
+
+The dots on the move indicate how many points were lost by that move.
+
+* The colour indicates the size of the mistake according to KataGo
+* The size indicates if the mistake was actually punished. Going from fully punished at maximal size,
+  to no actual effect on the score at minimal size.
+
+In short, if you are a weaker player you should mostly focus on large dots that are red or purple,
+while stronger players can pay more attention to smaller mistakes. If you want to hide some colours
+on the board, or not output details for them in SGFs,you can do so under 'Configure Teacher'.
+
+### AIs
+
+This section describes the available AIs.
+
+In the 'AI settings', settings which have been tested and calibrated are at the top and have a lighter color,
+changing these will show an estimate of rank.
+This estimate should be reasonably accurate as long as you have not changed the other settings.
+
+* Recommended options for serious play include:
+    * **KataGo** is full KataGo, above professional level. The analysis and feedback given is always based on this full strength KataGo AI.
+    * **Calibrated Rank Bot** was calibrated on various bots (e.g. GnuGo and Pachi at different strength settings) to play a balanced
+     game from the opening to the endgame without making serious (DDK) blunders. Further discussion can be found
+      [here](http://github.com/sanderland/katrain/issues/44) and [here](http://github.com/sanderland/katrain/issues/74).
+    * **Simple Style** Prefers moves that solidify both player's territory, leading to relatively simpler moves.
+* Legacy options which were developed earlier include: 
+    * **ScoreLoss** is KataGo analyzing as usual, but
+      choosing from potential moves depending on the expected score loss, leading to a varied style with mostly small mistakes.
+    * **Policy** uses the top move from the policy network (it's 'shape sense' without reading).
+    * **Policy Weighted** picks a random move weighted by the policy, leading to a varied style with mostly small mistakes, and occasional blunders due to a lack of reading.
+    * **Blinded Policy** picks a number of moves at random and play the best move among them, being effectively 'blind' to part of the board each turn. Calibrated rank is based on the same idea, and recommended over this option.
+* Options that are more on the 'fun and experimental' side include: 
+    * Variants of **Blinded Policy**, which use the same basic strategy, but with a twist:
+       * **Local Style** will consider mostly moves close to the last move.
+       * **Tenuki Style** will consider mostly moves away from the last move.
+       * **Influential Style** will consider mostly 4th+ line moves, leading to a center-oriented style.
+       * **Territory Style** is biased in the opposite way, towards 1-3rd line moves.
+    * **KataJigo** is KataGo attempting to win by 0.5 points, typically by responding to your mistakes with an immediate mistake of it's own.
+    * **KataAntiMirror** is KataGo assuming you are playing mirror go and attempting to break out of it with profit as long as you are.
+    
+The Engine based AIs (KataGo, ScoreLoss, KataJigo) are affected by both the model and choice of visits and maximum time,
+ while the policy net based AIs are affected by the choice of model file, but work identically with 1 visit.
+
+Further technical details and discussion on some of these AIs can be found on [this](http://lifein19x19.com/viewtopic.php?f=10&t=17488&sid=b11e42c005bb6f4f48c83771e6a27eff) thread at the life in 19x19 forums.
+
+## <a name="analysis"></a> Analysis
+
+Analysis options in KaTrain allow you to explore variations and request more in-depth analysis from the engine at any point in the game.
+
+| Key            | Short Description                      | Details                                                                                                                                                                                                                                                                                               |
+| -------------- | -------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| <kbd>Tab</kbd> | Switch between analysis and play modes | AI moves, teaching mode and timers are suspended in analysis mode. The state of the analysis options and right-hand side panels and options is saved independently for 'play' and 'analyze', allowing you to quickly switch between a more minimalistic 'play' mode and more complex 'analysis' mode. |
+
+The checkboxes at the top of the screen:
+
+| Key          | Short Description     | Details                                                                                                                                                                                                                                     |
+| ------------ | --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| <kbd>q</kbd> | Child moves are shown | On by default, can turn it off to avoid obscuring other information or when wanting to guess the next move.                                                                                                                                 |
+| <kbd>w</kbd> | Show all dots         | Toggles showing coloured evaluation 'dots' on the last few moves or not. You can configure the thresholds, along with how many of the last moves they are shown for under 'Teaching/Analysis Settings'.                                     |
+| <kbd>e</kbd> | Top moves             | Show the next moves KataGo considered, colored by their expected point loss. Small/faint dots indicate high uncertainty and never show text (lower than your 'fast visits' setting). Hover over any of them to see the principal variation. |
+| <kbd>r</kbd> | Policy moves          | Show KataGo's policy network evaluation, i.e. where it thinks the best next move is purely from the position, and in the absence of any 'reading'. This turns off the 'top moves' setting as the overlap is often not useful.               |
+| <kbd>t</kbd> | Expected territory    | Show expected ownership of each intersection.                                                                                                                                                                                               |
+
+The analysis options available under the 'Analysis' button are used for deeper evaluation of the position:
+
+| Key                                 | Short Description                                                                                            | Details                                                                                                                                                                                                                      |
+| ----------------------------------- | ------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| <kbd>a</kbd>                        | Deeper analysis                                                                                              | Re-evaluate the position using more visits, usually resulting in a more accurate evaluation.                                                                                                                                 |
+| <kbd>s</kbd>                        | Equalize visits                                                                                              | Re-evaluate all currently shown next moves with the same visits as the current top move. Useful to increase confidence in the suggestions with high uncertainty.                                                             |
+| <kbd>d</kbd>                        | Analyze all moves                                                                                            | Evaluate all possible next moves. This can take a bit of time even though 'fast_visits' is used, but can be useful to see how many reasonable next moves are available.                                                      |
+| <kbd>f</kbd>                        | Find alternatives                                                                                            | Increases analysis of current candidate moves to at least the 'fast visits' level, and request a new query that excludes all current candidate moves.                                                                        |
+| <kbd>g</kbd>                        | Select area of interest                                                                                      | Set an area and search only for moves in this box. Good for solving tsumegos. Note that some results may appear outside the box due to establishing a baseline for the best move, and the opponent can tenuki in variations. |
+| <kbd>h</kbd>                        | Reset analysis                                                                                               | This reverts the analysis to what the engine returns after a normal query, removing any additional exploration.                                                                                                              |
+| <kbd>i</kbd>                        | Start insertion mode                                                                                         | Allows you to insert moves, to improve analysis when both players ignore an important exchange or life and death situation. Press again to stop inserting and copy the rest of the branch.                                   |
+| <kbd>l</kbd>                        | Play out the game until the end and add as a collapsed branch, to visualize the potential effect of mistakes | This is done in the background, and can be started at several nodes at once when comparing the results at different starting positions.                                                                                      |
+| <kbd>Space</kbd>                    | Turn continuous analysis on/off.                                                                             | This will continuously improve analysis of the current position, similar to Lizzie's 'pondering', but only when there are no other queries going on.                                                                         |
+| <kbd>Shift</kbd> + <kbd>Space</kbd> | As above, but does not turn 'top moves' hints on when it is off.                                             |                                                                                                                                                                                                                              |
+| <kbd>Enter</kbd>                    | AI move                                                                                                      | Makes the AI move for the current player regardless of current player selection.                                                                                                                                             |
+| <kbd>F2</kbd>                       | Deeper full game analysis                                                                                    | Analyze the entire game to a higher number of visits.                                                                                                                                                                        |
+| <kbd>F3</kbd>                       | Performance report                                                                                           | Show an overview of performance statistics for both players.                                                                                                                                                                 |
+| <kbd>F10</kbd>                      | Tsumego Frame                                                                                                | After placing a life and death problem in a corner/side, use this to fill up the rest of the board to improve AI's ability in solving life and death problems.                                                               |
+
+## <a name="keyboard"></a> Keyboard and mouse shortcuts
+
+In addition to shortcuts mentioned above and those shown in the main menu:
+
+| Key                                            | Short Description                                                                    | Details                                                                                                                                 |
+| ---------------------------------------------- | ------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------- |
+| <kbd>Alt</kbd>                                 | Open the main menu                                                                   |                                                                                                                                         |
+| <kbd>~</kbd> or <kbd>`</kbd> or <kbd>F12</kbd> | Cycles through more minimalistic UI modes                                            |                                                                                                                                         |
+| <kbd>k</kbd>                                   | Toggle display of board coordinates                                                  |                                                                                                                                         |
+| <kbd>p</kbd>                                   | Pass                                                                                 |                                                                                                                                         |
+| <kbd>Pause</kbd>                               | Pause/Resume timer                                                                   |                                                                                                                                         |
+| <kbd>←</kbd> or <kbd>z</kbd>                   | Undo move                                                                            | Hold shift for 10 moves at a time, or ctrl to skip to the start.                                                                        |
+| <kbd>→</kbd> or <kbd>x</kbd>                   | Redo move                                                                            | Hold shift for 10 moves at a time, or ctrl to skip to the end.                                                                          |
+| <kbd>↑</kbd>/<kbd>↓</kbd>                      | Switch branch                                                                        | As would be expected from the move tree.                                                                                                |
+| <kbd>Home</kbd>/<kbd>End</kbd>                 | Go to the beginning/end of the game                                                  |                                                                                                                                         |
+| <kbd>PageUp</kbd>                              | Make the currently selected node the main branch                                     |                                                                                                                                         |
+| <kbd>Ctrl</kbd> + <kbd>Delete</kbd>            | Delete current node                                                                  |                                                                                                                                         |
+| <kbd>c</kbd>                                   | Collapse/Uncollapse the branch from the current node to the previous branching point |                                                                                                                                         |
+| <kbd>b</kbd>                                   | Go back to the previous branching point                                              |                                                                                                                                         |
+| <kbd>Shift</kbd> + <kbd>b</kbd>                | Go back the main branch                                                              |                                                                                                                                         |
+| <kbd>n</kbd>                                   | Go to one move before the next mistake (orange or worse) by a human player           | As in clicking the forward red arrow                                                                                                    |
+| <kbd>Shift</kbd> + <kbd>n</kbd>                | Go to one move before the previous mistake                                           | As in clicking the backward red arrow                                                                                                   |
+| Scroll Mouse                                   | Redo/Undo move or Scroll through principal variation                                 | When hovering the cursor over the right panel: Redo/Undo move. When hovering over a candidate move: Scroll through principal variation. |
+| Middle Scroll Wheel Click                      | Add principal variation to the move tree                                             | When scrolling, only moves up to the point you are viewing are added.                                                                   |
+| Click on a Move                                | See detailed statistics for a previous move                                          | Along with expected variation that was best instead of this move                                                                        |
+| Double Click on a Move                         | Navigate directly to just before that point in the game                              |                                                                                                                                         |
+| <kbd>Ctrl</kbd> + <kbd>v</kbd>                 | Load SGF from the clipboard and do a 'fast' analysis of the game                     | With a high priority normal analysis for the last move.                                                                                 |
+| <kbd>Ctrl</kbd> + <kbd>c</kbd>                 | Save SGF to clipboard                                                                |                                                                                                                                         |
+| <kbd>Escape</kbd>                              | Stop all analysis                                                                    |                                                                                                                                         |
+
+## <a name="distributed"></a> Contributing to distributed training
+
+Starting in December 2020, KataGo started [distributed training](https://katagotraining.org/).
+This allows people to all help generate self-play games to increase KataGo's strength and train bigger models.
+
+KaTrain 1.8.0+ makes it easy to contribute to distributed training: simply select the option from the main menu, register an account, and click run.
+During this mode you can do little more than watch games.
+
+Keep in mind that partial games are not uploaded,
+so it is best to plan to keep it running for at least an hour, if not several, for the most effective contribution.
+
+A few keyboard shortcuts have special functions in this mode:
+
+| Key               | Short Description                                                  | Details                                                                                                |
+| ----------------- | ------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------ |
+| <kbd>Space</kbd>  | Switch between manually navigating the current game                | And automatically advancing it.                                                                        |
+| <kbd>Escape</kbd> | Sends the `quit` command to KataGo                                 | Which starts a slow shutdown, finishing partial games but not starting new ones. Only works on v1.11+. |
+| <kbd>Pause</kbd>  | Pauses/resumes contributions via the `pause` and `resume` commands | Introduced in KataGo v1.11                                                                             |
+
+## <a name="themes"></a> Themes
+
+See [these instructions](THEMES.md) for how to modify the look of any graphics or colours, and creating or install themes.
+   
+## <a name="faq"></a> FAQ
+
+* The program is running too slowly. How can I speed it up?
+  *  Adjust the number of visits or maximum time allowed in the settings.
+* KataGo crashes with "out of memory" errors, how can I prevent this?
+  * Try using a lower number for `nnMaxBatchSize` in `KataGo/analysis_config.cfg`, and avoid using versions compiled with large board sizes.
+  * If still encountering problems, please start KataGo by itself to check for any errors it gives.
+  * Note that if you don't have a GPU, or your GPU does not support OpenCL, you should use the 'eigen' binaries which run on CPU only.
+* The font size is too small
+  * On some ultra-high resolution monitors, dialogs and other elements with text can appear too small. Please see [these](https://github.com/sanderland/katrain/issues/359#issuecomment-784096271) instructions to adjust them.
+* The app crashes with an error about "unable to find any valuable cutbuffer provider"
+  * Install xclip using `sudo apt-get install xclip`
+
+
+## <a name="support"></a> Support / Contribute
+
+[![GitHub issues](http://img.shields.io/github/issues/sanderland/katrain)](http://github.com/sanderland/katrain/issues)
+[![Contributors](http://img.shields.io/static/v1?label=contributors&message=<3&color=dcb424)](CONTRIBUTIONS.md)
+
+ * Ideas, feedback, and contributions to code or translations are all very welcome.
+    * For suggestions and planned improvements, see [open issues](http://github.com/sanderland/katrain/issues) on github to check if the functionality is already planned.
+* You can join the [Computer Go Community Discord (formerly Leela Zero & Friends)](http://discord.gg/AjTPFpN) (use the #gui channel) to get help, discuss improvements, or simply show your appreciation. Please do not use github issues to ask for technical help, this is only for bugs, suggestions and discussing contributions.
+
+
+

THEMES.md

@@ -0,0 +1,96 @@
+# Themes
+
+Version 1.7 brings basic support for themes, and 1.9 extends it to include keyboard shortcuts and support for multiple theme files.
+
+## Creating and editing themes
+
+* Look at the `Theme` class in [`katrain/gui/theme.py`](https://github.com/sanderland/katrain/blob/master/katrain/gui/theme.py).
+* Make a `theme-<yourthemename>.json` file in your `<home dir>/.katrain` directory and specify any variables from the above class you want to override, e.g. 
+ ```json
+ {
+  "BACKGROUND_COLOR": [1,0,0,1],
+  "KEY_STOP_ANALYSIS": "f10",
+  "MISTAKE_SOUNDS": ["jeff.wav","what.wav"]
+}
+  ```
+* All resources (including icons, which can not be renamed for now) will be looked up in `<home dir>/.katrain` first, so files with identical names there can be used to override sounds and images.
+* If variables are specified in multiple theme files, the *latest* alphabetically takes precedence. That is, each later theme file overwrites the settings from any previous one.
+
+## Expected territory options
+
+* KaTrain supports different styles of display of expected territory:
+  * Blended style colors the board with an intensity proportional to the likelihood of a player controlling that territory at the end of the game.
+  * Shaded style behaves the same as Blended, but uses square shades similar to
+  the Katago paper.
+  * In the Marks style, each point of the board is marked with a square of size which is proportional to ownership likelihood.
+  * The Blocks style divides the whole board into black, white, and neutral territory, based on a likelihood threshold. This style is appropriate as a counting aid, but may be misleading before endgame if much of the territory is unsettled.
+* Marks can also appear on stones to indicate the likelihood of these stones living at the end of the game. Three styles are supported:
+  * All stones can be marked, with the color of the mark indicating the expected ownership and the size of the mark indicating certainty.
+  * Weak stones only - marks will appear only on stones which are over 50% likely to die before the end of the game.
+  * No stone marks.
+* Stones can also be made transparent based on their strength.
+
+| <img src="./themes/blended-all.png"  width="400"/> <br> Blended style, all stones marked| <img src="./themes/shaded-all.png"   width="400"/> <br> Shaded style, all stones marked |
+| --- | ---|
+| <img src="./themes/blocks-none.png"  width="400"/> <br> Territory blocks, no stones marked | <img src="./themes/blended-weak.png" width="400"/> <br> Blended territory, weak stones marked |
+| <img src="./themes/marks-weak.png"   width="400"/>  <br> Marks on intersections, weak stones marked | <img src="./themes/shaded-no-alpha.png"   width="400"/>  <br> Shaded, no stone alpha |
+                             
+
+<sup>The game used in the screenshots is [Albert Yen vs. Eric Yoder](https://www.usgo.org/news/2022/03/members-edition-midwest-open-round-2-the-broken-ladder-game).</sup>
+
+The stone marks, transparency, and territory style are independent; the table above presents a collection of possible variants.
+The relevant variables are:
+```
+{
+    "TERRITORY_DISPLAY" : "blended" | "shaded" | "marks" | "blocks",
+    "STONE_MARKS" : "all" | "weak" | "none",
+    "OWNERSHIP_COLORS" : {"B": [0.0, 0.0, 0.10, 0.75], "W": [0.92, 0.92, 1.0, 0.800]},
+    "BLOCKS_THRESHOLD" : 0.6,
+    "MARK_SIZE" : 0.42,  # as fraction of stone size
+    "STONE_MIN_ALPHA" : 0.5
+}
+```
+
+The colors are specified as RGB values and a maximum alpha transparency.
+
+## Installation
+
+* To install a theme, simply unzip the theme.zip to your .katrain folder. 
+  * On Windows you can find it in C:\Users\you\\.katrain and on linux in ~/.katrain.
+  * When in doubt, the general settings dialog will also show the location.
+* To uninstall a theme, remove theme.json and all relevant images from that folder.
+
+## Available themes
+
+### Alternate board/stones theme by "koast"
+
+[Download](https://github.com/sanderland/katrain/blob/master/themes/koast-theme.zip)
+
+<img src="https://raw.githubusercontent.com/sanderland/katrain/master/themes/koast.png" width="500">
+
+### Lizzie-like theme
+
+* Theme created by Eric W, includes modified board, stones
+* Images taken from [Lizzie](https://github.com/featurecat/lizzie/) by featurecat and contributors.
+* Hides hints for low visit/uncertain moves instead of showing small dots. 
+
+[Download](https://github.com/sanderland/katrain/blob/master/themes/eric-lizzie-look.zip)
+
+<img src="https://raw.githubusercontent.com/sanderland/katrain/master/themes/eric-lizzie.png" width="500">
+
+### Milos Theme
+* Clean and crisp display.
+* Blocks for territory, textureless evaluation markers, no dots/alpha/etc with redundant ownership/strength info.
+* Resembles AI Sensei's design.
+
+[Download](themes/theme-milos.zip)
+
+<img src="themes/milos.png" width="500">
+
+### Jeff sounds
+
+* This theme makes Jeff comment `Ahhh?` and `What?!` when you make mistakes.
+* Sounds provided by Mikkgo.
+
+[Download](https://github.com/sanderland/katrain/blob/master/themes/jeff-sounds.zip)
+

i18n.py

@@ -0,0 +1,125 @@
+import copy
+import glob
+import os
+import re
+import sys
+from collections import defaultdict
+
+import polib
+
+localedir = "katrain/i18n/locales"
+locales = set(os.listdir(localedir))
+print("locales found:", locales)
+
+strings_to_langs = defaultdict(dict)
+strings_to_keys = defaultdict(dict)
+lang_to_strings = defaultdict(set)
+
+DEFAULT_LANG = "en"
+INACTIVE_LANGS = ["es"]
+errors = False
+
+po = {}
+pofile = {}
+todos = defaultdict(list)
+
+for lang in locales:
+    if lang in INACTIVE_LANGS:
+        continue
+    pofile[lang] = os.path.join(localedir, lang, "LC_MESSAGES", "katrain.po")
+    po[lang] = polib.pofile(pofile[lang])
+    for entry in po[lang].translated_entries():
+        if "TODO" in entry.comment and "DEPRECATED" not in entry.comment:
+            todos[lang].append(entry)
+        strings_to_langs[entry.msgid][lang] = entry
+        strings_to_keys[entry.msgid][lang] = set(re.findall("{.*?}", entry.msgstr))
+        if entry.msgid in lang_to_strings[lang]:
+            print("duplicate", entry.msgid, "in", lang, "--> deleting", entry.msgstr)
+            errors = True
+            po[lang].remove(entry)
+        else:
+            lang_to_strings[lang].add(entry.msgid)
+    if todos[lang] and any("todo" in a for a in sys.argv):
+        print(f"========== {lang} has {len(todos[lang])} TODO entries ========== ")
+        for item in todos[lang]:
+            print(item)
+
+
+for lang in locales:
+    if lang in INACTIVE_LANGS:
+        continue
+    if lang != DEFAULT_LANG:
+        for msgid in lang_to_strings[lang]:
+            if (
+                DEFAULT_LANG in strings_to_keys[msgid]
+                and strings_to_keys[msgid][lang] != strings_to_keys[msgid][DEFAULT_LANG]
+            ):
+                print(
+                    f"{msgid} has inconstent formatting keys for {lang}: ",
+                    strings_to_keys[msgid][lang],
+                    "is different from default",
+                    strings_to_keys[msgid][DEFAULT_LANG],
+                )
+                errors = True
+
+    for msgid in strings_to_langs.keys() - lang_to_strings[lang]:
+        if lang == DEFAULT_LANG:
+            print("Message id", msgid, "found as ", strings_to_langs[msgid], "but missing in default", DEFAULT_LANG)
+            errors = True
+        elif DEFAULT_LANG in strings_to_langs[msgid]:
+            copied_entry = copy.copy(strings_to_langs[msgid][DEFAULT_LANG])
+            print("Message id", msgid, "missing in ", lang, "-> Adding it from", DEFAULT_LANG)
+            if copied_entry.comment:
+                copied_entry.comment = f"TODO - {copied_entry.comment}"
+            else:
+                copied_entry.comment = "TODO"
+            po[lang].append(copied_entry)
+            errors = True
+        else:
+            print(f"MISSING IN DEFAULT AND {lang}", msgid)
+            errors = True
+
+    for msgid, lang_entries in strings_to_langs.items():
+        if lang in lang_entries and "TODO" in lang_entries[lang].comment:
+            if any(e.msgstr == lang_entries[lang].msgstr for ll, e in lang_entries.items() if ll != lang):
+                if lang_entries.get(DEFAULT_LANG):
+                    todo_comment = (
+                        f"TODO - {lang_entries[DEFAULT_LANG].comment}" if lang_entries[DEFAULT_LANG].comment else "TODO"
+                    )  # update todo
+                    if (
+                        lang_entries[lang].msgstr != lang_entries[DEFAULT_LANG].msgstr
+                        or lang_entries[lang].comment.replace("\n", " ") != todo_comment
+                    ):
+                        print(
+                            [
+                                lang_entries[lang].msgstr,
+                                lang_entries[DEFAULT_LANG].msgstr,
+                                lang_entries[lang].comment,
+                                todo_comment,
+                            ]
+                        )
+                        lang_entries[lang].msgstr = lang_entries[DEFAULT_LANG].msgstr  # update
+                        lang_entries[lang].comment = todo_comment
+                        print(f"{lang}/{msgid} todo entry updated")
+
+    po[lang].save(pofile[lang])
+    mofile = pofile[lang].replace(".po", ".mo")
+    po[lang].save_as_mofile(mofile)
+    print("Fixed", pofile[lang], "and converted ->", mofile)
+
+
+for ext in ["py", "kv"]:
+    lc = 0
+    for file in glob.glob(f"katrain/*.{ext}") + glob.glob(f"katrain/**/*.{ext}"):
+        with open(file, "r") as f:
+            for i, line in enumerate(f.readlines()):
+                if line.strip():
+                    lc += 1
+                matches = [m.strip() for m in re.findall(r"i18n._\((.*?)\)", line)]
+                for msgid in matches:
+                    stripped_msgid = msgid.strip("\"'")
+                    if stripped_msgid and msgid[0] in ['"', "'"] and stripped_msgid not in strings_to_langs:  # not code
+                        print(f"Missing {msgid} used in code at \t{file}:{i} \t'{line.strip()}'")
+                        errors += 1
+    print(f"Checked {lc} lines of {ext} code for missing i18n entries.")
+sys.exit(int(errors))

katrain.py

@@ -0,0 +1,4 @@
+# for backward compatibility
+from katrain.__main__ import run_app
+
+run_app()

katrain/KataGo/OpenCL.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0c835106eafe5b4816b90a73b613c34b9542d076813df541d65f04f03b012033
+size 107520

katrain/KataGo/analysis_config.cfg

@@ -0,0 +1,240 @@
+# Example config for C++ (non-python) gtp bot
+
+# SEE NOTES ABOUT PERFORMANCE AND MEMORY USAGE IN gtp_example.cfg
+# SEE NOTES ABOUT numSearchThreads AND OTHER IMPORTANT PARAMS BELOW!
+
+# Logs------------------------------------------------------------------------------------
+
+# Where to output log?
+# logFile = analysis.log  # Use this instead of logDir to just specify a single file directly
+# logToStderr = true      # Echo everything output to log file to stderr as well
+# logAllRequests = false  # Log all input lines received to the analysis engine.
+# logAllResponses = false # Log all lines output to stdout from the analysis engine.
+# logSearchInfo = false   # Log debug info for every search performed
+
+# Controls the number of moves after the first move in a variation.
+# analysisPVLen = 15
+
+# Report winrates for analysis as (BLACK|WHITE|SIDETOMOVE).
+reportAnalysisWinratesAs = BLACK
+
+# Bot behavior---------------------------------------------------------------------------------------
+
+# Handicap -------------
+
+# Assume that if black makes many moves in a row right at the start of the game, then the game is a handicap game.
+# This is necessary on some servers and for some GUIs and also when initializing from many SGF files, which may
+# set up a handicap games using repeated GTP "play" commands for black rather than GTP "place_free_handicap" commands.
+# However, it may also lead to incorrect undersanding of komi if whiteBonusPerHandicapStone = 1 and a server does NOT
+# have such a practice.
+# Defaults to true! Uncomment and set to false to disable this behavior.
+# assumeMultipleStartingBlackMovesAreHandicap = true
+
+# Passing and cleanup -------------
+
+# Make the bot never assume that its pass will end the game, even if passing would end and "win" under Tromp-Taylor rules.
+# Usually this is a good idea when using it for analysis or playing on servers where scoring may be implemented non-tromp-taylorly.
+# Defaults to true! Uncomment and set to false to disable this.
+conservativePass = true
+
+# When using territory scoring, self-play games continue beyond two passes with special cleanup
+# rules that may be confusing for human players. This option prevents the special cleanup phases from being
+# reachable when using the bot for GTP play.
+# Defaults to true! Uncomment and set to false if you want KataGo to be able to enter special cleanup.
+# For example, if you are testing it against itself, or against another bot that has precisely implemented the rules
+# documented at https://lightvector.github.io/KataGo/rules.html
+# preventCleanupPhase = true
+
+# Search limits-----------------------------------------------------------------------------------
+
+# By default, if NOT specified in an individual request, limit maximum number of root visits per search to this much
+maxVisits = 500
+# If provided, cap search time at this many seconds
+# maxTime = 60
+
+
+# numSearchThreads is the number of threads to use in each MCTS tree search in parallel for any individual position.
+# But NOTE: Analysis engine also specifies max number of POSITIONS to be able to search in parallel via command line
+# argument, -num-analysis-threads.
+
+# Parallelization across positions is more efficient since the threads on different positions operate
+# on different MCTS trees so they don't have to synchronize with each other. Also, multiple threads on the same MCTS
+# tree weakens the search (holding playouts fixed) due to out of date statistics on nodes and suboptimal exploration,
+# although the loss is still quite small for only 2,4,8 threads. So you often want to keep numSearchThreads small,
+# unlike in GTP.
+
+# But obviously you only get the benefit of parallelization across positions when you actually have lots of positions
+# that you are querying at once.
+
+# Therefore:
+# * If you plan to use the analysis engine only for batch processing large numbers of positions,
+#   it's preferable to set this to only a small number (e.g. 1,2,4) and use a higher -num-analysis-threads.
+# * But if you sometimes plan to query the analysis engine for single positions, or otherwise in smaller quantities
+#   than -num-analysis-threads, or if you plan to be user-interactive such that the response time on some individual
+#   analysis requests is important to keep low, then set this to a larger number and use somewhat fewer analysis threads,
+#   That way, individual searches complete faster due to having more threads on each one and doing fewer other ones at a time.
+
+# For 19x19 boards, weaker GPUs probably want a TOTAL number of threads (numSearchThreads * num-analysis-threads)
+# between 4 and 32. Mid-tier GPUs probably between 16 and 64. Strong GPUs probably between 32 and 256.
+# But there's no substitute for experimenting and seeing what's best for your hardware and your usage case.
+# Keep in mind that the number of threads you want doesn't necessarily have much to do with how many cores you
+# have on your system, and could easily exceed the number of cores. GPU batching is (usually) the dominant consideration.
+numAnalysisThreads = 12
+numSearchThreads = 8
+
+# nnMaxBatchSize is the max number of positions to send to a single GPU at once. Generally, it should be the case that:
+# (number of GPUs you will use * nnMaxBatchSize) >= (numSearchThreads * num-analysis-threads)
+# That way, when each threads tries to request a GPU eval, your batch size summed across GPUs is large enough to handle them
+# all at once. However, it can be sensible to set this a little smaller if you are limited on GPU memory,
+# too large a number may fail if the GPU doesn't have enough memory.
+nnMaxBatchSize = 96
+
+# Eigen-specific settings--------------------------------------
+# These only apply when using the Eigen (pure CPU) version of KataGo.
+
+# This is the number of CPU threads for evaluating the neural net on the Eigen backend.
+# It defaults to min(numAnalysisThreads * numSearchThreadsPerAnalysisThread, numCPUCores).
+# numEigenThreadsPerModel = X
+
+# Uncomment and set these smaller if you ONLY are going to use the analysis engine for smaller boards (or plan to
+# run multiple instances, with some instances only handling smaller boards). It should improve performance.
+# It may also mean you can use more threads profitably.
+# maxBoardXSizeForNNBuffer = 19
+# maxBoardYSizeForNNBuffer = 19
+
+# TO USE MULTIPLE GPUS:
+# Uncomment and set this to the number of GPUs you have and/or would like to use...
+# AND if it is more than 1, uncomment the appropriate CUDA or OpenCL section below.
+# numNNServerThreadsPerModel = 1
+
+# Other General GPU Settings-------------------------------------------------------------------------------
+
+
+# Cache up to 2 ** this many neural net evaluations in case of transpositions in the tree.
+nnCacheSizePowerOfTwo = 20
+# Size of mutex pool for nnCache is 2 ** this
+nnMutexPoolSizePowerOfTwo = 16
+# Randomize board orientation when running neural net evals?
+nnRandomize = true
+
+# TO USE MULTIPLE GPUS:
+# Set this to the number of GPUs you have and/or would like to use...
+# AND if it is more than 1, uncomment the appropriate CUDA or OpenCL section below.
+# numNNServerThreadsPerModel = 1
+
+
+# CUDA GPU settings--------------------------------------
+# These only apply when using the CUDA version of KataGo.
+
+# IF USING ONE GPU: optionally uncomment and change this if the GPU you want to use turns out to be not device 0
+# cudaDeviceToUse = 0
+
+# IF USING TWO GPUS: Uncomment these two lines (AND set numNNServerThreadsPerModel above):
+# cudaDeviceToUseThread0 = 0  # change this if the first GPU you want to use turns out to be not device 0
+# cudaDeviceToUseThread1 = 1  # change this if the second GPU you want to use turns out to be not device 1
+
+# IF USING THREE GPUS: Uncomment these three lines (AND set numNNServerThreadsPerModel above):
+# cudaDeviceToUseThread0 = 0  # change this if the first GPU you want to use turns out to be not device 0
+# cudaDeviceToUseThread1 = 1  # change this if the second GPU you want to use turns out to be not device 1
+# cudaDeviceToUseThread2 = 2  # change this if the third GPU you want to use turns out to be not device 2
+
+# You can probably guess the pattern if you have four, five, etc. GPUs.
+
+# KataGo will automatically use FP16 or not based on the compute capability of your NVIDIA GPU. If you
+# want to try to force a particular behavior though you can uncomment these lines and change them
+# to "true" or "false". E.g. it's using FP16 but on your card that's giving an error, or it's not using
+# FP16 but you think it should.
+# cudaUseFP16 = auto
+# cudaUseNHWC = auto
+
+# OpenCL GPU settings--------------------------------------
+# These only apply when using the OpenCL version of KataGo.
+
+# Uncomment to tune OpenCL for every board size separately, rather than only the largest possible size
+# openclReTunePerBoardSize = true
+
+# IF USING ONE GPU: optionally uncomment and change this if the best device to use is guessed incorrectly.
+# The default behavior tries to guess the 'best' GPU or device on your system to use, usually it will be a good guess.
+# openclDeviceToUse = 0
+
+# IF USING TWO GPUS: Uncomment these two lines and replace X and Y with the device ids of the devices you want to use.
+# It might NOT be 0 and 1, some computers will have many OpenCL devices. You can see what the devices are when
+# KataGo starts up - it should print or log all the devices it finds.
+# (AND also set numNNServerThreadsPerModel above)
+# openclDeviceToUseThread0 = X
+# openclDeviceToUseThread1 = Y
+
+# IF USING THREE GPUS: Uncomment these three lines and replace X and Y and Z with the device ids of the devices you want to use.
+# It might NOT be 0 and 1 and 2, some computers will have many OpenCL devices. You can see what the devices are when
+# KataGo starts up - it should print or log all the devices it finds.
+# (AND also set numNNServerThreadsPerModel above)
+# openclDeviceToUseThread0 = X
+# openclDeviceToUseThread1 = Y
+# openclDeviceToUseThread2 = Z
+
+# You can probably guess the pattern if you have four, five, etc. GPUs.
+
+
+# Root move selection and biases------------------------------------------------------------------------------
+# Uncomment and edit any of the below values to change them from their default.
+# Not all of these parameters are applicable to analysis, some are only used for actual play
+
+# Temperature for the early game, randomize between chosen moves with this temperature
+# chosenMoveTemperatureEarly = 0.5
+# Decay temperature for the early game by 0.5 every this many moves, scaled with board size.
+# chosenMoveTemperatureHalflife = 19
+# At the end of search after the early game, randomize between chosen moves with this temperature
+# chosenMoveTemperature = 0.10
+# Subtract this many visits from each move prior to applying chosenMoveTemperature
+# (unless all moves have too few visits) to downweight unlikely moves
+# chosenMoveSubtract = 0
+# The same as chosenMoveSubtract but only prunes moves that fall below the threshold, does not affect moves above
+# chosenMovePrune = 1
+
+# Number of symmetries to sample (WITH replacement) and average at the root
+# rootNumSymmetriesToSample = 1
+
+# Using LCB for move selection?
+# useLcbForSelection = true
+# How many stdevs a move needs to be better than another for LCB selection
+# lcbStdevs = 5.0
+# Only use LCB override when a move has this proportion of visits as the top move
+# minVisitPropForLCB = 0.15
+
+# Internal params------------------------------------------------------------------------------
+# Uncomment and edit any of the below values to change them from their default.
+
+# Scales the utility of winning/losing
+# winLossUtilityFactor = 1.0
+# Scales the utility for trying to maximize score
+# staticScoreUtilityFactor = 0.10
+# dynamicScoreUtilityFactor = 0.30
+# Adjust dynamic score center this proportion of the way towards zero, capped at a reasonable amount.
+# dynamicScoreCenterZeroWeight = 0.20
+# dynamicScoreCenterScale = 0.75
+# The utility of getting a "no result" due to triple ko or other long cycle in non-superko rulesets (-1 to 1)
+# noResultUtilityForWhite = 0.0
+# The number of wins that a draw counts as, for white. (0 to 1)
+# drawEquivalentWinsForWhite = 0.5
+
+# Exploration constant for mcts
+# cpuctExploration = 0.9
+# cpuctExplorationLog = 0.4
+# FPU reduction constant for mcts
+# fpuReductionMax = 0.2
+# rootFpuReductionMax = 0.1
+# Use parent average value for fpu base point instead of point value net estimate
+# fpuUseParentAverage = true
+# Amount to apply a downweighting of children with very bad values relative to good ones
+# valueWeightExponent = 0.5
+# Slight incentive for the bot to behave human-like with regard to passing at the end, filling the dame,
+# not wasting time playing in its own territory, etc, and not play moves that are equivalent in terms of
+# points but a bit more unfriendly to humans.
+# rootEndingBonusPoints = 0.5
+# Make the bot prune useless moves that are just prolonging the game to avoid losing yet
+# rootPruneUselessMoves = true
+
+# How big to make the mutex pool for search synchronization
+# mutexPoolSize = 8192
+# How many virtual losses to add when a thread descends through a node
+# numVirtualLossesPerThread = 1

katrain/KataGo/contribute_config.cfg

@@ -0,0 +1,94 @@
+
+serverUrl = https://katagotraining.org/
+username = x
+password = x
+
+# How many games should KataGo play at once? For good GPUs, putting too small a number here will be *very* inefficient.
+# For absolute-top-tier GPUs, try numbers like 32, 40, 64, etc.
+# For modern good middle-tier GPUs, you can try numbers like 8 or 16.
+# For very old or weak GPUs, or if you want KataGo to put less load on your system, try 4.
+maxSimultaneousGames = 4
+
+# Set to true if you want one of KataGo's games to be streamed to a text file, so you can watch.
+# Follow in a separate shell with a command like the following:
+# Linux: "tail -f watchgame.txt"
+# Windows Powershell: "Get-Content .\watchgame.txt -Tail 50 -Wait"
+watchOngoingGameInFile = false
+watchOngoingGameInFileName = watchgame.txt
+logGamesAsJson = true
+includeOwnership = false
+
+# KataGo will only use one GPU by default. You can edit the below if you have multiple GPUs and want to use them all.
+
+
+# TO USE MULTIPLE GPUS:
+# Set this to the number of GPUs you have and/or would like to use.
+# **AND** if it is more than 1, uncomment the appropriate CUDA or OpenCL section below.
+# numNNServerThreadsPerModel = 1
+
+
+# CUDA GPU settings--------------------------------------
+# These only apply when using the CUDA version of KataGo.
+
+# IF USING ONE GPU: optionally uncomment and change this if the GPU you want to use turns out to be not device 0
+# cudaDeviceToUse = 0
+
+# IF USING TWO GPUS: Uncomment these two lines (AND set numNNServerThreadsPerModel above):
+# cudaDeviceToUseThread0 = 0  # change this if the first GPU you want to use turns out to be not device 0
+# cudaDeviceToUseThread1 = 1  # change this if the second GPU you want to use turns out to be not device 1
+
+# IF USING THREE GPUS: Uncomment these three lines (AND set numNNServerThreadsPerModel above):
+# cudaDeviceToUseThread0 = 0  # change this if the first GPU you want to use turns out to be not device 0
+# cudaDeviceToUseThread1 = 1  # change this if the second GPU you want to use turns out to be not device 1
+# cudaDeviceToUseThread2 = 2  # change this if the third GPU you want to use turns out to be not device 2
+
+# You can probably guess the pattern if you have four, five, etc. GPUs.
+
+# KataGo will automatically use FP16 or not based on the compute capability of your NVIDIA GPU. If you
+# want to try to force a particular behavior though you can uncomment these lines and change them
+# to "true" or "false". E.g. it's using FP16 but on your card that's giving an error, or it's not using
+# FP16 but you think it should.
+# cudaUseFP16 = auto
+# cudaUseNHWC = auto
+
+
+# OpenCL GPU settings--------------------------------------
+# These only apply when using the OpenCL version of KataGo.
+
+# Uncomment to tune OpenCL for every board size separately, rather than only the largest possible size
+# openclReTunePerBoardSize = true
+
+# IF USING ONE GPU: optionally uncomment and change this if the best device to use is guessed incorrectly.
+# The default behavior tries to guess the 'best' GPU or device on your system to use, usually it will be a good guess.
+# openclDeviceToUse = 0
+
+# IF USING TWO GPUS: Uncomment these two lines and replace X and Y with the device ids of the devices you want to use.
+# It might NOT be 0 and 1, some computers will have many OpenCL devices. You can see what the devices are when
+# KataGo starts up - it should print or log all the devices it finds.
+# (AND also set numNNServerThreadsPerModel above)
+# openclDeviceToUseThread0 = X
+# openclDeviceToUseThread1 = Y
+
+# IF USING THREE GPUS: Uncomment these three lines and replace X and Y and Z with the device ids of the devices you want to use.
+# It might NOT be 0 and 1 and 2, some computers will have many OpenCL devices. You can see what the devices are when
+# KataGo starts up - it should print or log all the devices it finds.
+# (AND also set numNNServerThreadsPerModel above)
+# openclDeviceToUseThread0 = X
+# openclDeviceToUseThread1 = Y
+# openclDeviceToUseThread2 = Z
+
+# You can probably guess the pattern if you have four, five, etc. GPUs.
+
+# KataGo will automatically use FP16 or not based on testing your GPU during tuning. If you
+# want to try to force a particular behavior though you can uncomment this lines and change it
+# to "true" or "false". This is a fairly blunt setting - more detailed settings are testable
+# by rerunning the tuner with various arguments.
+# openclUseFP16 = auto
+
+
+# Eigen-specific settings--------------------------------------
+# These only apply when using the Eigen (pure CPU) version of KataGo.
+
+# This is the number of CPU threads for evaluating the neural net on the Eigen backend.
+# It defaults to numSearchThreads.
+# numEigenThreadsPerModel = X

katrain/KataGo/katago

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ebe2c7dea9c1adf68ae5430509d2faff218f2bb54dcaa090d339554df792f2d9
+size 944632

katrain/KataGo/katago.exe

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0684e4f608dc9614e2ac8a068bc66611e7e1dd78a48ad3d2369a66fc304c5e54
+size 4754432

katrain/KataGo/libcrypto-1_1-x64.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fef9b83b1ab802d411db78eac01e684e34ca090960d9b88618f054b29f36d9ee
+size 3409920

katrain/KataGo/libcrypto-3-x64.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1f6560dc57d177417932d04295fcb5f5b9b3414bd3baa75897d8e8bb49e904b7
+size 5148672

katrain/KataGo/libssl-1_1-x64.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e803bd8ba59f750935c4e460ff8cb2f37cf03be114380c13c6008b94fdd4a241
+size 682496

katrain/KataGo/libssl-3-x64.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:45434db8a17a9ddf3953d85de7e2e4d0c22866593c490e18128ee5c7931db6d1
+size 776704

katrain/KataGo/libz.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f41b06ae70e84ce4215e657a9fed61b71b590423d0b19687dced8f95d759b319
+size 95232

katrain/KataGo/libzip.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1c3151e9eab8bddffffd0cd180a5258b0de6cb8e780e47f7bd61b48875c1522f
+size 184832

katrain/KataGo/msvcp140.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:003da4807acdc912e67edba49be574daa5238bb7acff871d8666d16f8072ff89
+size 579920

katrain/KataGo/msvcp140_1.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a61901a4d719a3e1cc4fa8f629218571330331e8dde2ef1f05c34845b180928e
+size 35664

katrain/KataGo/msvcp140_2.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3d15cfe238ac1863bbe65501f05d561162f28032b80f2c8d9a1fc7b22f8445a2
+size 197488

katrain/KataGo/msvcp140_atomic_wait.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0fcf613254644c2ea451a693d7737741b8041f11decb8feffd3b34e00220620a
+size 50032

katrain/KataGo/msvcp140_codecvt_ids.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a714b498ab7b4b0508e69f66ca15196df605844d4d6d5e43969a5f1fd7d7e9e4
+size 31600

katrain/KataGo/vcruntime140.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a8f950b4357ec12cfccddc9094cca56a3d5244b95e09ea6e9a746489f2d58736
+size 109392

katrain/KataGo/vcruntime140_1.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e4b533a94e02c574780e4b333fcf0889f65ed00d39e32c0fbbda2116f185873f
+size 49520

katrain/__main__.py

@@ -0,0 +1,984 @@
+"""isort:skip_file"""
+
+# first, logging level lower
+import os
+import sys
+
+os.environ["KCFG_KIVY_LOG_LEVEL"] = os.environ.get("KCFG_KIVY_LOG_LEVEL", "warning")
+
+from kivy.utils import platform as kivy_platform
+
+if kivy_platform == "win":
+    from ctypes import windll, c_int64
+
+    if hasattr(windll.user32, "SetProcessDpiAwarenessContext"):
+        windll.user32.SetProcessDpiAwarenessContext(c_int64(-4))
+
+import kivy
+
+kivy.require("2.0.0")
+
+# next, icon
+from katrain.core.utils import find_package_resource, PATHS
+from kivy.config import Config
+
+if kivy_platform == "macosx":
+    ICON = find_package_resource("katrain/img/icon.icns")
+else:
+    ICON = find_package_resource("katrain/img/icon.ico")
+Config.set("kivy", "window_icon", ICON)
+Config.set("input", "mouse", "mouse,multitouch_on_demand")
+
+# next, certificates on package builds https://github.com/sanderland/katrain/issues/414
+if getattr(sys, "frozen", False):
+    import ssl
+
+    if ssl.get_default_verify_paths().cafile is None and hasattr(sys, "_MEIPASS"):
+        os.environ["SSL_CERT_FILE"] = os.path.join(sys._MEIPASS, "certifi", "cacert.pem")
+
+
+import re
+import signal
+import json
+import threading
+import traceback
+from queue import Queue
+import urllib3
+import webbrowser
+import time
+import random
+import glob
+
+from kivy.base import ExceptionHandler, ExceptionManager
+from kivy.app import App
+from kivy.core.clipboard import Clipboard
+from kivy.lang import Builder
+from kivy.resources import resource_add_path
+from kivy.uix.popup import Popup
+from kivy.uix.screenmanager import Screen
+from kivy.core.window import Window
+from kivy.uix.widget import Widget
+from kivy.resources import resource_find
+from kivy.properties import NumericProperty, ObjectProperty, StringProperty
+from kivy.clock import Clock
+from kivy.metrics import dp
+from katrain.core.ai import generate_ai_move
+
+from katrain.core.lang import DEFAULT_LANGUAGE, i18n
+from katrain.core.constants import (
+    OUTPUT_ERROR,
+    OUTPUT_KATAGO_STDERR,
+    OUTPUT_INFO,
+    OUTPUT_DEBUG,
+    OUTPUT_EXTRA_DEBUG,
+    MODE_ANALYZE,
+    HOMEPAGE,
+    VERSION,
+    STATUS_ERROR,
+    STATUS_INFO,
+    PLAYING_NORMAL,
+    PLAYER_HUMAN,
+    SGF_INTERNAL_COMMENTS_MARKER,
+    MODE_PLAY,
+    DATA_FOLDER,
+    AI_DEFAULT,
+)
+from katrain.gui.popups import (
+    ConfigTeacherPopup,
+    ConfigTimerPopup,
+    I18NPopup,
+    SaveSGFPopup,
+    ContributePopup,
+    EngineRecoveryPopup,
+)
+from katrain.gui.sound import play_sound
+from katrain.core.base_katrain import KaTrainBase
+from katrain.core.engine import KataGoEngine
+from katrain.core.contribute_engine import KataGoContributeEngine
+from katrain.core.game import Game, IllegalMoveException, KaTrainSGF, BaseGame
+from katrain.core.sgf_parser import Move, ParseError
+from katrain.gui.popups import ConfigPopup, LoadSGFPopup, NewGamePopup, ConfigAIPopup
+from katrain.gui.theme import Theme
+from kivymd.app import MDApp
+
+# used in kv
+from katrain.gui.kivyutils import *
+from katrain.gui.widgets import MoveTree, I18NFileBrowser, SelectionSlider, ScoreGraph  # noqa F401
+from katrain.gui.badukpan import AnalysisControls, BadukPanControls, BadukPanWidget  # noqa F401
+from katrain.gui.controlspanel import ControlsPanel  # noqa F401
+
+
+class KaTrainGui(Screen, KaTrainBase):
+    """Top level class responsible for tying everything together"""
+
+    zen = NumericProperty(0)
+    controls = ObjectProperty(None)
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.engine = None
+        self.contributing = False
+
+        self.new_game_popup = None
+        self.fileselect_popup = None
+        self.config_popup = None
+        self.ai_settings_popup = None
+        self.teacher_settings_popup = None
+        self.timer_settings_popup = None
+        self.contribute_popup = None
+
+        self.pondering = False
+        self.show_move_num = False
+
+        self.animate_contributing = False
+        self.message_queue = Queue()
+
+        self.last_key_down = None
+        self.last_focus_event = 0
+
+    def log(self, message, level=OUTPUT_INFO):
+        super().log(message, level)
+        if level == OUTPUT_KATAGO_STDERR and "ERROR" not in self.controls.status.text:
+            if self.contributing:
+                self.controls.set_status(message, STATUS_INFO)
+            elif "starting" in message.lower():
+                self.controls.set_status("KataGo engine starting...", STATUS_INFO)
+            elif message.startswith("Tuning"):
+                self.controls.set_status(
+                    "KataGo is tuning settings for first startup, please wait." + message, STATUS_INFO
+                )
+                return
+            elif "ready" in message.lower():
+                self.controls.set_status("KataGo engine ready.", STATUS_INFO)
+        if (
+            level == OUTPUT_ERROR
+            or (level == OUTPUT_KATAGO_STDERR and "error" in message.lower() and "tuning" not in message.lower())
+        ) and getattr(self, "controls", None):
+            self.controls.set_status(f"ERROR: {message}", STATUS_ERROR)
+
+    def handle_animations(self, *_args):
+        if self.contributing and self.animate_contributing:
+            self.engine.advance_showing_game()
+        if (self.contributing and self.animate_contributing) or self.pondering:
+            self.board_controls.engine_status_pondering += 5
+        else:
+            self.board_controls.engine_status_pondering = -1
+
+    @property
+    def play_analyze_mode(self):
+        return self.play_mode.mode
+
+    def toggle_continuous_analysis(self, quiet=False):
+        if self.contributing:
+            self.animate_contributing = not self.animate_contributing
+        else:
+            if self.pondering:
+                self.controls.set_status("", STATUS_INFO)
+            elif not quiet:  # See #549
+                Clock.schedule_once(self.analysis_controls.hints.activate, 0)
+            self.pondering = not self.pondering
+            self.update_state()
+
+    def toggle_move_num(self):
+        self.show_move_num = not self.show_move_num
+        self.update_state()
+
+    def start(self):
+        if self.engine:
+            return
+        self.board_gui.trainer_config = self.config("trainer")
+        self.engine = KataGoEngine(self, self.config("engine"))
+        threading.Thread(target=self._message_loop_thread, daemon=True).start()
+        sgf_args = [
+            f
+            for f in sys.argv[1:]
+            if os.path.isfile(f) and any(f.lower().endswith(ext) for ext in ["sgf", "ngf", "gib"])
+        ]
+        if sgf_args:
+            self.load_sgf_file(sgf_args[0], fast=True, rewind=True)
+        else:
+            self._do_new_game()
+
+        Clock.schedule_interval(self.handle_animations, 0.1)
+        Window.request_keyboard(None, self, "").bind(on_key_down=self._on_keyboard_down, on_key_up=self._on_keyboard_up)
+
+        def set_focus_event(*args):
+            self.last_focus_event = time.time()
+
+        MDApp.get_running_app().root_window.bind(focus=set_focus_event)
+
+    def update_gui(self, cn, redraw_board=False):
+        # Handle prisoners and next player display
+        prisoners = self.game.prisoner_count
+        top, bot = [w.__self__ for w in self.board_controls.circles]  # no weakref
+        if self.next_player_info.player == "W":
+            top, bot = bot, top
+            self.controls.players["W"].active = True
+            self.controls.players["B"].active = False
+        else:
+            self.controls.players["W"].active = False
+            self.controls.players["B"].active = True
+        self.board_controls.mid_circles_container.clear_widgets()
+        self.board_controls.mid_circles_container.add_widget(bot)
+        self.board_controls.mid_circles_container.add_widget(top)
+
+        self.controls.players["W"].captures = prisoners["W"]
+        self.controls.players["B"].captures = prisoners["B"]
+
+        # update engine status dot
+        if not self.engine or not self.engine.katago_process or self.engine.katago_process.poll() is not None:
+            self.board_controls.engine_status_col = Theme.ENGINE_DOWN_COLOR
+        elif self.engine.is_idle():
+            self.board_controls.engine_status_col = Theme.ENGINE_READY_COLOR
+        else:
+            self.board_controls.engine_status_col = Theme.ENGINE_BUSY_COLOR
+        self.board_controls.queries_remaining = self.engine.queries_remaining()
+
+        # redraw board/stones
+        if redraw_board:
+            self.board_gui.draw_board()
+        self.board_gui.redraw_board_contents_trigger()
+        self.controls.update_evaluation()
+        self.controls.update_timer(1)
+        # update move tree
+        self.controls.move_tree.current_node = self.game.current_node
+
+    def update_state(self, redraw_board=False):  # redirect to message queue thread
+        self("update_state", redraw_board=redraw_board)
+
+    def _do_update_state(
+        self, redraw_board=False
+    ):  # is called after every message and on receiving analyses and config changes
+        # AI and Trainer/auto-undo handlers
+        if not self.game or not self.game.current_node:
+            return
+        cn = self.game.current_node
+        if not self.contributing:
+            last_player, next_player = self.players_info[cn.player], self.players_info[cn.next_player]
+            if self.play_analyze_mode == MODE_PLAY and self.nav_drawer.state != "open" and self.popup_open is None:
+                points_lost = cn.points_lost
+                if (
+                    last_player.human
+                    and cn.analysis_complete
+                    and points_lost is not None
+                    and points_lost > self.config("trainer/eval_thresholds")[-4]
+                ):
+                    self.play_mistake_sound(cn)
+                teaching_undo = cn.player and last_player.being_taught and cn.parent
+                if (
+                    teaching_undo
+                    and cn.analysis_complete
+                    and cn.parent.analysis_complete
+                    and not cn.children
+                    and not self.game.end_result
+                ):
+                    self.game.analyze_undo(cn)  # not via message loop
+                if (
+                    cn.analysis_complete
+                    and next_player.ai
+                    and not cn.children
+                    and not self.game.end_result
+                    and not (teaching_undo and cn.auto_undo is None)
+                ):  # cn mismatch stops this if undo fired. avoid message loop here or fires repeatedly.
+                    self._do_ai_move(cn)
+                    Clock.schedule_once(self._play_stone_sound, 0.25)
+            if self.engine:
+                if self.pondering:
+                    self.game.analyze_extra("ponder")
+                else:
+                    self.engine.stop_pondering()
+        Clock.schedule_once(lambda _dt: self.update_gui(cn, redraw_board=redraw_board), -1)  # trigger?
+
+    def update_player(self, bw, **kwargs):
+        super().update_player(bw, **kwargs)
+        if self.game:
+            sgf_name = self.game.root.get_property("P" + bw)
+            self.players_info[bw].name = None if not sgf_name or SGF_INTERNAL_COMMENTS_MARKER in sgf_name else sgf_name
+        if self.controls:
+            self.controls.update_players()
+            self.update_state()
+        for player_setup_block in PlayerSetupBlock.INSTANCES:
+            player_setup_block.update_player_info(bw, self.players_info[bw])
+
+    def set_note(self, note):
+        self.game.current_node.note = note
+
+    # The message loop is here to make sure moves happen in the right order, and slow operations don't hang the GUI
+    def _message_loop_thread(self):
+        while True:
+            game, msg, args, kwargs = self.message_queue.get()
+            try:
+                self.log(f"Message Loop Received {msg}: {args} for Game {game}", OUTPUT_EXTRA_DEBUG)
+                if game != self.game.game_id:
+                    self.log(
+                        f"Message skipped as it is outdated (current game is {self.game.game_id}", OUTPUT_EXTRA_DEBUG
+                    )
+                    continue
+                msg = msg.replace("-", "_")
+                if self.contributing:
+                    if msg not in [
+                        "katago_contribute",
+                        "redo",
+                        "undo",
+                        "update_state",
+                        "save_game",
+                        "find_mistake",
+                    ]:
+                        self.controls.set_status(
+                            i18n._("gui-locked").format(action=msg), STATUS_INFO, check_level=False
+                        )
+                        continue
+                fn = getattr(self, f"_do_{msg}")
+                fn(*args, **kwargs)
+                if msg != "update_state":
+                    self._do_update_state()
+            except Exception as exc:
+                self.log(f"Exception in processing message {msg} {args}: {exc}", OUTPUT_ERROR)
+                traceback.print_exc()
+
+    def __call__(self, message, *args, **kwargs):
+        if self.game:
+            if message.endswith("popup"):  # gui code needs to run in main kivy thread.
+                if self.contributing and "save" not in message and message != "contribute-popup":
+                    self.controls.set_status(
+                        i18n._("gui-locked").format(action=message), STATUS_INFO, check_level=False
+                    )
+                    return
+                fn = getattr(self, f"_do_{message.replace('-', '_')}")
+                Clock.schedule_once(lambda _dt: fn(*args, **kwargs), -1)
+            else:  # game related actions
+                self.message_queue.put([self.game.game_id, message, args, kwargs])
+
+    def _do_new_game(self, move_tree=None, analyze_fast=False, sgf_filename=None):
+        self.pondering = False
+        mode = self.play_analyze_mode
+        if (move_tree is not None and mode == MODE_PLAY) or (move_tree is None and mode == MODE_ANALYZE):
+            self.play_mode.switch_ui_mode()  # for new game, go to play, for loaded, analyze
+        self.board_gui.animating_pv = None
+        self.board_gui.reset_rotation()
+        self.engine.on_new_game()  # clear queries
+        self.game = Game(
+            self,
+            self.engine,
+            move_tree=move_tree,
+            analyze_fast=analyze_fast or not move_tree,
+            sgf_filename=sgf_filename,
+        )
+        for bw, player_info in self.players_info.items():
+            player_info.sgf_rank = self.game.root.get_property(bw + "R")
+            player_info.calculated_rank = None
+            if sgf_filename is not None:  # load game->no ai player
+                player_info.player_type = PLAYER_HUMAN
+                player_info.player_subtype = PLAYING_NORMAL
+            self.update_player(bw, player_type=player_info.player_type, player_subtype=player_info.player_subtype)
+        self.controls.graph.initialize_from_game(self.game.root)
+        self.update_state(redraw_board=True)
+
+    def _do_katago_contribute(self):
+        if self.contributing and not self.engine.server_error and self.engine.katago_process is not None:
+            return
+        self.contributing = self.animate_contributing = True  # special mode
+        if self.play_analyze_mode == MODE_PLAY:  # switch to analysis view
+            self.play_mode.switch_ui_mode()
+        self.pondering = False
+        self.board_gui.animating_pv = None
+        for bw, player_info in self.players_info.items():
+            self.update_player(bw, player_type=PLAYER_AI, player_subtype=AI_DEFAULT)
+        self.engine.shutdown(finish=False)
+        self.engine = KataGoContributeEngine(self)
+        self.game = BaseGame(self)
+
+    def _do_insert_mode(self, mode="toggle"):
+        self.game.set_insert_mode(mode)
+        if self.play_analyze_mode != MODE_ANALYZE:
+            self.play_mode.switch_ui_mode()
+
+    def _do_ai_move(self, node=None):
+        if node is None or self.game.current_node == node:
+            mode = self.next_player_info.strategy
+            settings = self.config(f"ai/{mode}")
+            if settings is not None:
+                generate_ai_move(self.game, mode, settings)
+            else:
+                self.log(f"AI Mode {mode} not found!", OUTPUT_ERROR)
+
+    def _do_undo(self, n_times=1):
+        if n_times == "smart":
+            n_times = 1
+            if self.play_analyze_mode == MODE_PLAY and self.last_player_info.ai and self.next_player_info.human:
+                n_times = 2
+        self.board_gui.animating_pv = None
+        self.game.undo(n_times)
+
+    def _do_reset_analysis(self):
+        self.game.reset_current_analysis()
+
+    def _do_resign(self):
+        self.game.current_node.end_state = f"{self.game.current_node.player}+R"
+
+    def _do_redo(self, n_times=1):
+        self.board_gui.animating_pv = None
+        self.game.redo(n_times)
+
+    def _do_rotate(self):
+        self.board_gui.rotate_gridpos()
+
+    def _do_find_mistake(self, fn="redo"):
+        self.board_gui.animating_pv = None
+        getattr(self.game, fn)(9999, stop_on_mistake=self.config("trainer/eval_thresholds")[-4])
+
+    def _do_switch_branch(self, *args):
+        self.board_gui.animating_pv = None
+        self.controls.move_tree.switch_branch(*args)
+
+    def _play_stone_sound(self, _dt=None):
+        play_sound(random.choice(Theme.STONE_SOUNDS))
+
+    def _do_play(self, coords):
+        self.board_gui.animating_pv = None
+        try:
+            old_prisoner_count = self.game.prisoner_count["W"] + self.game.prisoner_count["B"]
+            self.game.play(Move(coords, player=self.next_player_info.player))
+            if old_prisoner_count < self.game.prisoner_count["W"] + self.game.prisoner_count["B"]:
+                play_sound(Theme.CAPTURING_SOUND)
+            elif not self.game.current_node.is_pass:
+                self._play_stone_sound()
+
+        except IllegalMoveException as e:
+            self.controls.set_status(f"Illegal Move: {str(e)}", STATUS_ERROR)
+
+    def _do_analyze_extra(self, mode, **kwargs):
+        self.game.analyze_extra(mode, **kwargs)
+
+    def _do_selfplay_setup(self, until_move, target_b_advantage=None):
+        self.game.selfplay(int(until_move) if isinstance(until_move, float) else until_move, target_b_advantage)
+
+    def _do_select_box(self):
+        self.controls.set_status(i18n._("analysis:region:start"), STATUS_INFO)
+        self.board_gui.selecting_region_of_interest = True
+
+    def _do_new_game_popup(self):
+        self.controls.timer.paused = True
+        if not self.new_game_popup:
+            self.new_game_popup = I18NPopup(
+                title_key="New Game title", size=[dp(800), dp(900)], content=NewGamePopup(self)
+            ).__self__
+            self.new_game_popup.content.popup = self.new_game_popup
+        self.new_game_popup.open()
+        self.new_game_popup.content.update_from_current_game()
+
+    def _do_timer_popup(self):
+        self.controls.timer.paused = True
+        if not self.timer_settings_popup:
+            self.timer_settings_popup = I18NPopup(
+                title_key="timer settings", size=[dp(600), dp(500)], content=ConfigTimerPopup(self)
+            ).__self__
+            self.timer_settings_popup.content.popup = self.timer_settings_popup
+        self.timer_settings_popup.open()
+
+    def _do_teacher_popup(self):
+        self.controls.timer.paused = True
+        if not self.teacher_settings_popup:
+            self.teacher_settings_popup = I18NPopup(
+                title_key="teacher settings", size=[dp(800), dp(825)], content=ConfigTeacherPopup(self)
+            ).__self__
+            self.teacher_settings_popup.content.popup = self.teacher_settings_popup
+        self.teacher_settings_popup.open()
+
+    def _do_config_popup(self):
+        self.controls.timer.paused = True
+        if not self.config_popup:
+            self.config_popup = I18NPopup(
+                title_key="general settings title", size=[dp(1200), dp(950)], content=ConfigPopup(self)
+            ).__self__
+            self.config_popup.content.popup = self.config_popup
+            self.config_popup.title += ": " + self.config_file
+        self.config_popup.open()
+
+    def _do_contribute_popup(self):
+        if not self.contribute_popup:
+            self.contribute_popup = I18NPopup(
+                title_key="contribute settings title", size=[dp(1100), dp(800)], content=ContributePopup(self)
+            ).__self__
+            self.contribute_popup.content.popup = self.contribute_popup
+        self.contribute_popup.open()
+
+    def _do_ai_popup(self):
+        self.controls.timer.paused = True
+        if not self.ai_settings_popup:
+            self.ai_settings_popup = I18NPopup(
+                title_key="ai settings", size=[dp(750), dp(750)], content=ConfigAIPopup(self)
+            ).__self__
+            self.ai_settings_popup.content.popup = self.ai_settings_popup
+        self.ai_settings_popup.open()
+
+    def _do_engine_recovery_popup(self, error_message, code):
+        current_open = self.popup_open
+        if current_open and isinstance(current_open.content, EngineRecoveryPopup):
+            self.log(f"Not opening engine recovery popup with {error_message} as one is already open", OUTPUT_DEBUG)
+            return
+        popup = I18NPopup(
+            title_key="engine recovery",
+            size=[dp(600), dp(700)],
+            content=EngineRecoveryPopup(self, error_message=error_message, code=code),
+        ).__self__
+        popup.content.popup = popup
+        popup.open()
+
+    def _do_tsumego_frame(self, ko, margin):
+        from katrain.core.tsumego_frame import tsumego_frame_from_katrain_game
+
+        if not self.game.stones:
+            return
+
+        black_to_play_p = self.next_player_info.player == "B"
+        node, analysis_region = tsumego_frame_from_katrain_game(
+            self.game, self.game.komi, black_to_play_p, ko_p=ko, margin=margin
+        )
+        self.game.set_current_node(node)
+        if self.play_mode.mode == MODE_PLAY:
+            self.play_mode.switch_ui_mode()  # go to analysis mode
+        if analysis_region:
+            flattened_region = [
+                analysis_region[0][1],
+                analysis_region[0][0],
+                analysis_region[1][1],
+                analysis_region[1][0],
+            ]
+            self.game.set_region_of_interest(flattened_region)
+        node.analyze(self.game.engines[node.next_player])
+        self.update_state(redraw_board=True)
+
+    def play_mistake_sound(self, node):
+        if self.config("timer/sound") and node.played_mistake_sound is None and Theme.MISTAKE_SOUNDS:
+            node.played_mistake_sound = True
+            play_sound(random.choice(Theme.MISTAKE_SOUNDS))
+
+    def load_sgf_file(self, file, fast=False, rewind=True):
+        if self.contributing:
+            return
+        try:
+            file = os.path.abspath(file)
+            move_tree = KaTrainSGF.parse_file(file)
+        except (ParseError, FileNotFoundError) as e:
+            self.log(i18n._("Failed to load SGF").format(error=e), OUTPUT_ERROR)
+            return
+        self._do_new_game(move_tree=move_tree, analyze_fast=fast, sgf_filename=file)
+        if not rewind:
+            self.game.redo(999)
+
+    def _do_analyze_sgf_popup(self):
+        if not self.fileselect_popup:
+            popup_contents = LoadSGFPopup(self)
+            popup_contents.filesel.path = os.path.abspath(os.path.expanduser(self.config("general/sgf_load", ".")))
+            self.fileselect_popup = I18NPopup(
+                title_key="load sgf title", size=[dp(1200), dp(800)], content=popup_contents
+            ).__self__
+
+            def readfile(*_args):
+                filename = popup_contents.filesel.filename
+                self.fileselect_popup.dismiss()
+                path, file = os.path.split(filename)
+                if path != self.config("general/sgf_load"):
+                    self.log(f"Updating sgf load path default to {path}", OUTPUT_DEBUG)
+                    self._config["general"]["sgf_load"] = path
+                popup_contents.update_config(False)
+                self.save_config("general")
+                self.load_sgf_file(filename, popup_contents.fast.active, popup_contents.rewind.active)
+
+            popup_contents.filesel.on_success = readfile
+            popup_contents.filesel.on_submit = readfile
+        self.fileselect_popup.open()
+        self.fileselect_popup.content.filesel.ids.list_view._trigger_update()
+
+    def _do_save_game(self, filename=None):
+        filename = filename or self.game.sgf_filename
+        if not filename:
+            return self("save-game-as-popup")
+        try:
+            msg = self.game.write_sgf(filename)
+            self.log(msg, OUTPUT_INFO)
+            self.controls.set_status(msg, STATUS_INFO, check_level=False)
+        except Exception as e:
+            self.log(f"Failed to save SGF to {filename}: {e}", OUTPUT_ERROR)
+
+    def _do_save_game_as_popup(self):
+        popup_contents = SaveSGFPopup(suggested_filename=self.game.generate_filename())
+        save_game_popup = I18NPopup(
+            title_key="save sgf title", size=[dp(1200), dp(800)], content=popup_contents
+        ).__self__
+
+        def readfile(*_args):
+            filename = popup_contents.filesel.filename
+            if not filename.lower().endswith(".sgf"):
+                filename += ".sgf"
+            save_game_popup.dismiss()
+            path, file = os.path.split(filename.strip())
+            if not path:
+                path = popup_contents.filesel.path  # whatever dir is shown
+            if path != self.config("general/sgf_save"):
+                self.log(f"Updating sgf save path default to {path}", OUTPUT_DEBUG)
+                self._config["general"]["sgf_save"] = path
+                self.save_config("general")
+            self._do_save_game(os.path.join(path, file))
+
+        popup_contents.filesel.on_success = readfile
+        popup_contents.filesel.on_submit = readfile
+        save_game_popup.open()
+
+    def load_sgf_from_clipboard(self):
+        clipboard = Clipboard.paste()
+        if not clipboard:
+            self.controls.set_status("Ctrl-V pressed but clipboard is empty.", STATUS_INFO)
+            return
+
+        url_match = re.match(r"(?P<url>https?://[^\s]+)", clipboard)
+        if url_match:
+            self.log("Recognized url: " + url_match.group(), OUTPUT_INFO)
+            http = urllib3.PoolManager()
+            response = http.request("GET", url_match.group())
+            clipboard = response.data.decode("utf-8")
+
+        try:
+            move_tree = KaTrainSGF.parse_sgf(clipboard)
+        except Exception as exc:
+            self.controls.set_status(
+                i18n._("Failed to import from clipboard").format(error=exc, contents=clipboard[:50]), STATUS_INFO
+            )
+            return
+        move_tree.nodes_in_tree[-1].analyze(
+            self.engine, analyze_fast=False
+        )  # speed up result for looking at end of game
+        self._do_new_game(move_tree=move_tree, analyze_fast=True)
+        self("redo", 9999)
+        self.log("Imported game from clipboard.", OUTPUT_INFO)
+
+    def on_touch_up(self, touch):
+        if touch.is_mouse_scrolling:
+            touching_board = self.board_gui.collide_point(*touch.pos) or self.board_controls.collide_point(*touch.pos)
+            touching_control_nonscroll = self.controls.collide_point(
+                *touch.pos
+            ) and not self.controls.notes_panel.collide_point(*touch.pos)
+            if self.board_gui.animating_pv is not None and touching_board:
+                if touch.button == "scrollup":
+                    self.board_gui.adjust_animate_pv_index(1)
+                elif touch.button == "scrolldown":
+                    self.board_gui.adjust_animate_pv_index(-1)
+            elif touching_board or touching_control_nonscroll:  # scroll through moves
+                if touch.button == "scrollup":
+                    self("redo")
+                elif touch.button == "scrolldown":
+                    self("undo")
+        return super().on_touch_up(touch)
+
+    @property
+    def shortcuts(self):
+        return {
+            k: v
+            for ks, v in [
+                (Theme.KEY_ANALYSIS_CONTROLS_SHOW_CHILDREN, self.analysis_controls.show_children),
+                (Theme.KEY_ANALYSIS_CONTROLS_EVAL, self.analysis_controls.eval),
+                (Theme.KEY_ANALYSIS_CONTROLS_HINTS, self.analysis_controls.hints),
+                (Theme.KEY_ANALYSIS_CONTROLS_OWNERSHIP, self.analysis_controls.ownership),
+                (Theme.KEY_ANALYSIS_CONTROLS_POLICY, self.analysis_controls.policy),
+                (Theme.KEY_AI_MOVE, ("ai-move",)),
+                (Theme.KEY_ANALYZE_EXTRA_EXTRA, ("analyze-extra", "extra")),
+                (Theme.KEY_ANALYZE_EXTRA_EQUALIZE, ("analyze-extra", "equalize")),
+                (Theme.KEY_ANALYZE_EXTRA_SWEEP, ("analyze-extra", "sweep")),
+                (Theme.KEY_ANALYZE_EXTRA_ALTERNATIVE, ("analyze-extra", "alternative")),
+                (Theme.KEY_SELECT_BOX, ("select-box",)),
+                (Theme.KEY_RESET_ANALYSIS, ("reset-analysis",)),
+                (Theme.KEY_INSERT_MODE, ("insert-mode",)),
+                (Theme.KEY_PASS, ("play", None)),
+                (Theme.KEY_SELFPLAY_TO_END, ("selfplay-setup", "end", None)),
+                (Theme.KEY_NAV_PREV_BRANCH, ("undo", "branch")),
+                (Theme.KEY_NAV_BRANCH_DOWN, ("switch-branch", 1)),
+                (Theme.KEY_NAV_BRANCH_UP, ("switch-branch", -1)),
+                (Theme.KEY_TIMER_POPUP, ("timer-popup",)),
+                (Theme.KEY_TEACHER_POPUP, ("teacher-popup",)),
+                (Theme.KEY_AI_POPUP, ("ai-popup",)),
+                (Theme.KEY_CONFIG_POPUP, ("config-popup",)),
+                (Theme.KEY_CONTRIBUTE_POPUP, ("contribute-popup",)),
+                (Theme.KEY_STOP_ANALYSIS, ("analyze-extra", "stop")),
+            ]
+            for k in (ks if isinstance(ks, list) else [ks])
+        }
+
+    @property
+    def popup_open(self) -> Popup:
+        app = App.get_running_app()
+        if app:
+            first_child = app.root_window.children[0]
+            return first_child if isinstance(first_child, Popup) else None
+
+    def _on_keyboard_down(self, _keyboard, keycode, _text, modifiers):
+        self.last_key_down = keycode
+        ctrl_pressed = "ctrl" in modifiers or ("meta" in modifiers and kivy_platform == "macosx")
+        shift_pressed = "shift" in modifiers
+        if self.controls.note.focus:
+            return  # when making notes, don't allow keyboard shortcuts
+        popup = self.popup_open
+        if popup:
+            if keycode[1] in [
+                Theme.KEY_DEEPERANALYSIS_POPUP,
+                Theme.KEY_REPORT_POPUP,
+                Theme.KEY_TIMER_POPUP,
+                Theme.KEY_TEACHER_POPUP,
+                Theme.KEY_AI_POPUP,
+                Theme.KEY_CONFIG_POPUP,
+                Theme.KEY_TSUMEGO_FRAME,
+                Theme.KEY_CONTRIBUTE_POPUP,
+            ]:  # switch between popups
+                popup.dismiss()
+
+                return
+            elif keycode[1] in Theme.KEY_SUBMIT_POPUP:
+                fn = getattr(popup.content, "on_submit", None)
+                if fn:
+                    fn()
+                return
+            else:
+                return
+
+        if self.contributing:
+            if keycode[1] == Theme.KEY_STOP_CONTRIBUTING:
+                self.engine.graceful_shutdown()
+                return
+            elif keycode[1] in Theme.KEY_PAUSE_CONTRIBUTE:
+                self.engine.pause()
+                return
+
+        if keycode[1] == Theme.KEY_TOGGLE_CONTINUOUS_ANALYSIS:
+            self.toggle_continuous_analysis(quiet=shift_pressed)
+        elif keycode[1] == Theme.KEY_TOGGLE_MOVENUM:
+            self.toggle_move_num()
+        elif keycode[1] == Theme.KEY_TOGGLE_COORDINATES:
+            self.board_gui.toggle_coordinates()
+        elif keycode[1] in Theme.KEY_PAUSE_TIMER and not ctrl_pressed:
+            self.controls.timer.paused = not self.controls.timer.paused
+        elif keycode[1] in Theme.KEY_ZEN:
+            self.zen = (self.zen + 1) % 3
+        elif keycode[1] in Theme.KEY_NAV_PREV:
+            self("undo", 1 + shift_pressed * 9 + ctrl_pressed * 9999)
+        elif keycode[1] in Theme.KEY_NAV_NEXT:
+            self("redo", 1 + shift_pressed * 9 + ctrl_pressed * 9999)
+        elif keycode[1] == Theme.KEY_NAV_GAME_START:
+            self("undo", 9999)
+        elif keycode[1] == Theme.KEY_NAV_GAME_END:
+            self("redo", 9999)
+        elif keycode[1] == Theme.KEY_MOVE_TREE_MAKE_SELECTED_NODE_MAIN_BRANCH:
+            self.controls.move_tree.make_selected_node_main_branch()
+        elif keycode[1] == Theme.KEY_NAV_MISTAKE and not ctrl_pressed:
+            self("find-mistake", "undo" if shift_pressed else "redo")
+        elif keycode[1] == Theme.KEY_MOVE_TREE_DELETE_SELECTED_NODE and ctrl_pressed:
+            self.controls.move_tree.delete_selected_node()
+        elif keycode[1] == Theme.KEY_MOVE_TREE_TOGGLE_SELECTED_NODE_COLLAPSE and not ctrl_pressed:
+            self.controls.move_tree.toggle_selected_node_collapse()
+        elif keycode[1] == Theme.KEY_NEW_GAME and ctrl_pressed:
+            self("new-game-popup")
+        elif keycode[1] == Theme.KEY_LOAD_GAME and ctrl_pressed:
+            self("analyze-sgf-popup")
+        elif keycode[1] == Theme.KEY_SAVE_GAME and ctrl_pressed:
+            self("save-game")
+        elif keycode[1] == Theme.KEY_SAVE_GAME_AS and ctrl_pressed:
+            self("save-game-as-popup")
+        elif keycode[1] == Theme.KEY_COPY and ctrl_pressed:
+            Clipboard.copy(self.game.root.sgf())
+            self.controls.set_status(i18n._("Copied SGF to clipboard."), STATUS_INFO)
+        elif keycode[1] == Theme.KEY_PASTE and ctrl_pressed:
+            self.load_sgf_from_clipboard()
+        elif keycode[1] == Theme.KEY_NAV_PREV_BRANCH and shift_pressed:
+            self("undo", "main-branch")
+        elif keycode[1] == Theme.KEY_DEEPERANALYSIS_POPUP:
+            self.analysis_controls.dropdown.open_game_analysis_popup()
+        elif keycode[1] == Theme.KEY_TSUMEGO_FRAME:
+            self.analysis_controls.dropdown.open_tsumego_frame_popup()
+        elif keycode[1] == Theme.KEY_REPORT_POPUP:
+            self.analysis_controls.dropdown.open_report_popup()
+        elif keycode[1] == "f10" and self.debug_level >= OUTPUT_EXTRA_DEBUG:
+            import yappi
+
+            yappi.set_clock_type("cpu")
+            yappi.start()
+            self.log("starting profiler", OUTPUT_ERROR)
+        elif keycode[1] == "f11" and self.debug_level >= OUTPUT_EXTRA_DEBUG:
+            import time
+            import yappi
+
+            stats = yappi.get_func_stats()
+            filename = f"callgrind.{int(time.time())}.prof"
+            stats.save(filename, type="callgrind")
+            self.log(f"wrote profiling results to {filename}", OUTPUT_ERROR)
+        elif not ctrl_pressed:
+            shortcut = self.shortcuts.get(keycode[1])
+            if shortcut is not None:
+                if isinstance(shortcut, Widget):
+                    shortcut.trigger_action(duration=0)
+                else:
+                    self(*shortcut)
+
+    def _on_keyboard_up(self, _keyboard, keycode):
+        if keycode[1] in ["alt", "tab"]:
+            Clock.schedule_once(lambda *_args: self._single_key_action(keycode), 0.05)
+
+    def _single_key_action(self, keycode):
+        if (
+            self.controls.note.focus
+            or self.popup_open
+            or keycode != self.last_key_down
+            or time.time() - self.last_focus_event < 0.2  # this is here to prevent alt-tab from firing alt or tab
+        ):
+            return
+        if keycode[1] == "alt":
+            self.nav_drawer.set_state("toggle")
+        elif keycode[1] == "tab":
+            self.play_mode.switch_ui_mode()
+
+
+class KaTrainApp(MDApp):
+    gui = ObjectProperty(None)
+    language = StringProperty(DEFAULT_LANGUAGE)
+
+    def __init__(self):
+        super().__init__()
+
+    def is_valid_window_position(self, left, top, width, height):
+        try:
+            from screeninfo import get_monitors
+            monitors = get_monitors()
+            for monitor in monitors:
+                if (left >= monitor.x and left + width <= monitor.x + monitor.width and
+                    top >= monitor.y and top + height <= monitor.y + monitor.height):
+                    return True
+            return False
+        except Exception as e:
+            return True # yolo
+
+    def build(self):
+        self.icon = ICON  # how you're supposed to set an icon
+
+        self.title = f"KaTrain v{VERSION}"
+        self.theme_cls.theme_style = "Dark"
+        self.theme_cls.primary_palette = "Gray"
+        self.theme_cls.primary_hue = "200"
+
+        kv_file = find_package_resource("katrain/gui.kv")
+        popup_kv_file = find_package_resource("katrain/popups.kv")
+        resource_add_path(PATHS["PACKAGE"] + "/fonts")
+        resource_add_path(PATHS["PACKAGE"] + "/sounds")
+        resource_add_path(PATHS["PACKAGE"] + "/img")
+        resource_add_path(os.path.abspath(os.path.expanduser(DATA_FOLDER)))  # prefer resources in .katrain
+
+        theme_files = glob.glob(os.path.join(os.path.expanduser(DATA_FOLDER), "theme*.json"))
+        for theme_file in sorted(theme_files):
+            try:
+                with open(theme_file) as f:
+                    theme_overrides = json.load(f)
+                for k, v in theme_overrides.items():
+                    setattr(Theme, k, v)
+                    print(f"[{theme_file}] Found theme override {k} = {v}")
+            except Exception as e:  # noqa E722
+                print(f"Failed to load theme file {theme_file}: {e}")
+
+        Theme.DEFAULT_FONT = resource_find(Theme.DEFAULT_FONT)
+        Builder.load_file(kv_file)
+
+        Window.bind(on_request_close=self.on_request_close)
+        Window.bind(on_dropfile=lambda win, file: self.gui.load_sgf_file(file.decode("utf8")))
+        self.gui = KaTrainGui()
+        Builder.load_file(popup_kv_file)
+
+        win_left = win_top = win_size = None
+        if self.gui.config("ui_state/restoresize", True):
+            win_size = self.gui.config("ui_state/size", [])
+            win_left = self.gui.config("ui_state/left", None)
+            win_top = self.gui.config("ui_state/top", None)
+        if not win_size:
+            window_scale_fac = 1
+            try:
+                from screeninfo import get_monitors
+
+                for m in get_monitors():
+                    window_scale_fac = min(window_scale_fac, (m.height - 100) / 1000, (m.width - 100) / 1300)
+            except Exception as e:
+                window_scale_fac = 0.85
+            win_size = [1300 * window_scale_fac, 1000 * window_scale_fac]
+        self.gui.log(f"Setting window size to {win_size} and position to {[win_left, win_top]}", OUTPUT_DEBUG)
+        Window.size = (win_size[0], win_size[1])
+        if win_left is not None and win_top is not None and self.is_valid_window_position(win_left, win_top, win_size[0], win_size[1]):
+            Window.left = win_left
+            Window.top = win_top
+
+        return self.gui
+
+    def on_language(self, _instance, language):
+        self.gui.log(f"Switching language to {language}", OUTPUT_INFO)
+        i18n.switch_lang(language)
+        self.gui._config["general"]["lang"] = language
+        self.gui.save_config()
+        if self.gui.game:
+            self.gui.update_state()
+            self.gui.controls.set_status("", STATUS_INFO)
+
+    def webbrowser(self, site_key):
+        websites = {
+            "homepage": HOMEPAGE + "#manual",
+            "support": HOMEPAGE + "#support",
+            "contribute:signup": "http://katagotraining.org/accounts/signup/",
+            "engine:help": HOMEPAGE + "/blob/master/ENGINE.md",
+        }
+        if site_key in websites:
+            webbrowser.open(websites[site_key])
+
+    def on_start(self):
+        self.language = self.gui.config("general/lang")
+        self.gui.start()
+
+    def on_request_close(self, *_args, source=None):
+        if source == "keyboard":
+            return True  # do not close on esc
+        if getattr(self, "gui", None):
+            self.gui.play_mode.save_ui_state()
+            self.gui._config["ui_state"]["size"] = list(Window._size)
+            self.gui._config["ui_state"]["top"] = Window.top
+            self.gui._config["ui_state"]["left"] = Window.left
+            self.gui.save_config("ui_state")
+            if self.gui.engine:
+                self.gui.engine.shutdown(finish=None)
+
+    def signal_handler(self, _signal, _frame):
+        if self.gui.debug_level >= OUTPUT_DEBUG:
+            print("TRACEBACKS")
+            for threadId, stack in sys._current_frames().items():
+                print(f"\n# ThreadID: {threadId}")
+                for filename, lineno, name, line in traceback.extract_stack(stack):
+                    print(f"\tFile: {filename}, line {lineno}, in {name}")
+                    if line:
+                        print(f"\t\t{line.strip()}")
+        self.stop()
+
+
+def run_app():
+    class CrashHandler(ExceptionHandler):
+        def handle_exception(self, inst):
+            ex_type, ex, tb = sys.exc_info()
+            trace = "".join(traceback.format_tb(tb))
+            app = MDApp.get_running_app()
+
+            if app and app.gui:
+                app.gui.log(
+                    f"Exception {inst.__class__.__name__}: {', '.join(repr(a) for a in inst.args)}\n{trace}",
+                    OUTPUT_ERROR,
+                )
+            else:
+                print(f"Exception {inst.__class__}: {inst.args}\n{trace}")
+            return ExceptionManager.PASS
+
+    ExceptionManager.add_handler(CrashHandler())
+    app = KaTrainApp()
+    signal.signal(signal.SIGINT, app.signal_handler)
+    app.run()
+
+
+if __name__ == "__main__":
+    run_app()

katrain/config.json

@@ -0,0 +1,242 @@
+{
+    "engine": {
+        "katago": "",
+        "altcommand": "",
+        "model": "katrain/models/kata1-b18c384nbt-s9996604416-d4316597426.bin.gz",
+        "humanlike_model": "",
+        "config": "katrain/KataGo/analysis_config.cfg",
+        "max_visits": 500,
+        "fast_visits": 25,
+        "max_time": 8.0,
+        "wide_root_noise": 0.04,
+        "_enable_ownership": true
+    },
+    "contribute": {
+        "katago": "",
+        "config": "katrain/KataGo/contribute_config.cfg",
+        "ownership": false,
+        "maxgames": 6,
+        "movespeed": 2,
+        "username": "",
+        "password": "",
+        "savepath": "./dist_sgf/",
+        "savesgf": false
+    },
+    "general": {
+        "sgf_load": "~/Downloads",
+        "sgf_save": "./sgfout",
+        "anim_pv_time": 0.5,
+        "debug_level": 0,
+        "lang": "en",
+        "version": "1.17.0",
+        "load_fast_analysis": false,
+        "load_sgf_rewind": true
+    },
+    "timer": {
+        "byo_length": 30,
+        "byo_periods": 5,
+        "minimal_use": 0,
+        "main_time": 0,
+        "sound": true
+    },
+    "game": {
+        "size": "19",
+        "komi": 6.5,
+        "handicap": 0,
+        "rules": "japanese",
+        "clear_cache": false,
+        "setup_move": 100,
+        "setup_advantage": 20
+    },
+    "trainer": {
+        "theme": "theme:normal",
+        "num_undo_prompts": [
+            1,
+            1,
+            1,
+            0.5,
+            0,
+            0
+        ],
+        "eval_thresholds": [
+            12,
+            6,
+            3,
+            1.5,
+            0.5,
+            0
+        ],
+        "save_feedback": [
+            true,
+            true,
+            true,
+            true,
+            false,
+            false
+        ],
+        "show_dots": [
+            true,
+            true,
+            true,
+            true,
+            true,
+            true
+        ],
+        "extra_precision": false,
+        "save_analysis": false,
+        "save_marks": false,
+        "low_visits": 25,
+        "eval_on_show_last": 3,
+        "top_moves_show": "top_move_delta_score",
+        "top_moves_show_secondary": "top_move_visits",
+        "eval_show_ai": true,
+        "lock_ai": false
+    },
+    "ai": {
+        "ai:default": {},
+        "ai:antimirror": {},
+        "ai:handicap": {
+            "automatic": true,
+            "pda": 0
+        },
+        "ai:jigo": {
+            "target_score": 0.5
+        },
+        "ai:scoreloss": {
+            "strength": 0.2
+        },
+        "ai:policy": {
+            "opening_moves": 22.0
+        },
+        "ai:simple": {
+            "max_points_lost": 1.75,
+            "settled_weight": 1.0,
+            "opponent_fac": 0.5,
+            "min_visits": 3,
+            "attach_penalty": 1,
+            "tenuki_penalty": 0.5
+        },
+        "ai:p:weighted": {
+            "weaken_fac": 1.25,
+            "pick_override": 1.0,
+            "lower_bound": 0.001
+        },
+        "ai:p:pick": {
+            "pick_override": 0.95,
+            "pick_n": 5,
+            "pick_frac": 0.35
+        },
+        "ai:p:local": {
+            "pick_override": 0.95,
+            "stddev": 1.5,
+            "pick_n": 15,
+            "pick_frac": 0.0,
+            "endgame": 0.5
+        },
+        "ai:p:tenuki": {
+            "pick_override": 0.85,
+            "stddev": 7.5,
+            "pick_n": 5,
+            "pick_frac": 0.4,
+            "endgame": 0.45
+        },
+        "ai:p:influence": {
+            "pick_override": 0.95,
+            "pick_n": 5,
+            "pick_frac": 0.3,
+            "threshold": 3.5,
+            "line_weight": 10,
+            "endgame": 0.4
+        },
+        "ai:p:territory": {
+            "pick_override": 0.95,
+            "pick_n": 5,
+            "pick_frac": 0.3,
+            "threshold": 3.5,
+            "line_weight": 2,
+            "endgame": 0.4
+        },
+        "ai:p:rank": {
+            "kyu_rank": 4.0
+        },
+        "ai:human": {
+            "human_kyu_rank": 8,
+            "modern_style": false
+        },
+        "ai:pro": {
+            "pro_year": 1914
+        }
+    },
+    "ui_state": {
+        "restoresize": true,
+        "size": [],
+        "play": {
+            "analysis_controls": {
+                "show_children": true,
+                "eval": false,
+                "hints": false,
+                "policy": false,
+                "ownership": false
+            },
+            "panels": {
+                "graph_panel": [
+                    "open",
+                    {
+                        "score": true,
+                        "winrate": false
+                    }
+                ],
+                "stats_panel": [
+                    "open",
+                    {
+                        "score": true,
+                        "winrate": true,
+                        "points": true
+                    }
+                ],
+                "notes_panel": [
+                    "open",
+                    {
+                        "info": true,
+                        "info-details": false,
+                        "notes": false
+                    }
+                ]
+            }
+        },
+        "analyze": {
+            "analysis_controls": {
+                "show_children": true,
+                "eval": true,
+                "hints": true,
+                "policy": false,
+                "ownership": true
+            },
+            "panels": {
+                "graph_panel": [
+                    "open",
+                    {
+                        "score": true,
+                        "winrate": true
+                    }
+                ],
+                "stats_panel": [
+                    "open",
+                    {
+                        "score": true,
+                        "winrate": true,
+                        "points": true
+                    }
+                ],
+                "notes_panel": [
+                    "open",
+                    {
+                        "info": true,
+                        "info-details": true,
+                        "notes": false
+                    }
+                ]
+            }
+        }
+    }
+}

katrain/core/ai.py

@@ -0,0 +1,1460 @@
+from abc import ABC, abstractmethod
+import heapq
+import math
+import random
+import time
+from typing import Dict, List, Optional, Tuple
+
+from katrain.core.constants import (
+    AI_DEFAULT, AI_HANDICAP, AI_INFLUENCE, AI_INFLUENCE_ELO_GRID, AI_JIGO,
+    AI_ANTIMIRROR, AI_LOCAL, AI_LOCAL_ELO_GRID, AI_PICK, AI_PICK_ELO_GRID,
+    AI_POLICY, AI_RANK, AI_SCORELOSS, AI_SCORELOSS_ELO, AI_SETTLE_STONES,
+    AI_SIMPLE_OWNERSHIP, AI_STRENGTH,
+    AI_TENUKI, AI_TENUKI_ELO_GRID, AI_TERRITORY, AI_TERRITORY_ELO_GRID,
+    AI_WEIGHTED, AI_WEIGHTED_ELO, CALIBRATED_RANK_ELO, OUTPUT_DEBUG,
+    OUTPUT_ERROR, OUTPUT_INFO, PRIORITY_EXTRA_AI_QUERY, ADDITIONAL_MOVE_ORDER, AI_HUMAN, AI_PRO
+)
+from katrain.core.game import Game, GameNode, Move
+from katrain.core.utils import var_to_grid, weighted_selection_without_replacement, evaluation_class
+
+# Decorator pattern for adding classes to the registry
+STRATEGY_REGISTRY = {}
+
+def register_strategy(strategy_name):
+    def decorator(strategy_class):
+        STRATEGY_REGISTRY[strategy_name] = strategy_class
+        return strategy_class
+    return decorator
+
+def interp_ix(lst, x):
+    i = 0
+    while i + 1 < len(lst) - 1 and lst[i + 1] < x:
+        i += 1
+    t = max(0, min(1, (x - lst[i]) / (lst[i + 1] - lst[i])))
+    return i, t
+
+def interp1d(lst, x):
+    xs, ys = zip(*lst)
+    i, t = interp_ix(xs, x)
+    return (1 - t) * ys[i] + t * ys[i + 1]
+
+def interp2d(gridspec, x, y):
+    xs, ys, matrix = gridspec
+    i, t = interp_ix(xs, x)
+    j, s = interp_ix(ys, y)
+    return (
+        matrix[j][i] * (1 - t) * (1 - s)
+        + matrix[j][i + 1] * t * (1 - s)
+        + matrix[j + 1][i] * (1 - t) * s
+        + matrix[j + 1][i + 1] * t * s
+    )
+
+def ai_rank_estimation(strategy, settings) -> int:
+    if strategy in [AI_DEFAULT, AI_HANDICAP, AI_JIGO, AI_PRO]:
+        return 9
+    if strategy == AI_RANK:
+        return 1 - settings["kyu_rank"]
+    if strategy == AI_HUMAN:
+        return 1 - settings["human_kyu_rank"]
+
+    if strategy in [AI_WEIGHTED, AI_SCORELOSS, AI_LOCAL, AI_TENUKI, AI_TERRITORY, AI_INFLUENCE, AI_PICK]:
+        if strategy == AI_WEIGHTED:
+            elo = interp1d(AI_WEIGHTED_ELO, settings["weaken_fac"])
+        if strategy == AI_SCORELOSS:
+            elo = interp1d(AI_SCORELOSS_ELO, settings["strength"])
+        if strategy == AI_PICK:
+            elo = interp2d(AI_PICK_ELO_GRID, settings["pick_frac"], settings["pick_n"])
+        if strategy == AI_LOCAL:
+            elo = interp2d(AI_LOCAL_ELO_GRID, settings["pick_frac"], settings["pick_n"])
+        if strategy == AI_TENUKI:
+            elo = interp2d(AI_TENUKI_ELO_GRID, settings["pick_frac"], settings["pick_n"])
+        if strategy == AI_TERRITORY:
+            elo = interp2d(AI_TERRITORY_ELO_GRID, settings["pick_frac"], settings["pick_n"])
+        if strategy == AI_INFLUENCE:
+            elo = interp2d(AI_INFLUENCE_ELO_GRID, settings["pick_frac"], settings["pick_n"])
+
+        kyu = interp1d(CALIBRATED_RANK_ELO, elo)
+        return 1 - kyu
+    else:
+        return AI_STRENGTH[strategy]
+
+def game_report(game, thresholds, depth_filter=None):
+    cn = game.current_node
+    nodes = cn.nodes_from_root
+    while cn.children:  # main branch
+        cn = cn.children[0]
+        nodes.append(cn)
+
+    x, y = game.board_size
+    depth_filter = [math.ceil(board_frac * x * y) for board_frac in depth_filter or (0, 1e9)]
+    nodes = [n for n in nodes if n.move and not n.is_root and depth_filter[0] <= n.depth < depth_filter[1]]
+    histogram = [{"B": 0, "W": 0} for _ in thresholds]
+    ai_top_move_count = {"B": 0, "W": 0}
+    ai_approved_move_count = {"B": 0, "W": 0}
+    player_ptloss = {"B": [], "W": []}
+    weights = {"B": [], "W": []}
+
+    for n in nodes:
+        points_lost = n.points_lost
+        if n.points_lost is None:
+            continue
+        else:
+            points_lost = max(0, points_lost)
+        bucket = len(thresholds) - 1 - evaluation_class(points_lost, thresholds)
+        player_ptloss[n.player].append(points_lost)
+        histogram[bucket][n.player] += 1
+        cands = n.parent.candidate_moves
+        filtered_cands = [d for d in cands if d["order"] < ADDITIONAL_MOVE_ORDER and "prior" in d]
+        weight = min(
+            1.0,
+            sum([max(d["pointsLost"], 0) * d["prior"] for d in filtered_cands])
+            / (sum(d["prior"] for d in filtered_cands) or 1e-6),
+        )  # complexity capped at 1
+        # adj_weight between 0.05 - 1, dependent on difficulty and points lost
+        adj_weight = max(0.05, min(1.0, max(weight, points_lost / 4)))
+        weights[n.player].append((weight, adj_weight))
+        if n.parent.analysis_complete:
+            ai_top_move_count[n.player] += int(cands[0]["move"] == n.move.gtp())
+            ai_approved_move_count[n.player] += int(
+                n.move.gtp()
+                in [d["move"] for d in filtered_cands if d["order"] == 0 or (d["pointsLost"] < 0.5 and d["order"] < 5)]
+            )
+
+    wt_loss = {
+        bw: sum(s * aw for s, (w, aw) in zip(player_ptloss[bw], weights[bw]))
+        / (sum(aw for _, aw in weights[bw]) or 1e-6)
+        for bw in "BW"
+    }
+    sum_stats = {
+        bw: (
+            {
+                "accuracy": 100 * 0.75 ** wt_loss[bw],
+                "complexity": sum(w for w, aw in weights[bw]) / len(player_ptloss[bw]),
+                "mean_ptloss": sum(player_ptloss[bw]) / len(player_ptloss[bw]),
+                "weighted_ptloss": wt_loss[bw],
+                "ai_top_move": ai_top_move_count[bw] / len(player_ptloss[bw]),
+                "ai_top5_move": ai_approved_move_count[bw] / len(player_ptloss[bw]),
+            }
+            if len(player_ptloss[bw]) > 0
+            else {}
+        )
+        for bw in "BW"
+    }
+    return sum_stats, histogram, player_ptloss
+
+def fmt_moves(moves: List[Tuple[float, Move]]):
+    return ", ".join(f"{mv.gtp()} ({p:.2%})" for p, mv in moves)
+
+# Utility functions from the original code
+def policy_weighted_move(policy_moves, lower_bound, weaken_fac):
+    lower_bound, weaken_fac = max(0, lower_bound), max(0.01, weaken_fac)
+    weighted_coords = [
+        (pv, pv ** (1 / weaken_fac), move) for pv, move in policy_moves if pv > lower_bound and not move.is_pass
+    ]
+    if weighted_coords:
+        top = weighted_selection_without_replacement(weighted_coords, 1)[0]
+        move = top[2]
+        ai_thoughts = f"Playing policy-weighted random move {move.gtp()} ({top[0]:.1%}) from {len(weighted_coords)} moves above lower_bound of {lower_bound:.1%}."
+    else:
+        move = policy_moves[0][1]
+        ai_thoughts = f"Playing top policy move because no non-pass move > above lower_bound of {lower_bound:.1%}."
+    return move, ai_thoughts
+
+def generate_influence_territory_weights(ai_mode, ai_settings, policy_grid, size):
+    thr_line = ai_settings["threshold"] - 1  # zero-based
+    if ai_mode == AI_INFLUENCE:
+        weight = lambda x, y: (1 / ai_settings["line_weight"]) ** (  # noqa E731
+            max(0, thr_line - min(size[0] - 1 - x, x)) + max(0, thr_line - min(size[1] - 1 - y, y))
+        )  # noqa E731
+    else:
+        weight = lambda x, y: (1 / ai_settings["line_weight"]) ** (  # noqa E731
+            max(0, min(size[0] - 1 - x, x, size[1] - 1 - y, y) - thr_line)
+        )
+    weighted_coords = [
+        (policy_grid[y][x] * weight(x, y), weight(x, y), x, y)
+        for x in range(size[0])
+        for y in range(size[1])
+        if policy_grid[y][x] > 0
+    ]
+    ai_thoughts = f"Generated weights for {ai_mode} according to weight factor {ai_settings['line_weight']} and distance from {thr_line + 1}th line. "
+    return weighted_coords, ai_thoughts
+
+def generate_local_tenuki_weights(ai_mode, ai_settings, policy_grid, cn, size):
+    var = ai_settings["stddev"] ** 2
+    mx, my = cn.move.coords
+    weighted_coords = [
+        (policy_grid[y][x], math.exp(-0.5 * ((x - mx) ** 2 + (y - my) ** 2) / var), x, y)
+        for x in range(size[0])
+        for y in range(size[1])
+        if policy_grid[y][x] > 0
+    ]
+    ai_thoughts = f"Generated weights based on one minus gaussian with variance {var} around coordinates {mx},{my}. "
+    if ai_mode == AI_TENUKI:
+        weighted_coords = [(p, 1 - w, x, y) for p, w, x, y in weighted_coords]
+        ai_thoughts = (
+            f"Generated weights based on one minus gaussian with variance {var} around coordinates {mx},{my}. "
+        )
+    return weighted_coords, ai_thoughts
+
+class AIStrategy(ABC):
+    """Base strategy class for AI move generation"""
+    
+    def __init__(self, game: Game, ai_settings: Dict):
+        self.game = game
+        self.settings = ai_settings
+        self.cn = game.current_node
+        self.strategy_name = self.__class__.__name__
+        self.game.katrain.log(f"Initializing {self.strategy_name} with settings: {self.settings}", OUTPUT_DEBUG)
+        
+    @abstractmethod
+    def generate_move(self) -> Tuple[Move, str]:
+        """Generate a move and explanation"""
+        pass
+    
+    def request_analysis(self, extra_settings: Dict) -> Optional[Dict]:
+        """Helper to request additional analysis with custom settings"""
+        self.game.katrain.log(f"[{self.strategy_name}] Requesting analysis with settings: {extra_settings}", OUTPUT_DEBUG)
+        error = False
+        analysis = None
+
+        def set_analysis(a, partial_result):
+            nonlocal analysis
+            if not partial_result:
+                analysis = a
+                self.game.katrain.log(f"[{self.strategy_name}] Analysis received", OUTPUT_DEBUG)
+
+        def set_error(a):
+            nonlocal error
+            self.game.katrain.log(f"[{self.strategy_name}] Error in additional analysis query: {a}", OUTPUT_ERROR)
+            error = True
+
+        engine = self.game.engines[self.cn.player]
+        engine.request_analysis(
+            self.cn,
+            callback=set_analysis,
+            error_callback=set_error,
+            priority=PRIORITY_EXTRA_AI_QUERY,
+            ownership=False,
+            extra_settings=extra_settings,
+        )
+        self.game.katrain.log(f"[{self.strategy_name}] Waiting for analysis to complete...", OUTPUT_DEBUG)
+        while not (error or analysis):
+            time.sleep(0.01)  # TODO: prevent deadlock if esc, check node in queries?
+            engine.check_alive(exception_if_dead=True)
+        
+        if analysis:
+            self.game.katrain.log(f"[{self.strategy_name}] Analysis completed successfully", OUTPUT_DEBUG)
+        return analysis
+    
+    def wait_for_analysis(self):
+        """Wait for the analysis to complete"""
+        self.game.katrain.log(f"[{self.strategy_name}] Waiting for regular analysis to complete...", OUTPUT_DEBUG)
+        while not self.cn.analysis_complete:
+            time.sleep(0.01)
+            self.game.engines[self.cn.next_player].check_alive(exception_if_dead=True)
+        self.game.katrain.log(f"[{self.strategy_name}] Regular analysis completed", OUTPUT_DEBUG)
+    
+    def should_play_top_move(self, policy_moves, top_5_pass, override=0.0, overridetwo=1.0):
+        """Check if we should play the top policy move, regardless of strategy"""
+        top_policy_move = policy_moves[0][1]
+        self.game.katrain.log(f"[{self.strategy_name}] Checking if should play top move. Top move: {top_policy_move.gtp()} ({policy_moves[0][0]:.2%})", OUTPUT_DEBUG)
+        self.game.katrain.log(f"[{self.strategy_name}] Override thresholds: single={override:.2%}, combined={overridetwo:.2%}", OUTPUT_DEBUG)
+        self.game.katrain.log(f"[{self.strategy_name}] Top 5 pass: {top_5_pass}", OUTPUT_DEBUG)
+        
+        if top_5_pass:
+            self.game.katrain.log(f"[{self.strategy_name}] Playing top move because pass is in top 5", OUTPUT_DEBUG)
+            return top_policy_move, "Playing top one because one of them is pass."
+        
+        if policy_moves[0][0] > override:
+            self.game.katrain.log(f"[{self.strategy_name}] Playing top move because weight {policy_moves[0][0]:.2%} > override {override:.2%}", OUTPUT_DEBUG)
+            return top_policy_move, f"Top policy move has weight > {override:.1%}, so overriding other strategies."
+            
+        if policy_moves[0][0] + policy_moves[1][0] > overridetwo:
+            combined = policy_moves[0][0] + policy_moves[1][0]
+            self.game.katrain.log(f"[{self.strategy_name}] Playing top move because combined weight {combined:.2%} > overridetwo {overridetwo:.2%}", OUTPUT_DEBUG)
+            return top_policy_move, f"Top two policy moves have cumulative weight > {overridetwo:.1%}, so overriding other strategies."
+        
+        self.game.katrain.log(f"[{self.strategy_name}] No override condition met, continuing with strategy", OUTPUT_DEBUG)    
+        return None, ""
+
+@register_strategy(AI_DEFAULT)
+class DefaultStrategy(AIStrategy):
+    """Default strategy - simply plays the top move from the engine"""
+    
+    def generate_move(self) -> Tuple[Move, str]:
+        self.game.katrain.log(f"[DefaultStrategy] Starting move generation", OUTPUT_DEBUG)
+        self.wait_for_analysis()
+        
+        candidate_moves = self.cn.candidate_moves
+        self.game.katrain.log(f"[DefaultStrategy] Analysis found {len(candidate_moves)} candidate moves", OUTPUT_DEBUG)
+        
+        if not candidate_moves:
+            self.game.katrain.log(f"[DefaultStrategy] No candidate moves found, will play pass", OUTPUT_DEBUG)
+            top_cand = Move(is_pass=True, player=self.cn.next_player)
+        else:
+            top_move_data = candidate_moves[0]
+            top_cand = Move.from_gtp(top_move_data["move"], player=self.cn.next_player)
+            self.game.katrain.log(f"[DefaultStrategy] Top move: {top_cand.gtp()} with stats: {top_move_data}", OUTPUT_DEBUG)
+        
+        ai_thoughts = f"Default strategy found {len(candidate_moves)} moves returned from the engine and chose {top_cand.gtp()} as top move"
+        self.game.katrain.log(f"[DefaultStrategy] Final decision: {top_cand.gtp()}", OUTPUT_DEBUG)
+        
+        return top_cand, ai_thoughts
+
+@register_strategy(AI_HANDICAP)
+class HandicapStrategy(AIStrategy):
+    """Handicap strategy - uses playoutDoublingAdvantage to analyze the position"""
+    
+    def generate_move(self) -> Tuple[Move, str]:
+        self.game.katrain.log(f"[HandicapStrategy] Starting move generation", OUTPUT_DEBUG)
+        
+        # Calculate PDA (Playout Doubling Advantage)
+        pda = self.settings["pda"]
+        self.game.katrain.log(f"[HandicapStrategy] Initial PDA from settings: {pda}", OUTPUT_DEBUG)
+        
+        if self.settings["automatic"]:
+            n_handicaps = len(self.game.root.get_list_property("AB", []))
+            MOVE_VALUE = 14  # could be rules dependent
+            b_stones_advantage = max(n_handicaps - 1, 0) - (self.cn.komi - MOVE_VALUE / 2) / MOVE_VALUE
+            pda = min(3, max(-3, -b_stones_advantage * (3 / 8)))  # max PDA at 8 stone adv, normal 9 stone game is 8.46
+            
+            self.game.katrain.log(f"[HandicapStrategy] Automatic PDA calculation:", OUTPUT_DEBUG)
+            self.game.katrain.log(f"[HandicapStrategy] - Handicap stones: {n_handicaps}", OUTPUT_DEBUG)
+            self.game.katrain.log(f"[HandicapStrategy] - Komi: {self.cn.komi}", OUTPUT_DEBUG)
+            self.game.katrain.log(f"[HandicapStrategy] - Stone advantage: {b_stones_advantage}", OUTPUT_DEBUG)
+            self.game.katrain.log(f"[HandicapStrategy] - Calculated PDA: {pda}", OUTPUT_DEBUG)
+        
+        # Request additional analysis with PDA
+        self.game.katrain.log(f"[HandicapStrategy] Requesting analysis with PDA={pda}", OUTPUT_DEBUG)
+        handicap_analysis = self.request_analysis(
+            {"playoutDoublingAdvantage": pda, "playoutDoublingAdvantagePla": "BLACK"}
+        )
+        
+        if not handicap_analysis:
+            self.game.katrain.log("[HandicapStrategy] Error getting handicap-based move, falling back to DefaultStrategy", OUTPUT_ERROR)
+            return DefaultStrategy(self.game, self.settings).generate_move()
+        
+        self.wait_for_analysis()
+        
+        candidate_moves = handicap_analysis["moveInfos"]
+        self.game.katrain.log(f"[HandicapStrategy] Analysis returned {len(candidate_moves)} candidate moves", OUTPUT_DEBUG)
+        
+        # Get top candidate move
+        top_move_data = candidate_moves[0]
+        top_cand = Move.from_gtp(top_move_data["move"], player=self.cn.next_player)
+        
+        # Log details about the top move
+        self.game.katrain.log(f"[HandicapStrategy] Top move: {top_cand.gtp()}", OUTPUT_DEBUG)
+        self.game.katrain.log(f"[HandicapStrategy] Score lead: {handicap_analysis['rootInfo']['scoreLead']}", OUTPUT_DEBUG)
+        self.game.katrain.log(f"[HandicapStrategy] Win rate: {handicap_analysis['rootInfo']['winrate']}", OUTPUT_DEBUG)
+        
+        ai_thoughts = f"Handicap strategy found {len(candidate_moves)} moves returned from the engine and chose {top_cand.gtp()} as top move. PDA based score {self.cn.format_score(handicap_analysis['rootInfo']['scoreLead'])} and win rate {self.cn.format_winrate(handicap_analysis['rootInfo']['winrate'])}"
+        
+        self.game.katrain.log(f"[HandicapStrategy] Final decision: {top_cand.gtp()}", OUTPUT_DEBUG)
+        return top_cand, ai_thoughts
+
+@register_strategy(AI_ANTIMIRROR)
+class AntimirrorStrategy(AIStrategy):
+    """Antimirror strategy - uses antiMirror to analyze the position"""
+    
+    def generate_move(self) -> Tuple[Move, str]:
+        self.game.katrain.log(f"[AntimirrorStrategy] Starting move generation", OUTPUT_DEBUG)
+        
+        # Request analysis with antimirror option
+        self.game.katrain.log(f"[AntimirrorStrategy] Requesting analysis with antiMirror=True", OUTPUT_DEBUG)
+        antimirror_analysis = self.request_analysis({"antiMirror": True})
+        
+        if not antimirror_analysis:
+            self.game.katrain.log("[AntimirrorStrategy] Error getting antimirror move, falling back to DefaultStrategy", OUTPUT_ERROR)
+            return DefaultStrategy(self.game, self.settings).generate_move()
+        
+        self.wait_for_analysis()
+        
+        candidate_moves = antimirror_analysis["moveInfos"]
+        self.game.katrain.log(f"[AntimirrorStrategy] Analysis returned {len(candidate_moves)} candidate moves", OUTPUT_DEBUG)
+        
+        # Get top candidate move
+        top_move_data = candidate_moves[0]
+        top_cand = Move.from_gtp(top_move_data["move"], player=self.cn.next_player)
+        
+        # Log details about the top move
+        self.game.katrain.log(f"[AntimirrorStrategy] Top move: {top_cand.gtp()}", OUTPUT_DEBUG)
+        self.game.katrain.log(f"[AntimirrorStrategy] Score lead: {antimirror_analysis['rootInfo']['scoreLead']}", OUTPUT_DEBUG)
+        self.game.katrain.log(f"[AntimirrorStrategy] Win rate: {antimirror_analysis['rootInfo']['winrate']}", OUTPUT_DEBUG)
+        
+        # Log the top 3 moves for comparison
+        for i, move_data in enumerate(candidate_moves[:3]):
+            move = Move.from_gtp(move_data["move"], player=self.cn.next_player)
+            self.game.katrain.log(f"[AntimirrorStrategy] Move #{i+1}: {move.gtp()} - visits: {move_data.get('visits', 'N/A')}, points lost: {move_data.get('pointsLost', 'N/A')}", OUTPUT_DEBUG)
+        
+        ai_thoughts = f"AntiMirror strategy found {len(candidate_moves)} moves returned from the engine and chose {top_cand.gtp()} as top move. antiMirror based score {self.cn.format_score(antimirror_analysis['rootInfo']['scoreLead'])} and win rate {self.cn.format_winrate(antimirror_analysis['rootInfo']['winrate'])}"
+        
+        self.game.katrain.log(f"[AntimirrorStrategy] Final decision: {top_cand.gtp()}", OUTPUT_DEBUG)
+        return top_cand, ai_thoughts
+
+@register_strategy(AI_JIGO)
+class JigoStrategy(AIStrategy):
+    """Jigo strategy - aims for a specific score difference"""
+    
+    def generate_move(self) -> Tuple[Move, str]:
+        self.game.katrain.log(f"[JigoStrategy] Starting move generation", OUTPUT_DEBUG)
+        self.wait_for_analysis()
+        
+        candidate_moves = self.cn.candidate_moves
+        self.game.katrain.log(f"[JigoStrategy] Analysis found {len(candidate_moves)} candidate moves", OUTPUT_DEBUG)
+        
+        if not candidate_moves:
+            self.game.katrain.log(f"[JigoStrategy] No candidate moves found, will play pass", OUTPUT_DEBUG)
+            return Move(is_pass=True, player=self.cn.next_player), "No candidate moves found, passing"
+        
+        # Get top engine move for reference
+        top_cand = Move.from_gtp(candidate_moves[0]["move"], player=self.cn.next_player)
+        self.game.katrain.log(f"[JigoStrategy] Top engine move would be: {top_cand.gtp()}", OUTPUT_DEBUG)
+        
+        # Calculate player sign (1 for black, -1 for white)
+        sign = self.cn.player_sign(self.cn.next_player)
+        self.game.katrain.log(f"[JigoStrategy] Player sign: {sign}", OUTPUT_DEBUG)
+        
+        # Get target score from settings
+        target_score = self.settings["target_score"]
+        self.game.katrain.log(f"[JigoStrategy] Target score: {target_score}", OUTPUT_DEBUG)
+        
+        # Log score leads before selecting jigo move
+        self.game.katrain.log("[JigoStrategy] Candidate move score leads:", OUTPUT_DEBUG)
+        for i, move_data in enumerate(candidate_moves[:5]):
+            move = Move.from_gtp(move_data["move"], player=self.cn.next_player)
+            score_diff = abs(sign * move_data["scoreLead"] - target_score)
+            self.game.katrain.log(f"[JigoStrategy] - {move.gtp()}: scoreLead={move_data['scoreLead']}, diff from target={score_diff}", OUTPUT_DEBUG)
+        
+        # Find the move that gives a score closest to the target
+        jigo_move = min(
+            candidate_moves, 
+            key=lambda move: abs(sign * move["scoreLead"] - target_score)
+        )
+        
+        aimove = Move.from_gtp(jigo_move["move"], player=self.cn.next_player)
+        jigo_score_diff = abs(sign * jigo_move["scoreLead"] - target_score)
+        
+        self.game.katrain.log(f"[JigoStrategy] Selected move: {aimove.gtp()}", OUTPUT_DEBUG)
+        self.game.katrain.log(f"[JigoStrategy] Selected move score lead: {jigo_move['scoreLead']}", OUTPUT_DEBUG)
+        self.game.katrain.log(f"[JigoStrategy] Distance from target: {jigo_score_diff}", OUTPUT_DEBUG)
+        
+        ai_thoughts = f"Jigo strategy found {len(candidate_moves)} candidate moves (best {top_cand.gtp()}) and chose {aimove.gtp()} as closest to 0.5 point win"
+        
+        self.game.katrain.log(f"[JigoStrategy] Final decision: {aimove.gtp()}", OUTPUT_DEBUG)
+        return aimove, ai_thoughts
+
+@register_strategy(AI_SCORELOSS)
+class ScoreLossStrategy(AIStrategy):
+    """ScoreLoss strategy - weights moves based on point loss"""
+    
+    def generate_move(self) -> Tuple[Move, str]:
+        self.game.katrain.log(f"[ScoreLossStrategy] Starting move generation", OUTPUT_DEBUG)
+        self.wait_for_analysis()
+        
+        candidate_moves = self.cn.candidate_moves
+        self.game.katrain.log(f"[ScoreLossStrategy] Analysis found {len(candidate_moves)} candidate moves", OUTPUT_DEBUG)
+        
+        if not candidate_moves:
+            self.game.katrain.log(f"[ScoreLossStrategy] No candidate moves found, will play pass", OUTPUT_DEBUG)
+            return Move(is_pass=True, player=self.cn.next_player), "No candidate moves found, passing"
+        
+        top_cand = Move.from_gtp(candidate_moves[0]["move"], player=self.cn.next_player)
+        self.game.katrain.log(f"[ScoreLossStrategy] Top engine move would be: {top_cand.gtp()}", OUTPUT_DEBUG)
+        
+        # Check if top move is pass
+        if top_cand.is_pass:
+            self.game.katrain.log(f"[ScoreLossStrategy] Top move is pass, so passing regardless of strategy", OUTPUT_DEBUG)
+            return top_cand, "Top move is pass, so passing regardless of strategy."
+        
+        # Get strength parameter
+        c = self.settings["strength"]
+        self.game.katrain.log(f"[ScoreLossStrategy] Strength parameter: {c}", OUTPUT_DEBUG)
+        
+        # Calculate weights for moves based on point loss
+        self.game.katrain.log(f"[ScoreLossStrategy] Calculating weights for candidate moves", OUTPUT_DEBUG)
+        
+        moves = []
+        for i, d in enumerate(candidate_moves):
+            move = Move.from_gtp(d["move"], player=self.cn.next_player)
+            points_lost = d["pointsLost"]
+            weight = math.exp(min(200, -c * max(0, points_lost)))
+            
+            self.game.katrain.log(f"[ScoreLossStrategy] Move {i+1}: {move.gtp()} - Points lost: {points_lost:.2f}, Weight: {weight:.6f}", OUTPUT_DEBUG)
+            moves.append((points_lost, weight, move))
+        
+        # Select move based on weights
+        self.game.katrain.log(f"[ScoreLossStrategy] Selecting move with weighted selection", OUTPUT_DEBUG)
+        topmove = weighted_selection_without_replacement(moves, 1)[0]
+        aimove = topmove[2]
+        
+        self.game.katrain.log(f"[ScoreLossStrategy] Selected move: {aimove.gtp()}", OUTPUT_DEBUG)
+        self.game.katrain.log(f"[ScoreLossStrategy] Selected move points lost: {topmove[0]:.2f}", OUTPUT_DEBUG)
+        self.game.katrain.log(f"[ScoreLossStrategy] Selected move weight: {topmove[1]:.6f}", OUTPUT_DEBUG)
+        
+        ai_thoughts = f"ScoreLoss strategy found {len(candidate_moves)} candidate moves (best {top_cand.gtp()}) and chose {aimove.gtp()} (weight {topmove[1]:.3f}, point loss {topmove[0]:.1f}) based on score weights."
+        
+        self.game.katrain.log(f"[ScoreLossStrategy] Final decision: {aimove.gtp()}", OUTPUT_DEBUG)
+        return aimove, ai_thoughts
+
+class OwnershipBaseStrategy(AIStrategy):
+    """Base class for ownership-based strategies"""
+    
+    def settledness(self, d, player_sign, player):
+        """Calculate settledness for Simple Ownership strategy"""
+        ownership_sum = sum([abs(o) for o in d["ownership"] if player_sign * o > 0])
+        self.game.katrain.log(f"[{self.strategy_name}] Calculating settledness for {player}, sign={player_sign}: {ownership_sum:.2f}", OUTPUT_DEBUG)
+        return ownership_sum
+    
+    def is_attachment(self, move):
+        """Check if a move is an attachment"""
+        if move.is_pass:
+            return False
+            
+        stones_with_player = {(*s.coords, s.player) for s in self.game.stones}
+        
+        attach_opponent_stones = sum(
+            (move.coords[0] + dx, move.coords[1] + dy, self.cn.player) in stones_with_player
+            for dx in [-1, 0, 1]
+            for dy in [-1, 0, 1]
+            if abs(dx) + abs(dy) == 1
+        )
+        
+        nearby_own_stones = sum(
+            (move.coords[0] + dx, move.coords[1] + dy, self.cn.next_player) in stones_with_player
+            for dx in [-2, 0, 1, 2]
+            for dy in [-2 - 1, 0, 1, 2]
+            if abs(dx) + abs(dy) <= 2  # allows clamps/jumps
+        )
+        
+        is_attach = attach_opponent_stones >= 1 and nearby_own_stones == 0
+        self.game.katrain.log(f"[{self.strategy_name}] Is move {move.gtp()} an attachment? {is_attach} (opponent stones: {attach_opponent_stones}, own stones: {nearby_own_stones})", OUTPUT_DEBUG)
+        return is_attach
+    
+    def is_tenuki(self, move):
+        """Check if a move is a tenuki (far from previous moves)"""
+        if move.is_pass:
+            return False
+            
+        result = not any(
+            not node
+            or not node.move
+            or node.move.is_pass
+            or max(abs(last_c - cand_c) for last_c, cand_c in zip(node.move.coords, move.coords)) < 5
+            for node in [self.cn, self.cn.parent]
+        )
+        
+        distances = []
+        for node in [self.cn, self.cn.parent]:
+            if node and node.move and not node.move.is_pass:
+                dist = max(abs(last_c - cand_c) for last_c, cand_c in zip(node.move.coords, move.coords))
+                distances.append(dist)
+                
+        if distances:
+            self.game.katrain.log(f"[{self.strategy_name}] Is move {move.gtp()} a tenuki? {result} (distances: {distances})", OUTPUT_DEBUG)
+        else:
+            self.game.katrain.log(f"[{self.strategy_name}] Is move {move.gtp()} a tenuki? {result} (no valid previous moves)", OUTPUT_DEBUG)
+            
+        return result
+    
+    def get_moves_with_settledness(self):
+        """Get moves with ownership and settledness information"""
+        self.game.katrain.log(f"[{self.strategy_name}] Getting moves with settledness information", OUTPUT_DEBUG)
+        
+        next_player_sign = self.cn.player_sign(self.cn.next_player)
+        candidate_moves = self.cn.candidate_moves
+        
+        self.game.katrain.log(f"[{self.strategy_name}] Processing {len(candidate_moves)} candidate moves", OUTPUT_DEBUG)
+        self.game.katrain.log(f"[{self.strategy_name}] Settings: max_points_lost={self.settings['max_points_lost']}, min_visits={self.settings.get('min_visits', 1)}", OUTPUT_DEBUG)
+        self.game.katrain.log(f"[{self.strategy_name}] Penalties: attach={self.settings['attach_penalty']}, tenuki={self.settings['tenuki_penalty']}", OUTPUT_DEBUG)
+        self.game.katrain.log(f"[{self.strategy_name}] Weights: settled={self.settings['settled_weight']}, opponent_fac={self.settings['opponent_fac']}", OUTPUT_DEBUG)
+        
+        moves_data = []
+        for d in candidate_moves:
+            # Check basic filtering conditions
+            if "pointsLost" not in d:
+                self.game.katrain.log(f"[{self.strategy_name}] Move {d['move']} has no pointsLost, skipping", OUTPUT_DEBUG)
+                continue
+                
+            if d["pointsLost"] >= self.settings["max_points_lost"]:
+                self.game.katrain.log(f"[{self.strategy_name}] Move {d['move']} has pointsLost={d['pointsLost']}, which exceeds max_points_lost={self.settings['max_points_lost']}, skipping", OUTPUT_DEBUG)
+                continue
+                
+            if "ownership" not in d:
+                self.game.katrain.log(f"[{self.strategy_name}] Move {d['move']} has no ownership data, skipping", OUTPUT_DEBUG)
+                continue
+                
+            if not (d["order"] <= 1 or d["visits"] >= self.settings.get("min_visits", 1)):
+                self.game.katrain.log(f"[{self.strategy_name}] Move {d['move']} has order={d['order']} and visits={d.get('visits', 'N/A')}, doesn't meet criteria, skipping", OUTPUT_DEBUG)
+                continue
+            
+            move = Move.from_gtp(d["move"], player=self.cn.next_player)
+            if move.is_pass and d["pointsLost"] > 0.75:
+                self.game.katrain.log(f"[{self.strategy_name}] Move {move.gtp()} is pass with high point loss ({d['pointsLost']}), skipping", OUTPUT_DEBUG)
+                continue
+            
+            # Calculate metrics
+            own_settledness = self.settledness(d, next_player_sign, self.cn.next_player)
+            opp_settledness = self.settledness(d, -next_player_sign, self.cn.player)
+            is_attach = self.is_attachment(move)
+            is_tenuki = self.is_tenuki(move)
+            
+            # Calculate total score for sorting
+            score = (d["pointsLost"] 
+                    + self.settings["attach_penalty"] * is_attach 
+                    + self.settings["tenuki_penalty"] * is_tenuki
+                    - self.settings["settled_weight"] * (own_settledness + self.settings["opponent_fac"] * opp_settledness))
+            
+            self.game.katrain.log(f"[{self.strategy_name}] Move {move.gtp()}: points_lost={d['pointsLost']:.2f}, own_settled={own_settledness:.2f}, opp_settled={opp_settledness:.2f}, attach={is_attach}, tenuki={is_tenuki}, score={score:.2f}", OUTPUT_DEBUG)
+            
+            moves_data.append((
+                move,
+                own_settledness,
+                opp_settledness,
+                is_attach,
+                is_tenuki,
+                d,
+                score  # Store the score for debugging
+            ))
+        
+        # Sort moves by score
+        sorted_moves = sorted(
+            moves_data,
+            key=lambda t: t[6]  # Sort by the precalculated score
+        )
+        
+        self.game.katrain.log(f"[{self.strategy_name}] Found {len(sorted_moves)} valid moves with settledness data", OUTPUT_DEBUG)
+        if sorted_moves:
+            self.game.katrain.log(f"[{self.strategy_name}] Top move after sorting: {sorted_moves[0][0].gtp()} with score {sorted_moves[0][6]:.2f}", OUTPUT_DEBUG)
+        
+        # Return all data except the score which was just for debugging
+        return [(move, own_settled, opp_settled, is_attach, is_tenuki, d) for move, own_settled, opp_settled, is_attach, is_tenuki, d, _ in sorted_moves]
+
+@register_strategy(AI_SIMPLE_OWNERSHIP)
+class SimpleOwnershipStrategy(OwnershipBaseStrategy):
+    """Simple Ownership strategy - weights moves based on territory control"""
+    
+    def generate_move(self) -> Tuple[Move, str]:
+        self.game.katrain.log(f"[SimpleOwnershipStrategy] Starting move generation", OUTPUT_DEBUG)
+        self.wait_for_analysis()
+        
+        candidate_moves = self.cn.candidate_moves
+        self.game.katrain.log(f"[SimpleOwnershipStrategy] Analysis found {len(candidate_moves)} candidate moves", OUTPUT_DEBUG)
+        
+        if not candidate_moves:
+            self.game.katrain.log(f"[SimpleOwnershipStrategy] No candidate moves found, will play pass", OUTPUT_DEBUG)
+            return Move(is_pass=True, player=self.cn.next_player), "No candidate moves found, passing"
+        
+        top_cand = Move.from_gtp(candidate_moves[0]["move"], player=self.cn.next_player)
+        self.game.katrain.log(f"[SimpleOwnershipStrategy] Top engine move would be: {top_cand.gtp()}", OUTPUT_DEBUG)
+        
+        # Check if top move is pass
+        if top_cand.is_pass:
+            self.game.katrain.log(f"[SimpleOwnershipStrategy] Top move is pass, so passing regardless of strategy", OUTPUT_DEBUG)
+            return top_cand, "Top move is pass, so passing regardless of strategy."
+        
+        # Get moves sorted by settledness criteria
+        self.game.katrain.log(f"[SimpleOwnershipStrategy] Getting moves with settledness info", OUTPUT_DEBUG)
+        moves_with_settledness = self.get_moves_with_settledness()
+        
+        if moves_with_settledness:
+            self.game.katrain.log(f"[SimpleOwnershipStrategy] Found {len(moves_with_settledness)} moves with settledness info", OUTPUT_DEBUG)
+            
+            # Log top 5 candidates in detail
+            self.game.katrain.log(f"[SimpleOwnershipStrategy] Top 5 candidates:", OUTPUT_DEBUG)
+            for i, (move, settled, oppsettled, isattach, istenuki, d) in enumerate(moves_with_settledness[:5]):
+                self.game.katrain.log(f"[SimpleOwnershipStrategy] #{i+1}: {move.gtp()} - pt_lost: {d['pointsLost']:.1f}, visits: {d.get('visits', 'N/A')}, settledness: {settled:.1f}, opp_settled: {oppsettled:.1f}, attach: {isattach}, tenuki: {istenuki}", OUTPUT_DEBUG)
+            
+            # Format candidate moves for ai_thoughts
+            cands = [
+                f"{move.gtp()} ({d['pointsLost']:.1f} pt lost, {d.get('visits', 'N/A')} visits, {settled:.1f} settledness, {oppsettled:.1f} opponent settledness{', attachment' if isattach else ''}{', tenuki' if istenuki else ''})"
+                for move, settled, oppsettled, isattach, istenuki, d in moves_with_settledness[:5]
+            ]
+            
+            ai_thoughts = f"{AI_SIMPLE_OWNERSHIP} strategy. Top 5 Candidates {', '.join(cands)} "
+            aimove = moves_with_settledness[0][0]
+            
+            self.game.katrain.log(f"[SimpleOwnershipStrategy] Selected move: {aimove.gtp()}", OUTPUT_DEBUG)
+        else:
+            error_msg = "No moves found - are you using an older KataGo with no per-move ownership info?"
+            self.game.katrain.log(f"[SimpleOwnershipStrategy] Error: {error_msg}", OUTPUT_ERROR)
+            raise Exception(error_msg)
+        
+        self.game.katrain.log(f"[SimpleOwnershipStrategy] Final decision: {aimove.gtp()}", OUTPUT_DEBUG)
+        return aimove, ai_thoughts
+
+@register_strategy(AI_SETTLE_STONES)
+class SettleStonesStrategy(OwnershipBaseStrategy):
+    """Settle Stones strategy - focuses on settled stones"""
+    
+    def settledness(self, d, player_sign, player):
+        """Calculate settledness for Settle Stones strategy"""
+        board_size_x, board_size_y = self.game.board_size
+        ownership_grid = var_to_grid(d["ownership"], (board_size_x, board_size_y))
+        
+        # Sum the absolute ownership values of existing stones
+        stone_ownership_values = [abs(ownership_grid[s.coords[0]][s.coords[1]]) for s in self.game.stones if s.player == player]
+        total_settledness = sum(stone_ownership_values)
+        
+        self.game.katrain.log(f"[SettleStonesStrategy] Calculating settledness for {player}, sign={player_sign}", OUTPUT_DEBUG)
+        self.game.katrain.log(f"[SettleStonesStrategy] Number of stones considered: {len(stone_ownership_values)}", OUTPUT_DEBUG)
+        self.game.katrain.log(f"[SettleStonesStrategy] Total settledness: {total_settledness:.2f}", OUTPUT_DEBUG)
+        
+        if stone_ownership_values:
+            self.game.katrain.log(f"[SettleStonesStrategy] Min stone ownership: {min(stone_ownership_values):.2f}", OUTPUT_DEBUG)
+            self.game.katrain.log(f"[SettleStonesStrategy] Max stone ownership: {max(stone_ownership_values):.2f}", OUTPUT_DEBUG)
+            self.game.katrain.log(f"[SettleStonesStrategy] Avg stone ownership: {total_settledness / len(stone_ownership_values):.2f}", OUTPUT_DEBUG)
+        
+        return total_settledness
+    
+    def generate_move(self) -> Tuple[Move, str]:
+        self.game.katrain.log(f"[SettleStonesStrategy] Starting move generation", OUTPUT_DEBUG)
+        self.wait_for_analysis()
+        
+        candidate_moves = self.cn.candidate_moves
+        self.game.katrain.log(f"[SettleStonesStrategy] Analysis found {len(candidate_moves)} candidate moves", OUTPUT_DEBUG)
+        
+        if not candidate_moves:
+            self.game.katrain.log(f"[SettleStonesStrategy] No candidate moves found, will play pass", OUTPUT_DEBUG)
+            return Move(is_pass=True, player=self.cn.next_player), "No candidate moves found, passing"
+        
+        top_cand = Move.from_gtp(candidate_moves[0]["move"], player=self.cn.next_player)
+        self.game.katrain.log(f"[SettleStonesStrategy] Top engine move would be: {top_cand.gtp()}", OUTPUT_DEBUG)
+        
+        # Check if top move is pass
+        if top_cand.is_pass:
+            self.game.katrain.log(f"[SettleStonesStrategy] Top move is pass, so passing regardless of strategy", OUTPUT_DEBUG)
+            return top_cand, "Top move is pass, so passing regardless of strategy."
+        
+        # Log the number of stones on the board
+        black_stones = sum(1 for s in self.game.stones if s.player == "B")
+        white_stones = sum(1 for s in self.game.stones if s.player == "W")
+        self.game.katrain.log(f"[SettleStonesStrategy] Stones on board: B={black_stones}, W={white_stones}", OUTPUT_DEBUG)
+        
+        # Get moves sorted by settledness criteria
+        self.game.katrain.log(f"[SettleStonesStrategy] Getting moves with settledness info", OUTPUT_DEBUG)
+        moves_with_settledness = self.get_moves_with_settledness()
+        
+        if moves_with_settledness:
+            self.game.katrain.log(f"[SettleStonesStrategy] Found {len(moves_with_settledness)} moves with settledness info", OUTPUT_DEBUG)
+            
+            # Log top 5 candidates in detail
+            self.game.katrain.log(f"[SettleStonesStrategy] Top 5 candidates:", OUTPUT_DEBUG)
+            for i, (move, settled, oppsettled, isattach, istenuki, d) in enumerate(moves_with_settledness[:5]):
+                self.game.katrain.log(f"[SettleStonesStrategy] #{i+1}: {move.gtp()} - pt_lost: {d['pointsLost']:.1f}, visits: {d.get('visits', 'N/A')}, settledness: {settled:.1f}, opp_settled: {oppsettled:.1f}, attach: {isattach}, tenuki: {istenuki}", OUTPUT_DEBUG)
+            
+            # Format candidate moves for ai_thoughts
+            cands = [
+                f"{move.gtp()} ({d['pointsLost']:.1f} pt lost, {d.get('visits', 'N/A')} visits, {settled:.1f} settledness, {oppsettled:.1f} opponent settledness{', attachment' if isattach else ''}{', tenuki' if istenuki else ''})"
+                for move, settled, oppsettled, isattach, istenuki, d in moves_with_settledness[:5]
+            ]
+            
+            ai_thoughts = f"{AI_SETTLE_STONES} strategy. Top 5 Candidates {', '.join(cands)} "
+            aimove = moves_with_settledness[0][0]
+            
+            self.game.katrain.log(f"[SettleStonesStrategy] Selected move: {aimove.gtp()}", OUTPUT_DEBUG)
+        else:
+            error_msg = "No moves found - are you using an older KataGo with no per-move ownership info?"
+            self.game.katrain.log(f"[SettleStonesStrategy] Error: {error_msg}", OUTPUT_ERROR)
+            raise Exception(error_msg)
+        
+        self.game.katrain.log(f"[SettleStonesStrategy] Final decision: {aimove.gtp()}", OUTPUT_DEBUG)
+        return aimove, ai_thoughts
+
+@register_strategy(AI_POLICY)
+class PolicyStrategy(AIStrategy):
+    """Policy strategy - plays the top move suggested by policy network"""
+    
+    def generate_move(self) -> Tuple[Move, str]:
+        self.game.katrain.log(f"[PolicyStrategy] Starting move generation", OUTPUT_DEBUG)
+        self.wait_for_analysis()
+        
+        # Ensure policy is available
+        if not self.cn.policy:
+            self.game.katrain.log(f"[PolicyStrategy] No policy data available, falling back to DefaultStrategy", OUTPUT_DEBUG)
+            return DefaultStrategy(self.game, self.settings).generate_move()
+        
+        policy_moves = self.cn.policy_ranking
+        pass_policy = self.cn.policy[-1]
+        
+        self.game.katrain.log(f"[PolicyStrategy] Got {len(policy_moves)} policy moves", OUTPUT_DEBUG)
+        self.game.katrain.log(f"[PolicyStrategy] Current move depth: {self.cn.depth}", OUTPUT_DEBUG)
+        self.game.katrain.log(f"[PolicyStrategy] Opening moves setting: {self.settings.get('opening_moves', 0)}", OUTPUT_DEBUG)
+        
+        # Log top 5 policy moves
+        self.game.katrain.log(f"[PolicyStrategy] Top 5 policy moves:", OUTPUT_DEBUG)
+        for i, (prob, move) in enumerate(policy_moves[:5]):
+            self.game.katrain.log(f"[PolicyStrategy] #{i+1}: {move.gtp()} - {prob:.2%}", OUTPUT_DEBUG)
+        
+        self.game.katrain.log(f"[PolicyStrategy] Pass policy: {pass_policy:.2%}", OUTPUT_DEBUG)
+        
+        # Check for pass in top 5
+        top_5_pass = any([polmove[1].is_pass for polmove in policy_moves[:5]])
+        self.game.katrain.log(f"[PolicyStrategy] Pass in top 5: {top_5_pass}", OUTPUT_DEBUG)
+        
+        # Handle opening moves override
+        if self.cn.depth <= self.settings.get("opening_moves", 0):
+            self.game.katrain.log(f"[PolicyStrategy] In opening phase, using WeightedStrategy instead", OUTPUT_DEBUG)
+            weighted_settings = {
+                "pick_override": 0.9, 
+                "weaken_fac": 1, 
+                "lower_bound": 0.02
+            }
+            self.game.katrain.log(f"[PolicyStrategy] Weighted settings: {weighted_settings}", OUTPUT_DEBUG)
+            return WeightedStrategy(self.game, weighted_settings).generate_move()
+        
+        # Check for pass in top 5
+        if top_5_pass:
+            aimove = policy_moves[0][1]
+            self.game.katrain.log(f"[PolicyStrategy] Playing top move {aimove.gtp()} because pass in top 5", OUTPUT_DEBUG)
+            ai_thoughts = "Playing top one because one of them is pass."
+            return aimove, ai_thoughts
+        
+        # Otherwise play top policy move
+        aimove = policy_moves[0][1]
+        self.game.katrain.log(f"[PolicyStrategy] Playing top policy move {aimove.gtp()} with probability {policy_moves[0][0]:.2%}", OUTPUT_DEBUG)
+        ai_thoughts = f"Playing top policy move {aimove.gtp()}."
+        
+        self.game.katrain.log(f"[PolicyStrategy] Final decision: {aimove.gtp()}", OUTPUT_DEBUG)
+        return aimove, ai_thoughts
+
+@register_strategy(AI_WEIGHTED)
+class WeightedStrategy(AIStrategy):
+    """Weighted strategy - weights moves based on policy and a weakening factor"""
+    
+    def generate_move(self) -> Tuple[Move, str]:
+        self.game.katrain.log(f"[WeightedStrategy] Starting move generation", OUTPUT_DEBUG)
+        self.wait_for_analysis()
+        
+        # Ensure policy is available
+        if not self.cn.policy:
+            self.game.katrain.log(f"[WeightedStrategy] No policy data available, falling back to DefaultStrategy", OUTPUT_DEBUG)
+            return DefaultStrategy(self.game, self.settings).generate_move()
+        
+        policy_moves = self.cn.policy_ranking
+        pass_policy = self.cn.policy[-1]
+        
+        self.game.katrain.log(f"[WeightedStrategy] Got {len(policy_moves)} policy moves", OUTPUT_DEBUG)
+        
+        # Log top 5 policy moves
+        self.game.katrain.log(f"[WeightedStrategy] Top 5 policy moves:", OUTPUT_DEBUG)
+        for i, (prob, move) in enumerate(policy_moves[:5]):
+            self.game.katrain.log(f"[WeightedStrategy] #{i+1}: {move.gtp()} - {prob:.2%}", OUTPUT_DEBUG)
+        
+        self.game.katrain.log(f"[WeightedStrategy] Pass policy: {pass_policy:.2%}", OUTPUT_DEBUG)
+        
+        # Check for pass in top 5
+        top_5_pass = any([polmove[1].is_pass for polmove in policy_moves[:5]])
+        self.game.katrain.log(f"[WeightedStrategy] Pass in top 5: {top_5_pass}", OUTPUT_DEBUG)
+        
+        # Get override threshold
+        override = self.settings.get("pick_override", 0.0)
+        self.game.katrain.log(f"[WeightedStrategy] Override threshold: {override:.2%}", OUTPUT_DEBUG)
+        
+        # Check if we should override with top move
+        override_move, override_thoughts = self.should_play_top_move(
+            policy_moves, 
+            top_5_pass,
+            override=override
+        )
+        
+        if override_move:
+            self.game.katrain.log(f"[WeightedStrategy] Using override move: {override_move.gtp()}", OUTPUT_DEBUG)
+            return override_move, override_thoughts
+        
+        # Apply weighted policy move selection
+        lower_bound = self.settings.get("lower_bound", 0.02)
+        weaken_fac = self.settings.get("weaken_fac", 1.0)
+        
+        self.game.katrain.log(f"[WeightedStrategy] Using weighted selection with lower_bound={lower_bound:.2%}, weaken_fac={weaken_fac}", OUTPUT_DEBUG)
+        
+        # Generate list of weighted coordinates
+        weighted_coords = [
+            (pv, pv ** (1 / weaken_fac), move) for pv, move in policy_moves if pv > lower_bound and not move.is_pass
+        ]
+        
+        self.game.katrain.log(f"[WeightedStrategy] Found {len(weighted_coords)} moves above lower bound", OUTPUT_DEBUG)
+        
+        if weighted_coords:
+            self.game.katrain.log(f"[WeightedStrategy] Performing weighted selection", OUTPUT_DEBUG)
+            top = weighted_selection_without_replacement(weighted_coords, 1)[0]
+            move = top[2]
+            prob = top[0]
+            
+            self.game.katrain.log(f"[WeightedStrategy] Selected move {move.gtp()} with probability {prob:.2%}", OUTPUT_DEBUG)
+            ai_thoughts = f"Playing policy-weighted random move {move.gtp()} ({prob:.1%}) from {len(weighted_coords)} moves above lower_bound of {lower_bound:.1%}."
+        else:
+            move = policy_moves[0][1]
+            self.game.katrain.log(f"[WeightedStrategy] No moves above lower bound, playing top policy move {move.gtp()}", OUTPUT_DEBUG)
+            ai_thoughts = f"Playing top policy move because no non-pass move > above lower_bound of {lower_bound:.1%}."
+        
+        self.game.katrain.log(f"[WeightedStrategy] Final decision: {move.gtp()}", OUTPUT_DEBUG)
+        return move, ai_thoughts
+
+class PickBasedStrategy(AIStrategy):
+    """Base class for pick-based strategies"""
+    
+    def get_n_moves(self, legal_policy_moves):
+        """Calculate the number of moves to consider"""
+        board_squares = self.game.board_size[0] * self.game.board_size[1]
+        
+        if self.settings.get("pick_frac") is not None:
+            n_moves = max(1, int(self.settings["pick_frac"] * len(legal_policy_moves) + self.settings["pick_n"]))
+            self.game.katrain.log(f"[{self.strategy_name}] Calculated n_moves={n_moves} from pick_frac={self.settings['pick_frac']}, pick_n={self.settings['pick_n']}, legal_moves={len(legal_policy_moves)}", OUTPUT_DEBUG)
+        else:
+            n_moves = 1  # Default
+            self.game.katrain.log(f"[{self.strategy_name}] Using default n_moves={n_moves} (no pick_frac in settings)", OUTPUT_DEBUG)
+            
+        return n_moves
+    
+    def generate_weighted_coords(self, legal_policy_moves, policy_grid, size):
+        """Generate weighted coordinates for selection"""
+        self.game.katrain.log(f"[{self.strategy_name}] Generating weighted coordinates (default equal weights implementation)", OUTPUT_DEBUG)
+        
+        # Default implementation for AI_PICK - equal weights
+        weighted_coords = [
+            (policy_grid[y][x], 1, x, y)
+            for x in range(size[0])
+            for y in range(size[1])
+            if policy_grid[y][x] > 0
+        ]
+        
+        self.game.katrain.log(f"[{self.strategy_name}] Generated {len(weighted_coords)} weighted coordinates", OUTPUT_DEBUG)
+        
+        if weighted_coords:
+            top5 = heapq.nlargest(5, weighted_coords, key=lambda t: t[0])
+            self.game.katrain.log(f"[{self.strategy_name}] Top 5 weighted coordinates by policy value:", OUTPUT_DEBUG)
+            for i, (pol, wt, x, y) in enumerate(top5):
+                self.game.katrain.log(f"[{self.strategy_name}] #{i+1}: ({x},{y}) - policy={pol:.2%}, weight={wt}", OUTPUT_DEBUG)
+                
+        return weighted_coords, "Generated equal weights for all moves. "
+    
+    def handle_endgame(self, legal_policy_moves, policy_grid, size):
+        """Handle special endgame case"""
+        board_squares = size[0] * size[1]
+        endgame_threshold = self.settings.get("endgame", 0.75) * board_squares
+        
+        self.game.katrain.log(f"[{self.strategy_name}] Checking endgame condition: move depth {self.cn.depth} vs threshold {endgame_threshold}", OUTPUT_DEBUG)
+        
+        if self.cn.depth > endgame_threshold:
+            self.game.katrain.log(f"[{self.strategy_name}] In endgame phase (move {self.cn.depth} > {endgame_threshold})", OUTPUT_DEBUG)
+            
+            weighted_coords = [(pol, 1, *mv.coords) for pol, mv in legal_policy_moves]
+            ai_thoughts = f"Generated equal weights as move number >= {self.settings['endgame'] * size[0] * size[1]}. "
+            
+            n_moves = int(max(self.get_n_moves(legal_policy_moves), len(legal_policy_moves) // 2))
+            self.game.katrain.log(f"[{self.strategy_name}] Using endgame n_moves={n_moves}", OUTPUT_DEBUG)
+            
+            self.game.katrain.log(f"[{self.strategy_name}] Generated {len(weighted_coords)} weighted coordinates for endgame", OUTPUT_DEBUG)
+            
+            return weighted_coords, ai_thoughts, n_moves, True
+            
+        self.game.katrain.log(f"[{self.strategy_name}] Not in endgame phase yet", OUTPUT_DEBUG)
+        return None, "", None, False
+    
+    def select_from_weighted_coords(self, weighted_coords, n_moves, pass_policy):
+        """Select moves from weighted coordinates"""
+        self.game.katrain.log(f"[{self.strategy_name}] Selecting from {len(weighted_coords)} weighted coordinates, n_moves={n_moves}", OUTPUT_DEBUG)
+        
+        # Perform weighted selection
+        pick_moves = weighted_selection_without_replacement(weighted_coords, n_moves)
+        self.game.katrain.log(f"[{self.strategy_name}] Picked {len(pick_moves)} moves", OUTPUT_DEBUG)
+        
+        if pick_moves:
+            # Get top 5 from picked moves
+            top_picked = heapq.nlargest(5, pick_moves)
+            self.game.katrain.log(f"[{self.strategy_name}] Top 5 after selection:", OUTPUT_DEBUG)
+            for i, (p, wt, x, y) in enumerate(top_picked):
+                self.game.katrain.log(f"[{self.strategy_name}] #{i+1}: ({x},{y}) - policy={p:.2%}, weight={wt}", OUTPUT_DEBUG)
+            
+            # Convert to move objects
+            new_top = [
+                (p, Move((x, y), player=self.cn.next_player)) for p, wt, x, y in top_picked
+            ]
+            
+            aimove = new_top[0][1]
+            ai_thoughts = f"Top 5 among these were {fmt_moves(new_top)} and picked top {aimove.gtp()}. "
+            
+            self.game.katrain.log(f"[{self.strategy_name}] Top picked move: {aimove.gtp()} ({new_top[0][0]:.2%})", OUTPUT_DEBUG)
+            self.game.katrain.log(f"[{self.strategy_name}] Pass policy: {pass_policy:.2%}", OUTPUT_DEBUG)
+            
+            # Check if pass is better
+            if new_top[0][0] < pass_policy:
+                self.game.katrain.log(f"[{self.strategy_name}] Pass policy {pass_policy:.2%} is better than top move {aimove.gtp()} ({new_top[0][0]:.2%}), switching to top policy move", OUTPUT_DEBUG)
+                
+                policy_moves = self.cn.policy_ranking
+                top_policy_move = policy_moves[0][1]
+                
+                ai_thoughts += f"But found pass ({pass_policy:.2%} to be higher rated than {aimove.gtp()} ({new_top[0][0]:.2%}) so will play top policy move instead."
+                aimove = top_policy_move
+                
+                self.game.katrain.log(f"[{self.strategy_name}] Final move (after pass check): {aimove.gtp()}", OUTPUT_DEBUG)
+            else:
+                self.game.katrain.log(f"[{self.strategy_name}] Top move is better than pass, keeping it", OUTPUT_DEBUG)
+        else:
+            self.game.katrain.log(f"[{self.strategy_name}] No moves selected, falling back to top policy move", OUTPUT_DEBUG)
+            
+            policy_moves = self.cn.policy_ranking
+            top_policy_move = policy_moves[0][1]
+            aimove = top_policy_move
+            
+            ai_thoughts = f"Pick policy strategy failed to find legal moves, so is playing top policy move {aimove.gtp()}."
+            
+            self.game.katrain.log(f"[{self.strategy_name}] Final move (fallback): {aimove.gtp()}", OUTPUT_DEBUG)
+            
+        return aimove, ai_thoughts
+    
+    def generate_move(self) -> Tuple[Move, str]:
+        self.game.katrain.log(f"[{self.strategy_name}] Starting move generation", OUTPUT_DEBUG)
+        self.wait_for_analysis()
+        
+        # Ensure policy is available
+        if not self.cn.policy:
+            self.game.katrain.log(f"[{self.strategy_name}] No policy data available, falling back to DefaultStrategy", OUTPUT_DEBUG)
+            return DefaultStrategy(self.game, self.settings).generate_move()
+        
+        policy_moves = self.cn.policy_ranking
+        pass_policy = self.cn.policy[-1]
+        
+        self.game.katrain.log(f"[{self.strategy_name}] Got {len(policy_moves)} policy moves", OUTPUT_DEBUG)
+        
+        # Log top 5 policy moves
+        self.game.katrain.log(f"[{self.strategy_name}] Top 5 policy moves:", OUTPUT_DEBUG)
+        for i, (prob, move) in enumerate(policy_moves[:5]):
+            self.game.katrain.log(f"[{self.strategy_name}] #{i+1}: {move.gtp()} - {prob:.2%}", OUTPUT_DEBUG)
+        
+        self.game.katrain.log(f"[{self.strategy_name}] Pass policy: {pass_policy:.2%}", OUTPUT_DEBUG)
+        
+        # Check for pass in top 5
+        top_5_pass = any([polmove[1].is_pass for polmove in policy_moves[:5]])
+        self.game.katrain.log(f"[{self.strategy_name}] Pass in top 5: {top_5_pass}", OUTPUT_DEBUG)
+        
+        # Get override settings
+        override = self.settings.get("pick_override", 0.0)
+        overridetwo = self.settings.get("pick_override_two", 1.0)
+        self.game.katrain.log(f"[{self.strategy_name}] Override settings: single={override:.2%}, combined={overridetwo:.2%}", OUTPUT_DEBUG)
+        
+        # Check if we should override with top move
+        override_move, override_thoughts = self.should_play_top_move(
+            policy_moves, 
+            top_5_pass,
+            override=override,
+            overridetwo=overridetwo
+        )
+        
+        if override_move:
+            self.game.katrain.log(f"[{self.strategy_name}] Using override move: {override_move.gtp()}", OUTPUT_DEBUG)
+            return override_move, override_thoughts
+        
+        # Get legal policy moves
+        legal_policy_moves = [(pol, mv) for pol, mv in policy_moves if not mv.is_pass and pol > 0]
+        self.game.katrain.log(f"[{self.strategy_name}] Found {len(legal_policy_moves)} legal non-pass policy moves", OUTPUT_DEBUG)
+        
+        # Create policy grid
+# Create policy grid
+        size = self.game.board_size
+        self.game.katrain.log(f"[{self.strategy_name}] Board size: {size}", OUTPUT_DEBUG)
+        policy_grid = var_to_grid(self.cn.policy, size)
+        
+        # Check for endgame
+        end_coords, end_thoughts, end_n_moves, is_endgame = self.handle_endgame(legal_policy_moves, policy_grid, size)
+        
+        if is_endgame:
+            self.game.katrain.log(f"[{self.strategy_name}] Using endgame logic", OUTPUT_DEBUG)
+            return self.select_from_weighted_coords(end_coords, end_n_moves, pass_policy)
+        
+        # Get weighted coordinates
+        self.game.katrain.log(f"[{self.strategy_name}] Generating weighted coordinates", OUTPUT_DEBUG)
+        weighted_coords, weight_thoughts = self.generate_weighted_coords(legal_policy_moves, policy_grid, size)
+        
+        # Get number of moves to consider
+        n_moves = self.get_n_moves(legal_policy_moves)
+        self.game.katrain.log(f"[{self.strategy_name}] Using n_moves={n_moves}", OUTPUT_DEBUG)
+        
+        ai_thoughts = weight_thoughts + f"Picked {min(n_moves, len(weighted_coords))} random moves according to weights. "
+        
+        # Select and return move
+        self.game.katrain.log(f"[{self.strategy_name}] Selecting move from weighted coordinates", OUTPUT_DEBUG)
+        move, thoughts = self.select_from_weighted_coords(weighted_coords, n_moves, pass_policy)
+        
+        self.game.katrain.log(f"[{self.strategy_name}] Final decision: {move.gtp()}", OUTPUT_DEBUG)
+        return move, ai_thoughts + thoughts
+
+@register_strategy(AI_PICK)
+class PickStrategy(PickBasedStrategy):
+    """Pick strategy - picks a move from a subset of legal moves"""
+    
+    def generate_move(self) -> Tuple[Move, str]:
+        self.game.katrain.log(f"[PickStrategy] Starting move generation using base PickBasedStrategy implementation", OUTPUT_DEBUG)
+        return super().generate_move()
+
+    def handle_endgame(self, legal_policy_moves, policy_grid, size):
+        return None, "", None, False
+
+@register_strategy(AI_RANK)
+class RankStrategy(PickBasedStrategy):
+    """Rank strategy - similar to Pick but calibrated based on rank"""
+    
+    def get_n_moves(self, legal_policy_moves):
+        """Calculate n_moves based on rank"""
+        self.game.katrain.log(f"[RankStrategy] Calculating n_moves based on rank", OUTPUT_DEBUG)
+        
+        size = self.game.board_size
+        board_squares = size[0] * size[1]
+        norm_leg_moves = len(legal_policy_moves) / board_squares
+        
+        self.game.katrain.log(f"[RankStrategy] Board squares: {board_squares}", OUTPUT_DEBUG)
+        self.game.katrain.log(f"[RankStrategy] Legal moves: {len(legal_policy_moves)}", OUTPUT_DEBUG)
+        self.game.katrain.log(f"[RankStrategy] Normalized legal moves: {norm_leg_moves:.4f}", OUTPUT_DEBUG)
+        self.game.katrain.log(f"[RankStrategy] Kyu rank: {self.settings['kyu_rank']}", OUTPUT_DEBUG)
+        
+        # Calculate n_moves using the rank formula
+        orig_calib_avemodrank = 0.063015 + 0.7624 * board_squares / (
+            10 ** (-0.05737 * self.settings["kyu_rank"] + 1.9482)
+        )
+        
+        self.game.katrain.log(f"[RankStrategy] Original calibrated average mod rank: {orig_calib_avemodrank:.4f}", OUTPUT_DEBUG)
+        
+        exponent_term = (
+            3.002 * norm_leg_moves * norm_leg_moves
+            - norm_leg_moves
+            - 0.034889 * self.settings["kyu_rank"]
+            - 0.5097
+        )
+        self.game.katrain.log(f"[RankStrategy] Exponent term: {exponent_term:.4f}", OUTPUT_DEBUG)
+        
+        modified_calib_avemodrank = (
+            0.3931
+            + 0.6559
+            * norm_leg_moves
+            * math.exp(-1 * exponent_term ** 2)
+            - 0.01093 * self.settings["kyu_rank"]
+        ) * orig_calib_avemodrank
+        
+        self.game.katrain.log(f"[RankStrategy] Modified calibrated average mod rank: {modified_calib_avemodrank:.4f}", OUTPUT_DEBUG)
+        
+        denominator = 1.31165 * (modified_calib_avemodrank + 1) - 0.082653
+        self.game.katrain.log(f"[RankStrategy] Denominator: {denominator:.4f}", OUTPUT_DEBUG)
+        
+        n_moves = board_squares * norm_leg_moves / denominator
+        n_moves = max(1, round(n_moves))
+        
+        self.game.katrain.log(f"[RankStrategy] Calculated n_moves: {n_moves}", OUTPUT_DEBUG)
+        
+        return n_moves
+    
+    def should_play_top_move(self, policy_moves, top_5_pass, override=0.0, overridetwo=1.0):
+        """Special override logic for rank-based"""
+        self.game.katrain.log(f"[RankStrategy] Calculating special override thresholds based on rank", OUTPUT_DEBUG)
+        
+        size = self.game.board_size
+        board_squares = size[0] * size[1]
+        legal_policy_moves = [(pol, mv) for pol, mv in policy_moves if not mv.is_pass and pol > 0]
+        
+        # Parameters for calculating the overrides
+        self.game.katrain.log(f"[RankStrategy] Board squares: {board_squares}", OUTPUT_DEBUG)
+        self.game.katrain.log(f"[RankStrategy] Legal non-pass moves: {len(legal_policy_moves)}", OUTPUT_DEBUG)
+        self.game.katrain.log(f"[RankStrategy] Kyu rank: {self.settings['kyu_rank']}", OUTPUT_DEBUG)
+        
+        # Calibrated override based on board filling
+        ratio = (board_squares - len(legal_policy_moves)) / board_squares
+        override = 0.8 * (1 - 0.5 * ratio)
+        self.game.katrain.log(f"[RankStrategy] Calculated override: {override:.2%} (from board filling ratio {ratio:.2f})", OUTPUT_DEBUG)
+        
+        overridetwo = 0.85 + max(0, 0.02 * (self.settings["kyu_rank"] - 8))
+        self.game.katrain.log(f"[RankStrategy] Calculated overridetwo: {overridetwo:.2%} (from kyu rank adjustment)", OUTPUT_DEBUG)
+        
+        # Call the parent class method with calculated overrides
+        return super().should_play_top_move(policy_moves, top_5_pass, override, overridetwo)
+
+    def handle_endgame(self, legal_policy_moves, policy_grid, size):
+        return None, "", None, False
+
+@register_strategy(AI_INFLUENCE)
+class InfluenceStrategy(PickBasedStrategy):
+    """Influence strategy - weights moves based on influence (distance from edge)"""
+    
+    def generate_weighted_coords(self, legal_policy_moves, policy_grid, size):
+        """Generate influence-based weights"""
+        self.game.katrain.log(f"[InfluenceStrategy] Generating influence-based weights", OUTPUT_DEBUG)
+        self.game.katrain.log(f"[InfluenceStrategy] Settings: threshold={self.settings['threshold']}, line_weight={self.settings['line_weight']}", OUTPUT_DEBUG)
+        weighted_coords, ai_thoughts = generate_influence_territory_weights(
+            AI_INFLUENCE, 
+            self.settings, 
+            policy_grid, 
+            size
+        )
+        self.game.katrain.log(f"[InfluenceStrategy] Generated {len(weighted_coords)} weighted coordinates", OUTPUT_DEBUG)
+        if weighted_coords:
+            top5 = heapq.nlargest(5, weighted_coords, key=lambda t: t[0] * t[1])
+            self.game.katrain.log(f"[InfluenceStrategy] Top 5 weighted coordinates (by policy*weight):", OUTPUT_DEBUG)
+            for i, (pol, wt, x, y) in enumerate(top5):
+                self.game.katrain.log(f"[InfluenceStrategy] #{i+1}: ({x},{y}) - policy={pol:.2%}, weight={wt}, combined={pol*wt:.2%}", OUTPUT_DEBUG)
+        return weighted_coords, ai_thoughts
+
+@register_strategy(AI_TERRITORY)
+class TerritoryStrategy(PickBasedStrategy):
+    """Territory strategy - weights moves based on territory (distance from center)"""
+    
+    def generate_weighted_coords(self, legal_policy_moves, policy_grid, size):
+        """Generate territory-based weights"""
+        self.game.katrain.log(f"[TerritoryStrategy] Generating territory-based weights", OUTPUT_DEBUG)
+        self.game.katrain.log(f"[TerritoryStrategy] Settings: threshold={self.settings['threshold']}, line_weight={self.settings['line_weight']}", OUTPUT_DEBUG)
+        weighted_coords, ai_thoughts = generate_influence_territory_weights(
+            AI_TERRITORY, 
+            self.settings, 
+            policy_grid, 
+            size
+        )
+        self.game.katrain.log(f"[TerritoryStrategy] Generated {len(weighted_coords)} weighted coordinates", OUTPUT_DEBUG)
+        if weighted_coords:
+            top5 = heapq.nlargest(5, weighted_coords, key=lambda t: t[0] * t[1])
+            self.game.katrain.log(f"[TerritoryStrategy] Top 5 weighted coordinates (by policy*weight):", OUTPUT_DEBUG)
+            for i, (pol, wt, x, y) in enumerate(top5):
+                self.game.katrain.log(f"[TerritoryStrategy] #{i+1}: ({x},{y}) - policy={pol:.2%}, weight={wt}, combined={pol*wt:.2%}", OUTPUT_DEBUG)
+        return weighted_coords, ai_thoughts
+
+@register_strategy(AI_LOCAL)
+class LocalStrategy(PickBasedStrategy):
+    """Local strategy - weights moves based on proximity to the last move"""
+    
+    def generate_move(self) -> Tuple[Move, str]:
+        # Handle the case where there's no previous move
+        if not (self.cn.move and self.cn.move.coords):
+            self.game.katrain.log(f"[LocalStrategy] No previous move with valid coordinates found, falling back to WeightedStrategy", OUTPUT_DEBUG)
+            self.game.katrain.log(f"[LocalStrategy] Using default weighted settings: pick_override=0.9, weaken_fac=1, lower_bound=0.02", OUTPUT_DEBUG)
+            return WeightedStrategy(self.game, {
+                "pick_override": 0.9, 
+                "weaken_fac": 1, 
+                "lower_bound": 0.02
+            }).generate_move()
+        
+        return super().generate_move()
+    
+    def generate_weighted_coords(self, legal_policy_moves, policy_grid, size):
+        """Generate local-based weights"""
+        self.game.katrain.log(f"[LocalStrategy] Generating local-based weights around previous move", OUTPUT_DEBUG)
+        self.game.katrain.log(f"[LocalStrategy] Previous move: {self.cn.move.gtp()}", OUTPUT_DEBUG)
+        self.game.katrain.log(f"[LocalStrategy] Variance setting: {self.settings['stddev']}", OUTPUT_DEBUG)
+        weighted_coords, ai_thoughts = generate_local_tenuki_weights(
+            AI_LOCAL, 
+            self.settings, 
+            policy_grid, 
+            self.cn, 
+            size
+        )
+        self.game.katrain.log(f"[LocalStrategy] Generated {len(weighted_coords)} weighted coordinates", OUTPUT_DEBUG)
+        if weighted_coords:
+            top5 = heapq.nlargest(5, weighted_coords, key=lambda t: t[0] * t[1])
+            self.game.katrain.log(f"[LocalStrategy] Top 5 weighted coordinates (by policy*weight):", OUTPUT_DEBUG)
+            for i, (pol, wt, x, y) in enumerate(top5):
+                self.game.katrain.log(f"[LocalStrategy] #{i+1}: ({x},{y}) - policy={pol:.2%}, weight={wt}, combined={pol*wt:.2%}", OUTPUT_DEBUG)
+        return weighted_coords, ai_thoughts
+
+@register_strategy(AI_TENUKI)
+class TenukiStrategy(PickBasedStrategy):
+    """Tenuki strategy - weights moves based on distance from the last move"""
+    
+    def generate_move(self) -> Tuple[Move, str]:
+        # Handle the case where there's no previous move
+        if not (self.cn.move and self.cn.move.coords):
+            self.game.katrain.log(f"[TenukiStrategy] No previous move with valid coordinates found, falling back to WeightedStrategy", OUTPUT_DEBUG)
+            self.game.katrain.log(f"[TenukiStrategy] Using default weighted settings: pick_override=0.9, weaken_fac=1, lower_bound=0.02", OUTPUT_DEBUG)
+            return WeightedStrategy(self.game, {
+                "pick_override": 0.9, 
+                "weaken_fac": 1, 
+                "lower_bound": 0.02
+            }).generate_move()
+        
+        return super().generate_move()
+    
+    def generate_weighted_coords(self, legal_policy_moves, policy_grid, size):
+        """Generate tenuki-based weights"""
+        self.game.katrain.log(f"[TenukiStrategy] Generating tenuki-based weights (far from previous move)", OUTPUT_DEBUG)
+        self.game.katrain.log(f"[TenukiStrategy] Previous move: {self.cn.move.gtp()}", OUTPUT_DEBUG)
+        self.game.katrain.log(f"[TenukiStrategy] Variance setting: {self.settings['stddev']}", OUTPUT_DEBUG)
+        weighted_coords, ai_thoughts = generate_local_tenuki_weights(
+            AI_TENUKI, 
+            self.settings, 
+            policy_grid, 
+            self.cn, 
+            size
+        )
+        self.game.katrain.log(f"[TenukiStrategy] Generated {len(weighted_coords)} weighted coordinates", OUTPUT_DEBUG)
+        if weighted_coords:
+            top5 = heapq.nlargest(5, weighted_coords, key=lambda t: t[0] * t[1])
+            self.game.katrain.log(f"[TenukiStrategy] Top 5 weighted coordinates (by policy*weight):", OUTPUT_DEBUG)
+            for i, (pol, wt, x, y) in enumerate(top5):
+                self.game.katrain.log(f"[TenukiStrategy] #{i+1}: ({x},{y}) - policy={pol:.2%}, weight={wt}, combined={pol*wt:.2%}", OUTPUT_DEBUG)
+        return weighted_coords, ai_thoughts
+
+@register_strategy(AI_HUMAN)
+@register_strategy(AI_PRO)
+class HumanStyleStrategy(AIStrategy):
+    """Strategy that imitates human play at various skill levels"""
+    
+    def __init__(self, game: Game, ai_settings: Dict):
+        super().__init__(game, ai_settings)
+        self.game.katrain.log(f"[HumanStyleStrategy] Initializing HumanStyleStrategy", OUTPUT_DEBUG)
+        self.game.katrain.log(f"[HumanStyleStrategy] AI settings: {ai_settings}", OUTPUT_DEBUG)
+        
+    def generate_move(self) -> Tuple[Move, str]:
+        self.game.katrain.log(f"[HumanStyleStrategy] Starting move generation", OUTPUT_DEBUG)
+        
+        if "human_kyu_rank" in self.settings:
+            human_kyu_rank = round(self.settings["human_kyu_rank"])
+            human_style = "rank" if self.settings["modern_style"] else "preaz"
+
+            if human_kyu_rank <= 0:  # dan ranks
+                rank_text = f"{1-human_kyu_rank}d"
+            else:  # kyu ranks
+                rank_text = f"{human_kyu_rank}k"
+
+            human_profile = f"{human_style}_{rank_text}"
+        else:
+            pro_year = round(self.settings["pro_year"])
+            human_profile = f"proyear_{pro_year}"
+        
+        self.game.katrain.log(f"[HumanStyleStrategy] Human profile string: {human_profile}", OUTPUT_DEBUG)
+        
+        # Define override settings (separate from includePolicy)
+        override_settings = {
+            "humanSLProfile": human_profile,
+            "ignorePreRootHistory": False,
+        }
+        self.game.katrain.log(f"[HumanStyleStrategy] Override settings for engine: {override_settings}", OUTPUT_DEBUG)
+        
+        # Request analysis from engine - note includePolicy is a direct parameter
+        analysis = None
+        
+        def set_analysis(a, partial_result):
+            nonlocal analysis
+            if not partial_result:
+                self.game.katrain.log(f"[HumanStyleStrategy] Full analysis results received", OUTPUT_DEBUG)
+                analysis = a
+                # Log some analysis stats for debugging
+                if a:
+                    self.game.katrain.log(f"[HumanStyleStrategy] Analysis contains humanPolicy: {'humanPolicy' in a}", OUTPUT_DEBUG)
+                    self.game.katrain.log(f"[HumanStyleStrategy] Analysis contains moveInfos: {len(a.get('moveInfos', []))} moves", OUTPUT_DEBUG)
+                    if 'humanPolicy' in a:
+                        policy_sum = sum(a['humanPolicy'])
+                        policy_max = max(a['humanPolicy'])
+                        self.game.katrain.log(f"[HumanStyleStrategy] Human policy sum: {policy_sum}, max: {policy_max}", OUTPUT_DEBUG)
+            else:
+                self.game.katrain.log(f"[HumanStyleStrategy] Received partial analysis results - ignoring", OUTPUT_DEBUG)
+
+        def set_error(a):
+            nonlocal error
+            error = True
+            self.game.katrain.log(f"[HumanStyleStrategy] Error in human analysis query: {a}", OUTPUT_ERROR)
+            self.game.katrain.log(f"[HumanStyleStrategy] Will attempt to fall back to policy move", OUTPUT_DEBUG)
+            
+        error = False
+        self.game.katrain.log(f"[HumanStyleStrategy] Getting engine for player", OUTPUT_DEBUG)
+        engine = self.game.engines[self.cn.player]
+        self.game.katrain.log(f"[HumanStyleStrategy] Using engine for player {self.cn.player}", OUTPUT_DEBUG)
+        
+        self.game.katrain.log(f"[HumanStyleStrategy] Requesting analysis with human profile settings", OUTPUT_DEBUG)
+        engine.request_analysis(
+            self.cn,
+            callback=set_analysis,
+            error_callback=set_error,
+            priority=PRIORITY_EXTRA_AI_QUERY,
+            include_policy=True,
+            extra_settings=override_settings
+        )
+        self.game.katrain.log(f"[HumanStyleStrategy] Analysis request sent, waiting for results", OUTPUT_DEBUG)
+        
+        # Wait for analysis to complete
+        wait_count = 0
+        while not (error or analysis):
+            import time
+            time.sleep(0.01)
+            wait_count += 1
+            if wait_count % 100 == 0:  # Log every 1 second
+                self.game.katrain.log(f"[HumanStyleStrategy] Still waiting for analysis results ({wait_count/100:.1f}s)", OUTPUT_DEBUG)
+            engine.check_alive(exception_if_dead=True)
+        
+        self.game.katrain.log(f"[HumanStyleStrategy] Finished waiting for analysis, error={error}, analysis received={analysis is not None}", OUTPUT_DEBUG)
+            
+        if error or not analysis:
+            self.game.katrain.log(f"[HumanStyleStrategy] Analysis failed or returned empty", OUTPUT_DEBUG)
+            # Fall back to policy
+            policy_move = self.cn.policy_ranking[0][1] if self.cn.policy_ranking else None
+            if policy_move:
+                self.game.katrain.log(f"[HumanStyleStrategy] Falling back to top policy move: {policy_move.gtp()}", OUTPUT_DEBUG)
+                return policy_move, "Falling back to policy move due to error in human analysis."
+            else:
+                self.game.katrain.log(f"[HumanStyleStrategy] No policy moves available for fallback - will return pass", OUTPUT_DEBUG)
+                return Move(None, player=self.cn.next_player), "No valid moves found."
+        
+        # Check if human policy is available
+        self.game.katrain.log(f"[HumanStyleStrategy] Processing analysis results", OUTPUT_DEBUG)
+        if "humanPolicy" not in analysis:
+            error_msg = "humanPolicy not found in analysis—have you downloaded and configured your human model yet?"
+            raise Exception(error_msg)
+        
+        self.game.katrain.log(f"[HumanStyleStrategy] Human policy found in analysis", OUTPUT_DEBUG)
+        board_size = self.game.board_size
+        self.game.katrain.log(f"[HumanStyleStrategy] Board size: {board_size}", OUTPUT_DEBUG)
+        human_policy = analysis["humanPolicy"]
+        self.game.katrain.log(f"[HumanStyleStrategy] Human policy length: {len(human_policy)}", OUTPUT_DEBUG)
+        if len(human_policy) != 362:
+            self.game.katrain.log(f"[HumanStyleStrategy] WARNING: Human policy length {len(human_policy)} != 362", OUTPUT_ERROR)
+        
+        # Create a list of moves with their human policy weights
+        moves = []
+        for x in range(board_size[0]):
+            for y in range(board_size[1]):
+                idx = (board_size[1] - y - 1) * board_size[0] + x
+                if idx < len(human_policy) and human_policy[idx] > 0:
+                    moves.append((Move((x, y), player=self.cn.next_player), human_policy[idx]))
+        
+        self.game.katrain.log(f"[HumanStyleStrategy] Generated {len(moves)} candidate moves from human policy", OUTPUT_DEBUG)
+                    
+        # Add pass move if it has positive probability
+        if len(human_policy) > board_size[0] * board_size[1] and human_policy[-1] > 0:
+            self.game.katrain.log(f"[HumanStyleStrategy] Adding pass move with probability {human_policy[-1]}", OUTPUT_DEBUG)
+            moves.append((Move(None, player=self.cn.next_player), human_policy[-1]))
+            
+        self.game.katrain.log(f"[HumanStyleStrategy] Performing weighted selection from {len(moves)} moves", OUTPUT_DEBUG)
+        top_moves = sorted(moves, key=lambda x: -x[1])
+        self.game.katrain.log(f"[HumanStyleStrategy] Top 5 moves by probability:", OUTPUT_DEBUG)
+        
+        # Create a formatted string of top 5 moves for ai_thoughts
+        top_moves_str = "\n".join([f"#{i+1}: {move.gtp()} - {prob:.1%}" for i, (move, prob) in enumerate(top_moves[:5])])
+
+        self.game.katrain.log(f"[HumanStyleStrategy]\n{top_moves_str}", OUTPUT_DEBUG)
+        
+        selected = weighted_selection_without_replacement(moves, 1)[0]
+        move = selected[0]
+        prob = selected[1]
+        
+        # Find the rank of the selected move
+        selected_rank = next((i+1 for i, (m, _) in enumerate(top_moves) if m.gtp() == move.gtp()), "ERROR: move not found in ranking")
+        
+        self.game.katrain.log(f"[HumanStyleStrategy] Selected move {move.gtp()} with probability {prob:.4f}", OUTPUT_DEBUG)
+        ai_thoughts = f"\n{top_moves_str}\n\nPlayed move {move.gtp()} ({prob:.1%}) as the #{selected_rank} top move."
+        self.game.katrain.log(f"[HumanStyleStrategy] Final decision: {move.gtp()}", OUTPUT_DEBUG)
+        return move, ai_thoughts
+
+def generate_ai_move(game: Game, ai_mode: str, ai_settings: Dict) -> Tuple[Move, GameNode]:
+    """Generate a move using the selected AI strategy"""
+    game.katrain.log(f"Generate AI move called with mode: {ai_mode}", OUTPUT_DEBUG)
+    
+    # Create the appropriate strategy based on mode
+
+    strategy = STRATEGY_REGISTRY[ai_mode](game, ai_settings)
+    
+    # Generate the move
+    game.katrain.log(f"Generating move using {strategy.__class__.__name__}", OUTPUT_DEBUG)
+    move, ai_thoughts = strategy.generate_move()
+    
+    # Play the move and return
+    game.katrain.log(f"Playing move {move.gtp()} and creating game node", OUTPUT_DEBUG)
+    played_node = game.play(move)
+    game.katrain.log(f"AI thoughts: {ai_thoughts}", OUTPUT_DEBUG)
+    played_node.ai_thoughts = ai_thoughts
+    
+    game.katrain.log(f"Move generation complete: {move.gtp()}", OUTPUT_DEBUG)
+    return move, played_node

katrain/core/base_katrain.py

@@ -0,0 +1,189 @@
+import os
+import shutil
+import sys
+
+from kivy import Config
+from kivy.storage.jsonstore import JsonStore
+
+from katrain.core.ai import ai_rank_estimation
+from katrain.core.constants import (
+    PLAYER_HUMAN,
+    PLAYER_AI,
+    PLAYING_NORMAL,
+    PLAYING_TEACHING,
+    OUTPUT_INFO,
+    OUTPUT_ERROR,
+    OUTPUT_DEBUG,
+    AI_DEFAULT,
+    CONFIG_MIN_VERSION,
+    DATA_FOLDER,
+)
+from katrain.core.utils import find_package_resource
+
+
+class Player:
+    def __init__(self, player="B", player_type=PLAYER_HUMAN, player_subtype=PLAYING_NORMAL, periods_used=0):
+        self.player = player
+        self.sgf_rank = None
+        self.calculated_rank = None
+        self.name = ""
+        self.update(player_type, player_subtype)
+        self.periods_used = periods_used
+
+    def update(self, player_type=PLAYER_HUMAN, player_subtype=PLAYING_NORMAL):
+        self.player_type = player_type
+        self.player_subtype = player_subtype
+
+    @property
+    def ai(self):
+        return self.player_type == PLAYER_AI
+
+    @property
+    def human(self):
+        return self.player_type == PLAYER_HUMAN
+
+    @property
+    def being_taught(self):
+        return self.player_type == PLAYER_HUMAN and self.player_subtype == PLAYING_TEACHING
+
+    @property
+    def strategy(self):
+        return self.player_subtype if self.ai else AI_DEFAULT
+
+    def __str__(self):
+        return f"{self.player_type} ({self.player_subtype})"
+
+
+def parse_version(s):
+    parts = [int(p) for p in s.split(".")]
+    while len(parts) < 3:
+        parts.append(0)
+    return parts
+
+
+class KaTrainBase:
+    USER_CONFIG_FILE = os.path.expanduser(os.path.join(DATA_FOLDER, "config.json"))
+    PACKAGE_CONFIG_FILE = "katrain/config.json"
+
+    """Settings, logging, and players functionality, so other classes like bots who need a katrain instance can be used without a GUI"""
+
+    def __init__(self, force_package_config=False, debug_level=None, **kwargs):
+        self.debug_level = debug_level or 0
+        self.game = None
+
+        self.logger = lambda message, level=OUTPUT_INFO: self.log(message, level)
+        self.config_file = self._load_config(force_package_config=force_package_config)
+        self.debug_level = self.config("general/debug_level", OUTPUT_INFO) if debug_level is None else debug_level
+
+        Config.set("kivy", "log_level", "warning")
+        if self.debug_level >= OUTPUT_DEBUG:
+            Config.set("kivy", "log_enable", 1)
+            Config.set("kivy", "log_level", "debug")
+        #        if self.debug_level >= OUTPUT_EXTRA_DEBUG:
+        #            Config.set("kivy", "log_level", "trace")
+        self.players_info = {"B": Player("B"), "W": Player("W")}
+        self.reset_players()
+
+    def log(self, message, level=OUTPUT_INFO):
+        if level == OUTPUT_ERROR:
+            print(f"ERROR: {message}")
+        elif self.debug_level >= level:
+            print(message)
+
+    def _load_config(self, force_package_config):
+        if len(sys.argv) > 1 and sys.argv[1].endswith("config.json"):
+            config_file = os.path.abspath(sys.argv[1])
+            self.log(f"Using command line config file {config_file}", OUTPUT_INFO)
+        else:
+            user_config_file = find_package_resource(self.USER_CONFIG_FILE)
+            package_config_file = find_package_resource(self.PACKAGE_CONFIG_FILE)
+            if force_package_config:
+                config_file = package_config_file
+            else:
+                try:
+                    if not os.path.exists(user_config_file):
+                        self.log("User config does not exist, creating it", OUTPUT_DEBUG)
+                        parent_dir = os.path.split(user_config_file)[0]
+                        self.log(f"Creating parent directory if needed: {parent_dir}", OUTPUT_DEBUG)
+                        os.makedirs(parent_dir, exist_ok=True)
+                        
+                        self.log(f"Copying package config {package_config_file} to user config {user_config_file}", OUTPUT_DEBUG)
+                        shutil.copyfile(package_config_file, user_config_file)
+                        config_file = user_config_file
+                        self.log(f"Copied package config to local file {config_file}", OUTPUT_INFO)
+                    else:  # user file exists
+                        try:
+                            version_str = JsonStore(user_config_file).get("general")["version"]
+                            version = parse_version(version_str)
+                            self.log(f"Parsed version: {version}", OUTPUT_DEBUG)
+                        except Exception as e:  # noqa E722 broken file etc
+                            self.log(f"Failed to read version from user config: {e}", OUTPUT_DEBUG)
+                            version_str = "0.0.0"
+                            version = [0, 0, 0]
+                        min_version = parse_version(CONFIG_MIN_VERSION)
+                        if version < min_version:
+                            backup = f"{user_config_file}.{version_str}.backup"
+                            shutil.copyfile(user_config_file, backup)
+                            shutil.copyfile(package_config_file, user_config_file)
+                            self.log(
+                                f"Copied package config file to {user_config_file} as user file is outdated or broken ({version}<{min_version}). Old version stored as {backup}",
+                                OUTPUT_INFO,
+                            )
+                        config_file = user_config_file
+                        self.log(f"Using user config file {config_file}", OUTPUT_INFO)
+                except Exception as e:
+                    config_file = package_config_file
+                    self.log(
+                        f"Using package config file {config_file} (exception {e} occurred when finding or creating user config)",
+                        OUTPUT_INFO,
+                    )
+        try:
+            self._config_store = JsonStore(config_file, indent=4)
+        except Exception as e:
+            self.log(f"Failed to load config {config_file}: {e}", OUTPUT_ERROR)
+            sys.exit(1)
+        self._config = dict(self._config_store)
+        return config_file
+
+    def save_config(self, key=None):
+        if key is None:
+            for k, v in self._config.items():
+                self._config_store.put(k, **v)
+        else:
+            self._config_store.put(key, **self._config[key])
+
+    def config(self, setting, default=None):
+        try:
+            if "/" in setting:
+                cat, key = setting.split("/")
+                return self._config.get(cat, {}).get(key, default)
+            else:
+                return self._config.get(setting, default)
+        except KeyError:
+            self.log(f"Missing configuration option {setting}", OUTPUT_ERROR)
+
+    def update_player(self, bw, **kwargs):
+        self.players_info[bw].update(**kwargs)
+        self.update_calculated_ranks()
+
+    def update_calculated_ranks(self):
+        for bw, player_info in self.players_info.items():
+            if player_info.player_type == PLAYER_AI:
+                settings = self.config(f"ai/{player_info.strategy}")
+                player_info.calculated_rank = ai_rank_estimation(player_info.player_subtype, settings)
+            else:
+                player_info.calculated_rank = None
+
+    def reset_players(self):
+        self.update_player("B")
+        self.update_player("W")
+        for v in self.players_info.values():
+            v.periods_used = 0
+
+    @property
+    def last_player_info(self) -> Player:
+        return self.players_info[self.game.current_node.player]
+
+    @property
+    def next_player_info(self) -> Player:
+        return self.players_info[self.game.current_node.next_player]

katrain/core/constants.py

@@ -0,0 +1,280 @@
+PROGRAM_NAME = "KaTrain"
+VERSION = "1.17.1"
+HOMEPAGE = "https://github.com/sanderland/katrain"
+CONFIG_MIN_VERSION = "1.17.0"  # keep config files from this version
+ANALYSIS_FORMAT_VERSION = "1.0"
+DATA_FOLDER = "~/.katrain"
+
+
+OUTPUT_ERROR = -1
+OUTPUT_KATAGO_STDERR = -0.5
+OUTPUT_INFO = 0
+OUTPUT_DEBUG = 1
+OUTPUT_EXTRA_DEBUG = 2
+
+KATAGO_EXCEPTION = "KATAGO-INTERNAL-ERROR"
+
+STATUS_ANALYSIS = 1.0  # same priority for analysis/info
+STATUS_INFO = 1.1
+STATUS_TEACHING = 2.0
+STATUS_ERROR = 1000.0
+
+ADDITIONAL_MOVE_ORDER = 999
+
+PRIORITY_GAME_ANALYSIS = -100
+PRIORITY_SWEEP = -10  # sweep is live, but slow, so deprioritize
+PRIORITY_ALTERNATIVES = 100  # extra analysis, live interaction
+PRIORITY_EQUALIZE = 100
+PRIORITY_EXTRA_ANALYSIS = 100
+PRIORITY_DEFAULT = 1000  # new move, high pri
+PRIORITY_EXTRA_AI_QUERY = 10_000
+
+PLAYER_HUMAN, PLAYER_AI = "player:human", "player:ai"
+PLAYER_TYPES = [PLAYER_HUMAN, PLAYER_AI]
+
+PLAYING_NORMAL, PLAYING_TEACHING = "game:normal", "game:teach"
+GAME_TYPES = [PLAYING_NORMAL, PLAYING_TEACHING]
+
+MODE_PLAY, MODE_ANALYZE = "play", "analyze"
+
+AI_DEFAULT = "ai:default"
+AI_HANDICAP = "ai:handicap"
+AI_SCORELOSS = "ai:scoreloss"
+AI_WEIGHTED = "ai:p:weighted"
+AI_JIGO = "ai:jigo"
+AI_ANTIMIRROR = "ai:antimirror"
+AI_POLICY = "ai:policy"
+AI_PICK = "ai:p:pick"
+AI_LOCAL = "ai:p:local"
+AI_TENUKI = "ai:p:tenuki"
+AI_INFLUENCE = "ai:p:influence"
+AI_TERRITORY = "ai:p:territory"
+AI_RANK = "ai:p:rank"
+AI_SIMPLE_OWNERSHIP = "ai:simple"
+AI_SETTLE_STONES = "ai:settle"
+AI_HUMAN = "ai:human"
+AI_PRO = "ai:pro"
+
+AI_CONFIG_DEFAULT = AI_RANK
+
+AI_STRATEGIES_ENGINE = [AI_DEFAULT, AI_HANDICAP, AI_SCORELOSS, AI_SIMPLE_OWNERSHIP, AI_JIGO, AI_ANTIMIRROR]
+AI_STRATEGIES_PICK = [AI_PICK, AI_LOCAL, AI_TENUKI, AI_INFLUENCE, AI_TERRITORY, AI_RANK]
+AI_STRATEGIES_POLICY = [AI_WEIGHTED, AI_POLICY] + AI_STRATEGIES_PICK
+AI_STRATEGIES = AI_STRATEGIES_ENGINE + AI_STRATEGIES_POLICY + [AI_HUMAN, AI_PRO]
+AI_STRATEGIES_RECOMMENDED_ORDER = [
+    AI_DEFAULT,
+    AI_HUMAN,
+    AI_PRO,
+    AI_RANK,
+    AI_HANDICAP,
+    AI_SIMPLE_OWNERSHIP,
+    AI_SCORELOSS,
+    AI_POLICY,
+    AI_WEIGHTED,
+    AI_JIGO,
+    AI_ANTIMIRROR,
+    AI_PICK,
+    AI_LOCAL,
+    AI_TENUKI,
+    AI_TERRITORY,
+    AI_INFLUENCE,
+]
+
+AI_STRENGTH = {  # dan ranks, backup if model is missing. TODO: remove some?
+    AI_DEFAULT: 9,
+    AI_ANTIMIRROR: 9,
+    AI_POLICY: 5,
+    AI_JIGO: float("nan"),
+    AI_SCORELOSS: -4,
+    AI_WEIGHTED: -4,
+    AI_PICK: -7,
+    AI_LOCAL: -4,
+    AI_TENUKI: -7,
+    AI_INFLUENCE: -7,
+    AI_TERRITORY: -7,
+    AI_RANK: float("nan"),
+    AI_SIMPLE_OWNERSHIP: 2,
+    AI_SETTLE_STONES: 2,
+    AI_HUMAN: float("nan"),
+    AI_PRO: float("nan")
+}
+
+AI_OPTION_VALUES = {
+    "kyu_rank": [(k, f"{k}[strength:kyu]") for k in range(15, 0, -1)]
+    + [(k, f"{1-k}[strength:dan]") for k in range(0, -3, -1)],
+    "strength": [0, 0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.4, 0.5, 1],
+    "opening_moves": range(0, 51),
+    "pick_override": [0, 0.5, 0.6, 0.7, 0.8, 0.85, 0.9, 0.95, 0.99, 1],
+    "lower_bound": [(v, f"{v:.2%}") for v in [0, 0.0001, 0.0005, 0.001, 0.005, 0.01, 0.05]],
+    "weaken_fac": [x / 20 for x in range(10, 3 * 20 + 1)],
+    "endgame": [x / 100 for x in range(10, 80, 5)],
+    "pick_frac": [x / 100 for x in range(0, 101, 5)],
+    "pick_n": range(0, 26),
+    "stddev": [x / 2 for x in range(21)],
+    "line_weight": range(0, 11),
+    "threshold": [2, 2.5, 3, 3.5, 4, 4.5],
+    "automatic": "bool",
+    "pda": [(x / 10, f"{'W' if x<0 else 'B'}+{abs(x/10):.1f}") for x in range(-30, 31)],
+    "max_points_lost": [x / 10 for x in range(51)],
+    "settled_weight": [x / 4 for x in range(0, 17)],
+    "opponent_fac": [x / 10 for x in range(-20, 11)],
+    "min_visits": range(1, 10),
+    "attach_penalty": [x / 10 for x in range(-10, 51)],
+    "tenuki_penalty": [x / 10 for x in range(-10, 51)],
+    "human_kyu_rank": [(k, f"{k}[strength:kyu]") for k in range(20, 0, -1)] +
+                  [(k, f"{1-k}[strength:dan]") for k in range(0, -9,-1)],
+    "modern_style": "bool",
+    "pro_year": range(1800,2024),
+}
+
+AI_KEY_PROPERTIES = {
+    "kyu_rank",
+    "strength",
+    "weaken_fac",
+    "pick_frac",
+    "pick_n",
+    "automatic",
+    "max_points_lost",
+    "min_visits",
+}
+
+
+CALIBRATED_RANK_ELO = [
+    (-21.679482223451032, 18),
+    (42.60243194422105, 17),
+    (106.88434611189314, 16),
+    (171.16626027956522, 15),
+    (235.44817444723742, 14),
+    (299.7300886149095, 13),
+    (364.0120027825817, 12),
+    (428.2939169502538, 11),
+    (492.5758311179259, 10),
+    (556.8577452855981, 9),
+    (621.1396594532702, 8),
+    (685.4215736209424, 7),
+    (749.7034877886144, 6),
+    (813.9854019562865, 5),
+    (878.2673161239586, 4),
+    (942.5492302916308, 3),
+    (1006.8311444593029, 2),
+    (1071.113058626975, 1),
+    (1135.3949727946472, 0),
+    (1199.6768869623193, -1),
+    (1263.9588011299913, -2),
+    (1700, -4),
+]
+
+
+AI_WEIGHTED_ELO = [
+    (0.5, 1591.5718897531551),
+    (1.0, 1269.9896556526198),
+    (1.25, 1042.25179764667),
+    (1.5, 848.9410084463602),
+    (1.75, 630.1483212024823),
+    (2, 575.3637091858013),
+    (2.5, 410.9747543504796),
+    (3.0, 219.8667371799533),
+]
+
+AI_SCORELOSS_ELO = [
+    (0.0, 539),
+    (0.05, 625),
+    (0.1, 859),
+    (0.2, 1035),
+    (0.3, 1201),
+    (0.4, 1299),
+    (0.5, 1346),
+    (0.75, 1374),
+    (1.0, 1386),
+]
+
+
+AI_LOCAL_ELO_GRID = [
+    [0.0, 0.05, 0.1, 0.2, 0.3, 0.5, 0.75, 1.0],
+    [0, 5, 10, 15, 25, 50],
+    [
+        [-204.0, 791.0, 1154.0, 1372.0, 1402.0, 1473.0, 1700.0, 1700.0],
+        [174.0, 1094.0, 1191.0, 1384.0, 1435.0, 1522.0, 1700.0, 1700.0],
+        [619.0, 1155.0, 1323.0, 1390.0, 1450.0, 1558.0, 1700.0, 1700.0],
+        [975.0, 1289.0, 1332.0, 1401.0, 1461.0, 1575.0, 1700.0, 1700.0],
+        [1344.0, 1348.0, 1358.0, 1467.0, 1477.0, 1616.0, 1700.0, 1700.0],
+        [1425.0, 1474.0, 1489.0, 1524.0, 1571.0, 1700.0, 1700.0, 1700.0],
+    ],
+]
+AI_TENUKI_ELO_GRID = [
+    [0.0, 0.05, 0.1, 0.2, 0.3, 0.5, 0.75, 1.0],
+    [0, 5, 10, 15, 25, 50],
+    [
+        [47.0, 335.0, 530.0, 678.0, 830.0, 1070.0, 1376.0, 1700.0],
+        [99.0, 469.0, 546.0, 707.0, 855.0, 1090.0, 1413.0, 1700.0],
+        [327.0, 513.0, 605.0, 745.0, 875.0, 1110.0, 1424.0, 1700.0],
+        [429.0, 519.0, 620.0, 754.0, 900.0, 1130.0, 1435.0, 1700.0],
+        [492.0, 607.0, 682.0, 797.0, 1000.0, 1208.0, 1454.0, 1700.0],
+        [778.0, 830.0, 909.0, 949.0, 1169.0, 1461.0, 1483.0, 1700.0],
+    ],
+]
+AI_TERRITORY_ELO_GRID = [
+    [0.0, 0.05, 0.1, 0.2, 0.3, 0.5, 0.75, 1.0],
+    [0, 5, 10, 15, 25, 50],
+    [
+        [34.0, 383.0, 566.0, 748.0, 980.0, 1264.0, 1527.0, 1700.0],
+        [131.0, 450.0, 586.0, 826.0, 995.0, 1280.0, 1537.0, 1700.0],
+        [291.0, 517.0, 627.0, 850.0, 1010.0, 1310.0, 1547.0, 1700.0],
+        [454.0, 526.0, 696.0, 870.0, 1038.0, 1340.0, 1590.0, 1700.0],
+        [491.0, 603.0, 747.0, 890.0, 1050.0, 1390.0, 1635.0, 1700.0],
+        [718.0, 841.0, 1039.0, 1076.0, 1332.0, 1523.0, 1700.0, 1700.0],
+    ],
+]
+AI_INFLUENCE_ELO_GRID = [
+    [0.0, 0.05, 0.1, 0.2, 0.3, 0.5, 0.75, 1.0],
+    [0, 5, 10, 15, 25, 50],
+    [
+        [217.0, 439.0, 572.0, 768.0, 960.0, 1227.0, 1449.0, 1521.0],
+        [302.0, 551.0, 580.0, 800.0, 1028.0, 1257.0, 1470.0, 1529.0],
+        [388.0, 572.0, 619.0, 839.0, 1077.0, 1305.0, 1490.0, 1561.0],
+        [467.0, 591.0, 764.0, 878.0, 1097.0, 1390.0, 1530.0, 1591.0],
+        [539.0, 622.0, 815.0, 953.0, 1120.0, 1420.0, 1560.0, 1601.0],
+        [772.0, 912.0, 958.0, 1145.0, 1318.0, 1511.0, 1577.0, 1623.0],
+    ],
+]
+AI_PICK_ELO_GRID = [
+    [0.0, 0.05, 0.1, 0.2, 0.3, 0.5, 0.75, 1.0],
+    [0, 5, 10, 15, 25, 50],
+    [
+        [-533.0, -515.0, -355.0, 234.0, 650.0, 1147.0, 1546.0, 1700.0],
+        [-531.0, -450.0, -69.0, 347.0, 670.0, 1182.0, 1550.0, 1700.0],
+        [-450.0, -311.0, 140.0, 459.0, 693.0, 1252.0, 1555.0, 1700.0],
+        [-365.0, -82.0, 265.0, 508.0, 864.0, 1301.0, 1619.0, 1700.0],
+        [-113.0, 273.0, 363.0, 641.0, 983.0, 1486.0, 1700.0, 1700.0],
+        [514.0, 670.0, 870.0, 1128.0, 1305.0, 1550.0, 1700.0, 1700.0],
+    ],
+]
+
+
+TOP_MOVE_DELTA_SCORE = "top_move_delta_score"
+TOP_MOVE_SCORE = "top_move_score"
+TOP_MOVE_DELTA_WINRATE = "top_move_delta_winrate"
+TOP_MOVE_WINRATE = "top_move_winrate"
+TOP_MOVE_VISITS = "top_move_visits"
+# TOP_MOVE_UTILITY = "top_move_utility"
+# TOP_MOVE_UTILITYLCB = "top_move_utiltiy_lcb"
+# TOP_MOVE_SCORE_STDDEV = "top_move_score_stddev"
+TOP_MOVE_NOTHING = "top_move_nothing"
+
+
+TOP_MOVE_OPTIONS = [
+    TOP_MOVE_SCORE,
+    TOP_MOVE_DELTA_SCORE,
+    TOP_MOVE_WINRATE,
+    TOP_MOVE_DELTA_WINRATE,
+    TOP_MOVE_VISITS,
+    TOP_MOVE_NOTHING,
+    # TOP_MOVE_SCORE_STDDEV,
+    # TOP_MOVE_UTILITY,
+    # TOP_MOVE_UTILITYLCB
+]
+REPORT_DT = 1
+PONDERING_REPORT_DT = 0.25
+
+SGF_INTERNAL_COMMENTS_MARKER = "\u3164\u200b"
+SGF_SEPARATOR_MARKER = "\u3164\u3164"

katrain/core/contribute_engine.py

@@ -0,0 +1,302 @@
+import json
+import os
+import random
+import shlex
+import shutil
+import signal
+import subprocess
+import threading
+import time
+import traceback
+from collections import defaultdict
+
+from katrain.core.constants import OUTPUT_DEBUG, OUTPUT_ERROR, OUTPUT_INFO, OUTPUT_KATAGO_STDERR, DATA_FOLDER
+from katrain.core.engine import BaseEngine
+from katrain.core.game import BaseGame
+from katrain.core.lang import i18n
+from katrain.core.sgf_parser import Move
+from katrain.core.utils import find_package_resource
+
+
+class KataGoContributeEngine(BaseEngine):
+    """Starts and communicates with the KataGo contribute program"""
+
+    DEFAULT_MAX_GAMES = 8
+
+    SHOW_RESULT_TIME = 5
+    GIVE_UP_AFTER = 120
+
+    def __init__(self, katrain):
+        super().__init__(katrain, katrain.config("contribute"))
+        self.katrain = katrain
+        base_dir = os.path.expanduser("~/.katrain/katago_contribute")
+        self.katago_process = None
+        self.stdout_thread = None
+        self.stderr_thread = None
+        self.shell = False
+        self.active_games = {}
+        self.finished_games = set()
+        self.showing_game = None
+        self.last_advance = 0
+        self.move_count = 0
+        self.uploaded_games_count = 0
+        self.last_move_for_game = defaultdict(int)
+        self.visits_count = 0
+        self.start_time = 0
+        self.server_error = None
+        self.paused = False
+        self.save_sgf = self.config.get("savesgf", False)
+        self.save_path = self.config.get("savepath", "./dist_sgf/")
+        self.move_speed = self.config.get("movespeed", 2.0)
+
+        exe = self.get_engine_path(self.config.get("katago"))
+        cacert_path = os.path.join(os.path.split(exe)[0], "cacert.pem")
+        if not os.path.isfile(cacert_path):
+            try:
+                shutil.copyfile(find_package_resource("katrain/KataGo/cacert.pem"), cacert_path)
+            except Exception as e:
+                self.katrain.log(
+                    f"Could not copy cacert file ({e}), please add it manually to your katago.exe directory",
+                    OUTPUT_ERROR,
+                )
+        cfg = find_package_resource(self.config.get("config"))
+
+        settings_dict = {
+            "username": self.config.get("username"),
+            "password": self.config.get("password"),
+            "maxSimultaneousGames": self.config.get("maxgames") or self.DEFAULT_MAX_GAMES,
+            "includeOwnership": self.config.get("ownership") or False,
+            "logGamesAsJson": True,
+            "homeDataDir": os.path.expanduser(DATA_FOLDER),
+        }
+        self.max_buffer_games = 2 * settings_dict["maxSimultaneousGames"]
+        settings = {f"{k}={v}" for k, v in settings_dict.items()}
+        self.command = shlex.split(
+            f'"{exe}" contribute -config "{cfg}" -base-dir "{base_dir}" -override-config {shlex.quote(",".join(settings))}'
+        )
+        self.start()
+
+    @staticmethod
+    def game_ended(game):
+        cn = game.current_node
+        if cn.is_pass and cn.analysis_exists:
+            moves = cn.candidate_moves
+            if moves and moves[0]["move"] == "pass":
+                game.play(Move(None, player=game.current_node.next_player))  # play pass
+        return game.end_result
+
+    def advance_showing_game(self):
+        current_game = self.active_games.get(self.showing_game)
+        if current_game:
+            end_result = self.game_ended(current_game)
+            if end_result is not None:
+                self.finished_games.add(self.showing_game)
+                if time.time() - self.last_advance > self.SHOW_RESULT_TIME:
+                    del self.active_games[self.showing_game]
+                    if self.save_sgf:
+                        filename = os.path.join(self.save_path, f"{self.showing_game}.sgf")
+                        self.katrain.log(current_game.write_sgf(filename, self.katrain.config("trainer")), OUTPUT_INFO)
+
+                    self.katrain.log(f"Game {self.showing_game} finished, finding a new one", OUTPUT_INFO)
+                    self.showing_game = None
+            elif time.time() - self.last_advance > self.move_speed or len(self.active_games) > self.max_buffer_games:
+                if current_game.current_node.children:
+                    current_game.redo(1)
+                    self.last_advance = time.time()
+                    self.katrain("update-state")
+                elif time.time() - self.last_advance > self.GIVE_UP_AFTER:
+                    self.katrain.log(
+                        f"Giving up on game {self.showing_game} which appears stuck, finding a new one", OUTPUT_INFO
+                    )
+                    self.showing_game = None
+        else:
+            if self.active_games:
+                self.showing_game = None
+                best_count = -1
+                for game_id, game in self.active_games.items():  # find game with most moves left to show
+                    count = 0
+                    node = game.current_node
+                    while node.children:
+                        node = node.children[0]
+                        count += 1
+                    if count > best_count:
+                        best_count = count
+                        self.showing_game = game_id
+                self.last_advance = time.time()
+                self.katrain.log(f"Showing game {self.showing_game}, {best_count} moves left to show.", OUTPUT_INFO)
+
+                self.katrain.game = self.active_games[self.showing_game]
+                self.katrain("update-state", redraw_board=True)
+
+    def status(self):
+        return f"Contributing to distributed training\nGames: {self.uploaded_games_count} uploaded, {len(self.active_games)} in buffer, {len(self.finished_games)} shown\n{self.move_count} moves played ({60*self.move_count/(time.time()-self.start_time):.1f}/min, {self.visits_count / (time.time() - self.start_time):.1f} visits/s)\n"
+
+    def is_idle(self):
+        return False
+
+    def queries_remaining(self):
+        return 1
+
+    def start(self):
+        try:
+            self.katrain.log(f"Starting Distributed KataGo with {self.command}", OUTPUT_INFO)
+            startupinfo = None
+            if hasattr(subprocess, "STARTUPINFO"):
+                startupinfo = subprocess.STARTUPINFO()
+                startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW  # stop command box popups on win/pyinstaller
+            self.katago_process = subprocess.Popen(
+                self.command,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                stdin=subprocess.PIPE,
+                startupinfo=startupinfo,
+                shell=self.shell,
+            )
+        except (FileNotFoundError, PermissionError, OSError) as e:
+            self.katrain.log(
+                i18n._("Starting Kata failed").format(command=self.command, error=e),
+                OUTPUT_ERROR,
+            )
+            return  # don't start
+        self.paused = False
+        self.stdout_thread = threading.Thread(target=self._read_stdout_thread, daemon=True)
+        self.stderr_thread = threading.Thread(target=self._read_stderr_thread, daemon=True)
+        self.stdout_thread.start()
+        self.stderr_thread.start()
+
+    def check_alive(self, os_error="", maybe_open_help=False):
+        ok = self.katago_process and self.katago_process.poll() is None
+        if not ok:
+            if self.katago_process:
+                code = self.katago_process and self.katago_process.poll()
+                if code == 3221225781:
+                    died_msg = i18n._("Engine missing DLL")
+                else:
+                    os_error += f"status {code}"
+                    died_msg = i18n._("Engine died unexpectedly").format(error=os_error)
+                if code != 1 and not self.server_error:  # deliberate exit, already showed message?
+                    self.katrain.log(died_msg, OUTPUT_ERROR)
+                self.katago_process = None
+        return ok
+
+    def shutdown(self, finish=False):
+        process = self.katago_process
+        if process:
+            self.katago_process.stdin.write(b"forcequit\n")
+            self.katago_process.stdin.flush()
+            self.katago_process = None
+            process.terminate()
+        if finish is not None:
+            for t in [self.stderr_thread, self.stdout_thread]:
+                if t:
+                    t.join()
+
+    def graceful_shutdown(self):
+        """respond to esc"""
+        if self.katago_process:
+            self.katago_process.stdin.write(b"quit\n")
+            self.katago_process.stdin.flush()
+            self.katrain.log("Finishing games in progress and stopping contribution", OUTPUT_KATAGO_STDERR)
+
+    def pause(self):
+        """respond to pause"""
+        if self.katago_process:
+            if not self.paused:
+                self.katago_process.stdin.write(b"pause\n")
+                self.katago_process.stdin.flush()
+                self.katrain.log("Pausing contribution", OUTPUT_KATAGO_STDERR)
+            else:
+                self.katago_process.stdin.write(b"resume\n")
+                self.katago_process.stdin.flush()
+                self.katrain.log("Resuming contribution", OUTPUT_KATAGO_STDERR)
+            self.paused = not self.paused
+
+    def _read_stderr_thread(self):
+        while self.katago_process is not None:
+            try:
+                line = self.katago_process.stderr.readline()
+                if line:
+                    try:
+                        message = line.decode(errors="ignore").strip()
+                        if any(
+                            s in message
+                            for s in ["not status code 200 OK", "Server returned error", "Uncaught exception:"]
+                        ):
+                            message = message.replace("what():", "").replace("Uncaught exception:", "").strip()
+                            self.server_error = message  # don't be surprised by engine dying
+                            self.katrain.log(message, OUTPUT_ERROR)
+                            return
+                        else:
+                            self.katrain.log(message, OUTPUT_KATAGO_STDERR)
+                    except Exception as e:
+                        print("ERROR in processing KataGo stderr:", line, "Exception", e)
+                elif self.katago_process and not self.check_alive():
+                    return
+            except Exception as e:
+                self.katrain.log(f"Exception in reading stdout {e}", OUTPUT_DEBUG)
+                return
+
+    def _read_stdout_thread(self):
+        while self.katago_process is not None:
+            try:
+                line = self.katago_process.stdout.readline()
+                if line:
+                    line = line.decode(errors="ignore").strip()
+                    if line.startswith("{"):
+                        try:
+                            analysis = json.loads(line)
+                            if "gameId" in analysis:
+                                game_id = analysis["gameId"]
+                                if game_id in self.finished_games:
+                                    continue
+                                current_game = self.active_games.get(game_id)
+                                new_game = current_game is None
+                                if new_game:
+                                    board_size = [analysis["boardXSize"], analysis["boardYSize"]]
+                                    placements = {
+                                        f"A{bw}": [
+                                            Move.from_gtp(move, pl).sgf(board_size)
+                                            for pl, move in analysis["initialStones"]
+                                            if pl == bw
+                                        ]
+                                        for bw in "BW"
+                                    }
+                                    game_properties = {k: v for k, v in placements.items() if v}
+                                    game_properties["SZ"] = f"{board_size[0]}:{board_size[1]}"
+                                    game_properties["KM"] = analysis["rules"]["komi"]
+                                    game_properties["RU"] = json.dumps(analysis["rules"])
+                                    game_properties["PB"] = analysis["blackPlayer"]
+                                    game_properties["PW"] = analysis["whitePlayer"]
+                                    current_game = BaseGame(
+                                        self.katrain, game_properties=game_properties, bypass_config=True
+                                    )
+                                    self.active_games[game_id] = current_game
+                                last_node = current_game.sync_branch(
+                                    [Move.from_gtp(coord, pl) for pl, coord in analysis["moves"]]
+                                )
+                                last_node.set_analysis(analysis)
+                                if new_game:
+                                    current_game.set_current_node(last_node)
+                                self.start_time = self.start_time or time.time() - 1
+                                self.move_count += 1
+                                self.visits_count += analysis["rootInfo"]["visits"]
+                                last_move = self.last_move_for_game[game_id]
+                                self.last_move_for_game[game_id] = time.time()
+                                dt = self.last_move_for_game[game_id] - last_move if last_move else 0
+                                self.katrain.log(
+                                    f"[{time.time()-self.start_time:.1f}] Game {game_id} Move {analysis['turnNumber']}: {' '.join(analysis['move'])} Visits {analysis['rootInfo']['visits']} Time {dt:.1f}s\t Moves/min {60*self.move_count/(time.time()-self.start_time):.1f} Visits/s {self.visits_count/(time.time()-self.start_time):.1f}",
+                                    OUTPUT_DEBUG,
+                                )
+                                self.katrain("update-state")
+                        except Exception as e:
+                            traceback.print_exc()
+                            self.katrain.log(f"Exception {e} in parsing or processing JSON: {line}", OUTPUT_ERROR)
+                    elif "uploaded sgf" in line:
+                        self.uploaded_games_count += 1
+                    else:
+                        self.katrain.log(line, OUTPUT_KATAGO_STDERR)
+                elif self.katago_process and not self.check_alive():  # stderr will do this
+                    return
+            except Exception as e:
+                self.katrain.log(f"Exception in reading stdout {e}", OUTPUT_DEBUG)
+                return

katrain/core/engine.py

@@ -0,0 +1,471 @@
+import copy
+import json
+import os
+import platform
+import queue
+import shlex
+import subprocess
+import threading
+import time
+import traceback
+from typing import Callable, Dict, List, Optional
+
+from kivy.utils import platform as kivy_platform
+
+from katrain.core.constants import (
+    OUTPUT_DEBUG,
+    OUTPUT_ERROR,
+    OUTPUT_EXTRA_DEBUG,
+    OUTPUT_KATAGO_STDERR,
+    DATA_FOLDER,
+    KATAGO_EXCEPTION,
+    PONDERING_REPORT_DT,
+)
+from katrain.core.game_node import GameNode
+from katrain.core.lang import i18n
+from katrain.core.sgf_parser import Move
+from katrain.core.utils import find_package_resource, json_truncate_arrays
+
+
+class BaseEngine:  # some common elements between analysis and contribute engine
+
+    RULESETS_ABBR = [
+        ("jp", "japanese"),
+        ("cn", "chinese"),
+        ("ko", "korean"),
+        ("aga", "aga"),
+        ("tt", "tromp-taylor"),
+        ("nz", "new zealand"),
+        ("stone_scoring", "stone_scoring"),
+    ]
+    RULESETS = {fromkey: name for abbr, name in RULESETS_ABBR for fromkey in [abbr, name]}
+
+    def __init__(self, katrain, config):
+        self.katrain = katrain
+        self.config = config
+
+    @staticmethod
+    def get_rules(ruleset):
+        if ruleset.strip().startswith("{"):
+            try:
+                ruleset = json.loads(ruleset)
+            except json.JSONDecodeError:
+                pass
+        if isinstance(ruleset, dict):
+            return ruleset
+        return KataGoEngine.RULESETS.get(str(ruleset).lower(), "japanese")
+
+    def advance_showing_game(self):
+        pass  # avoid transitional error
+
+    def status(self):
+        return ""  # avoid transitional error
+
+    def get_engine_path(self, exe):
+        if not exe:
+            if kivy_platform == "win":
+                exe = "katrain/KataGo/katago.exe"
+            elif kivy_platform == "linux":
+                exe = "katrain/KataGo/katago"
+            else:
+                exe = find_package_resource("katrain/KataGo/katago-osx")  # github actions built
+                if not os.path.isfile(exe) or "arm64" in platform.version().lower():
+                    exe = "katago"  # e.g. MacOS after brewing
+        if exe.startswith("katrain"):
+            exe = find_package_resource(exe)
+        exepath, exename = os.path.split(exe)
+
+        if exepath and not os.path.isfile(exe):
+            self.on_error(i18n._("Kata exe not found").format(exe=exe), "KATAGO-EXE")
+            return None
+        elif not exepath:
+            paths = os.getenv("PATH", ".").split(os.pathsep) + ["/opt/homebrew/bin/"]
+            exe_with_paths = [os.path.join(path, exe) for path in paths if os.path.isfile(os.path.join(path, exe))]
+            if not exe_with_paths:
+                self.on_error(i18n._("Kata exe not found in path").format(exe=exe), "KATAGO-EXE")
+                return None
+            exe = exe_with_paths[0]
+        return exe
+
+    def on_error(self, message, code, allow_popup):
+        print("ERROR", message, code)
+
+
+class KataGoEngine(BaseEngine):
+    """Starts and communicates with the KataGO analysis engine"""
+
+    PONDER_KEY = "_kt_continuous"
+
+    def __init__(self, katrain, config):
+        super().__init__(katrain, config)
+
+        self.allow_recovery = self.config.get("allow_recovery", True)  # if false, don't give popups
+        self.queries = {}  # outstanding query id -> start time and callback
+        self.ponder_query = None
+        self.query_counter = 0
+        self.katago_process = None
+        self.base_priority = 0
+        self.override_settings = {"reportAnalysisWinratesAs": "BLACK"}  # force these settings
+        self.analysis_thread = None
+        self.stderr_thread = None
+        self.write_stdin_thread = None
+        self.shell = False
+        self.write_queue = queue.Queue()
+        self.thread_lock = threading.Lock()
+        if config.get("altcommand", ""):
+            self.command = config["altcommand"]
+            self.shell = True
+        else:    
+            model = find_package_resource(config["model"])
+            cfg = find_package_resource(config["config"])
+            exe = self.get_engine_path(config.get("katago", "").strip())
+            
+            if not exe:
+                return
+                
+            # Add human model to command if provided
+            if config.get("humanlike_model", ""):
+                human_model_path = find_package_resource(config.get("humanlike_model",""))
+                if os.path.isfile(human_model_path):
+                    self.command = shlex.split(
+                        f'"{exe}" analysis -model "{model}" -human-model "{human_model_path}" -config "{cfg}" -override-config "homeDataDir={os.path.expanduser(DATA_FOLDER)}"'
+                    )
+                else:
+                    self.katrain.log(f"Human model not found at {human_model_path}", -1)
+                    # Fall back to regular command without human model
+                    self.command = shlex.split(
+                        f'"{exe}" analysis -model "{model}" -config "{cfg}" -override-config "homeDataDir={os.path.expanduser(DATA_FOLDER)}"'
+                    )
+            else:
+                # Regular command without human model
+                self.command = shlex.split(
+                    f'"{exe}" analysis -model "{model}" -config "{cfg}" -override-config "homeDataDir={os.path.expanduser(DATA_FOLDER)}"'
+                )
+        self.start()
+
+    def on_error(self, message, code=None, allow_popup=True):
+        self.katrain.log(message, OUTPUT_ERROR)
+        if self.allow_recovery and allow_popup:
+            self.katrain("engine_recovery_popup", message, code)
+
+    def start(self):
+        with self.thread_lock:
+            self.write_queue = queue.Queue()
+            try:
+                self.katrain.log(f"Starting KataGo with {self.command}", OUTPUT_DEBUG)
+                startupinfo = None
+                if hasattr(subprocess, "STARTUPINFO"):
+                    startupinfo = subprocess.STARTUPINFO()
+                    startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW  # stop command box popups on win/pyinstaller
+                self.katago_process = subprocess.Popen(
+                    self.command,
+                    startupinfo=startupinfo,
+                    stdin=subprocess.PIPE,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    shell=self.shell,
+                )
+            except (FileNotFoundError, PermissionError, OSError) as e:
+                self.on_error(i18n._("Starting Kata failed").format(command=self.command, error=e), code="c")
+                return  # don't start
+            self.analysis_thread = threading.Thread(target=self._analysis_read_thread, daemon=True)
+            self.stderr_thread = threading.Thread(target=self._read_stderr_thread, daemon=True)
+            self.write_stdin_thread = threading.Thread(target=self._write_stdin_thread, daemon=True)
+            self.analysis_thread.start()
+            self.stderr_thread.start()
+            self.write_stdin_thread.start()
+
+    def on_new_game(self):
+        self.base_priority += 1
+        if not self.is_idle():
+            with self.thread_lock:
+                self.write_queue = queue.Queue()
+                self.terminate_queries(only_for_node=None, lock=False)
+                self.ponder_query = None
+                self.queries = {}
+
+    def terminate_queries(self, only_for_node=None, lock=True):
+        if lock:
+            with self.thread_lock:
+                return self.terminate_queries(only_for_node=only_for_node, lock=False)
+        for query_id, (_, _, _, _, node) in list(self.queries.items()):
+            if only_for_node is None or only_for_node is node:
+                self.terminate_query(query_id)
+
+    def stop_pondering(self):
+        pq = self.ponder_query
+        if pq:
+            self.terminate_query(pq["id"], ignore_further_results=False)
+        self.ponder_query = None
+
+    def terminate_query(self, query_id, ignore_further_results=True):
+        self.katrain.log(f"Terminating query {query_id}", OUTPUT_DEBUG)
+
+        if query_id is not None:
+            self.send_query({"action": "terminate", "terminateId": query_id}, None, None)
+            if ignore_further_results:
+                self.queries.pop(query_id, None)
+
+    def restart(self):
+        self.queries = {}
+        self.shutdown(finish=False)
+        self.start()
+
+    def check_alive(self, os_error="", exception_if_dead=False, maybe_open_recovery=False):
+        ok = self.katago_process and self.katago_process.poll() is None
+        if not ok and exception_if_dead:
+            if self.katago_process:
+                code = self.katago_process and self.katago_process.poll()
+                if code == 3221225781:
+                    died_msg = i18n._("Engine missing DLL")
+                else:
+                    died_msg = i18n._("Engine died unexpectedly").format(error=f"{os_error} status {code}")
+                if code != 1:  # deliberate exit
+                    self.on_error(died_msg, code, allow_popup=maybe_open_recovery)
+                self.katago_process = None  # return from threads
+            else:
+                self.katrain.log(i18n._("Engine died unexpectedly").format(error=os_error), OUTPUT_DEBUG)
+        return ok
+
+    def wait_to_finish(self):
+        while self.queries and self.katago_process and self.katago_process.poll() is None:
+            time.sleep(0.1)
+
+    def shutdown(self, finish=False):
+        process = self.katago_process
+        if finish and process:
+            self.wait_to_finish()
+        if process:
+            self.katago_process = None
+            self.katrain.log("Terminating KataGo process", OUTPUT_DEBUG)
+            process.terminate()
+            self.katrain.log("Terminated KataGo process", OUTPUT_DEBUG)
+        if finish is not None:  # don't care if exiting app
+            for t in [self.write_stdin_thread, self.analysis_thread, self.stderr_thread]:
+                if t:
+                    t.join()
+
+    def is_idle(self):
+        return not self.queries and self.write_queue.empty()
+
+    def queries_remaining(self):
+        return len(self.queries) + int(not self.write_queue.empty())
+
+    def _read_stderr_thread(self):
+        while self.katago_process is not None:
+            try:
+                line = self.katago_process.stderr.readline()
+                if line:
+                    if b"Uncaught exception" in line or b"what()" in line:  # linux=what
+                        msg = f"KataGo Engine Failed: {line.decode(errors='ignore')[9:].strip()}"
+                        self.on_error(msg, KATAGO_EXCEPTION)
+                        return
+                    try:
+                        self.katrain.log(line.decode(errors="ignore").strip(), OUTPUT_KATAGO_STDERR)
+                    except Exception as e:
+                        print("ERROR in processing KataGo stderr:", line, "Exception", e)
+                elif not self.check_alive(exception_if_dead=True):
+                    return
+            except Exception as e:
+                self.katrain.log(f"Exception in reading stderr: {e}", OUTPUT_DEBUG)
+                return
+
+    def _analysis_read_thread(self):
+        while self.katago_process is not None:
+            try:
+                line = self.katago_process.stdout.readline().strip()
+                if self.katago_process and not line:
+                    if not self.check_alive(exception_if_dead=True, maybe_open_recovery=True):
+                        return
+            except OSError as e:
+                self.check_alive(os_error=str(e), exception_if_dead=True, maybe_open_recovery=True)
+                return
+
+            if b"Uncaught exception" in line:
+                msg = f"KataGo Engine Failed: {line.decode(errors='ignore')}"
+                self.on_error(msg, KATAGO_EXCEPTION)
+                return
+            if not line:
+                continue
+            try:
+                analysis = json.loads(line)
+                if "id" not in analysis:
+                    self.katrain.log(f"Error without ID {analysis} received from KataGo", OUTPUT_ERROR)
+                    continue
+                query_id = analysis["id"]
+                if query_id not in self.queries:
+                    if analysis.get("action") != "terminate":
+                        self.katrain.log(
+                            f"Query result {query_id} discarded -- recent new game or node reset?", OUTPUT_DEBUG
+                        )
+                    continue
+                callback, error_callback, start_time, next_move, _ = self.queries[query_id]
+                if "error" in analysis:
+                    del self.queries[query_id]
+                    if error_callback:
+                        error_callback(analysis)
+                    elif not (next_move and "Illegal move" in analysis["error"]):  # sweep
+                        self.katrain.log(f"{analysis} received from KataGo", OUTPUT_ERROR)
+                elif "warning" in analysis:
+                    self.katrain.log(f"{analysis} received from KataGo", OUTPUT_DEBUG)
+                elif "terminateId" in analysis:
+                    self.katrain.log(f"{analysis} received from KataGo", OUTPUT_DEBUG)
+                else:
+                    partial_result = analysis.get("isDuringSearch", False)
+                    if not partial_result:
+                        del self.queries[query_id]
+                    time_taken = time.time() - start_time
+                    results_exist = not analysis.get("noResults", False)
+                    self.katrain.log(
+                        f"[{time_taken:.1f}][{query_id}][{'....' if partial_result else 'done'}] KataGo analysis received: {len(analysis.get('moveInfos',[]))} candidate moves, {analysis['rootInfo']['visits'] if results_exist else 'n/a'} visits",
+                        OUTPUT_DEBUG,
+                    )
+                    self.katrain.log(json_truncate_arrays(analysis), OUTPUT_EXTRA_DEBUG)
+                    try:
+                        if callback and results_exist:
+                            callback(analysis, partial_result)
+                    except Exception as e:
+                        self.katrain.log(f"Error in engine callback for query {query_id}: {e}", OUTPUT_ERROR)
+                        traceback.print_exc()
+                if getattr(self.katrain, "update_state", None):  # easier mocking etc
+                    self.katrain.update_state()
+            except Exception as e:
+                self.katrain.log(f"Unexpected exception {e} while processing KataGo output {line}", OUTPUT_ERROR)
+                traceback.print_exc()
+
+    def _write_stdin_thread(self):  # flush only in a thread since it returns only when the other program reads
+        while self.katago_process is not None:
+            try:
+                query, callback, error_callback, next_move, node = self.write_queue.get(block=True, timeout=0.1)
+            except queue.Empty:
+                continue
+            with self.thread_lock:
+                if "id" not in query:
+                    self.query_counter += 1
+                    query["id"] = f"QUERY:{str(self.query_counter)}"
+
+                ponder = query.pop(self.PONDER_KEY, False)
+                if ponder:  # handle pondering in here to be in lock and such
+                    pq = self.ponder_query or {}
+                    # basically we handle pondering by just asking for these queries a lot and ignoring duplicates
+                    # when a different ponder query comes in, e.g. due to selecting a roi or different node, switch
+                    differences = {
+                        k: (pq.get(k), query.get(k))
+                        for k in (query.keys() | pq.keys()) - {"id", "maxVisits", "reportDuringSearchEvery"}
+                        if pq.get(k) != query.get(k)
+                    }
+                    if differences:
+                        self.stop_pondering()
+                        query["maxVisits"] = 10_000_000
+                        query["reportDuringSearchEvery"] = PONDERING_REPORT_DT
+                        self.ponder_query = query
+                    else:
+                        continue
+
+                terminate = query.get("action") == "terminate"
+                if not terminate:
+                    self.queries[query["id"]] = (callback, error_callback, time.time(), next_move, node)
+                tag = "ponder " if ponder else ("terminate " if terminate else "")
+                self.katrain.log(f"Sending {tag}query {query['id']}: {json.dumps(query)}", OUTPUT_DEBUG)
+                try:
+                    self.katago_process.stdin.write((json.dumps(query) + "\n").encode())
+                    self.katago_process.stdin.flush()
+                except OSError as e:
+                    self.katrain.log(f"Exception in writing to katago: {e}", OUTPUT_DEBUG)
+                    return  # some other thread will take care of this
+
+    def send_query(self, query, callback, error_callback, next_move=None, node=None):
+        self.write_queue.put((query, callback, error_callback, next_move, node))
+
+    def request_analysis(
+        self,
+        analysis_node: GameNode,
+        callback: Callable,
+        error_callback: Optional[Callable] = None,
+        visits: int = None,
+        analyze_fast: bool = False,
+        time_limit=True,
+        find_alternatives: bool = False,
+        region_of_interest: Optional[List] = None,
+        priority: int = 0,
+        ponder=False,  # infinite visits, cancellable
+        ownership: Optional[bool] = None,
+        next_move: Optional[GameNode] = None,
+        extra_settings: Optional[Dict] = None,
+        include_policy=True,
+        report_every: Optional[float] = None,
+    ):
+        nodes = analysis_node.nodes_from_root
+        moves = [m for node in nodes for m in node.moves]
+        initial_stones = [m for node in nodes for m in node.placements]
+        clear_placements = [m for node in nodes for m in node.clear_placements]
+        if clear_placements:  # TODO: support these
+            self.katrain.log(f"Not analyzing node {analysis_node} as there are AE commands in the path", OUTPUT_DEBUG)
+            return
+
+        if next_move:
+            moves.append(next_move)
+        if ownership is None:
+            ownership = self.config["_enable_ownership"] and not next_move
+
+        if visits is None:
+            visits = self.config["max_visits"]
+            if analyze_fast and self.config.get("fast_visits"):
+                visits = self.config["fast_visits"]
+
+        size_x, size_y = analysis_node.board_size
+
+        if find_alternatives:
+            avoid = [
+                {
+                    "moves": list(analysis_node.analysis["moves"].keys()),
+                    "player": analysis_node.next_player,
+                    "untilDepth": 1,
+                }
+            ]
+        elif region_of_interest:
+            xmin, xmax, ymin, ymax = region_of_interest
+            avoid = [
+                {
+                    "moves": [
+                        Move((x, y)).gtp()
+                        for x in range(0, size_x)
+                        for y in range(0, size_y)
+                        if x < xmin or x > xmax or y < ymin or y > ymax
+                    ],
+                    "player": player,
+                    "untilDepth": 1,  # tried a large number here, or 2, but this seems more natural
+                }
+                for player in "BW"
+            ]
+        else:
+            avoid = []
+
+        settings = copy.copy(self.override_settings)
+        settings["wideRootNoise"] = self.config["wide_root_noise"]
+        if time_limit:
+            settings["maxTime"] = self.config["max_time"]
+
+        query = {
+            "rules": self.get_rules(analysis_node.ruleset),
+            "priority": self.base_priority + priority,
+            "analyzeTurns": [len(moves)],
+            "maxVisits": visits,
+            "komi": analysis_node.komi,
+            "boardXSize": size_x,
+            "boardYSize": size_y,
+            "includeOwnership": ownership and not next_move,
+            "includeMovesOwnership": ownership and not next_move,
+            "includePolicy": include_policy,
+            "initialStones": [[m.player, m.gtp()] for m in initial_stones],
+            "initialPlayer": analysis_node.initial_player,
+            "moves": [[m.player, m.gtp()] for m in moves],
+            "overrideSettings": {**settings, **(extra_settings or {})},
+            self.PONDER_KEY: ponder,
+        }
+        if report_every is not None:
+            query["reportDuringSearchEvery"] = report_every
+        if avoid:
+            query["avoidMoves"] = avoid
+        self.send_query(query, callback, error_callback, next_move, analysis_node)
+        analysis_node.analysis_visits_requested = max(analysis_node.analysis_visits_requested, visits)

katrain/core/game.py

@@ -0,0 +1,803 @@
+import copy
+import math
+import os
+import re
+import threading
+from datetime import datetime
+from typing import Dict, List, Optional, Union
+
+from kivy.clock import Clock
+
+from katrain.core.constants import (
+    OUTPUT_DEBUG,
+    OUTPUT_EXTRA_DEBUG,
+    OUTPUT_INFO,
+    PLAYER_AI,
+    PLAYER_HUMAN,
+    PROGRAM_NAME,
+    SGF_INTERNAL_COMMENTS_MARKER,
+    STATUS_ANALYSIS,
+    STATUS_ERROR,
+    STATUS_INFO,
+    STATUS_TEACHING,
+    PRIORITY_GAME_ANALYSIS,
+    PRIORITY_EXTRA_ANALYSIS,
+    PRIORITY_SWEEP,
+    PRIORITY_ALTERNATIVES,
+    PRIORITY_EQUALIZE,
+    PRIORITY_DEFAULT,
+)
+from katrain.core.engine import KataGoEngine
+from katrain.core.game_node import GameNode
+from katrain.core.lang import i18n, rank_label
+from katrain.core.sgf_parser import SGF, Move
+from katrain.core.utils import var_to_grid, weighted_selection_without_replacement
+
+
+class IllegalMoveException(Exception):
+    pass
+
+
+class KaTrainSGF(SGF):
+    _NODE_CLASS = GameNode
+
+
+class BaseGame:
+    """Represents a game of go, including an implementation of capture rules."""
+
+    DEFAULT_PROPERTIES = {"GM": 1, "FF": 4}
+
+    def __init__(
+        self,
+        katrain,
+        move_tree: GameNode = None,
+        game_properties: Optional[Dict] = None,
+        sgf_filename=None,
+        bypass_config=False,  # TODO: refactor?
+    ):
+        self.katrain = katrain
+        self._lock = threading.Lock()
+        self.game_id = datetime.strftime(datetime.now(), "%Y-%m-%d %H %M %S")
+        self.sgf_filename = sgf_filename
+
+        self.insert_mode = False
+        self.external_game = False  # not generated by katrain at some point
+
+        if move_tree:
+            self.root = move_tree
+            self.external_game = PROGRAM_NAME not in self.root.get_property("AP", "")
+            handicap = int(self.root.handicap)
+            num_starting_moves_black = 0
+            node = self.root
+            while node.children:
+                node = node.children[0]
+                if node.player == "B":
+                    num_starting_moves_black += 1
+                else:
+                    break
+
+            if (
+                handicap >= 2
+                and not self.root.placements
+                and not (num_starting_moves_black == handicap)
+                and not (self.root.children and self.root.children[0].placements)
+            ):  # not really according to sgf, and not sure if still needed, last clause for fox
+                self.root.place_handicap_stones(handicap)
+        else:
+            default_properties = {**Game.DEFAULT_PROPERTIES, "DT": self.game_id}
+            if not bypass_config:
+                default_properties.update(
+                    {
+                        "SZ": katrain.config("game/size"),
+                        "KM": katrain.config("game/komi"),
+                        "RU": katrain.config("game/rules"),
+                    }
+                )
+            self.root = GameNode(
+                properties={
+                    **default_properties,
+                    **(game_properties or {}),
+                }
+            )
+            handicap = katrain.config("game/handicap")
+            if not bypass_config and handicap:
+                self.root.place_handicap_stones(handicap)
+
+        if not self.root.get_property("RU"):  # if rules missing in sgf, inherit current
+            self.root.set_property("RU", katrain.config("game/rules"))
+
+        self.set_current_node(self.root)
+        self.main_time_used = 0
+
+        # restore shortcuts
+        shortcut_id_to_node = {node.get_property("KTSID", None): node for node in self.root.nodes_in_tree}
+        for node in self.root.nodes_in_tree:
+            shortcut_id = node.get_property("KTSF", None)
+            if shortcut_id and shortcut_id in shortcut_id_to_node:
+                shortcut_id_to_node[shortcut_id].add_shortcut(node)
+
+    # -- move tree functions --
+    def _init_state(self):
+        board_size_x, board_size_y = self.board_size
+        self.board = [
+            [-1 for _x in range(board_size_x)] for _y in range(board_size_y)
+        ]  # type: List[List[int]]  #  board pos -> chain id
+        self.chains = []  # type: List[List[Move]]  #   chain id -> chain
+        self.prisoners = []  # type: List[Move]
+        self.last_capture = []  # type: List[Move]
+
+    def _calculate_groups(self):
+        with self._lock:
+            self._init_state()
+            try:
+                for node in self.current_node.nodes_from_root:
+                    for m in node.move_with_placements:
+                        self._validate_move_and_update_chains(
+                            m, True
+                        )  # ignore ko since we didn't know if it was forced
+                    if node.clear_placements:  # handle AE by playing all moves left from empty board
+                        clear_coords = {c.coords for c in node.clear_placements}
+                        stones = [m for c in self.chains for m in c if m.coords not in clear_coords]
+                        self._init_state()
+                        for m in stones:
+                            self._validate_move_and_update_chains(m, True)
+            except IllegalMoveException as e:
+                raise Exception(f"Unexpected illegal move ({str(e)})")
+
+    def _validate_move_and_update_chains(self, move: Move, ignore_ko: bool):
+        board_size_x, board_size_y = self.board_size
+
+        def neighbours(moves):
+            return {
+                self.board[m.coords[1] + dy][m.coords[0] + dx]
+                for m in moves
+                for dy, dx in [(-1, 0), (1, 0), (0, -1), (0, 1)]
+                if 0 <= m.coords[0] + dx < board_size_x and 0 <= m.coords[1] + dy < board_size_y
+            }
+
+        ko_or_snapback = len(self.last_capture) == 1 and self.last_capture[0] == move
+        self.last_capture = []
+
+        if move.is_pass:
+            return
+
+        if self.board[move.coords[1]][move.coords[0]] != -1:
+            raise IllegalMoveException("Space occupied")
+
+        # merge chains connected by this move, or create a new one
+        nb_chains = list({c for c in neighbours([move]) if c >= 0 and self.chains[c][0].player == move.player})
+        if nb_chains:
+            this_chain = nb_chains[0]
+            self.board = [[nb_chains[0] if sq in nb_chains else sq for sq in line] for line in self.board]
+            for oc in nb_chains[1:]:
+                self.chains[nb_chains[0]] += self.chains[oc]
+                self.chains[oc] = []
+            self.chains[nb_chains[0]].append(move)
+        else:
+            this_chain = len(self.chains)
+            self.chains.append([move])
+        self.board[move.coords[1]][move.coords[0]] = this_chain
+
+        # check captures
+        opp_nb_chains = {c for c in neighbours([move]) if c >= 0 and self.chains[c][0].player != move.player}
+        for c in opp_nb_chains:
+            if -1 not in neighbours(self.chains[c]):  # no liberties
+                self.last_capture += self.chains[c]
+                for om in self.chains[c]:
+                    self.board[om.coords[1]][om.coords[0]] = -1
+                self.chains[c] = []
+        if ko_or_snapback and len(self.last_capture) == 1 and not ignore_ko:
+            raise IllegalMoveException("Ko")
+        self.prisoners += self.last_capture
+
+        # suicide: check rules and throw exception if needed
+        if -1 not in neighbours(self.chains[this_chain]):
+            rules = self.rules
+            if len(self.chains[this_chain]) == 1:  # even in new zealand rules, single stone suicide is not allowed
+                raise IllegalMoveException("Single stone suicide")
+            elif (isinstance(rules, str) and rules in ["tromp-taylor", "new zealand"]) or (
+                isinstance(rules, dict) and rules.get("suicide", False)
+            ):
+                self.last_capture += self.chains[this_chain]
+                for om in self.chains[this_chain]:
+                    self.board[om.coords[1]][om.coords[0]] = -1
+                self.chains[this_chain] = []
+                self.prisoners += self.last_capture
+            else:  # suicide not allowed by rules
+                raise IllegalMoveException("Suicide")
+
+    # Play a Move from the current position, raise IllegalMoveException if invalid.
+    def play(self, move: Move, ignore_ko: bool = False):
+        board_size_x, board_size_y = self.board_size
+        if not move.is_pass and not (0 <= move.coords[0] < board_size_x and 0 <= move.coords[1] < board_size_y):
+            raise IllegalMoveException(f"Move {move} outside of board coordinates")
+        try:
+            self._validate_move_and_update_chains(move, ignore_ko)
+        except IllegalMoveException:
+            self._calculate_groups()
+            raise
+        with self._lock:
+            played_node = self.current_node.play(move)
+            self.current_node = played_node
+        return played_node
+
+    # Insert a list of moves from root, often just adding one.
+    def sync_branch(self, moves: List[Move]):
+        node = self.root
+        with self._lock:
+            for move in moves:
+                node = node.play(move)
+        return node
+
+    def set_current_node(self, node):
+        self.current_node = node
+        self._calculate_groups()
+
+    def undo(self, n_times=1, stop_on_mistake=None):
+        break_on_branch = False
+        cn = self.current_node  # avoid race conditions
+        break_on_main_branch = False
+        last_branching_node = cn
+        if n_times == "branch":
+            n_times = 9999
+            break_on_branch = True
+        elif n_times == "main-branch":
+            n_times = 9999
+            break_on_main_branch = True
+        for move in range(n_times):
+            if (
+                stop_on_mistake is not None
+                and cn.points_lost is not None
+                and cn.points_lost >= stop_on_mistake
+                and self.katrain.players_info[cn.player].player_type != PLAYER_AI
+            ):
+                self.set_current_node(cn.parent)
+                return
+            previous_cn = cn
+            if cn.shortcut_from:
+                cn = cn.shortcut_from
+            elif not cn.is_root:
+                cn = cn.parent
+            else:
+                break  # root
+            if break_on_branch and len(cn.children) > 1:
+                break
+            elif break_on_main_branch and cn.ordered_children[0] != previous_cn:  # implies > 1 child
+                last_branching_node = cn
+        if break_on_main_branch:
+            cn = last_branching_node
+        if cn is not self.current_node:
+            self.set_current_node(cn)
+
+    def redo(self, n_times=1, stop_on_mistake=None):
+        cn = self.current_node  # avoid race conditions
+        for move in range(n_times):
+            if cn.children:
+                child = cn.ordered_children[0]
+                shortcut_to = [m for m, v in cn.shortcuts_to if child == v]  # are we about to go to a shortcut node?
+                if shortcut_to:
+                    child = shortcut_to[0]
+                cn = child
+            if (
+                move > 0
+                and stop_on_mistake is not None
+                and cn.points_lost is not None
+                and cn.points_lost >= stop_on_mistake
+                and self.katrain.players_info[cn.player].player_type != PLAYER_AI
+            ):
+                self.set_current_node(cn.parent)
+                return
+        if stop_on_mistake is None:
+            self.set_current_node(cn)
+
+    @property
+    def komi(self):
+        return self.root.komi
+
+    @property
+    def board_size(self):
+        return self.root.board_size
+
+    @property
+    def stones(self):
+        with self._lock:
+            return sum(self.chains, [])
+
+    @property
+    def end_result(self):
+        if self.current_node.end_state:
+            return self.current_node.end_state
+        if self.current_node.parent and self.current_node.is_pass and self.current_node.parent.is_pass:
+            return self.manual_score or i18n._("board-game-end")
+
+    @property
+    def prisoner_count(
+        self,
+    ) -> Dict:  # returns prisoners that are of a certain colour as {B: black stones captures, W: white stones captures}
+        return {player: sum([m.player == player for m in self.prisoners]) for player in Move.PLAYERS}
+
+    @property
+    def rules(self):
+        return KataGoEngine.get_rules(self.root.ruleset)
+
+    @property
+    def manual_score(self):
+        rules = self.rules
+        if (
+            not self.current_node.ownership
+            or str(rules).lower() not in ["jp", "japanese"]
+            or not self.current_node.parent
+            or not self.current_node.parent.ownership
+        ):
+            if not self.current_node.score:
+                return None
+            return self.current_node.format_score(round(2 * self.current_node.score) / 2) + "?"
+        board_size_x, board_size_y = self.board_size
+        mean_ownership = [(c + p) / 2 for c, p in zip(self.current_node.ownership, self.current_node.parent.ownership)]
+        ownership_grid = var_to_grid(mean_ownership, (board_size_x, board_size_y))
+        stones = {m.coords: m.player for m in self.stones}
+        lo_threshold = 0.15
+        hi_threshold = 0.85
+        max_unknown = 10
+        max_dame = 4 * (board_size_x + board_size_y)
+
+        def japanese_score_square(square, owner):
+            player = stones.get(square, None)
+            if (
+                (player == "B" and owner > hi_threshold)
+                or (player == "W" and owner < -hi_threshold)
+                or abs(owner) < lo_threshold
+            ):
+                return 0  # dame or own stones
+            if player is None and abs(owner) >= hi_threshold:
+                return round(owner)  # surrounded empty intersection
+            if (player == "B" and owner < -hi_threshold) or (player == "W" and owner > hi_threshold):
+                return 2 * round(owner)  # captured stone
+            return math.nan  # unknown!
+
+        scored_squares = [
+            japanese_score_square((x, y), ownership_grid[y][x])
+            for y in range(board_size_y)
+            for x in range(board_size_x)
+        ]
+        num_sq = {t: sum([s == t for s in scored_squares]) for t in [-2, -1, 0, 1, 2]}
+        num_unkn = sum(math.isnan(s) for s in scored_squares)
+        prisoners = self.prisoner_count
+        score = sum([t * n for t, n in num_sq.items()]) + prisoners["W"] - prisoners["B"] - self.komi
+        self.katrain.log(
+            f"Manual Scoring: {num_sq} score by square with {num_unkn} unknown, {prisoners} captures, and {self.komi} komi -> score = {score}",
+            OUTPUT_DEBUG,
+        )
+        if num_unkn > max_unknown or (num_sq[0] - len(stones)) > max_dame:
+            return None
+        return self.current_node.format_score(score)
+
+    def __repr__(self):
+        return (
+            "\n".join("".join(self.chains[c][0].player if c >= 0 else "-" for c in line) for line in self.board)
+            + f"\ncaptures: {self.prisoner_count}"
+        )
+
+    def update_root_properties(self):
+        def player_name(player_info):
+            if player_info.name and player_info.player_type == PLAYER_HUMAN:
+                return player_info.name
+            else:
+                return f"{i18n._(player_info.player_type)} ({i18n._(player_info.player_subtype)}){SGF_INTERNAL_COMMENTS_MARKER}"
+
+        root_properties = self.root.properties
+        x_properties = {}
+        for bw in "BW":
+            if not self.external_game:
+                x_properties["P" + bw] = player_name(self.katrain.players_info[bw])
+                player_info = self.katrain.players_info[bw]
+                if player_info.player_type == PLAYER_AI:
+                    x_properties[bw + "R"] = rank_label(player_info.calculated_rank)
+        if "+" in str(self.end_result):
+            x_properties["RE"] = self.end_result
+        self.root.properties = {**root_properties, **{k: [v] for k, v in x_properties.items()}}
+
+    def generate_filename(self):
+        self.update_root_properties()
+        player_names = {
+            bw: re.sub(r"[\u200b\u3164'<>:\"/\\|?*]", "", self.root.get_property("P" + bw, bw)) for bw in "BW"
+        }
+        base_game_name = f"{PROGRAM_NAME}_{player_names['B']} vs {player_names['W']}"
+        return f"{base_game_name} {self.game_id}.sgf"
+
+    def write_sgf(self, filename: str, trainer_config: Optional[Dict] = None):
+        if trainer_config is None:
+            trainer_config = self.katrain.config("trainer", {})
+        save_feedback = trainer_config.get("save_feedback", False)
+        eval_thresholds = trainer_config["eval_thresholds"]
+        save_analysis = trainer_config.get("save_analysis", False)
+        save_marks = trainer_config.get("save_marks", False)
+        self.update_root_properties()
+        show_dots_for = {
+            bw: trainer_config.get("eval_show_ai", True) or self.katrain.players_info[bw].human for bw in "BW"
+        }
+        sgf = self.root.sgf(
+            save_comments_player=show_dots_for,
+            save_comments_class=save_feedback,
+            eval_thresholds=eval_thresholds,
+            save_analysis=save_analysis,
+            save_marks=save_marks,
+        )
+        self.sgf_filename = filename
+        os.makedirs(os.path.dirname(filename), exist_ok=True)
+        with open(filename, "w", encoding="utf-8") as f:
+            f.write(sgf)
+        return i18n._("sgf written").format(file_name=filename)
+
+
+class Game(BaseGame):
+    """Extensions related to analysis etc."""
+
+    def __init__(
+        self,
+        katrain,
+        engine: Union[Dict, KataGoEngine],
+        move_tree: GameNode = None,
+        analyze_fast=False,
+        game_properties: Optional[Dict] = None,
+        sgf_filename=None,
+    ):
+        super().__init__(
+            katrain=katrain, move_tree=move_tree, game_properties=game_properties, sgf_filename=sgf_filename
+        )
+        if not isinstance(engine, Dict):
+            engine = {"B": engine, "W": engine}
+        self.engines = engine
+
+        self.insert_mode = False
+        self.insert_after = None
+        self.region_of_interest = None
+
+        threading.Thread(
+            target=lambda: self.analyze_all_nodes(analyze_fast=analyze_fast, even_if_present=False),
+            daemon=True,
+        ).start()  # return faster, but bypass Kivy Clock
+
+    def analyze_all_nodes(self, priority=PRIORITY_GAME_ANALYSIS, analyze_fast=False, even_if_present=True):
+        for node in self.root.nodes_in_tree:
+            # forced, or not present, or something went wrong in loading
+            if even_if_present or not node.analysis_from_sgf or not node.load_analysis():
+                node.clear_analysis()
+                node.analyze(self.engines[node.next_player], priority=priority, analyze_fast=analyze_fast)
+
+    def set_current_node(self, node):
+        if self.insert_mode:
+            self.katrain.controls.set_status(i18n._("finish inserting before navigating"), STATUS_ERROR)
+            return
+        super().set_current_node(node)
+
+    def undo(self, n_times=1, stop_on_mistake=None):
+        if self.insert_mode:  # in insert mode, undo = delete
+            cn = self.current_node  # avoid race conditions
+            if n_times == 1 and cn not in self.insert_after.nodes_from_root:
+                cn.parent.children = [c for c in cn.parent.children if c != cn]
+                self.current_node = cn.parent
+                self._calculate_groups()
+            return
+        super().undo(n_times=n_times, stop_on_mistake=stop_on_mistake)
+
+    def reset_current_analysis(self):
+        cn = self.current_node
+        engine = self.engines[cn.next_player]
+        engine.terminate_queries(cn)
+        cn.clear_analysis()
+        cn.analyze(engine)
+
+    def redo(self, n_times=1, stop_on_mistake=None):
+        if self.insert_mode:
+            return
+        super().redo(n_times=n_times, stop_on_mistake=stop_on_mistake)
+
+    def set_insert_mode(self, mode):
+        if mode == "toggle":
+            mode = not self.insert_mode
+        if mode == self.insert_mode:
+            return
+        self.insert_mode = mode
+        if mode:
+            children = self.current_node.ordered_children
+            if not children:
+                self.insert_mode = False
+            else:
+                self.insert_after = self.current_node.ordered_children[0]
+                self.katrain.controls.set_status(i18n._("starting insert mode"), STATUS_INFO)
+        else:
+            copy_from_node = self.insert_after
+            copy_to_node = self.current_node
+            num_copied = 0
+            if copy_to_node != self.insert_after.parent:
+                above_insertion_root = self.insert_after.parent.nodes_from_root
+                already_inserted_moves = [
+                    n.move for n in copy_to_node.nodes_from_root if n not in above_insertion_root and n.move
+                ]
+                try:
+                    while True:
+                        for m in copy_from_node.move_with_placements:
+                            if m not in already_inserted_moves:
+                                self._validate_move_and_update_chains(m, True)
+                                # this inserts
+                                copy_to_node = GameNode(
+                                    parent=copy_to_node, properties=copy.deepcopy(copy_from_node.properties)
+                                )
+                                num_copied += 1
+                        if not copy_from_node.children:
+                            break
+                        copy_from_node = copy_from_node.ordered_children[0]
+                except IllegalMoveException:
+                    pass  # illegal move = stop
+                self._calculate_groups()  # recalculate groups
+                self.katrain.controls.set_status(
+                    i18n._("ending insert mode").format(num_copied=num_copied), STATUS_INFO
+                )
+                self.analyze_all_nodes(analyze_fast=True, even_if_present=False)
+            else:
+                self.katrain.controls.set_status("", STATUS_INFO)
+        self.katrain.controls.move_tree.insert_node = self.insert_after if self.insert_mode else None
+        self.katrain.controls.move_tree.redraw()
+        self.katrain.update_state(redraw_board=True)
+
+    # Play a Move from the current position, raise IllegalMoveException if invalid.
+    def play(self, move: Move, ignore_ko: bool = False, analyze=True):
+        played_node = super().play(move, ignore_ko)
+        if analyze:
+            if self.region_of_interest:
+                played_node.analyze(self.engines[played_node.next_player], analyze_fast=True)
+                played_node.analyze(self.engines[played_node.next_player], region_of_interest=self.region_of_interest)
+            else:
+                played_node.analyze(self.engines[played_node.next_player])
+        return played_node
+
+    def set_region_of_interest(self, region_of_interest):
+        x1, x2, y1, y2 = region_of_interest
+        xmin, xmax = min(x1, x2), max(x1, x2)
+        ymin, ymax = min(y1, y2), max(y1, y2)
+        szx, szy = self.board_size
+        if not (xmin == xmax and ymin == ymax) and not (xmax - xmin + 1 >= szx and ymax - ymin + 1 >= szy):
+            self.region_of_interest = [xmin, xmax, ymin, ymax]
+        else:
+            self.region_of_interest = None
+        self.katrain.controls.set_status("", OUTPUT_INFO)
+
+    def analyze_extra(self, mode, **kwargs):
+        stones = {s.coords for s in self.stones}
+        cn = self.current_node
+
+        if mode == "stop":
+            self.katrain.pondering = False
+            for e in set(self.engines.values()):
+                e.stop_pondering()
+                e.terminate_queries()
+            return
+
+        engine = self.engines[cn.next_player]
+
+        if mode == "ponder":
+            cn.analyze(
+                engine,
+                ponder=True,
+                priority=PRIORITY_EXTRA_ANALYSIS,
+                region_of_interest=self.region_of_interest,
+                time_limit=False,
+            )
+            return
+
+        if mode == "extra":
+            visits = cn.analysis_visits_requested + engine.config["max_visits"]
+            self.katrain.controls.set_status(i18n._("extra analysis").format(visits=visits), STATUS_ANALYSIS)
+            cn.analyze(
+                engine,
+                visits=visits,
+                priority=PRIORITY_EXTRA_ANALYSIS,
+                region_of_interest=self.region_of_interest,
+                time_limit=False,
+            )
+            return
+
+        if mode == "game":
+            nodes = self.root.nodes_in_tree
+            only_mistakes = kwargs.get("mistakes_only", False)
+            move_range = kwargs.get("move_range", None)
+            if move_range:
+                if move_range[1] < move_range[0]:
+                    move_range = reversed(move_range)
+            threshold = self.katrain.config("trainer/eval_thresholds")[-4]
+            if "visits" in kwargs:
+                visits = kwargs["visits"]
+            else:
+                min_visits = min(node.analysis_visits_requested for node in nodes)
+                visits = min_visits + engine.config["max_visits"]
+            for node in nodes:
+                max_point_loss = max(c.points_lost or 0 for c in [node] + node.children)
+                if only_mistakes and max_point_loss <= threshold:
+                    continue
+                if move_range and (not node.depth - 1 in range(move_range[0], move_range[1] + 1)):
+                    continue
+                node.analyze(engine, visits=visits, priority=-1_000_000, time_limit=False, report_every=None)
+            if not move_range:
+                self.katrain.controls.set_status(i18n._("game re-analysis").format(visits=visits), STATUS_ANALYSIS)
+            else:
+                self.katrain.controls.set_status(
+                    i18n._("move range analysis").format(
+                        start_move=move_range[0], end_move=move_range[1], visits=visits
+                    ),
+                    STATUS_ANALYSIS,
+                )
+            return
+
+        elif mode == "sweep":
+            board_size_x, board_size_y = self.board_size
+
+            if cn.analysis_exists:
+                policy_grid = (
+                    var_to_grid(self.current_node.policy, size=(board_size_x, board_size_y))
+                    if self.current_node.policy
+                    else None
+                )
+                analyze_moves = sorted(
+                    [
+                        Move(coords=(x, y), player=cn.next_player)
+                        for x in range(board_size_x)
+                        for y in range(board_size_y)
+                        if (policy_grid is None and (x, y) not in stones) or policy_grid[y][x] >= 0
+                    ],
+                    key=lambda mv: -policy_grid[mv.coords[1]][mv.coords[0]],
+                )
+            else:
+                analyze_moves = [
+                    Move(coords=(x, y), player=cn.next_player)
+                    for x in range(board_size_x)
+                    for y in range(board_size_y)
+                    if (x, y) not in stones
+                ]
+            visits = engine.config["fast_visits"]
+            self.katrain.controls.set_status(i18n._("sweep analysis").format(visits=visits), STATUS_ANALYSIS)
+            priority = PRIORITY_SWEEP
+        elif mode in ["equalize", "alternative", "local"]:
+            if not cn.analysis_complete and mode != "local":
+                self.katrain.controls.set_status(i18n._("wait-before-extra-analysis"), STATUS_INFO, self.current_node)
+                return
+            if mode == "alternative":  # also do a quick update on current candidates so it doesn't look too weird
+                self.katrain.controls.set_status(i18n._("alternative analysis"), STATUS_ANALYSIS)
+                cn.analyze(engine, priority=PRIORITY_ALTERNATIVES, time_limit=False, find_alternatives="alternative")
+                visits = engine.config["fast_visits"]
+            else:  # equalize
+                visits = max(d["visits"] for d in cn.analysis["moves"].values())
+                self.katrain.controls.set_status(i18n._("equalizing analysis").format(visits=visits), STATUS_ANALYSIS)
+            priority = PRIORITY_EQUALIZE
+            analyze_moves = [Move.from_gtp(gtp, player=cn.next_player) for gtp, _ in cn.analysis["moves"].items()]
+        else:
+            raise ValueError("Invalid analysis mode")
+
+        for move in analyze_moves:
+            if cn.analysis["moves"].get(move.gtp(), {"visits": 0})["visits"] < visits:
+                cn.analyze(
+                    engine, priority=priority, visits=visits, refine_move=move, time_limit=False
+                )  # explicitly requested so take as long as you need
+
+    def selfplay(self, until_move, target_b_advantage=None):
+        cn = self.current_node
+
+        if target_b_advantage is not None:
+            analysis_kwargs = {"visits": max(25, self.katrain.config("engine/fast_visits"))}
+            engine_settings = {"wideRootNoise": 0.03}
+        else:
+            analysis_kwargs = engine_settings = {}
+
+        def set_analysis(node, result):
+            node.set_analysis(result)
+            analyze_and_play(node)
+
+        def request_analysis_for_node(node):
+            self.engines[node.player].request_analysis(
+                node,
+                callback=lambda result, _partial: set_analysis(node, result),
+                priority=PRIORITY_DEFAULT,
+                analyze_fast=True,
+                extra_settings=engine_settings,
+                **analysis_kwargs,
+            )
+
+        def analyze_and_play(node):
+            nonlocal cn, engine_settings
+            candidates = node.candidate_moves
+            if self.katrain.game is not self:
+                return  # a new game happened
+            ai_thoughts = "Move generated by AI self-play\n"
+            if until_move != "end" and target_b_advantage is not None:  # setup pos
+                if node.depth >= until_move or candidates[0]["move"] == "pass":
+                    self.set_current_node(node)
+                    return
+                target_score = cn.score + (node.depth - cn.depth + 1) * (target_b_advantage - cn.score) / (
+                    until_move - cn.depth
+                )
+                max_loss = 5
+                stddev = min(3, 0.5 + (until_move - node.depth) * 0.15)
+                ai_thoughts += f"Selecting moves aiming at score {target_score:.1f} +/- {stddev:.2f} with < {max_loss} points lost\n"
+                if abs(node.score - target_score) < 3 * stddev:
+                    weighted_cands = [
+                        (
+                            move,
+                            math.exp(-0.5 * (abs(move["scoreLead"] - target_score) / stddev) ** 2)
+                            * math.exp(-0.5 * (min(0, move["pointsLost"]) / max_loss) ** 2),
+                        )
+                        for i, move in enumerate(candidates)
+                        if move["pointsLost"] < max_loss or i == 0
+                    ]
+                    move_info = weighted_selection_without_replacement(weighted_cands, 1)[0][0]
+                    for move, wt in weighted_cands:
+                        self.katrain.log(
+                            f"{'* ' if move_info == move else '  '} {move['move']} {move['scoreLead']} {wt}",
+                            OUTPUT_EXTRA_DEBUG,
+                        )
+                        ai_thoughts += f"Move option: {move['move']} score {move['scoreLead']:.2f} loss {move['pointsLost']:.2f} weight {wt:.3e}\n"
+                else:  # we're a bit lost, far away from target, just push it closer
+                    move_info = min(candidates, key=lambda move: abs(move["scoreLead"] - target_score))
+                    self.katrain.log(
+                        f"* Played {move_info['move']} {move_info['scoreLead']} because score deviation between current score {node.score} and target score {target_score} > {3*stddev}",
+                        OUTPUT_EXTRA_DEBUG,
+                    )
+                    ai_thoughts += f"Move played to close difference between score {node.score:.1f} and target {target_score:.1f} quickly."
+
+                self.katrain.log(
+                    f"Self-play until {until_move} target {target_b_advantage}: {len(candidates)} candidates -> move {move_info['move']} score {move_info['scoreLead']} point loss {move_info['pointsLost']}",
+                    OUTPUT_DEBUG,
+                )
+                move = Move.from_gtp(move_info["move"], player=node.next_player)
+            elif candidates:  # just selfplay to end
+                move = Move.from_gtp(candidates[0]["move"], player=node.next_player)
+            else:  # 1 visit etc
+                polmoves = node.policy_ranking
+                move = polmoves[0][1] if polmoves else Move(None)
+            if move.is_pass:
+                if self.current_node == cn:
+                    self.set_current_node(node)
+                return
+            new_node = GameNode(parent=node, move=move)
+            new_node.ai_thoughts = ai_thoughts
+            if until_move != "end" and target_b_advantage is not None:
+                self.set_current_node(new_node)
+                self.katrain.controls.set_status(
+                    i18n._("setup game status message").format(move=new_node.depth, until_move=until_move),
+                    STATUS_INFO,
+                )
+            else:
+                if node != cn:
+                    node.remove_shortcut()
+                cn.add_shortcut(new_node)
+
+            self.katrain.controls.move_tree.redraw_tree_trigger()
+            request_analysis_for_node(new_node)
+
+        request_analysis_for_node(cn)
+
+    def analyze_undo(self, node):
+        train_config = self.katrain.config("trainer")
+        move = node.move
+        if node != self.current_node or node.auto_undo is not None or not node.analysis_complete or not move:
+            return
+        points_lost = node.points_lost
+        thresholds = train_config["eval_thresholds"]
+        num_undo_prompts = train_config["num_undo_prompts"]
+        i = 0
+        while i < len(thresholds) and points_lost < thresholds[i]:
+            i += 1
+        num_undos = num_undo_prompts[i] if i < len(num_undo_prompts) else 0
+        if num_undos == 0:
+            undo = False
+        elif num_undos < 1:  # probability
+            undo = int(node.undo_threshold < num_undos) and len(node.parent.children) == 1
+        else:
+            undo = len(node.parent.children) <= num_undos
+
+        node.auto_undo = undo
+        if undo:
+            self.undo(1)
+            self.katrain.controls.set_status(
+                i18n._("teaching undo message").format(move=move.gtp(), points_lost=points_lost), STATUS_TEACHING
+            )
+            self.katrain.update_state()