Upload 211 files

.gitattributes

@@ -33,3 +33,47 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+katrain/fonts/Roboto-Black.ttf filter=lfs diff=lfs merge=lfs -text
+katrain/fonts/Roboto-BlackItalic.ttf filter=lfs diff=lfs merge=lfs -text
+katrain/fonts/Roboto-Bold.ttf filter=lfs diff=lfs merge=lfs -text
+katrain/fonts/Roboto-BoldItalic.ttf filter=lfs diff=lfs merge=lfs -text
+katrain/fonts/Roboto-Italic.ttf filter=lfs diff=lfs merge=lfs -text
+katrain/fonts/Roboto-Light.ttf filter=lfs diff=lfs merge=lfs -text
+katrain/fonts/Roboto-LightItalic.ttf filter=lfs diff=lfs merge=lfs -text
+katrain/fonts/Roboto-Medium.ttf filter=lfs diff=lfs merge=lfs -text
+katrain/fonts/Roboto-MediumItalic.ttf filter=lfs diff=lfs merge=lfs -text
+katrain/fonts/Roboto-Regular.ttf filter=lfs diff=lfs merge=lfs -text
+katrain/fonts/Roboto-Thin.ttf filter=lfs diff=lfs merge=lfs -text
+katrain/fonts/Roboto-ThinItalic.ttf filter=lfs diff=lfs merge=lfs -text
+katrain/katrain/fonts/materialdesignicons-webfont.ttf filter=lfs diff=lfs merge=lfs -text
+katrain/katrain/fonts/NotoSans-Regular.ttf filter=lfs diff=lfs merge=lfs -text
+katrain/katrain/fonts/NotoSansCJKsc-Regular.otf filter=lfs diff=lfs merge=lfs -text
+katrain/katrain/fonts/NotoSansJP-Regular.otf filter=lfs diff=lfs merge=lfs -text
+katrain/katrain/fonts/Roboto-Black.ttf filter=lfs diff=lfs merge=lfs -text
+katrain/katrain/fonts/Roboto-BlackItalic.ttf filter=lfs diff=lfs merge=lfs -text
+katrain/katrain/fonts/Roboto-Bold.ttf filter=lfs diff=lfs merge=lfs -text
+katrain/katrain/fonts/Roboto-BoldItalic.ttf filter=lfs diff=lfs merge=lfs -text
+katrain/katrain/fonts/Roboto-Italic.ttf filter=lfs diff=lfs merge=lfs -text
+katrain/katrain/fonts/Roboto-Light.ttf filter=lfs diff=lfs merge=lfs -text
+katrain/katrain/fonts/Roboto-LightItalic.ttf filter=lfs diff=lfs merge=lfs -text
+katrain/katrain/fonts/Roboto-Medium.ttf filter=lfs diff=lfs merge=lfs -text
+katrain/katrain/fonts/Roboto-MediumItalic.ttf filter=lfs diff=lfs merge=lfs -text
+katrain/katrain/fonts/Roboto-Regular.ttf filter=lfs diff=lfs merge=lfs -text
+katrain/katrain/fonts/Roboto-Thin.ttf filter=lfs diff=lfs merge=lfs -text
+katrain/katrain/fonts/Roboto-ThinItalic.ttf filter=lfs diff=lfs merge=lfs -text
+katrain/katrain/img/B_stone.png filter=lfs diff=lfs merge=lfs -text
+katrain/katrain/img/board.png filter=lfs diff=lfs merge=lfs -text
+katrain/katrain/img/icon.ico filter=lfs diff=lfs merge=lfs -text
+katrain/katrain/img/icon.ico__ filter=lfs diff=lfs merge=lfs -text
+katrain/katrain/img/inner.png filter=lfs diff=lfs merge=lfs -text
+katrain/katrain/img/W_stone.png filter=lfs diff=lfs merge=lfs -text
+katrain/katrain/sounds/boing.wav filter=lfs diff=lfs merge=lfs -text
+katrain/katrain/sounds/countdownbeep.wav filter=lfs diff=lfs merge=lfs -text
+katrain/themes/blended-all.png filter=lfs diff=lfs merge=lfs -text
+katrain/themes/blended-weak.png filter=lfs diff=lfs merge=lfs -text
+katrain/themes/blocks-none.png filter=lfs diff=lfs merge=lfs -text
+katrain/themes/eric-lizzie.png filter=lfs diff=lfs merge=lfs -text
+katrain/themes/koast.png filter=lfs diff=lfs merge=lfs -text
+katrain/themes/marks-weak.png filter=lfs diff=lfs merge=lfs -text
+katrain/themes/shaded-all.png filter=lfs diff=lfs merge=lfs -text
+katrain/themes/shaded-no-alpha.png filter=lfs diff=lfs merge=lfs -text

katrain/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.
+

katrain/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.

katrain/INSTALL.md

@@ -0,0 +1,177 @@
+# 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
+```
+
+If you are using a M1 Mac, at the point of writing, the latest stable release of Kivy (2.0) does not support the new architecture, so we have to use a development snapshot and build it from source:
+
+```bash
+/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install.sh)"
+brew install python3
+brew install katago
+
+# install dependencies: https://kivy.org/doc/stable/installation/installation-osx.html#install-source-osx
+brew install pkg-config sdl2 sdl2_image sdl2_ttf sdl2_mixer gstreamer ffmpeg
+
+# install Kivy from source: https://kivy.org/doc/stable/gettingstarted/installation.html#kivy-source-install
+pip3 install "kivy[base] @ https://github.com/kivy/kivy/archive/master.zip" --no-binary kivy
+
+pip3 install katrain
+```
+
+Now you can start KaTrain by simply typing `katrain` in a terminal.
+
+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.7/3.8), 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.6-3.8 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.6+ 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 `requirements.txt`.
+
+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 -r requirements.txt
+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.

katrain/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.
+
+-----------------------------------------------------------------------------------------

katrain/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>
+
+* [Previews and YouTube tutorials](#preview)
+* [Installation](#install)
+* [Manual](#ai)
+    * [Configuring KataGo](#kata)
+    * [Play against AI](#ai)
+    * [Analyzing your Games](#analysis)
+    * [Keyboard shortcuts](#keyboard)
+    * [Distributed training](#distributed)
+    * [Themes](#themes)
+* [FAQ and Troubleshooting](#faq)
+* [Contributing](#support)
+
+
+<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=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>
+<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>
+<br/>
+
+<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 `pip3 install -U katrain` to install the latest version from PyPI on any 64-bit OS.
+* 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.
+
+Keyboard shortcuts are shown with **[key]**.
+
+* **[Tab]**: 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:
+    * **[q]**: Child moves are shown. On by default, can turn it off to avoid obscuring other information or when 
+               wanting to guess the next move.
+    * **[w]**: 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'.
+    * **[e]**: 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.
+    * **[r]**: 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.
+    * **[t]**: Expected territory: Show expected ownership of each intersection.
+
+* The analysis options available under the 'Analysis' button are used for deeper evaluation of the position:
+    * **[a]**: Deeper analysis: Re-evaluate the position using more visits, usually resulting in a more accurate evaluation.
+    * **[s]**: 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.
+    * **[d]**: 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.
+    * **[f]**: 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.    
+    * **[g]**: 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.
+    * **[h]**: Reset analysis. This reverts the analysis to what the engine returns after a normal query, removing any additional exploration.
+    * **[i]**: 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.
+    * **[l]**: 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.      
+    * **[spacebar]**: 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.
+      * **[shift+spacebar]**: As above, but does not turn 'top moves' hints on when it is off.
+    * **[enter]** AI move. Makes the AI move for the current player regardless of current player selection.
+    * **[F2]**: Deeper full game analysis. Analyze the entire game to a higher number of visits.
+    * **[F3]**: Performance report. Show an overview of performance statistics for both players.  
+    * **[F10]**: 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:
+
+* **[Alt]**: Open the main menu.
+* **[~]** or **[ ` ]** or **[F12]**: Cycles through more minimalistic UI modes.
+* **[k]**: Toggle display of board coordinates.
+* **[p]**: Pass
+* **[pause]**: Pause/Resume timer
+* **[arrow left]** or **[z]**: Undo move. Hold shift for 10 moves at a time, or ctrl to skip to the start.
+* **[arrow right]** or **[x]**: Redo move. Hold shift for 10 moves at a time, or ctrl to skip to the end.
+* **[arrow up/down]** Switch branch, as would be expected from the move tree.
+* **[home/end]** Go to the beginning/end of the game.
+* **[pageup]** Make the currently selected node the main branch
+* **[Ctrl-delete]** Delete current node.
+* **[c]** Collapse/Uncollapse the branch from the current node to the previous branching point.
+* **[b]** Go back to the previous branching point.
+* **[Shift-b]** Go back the main branch.
+* **[n]** As in clicking the forward red arrow, go to one move before the next mistake (orange or worse) by a human player.
+* **[Shift-n]** As in clicking the backward red arrow, go to one move before the previous mistake.
+* **[scroll mouse]**:
+  * 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.
+* **[Ctrl-V]**: Load SGF from the clipboard and do a 'fast' analysis of the game (with a high priority normal analysis for the last move).
+* **[Ctrl-C]**: Save SGF to clipboard.
+* **[Escape]**: 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:
+
+* **[Spacebar]** Switch between manually navigating the current game, and automatically advancing it.
+* **[Escape]**: This sends the `quit` command to KataGo, which starts a slow shutdown, finishing partial games but not starting new ones. Only works on v1.11+.
+* **[Pause]**: 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.
+
+
+

katrain/THEMES.md

