Initial commit

10 files changed, 1166 insertions, 0 deletions

diff --git a/qml/python/__init__.py b/qml/python/__init__.py
new file mode 100644
index 0000000..7847780
--- /dev/null
+++ b/qml/python/__init__.py
@@ -0,0 +1,3 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
diff --git a/qml/python/board.py b/qml/python/board.py
new file mode 100644
index 0000000..48f3ff0
--- /dev/null
+++ b/qml/python/board.py
@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+import os
+try:
+    import pyotherside
+except:
+    print("no pyotherside module loaded")
+
+import sgfparser
+from game import Game
+
+counter = 0
+
+path = ""
+cursor = None
+
+def setPath(qtPath):
+    global path
+    path = qtPath
+
+def loadBoard(filename):
+    global cursor
+
+    sgfPath = os.path.join(path,"../content","sgf",filename);
+    pyotherside.send('log', sgfPath)
+    try:
+        f = open(sgfPath)
+        s = f.read()
+        f.close()
+    except IOError:
+        pyotherside.send('log', "Cannot open %s" % filename)
+        return
+
+    try:
+        cursor = sgfparser.Cursor(s)
+    except sgfparser.SGFError:
+        pyotherside.send('log', 'Error in SGF file!')
+        return
+    pyotherside.send('log', 'File %s loaded' % filename)
+    pyotherside.send('log', 'Found %d problems' % cursor.root.numChildren)
+    return cursor.root.numChildren
+
+def getGame(n):
+    global cursor
+
+    cursor.game(n)
+
+    game = Game(cursor)
+    game.normalize()
+    pyotherside.send('log', "Game loaded !!")
+
+    return {
+        "tree": game.tree,
+        "size": game.get_size(),
+        "side": game.side,
+    }
diff --git a/qml/python/game.py b/qml/python/game.py
new file mode 100644
index 0000000..7a91ae7
--- /dev/null
+++ b/qml/python/game.py
@@ -0,0 +1,145 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import random
+from transformations import *
+
+
+class Game(object):
+    """" A game loaded from a sgf data source.
+    """
+
+    def __init__(self, cursor):
+        """ Create a new Game on the current cursor position.
+        :cursor: The cursor opened at the game.
+        """
+
+        node = cursor.currentNode()
+
+        # display problem name
+        name = ''
+        if 'GN' in node:
+            name = node['GN'][0][:15]
+        self.name = name
+
+        while not ('AG' in node or 'AW' in node \
+                   or 'B' in node or 'W' in node):
+            node = cursor.next()
+
+        self.min_x, self.min_y = 19, 19
+        self.max_x, self.max_y = 0, 0
+
+        # Get the board size from the whole possibles positions and create the
+        # game tree
+        self.tree = Game.create_tree(cursor, self.extend_board_size, [])
+
+        x_space = 2
+        y_space = 2
+
+        if self.min_y > y_space:
+            self.min_y -= y_space
+
+        if self.min_x > x_space:
+            self.min_x -= x_space
+
+        if self.max_y < 19 - y_space:
+            self.max_y += y_space
+
+        if self.max_x < 19 - x_space:
+            self.max_x += x_space
+
+        self.side = {
+            "TOP": self.min_y != 0,
+            "LEFT": self.min_x != 0,
+            "RIGHT": self.max_x != 19,
+            "BOTTOM": self.max_y != 19,
+        }
+
+
+    def extend_board_size(self, pos):
+        """ Extend the board size to include the position given.
+        """
+        x, y = Game.conv_coord(pos)
+        self.min_x = min(x, self.min_x)
+        self.max_x = max(x, self.max_x)
+        self.min_y = min(y, self.min_y)
+        self.max_y = max(y, self.max_y)
+        return (x, y)
+
+    @staticmethod
+    def create_tree(cursor, fun, acc=None):
+        """ Walk over the whole node in the game and call fun for each of them.
+        :cursor:    The cursor in the sgf parser.
+        :fun:       Function called for each position read
+        """
+
+        if acc is None:
+            acc = []
+
+        node = cursor.currentNode().copy()
+        for key in ['AB', 'AW', 'B', 'W']:
+            if key in node:
+                node[key] = [fun(pos) for pos in node[key]]
+
+        acc.append(node)
+        childs = cursor.noChildren()
+
+        if childs == 1:
+            # When there is only one child, we just add it to the current path
+            cursor.next()
+            Game.create_tree(cursor, fun, acc)
+            cursor.previous()
+        elif childs > 1:
+            # Create a new list containing each subtree
+            sub_nodes = []
+            for i in range(childs):
+                cursor.next(i)
+                sub_nodes.append(Game.create_tree(cursor, fun))
+                cursor.previous()
+            acc.append(sub_nodes)
+        return acc
+
+    def get_size(self):
+        #return self.max_x, self.max_y
+        x_size = self.max_x - self.min_x
+        y_size = self.max_y - self.min_y
+        return min(19, x_size + 1), min(19, y_size + 1)
+
+    @staticmethod
+    def conv_coord(x):
+        """ This takes coordinates in SGF style (aa - qq) and returns the
+        corresponding integer coordinates (between 1 and 19). """
+
+        print(x)
+
+        return tuple([ord(c) - 96 for c in x])
+
+    def parse_tree(self, fun, elements=None):
+        """" Parse the current tree, and apply fun to each element.
+        """
+
+        if elements is None:
+            elements = self.tree
+
+        for elem in elements:
+            if isinstance(elem, dict):
+                for key in ['AB', 'AW', 'B', 'W']:
+                    if key in elem:
+                        elem[key] = [fun(pos) for pos in elem[key]]
+#                for type, values in elem.items():
+#                    elem[type] = [fun(coord) for coord in values]
+            else:
+                for l in elem:
+                    self.parse_tree(fun, l)
+
+    def normalize(self):
+        """ Create a normalized board, translated on lower coord.
+        """
+
+        for transformation in [Translation(self), Rotation(self), Translation(self), Symmetry(self)]:
+            if not transformation.is_valid():
+                continue
+
+            self.parse_tree(transformation.apply_points)
+            self.min_x, self.min_y, self.max_x, self.max_y = transformation.get_new_size()
+            self.side = transformation.get_new_side()
diff --git a/qml/python/sgfparser.py b/qml/python/sgfparser.py
new file mode 100644
index 0000000..2ad91c9
--- /dev/null
+++ b/qml/python/sgfparser.py
@@ -0,0 +1,579 @@
+# File: sgfparser.py
+
+##   This is part of uliGo 0.4, a program for practicing
+##   go problems. For more information, see http://www.g0ertz.de/uligo/
+
+##   Copyright (C) 2001-12 Ulrich Goertz (uligo@g0ertz.de)
+
+##   This program is free software; you can redistribute it and/or modify
+##   it under the terms of the GNU General Public License as published by
+##   the Free Software Foundation; either version 2 of the License, or
+##   (at your option) any later version.
+
+##   This program is distributed in the hope that it will be useful,
+##   but WITHOUT ANY WARRANTY; without even the implied warranty of
+##   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+##   GNU General Public License for more details.
+
+##   You should have received a copy of the GNU General Public License
+##   along with this program (gpl.txt); if not, write to the Free Software
+##   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+##   The GNU GPL is also currently available at
+##   http://www.gnu.org/copyleft/gpl.html
+
+import re
+import string
+
+class SGFError(Exception): pass
+
+reGameStart = re.compile(r'\(\s*;')
+reRelevant = re.compile(r'[\[\]\(\);]')
+reStartOfNode = re.compile(r'\s*;\s*')
+
+def SGFescape(s):
+    t = s.replace('\\', '\\\\')
+    t = t.replace(']', '\\]')
+    return t
+
+class Node:
+    def __init__(self, previous=None, SGFstring = '', level=0):
+        self.previous = previous
+        self.next = None
+        self.up = None
+        self.down = None
+        self.level = level # self == self.previous.next[self.level]
+
+        self.numChildren = 0
+
+        self.SGFstring = SGFstring
+        self.parsed = 0
+        if self.SGFstring:
+            self.parseNode()
+        else:
+            self.data = {}
+
+        self.posyD = 0
+
+
+    def getData(self):
+        if not self.parsed: self.parseNode()
+        return self.data
+
+    def pathToNode(self):
+        l = []
+        n = self
+
+        while n.previous:
+            l.append(n.level)
+            n = n.previous
+
+        l.reverse()
+        return l
+
+
+    def parseNode(self):
+
+        if self.parsed: return
+
+        s = self.SGFstring
+        i = 0
+
+        match = reStartOfNode.search(s, i)
+        if not match:
+            raise SGFError('No node found')
+        i = match.end()
+
+        node = {}
+        while i < len(s):
+
+            while i < len(s) and s[i] in string.whitespace: i += 1
+            if i >= len(s): break
+
+            ID = []
+
+            while not s[i] == '[':
+                if s[i] in string.ascii_uppercase:
+                    ID.append(s[i])
+                elif not s[i] in string.ascii_lowercase + string.whitespace:
+                    raise SGFError('Invalid Property ID')
+
+                i += 1
+
+                if i >= len(s):
+                    raise SGFError('Property ID does not have any value')
+
+            i += 1
+
+            key = ''.join(ID)
+
+            if key == '': raise SGFError('Property does not have a correct ID')
+
+
+            if key in node:
+                if not Node.sloppy:
+                    raise SGFError('Multiple occurrence of SGF tag')
+            else:
+                node[key] = []
+
+            propertyValueList = []
+            while 1:
+                propValue = []
+                while s[i] != ']':
+                    if s[i] == '\t':      # convert whitespace to ' '
+                        propValue.append(' ')
+                        i += 1
+                        continue
+                    if s[i] == '\\':
+                        i += 1            # ignore escaped characters, throw away backslash
+                        if s[i:i+2] in ['\n\r', '\r\n']:
+                            i += 2
+                            continue
+                        elif s[i] in ['\n', '\r']:
+                            i += 1
+                            continue
+                    propValue.append(s[i])
+                    i += 1
+
+                    if i >= len(s):
+                        raise SGFError('Property value does not end')
+
+                propertyValueList.append(''.join(propValue))
+
+                i += 1
+
+                while i < len(s) and s[i] in string.whitespace:
+                    i += 1
+
+                if i >= len(s) or s[i] != '[': break
+                else: i += 1
+
+            if key in ['B', 'W', 'AB', 'AW']:
+                for N in range(len(propertyValueList)):
+                    en = propertyValueList[N]
+                    if Node.sloppy:
+                        en = en.replace('\n', '')
+                        en = en.replace('\r', '')
+                    if not (len(en) == 2 or (len(en) == 0 and key in ['B', 'W'])):
+                        raise SGFError('')
+                    propertyValueList[N] = en
+
+            node[key].extend(propertyValueList)
+
+        self.data = node
+        self.parsed = 1
+
+
+Node.sloppy = 1
+
+# ------------------------------------------------------------------------------------
+
+class Cursor:
+
+    """ Initialized with an SGF file. Then use game(n); next(n), previous to navigate.
+    self.collection is list of Nodes, namely of the root nodes of the game trees.
+
+    self.currentN is the current Node
+    self.currentNode() returns self.currentN.data
+
+    The sloppy option for __init__ determines if the following things, which are not allowed
+    according to the SGF spec, are accepted nevertheless:
+     - multiple occurrences of a tag in one node
+     - line breaks in AB[]/AW[]/B[]/W[] tags (e.g. "B[a\nb]")
+    """
+
+
+    def __init__(self, sgf, sloppy = 1):
+        Node.sloppy = sloppy
+
+        self.height = 0
+        self.width = 0
+        self.posx = 0
+        self.posy = 0
+
+        self.root = Node(None, '', 0)
+
+        self.parse(sgf)
+        self.currentN = self.root.next
+        self.setFlags()
+
+    def setFlags(self):
+        if self.currentN.next: self.atEnd = 0
+        else: self.atEnd = 1
+        if self.currentN.previous: self.atStart = 0
+        else: self.atStart = 1
+
+    def noChildren(self):
+        return self.currentN.numChildren
+
+    def currentNode(self):
+        if not self.currentN.parsed:
+            self.currentN.parseNode()
+        return self.currentN.data
+
+    def parse(self, sgf):
+
+        curr = self.root
+
+        p = -1           # start of the currently parsed node
+        c = []           # list of nodes from which variations started
+        last = ')'       # type of last aprsed bracked ('(' or ')')
+        inbrackets = 0   # are the currently parsed characters in []'s?
+
+        height_previous = 0
+        width_currentVar = 0
+
+        i = 0 # current parser position
+
+        # skip everything before first (; :
+
+        match = reGameStart.search(sgf, i)
+        if not match:
+            raise SGFError('No game found')
+
+        i = match.start()
+
+        while i < len(sgf):
+
+            match = reRelevant.search(sgf, i)
+            if not match:
+                break
+            i = match.end() - 1
+
+            if inbrackets:
+                if sgf[i]==']':
+                    numberBackslashes = 0
+                    j = i-1
+                    while sgf[j] == '\\':
+                        numberBackslashes += 1
+                        j -= 1
+                    if not (numberBackslashes % 2):
+                        inbrackets = 0
+                i = i + 1
+                continue
+
+            if sgf[i] == '[':
+                inbrackets = 1
+
+            if sgf[i] == '(':
+                if last != ')':       # start of first variation of previous node
+                    if p != -1: curr.SGFstring = sgf[p:i]
+
+                nn = Node()
+                nn.previous = curr
+
+                width_currentVar += 1
+                if width_currentVar > self.width: self.width = width_currentVar
+
+                if curr.next:
+                    last = curr.next
+                    while last.down: last = last.down
+                    nn.up = last
+                    last.down = nn
+                    nn.level = last.level + 1
+                    self.height += 1
+                    nn.posyD = self.height - height_previous
+                else:
+                    curr.next = nn
+                    nn.posyD = 0
+                    height_previous = self.height
+
+                curr.numChildren += 1
+
+                c.append((curr, width_currentVar-1, self.height))
+
+                curr = nn
+
+                p = -1
+                last = '('
+
+            if sgf[i] == ')':
+                if last != ')' and p != -1:
+                    curr.SGFstring = sgf[p:i]
+                try:
+                    curr, width_currentVar, height_previous = c.pop()
+                except IndexError:
+                    raise SGFError('Game tree parse error')
+                last = ')'
+
+            if sgf[i] == ';':
+                if p != -1:
+                    curr.SGFstring = sgf[p:i]
+                    nn = Node()
+                    nn.previous = curr
+                    width_currentVar += 1
+                    if width_currentVar > self.width: self.width = width_currentVar
+                    nn.posyD = 0
+                    curr.next = nn
+                    curr.numChildren = 1
+                    curr = nn
+                p = i
+
+            i = i + 1
+
+        if inbrackets or c:
+            raise SGFError('Game tree parse error')
+
+        n = curr.next
+        n.previous = None
+        n.up = None
+
+        while n.down:
+            n = n.down
+            n.previous = None
+
+
+    def game(self, n):
+        if n < self.root.numChildren:
+            self.posx = 0
+            self.posy = 0
+            self.currentN = self.root.next
+            for i in range(n): self.currentN = self.currentN.down
+            self.setFlags()
+        else:
+            raise SGFError('Game not found')
+
+
+    def delVariation(self, c):
+
+        if c.previous:
+            self.delVar(c)
+        else:
+            if c.next:
+                node = c.next
+                while node.down:
+                    node = node.down
+                    self.delVar(node.up)
+
+                self.delVar(node)
+
+            c.next = None
+
+        self.setFlags()
+
+
+    def delVar(self, node):
+        if node.up: node.up.down = node.down
+        else: node.previous.next = node.down
+
+        if node.down:
+            node.down.up = node.up
+            node.down.posyD = node.posyD
+            n = node.down
+            while n:
+                n.level -= 1
+                n = n.down
+
+        h = 0
+        n = node
+        while n.next:
+            n = n.next
+            while n.down:
+                n = n.down
+                h += n.posyD
+
+        if node.up or node.down: h += 1
+
+        p = node.previous
+        p.numChildren -= 1
+
+        while p:
+            if p.down: p.down.posyD -= h
+            p = p.previous
+
+
+        self.height -= h
+
+
+
+
+    def add(self, st):
+        node = Node(self.currentN,st,0)
+
+        node.down = None
+        node.next = None
+        node.numChildren = 0
+
+        if not self.currentN.next:
+            node.level = 0
+            node.posyD = 0
+            node.up = 0
+
+            self.currentN.next = node
+            self.currentN.numChildren = 1
+        else:
+            n = self.currentN.next
+            while n.down:
+                n = n.down
+                self.posy += n.posyD
+
+
+            n.down = node
+            node.up = n
+            node.level = n.level + 1
+            node.next = None
+            self.currentN.numChildren += 1
+
+            node.posyD = 1
+            while n.next:
+                n = n.next
+                while n.down:
+                    n = n.down
+                    node.posyD += n.posyD
+
+            self.posy += node.posyD
+
+            self.height += 1
+
+            n = node
+            while n.previous:
+                n = n.previous
+                if n.down: n.down.posyD += 1
+
+        self.currentN = node
+
+        self.posx += 1
+        self.setFlags()
+
+        if self.posx > self.width: self.width += 1
+
+
+
+
+
+
+
+    def next(self, n=0):
+        if n >= self.noChildren():
+            raise SGFError('Variation not found')
+
+        self.posx += 1
+
+        self.currentN = self.currentN.next
+        for i in range(n):
+            self.currentN = self.currentN.down
+            self.posy += self.currentN.posyD
+        self.setFlags()
+        return self.currentNode()
+
+    def previous(self):
+        if self.currentN.previous:
+            while self.currentN.up:
+                self.posy -= self.currentN.posyD
+                self.currentN = self.currentN.up
+            self.currentN = self.currentN.previous
+            self.posx -= 1
+        else: raise SGFError('No previous node')
+        self.setFlags()
+        return self.currentNode()
+
+    def getRootNode(self, n):
+        if not self.root: return
+        if n >= self.root.numChildren: raise SGFError('Game not found')
+
+        nn = self.root.next
+        for i in range(n): nn = nn.down
+
+        if not nn.parsed: nn.parseNode()
+
+        return nn.data
+
+
+    def updateCurrentNode(self):
+        """ Put the data in self.currentNode into the corresponding string in self.collection.
+        This will be called from an application which may have modified self.currentNode."""
+
+        self.currentN.SGFstring = self.nodeToString(self.currentN.data)
+
+
+
+
+    def updateRootNode(self, data, n=0):
+        if n >= self.root.numChildren:
+            raise SGFError('Game not found')
+
+        nn = self.root.next
+        for i in range(n): nn = nn.down
+
+        nn.SGFstring = self.rootNodeToString(data)
+        nn.parsed = 0
+        nn.parseNode()
+
+
+    def rootNodeToString(self, node):
+
+        result = [';']
+        keylist = ['GM', 'FF', 'SZ', 'PW', 'WR', 'PB', 'BR',
+                   'EV', 'RO', 'DT', 'PC', 'KM', 'RE', 'US', 'GC']
+        for key in keylist:
+            if key in node:
+                result.append(key)
+                result.append('[' + SGFescape(node[key][0]) + ']\n')
+
+        l = 0
+        for key in node.keys():
+            if not key in keylist:
+                result.append(key)
+                l += len(key)
+                for item in node[key]:
+                    result.append('[' + SGFescape(item) + ']\n')
+                    l += len(item) + 2
+                    if l > 72:
+                        result.append('\n')
+                        l = 0
+
+        return ''.join(result)
+
+    def nodeToString(self, node):
+        l = 0
+        result = [';']
+        for k in node.keys():
+            if l + len(k) > 72:
+                result.append('\n')
+                l = 0
+            if not node[k]: continue
+            result.append(k)
+            l += len(k)
+            for item in node[k]:
+                if l + len(item) > 72:
+                    result.append('\n')
+                    l = 0
+                l += len(item) + 2
+                result.append('[' + SGFescape(item) + ']')
+
+        return ''.join(result)
+
+
+    def outputVar(self, node):
+
+        result = []
+
+        result.append(node.SGFstring)
+
+        while node.next:
+            node = node.next
+
+            if node.down:
+                while node.down:
+                    result.append('(' + self.outputVar(node) + ')' )
+                    node = node.down
+
+                result.append('(' + self.outputVar(node) + ')' )
+                return ''.join(result)
+
+            else:
+                result.append(node.SGFstring)
+
+        return ''.join(result)
+
+
+
+    def output(self):
+        result = []
+
+        n = self.root.next
+
+        while n:
+            result.append('(' + self.outputVar(n)+ ')\n')
+            n = n.down
+
+        return ''.join(result)
diff --git a/qml/python/tests/__init__.py b/qml/python/tests/__init__.py
new file mode 100644
index 0000000..7847780
--- /dev/null
+++ b/qml/python/tests/__init__.py
@@ -0,0 +1,3 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
diff --git a/qml/python/tests/test.sgf b/qml/python/tests/test.sgf
new file mode 100644
index 0000000..bdbe898
--- /dev/null
+++ b/qml/python/tests/test.sgf
@@ -0,0 +1,13 @@
+(;GM[1]FF[3]
+;AW[ro][nq][oq][pq][qq][rq][mr]
+AB[or][pr][qr][rr][sr]
+    (;W[os]
+        (;B[ps];W[rs];B[ns];W[nr])
+        (;B[ns];W[nr];B[rs];W[ps];B[qs];W[os])
+    )
+(;W[rs]
+    (;B[os];W[qs])
+    (;B[qs];W[os];B[nr];W[ns])
+)
+)
+
diff --git a/qml/python/tests/test2.sgf b/qml/python/tests/test2.sgf
new file mode 100644
index 0000000..a11356c
--- /dev/null
+++ b/qml/python/tests/test2.sgf
@@ -0,0 +1,6 @@
+(;GM[1]FF[3]
+;AW[qn][mp][qp][rp][kq][mq][oq][pq][nr][pr][rs]
+AB[nn][mo][np][op][pp][nq][qq][rq][qr][sr][qs]
+(;B[or];W[os];B[ps];W[or];B[mr])
+(;B[ps]WV[ps];W[or];B[mr];W[lr])
+)
diff --git a/qml/python/tests/test_game.py b/qml/python/tests/test_game.py
new file mode 100644
index 0000000..de43909
--- /dev/null
+++ b/qml/python/tests/test_game.py
@@ -0,0 +1,101 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+import unittest
+from python import sgfparser, game
+
+def create_board(fic):
+   with open("python/tests/%s" % fic) as f:
+       cursor = sgfparser.Cursor(f.read())
+
+   return game.Game(cursor)
+
+class TestBoard(unittest.TestCase):
+    """ Test for the board management.
+    """
+
+    def testConvCoord(self):
+        """ Test the conversion in the coordinates system.
+        """
+
+        self.assertEqual((1,2),game.Game.conv_coord("ab"))
+        self.assertEqual((1,1),game.Game.conv_coord("aa"))
+
+    def test_createTree(self):
+
+        def fun(pos):
+            return pos
+
+        with open("python/tests/test.sgf") as f:
+            cursor = sgfparser.Cursor(f.read())
+
+        cursor.next()
+
+        expected_tee = \
+            [{'AB': ['or', 'pr', 'qr', 'rr', 'sr'], 'AW': ['ro', 'nq', 'oq', 'pq', 'qq', 'rq', 'mr']},
+                [
+                    [{'W': ['os']},
+                        [
+                            [{'B': ['ps']}, {'W': ['rs']}, {'B': ['ns']}, {'W': ['nr']}],
+                            [{'B': ['ns']}, {'W': ['nr']}, {'B': ['rs']}, {'W': ['ps']}, {'B': ['qs']}, {'W': ['os']}]
+                        ]
+                    ],
+                    [{'W': ['rs']},
+                        [
+                            [{'B': ['os']}, {'W': ['qs']}],
+                            [{'B': ['qs']}, {'W': ['os']}, {'B': ['nr']}, {'W': ['ns']}]
+                        ]
+                    ]
+                ]
+            ]
+        self.assertEqual(expected_tee, game.Game.create_tree(cursor, fun))
+
+    def test_init(self):
+
+        def fun(pos):
+            return (0,0)
+        currentgame = create_board("test.sgf")
+
+        self.assertEqual(11, currentgame.min_x)
+        self.assertEqual(13, currentgame.min_y)
+        self.assertEqual(19, currentgame.max_x)
+        self.assertEqual(19, currentgame.max_y)
+
+        self.assertEqual((9, 7), currentgame.get_size())
+
+        # There is only 2 state : initial board, and 2 possibilities.
+        self.assertEqual(2, len(currentgame.tree))
+
+        self.assertTrue(currentgame.side['TOP'])
+        self.assertTrue(currentgame.side['LEFT'])
+        self.assertFalse(currentgame.side['BOTTOM'])
+        self.assertFalse(currentgame.side['RIGHT'])
+
+        currentgame.normalize()
+
+    def test_level2(self):
+
+        def fun(pos):
+            return (0,0)
+        currentgame = create_board("test2.sgf")
+
+        print(currentgame.tree)
+
+        currentgame.normalize()
+
+        self.assertEqual(11, currentgame.min_x)
+        self.assertEqual(13, currentgame.min_y)
+        self.assertEqual(19, currentgame.max_x)
+        self.assertEqual(19, currentgame.max_y)
+
+        self.assertEqual((9, 7), currentgame.get_size())
+
+        # There is only 2 state : initial board, and 2 possibilities.
+        self.assertEqual(2, len(currentgame.tree))
+
+        self.assertTrue(currentgame.side['TOP'])
+        self.assertTrue(currentgame.side['LEFT'])
+        self.assertFalse(currentgame.side['BOTTOM'])
+        self.assertFalse(currentgame.side['RIGHT'])
+
+        currentgame.normalize()
diff --git a/qml/python/tests/test_transformations.py b/qml/python/tests/test_transformations.py
new file mode 100644
index 0000000..b802b9f
--- /dev/null
+++ b/qml/python/tests/test_transformations.py
@@ -0,0 +1,134 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import unittest
+
+from python.transformations import Rotation, Translation, Symmetry
+
+class FakeBoard():
+
+    def __init__(self, min_x, min_y, max_x, max_y):
+        self.min_x = min_x
+        self.min_y = min_y
+        self.max_x = max_x
+        self.max_y = max_y
+
+    def get_size(self):
+        x_size = self.max_x - self.min_x
+        y_size = self.max_y - self.min_y
+        return min(19, x_size), min(19, y_size)
+
+class TestRotation(unittest.TestCase):
+    """ Test the rotation transformation
+    """
+
+    def test_apply_points(self):
+        """ Test the points rotation.
+        """
+        rotation = Rotation(FakeBoard(2, 1, 8, 5))
+        self.assertEqual((4, 2), rotation.apply_points((2, 1)))
+
+        rotation = Rotation(FakeBoard(0, 0, 6, 4))
+        self.assertEqual((4, 0), rotation.apply_points((0, 0)))
+        self.assertEqual((4, 3), rotation.apply_points((3, 0)))
+        self.assertEqual((1, 0), rotation.apply_points((0, 3)))
+        self.assertEqual((1, 3), rotation.apply_points((3, 3)))
+
+        rotation = Rotation(FakeBoard(1, 1, 6, 4))
+        self.assertEqual((4, 1), rotation.apply_points((1, 0)))
+
+
+
+    def test_get_new_size(self):
+        """ Test the goban size rotation.
+        """
+        rotation = Rotation(FakeBoard(2, 1, 8, 5))
+        self.assertEqual((0, 2, 4, 8), rotation.get_new_size())
+
+        rotation = Rotation(FakeBoard(0, 0, 6, 4))
+        self.assertEqual((0, 0, 4, 6), rotation.get_new_size())
+
+    def test_is_valid(self):
+        """ Test the is_valid method.
+        """
+
+        # Do not rotate if height > width
+        rotation = Rotation(FakeBoard(0, 0, 6, 4))
+        self.assertTrue(rotation.is_valid())
+
+        # Always rotate if width > height
+        rotation = Rotation(FakeBoard(0, 0, 4, 6))
+        self.assertFalse(rotation.is_valid())
+
+        # May rotate if width = height (not tested here…)
+
+class TestTranslation(unittest.TestCase):
+    """ Test the translation transformation.
+    """
+
+    def test_apply_points(self):
+        """ Test the points translation.
+        """
+        translation = Translation(FakeBoard(2, 1, 8, 5))
+        self.assertEqual((0, 0), translation.apply_points((2, 1)))
+        self.assertEqual((6, 4), translation.apply_points((8, 5)))
+
+    def test_get_new_size(self):
+        """ Test the goban size translation.
+        """
+        translation = Translation(FakeBoard(2, 1, 8, 5))
+
+        self.assertEqual((0, 0, 6, 4), translation.get_new_size())
+
+    def test_is_valid(self):
+        """ Test the is_valid method.
+        """
+
+        translation = Translation(FakeBoard(1, 0, 6, 4))
+        self.assertTrue(translation.is_valid())
+
+        translation = Translation(FakeBoard(0, 1, 6, 4))
+        self.assertTrue(translation.is_valid())
+
+        translation = Translation(FakeBoard(0, 0, 4, 6))
+        self.assertFalse(translation.is_valid())
+
+class TestRotation(unittest.TestCase):
+    """ Test the simetry transformation.
+    """
+
+    def test_apply_points(self):
+        """ Test the points Symmetry.
+        """
+        symmetry = Symmetry(FakeBoard(2, 1, 8, 5))
+        symmetry.x_flip = True
+        symmetry.y_flip = False
+        self.assertEqual((8, 1), symmetry.apply_points((2, 1)))
+        self.assertEqual((2, 5), symmetry.apply_points((8, 5)))
+
+        symmetry.x_flip = False
+        symmetry.y_flip = True
+        self.assertEqual((2, 5), symmetry.apply_points((2, 1)))
+        self.assertEqual((8, 1), symmetry.apply_points((8, 5)))
+
+    def test_get_new_size(self):
+        """ Test the goban size Symmetry.
+        """
+        symmetry = Symmetry(FakeBoard(2, 1, 8, 5))
+
+        self.assertEqual((2, 1, 8, 5), symmetry.get_new_size())
+
+    def test_is_valid(self):
+        """ Test the is_valid method.
+        """
+
+        symmetry = Symmetry(FakeBoard(1, 0, 6, 4))
+        symmetry.x_flip = True
+        self.assertTrue(symmetry.is_valid())
+
+
+        symmetry = Symmetry(FakeBoard(0, 0, 4, 6))
+        symmetry.x_flip = False
+        symmetry.y_flip = False
+        self.assertFalse(symmetry.is_valid())
+
diff --git a/qml/python/transformations.py b/qml/python/transformations.py
new file mode 100644
index 0000000..380c30c
--- /dev/null
+++ b/qml/python/transformations.py
@@ -0,0 +1,125 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import random
+random.seed()
+
+class Translation(object):
+    """ A translation transformation.
+    """
+
+    def __init__(self, board):
+        """ Create a new translation from the board.
+        """
+        self.board = board
+
+    def is_valid(self):
+        """ Apply if a translation if the goban is not maximized.
+        """
+        return self.board.min_x != 0 or self.board.min_y != 0
+
+    def apply_points(self, coord):
+        """ Move the points to the lower position.
+        """
+        x, y = coord
+        return (x - self.board.min_x, y - self.board.min_y)
+
+    def get_new_size(self):
+        """ The goban size does not change.
+        """
+        return 0, 0, self.board.max_x - self.board.min_x, self.board.max_y - self.board.min_y
+
+    def get_new_side(self):
+        """ There is no changes on the sides.
+        """
+        return self.board.side
+
+class Rotation(object):
+    """ A rotation transformation.
+    """
+
+    def __init__(self, board):
+        """ Create a new roation from the board.
+        """
+        self.board = board
+
+    def is_valid(self):
+        """ Apply the rotation in following cases :
+        * if the board is widther than heigther
+        * randomly is width == heigth
+        * never if the board is heigther than widther
+        """
+
+        width, heigth = self.board.get_size()
+        should = heigth - width
+        if should == 0:
+            return random.randint(0, 1) == 1
+        return should < 0
+
+    def apply_points(self, coord):
+        """ Apply the transformation on a point.
+        """
+        x, y = coord
+        return (self.board.max_y - y, x)
+
+    def get_new_size(self):
+        """ Apply the transformation on the goban size.
+        """
+        max_x = self.board.max_y - self.board.min_y
+        return 0, self.board.min_x, max_x, self.board.max_x
+
+    def get_new_side(self):
+        """ Apply the transformations on the sides.
+        """
+        return {
+            "TOP":   self.board.side["RIGHT"],
+            "LEFT":  self.board.side["TOP"],
+            "RIGHT": self.board.side["BOTTOM"],
+            "BOTTOM":self.board.side["LEFT"]
+        }
+
+class Symmetry(object):
+    """ A translation transformation.
+    """
+
+    def __init__(self, board):
+        self.board = board
+
+        self.x_flip = random.randint(0, 1) == 1
+        self.y_flip = random.randint(0, 1) == 1
+
+    def is_valid(self):
+        """ The transformation is valid if one flip is required in one
+        direction.  """
+        return self.x_flip or self.y_flip
+
+    def apply_points(self, coord):
+        """ Flip in both directions.
+        """
+        x, y = coord
+        if self.x_flip:
+            new_x = self.board.max_x - x + self.board.min_x
+        else:
+            new_x = x
+
+        if self.y_flip:
+            new_y = self.board.max_y - y + self.board.min_y
+        else:
+            new_y = y
+
+        return (new_x, new_y)
+
+    def get_new_size(self):
+        """ The size is not changed.
+        """
+        return self.board.min_x, self.board.min_y, self.board.max_x, self.board.max_y
+
+    def get_new_side(self):
+        """ There is no changes on the sides.
+        """
+        return {
+            "TOP":   self.board.side["BOTTOM" if self.y_flip else "TOP"],
+            "LEFT":  self.board.side["RIGHT" if self.x_flip else "LEFT"],
+            "RIGHT": self.board.side["LEFT" if self.x_flip else "RIGHT"],
+            "BOTTOM":self.board.side["TOP" if self.y_flip else "BOTTOM"]
+        }