Changeset - a362783e3bec
Parent rev.
Child rev.
[Not reviewed]
default
1 4 0
Laman - 8 years ago 2017-01-24 20:57:58

exporting SGF back to string, also useful Composed and Point property classes
5 files changed with 58 insertions and 4 deletions:
src/__init__.py
del
src/sgfParser/collection.py
1
1
src/sgfParser/node.py
26
src/sgfParser/property.py
29
3
src/tests/testSgfParser.py
2
0 comments (0 inline, 0 general)
src/__init__.py
➞
Show inline comments
 
deleted file
src/sgfParser/collection.py
➞
Show inline comments
 
@@ -60,25 +60,25 @@ class GameTree:
 
	## Expand multiple games into distinct GameTrees and yield each.
 
	def listGames(self):
 
		for node in self._listGINodes():
 
			yield self._buildSubtree(node)
 
 
	def getNode(self,i):
 
		if 0<=i<len(self.nodes):
 
			return self.nodes[i]
 
		return None
 
 
	## Create and return a new game tree containing the provided Node.
 
	#
 
	# Ancestor nodes are copied, descendants are taken directly.
 
	# Ancestor nodes are copied, descendants are shared.
 
	def _buildSubtree(self,seedNode):
 
		node=seedNode.copy()
 
 
		while node.parent:
 
			newNode=node.parent.copy()
 
			node.parent=newNode
 
			newNode.setChildren([node])
 
			node=newNode
 
 
		return node
 
 
	## Find and yield Game Info nodes.
src/sgfParser/node.py
➞
Show inline comments
 
@@ -59,12 +59,38 @@ class Node:
 

			




	
	
	
		
 
	## Create a copy of the Node, with deep copied propeties and shallow copied parent and children.

			




	
	
	
		
 
	def copy(self):

			




	
	
	
		
 
		res=Node()

			




	
	
	
		
 
		res.properties={k: v.copy() for (k,v) in self.properties.items()}

			




	
	
	
		
 
		res.parent=self.parent

			




	
	
	
		
 
		res.setChildren(self.children[:])

			




	
	
	
		
 
		return res

			




	
	
	
		
 

			




	
	
	
		
 
	def getProperty(self,name):

			




	
	
	
		
 
		if name in self.properties: return self.properties[name]

			




	
	
	
		
 
		else: return None

			




	
	
	
		
 

			




	
	
	
		
 
	## Returns textual representation of the Node itself, but disregards its children.

			




	
	
	
		
 
	def __str__(self):

			




	
	
	
		
 
		return ";" + "".join(str(p) for p in self.properties.values())

			




	
	
	
		
 

			




	
	
	
		
 
	def export(self):

			




	
	
	
		
 
		# there is a beatiful recursive solution, which this stack is too narrow to contain

			




	
	
	
		
 
		stack=[(self,1,1)]

			




	
	
	
		
 
		output=[]

			




	
	
	
		
 

			




	
	
	
		
 
		while len(stack)>0:

			




	
	
	
		
 
			node,left,right=stack.pop()

			




	
	
	
		
 
			if left>0: output.append("("*left)

			




	
	
	
		
 
			output.append(str(node))

			




	
	
	
		
 

			




	
	
	
		
 
			childCount=len(node.children)

			




	
	
	
		
 
			if childCount==0: # a leaf

			




	
	
	
		
 
				output.append(")"*right)

			




	
	
	
		
 
			elif childCount==1: # a line

			




	
	
	
		
 
				stack.append((node.children[0],0,right))

			




	
	
	
		
 
			else: # a branching node

			




	
	
	
		
 
				# first child pops first, last child closes parent's parentheses

			




	
	
	
		
 
				children=zip(node.children,[1]*childCount,[1]*(childCount-1)+[1+right])

			




	
	
	
		
 
				stack.extend(reversed(children))

			




	
	
	
		
 

			




	
	
	
		
 
		return "".join(output)

			




        

    


    
    

    

        

                

                    src/sgfParser/property.py
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
import re

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
GAME_INFO=1

			




	
	
	
		
 
UNKNOWN=99

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class Composed:

			




	
	
	
		
 
	def __init__(self,a=None,b=None):

			




	
	
	
		
 
		self.a=a

			




	
	
	
		
 
		self.b=b

			




	
	
	
		
 

			




	
	
	
		
 
	def __str__(self):

			




	
	
	
		
 
		return "{0}:{1}".format(self.a,self.b)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class Point:

			




	
	
	
		
 
	def __init__(self,c,r):

			




	
	
	
		
 
		self.r=r

			




	
	
	
		
 
		self.c=c

			




	
	
	
		
 

			




	
	
	
		
 
	def __iter__(self):

			




	
	
	
		
 
		yield self.c

			




	
	
	
		
 
		yield self.r

			




	
	
	
		
 

			




	
	
	
		
 
	def __str__(self):

			




	
	
	
		
 
		a=ord("a")

			




	
	
	
		
 
		return chr(a+self.c)+chr(a+self.r)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def choose(*vTypes):

			




	
	
	
		
 
	def f(s,start):

			




	
	
	
		
 
		for vType in vTypes:

			




	
	
	
		
 
			i,x=vType(s,start)

			




	
	
	
		
 
			if x is not None: return (i,x)

			




	
	
	
		
 
		return (start,None)

			




	
	
	
		
 
	return f

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def singleton(vType):

			




	
	
	
		
 
	def f(s,start):

			




	
	
	
		
 
		if s[start]!="[":

			




	
	
		
 