@@ -0,0 +1,86 @@
+# 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)
+
+![Preview](https://raw.githubusercontent.com/sanderland/katrain/master/themes/koast.png)
+
+### 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)
+
+![Preview](https://raw.githubusercontent.com/sanderland/katrain/master/themes/eric-lizzie.png)
+
+
+### 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)
+

katrain/__main__.spec

@@ -0,0 +1,38 @@
+# -*- mode: python ; coding: utf-8 -*-
+
+
+a = Analysis(
+    ['katrain\\__main__.py'],
+    pathex=[],
+    binaries=[],
+    datas=[],
+    hiddenimports=[],
+    hookspath=[],
+    hooksconfig={},
+    runtime_hooks=[],
+    excludes=[],
+    noarchive=False,
+    optimize=0,
+)
+pyz = PYZ(a.pure)
+
+exe = EXE(
+    pyz,
+    a.scripts,
+    a.binaries,
+    a.datas,
+    [],
+    name='__main__',
+    debug=False,
+    bootloader_ignore_signals=False,
+    strip=False,
+    upx=True,
+    upx_exclude=[],
+    runtime_tmpdir=None,
+    console=False,
+    disable_windowed_traceback=False,
+    argv_emulation=False,
+    target_arch=None,
+    codesign_identity=None,
+    entitlements_file=None,
+)

katrain/fonts/Roboto-Black.ttf

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

katrain/fonts/Roboto-BlackItalic.ttf

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

katrain/fonts/Roboto-Bold.ttf

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

katrain/fonts/Roboto-BoldItalic.ttf

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

katrain/fonts/Roboto-Italic.ttf

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

katrain/fonts/Roboto-Light.ttf

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

katrain/fonts/Roboto-LightItalic.ttf

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

katrain/fonts/Roboto-Medium.ttf

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

katrain/fonts/Roboto-MediumItalic.ttf

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

katrain/fonts/Roboto-Regular.ttf

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

katrain/fonts/Roboto-Thin.ttf

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

katrain/fonts/Roboto-ThinItalic.ttf

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

katrain/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/katrain.py

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

katrain/katrain/__main__.py

@@ -0,0 +1,455 @@
+# Main entry point for the HongikAI-KaTrain application.
+# It initializes the Kivy/KaTrain GUI and integrates the custom HongikAIEngine.
+#
+# Author: Gemini 2.5 Pro, Gemini 2.5 Flash
+
+import os
+import sys
+import signal
+import threading
+import time
+import traceback
+import random
+from queue import Queue
+import json
+
+project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+if project_root not in sys.path:
+    sys.path.insert(0, project_root)
+
+os.environ["KCFG_KIVY_LOG_LEVEL"] = os.environ.get("KCFG_KIVY_LOG_LEVEL", "warning")
+import kivy
+kivy.require("2.0.0")
+from kivy.app import App
+from kivy.base import ExceptionHandler, ExceptionManager
+from kivy.lang import Builder
+from kivy.resources import resource_add_path
+from kivy.uix.screenmanager import Screen
+from kivy.core.window import Window
+from kivy.properties import ObjectProperty, StringProperty, NumericProperty, BooleanProperty
+from kivy.clock import Clock
+from kivy.config import Config
+from kivymd.app import MDApp
+
+from katrain.core.utils import find_package_resource, PATHS
+from katrain.core.base_katrain import KaTrainBase
+from katrain.core.lang import DEFAULT_LANGUAGE, i18n
+from katrain.core.constants import *
+from katrain.core.game import Game, KaTrainSGF, IllegalMoveException
+from katrain.core.sgf_parser import Move, ParseError
+from katrain.gui.theme import Theme
+
+import pygame
+
+from hongik.board_ai import Board
+from hongik.engine_ai import HongikAIEngine
+
+from katrain.gui.kivyutils import *
+from katrain.gui.widgets import MoveTree
+from katrain.gui.badukpan import BadukPanWidget
+from katrain.gui.controlspanel import ControlsPanel
+
+if 'USER' not in PATHS:
+    USER_DATA_PATH = os.path.expanduser(os.path.join("~", ".katrain"))
+    os.makedirs(USER_DATA_PATH, exist_ok=True)
+    PATHS['USER'] = USER_DATA_PATH
+
+ICON = find_package_resource("katrain/img/icon.ico")
+Config.set("kivy", "window_icon", ICON)
+Config.set("input", "mouse", "mouse,multitouch_on_demand")
+SOUNDS_DIR = find_package_resource("katrain/sounds")
+
+class KaTrainGui(Screen, KaTrainBase):
+    """
+    The main GUI class for the application. It inherits from Kivy's Screen and
+    KaTrainBase, managing all visual components and user interactions.
+    """
+    zen = NumericProperty(0)
+    controls = ObjectProperty(None); engine = ObjectProperty(None); game = ObjectProperty(None)
+    board_gui = ObjectProperty(None); board_controls = ObjectProperty(None); play_mode = ObjectProperty(None)
+    show_move_numbers = BooleanProperty(False)
+    analysis_controls = ObjectProperty(None) 
+
+    @property
+    def play_analyze_mode(self):
+        return self.play_mode.mode
+    
+    def __init__(self, **kwargs):
+        """Initializes the GUI, linking it to the main app and setting up necessary variables."""
+        self.katrain_app = kwargs.get('katrain_app')
+        self.engine, self.message_queue, self.pondering = None, Queue(), False
+        self.contributing, self.animate_contributing = False, False
+        super().__init__(**kwargs)
+
+    def config_set(self, section, option, value):
+        """Sets a configuration value and writes it to the config file."""
+        self.katrain_app.config.set(section, option, value)
+        self.katrain_app.config.write()
+
+    def save_config(self, sections=None):
+        """Writes the current configuration to disk."""
+        self.katrain_app.config.write()
+        
+    def play_sound(self):
+        """Randomly plays a stone placement sound from the sounds directory."""
+        try:
+            sound_files = [f for f in os.listdir(SOUNDS_DIR) if f.startswith('stone') and f.endswith(('.wav', '.ogg'))]
+            if sound_files:
+                sound_to_play = random.choice(sound_files)
+                pygame.mixer.Sound(os.path.join(SOUNDS_DIR, sound_to_play)).play()
+        except pygame.error as e:
+            print(f"Pygame sound playback error: {e}")
+
+    def start(self):
+        """
+        Starts the main application logic, initializes the AI engine, starts the
+        message loop, and creates a new game.
+        """
+        if self.engine: return
+        self.board_gui.trainer_config = self.config("trainer")
+        self.engine = HongikAIEngine(self, self.config("engine"))
+        threading.Thread(target=self._message_loop_thread, daemon=True).start()
+        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)
+        
+    def update_player(self, bw, **kwargs):
+        """Updates the information and type for a given player (Black or White)."""
+        player_type = kwargs.get('player_type')
+        if player_type == PLAYER_AI:
+            self.players_info[bw].player_type, self.players_info[bw].player_subtype = PLAYER_AI, "홍익 AI"
+            self.players_info[bw].sgf_rank = ""
+            self.players_info[bw].calculated_rank = ""
+        elif player_type == PLAYER_HUMAN:
+            self.players_info[bw].player_type, self.players_info[bw].player_subtype = PLAYER_HUMAN, "Human"
+
+        self.players_info[bw].periods_used = 0
+        self.players_info[bw].being_taught = False
+        self.players_info[bw].player = bw 
+        if self.game: self.players_info[bw].name = self.game.root.get_property("P" + bw)
+        if self.controls: self.controls.update_players(); self.update_state()
+
+    def update_gui(self, cn, redraw_board=False):
+        """Updates all GUI elements with the latest game state information."""
+        if not self.game: return
+        prisoners = self.game.prisoner_count
+        self.controls.players["B"].captures, self.controls.players["W"].captures = prisoners.get("W", 0), prisoners.get("B", 0)
+        if not self.engine or not self.engine.is_idle(): self.board_controls.engine_status_col = Theme.ENGINE_BUSY_COLOR
+        else: self.board_controls.engine_status_col = Theme.ENGINE_READY_COLOR
+        if redraw_board: self.board_gui.draw_board()
+        self.board_gui.redraw_board_contents_trigger()
+        self.controls.update_evaluation(); self.controls.move_tree.current_node = self.game.current_node
+
+    def update_state(self, redraw_board=False):
+        """A shortcut to send an 'update-state' message to the message queue."""
+        self("update-state", redraw_board=redraw_board)
+
+    def _message_loop_thread(self):
+        """
+        The main message loop that runs in a separate thread, processing commands
+        from the message queue to avoid blocking the GUI.
+        """
+        while True:
+            game_id, msg, args, kwargs = self.message_queue.get()
+            try:
+                if self.game and game_id != self.game.game_id: continue
+                fn = getattr(self, f"_do_{msg.replace('-', '_')}")
+                fn(*args, **kwargs)
+                if msg != "update_state": self._do_update_state()
+            except Exception as exc:
+                self.log(f"Message loop exception: {exc}", OUTPUT_ERROR); traceback.print_exc()
+
+    def __call__(self, message, *args, **kwargs):
+        """Adds a message to the thread-safe message queue for processing."""
+        if message.endswith("popup"): Clock.schedule_once(lambda _dt: getattr(self, f"_do_{message.replace('-', '_')}")(*args, **kwargs), -1)
+        else: self.message_queue.put([self.game.game_id if self.game else None, message, args, kwargs])
+
+    def _do_update_state(self, redraw_board=False):
+        """
+        Handles the 'update-state' message, refreshing the GUI to reflect the
+        current game state, player turn, and engine status.
+        """
+        if not self.game or not self.game.current_node: return
+
+        if self.controls:
+            self.controls.update_players()
+            next_player_is = self.game.current_node.next_player
+            self.controls.active_player = self.game.current_node.next_player
+         
+            self.controls.players['B'].active = (next_player_is == 'B')
+            self.controls.players['W'].active = (next_player_is == 'W')
+        
+        is_game_active = self.game and not self.game.end_result      
+        is_game_over = not is_game_active
+
+        if self.board_gui.game_is_over != is_game_over:
+            self.board_gui.game_is_over = is_game_over
+            if is_game_over:
+                self.board_gui.game_over_message = "Game Over"
+        
+        is_ai_vs_ai = (self.players_info['B'].player_type == PLAYER_AI and self.players_info['W'].player_type == PLAYER_AI)
+        
+        if self.controls and self.controls.ids.get('undo_button'):
+            self.controls.ids.undo_button.disabled = not is_game_active or is_ai_vs_ai
+            self.controls.ids.resign_button.disabled = not is_game_active or is_ai_vs_ai
+        
+        if self.engine and self.pondering:
+            self.game.analyze_extra("ponder")
+        else:
+            self.engine.stop_pondering()
+            
+        Clock.schedule_once(lambda _dt: self.update_gui(self.game.current_node, redraw_board), -1)
+        self.engine._game_turn()
+
+    def _do_play(self, coords):
+        """Handles a 'play' event, creating a Move object and playing it on the board."""
+        try:
+            move = Move(coords, player=self.game.current_node.next_player)
+            self.game.play(move)
+            self.update_state()
+            if not move.is_pass: self.play_sound()
+        except IllegalMoveException as e:
+            self.controls.set_status(f"Illegal move: {str(e)}", STATUS_ERROR)
+
+    def _do_new_game(self, player_types=(PLAYER_HUMAN, PLAYER_HUMAN), move_tree=None, sgf_filename=None):
+        """Handles a 'new-game' event, setting up a new game with specified players."""
+        self.pondering = False
+        self.engine.sound_index = False
+        if self.engine: self.engine.stop_self_play_loop(); self.engine.on_new_game()
+        self.game = Game(self, self.engine, move_tree=move_tree, sgf_filename=sgf_filename)
+       
+        self.board_controls.ids.game_mode_reset_btn.state = 'down'
+        self.update_player('B', player_type=player_types[0])
+        self.update_player('W', player_type=player_types[1])
+        if self.controls and self.controls.graph:
+            self.controls.graph.initialize_from_game(self.game.root)
+        self.update_state(redraw_board=True)
+
+        try:
+            self.analysis_controls.hamburger.disabled = False 
+            self.analysis_controls.show_children.disabled =False
+            self.analysis_controls.hints.disabled =False
+            self.analysis_controls.policy.disabled =False            
+            self.controls.ids.undo.disabled = False
+            self.board_controls.ids.pass_btn.disabled = False
+            self.controls.ids.timer.ids.pause.disabled = False
+        except Exception as e:
+            self.log(f"Error enabling button: {e}", OUTPUT_ERROR)
+
+    
+    def _do_start_hongik_selfplay(self):
+        """Starts a new self-play game between two Hongik AI instances."""
+        self._do_new_game(player_types=(PLAYER_AI, PLAYER_AI))
+        self.engine.start_self_play_loop()
+
+        try:
+            self.analysis_controls.hamburger.disabled = True
+            self.analysis_controls.show_children.checkbox.active = False
+            self.analysis_controls.show_children.disabled =True
+            self.analysis_controls.hints.checkbox.active = False
+            self.analysis_controls.hints.disabled =True
+            self.analysis_controls.policy.checkbox.active = False
+            self.analysis_controls.policy.disabled =True
+            self.controls.ids.undo.disabled = True
+            self.board_controls.ids.pass_btn.disabled = True
+            self.controls.ids.timer.ids.pause.disabled = True
+        except Exception as e:
+            self.log(f"Error enabling hamburger button: {e}", OUTPUT_ERROR)
+
+    def _do_start_hongik_vshuman(self):
+        """Starts a new game between a human player and Hongik AI."""
+        self._do_new_game(player_types=(PLAYER_HUMAN, PLAYER_AI))
+        try:
+            hamburger_button = self.analysis_controls.ids.get('hamburger')
+            if hamburger_button:
+                hamburger_button.disabled = True
+        except Exception as e:
+            self.log(f"Error enabling hamburger button: {e}", OUTPUT_ERROR)
+        
+    def _do_undo(self, n_times=1):
+        """Handles an 'undo' event, going back a specified number of moves."""
+        try: n_times = int(n_times)
+        except (ValueError, TypeError): n_times = 1
+        self.game.undo(n_times); self.update_state()
+        
+    def _do_resign(self):
+        """Handles a 'resign' event, ending the game and resetting the GUI."""
+        if self.game:
+            winner = 'W' if self.game.current_node.next_player == 'B' else 'B'
+            self.game.root.set_property("RE", f"{winner}+Resign")
+            try:
+                self_play_button = self.board_controls.ids.hongik_selfplay_btn
+                vs_human_button = self.board_controls.ids.hongik_vs_human_btn
+                self_play_button.state = 'normal'
+                vs_human_button.state = 'normal'
+            except Exception as e:
+                self.log(f"Failed to change button state: {e}", OUTPUT_ERROR)
+            self.game = Game(self, self.engine)
+            self._do_new_game()
+    
+    def load_sgf_file(self, file_path):
+        """Initiates loading of an SGF file in a separate thread."""
+        self.controls.set_status(f"Loading SGF file: {os.path.basename(file_path)}", STATUS_INFO)
+        threading.Thread(target=self._load_sgf_thread_target, args=(file_path,), daemon=True).start()
+
+    def _load_sgf_thread_target(self, file_path):
+        """The target function for the SGF loading thread."""
+        try:
+            move_tree = KaTrainSGF.parse_file(os.path.abspath(file_path))
+            Clock.schedule_once(lambda dt: self._do_new_game(move_tree=move_tree, sgf_filename=file_path))
+        except Exception as e:
+            self.log(f"SGF file loading failed: {e}", OUTPUT_ERROR)
+            Clock.schedule_once(lambda dt: self.controls.set_status(f"SGF loading failed", STATUS_ERROR))
+
+    def handle_animations(self, *_args): pass
+    
+    def _on_keyboard_down(self, keyboard, keycode, text, modifiers):
+        """Handles keyboard shortcuts, such as toggling move numbers."""
+        if not self.game: return True
+        key = keycode[1]
+        if key == 'n':
+            self.show_move_numbers = not self.show_move_numbers
+            self.board_gui.redraw_board_contents_trigger()
+            return True
+        return False
+    
+    def _do_score(self, *_args):
+        """Handles a 'score' event, requesting the engine to score the current position."""
+        self.board_gui.game_over_message = "Scoring..."
+        self.controls.set_status("Scoring...", STATUS_INFO)
+        def score_callback(score_details):
+            if score_details:
+                winner = score_details['winner']
+                score = score_details['score']
+                self.game.set_result(f"{winner}+{abs(score)}")
+                self.update_state()
+            else:
+                self.controls.set_status("Failed to score the game.", STATUS_ERROR)
+        self.engine.request_score(self.game.current_node, score_callback)
+    
+    def _bind_widgets(self, dt):
+        """위젯이 모두 생성된 후, 이벤트를 파이썬에서 직접 바인딩합니다."""
+        if self.analysis_controls and self.analysis_controls.show_children:
+            self.analysis_controls.show_children.checkbox.bind(active=self._handle_show_children_toggle)
+
+        if self.nav_drawer_contents and 'player_type_spinner_W' in self.nav_drawer_contents.ids:
+            self.nav_drawer_contents.ids.player_type_spinner_W.disabled = True
+            print("W player type spinner successfully disabled via Python.") # 확인용 로그
+
+    def on_nav_drawer_close(self):
+        """Handles the closing of the navigation drawer, forcing a redraw."""
+        self.update_state() 
+        if self.board_gui:
+            self.board_gui.draw_board()
+            self.board_gui.redraw_board_contents_trigger() 
+        self.canvas.ask_update() 
+
+    def _do_contribute_popup(self,*_args):pass
+    def _do_config_popup(self, *_args):pass    
+    def _do_new_game_popup(self,*_args):pass    
+    def _do_save_game(self,*_args):pass
+    def _do_save_game_as_popup(self,*_args):pass
+    def _do_analyze_sgf_popup(self,*_args):pass
+    def _do_teacher_popup(self,*_args):pass
+    def _do_ai_popup(self,*_args):pass
+    def _do_timer_popup(self,*_args):pass
+
+class KaTrainApp(MDApp):
+    """
+    The main application class that inherits from KivyMD's MDApp. It builds the
+    GUI, manages the configuration, and handles application lifecycle events.
+    """
+    gui = ObjectProperty(None)
+    language = StringProperty(DEFAULT_LANGUAGE, allownone=True)
+    
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._resize_event = None
+
+    def build_config(self, config):
+        """Sets up the default configuration for the application."""
+        if 'SGF' not in PATHS:
+            PATHS['SGF'] = os.path.join(PATHS.get('USER', '.'), 'sgf')
+            os.makedirs(PATHS['SGF'], exist_ok=True)
+        config.setdefaults("general",{"lang": DEFAULT_LANGUAGE, "show_player_rank": True, "last_sgf_directory": PATHS["SGF"],})
+        config.setdefaults("engine", {"max_visits": "100"})
+        
+        threshold_str = "-1,0.5,1.5,3,5,7.5,10"
+        thresholds_as_floats = [float(v) for v in threshold_str.split(',')]
+        
+        config.setdefaults("trainer", {
+            "eval_thresholds": thresholds_as_floats,
+            "theme": "theme:normal" 
+        })
+        
+        config.setdefaults("uistate", {"size": "[1300, 1000]"})
+
+    def build(self):
+        """Builds the application's widget tree and sets up window bindings."""
+        pygame.mixer.init()
+        self.icon, self.title = ICON, "홍익 AI - KaTrain"
+        self.theme_cls.theme_style, self.theme_cls.primary_palette = "Dark", "Gray"
+        for p in [os.path.join(PATHS["PACKAGE"], d) for d in ["fonts","sounds","img", "lang"]] + [os.path.abspath(PATHS["USER"])]:
+            resource_add_path(p)
+        Builder.load_file(find_package_resource("katrain/gui.kv"))
+        Builder.load_file(find_package_resource("katrain/popups.kv"))
+        Window.bind(on_request_close=self.on_request_close)
+        Window.bind(on_dropfile=lambda win, file: self.gui.load_sgf_file(file.decode("utf8")))
+        Window.bind(on_resize=self.on_resize)
+        self.gui = KaTrainGui(katrain_app=self, config=self.config)
+        Window.size = Window.system_size
+        return self.gui
+    
+    def on_resize(self, window, width, height):
+        """Controls the storm of resize events by debouncing them with a short delay."""
+        if self._resize_event:
+            self._resize_event.cancel()
+        self._resize_event = Clock.schedule_once(self._redraw_all, 0.15)
+
+    def _redraw_all(self, dt):
+        """The actual function that redraws the entire screen after a resize."""
+        if self.gui:
+            self.gui.update_state(redraw_board=True)
+    
+    def on_start(self):
+        """Called when the application is starting."""
+        self.language = self.gui.config("general/lang") or DEFAULT_LANGUAGE
+        self.gui.start()
+        Window.show()        
+
+    def on_language(self, _instance, language):
+        """Handles language changes."""
+        i18n.switch_lang(language)
+        self.gui.config_set("general", "lang", language)
+        
+    def on_request_close(self, *_args, **_kwargs):
+        """Handles the window close event, saving the window size and shutting down the engine."""
+        if getattr(self, "gui", None):
+            size_str = json.dumps([int(d) for d in Window.size])
+            self.gui.config_set("uistate", "size", size_str)
+            self.gui.save_config("uistate")
+            if self.gui.engine: self.gui.engine.shutdown()
+            
+    def signal_handler(self, _signal, _frame):
+        """Handles signals like Ctrl+C."""
+        self.stop()
+
+def run_app():
+    """Initializes and runs the application."""
+    class CrashHandler(ExceptionHandler):
+        def handle_exception(self, inst):
+            trace = "".join(traceback.format_tb(sys.exc_info()[2]))
+            app = MDApp.get_running_app()   
+            message = f"Exception {inst.__class__.__name__}: {inst}\n{trace}"
+            if app and app.gui: app.gui.log(message, OUTPUT_ERROR)
+            else: print(message)
+            return ExceptionManager.PASS
+    ExceptionManager.add_handler(CrashHandler())
+    
+    Config.set('graphics', 'window_state', 'hidden')
+
+    app = KaTrainApp(); signal.signal(signal.SIGINT, app.signal_handler); app.run()
+
+if __name__ == "__main__":
+    run_app()

katrain/katrain/__main__.spec

@@ -0,0 +1,38 @@
+# -*- mode: python ; coding: utf-8 -*-
+
+
+a = Analysis(
+    ['__main__.py'],
+    pathex=[],
+    binaries=[],
+    datas=[('C:\\Users\\puco2\\katrain\\katrain\\fonts\\Roboto-Regular.ttf', 'kivymd\\fonts'), ('C:\\Users\\puco2\\katrain\\katrain\\fonts\\Roboto-Italic.ttf', 'kivymd\\fonts'), ('C:\\Users\\puco2\\katrain\\katrain\\fonts\\Roboto-Bold.ttf', 'kivymd\\fonts'), ('C:\\Users\\puco2\\katrain\\katrain\\fonts\\Roboto-BoldItalic.ttf', 'kivymd\\fonts'), ('C:\\Users\\puco2\\katrain\\katrain\\fonts\\Roboto-Thin.ttf', 'kivymd\\fonts'), ('C:\\Users\\puco2\\katrain\\katrain\\fonts\\Roboto-BoldItalic.ttf', 'kivymd\\fonts'), ('C:\\Users\\puco2\\katrain\\katrain\\fonts\\Roboto-LightItalic.ttf', 'kivymd\\fonts'), ('C:\\Users\\puco2\\katrain\\katrain\\fonts\\Roboto-Light.ttf', 'kivymd\\fonts'), ('C:\\Users\\puco2\\katrain\\katrain\\fonts\\Roboto-BlackItalic.ttf', 'kivymd\\fonts'), ('C:\\Users\\puco2\\katrain\\katrain\\fonts\\Roboto-Black.ttf', 'kivymd\\fonts'), ('C:\\Users\\puco2\\katrain\\katrain\\fonts\\Roboto-MediumItalic.ttf', 'kivymd\\fonts'), ('C:\\Users\\puco2\\katrain\\katrain\\fonts\\Roboto-Medium.ttf', 'kivymd\\fonts'), ('C:\\Users\\puco2\\katrain\\katrain\\fonts\\Roboto-ThinItalic.ttf', 'kivymd\\fonts'), ('C:\\Users\\puco2\\katrain\\katrain\\fonts\\materialdesignicons-webfont.ttf', 'kivymd\\fonts')],
+    hiddenimports=[],
+    hookspath=[],
+    hooksconfig={},
+    runtime_hooks=[],
+    excludes=[],
+    noarchive=False,
+    optimize=0,
+)
+pyz = PYZ(a.pure)
+
+exe = EXE(
+    pyz,
+    a.scripts,
+    a.binaries,
+    a.datas,
+    [],
+    name='__main__',
+    debug=False,
+    bootloader_ignore_signals=False,
+    strip=False,
+    upx=True,
+    upx_exclude=[],
+    runtime_tmpdir=None,
+    console=False,
+    disable_windowed_traceback=False,
+    argv_emulation=False,
+    target_arch=None,
+    codesign_identity=None,
+    entitlements_file=None,
+)

katrain/katrain/config.json

@@ -0,0 +1,235 @@
+{
+    "engine": {
+        "katago": "",
+        "altcommand": "",
+        "model": "katrain/models/g170e-b15c192-s1672170752-d466197061.bin.gz",
+        "config": "katrain/KataGo/analysis_config.cfg",
+        "threads": 12,
+        "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.13.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
+        }
+    },
+    "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/katrain/core/ai.py

@@ -0,0 +1,516 @@
+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_STRATEGIES_PICK,
+    AI_STRATEGIES_POLICY,
+    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,
+)
+from katrain.core.game import Game, GameNode, Move
+from katrain.core.utils import var_to_grid, weighted_selection_without_replacement, evaluation_class
+
+
+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]:
+        return 9
+    if strategy == AI_RANK:
+        return 1 - settings["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 dirichlet_noise(num, dir_alpha=0.3):
+    sample = [random.gammavariate(dir_alpha, 1) for _ in range(num)]
+    sum_sample = sum(sample)
+    return [s / sum_sample for s in sample]
+
+
+def fmt_moves(moves: List[Tuple[float, Move]]):
+    return ", ".join(f"{mv.gtp()} ({p:.2%})" for p, mv in moves)
+
+
+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
+
+
+def request_ai_analysis(game: Game, cn: GameNode, extra_settings: Dict) -> Optional[Dict]:
+    error = False
+    analysis = None
+
+    def set_analysis(a, partial_result):
+        nonlocal analysis
+        if not partial_result:
+            analysis = a
+
+    def set_error(a):
+        nonlocal error
+        game.katrain.log(f"Error in additional analysis query: {a}")
+        error = True
+
+    engine = game.engines[cn.player]
+    engine.request_analysis(
+        cn,
+        callback=set_analysis,
+        error_callback=set_error,
+        priority=PRIORITY_EXTRA_AI_QUERY,
+        ownership=False,
+        extra_settings=extra_settings,
+    )
+    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)
+    return analysis
+
+
+def generate_ai_move(game: Game, ai_mode: str, ai_settings: Dict) -> Tuple[Move, GameNode]:
+    cn = game.current_node
+
+    if ai_mode == AI_HANDICAP:
+        pda = ai_settings["pda"]
+        if ai_settings["automatic"]:
+            n_handicaps = len(game.root.get_list_property("AB", []))
+            MOVE_VALUE = 14  # could be rules dependent
+            b_stones_advantage = max(n_handicaps - 1, 0) - (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
+        handicap_analysis = request_ai_analysis(
+            game, cn, {"playoutDoublingAdvantage": pda, "playoutDoublingAdvantagePla": "BLACK"}
+        )
+        if not handicap_analysis:
+            game.katrain.log("Error getting handicap-based move", OUTPUT_ERROR)
+            ai_mode = AI_DEFAULT
+    elif ai_mode == AI_ANTIMIRROR:
+        antimirror_analysis = request_ai_analysis(game, cn, {"antiMirror": True})
+        if not antimirror_analysis:
+            game.katrain.log("Error getting antimirror move", OUTPUT_ERROR)
+            ai_mode = AI_DEFAULT
+
+    while not cn.analysis_complete:
+        time.sleep(0.01)
+        game.engines[cn.next_player].check_alive(exception_if_dead=True)
+
+    ai_thoughts = ""
+    if (ai_mode in AI_STRATEGIES_POLICY) and cn.policy:  # pure policy based move
+        policy_moves = cn.policy_ranking
+        pass_policy = cn.policy[-1]
+        # dont make it jump around for the last few sensible non pass moves
+        top_5_pass = any([polmove[1].is_pass for polmove in policy_moves[:5]])
+
+        size = game.board_size
+        policy_grid = var_to_grid(cn.policy, size)  # type: List[List[float]]
+        top_policy_move = policy_moves[0][1]
+        ai_thoughts += f"Using policy based strategy, base top 5 moves are {fmt_moves(policy_moves[:5])}. "
+        if (ai_mode == AI_POLICY and cn.depth <= ai_settings["opening_moves"]) or (
+            ai_mode in [AI_LOCAL, AI_TENUKI] and not (cn.move and cn.move.coords)
+        ):
+            ai_mode = AI_WEIGHTED
+            ai_thoughts += "Strategy override, using policy-weighted strategy instead. "
+            ai_settings = {"pick_override": 0.9, "weaken_fac": 1, "lower_bound": 0.02}
+
+        if top_5_pass:
+            aimove = top_policy_move
+            ai_thoughts += "Playing top one because one of them is pass."
+        elif ai_mode == AI_POLICY:
+            aimove = top_policy_move
+            ai_thoughts += f"Playing top policy move {aimove.gtp()}."
+        else:  # weighted or pick-based
+            legal_policy_moves = [(pol, mv) for pol, mv in policy_moves if not mv.is_pass and pol > 0]
+            board_squares = size[0] * size[1]
+            if ai_mode == AI_RANK:  # calibrated, override from 0.8 at start to ~0.4 at full board
+                override = 0.8 * (1 - 0.5 * (board_squares - len(legal_policy_moves)) / board_squares)
+                overridetwo = 0.85 + max(0, 0.02 * (ai_settings["kyu_rank"] - 8))
+            else:
+                override = ai_settings["pick_override"]
+                overridetwo = 1.0
+
+            if policy_moves[0][0] > override:
+                aimove = top_policy_move
+                ai_thoughts += f"Top policy move has weight > {override:.1%}, so overriding other strategies."
+            elif policy_moves[0][0] + policy_moves[1][0] > overridetwo:
+                aimove = top_policy_move
+                ai_thoughts += (
+                    f"Top two policy moves have cumulative weight > {overridetwo:.1%}, so overriding other strategies."
+                )
+            elif ai_mode == AI_WEIGHTED:
+                aimove, ai_thoughts = policy_weighted_move(
+                    policy_moves, ai_settings["lower_bound"], ai_settings["weaken_fac"]
+                )
+            elif ai_mode in AI_STRATEGIES_PICK:
+
+                if ai_mode != AI_RANK:
+                    n_moves = max(1, int(ai_settings["pick_frac"] * len(legal_policy_moves) + ai_settings["pick_n"]))
+                else:
+                    orig_calib_avemodrank = 0.063015 + 0.7624 * board_squares / (
+                        10 ** (-0.05737 * ai_settings["kyu_rank"] + 1.9482)
+                    )
+                    norm_leg_moves = len(legal_policy_moves) / board_squares
+                    modified_calib_avemodrank = (
+                        0.3931
+                        + 0.6559
+                        * norm_leg_moves
+                        * math.exp(
+                            -1
+                            * (
+                                3.002 * norm_leg_moves * norm_leg_moves
+                                - norm_leg_moves
+                                - 0.034889 * ai_settings["kyu_rank"]
+                                - 0.5097
+                            )
+                            ** 2
+                        )
+                        - 0.01093 * ai_settings["kyu_rank"]
+                    ) * orig_calib_avemodrank
+                    n_moves = board_squares * norm_leg_moves / (1.31165 * (modified_calib_avemodrank + 1) - 0.082653)
+                    n_moves = max(1, round(n_moves))
+
+                if ai_mode in [AI_INFLUENCE, AI_TERRITORY, AI_LOCAL, AI_TENUKI]:
+                    if cn.depth > ai_settings["endgame"] * board_squares:
+                        weighted_coords = [(pol, 1, *mv.coords) for pol, mv in legal_policy_moves]
+                        x_ai_thoughts = (
+                            f"Generated equal weights as move number >= {ai_settings['endgame'] * size[0] * size[1]}. "
+                        )
+                        n_moves = int(max(n_moves, len(legal_policy_moves) // 2))
+                    elif ai_mode in [AI_INFLUENCE, AI_TERRITORY]:
+                        weighted_coords, x_ai_thoughts = generate_influence_territory_weights(
+                            ai_mode, ai_settings, policy_grid, size
+                        )
+                    else:  # ai_mode in [AI_LOCAL, AI_TENUKI]
+                        weighted_coords, x_ai_thoughts = generate_local_tenuki_weights(
+                            ai_mode, ai_settings, policy_grid, cn, size
+                        )
+                    ai_thoughts += x_ai_thoughts
+                else:  # ai_mode in [AI_PICK, AI_RANK]:
+                    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
+                    ]
+
+                pick_moves = weighted_selection_without_replacement(weighted_coords, n_moves)
+                ai_thoughts += f"Picked {min(n_moves,len(weighted_coords))} random moves according to weights. "
+
+                if pick_moves:
+                    new_top = [
+                        (p, Move((x, y), player=cn.next_player)) for p, wt, x, y in heapq.nlargest(5, pick_moves)
+                    ]
+                    aimove = new_top[0][1]
+                    ai_thoughts += f"Top 5 among these were {fmt_moves(new_top)} and picked top {aimove.gtp()}. "
+                    if new_top[0][0] < pass_policy:
+                        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
+                else:
+                    aimove = top_policy_move
+                    ai_thoughts += f"Pick policy strategy {ai_mode} failed to find legal moves, so is playing top policy move {aimove.gtp()}."
+            else:
+                raise ValueError(f"Unknown Policy-based AI mode {ai_mode}")
+    else:  # Engine based move
+        candidate_ai_moves = cn.candidate_moves
+        if ai_mode == AI_HANDICAP:
+            candidate_ai_moves = handicap_analysis["moveInfos"]
+        elif ai_mode == AI_ANTIMIRROR:
+            candidate_ai_moves = antimirror_analysis["moveInfos"]
+
+        top_cand = Move.from_gtp(candidate_ai_moves[0]["move"], player=cn.next_player)
+        if top_cand.is_pass and ai_mode not in [
+            AI_DEFAULT,
+            AI_HANDICAP,
+        ]:  # don't play suicidal to balance score
+            aimove = top_cand
+            ai_thoughts += "Top move is pass, so passing regardless of strategy. "
+        else:
+            if ai_mode == AI_JIGO:
+                sign = cn.player_sign(cn.next_player)
+                jigo_move = min(
+                    candidate_ai_moves, key=lambda move: abs(sign * move["scoreLead"] - ai_settings["target_score"])
+                )
+                aimove = Move.from_gtp(jigo_move["move"], player=cn.next_player)
+                ai_thoughts += f"Jigo strategy found {len(candidate_ai_moves)} candidate moves (best {top_cand.gtp()}) and chose {aimove.gtp()} as closest to 0.5 point win"
+            elif ai_mode == AI_SCORELOSS:
+                c = ai_settings["strength"]
+                moves = [
+                    (
+                        d["pointsLost"],
+                        math.exp(min(200, -c * max(0, d["pointsLost"]))),
+                        Move.from_gtp(d["move"], player=cn.next_player),
+                    )
+                    for d in candidate_ai_moves
+                ]
+                topmove = weighted_selection_without_replacement(moves, 1)[0]
+                aimove = topmove[2]
+                ai_thoughts += f"ScoreLoss strategy found {len(candidate_ai_moves)} candidate moves (best {top_cand.gtp()}) and chose {aimove.gtp()} (weight {topmove[1]:.3f}, point loss {topmove[0]:.1f}) based on score weights."
+            elif ai_mode in [AI_SIMPLE_OWNERSHIP, AI_SETTLE_STONES]:
+                stones_with_player = {(*s.coords, s.player) for s in game.stones}
+                next_player_sign = cn.player_sign(cn.next_player)
+                if ai_mode == AI_SIMPLE_OWNERSHIP:
+
+                    def settledness(d, player_sign, player):
+                        return sum([abs(o) for o in d["ownership"] if player_sign * o > 0])
+
+                else:
+                    board_size_x, board_size_y = game.board_size
+
+                    def settledness(d, player_sign, player):
+                        ownership_grid = var_to_grid(d["ownership"], (board_size_x, board_size_y))
+                        return sum(
+                            [abs(ownership_grid[s.coords[0]][s.coords[1]]) for s in game.stones if s.player == player]
+                        )
+
+                def is_attachment(move):
+                    if move.is_pass:
+                        return False
+                    attach_opponent_stones = sum(
+                        (move.coords[0] + dx, move.coords[1] + dy, 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, 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
+                    )
+                    return attach_opponent_stones >= 1 and nearby_own_stones == 0
+
+                def is_tenuki(d):
+                    return not d.is_pass and 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, d.coords)) < 5
+                        for node in [cn, cn.parent]
+                    )
+
+                moves_with_settledness = sorted(
+                    [
+                        (
+                            move,
+                            settledness(d, next_player_sign, cn.next_player),
+                            settledness(d, -next_player_sign, cn.player),
+                            is_attachment(move),
+                            is_tenuki(move),
+                            d,
+                        )
+                        for d in candidate_ai_moves
+                        if d["pointsLost"] < ai_settings["max_points_lost"]
+                        and "ownership" in d
+                        and (d["order"] <= 1 or d["visits"] >= ai_settings.get("min_visits", 1))
+                        for move in [Move.from_gtp(d["move"], player=cn.next_player)]
+                        if not (move.is_pass and d["pointsLost"] > 0.75)
+                    ],
+                    key=lambda t: t[5]["pointsLost"]
+                    + ai_settings["attach_penalty"] * t[3]
+                    + ai_settings["tenuki_penalty"] * t[4]
+                    - ai_settings["settled_weight"] * (t[1] + ai_settings["opponent_fac"] * t[2]),
+                )
+                if moves_with_settledness:
+                    cands = [
+                        f"{move.gtp()} ({d['pointsLost']:.1f} pt lost, {d['visits']} 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_mode} strategy. Top 5 Candidates {', '.join(cands)} "
+                    aimove = moves_with_settledness[0][0]
+                else:
+                    raise (Exception("No moves found - are you using an older KataGo with no per-move ownership info?"))
+            else:
+                if ai_mode not in [AI_DEFAULT, AI_HANDICAP, AI_ANTIMIRROR]:
+                    game.katrain.log(f"Unknown AI mode {ai_mode} or policy missing, using default.", OUTPUT_INFO)
+                    ai_thoughts += f"Strategy {ai_mode} not found or unexpected fallback."
+                aimove = top_cand
+                if ai_mode == AI_HANDICAP:
+                    ai_thoughts += f"Handicap strategy found {len(candidate_ai_moves)} moves returned from the engine and chose {aimove.gtp()} as top move. PDA based score {cn.format_score(handicap_analysis['rootInfo']['scoreLead'])} and win rate {cn.format_winrate(handicap_analysis['rootInfo']['winrate'])}"
+                if ai_mode == AI_ANTIMIRROR:
+                    ai_thoughts += f"AntiMirror strategy found {len(candidate_ai_moves)} moves returned from the engine and chose {aimove.gtp()} as top move. antiMirror based score {cn.format_score(antimirror_analysis['rootInfo']['scoreLead'])} and win rate {cn.format_winrate(antimirror_analysis['rootInfo']['winrate'])}"
+                else:
+                    ai_thoughts += f"Default strategy found {len(candidate_ai_moves)} moves returned from the engine and chose {aimove.gtp()} as top move"
+    game.katrain.log(f"AI thoughts: {ai_thoughts}", OUTPUT_DEBUG)
+    played_node = game.play(aimove)
+    played_node.ai_thoughts = ai_thoughts
+    return aimove, played_node

katrain/katrain/core/base_katrain.py

@@ -0,0 +1,96 @@
+# base_katrain.py (진짜 최종 완성본)
+
+import json
+import os
+from configparser import ConfigParser, NoSectionError, NoOptionError
+
+# --- 필요한 모든 부품을 정확하게 import ---
+from katrain.core.constants import *
+from katrain.core.lang import i18n
+from katrain.core.utils import PATHS
+from katrain.core.ai import ai_rank_estimation
+
+class KaTrainBase:
+    """KaTrain의 GUI와 엔진 로직 사이에 공유되는 기본 클래스"""
+
+    def __init__(self, katrain_app, config: ConfigParser):
+        self.katrain = katrain_app
+        self._config = config
+        self.players_info = {}
+        self.debug_level = self.config("general/debug_level", 0, int)
+
+        for bw in "BW":
+            self.players_info[bw] = self.PlayerInfo(bw, self)
+
+    def config(self, key, default=None, vartype=str):
+        try:
+            if "/" in key:
+                parts = key.split("/")
+                section = parts[0]
+                name = "/".join(parts[1:])
+                if vartype == bool:
+                    return self._config.getboolean(section, name)
+                if vartype == int:
+                    return self._config.getint(section, name)
+                return self._config.get(section, name)
+            else: # section만 요청된 경우
+                return dict(self._config.items(key))
+        except (ValueError, KeyError, NoSectionError, NoOptionError):
+            return default if "/" in key else (default or {})
+
+    def save_config(self, sections=None):
+        config_path = os.path.join(PATHS["USER"], "config.json")
+        save_sections = [sections] if isinstance(sections, str) else (sections or self._config.sections())
+
+        output_dict = {}
+        for s in save_sections:
+            if self._config.has_section(s):
+                output_dict[s] = dict(self._config.items(s))
+
+        with open(config_path, "w") as f:
+            json.dump(output_dict, f, indent=4)
+        
+    def log(self, message, level=OUTPUT_INFO):
+        if self.debug_level is not None and level <= self.debug_level:
+            print(message)
+
+    def update_player(self, bw, **kwargs):
+        self.players_info[bw].update(**kwargs)
+        self.save_config("players")
+        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 = {"komi": self.config("game/komi"), "rules": self.config("game/rules")}
+                player_info.calculated_rank = ai_rank_estimation(player_info.player_subtype, settings)
+
+    @property
+    def next_player_info(self):
+        if hasattr(self, 'game') and self.game and self.game.current_node:
+            return self.players_info[self.game.current_node.next_player]
+        return self.players_info["B"]
+
+    @property
+    def last_player_info(self):
+        if hasattr(self, 'game') and self.game and self.game.current_node and self.game.current_node.player:
+            return self.players_info[self.game.current_node.player]
+        return self.players_info["W"]
+
+    class PlayerInfo:
+        def __init__(self, bw, katrain_base):
+            self.bw = bw
+            self.katrain_base = katrain_base
+            self.name = katrain_base.config(f"players/{bw}/name", None)
+            self.player_type = katrain_base.config(f"players/{bw}/type", PLAYER_HUMAN)
+            self.player_subtype = katrain_base.config(f"players/{bw}/subtype", AI_DEFAULT)
+            self.sgf_rank = None
+            self.calculated_rank = None
+            
+        def update(self, **kwargs):
+            for k, v in kwargs.items():
+                if hasattr(self, k):
+                    setattr(self, k, v)
+                    if not self.katrain_base._config.has_section("players"):
+                        self.katrain_base._config.add_section("players")
+                    self.katrain_base._config.set("players", f"{self.bw}/{k}", str(v))

katrain/katrain/core/constants.py

@@ -0,0 +1,272 @@
+PROGRAM_NAME = "KaTrain"
+VERSION = "1.13.0"
+HOMEPAGE = "https://github.com/sanderland/katrain"
+CONFIG_MIN_VERSION = "1.11.0"  # keep config files from this version
+ANALYSIS_FORMAT_VERSION = "1.0"
+DATA_FOLDER = "~/.katrain"
+
+
+OUTPUT_ERROR = -1
+OUTPUT_HONGIK_STDERR = -0.5
+OUTPUT_INFO = 0
+OUTPUT_DEBUG = 1
+OUTPUT_EXTRA_DEBUG = 2
+
+HONGIK_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]
+
+PLAYER_BLACK = "B"
+PLAYER_WHITE = "W"
+
+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_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_STRATEGIES_RECOMMENDED_ORDER = [
+    AI_DEFAULT,
+    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_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)],
+}
+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/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_HONGIK_STDERR, DATA_FOLDER
+from katrain.katrain.core.AI_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 "{",".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/katrain/core/game.py

@@ -0,0 +1,818 @@
+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 hongik.engine_ai import HongikAIEngine
+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 HongikAIEngine.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, HongikAIEngine],
+        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()
+            
+    def get_score(self):
+        if hasattr(self.engine, 'get_score'):  # 우리 엔진에 get_score가 있는지 확인
+            score_data = self.engine.get_score(self.current_node)
+            if score_data:
+                self._score = score_data
+                self.end_result = f'B+R' if score_data['winner'] == 'B' else 'W+R' # 임시 결과 문자열
+                if 'score' in score_data:
+                    self.end_result = f"{score_data['winner']}+{score_data['score']}"
+                return self._score
+        
+        # 만약 우리 엔진에 기능이 없으면 원래 로직을 수행 (안전장치)
+        if self.engine:
+             return self.engine.get_score(self.current_node)
+        return self._score

katrain/katrain/core/game_node.py

@@ -0,0 +1,466 @@
+import base64
+import copy
+import gzip
+import json
+import random
+from typing import Dict, List, Optional, Tuple
+
+from katrain.core.constants import (
+    ANALYSIS_FORMAT_VERSION,
+    PROGRAM_NAME,
+    REPORT_DT,
+    SGF_INTERNAL_COMMENTS_MARKER,
+    SGF_SEPARATOR_MARKER,
+    VERSION,
+    PRIORITY_DEFAULT,
+    ADDITIONAL_MOVE_ORDER,
+)
+from katrain.core.lang import i18n
+from katrain.core.sgf_parser import Move, SGFNode
+from katrain.core.utils import evaluation_class, pack_floats, unpack_floats, var_to_grid
+from katrain.gui.theme import Theme
+
+
+def analysis_dumps(analysis):
+    analysis = copy.deepcopy(analysis)
+    for movedict in analysis["moves"].values():
+        if "ownership" in movedict:  # per-move ownership rarely used
+            del movedict["ownership"]
+    ownership_data = pack_floats(analysis.pop("ownership"))
+    policy_data = pack_floats(analysis.pop("policy"))
+    main_data = json.dumps(analysis).encode("utf-8")
+    return [
+        base64.standard_b64encode(gzip.compress(data)).decode("utf-8")
+        for data in [ownership_data, policy_data, main_data]
+    ]
+
+
+class GameNode(SGFNode):
+    """Represents a single game node, with one or more moves and placements."""
+
+    def __init__(self, parent=None, properties=None, move=None):
+        super().__init__(parent=parent, properties=properties, move=move)
+        self.auto_undo = None  # None = not analyzed. False: not undone (good move). True: undone (bad move)
+        self.played_mistake_sound = None
+        self.ai_thoughts = ""
+        self.note = ""
+        self.move_number = 0
+        self.time_used = 0
+        self.undo_threshold = random.random()  # for fractional undos
+        self.end_state = None
+        self.shortcuts_to = []
+        self.shortcut_from = None
+        self.analysis_from_sgf = None
+        self.clear_analysis()
+
+    def add_shortcut(self, to_node):  # collapses the branch between them
+        nodes = [to_node]
+        while nodes[-1].parent and nodes[-1] != self:  # ensure on path
+            nodes.append(nodes[-1].parent)
+        if nodes[-1] == self and len(nodes) > 2:
+            via = nodes[-2]
+            self.shortcuts_to.append((to_node, via))  # and first child
+            to_node.shortcut_from = self
+
+    def remove_shortcut(self):
+        from_node = self.shortcut_from
+        if from_node:
+            from_node.shortcuts_to = [(m, v) for m, v in from_node.shortcuts_to if m != self]
+            self.shortcut_from = None
+
+    def load_analysis(self):
+        if not self.analysis_from_sgf:
+            return False
+        try:
+            szx, szy = self.root.board_size
+            board_squares = szx * szy
+            version = self.root.get_property("KTV", ANALYSIS_FORMAT_VERSION)
+            if version > ANALYSIS_FORMAT_VERSION:
+                raise ValueError(f"Can not decode analysis data with version {version}, please update {PROGRAM_NAME}")
+            ownership_data, policy_data, main_data, *_ = [
+                gzip.decompress(base64.standard_b64decode(data)) for data in self.analysis_from_sgf
+            ]
+            self.analysis = {
+                **json.loads(main_data),
+                "policy": unpack_floats(policy_data, board_squares + 1),
+                "ownership": unpack_floats(ownership_data, board_squares),
+            }
+            return True
+        except Exception as e:
+            print(f"Error in loading analysis: {e}")
+            return False
+
+    def add_list_property(self, property: str, values: List):
+        if property == "KT":
+            self.analysis_from_sgf = values
+        elif property == "C":
+            comments = [  # strip out all previously auto generated comments
+                c
+                for v in values
+                for c in v.split(SGF_SEPARATOR_MARKER)
+                if c.strip() and SGF_INTERNAL_COMMENTS_MARKER not in c
+            ]
+            self.note = "".join(comments).strip()  # no super call intended, just save as note to be editable
+        else:
+            return super().add_list_property(property, values)
+
+    def clear_analysis(self):
+        self.analysis_visits_requested = 0
+        self.analysis = {"moves": {}, "root": None, "ownership": None, "policy": None, "completed": False}
+
+    def sgf_properties(
+        self,
+        save_comments_player=None,
+        save_comments_class=None,
+        eval_thresholds=None,
+        save_analysis=False,
+        save_marks=False,
+    ):
+        properties = copy.copy(super().sgf_properties())
+        note = self.note.strip()
+        if save_analysis and self.analysis_complete:
+            try:
+                properties["KT"] = analysis_dumps(self.analysis)
+            except Exception as e:
+                print(f"Error in saving analysis: {e}")
+        if self.points_lost and save_comments_class is not None and eval_thresholds is not None:
+            show_class = save_comments_class[evaluation_class(self.points_lost, eval_thresholds)]
+        else:
+            show_class = False
+        comments = properties.get("C", [])
+        if (
+            self.parent
+            and self.parent.analysis_exists
+            and self.analysis_exists
+            and (note or ((save_comments_player or {}).get(self.player, False) and show_class))
+        ):
+            if save_marks:
+                candidate_moves = self.parent.candidate_moves
+                top_x = Move.from_gtp(candidate_moves[0]["move"]).sgf(self.board_size)
+                best_sq = [
+                    Move.from_gtp(d["move"]).sgf(self.board_size)
+                    for d in candidate_moves
+                    if d["pointsLost"] <= 0.5 and d["move"] != "pass" and d["order"] != 0
+                ]
+                if best_sq and "SQ" not in properties:
+                    properties["SQ"] = best_sq
+                if top_x and "MA" not in properties:
+                    properties["MA"] = [top_x]
+            comments.append("\n" + self.comment(sgf=True, interactive=False) + SGF_INTERNAL_COMMENTS_MARKER)
+        if self.is_root:
+            if save_marks:
+                comments = [i18n._("SGF start message") + SGF_INTERNAL_COMMENTS_MARKER + "\n"]
+            else:
+                comments = []
+            comments += [
+                *comments,
+                f"\nSGF generated by {PROGRAM_NAME} {VERSION}{SGF_INTERNAL_COMMENTS_MARKER}\n",
+            ]
+            properties["CA"] = ["UTF-8"]
+            properties["AP"] = [f"{PROGRAM_NAME}:{VERSION}"]
+            properties["KTV"] = [ANALYSIS_FORMAT_VERSION]
+        if self.shortcut_from:
+            properties["KTSF"] = [id(self.shortcut_from)]
+        elif "KTSF" in properties:
+            del properties["KTSF"]
+        if self.shortcuts_to:
+            properties["KTSID"] = [id(self)]
+        elif "KTSID" in properties:
+            del properties["KTSID"]
+        if note:
+            comments.insert(0, f"{self.note}\n")  # user notes at top!
+        if comments:
+            properties["C"] = [SGF_SEPARATOR_MARKER.join(comments).strip("\n")]
+        elif "C" in properties:
+            del properties["C"]
+        return properties
+    
+    @property
+    def board_size(self):
+        # ★★★ 핵심 수정: SZ 속성이 없을 경우 기본값 19를 사용합니다. ★★★
+        sz = self.get_property("SZ", 19)
+        try:
+            if isinstance(sz, str) and ":" in sz:
+                x, y = sz.split(":")
+                return int(x), int(y)
+            return int(sz), int(sz)
+        except (ValueError, TypeError):
+            return 19, 19 # 혹시 모를 다른 에러에도 대비
+        
+    @staticmethod
+    def order_children(children):
+        return sorted(
+            children, key=lambda c: 0.5 if c.auto_undo is None else int(c.auto_undo)
+        )  # analyzed/not undone main, non-teach second, undone last
+
+    # various analysis functions
+    def analyze(
+        self,
+        engine,
+        priority=PRIORITY_DEFAULT,
+        visits=None,
+        ponder=False,
+        time_limit=True,
+        refine_move=None,
+        analyze_fast=False,
+        find_alternatives=False,
+        region_of_interest=None,
+        report_every=REPORT_DT,
+    ):
+        engine.request_analysis(
+            self,
+            callback=lambda result, partial_result: self.set_analysis(
+                result, refine_move, find_alternatives, region_of_interest, partial_result
+            ),
+            priority=priority,
+            visits=visits,
+            ponder=ponder,
+            analyze_fast=analyze_fast,
+            time_limit=time_limit,
+            next_move=refine_move,
+            find_alternatives=find_alternatives,
+            region_of_interest=region_of_interest,
+            report_every=report_every,
+        )
+
+    def update_move_analysis(self, move_analysis, move_gtp):
+        cur = self.analysis["moves"].get(move_gtp)
+        if cur is None:
+            self.analysis["moves"][move_gtp] = {
+                "move": move_gtp,
+                "order": ADDITIONAL_MOVE_ORDER,
+                **move_analysis,
+            }  # some default values for keys missing in rootInfo
+        else:
+            cur["order"] = min(
+                cur["order"], move_analysis.get("order", ADDITIONAL_MOVE_ORDER)
+            )  # parent arriving after child
+            if cur["visits"] < move_analysis["visits"]:
+                cur.update(move_analysis)
+            else:  # prior etc only
+                cur.update({k: v for k, v in move_analysis.items() if k not in cur})
+
+    def set_analysis(
+        self,
+        analysis_json: Dict,
+        refine_move: Optional[Move] = None,
+        additional_moves: bool = False,
+        region_of_interest=None,
+        partial_result: bool = False,
+    ):
+        if refine_move:
+            pvtail = analysis_json["moveInfos"][0]["pv"] if analysis_json["moveInfos"] else []
+            self.update_move_analysis(
+                {"pv": [refine_move.gtp()] + pvtail, **analysis_json["rootInfo"]}, refine_move.gtp()
+            )
+        else:
+            if additional_moves:  # additional moves: old order matters, ignore new order
+                for m in analysis_json["moveInfos"]:
+                    del m["order"]
+            elif refine_move is None:  # normal update: old moves to end, new order matters. also for region?
+                for move_dict in self.analysis["moves"].values():
+                    move_dict["order"] = ADDITIONAL_MOVE_ORDER  # old moves to end
+            for move_analysis in analysis_json["moveInfos"]:
+                self.update_move_analysis(move_analysis, move_analysis["move"])
+            self.analysis["ownership"] = analysis_json.get("ownership")
+            self.analysis["policy"] = analysis_json.get("policy")
+            if not additional_moves and not region_of_interest:
+                self.analysis["root"] = analysis_json["rootInfo"]
+                if self.parent and self.move:
+                    analysis_json["rootInfo"]["pv"] = [self.move.gtp()] + (
+                        analysis_json["moveInfos"][0]["pv"] if analysis_json["moveInfos"] else []
+                    )
+                    self.parent.update_move_analysis(
+                        analysis_json["rootInfo"], self.move.gtp()
+                    )  # update analysis in parent for consistency
+            is_normal_query = refine_move is None and not additional_moves
+            self.analysis["completed"] = self.analysis["completed"] or (is_normal_query and not partial_result)
+
+    @property
+    def ownership(self):
+        return self.analysis.get("ownership")
+
+    @property
+    def policy(self):
+        return self.analysis.get("policy")
+
+    @property
+    def analysis_exists(self):
+        return self.analysis.get("root") is not None
+
+    @property
+    def analysis_complete(self):
+        return self.analysis["completed"] and self.analysis["root"] is not None
+
+    @property
+    def root_visits(self):
+        return ((self.analysis or {}).get("root") or {}).get("visits", 0)
+
+    @property
+    def score(self) -> Optional[float]:
+        if self.analysis_exists:
+            return self.analysis["root"].get("scoreLead")
+
+    def format_score(self, score=None):
+        score = score or self.score
+        if score is not None:
+            return f"{'B' if score >= 0 else 'W'}+{abs(score):.1f}"
+
+    @property
+    def winrate(self) -> Optional[float]:
+        if self.analysis_exists:
+            return self.analysis["root"].get("winrate")
+
+    def format_winrate(self, win_rate=None):
+        win_rate = win_rate or self.winrate
+        if win_rate is not None:
+            return f"{'B' if win_rate > 0.5 else 'W'} {max(win_rate,1-win_rate):.1%}"
+
+    def move_policy_stats(self) -> Tuple[Optional[int], float, List]:
+        single_move = self.move
+        if single_move and self.parent:
+            policy_ranking = self.parent.policy_ranking
+            if policy_ranking:
+                for ix, (p, m) in enumerate(policy_ranking):
+                    if m == single_move:
+                        return ix + 1, p, policy_ranking
+        return None, 0.0, []
+
+    def make_pv(self, player, pv, interactive):
+        pvtext = f"{player}{' '.join(pv)}"
+        if interactive:
+            pvtext = f"[u][ref={pvtext}][color={Theme.INFO_PV_COLOR}]{pvtext}[/color][/ref][/u]"
+        return pvtext
+
+    def comment(self, sgf=False, teach=False, details=False, interactive=True):
+        single_move = self.move
+        if not self.parent or not single_move:  # root
+            if self.root:
+                rules = self.get_property("RU", "Japanese")
+                if isinstance(rules, str):  # else katago dict
+                    rules = i18n._(rules.lower())
+                return f"{i18n._('komi')}: {self.komi:.1f}\n{i18n._('ruleset')}: {rules}\n"
+            return ""
+
+        text = i18n._("move").format(number=self.depth) + f": {single_move.player} {single_move.gtp()}\n"
+        if self.analysis_exists:
+            score = self.score
+            if sgf:
+                text += i18n._("Info:score").format(score=self.format_score(score)) + "\n"
+                text += i18n._("Info:winrate").format(winrate=self.format_winrate()) + "\n"
+            if self.parent and self.parent.analysis_exists:
+                previous_top_move = self.parent.candidate_moves[0]
+                if sgf or details:
+                    if previous_top_move["move"] != single_move.gtp():
+                        points_lost = self.points_lost
+                        if sgf and points_lost > 0.5:
+                            text += i18n._("Info:point loss").format(points_lost=points_lost) + "\n"
+                        top_move = previous_top_move["move"]
+                        score = self.format_score(previous_top_move["scoreLead"])
+                        text += (
+                            i18n._("Info:top move").format(
+                                top_move=top_move,
+                                score=score,
+                            )
+                            + "\n"
+                        )
+                    else:
+                        text += i18n._("Info:best move") + "\n"
+                    if previous_top_move.get("pv") and (sgf or details):
+                        pv = self.make_pv(single_move.player, previous_top_move["pv"], interactive)
+                        text += i18n._("Info:PV").format(pv=pv) + "\n"
+                if sgf or details or teach:
+                    currmove_pol_rank, currmove_pol_prob, policy_ranking = self.move_policy_stats()
+                    if currmove_pol_rank is not None:
+                        policy_rank_msg = i18n._("Info:policy rank")
+                        text += policy_rank_msg.format(rank=currmove_pol_rank, probability=currmove_pol_prob) + "\n"
+                    if currmove_pol_rank != 1 and policy_ranking and (sgf or details):
+                        policy_best_msg = i18n._("Info:policy best")
+                        pol_move, pol_prob = policy_ranking[0][1].gtp(), policy_ranking[0][0]
+                        text += policy_best_msg.format(move=pol_move, probability=pol_prob) + "\n"
+            if self.auto_undo and sgf:
+                text += i18n._("Info:teaching undo") + "\n"
+                top_pv = self.analysis_exists and self.candidate_moves[0].get("pv")
+                if top_pv:
+                    text += i18n._("Info:undo predicted PV").format(pv=f"{self.next_player}{' '.join(top_pv)}") + "\n"
+        else:
+            text = i18n._("No analysis available") if sgf else i18n._("Analyzing move...")
+
+        if self.ai_thoughts and (sgf or details):
+            text += "\n" + i18n._("Info:AI thoughts").format(thoughts=self.ai_thoughts)
+
+        if "C" in self.properties:
+            text += "\n[u]SGF Comments:[/u]\n" + "\n".join(self.properties["C"])
+
+        return text
+
+    @property
+    def points_lost(self) -> Optional[float]:
+        single_move = self.move
+        if single_move and self.parent and self.analysis_exists and self.parent.analysis_exists:
+            parent_score = self.parent.score
+            score = self.score
+            return self.player_sign(single_move.player) * (parent_score - score)
+
+    @property
+    def parent_realized_points_lost(self) -> Optional[float]:
+        single_move = self.move
+        if (
+            single_move
+            and self.parent
+            and self.parent.parent
+            and self.analysis_exists
+            and self.parent.parent.analysis_exists
+        ):
+            parent_parent_score = self.parent.parent.score
+            score = self.score
+            return self.player_sign(single_move.player) * (score - parent_parent_score)
+
+    @staticmethod
+    def player_sign(player):
+        return {"B": 1, "W": -1, None: 0}[player]
+
+    @property
+    def candidate_moves(self) -> List[Dict]:
+        if not self.analysis_exists:
+            return []
+        if not self.analysis["moves"]:
+            polmoves = self.policy_ranking
+            top_polmove = polmoves[0][1] if polmoves else Move(None)  # if no info at all, pass
+            return [
+                {
+                    **self.analysis["root"],
+                    "pointsLost": 0,
+                    "winrateLost": 0,
+                    "order": 0,
+                    "move": top_polmove.gtp(),
+                    "pv": [top_polmove.gtp()],
+                }
+            ]  # single visit -> go by policy/root
+
+        root_score = self.analysis["root"]["scoreLead"]
+        root_winrate = self.analysis["root"]["winrate"]
+        move_dicts = list(self.analysis["moves"].values())  # prevent incoming analysis from causing crash
+        top_move = [d for d in move_dicts if d["order"] == 0]
+        top_score_lead = top_move[0]["scoreLead"] if top_move else root_score
+        return sorted(
+            [
+                {
+                    "pointsLost": self.player_sign(self.next_player) * (root_score - d["scoreLead"]),
+                    "relativePointsLost": self.player_sign(self.next_player) * (top_score_lead - d["scoreLead"]),
+                    "winrateLost": self.player_sign(self.next_player) * (root_winrate - d["winrate"]),
+                    **d,
+                }
+                for d in move_dicts
+            ],
+            key=lambda d: (d["order"], d["pointsLost"]),
+        )
+
+    @property
+    def policy_ranking(self) -> Optional[List[Tuple[float, Move]]]:  # return moves from highest policy value to lowest
+        if self.policy:
+            szx, szy = self.board_size
+            policy_grid = var_to_grid(self.policy, size=(szx, szy))
+            moves = [(policy_grid[y][x], Move((x, y), player=self.next_player)) for x in range(szx) for y in range(szy)]
+            moves.append((self.policy[-1], Move(None, player=self.next_player)))
+            return sorted(moves, key=lambda mp: -mp[0])