@@ -36,25 +59,25 @@ def listOf(vType,allowEmpty=False):

			




	
	
	
		
 
			i,x=single(s,i)

			




	
	
	
		
 
		if len(res)==0 and not allowEmpty: return (start,None)

			




	
	
	
		
 
		return (i,res)

			




	
	
	
		
 
	return f

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def compose(vTypeA,vTypeB):

			




	
	
	
		
 
	def f(s,start):

			




	
	
	
		
 
		i,a=vTypeA(s,start)

			




	
	
	
		
 
		if a==None or s[i]!=":": return (start,None)

			




	
	
	
		
 
		i,b=vTypeB(s,i+1)

			




	
	
	
		
 
		if b==None: return start,None

			




	
	
	
		
 
		return (i,(a,b))

			




	
	
	
		
 
		return (i,Composed(a,b))

			




	
	
	
		
 
	return f

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def number(s,start):

			




	
	
	
		
 
	r=re.compile(r"(\+|-|)\d+")

			




	
	
	
		
 
	m=r.match(s,start)

			




	
	
	
		
 
	if m is None: return (start,None)

			




	
	
	
		
 
	res=int(m.group(0))

			




	
	
	
		
 
	return (m.end(),res)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def real(s,start):

			




	
	
		
 
@@ -119,25 +142,25 @@ def anything(s,start):

			




	
	
	
		
 

			




	
	
	
		
 
# go specific

			




	
	
	
		
 
def point(s,start):

			




	
	
	
		
 
	r=re.compile(r"[a-zA-Z]{2}|") # !! limit to board size

			




	
	
	
		
 
	m=r.match(s,start)

			




	
	
	
		
 
	if m is None: return (start,None)

			




	
	
	
		
 
	if m.group(0)=="": # pass, !! tt

			




	
	
	
		
 
		return (m.end(),tuple())

			




	
	
	
		
 
	col=m.group(0)[0]

			




	
	
	
		
 
	row=m.group(0)[1]

			




	
	
	
		
 
	col=ord(col) - (ord("a") if "a"<=col<="z" else ord("A")-26)

			




	
	
	
		
 
	row=ord(row) - (ord("a") if "a"<=row<="z" else ord("A")-26)

			




	
	
	
		
 
	return (m.end(),(col,row))

			




	
	
	
		
 
	return (m.end(),Point(col,row))

			




	
	
	
		
 

			




	
	
	
		
 
move=point

			




	
	
	
		
 
stone=point

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class Property:

			




	
	
	
		
 
	def __init__(self):

			




	
	
	
		
 
		self.name=""

			




	
	
	
		
 
		self.value=""

			




	
	
	
		
 

			




	
	
	
		
 
	@staticmethod

			




	
	
	
		
 
	def create(s,start):

			




	
	
		
 