katrain/katrain/core/lang.py

@@ -0,0 +1,89 @@
+import gettext
+import os
+import sys
+
+from kivy._event import Observable
+
+from katrain.core.utils import find_package_resource
+from katrain.gui.theme import Theme
+
+
+class Lang(Observable):
+    observers = []
+    callbacks = []
+    FONTS = {"jp": "NotoSansJP-Regular.otf", "tr": "NotoSans-Regular.ttf"}
+
+    def __init__(self, lang):
+        super(Lang, self).__init__()
+        self.lang = None
+        self.switch_lang(lang)
+
+    def _(self, text):
+        return self.ugettext(text)
+
+    def set_widget_font(self, widget):
+        widget.font_name = self.font_name
+        for sub_widget in [getattr(widget, "_hint_lbl", None), getattr(widget, "_msg_lbl", None)]:  # MDText
+            if sub_widget:
+                sub_widget.font_name = self.font_name
+
+    def fbind(self, name, func, *args):
+        if name == "_":
+            widget, property, *_ = args[0]
+            self.observers.append((widget, func, args))
+            try:
+                self.set_widget_font(widget)
+            except Exception as e:
+                print(e)
+                # pass
+        else:
+            return super(Lang, self).fbind(name, func, *args)
+
+    def funbind(self, name, func, *args):
+        if name == "_":
+            widget, *_ = args[0]
+            key = (widget, func, args)
+            if key in self.observers:
+                self.observers.remove(key)
+        else:
+            return super(Lang, self).funbind(name, func, *args)
+
+    def switch_lang(self, lang):
+        if lang == self.lang:
+            return
+        # get the right locales directory, and instantiate a gettext
+        self.lang = lang
+        self.font_name = self.FONTS.get(lang) or Theme.DEFAULT_FONT
+        i18n_dir, _ = os.path.split(find_package_resource("katrain/i18n/__init__.py"))
+        locale_dir = os.path.join(i18n_dir, "locales")
+        locales = gettext.translation("katrain", locale_dir, languages=[lang, DEFAULT_LANGUAGE])
+        self.ugettext = locales.gettext
+
+        # update all the kv rules attached to this text
+        for widget, func, args in self.observers:
+            try:
+                func(args[0], None, None)
+                self.set_widget_font(widget)
+            except ReferenceError:
+                pass  # proxy no longer exists
+            except Exception as e:
+                print("Error in switching languages", e)
+        for cb in self.callbacks:
+            try:
+                cb(self)
+            except Exception as e:
+                print(f"Failed callback on language change: {e}", file=sys.stderr)
+
+
+DEFAULT_LANGUAGE = "en"
+i18n = Lang(DEFAULT_LANGUAGE)
+
+
+def rank_label(rank):
+    if rank is None:
+        return "??k"
+
+    if rank >= 0.5:
+        return f"{rank:.0f}{i18n._('strength:dan')}"
+    else:
+        return f"{1-rank:.0f}{i18n._('strength:kyu')}"

katrain/katrain/core/sgf_parser.py

@@ -0,0 +1,714 @@
+import copy
+import chardet
+import math
+import re
+from collections import defaultdict
+from typing import Any, Dict, List, Optional, Tuple
+
+
+class ParseError(Exception):
+    """Exception raised on a parse error"""
+
+    pass
+
+
+class Move:
+    GTP_COORD = list("ABCDEFGHJKLMNOPQRSTUVWXYZ") + [
+        xa + c for xa in "ABCDEFGH" for c in "ABCDEFGHJKLMNOPQRSTUVWXYZ"
+    ]  # board size 52+ support
+    PLAYERS = "BW"
+    SGF_COORD = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ".lower()) + list("ABCDEFGHIJKLMNOPQRSTUVWXYZ")  # sgf goes to 52
+
+    @classmethod
+    def from_gtp(cls, gtp_coords, player="B"):
+        """Initialize a move from GTP coordinates and player"""
+        if "pass" in gtp_coords.lower():
+            return cls(coords=None, player=player)
+        match = re.match(r"([A-Z]+)(\d+)", gtp_coords)
+        return cls(coords=(Move.GTP_COORD.index(match[1]), int(match[2]) - 1), player=player)
+
+    @classmethod
+    def from_sgf(cls, sgf_coords, board_size, player="B"):
+        """Initialize a move from SGF coordinates and player"""
+        if sgf_coords == "" or (
+            sgf_coords == "tt" and board_size[0] <= 19 and board_size[1] <= 19
+        ):  # [tt] can be used as "pass" for <= 19x19 board
+            return cls(coords=None, player=player)
+        return cls(
+            coords=(Move.SGF_COORD.index(sgf_coords[0]), board_size[1] - Move.SGF_COORD.index(sgf_coords[1]) - 1),
+            player=player,
+        )
+
+    def __init__(self, coords: Optional[Tuple[int, int]] = None, player: str = "B"):
+        """Initialize a move from zero-based coordinates and player"""
+        self.player = player
+        self.coords = coords
+
+    def __repr__(self):
+        return f"Move({self.player or ''}{self.gtp()})"
+
+    def __eq__(self, other):
+        return self.coords == other.coords and self.player == other.player
+
+    def __hash__(self):
+        return hash((self.coords, self.player))
+
+    def gtp(self):
+        """Returns GTP coordinates of the move"""
+        if self.is_pass:
+            return "pass"
+        return Move.GTP_COORD[self.coords[0]] + str(self.coords[1] + 1)
+
+    def sgf(self, board_size):
+        """Returns SGF coordinates of the move"""
+        if self.is_pass:
+            return ""
+        return f"{Move.SGF_COORD[self.coords[0]]}{Move.SGF_COORD[board_size[1] - self.coords[1] - 1]}"
+
+    @property
+    def is_pass(self):
+        """Returns True if the move is a pass"""
+        return self.coords is None
+
+    @staticmethod
+    def opponent_player(player):
+        """Returns the opposing player, i.e. W <-> B"""
+        return "W" if player == "B" else "B"
+
+    @property
+    def opponent(self):
+        """Returns the opposing player, i.e. W <-> B"""
+        return self.opponent_player(self.player)
+
+
+class SGFNode:
+    def __init__(self, parent=None, properties=None, move=None):
+        self.children = []
+        self.properties = defaultdict(list)
+        if properties:
+            for k, v in properties.items():
+                self.set_property(k, v)
+        self.parent = parent
+        if self.parent:
+            self.parent.children.append(self)
+        if parent and move:
+            self.set_property(move.player, move.sgf(self.board_size))
+        self._clear_cache()
+
+    def _clear_cache(self):
+        self.moves_cache = None
+
+    def __repr__(self):
+        return f"SGFNode({dict(self.properties)})"
+
+    def sgf_properties(self, **xargs) -> Dict:
+        """For hooking into in a subclass and overriding/formatting any additional properties to be output."""
+        return copy.deepcopy(self.properties)
+
+    @staticmethod
+    def order_children(children):
+        """For hooking into in a subclass and overriding branch order."""
+        return children
+
+    @property
+    def ordered_children(self):
+        return self.order_children(self.children)
+
+    @staticmethod
+    def _escape_value(value):
+        return re.sub(r"([\]\\])", r"\\\1", value) if isinstance(value, str) else value  # escape \ and ]
+
+    @staticmethod
+    def _unescape_value(value):
+        return re.sub(r"\\([\]\\])", r"\1", value) if isinstance(value, str) else value  # unescape \ and ]
+
+    def sgf(self, **xargs) -> str:
+        """Generates an SGF, calling sgf_properties on each node with the given xargs, so it can filter relevant properties if needed."""
+
+        def node_sgf_str(node):
+            return ";" + "".join(
+                [
+                    prop + "".join(f"[{self._escape_value(v)}]" for v in values)
+                    for prop, values in node.sgf_properties(**xargs).items()
+                    if values
+                ]
+            )
+
+        stack = [")", self, "("]
+        sgf_str = ""
+        while stack:
+            item = stack.pop()
+            if isinstance(item, str):
+                sgf_str += item
+            else:
+                sgf_str += node_sgf_str(item)
+                if len(item.children) == 1:
+                    stack.append(item.children[0])
+                elif item.children:
+                    stack += sum([[")", c, "("] for c in item.ordered_children[::-1]], [])
+        return sgf_str
+
+    def add_list_property(self, property: str, values: List):
+        """Add some values to the property list."""
+        # SiZe[19] ==> SZ[19] etc. for old SGF
+        normalized_property = re.sub("[a-z]", "", property)
+        self._clear_cache()
+        self.properties[normalized_property] += values
+
+    def get_list_property(self, property, default=None) -> Any:
+        """Get the list of values for a property."""
+        return self.properties.get(property, default)
+
+    def set_property(self, property: str, value: Any):
+        """Add some values to the property. If not a list, it will be made into a single-value list."""
+        if not isinstance(value, list):
+            value = [value]
+        self._clear_cache()
+        self.properties[property] = value
+
+    def get_property(self, property, default=None) -> Any:
+        """Get the first value of the property, typically when exactly one is expected."""
+        return self.properties.get(property, [default])[0]
+
+    def clear_property(self, property) -> Any:
+        """Removes property if it exists."""
+        return self.properties.pop(property, None)
+
+    @property
+    def parent(self) -> Optional["SGFNode"]:
+        """Returns the parent node"""
+        return self._parent
+
+    @parent.setter
+    def parent(self, parent_node):
+        self._parent = parent_node
+        self._root = None
+        self._depth = None
+
+    @property
+    def root(self) -> "SGFNode":
+        """Returns the root of the tree, cached for speed"""
+        if self._root is None:
+            self._root = self.parent.root if self.parent else self
+        return self._root
+
+    @property
+    def depth(self) -> int:
+        """Returns the depth of this node, where root is 0, cached for speed"""
+        if self._depth is None:
+            moves = self.moves
+            if self.is_root:
+                self._depth = 0
+            else:  # no increase on placements etc
+                self._depth = self.parent.depth + len(moves)
+        return self._depth
+
+    @property
+    def board_size(self) -> Tuple[int, int]:
+        """Retrieves the root's SZ property, or 19 if missing. Parses it, and returns board size as a tuple x,y"""
+        size = str(self.root.get_property("SZ", "19"))
+        if ":" in size:
+            x, y = map(int, size.split(":"))
+        else:
+            x = int(size)
+            y = x
+        return x, y
+
+    @property
+    def komi(self) -> float:
+        """Retrieves the root's KM property, or 6.5 if missing"""
+        try:
+            km_value = self.root.get_property("KM")
+            km = float(km_value or 6.5)
+        except ValueError:
+            km = 6.5
+
+        return km
+
+    @property
+    def handicap(self) -> int:
+        try:
+            return int(self.root.get_property("HA", 0))
+        except ValueError:
+            return 0
+
+    @property
+    def ruleset(self) -> str:
+        """Retrieves the root's RU property, or 'japanese' if missing"""
+        return self.root.get_property("RU", "japanese")
+
+    @property
+    def moves(self) -> List[Move]:
+        """Returns all moves in the node - typically 'move' will be better."""
+        if self.moves_cache is None:
+            self.moves_cache = [
+                Move.from_sgf(move, player=pl, board_size=self.board_size)
+                for pl in Move.PLAYERS
+                for move in self.get_list_property(pl, [])
+            ]
+        return self.moves_cache
+
+    def _expanded_placements(self, player):
+        sgf_pl = player if player is not None else "E"  # AE
+        placements = self.get_list_property("A" + sgf_pl, [])
+        if not placements:
+            return []
+        to_be_expanded = [p for p in placements if ":" in p]
+        board_size = self.board_size
+        if to_be_expanded:
+            coords = {
+                Move.from_sgf(sgf_coord, player=player, board_size=board_size)
+                for sgf_coord in placements
+                if ":" not in sgf_coord
+            }
+            for p in to_be_expanded:
+                from_coord, to_coord = [Move.from_sgf(c, board_size=board_size) for c in p.split(":")[:2]]
+                for x in range(from_coord.coords[0], to_coord.coords[0] + 1):
+                    for y in range(to_coord.coords[1], from_coord.coords[1] + 1):  # sgf upside dn
+                        if 0 <= x < board_size[0] and 0 <= y < board_size[1]:
+                            coords.add(Move((x, y), player=player))
+            return list(coords)
+        else:
+            return [Move.from_sgf(sgf_coord, player=player, board_size=board_size) for sgf_coord in placements]
+
+    @property
+    def placements(self) -> List[Move]:
+        """Returns all placements (AB/AW) in the node."""
+        return [coord for pl in Move.PLAYERS for coord in self._expanded_placements(pl)]
+
+    @property
+    def clear_placements(self) -> List[Move]:
+        """Returns all AE clear square commends in the node."""
+        return self._expanded_placements(None)
+
+    @property
+    def move_with_placements(self) -> List[Move]:
+        """Returns all moves (B/W) and placements (AB/AW) in the node."""
+        return self.placements + self.moves
+
+    @property
+    def move(self) -> Optional[Move]:
+        """Returns the single move for the node if one exists, or None if no moves (or multiple ones) exist."""
+        moves = self.moves
+        if len(moves) == 1:
+            return moves[0]
+
+    @property
+    def is_root(self) -> bool:
+        """Returns true if node is a root"""
+        return self.parent is None
+
+    @property
+    def is_pass(self) -> bool:
+        """Returns true if associated move is pass"""
+        return not self.placements and self.move and self.move.is_pass
+
+    @property
+    def empty(self) -> bool:
+        """Returns true if node has no children or properties"""
+        return not self.children and not self.properties
+
+    @property
+    def nodes_in_tree(self) -> List:
+        """Returns all nodes in the tree rooted at this node"""
+        stack = [self]
+        nodes = []
+        while stack:
+            item = stack.pop(0)
+            nodes.append(item)
+            stack += item.children
+        return nodes
+
+    @property
+    def nodes_from_root(self) -> List:
+        """Returns all nodes from the root up to this node, i.e. the moves played in the current branch of the game"""
+        nodes = [self]
+        n = self
+        while not n.is_root:
+            n = n.parent
+            nodes.append(n)
+        return nodes[::-1]
+
+    def play(self, move) -> "SGFNode":
+        """Either find an existing child or create a new one with the given move."""
+        for c in self.children:
+            if c.move and c.move == move:
+                return c
+        return self.__class__(parent=self, move=move)
+
+    @property
+    def initial_player(self):  # player for first node
+        root = self.root
+        if "PL" in root.properties:  # explicit
+            return "B" if self.root.get_property("PL").upper().strip() == "B" else "W"
+        elif root.children:  # child exist, use it if not placement
+            for child in root.children:
+                for color in "BW":
+                    if color in child.properties:
+                        return color
+        # b move or setup with only black moves like handicap
+        if "AB" in self.properties and "AW" not in self.properties:
+            return "W"
+        else:
+            return "B"
+
+    @property
+    def next_player(self):
+        """Returns player to move"""
+        if self.is_root:
+            return self.initial_player
+        elif "B" in self.properties:
+            return "W"
+        elif "W" in self.properties:
+            return "B"
+        else:  # only placements, find a parent node with a real move. TODO: better placement support
+            return self.parent.next_player
+
+    @property
+    def player(self):
+        """Returns player that moved last. nb root is considered white played if no handicap stones are placed"""
+        if "B" in self.properties or ("AB" in self.properties and "W" not in self.properties):
+            return "B"
+        else:
+            return "W"
+
+    def place_handicap_stones(self, n_handicaps, tygem=False):
+        board_size_x, board_size_y = self.board_size
+        if min(board_size_x, board_size_y) < 3:
+            return  # No
+        near_x = 3 if board_size_x >= 13 else min(2, board_size_x - 1)
+        near_y = 3 if board_size_y >= 13 else min(2, board_size_y - 1)
+        far_x = board_size_x - 1 - near_x
+        far_y = board_size_y - 1 - near_y
+        middle_x = board_size_x // 2  # what for even sizes?
+        middle_y = board_size_y // 2
+        if n_handicaps > 9 and board_size_x == board_size_y:
+            stones_per_row = math.ceil(math.sqrt(n_handicaps))
+            spacing = (far_x - near_x) / (stones_per_row - 1)
+            if spacing < near_x:
+                far_x += 1
+                near_x -= 1
+                spacing = (far_x - near_x) / (stones_per_row - 1)
+            coords = list({math.floor(0.5 + near_x + i * spacing) for i in range(stones_per_row)})
+            stones = sorted(
+                [(x, y) for x in coords for y in coords],
+                key=lambda xy: -((xy[0] - (board_size_x - 1) / 2) ** 2 + (xy[1] - (board_size_y - 1) / 2) ** 2),
+            )
+        else:  # max 9
+            stones = [(far_x, far_y), (near_x, near_y), (far_x, near_y), (near_x, far_y)]
+            if n_handicaps % 2 == 1:
+                stones.append((middle_x, middle_y))
+            stones += [(near_x, middle_y), (far_x, middle_y), (middle_x, near_y), (middle_x, far_y)]
+        if tygem:
+            stones[2], stones[3] = stones[3], stones[2]
+        self.set_property(
+            "AB", list({Move(stone).sgf(board_size=(board_size_x, board_size_y)) for stone in stones[:n_handicaps]})
+        )
+
+
+class SGF:
+    DEFAULT_ENCODING = "UTF-8"
+
+    _NODE_CLASS = SGFNode  # Class used for SGF Nodes, can change this to something that inherits from SGFNode
+    # https://xkcd.com/1171/
+    SGFPROP_PAT = re.compile(r"\s*(?:\(|\)|;|(\w+)((\s*\[([^\]\\]|\\.)*\])+))", flags=re.DOTALL)
+    SGF_PAT = re.compile(r"\(;.*\)", flags=re.DOTALL)
+
+    @classmethod
+    def parse_sgf(cls, input_str) -> SGFNode:
+        """Parse a string as SGF."""
+        match = re.search(cls.SGF_PAT, input_str)
+        clipped_str = match.group() if match else input_str
+        root = cls(clipped_str).root
+        # Fix weird FoxGo server KM values
+        if "foxwq" in root.get_list_property("AP", []):
+            if int(root.get_property("HA", 0)) >= 1:
+                corrected_komi = 0.5
+            elif root.get_property("RU").lower() in ["chinese", "cn"]:
+                corrected_komi = 7.5
+            else:
+                corrected_komi = 6.5
+            root.set_property("KM", corrected_komi)
+        return root
+
+    @classmethod
+    def parse_file(cls, filename, encoding=None) -> SGFNode:
+        is_gib = filename.lower().endswith(".gib")
+        is_ngf = filename.lower().endswith(".ngf")
+
+        """Parse a file as SGF, encoding will be detected if not given."""
+        with open(filename, "rb") as f:
+            bin_contents = f.read()
+            if not encoding:
+                if is_gib or is_ngf or b"AP[foxwq]" in bin_contents:
+                    encoding = "utf8"
+                else:  # sgf
+                    match = re.search(rb"CA\[(.*?)\]", bin_contents)
+                    if match:
+                        encoding = match[1].decode("ascii", errors="ignore")
+                    else:
+                        encoding = chardet.detect(bin_contents[:300])["encoding"]
+                        # workaround for some compatibility issues for Windows-1252 and GB2312 encodings
+                        if encoding == "Windows-1252" or encoding == "GB2312":
+                            encoding = "GBK"
+            try:
+                decoded = bin_contents.decode(encoding=encoding, errors="ignore")
+            except LookupError:
+                decoded = bin_contents.decode(encoding=cls.DEFAULT_ENCODING, errors="ignore")
+            if is_ngf:
+                return cls.parse_ngf(decoded)
+            if is_gib:
+                return cls.parse_gib(decoded)
+            else:  # sgf
+                return cls.parse_sgf(decoded)
+
+    def __init__(self, contents):
+        self.contents = contents
+        try:
+            self.ix = self.contents.index("(") + 1
+        except ValueError:
+            raise ParseError(f"Parse error: Expected '(' at start, found {self.contents[:50]}")
+        self.root = self._NODE_CLASS()
+        self._parse_branch(self.root)
+
+    def _parse_branch(self, current_move: SGFNode):
+        while self.ix < len(self.contents):
+            match = re.match(self.SGFPROP_PAT, self.contents[self.ix :])
+            if not match:
+                break
+            self.ix += len(match[0])
+            matched_item = match[0].strip()
+            if matched_item == ")":
+                return
+            if matched_item == "(":
+                self._parse_branch(self._NODE_CLASS(parent=current_move))
+            elif matched_item == ";":
+                # ignore ;) for old SGF
+                useless = self.ix < len(self.contents) and self.contents[self.ix :].strip() == ")"
+                # ignore ; that generate empty nodes
+                if not (current_move.empty or useless):
+                    current_move = self._NODE_CLASS(parent=current_move)
+            else:
+                property, value = match[1], match[2].strip()[1:-1]
+                values = re.split(r"\]\s*\[", value)
+                current_move.add_list_property(property, [SGFNode._unescape_value(v) for v in values])
+        if self.ix < len(self.contents):
+            raise ParseError(f"Parse Error: unexpected character at {self.contents[self.ix:self.ix+25]}")
+        raise ParseError("Parse Error: expected ')' at end of input.")
+
+    # NGF parser adapted from https://github.com/fohristiwhirl/gofish/
+    @classmethod
+    def parse_ngf(cls, ngf):
+        ngf = ngf.strip()
+        lines = ngf.split("\n")
+
+        try:
+            boardsize = int(lines[1])
+            handicap = int(lines[5])
+            pw = lines[2].split()[0]
+            pb = lines[3].split()[0]
+            rawdate = lines[8][0:8]
+            komi = float(lines[7])
+
+            if handicap == 0 and int(komi) == komi:
+                komi += 0.5
+
+        except (IndexError, ValueError):
+            boardsize = 19
+            handicap = 0
+            pw = ""
+            pb = ""
+            rawdate = ""
+            komi = 0
+
+        re = ""
+        try:
+            if "hite win" in lines[10]:
+                re = "W+"
+            elif "lack win" in lines[10]:
+                re = "B+"
+        except IndexError:
+            pass
+
+        if handicap < 0 or handicap > 9:
+            raise ParseError(f"Handicap {handicap} out of range")
+
+        root = cls._NODE_CLASS()
+        node = root
+
+        # Set root values...
+
+        root.set_property("SZ", boardsize)
+
+        if handicap >= 2:
+            root.set_property("HA", handicap)
+            root.place_handicap_stones(handicap, tygem=True)  # While this isn't Tygem, it uses the same layout
+
+        if komi:
+            root.set_property("KM", komi)
+
+        if len(rawdate) == 8:
+            ok = True
+            for n in range(8):
+                if rawdate[n] not in "0123456789":
+                    ok = False
+            if ok:
+                date = rawdate[0:4] + "-" + rawdate[4:6] + "-" + rawdate[6:8]
+                root.set_property("DT", date)
+
+        if pw:
+            root.set_property("PW", pw)
+        if pb:
+            root.set_property("PB", pb)
+
+        if re:
+            root.set_property("RE", re)
+
+        # Main parser...
+
+        for line in lines:
+            line = line.strip().upper()
+
+            if len(line) >= 7:
+                if line[0:2] == "PM":
+                    if line[4] in ["B", "W"]:
+
+                        # move format is similar to SGF, but uppercase and out-by-1
+
+                        key = line[4]
+                        raw_move = line[5:7].lower()
+                        if raw_move == "aa":
+                            value = "" # pass
+                        else:
+                            value = chr(ord(raw_move[0]) - 1) + chr(ord(raw_move[1]) - 1)
+
+                        node = cls._NODE_CLASS(parent=node)
+                        node.set_property(key, value)
+
+        if len(root.children) == 0:  # We'll assume we failed in this case
+            raise ParseError("Found no moves")
+
+        return root
+
+    # GIB parser adapted from https://github.com/fohristiwhirl/gofish/
+    @classmethod
+    def parse_gib(cls, gib):
+        def parse_player_name(raw):
+            name = raw
+            rank = ""
+            foo = raw.split("(")
+            if len(foo) == 2:
+                if foo[1][-1] == ")":
+                    name = foo[0].strip()
+                    rank = foo[1][0:-1]
+            return name, rank
+
+        def gib_make_result(grlt, zipsu):
+            easycases = {3: "B+R", 4: "W+R", 7: "B+T", 8: "W+T"}
+
+            if grlt in easycases:
+                return easycases[grlt]
+
+            if grlt in [0, 1]:
+                return "{}+{}".format("B" if grlt == 0 else "W", zipsu / 10)
+
+            return ""
+
+        def gib_get_result(line, grlt_regex, zipsu_regex):
+            try:
+                grlt = int(re.search(grlt_regex, line).group(1))
+                zipsu = int(re.search(zipsu_regex, line).group(1))
+            except:  # noqa E722
+                return ""
+            return gib_make_result(grlt, zipsu)
+
+        root = cls._NODE_CLASS()
+        node = root
+
+        lines = gib.split("\n")
+        for line in lines:
+            line = line.strip()
+            if line.startswith("\\[GAMEBLACKNAME=") and line.endswith("\\]"):
+                s = line[16:-2]
+                name, rank = parse_player_name(s)
+                if name:
+                    root.set_property("PB", name)
+                if rank:
+                    root.set_property("BR", rank)
+
+            if line.startswith("\\[GAMEWHITENAME=") and line.endswith("\\]"):
+                s = line[16:-2]
+                name, rank = parse_player_name(s)
+                if name:
+                    root.set_property("PW", name)
+                if rank:
+                    root.set_property("WR", rank)
+
+            if line.startswith("\\[GAMEINFOMAIN="):
+                result = gib_get_result(line, r"GRLT:(\d+),", r"ZIPSU:(\d+),")
+                if result:
+                    root.set_property("RE", result)
+                    try:
+                        komi = int(re.search(r"GONGJE:(\d+),", line).group(1)) / 10
+                        if komi:
+                            root.set_property("KM", komi)
+                    except:  # noqa E722
+                        pass
+
+            if line.startswith("\\[GAMETAG="):
+                if "DT" not in root.properties:
+                    try:
+                        match = re.search(r"C(\d\d\d\d):(\d\d):(\d\d)", line)
+                        date = "{}-{}-{}".format(match.group(1), match.group(2), match.group(3))
+                        root.set_property("DT", date)
+                    except:  # noqa E722
+                        pass
+
+                if "RE" not in root.properties:
+                    result = gib_get_result(line, r",W(\d+),", r",Z(\d+),")
+                    if result:
+                        root.set_property("RE", result)
+
+                if "KM" not in root.properties:
+                    try:
+                        komi = int(re.search(r",G(\d+),", line).group(1)) / 10
+                        if komi:
+                            root.set_property("KM", komi)
+                    except:  # noqa E722
+                        pass
+
+            if line[0:3] == "INI":
+                if node is not root:
+                    raise ParseError("Node is not root")
+                setup = line.split()
+                try:
+                    handicap = int(setup[3])
+                except ParseError:
+                    continue
+
+                if handicap < 0 or handicap > 9:
+                    raise ParseError(f"Handicap {handicap} out of range")
+
+                if handicap >= 2:
+                    root.set_property("HA", handicap)
+                    root.place_handicap_stones(handicap, tygem=True)
+
+            if line[0:3] == "STO":
+                move = line.split()
+                key = "B" if move[3] == "1" else "W"
+                try:
+                    x = int(move[4])
+                    y = 18 - int(move[5])
+                    if not (0 <= x < 19 and 0 <= y < 19):
+                        raise ParseError(f"Coordinates for move ({x},{y}) out of range on line {line}")
+                    value = Move(coords=(x, y)).sgf(board_size=(19, 19))
+                except IndexError:
+                    continue
+
+                node = cls._NODE_CLASS(parent=node)
+                node.set_property(key, value)
+
+        if len(root.children) == 0:  # We'll assume we failed in this case
+            raise ParseError("No valid nodes found")
+
+        return root