@@ -168,28 +191,31 @@ class Property:

			




	
	
	
		
 
			print('warning, unknown property "{0}" at position {1}'.format(name,start))

			




	
	
	
		
 
			return singleton(anything)(s,start)

			




	
	
	
		
 

			




	
	
	
		
 
	@property

			




	
	
	
		
 
	def type(self):

			




	
	
	
		
 
		gameInfo={"AN","BR","BT","CP","DT","EV","GN","GC","ON","OT","PB","PC","PW","RE","RO","RU","SO","TM","US","WR","WT"}

			




	
	
	
		
 
		if self.name in gameInfo: return GAME_INFO

			




	
	
	
		
 
		else: return UNKNOWN

			




	
	
	
		
 

			




	
	
	
		
 
	def copy(self):

			




	
	
	
		
 
		res=Property()

			




	
	
	
		
 
		res.name=self.name

			




	
	
	
		
 
		# !! wouldn't work for listOf(listOf())

			




	
	
	
		
 
		res.value=self.value if not isinstance(self.value,list) else self.value[:]

			




	
	
	
		
 
		return res

			




	
	
	
		
 

			




	
	
	
		
 
	def __str__(self):

			




	
	
	
		
 
		val="[{0}]".format(self.value) if not isinstance(self.value,list) else "".join("[{0}]".format(x) for x in self.value)

			




	
	
	
		
 
		return "{0}{1}".format(self.name,val)

			




	
	
	
		
 

			




	
	
	
		
 
	patterns={

			




	
	
	
		
 
		"B":singleton(move),

			




	
	
	
		
 
		"KO":singleton(empty),

			




	
	
	
		
 
		"MN":singleton(number),

			




	
	
	
		
 
		"W":singleton(move),

			




	
	
	
		
 
		"AB":listOf(stone), #

			




	
	
	
		
 
		"AE":listOf(point), #

			




	
	
	
		
 
		"AW":listOf(stone), #

			




	
	
	
		
 
		"PL":singleton(color),

			




	
	
	
		
 
		"C":singleton(text(simple=False)),

			




	
	
	
		
 
		"DM":singleton(double),

			




	
	
	
		
 
		"GB":singleton(double),

			




        

    


    
    

    

        

                

                    src/tests/testSgfParser.py
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -20,24 +20,26 @@ class TestProperty(TestCase):

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class TestCollection(TestCase):

			




	
	
	
		
 
	def testSubtrees(self):

			




	
	
	
		
 
		c=Collection("""

			




	
	
	
		
 
(;B[aa]

			




	
	
	
		
 
	(;W[ab]PB[Some Black]PW[Some White];B[ac])

			




	
	
	
		
 
	(;W[bb]PB[Other Black]PW[Other White])

			




	
	
	
		
 
)""")

			




	
	
	
		
 
		games=list(c.listGames())

			




	
	
	
		
 

			




	
	
	
		
 
		self.assertEqual(len(games),2)

			




	
	
	
		
 
		self.assertRegex(games[0].export(), r"^\(;B\[aa];(PB\[Some Black]|PW\[Some White]|W\[ab]){3};B\[ac]\)$")

			




	
	
	
		
 
		self.assertRegex(games[1].export(), r"^\(;B\[aa];(PB\[Other Black]|PW\[Other White]|W\[bb]){3}\)$")

			




	
	
	
		
 

			




	
	
	
		
 
	def testEmptySgf(self):

			




	
	
	
		
 
		Collection("(;)")

			




	
	
	
		
 

			




	
	
	
		
 
	def testSimpleSgf(self):

			




	
	
	
		
 
		with open(os.path.join(dataDir, "simple.sgf")) as f:

			




	
	
	
		
 
			Collection(f.read())

			




	
	
	
		
 

			




	
	
	
		
 
	def testComplexSgf(self):

			




	
	
	
		
 
		with open(os.path.join(dataDir, "kogos.sgf")) as f:

			




	
	
	
		
 
			Collection(f.read())

			




	
	
	
		
 

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








    
        Server instance: Sirius-560
    
    
        This site is powered by
            Kallithea 0.7.0,
        which is
        © 2010–2023 by various authors & licensed under GPLv3.
            – Support