katrain/katrain/core/tsumego_frame.py

@@ -0,0 +1,289 @@
+from katrain.core.game_node import GameNode
+from katrain.core.sgf_parser import Move
+
+# tsumego frame ported from lizgoban by kaorahi
+# note: coords = (j, i) in katrain
+
+near_to_edge = 2
+offence_to_win = 5
+
+BLACK = "B"
+WHITE = "W"
+
+
+def tsumego_frame_from_katrain_game(game, komi, black_to_play_p, ko_p, margin):
+    current_node = game.current_node
+    bw_board = [[game.chains[c][0].player if c >= 0 else "-" for c in line] for line in game.board]
+    isize, jsize = ij_sizes(bw_board)
+    blacks, whites, analysis_region = tsumego_frame(bw_board, komi, black_to_play_p, ko_p, margin)
+    sgf_blacks = katrain_sgf_from_ijs(blacks, isize, jsize, "B")
+    sgf_whites = katrain_sgf_from_ijs(whites, isize, jsize, "W")
+
+    played_node = GameNode(parent=current_node, properties={"AB": sgf_blacks, "AW": sgf_whites})  # this inserts
+
+    katrain_region = analysis_region and (analysis_region[1], analysis_region[0])
+    return (played_node, katrain_region)
+
+
+def katrain_sgf_from_ijs(ijs, isize, jsize, player):
+    return [Move((j, i)).sgf((jsize, isize)) for i, j in ijs]
+
+
+def tsumego_frame(bw_board, komi, black_to_play_p, ko_p, margin):
+    stones = stones_from_bw_board(bw_board)
+    filled_stones = tsumego_frame_stones(stones, komi, black_to_play_p, ko_p, margin)
+    region_pos = pick_all(filled_stones, "tsumego_frame_region_mark")
+    bw = pick_all(filled_stones, "tsumego_frame")
+    blacks = [(i, j) for i, j, black in bw if black]
+    whites = [(i, j) for i, j, black in bw if not black]
+    return (blacks, whites, get_analysis_region(region_pos))
+
+
+def pick_all(stones, key):
+    return [[i, j, s.get("black")] for i, row in enumerate(stones) for j, s in enumerate(row) if s.get(key)]
+
+
+def get_analysis_region(region_pos):
+    if len(region_pos) == 0:
+        return None
+    ai, aj, dummy = tuple(zip(*region_pos))
+    ri = (min(ai), max(ai))
+    rj = (min(aj), max(aj))
+    return ri[0] < ri[1] and rj[0] < rj[1] and (ri, rj)
+
+
+def tsumego_frame_stones(stones, komi, black_to_play_p, ko_p, margin):
+    sizes = ij_sizes(stones)
+    isize, jsize = sizes
+    ijs = [
+        {"i": i, "j": j, "black": h.get("black")}
+        for i, row in enumerate(stones)
+        for j, h in enumerate(row)
+        if h.get("stone")
+    ]
+
+    if len(ijs) == 0:
+        return []
+    # find range of problem
+    top = min_by(ijs, "i", +1)
+    left = min_by(ijs, "j", +1)
+    bottom = min_by(ijs, "i", -1)
+    right = min_by(ijs, "j", -1)
+    imin = snap0(top["i"])
+    jmin = snap0(left["j"])
+    imax = snapS(bottom["i"], isize)
+    jmax = snapS(right["j"], jsize)
+    # flip/rotate for standard position
+    # don't mix flip and swap (FF = SS = identity, but SFSF != identity)
+    flip_spec = (
+        [False, False, True] if imin < jmin else [need_flip_p(imin, imax, isize), need_flip_p(jmin, jmax, jsize), False]
+    )
+    if True in flip_spec:
+        flipped = flip_stones(stones, flip_spec)
+        filled = tsumego_frame_stones(flipped, komi, black_to_play_p, ko_p, margin)
+        return flip_stones(filled, flip_spec)
+    # put outside stones
+    i0 = imin - margin
+    i1 = imax + margin
+    j0 = jmin - margin
+    j1 = jmax + margin
+    frame_range = [i0, i1, j0, j1]
+    black_to_attack_p = guess_black_to_attack([top, bottom, left, right], sizes)
+    put_border(stones, sizes, frame_range, black_to_attack_p)
+    put_outside(stones, sizes, frame_range, black_to_attack_p, black_to_play_p, komi)
+    put_ko_threat(stones, sizes, frame_range, black_to_attack_p, black_to_play_p, ko_p)
+    return stones
+
+
+# detect corner/edge/center problems
+# (avoid putting border stones on the first lines)
+def snap(k, to):
+    return to if abs(k - to) <= near_to_edge else k
+
+
+def snap0(k):
+    return snap(k, 0)
+
+
+def snapS(k, size):
+    return snap(k, size - 1)
+
+
+def min_by(ary, key, sign):
+    by = [sign * z[key] for z in ary]
+    return ary[by.index(min(by))]
+
+
+def need_flip_p(kmin, kmax, size):
+    return kmin < size - kmax - 1
+
+
+def guess_black_to_attack(extrema, sizes):
+    return sum([sign_of_color(z) * height2(z, sizes) for z in extrema]) > 0
+
+
+def sign_of_color(z):
+    return 1 if z["black"] else -1
+
+
+def height2(z, sizes):
+    isize, jsize = sizes
+    return height(z["i"], isize) + height(z["j"], jsize)
+
+
+def height(k, size):
+    return size - abs(k - (size - 1) / 2)
+
+
+######################################
+# sub
+
+
+def put_border(stones, sizes, frame_range, is_black):
+    i0, i1, j0, j1 = frame_range
+    put_twin(stones, sizes, i0, i1, j0, j1, is_black, False)
+    put_twin(stones, sizes, j0, j1, i0, i1, is_black, True)
+
+
+def put_twin(stones, sizes, beg, end, at0, at1, is_black, reverse_p):
+    for at in (at0, at1):
+        for k in range(beg, end + 1):
+            i, j = (at, k) if reverse_p else (k, at)
+            put_stone(stones, sizes, i, j, is_black, False, True)
+
+
+def put_outside(stones, sizes, frame_range, black_to_attack_p, black_to_play_p, komi):
+    isize, jsize = sizes
+    count = 0
+    offense_komi = (+1 if black_to_attack_p else -1) * komi
+    defense_area = (isize * jsize - offense_komi - offence_to_win) / 2
+    for i in range(isize):
+        for j in range(jsize):
+            if inside_p(i, j, frame_range):
+                continue
+            count += 1
+            black_p = xor(black_to_attack_p, (count <= defense_area))
+            empty_p = (i + j) % 2 == 0 and abs(count - defense_area) > isize
+            put_stone(stones, sizes, i, j, black_p, empty_p)
+
+
+# standard position:
+# ? = problem, X = offense, O = defense
+# OOOOOOOOOOOOO
+# OOOOOOOOOOOOO
+# OOOOOOOOOOOOO
+# XXXXXXXXXXXXX
+# XXXXXXXXXXXXX
+# XXXX.........
+# XXXX.XXXXXXXX
+# XXXX.X???????
+# XXXX.X???????
+
+# (pattern, top_p, left_p)
+offense_ko_threat = (
+    """
+....OOOX.
+.....XXXX
+""",
+    True,
+    False,
+)
+
+defense_ko_threat = (
+    """
+..
+..
+X.
+XO
+OO
+.O
+""",
+    False,
+    True,
+)
+
+
+def put_ko_threat(stones, sizes, frame_range, black_to_attack_p, black_to_play_p, ko_p):
+    isize, jsize = sizes
+    for_offense_p = xor(ko_p, xor(black_to_attack_p, black_to_play_p))
+    pattern, top_p, left_p = offense_ko_threat if for_offense_p else defense_ko_threat
+    aa = [list(line) for line in pattern.splitlines() if len(line) > 0]
+    height, width = ij_sizes(aa)
+    for i, row in enumerate(aa):
+        for j, ch in enumerate(row):
+            ai = i + (0 if top_p else isize - height)
+            aj = j + (0 if left_p else jsize - width)
+            if inside_p(ai, aj, frame_range):
+                return
+            black = xor(black_to_attack_p, ch == "O")
+            empty = ch == "."
+            put_stone(stones, sizes, ai, aj, black, empty)
+
+
+def xor(a, b):
+    return bool(a) != bool(b)
+
+
+######################################
+# util
+
+
+def flip_stones(stones, flip_spec):
+    swap_p = flip_spec[2]
+    sizes = ij_sizes(stones)
+    isize, jsize = sizes
+    new_isize, new_jsize = [jsize, isize] if swap_p else [isize, jsize]
+    new_stones = [[None for z in range(new_jsize)] for row in range(new_isize)]
+    for i, row in enumerate(stones):
+        for j, z in enumerate(row):
+            new_i, new_j = flip_ij((i, j), sizes, flip_spec)
+            new_stones[new_i][new_j] = z
+    return new_stones
+
+
+def put_stone(stones, sizes, i, j, black, empty, tsumego_frame_region_mark=False):
+    isize, jsize = sizes
+    if i < 0 or isize <= i or j < 0 or jsize <= j:
+        return
+    stones[i][j] = (
+        {}
+        if empty
+        else {
+            "stone": True,
+            "tsumego_frame": True,
+            "black": black,
+            "tsumego_frame_region_mark": tsumego_frame_region_mark,
+        }
+    )
+
+
+def inside_p(i, j, region):
+    i0, i1, j0, j1 = region
+    return i0 <= i and i <= i1 and j0 <= j and j <= j1
+
+
+def stones_from_bw_board(bw_board):
+    return [[stone_from_str(s) for s in row] for row in bw_board]
+
+
+def stone_from_str(s):
+    black = s == BLACK
+    white = s == WHITE
+    return {"stone": True, "black": black} if (black or white) else {}
+
+
+def ij_sizes(stones):
+    return (len(stones), len(stones[0]))
+
+
+def flip_ij(ij, sizes, flip_spec):
+    i, j = ij
+    isize, jsize = sizes
+    flip_i, flip_j, swap_ij = flip_spec
+    fi = flip1(i, isize, flip_i)
+    fj = flip1(j, jsize, flip_j)
+    return (fj, fi) if swap_ij else (fi, fj)
+
+
+def flip1(k, size, flag):
+    return size - 1 - k if flag else k

katrain/katrain/core/utils.py

@@ -0,0 +1,99 @@
+import heapq
+import math
+import os
+import random
+import struct
+import sys
+from typing import List, Tuple, TypeVar
+
+try:
+    import importlib.resources as pkg_resources
+except ImportError:
+    import importlib_resources as pkg_resources
+
+T = TypeVar("T")
+
+
+def var_to_grid(array_var: List[T], size: Tuple[int, int]) -> List[List[T]]:
+    """convert ownership/policy to grid format such that grid[y][x] is for move with coords x,y"""
+    ix = 0
+    grid = [[]] * size[1]
+    for y in range(size[1] - 1, -1, -1):
+        grid[y] = array_var[ix : ix + size[0]]
+        ix += size[0]
+    return grid
+
+
+def evaluation_class(points_lost, eval_thresholds):
+    i = 0
+    while i < len(eval_thresholds) - 1 and points_lost > eval_thresholds[i + 1]:
+        i += 1
+    return i
+
+def check_thread(tb=False):  # for checking if draws occur in correct thread
+    import threading
+
+    print("build in ", threading.current_thread().ident)
+    if tb:
+        import traceback
+
+        traceback.print_stack()
+
+
+PATHS = {}
+
+
+def find_package_resource(path, silent_errors=False):
+    global PATHS
+    if path.startswith("katrain"):
+        if not PATHS.get("PACKAGE"):
+            try:
+                with pkg_resources.path("katrain", "gui.kv") as p:
+                    PATHS["PACKAGE"] = os.path.split(str(p))[0]
+            except (ModuleNotFoundError, FileNotFoundError, ValueError) as e:
+                print(f"Package path not found, installation possibly broken. Error: {e}", file=sys.stderr)
+                return f"FILENOTFOUND/{path}"
+        return os.path.join(PATHS["PACKAGE"], path.replace("katrain\\", "katrain/").replace("katrain/", ""))
+    else:
+        return os.path.abspath(os.path.expanduser(path))  # absolute path
+
+
+def pack_floats(float_list):
+    if float_list is None:
+        return b""
+    return struct.pack(f"{len(float_list)}e", *float_list)
+
+
+def unpack_floats(str, num):
+    if not str:
+        return None
+    return struct.unpack(f"{num}e", str)
+
+
+def format_visits(n):
+    if n < 1000:
+        return str(n)
+    if n < 1e5:
+        return f"{n/1000:.1f}k"
+    if n < 1e6:
+        return f"{n/1000:.0f}k"
+    return f"{n/1e6:.0f}M"
+
+
+def json_truncate_arrays(data, lim=20):
+    if isinstance(data, list):
+        if data and isinstance(data[0], dict):
+            return [json_truncate_arrays(d) for d in data]
+        if len(data) > lim:
+            data = [f"{len(data)} x {type(data[0]).__name__}"]
+        return data
+    elif isinstance(data, dict):
+        return {k: json_truncate_arrays(v) for k, v in data.items()}
+    else:
+        return data
+
+
+def weighted_selection_without_replacement(items: List[Tuple], pick_n: int) -> List[Tuple]:
+    """For a list of tuples where the second element is a weight, returns random items with those weights, without replacement."""
+    elt = [(math.log(random.random()) / (item[1] + 1e-18), item) for item in items]  # magic
+    return [e[1] for e in heapq.nlargest(pick_n, elt)]  # NB fine if too small