^\.

__pycache__/

^in/

^out/

movesPerDiagram=75

highNumbers=True

  extension="svg"

  highNumbers=True

  extension="tex"

  highNumbers=True

    self.content=r'''\begin{tikzpicture}

  \draw[step=\boardSquare,gray,very thin] (0,0) grid (18\boardSquare,18\boardSquare);

  \draw (0,0) rectangle (18\boardSquare,18\boardSquare);

  '''

        self.content+=r'''  \filldraw[fill=black] ({0}\boardSquare,{1}\boardSquare) circle[radius=0.04];'''.format(6*i+3, 6*j+3)+'\n'

    self.footer=r'\end{tikzpicture}' '\n'

    self.content+=r'  \filldraw[draw=black,fill={0}] ({1}\boardSquare,{2}\boardSquare) circle[radius=0.5\boardSquare];'.format(fill,x,18-y)+'\n'

    self.content+=r'  \filldraw[draw=black,fill={0}] ({1}\boardSquare,{2}\boardSquare) circle[radius=0.5\boardSquare] node[color={3}]{{{4}}};'.format(fill,x,18-y,labelColor,label)+'\n'

  shortName="".join(re.split(r'[/\\]',fileName)[-1].split('.')[:-1])

	# TODO rozumně pracovat s adresáři

    t=open(os.path.join(os.path.dirname(__file__),"out","{0}-{1}.{2}".format(shortName,i+1,diagram.extension)),'w') # nový soubor

  notes=open(os.path.join(os.path.dirname(__file__),"out","{0}.txt".format(shortName)),'w')

  # relativně vůči work directory nebo vůči skriptu?

  # item=os.path.join(os.path.dirname(__file__),item)

    print("{0}... ".format(item),end="")

    files+=[os.path.join(item,child) for child in os.listdir(item)]

class Collection:

  gameTrees=[]

  def export(self):

    res=""

    for root in gameTrees:

      res+="({0})\n".format(root.fullExport())

    return res

class Node:

  parent=None

  children=[]

  properties={}

  def newChild(self):

    child=Node()

    child.parent=self

    self.children.append(child)

    return child

  def addChild(self,child):

    child.parent=self

    self.children.append(child)

  def delChild(self,index):

    del self.children[index]

  def setProperty(self): pass

  def getProperty(self): pass

  def fullExport(self):

    res=self.export()

    if len(self.children)==1: res+=children[0].fullExport()

    else:

      for child in self.children:

        res+=child.fullExport()

    return res

  def export(self):

    res=";"

    for name,value in properties.items():

      res+="{0}[{1}]".format(name,value) # !! str(value)

    res+="\n"

    return res

class Property:

  name=""

  value=None

class ListOf(Property):

  values=[]

  vType=None

  def __str__(self):

    return "["+"][".join(self.values)+"]"

class Composed(Property):

  value=()

  def __str__(self):

    return self.value[0]+":"+self.value[1] # !! str(self.value[0])

class Point(Property): # !! pass

  row=0

  col=0

  def __str__(self):

    f=lambda x: chr(x+ord("a")) if x<26 else chr(x-26+ord("A"))

    row=f(self.row)

    col=f(self.col)

    return col+row

def skipWhitespace(str,start):

  i=start

  while i<len(str) and str[i].isspace(): i+=1

  return i

class Collection:

  gameTrees=[]

  def __init__(self,str):

    self.gameTrees=[]

    i,x=GameTree.create(str,0)

    if x is None:

      print("error when parsing Collection")

      return

    while x is not None:

      self.gameTrees.append(x)

      i,x=GameTree.create(str,i)

class GameTree:

  nodes=[]

  branches=[]

  def create(str,start):

    res=GameTree()

    i=skipWhitespace(str,start)

    if i>=len(str) or str[i]!="(":

      # print("error when parsing GameTree")

      return (start,None)

    i=skipWhitespace(str,i)

    i,x=Node.create(str,start+1)

    if x is None:

      # print("error when parsing GameTree")

      return (i,None)

    while x is not None:

      res.nodes.append(x)

      i=skipWhitespace(str,i)

      i,x=Node.create(str,i)

    i=skipWhitespace(str,i)

    i,x=GameTree.create(str,i)

    while x is not None:

      res.branches.append(x)

      i=skipWhitespace(str,i)

      i,x=GameTree.create(str,i)

    if str[i]!=")":

      # print("error when parsing GameTree")

      return (i,None)

    return (i+1,res)

class Node:

  properties=dict()

  def create(str,start):

    res=Node()

    if str[start]!=";":

      # print("error when parsing Node")

      return (start,None)

    i=skipWhitespace(str,start+1)

    i,x=Property.create(str,i)

    while x is not None:

      if x.name in res.properties:

        print('error: duplicate "{0}" property in node at position {1}. second value ignored'.format(x.name,start))

      else:

        res.properties[x.name]=x

      i=skipWhitespace(str,i)

      i,x=Property.create(str,i)

    return (i,res)

  def setProperty(self,name,value):

    self.properties[name]=value

    # zkontrolovat typ value

  def getProperty(self,name):

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

    else: return None

class Property:

  name=""

  value=""

  def create(str,start):

    res=Property()

    i,x=Property.ident(str,start)

    if x is None:

      return (start,None)

    res.name=x

    i,x=PropValue.create(str,i,res.name)

    if x is None:

      print('error when parsing property "{0}" at position {1}'.format(res.name,i))

      return (start,None)

    # while x is not None: # přesunuto do PropValue.listOf

      # res.values.append(x)

      # i=skipWhitespace(str,i)

      # i,x=PropValue.create(str,i,res.name)

    res.values.append(x) # !! podezřelé

    return (i,res)

  def ident(str,start):

    r=re.compile(r"[A-Z]+")

    m=r.match(str,start)

    if m is None: return (start,None)

    return (m.end(),m.group())

class PropValue:

  type=""

  value=None

  patterns=dict()

  def create(str,start,name):

    if name in PropValue.patterns:

      return PropValue.patterns[name](str,start)

    else:

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

      return PropValue.singleton(PropValue.anything)(str,start)

  # def singleton(str,start,vType):

    # if str[start]!="[":

      # return (start,None)

    # i,x=vType(str,start+1)

    # if x is None: return (start,None)

    # if str[i]!="]":

      # return (start,None)

    # return (i+1,x)

  def choose(*vTypes):

    def f(str,start):

      for vType in vTypes:

        i,x=vType(str,start)

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

      return (start,None)

    return f

  def singleton(vType):

    def f(str,start):

      if str[start]!="[":

        return (start,None)

      i,x=vType(str,start+1)

      if x is None: return (start,None)

      if str[i]!="]":

        return (start,None)

      return (i+1,x)

    return f

  # def listOf(str,start,vType,allowEmpty=False):

    # res=[]

    # i,x=singleton(str,start,vType)

    # # singleton(vType) if vType not tuple else compose(vType[0],vType[1])

    # while x!=None:

      # res.append(x)

      # i,x=singleton(str,i,vType)

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

    # return (i,res)

  def listOf(vType,allowEmpty=False):

    def f(str,start):

      res=[]

      single=singleton(vType)

      i,x=single(str,start)

      while x!=None:

        res.append(x)

        i,x=single(str,i)

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

      return (i,res)

    return f

  # def compose(str,start,vTypeA,vTypeB):

    # i,a=vTypeA(str,start)

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

    # i,b=vTypeB(str,i+1)

    # if b==None: return start,None

    # return (i,(a,b))

  def compose(vTypeA,vTypeB):

    def f(str,start):

      i,a=vTypeA(str,start)

      # print(">",i,a)

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

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

      # print(">",i,b)

      if b==None: return start,None

      return (i,(a,b))

    return f

  def number(str,start):

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

    m=r.match(str,start)

    if m is None: return (start,None)

    res=int(m.group(0))

    return (m.end(),res)

  def real(str,start):

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

    m=r.match(str,start)

    if m is None: return (start,None)

    res=float(m.group(0))

    return (m.end(),res)

  def double(str,start):

    r=re.compile(r"1|2")

    m=r.match(str,start)

    if m is None: return (start,None)

    res=int(m.group(0))

    return (m.end(),res)

  def color(str,start):

    r=re.compile(r"B|W")

    m=r.match(str,start)

    if m is None: return (start,None)

    return (m.end(),m.group(0))

  # def simpleText(str,start):

    # res=""

    # esc=False

    # lineBreak=False

    # for c in str:

      # if esc:

        # res+=c

        # esc=False

      # elif c=="\\":

        # esc=True

      # elif c=="]":

        # break

      # else:

        # res+=c

    # return res

  def text(simple=True,composed=False):

    def f(str,start):

      res=""

      esc=False

      lastC=""

      for i,c in enumerate(str[start:],start):

        if esc:

          if c!="\n" and c!="\r": res+=c

          esc=False

        elif (c=="\n" and lastC=="\r") or (c=="\r" and lastC=="\n"): pass

        elif c=="\r" or c=="\n" and not simple:

          res+="\n"

        elif c.isspace():

          res+=" "

        elif c=="\\":

          esc=True

        elif c=="]" or (c==":" and composed):

          break

        else:

          res+=c

        lastC=c

      return (i,res)

    return f

  def empty(str,start): return (start,"")

  def anything(str,start): # přidat listOf

    esc=False

    for i,c in enumerate(str[start:],start):

      if esc: esc=False

      elif c=="\\": esc=True

      elif c=="]": break

    return (i,str[start:i])

  # go specific

  def point(str,start):

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

    m=r.match(str,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))

  move=point

  stone=point

  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),

    "GW":singleton(double),

    "HO":singleton(double),

    "N":singleton(text()),

    "UC":singleton(double),

    "V":singleton(real),

    "BM":singleton(double),

    "DO":singleton(empty),

    "IT":singleton(empty),

    "TE":singleton(double),

    "AR":listOf(compose(point,point)), #

    "CR":listOf(point), #

    "DD":listOf(point,allowEmpty=True), #

    "LB":listOf(compose(point,text())), #

    "LN":listOf(compose(point,point)), #

    "MA":listOf(point), #

    "SL":listOf(point), #

    "SQ":listOf(point), #

    "TR":listOf(point), #

    "AP":singleton(compose(text(composed=True),text())), #

    "CA":singleton(text()),

    "FF":singleton(number),

    "GM":singleton(number),

    "ST":singleton(number),

    "SZ":choose(singleton(number),singleton(compose(number,number))), #

    "AN":singleton(text()),

    "BR":singleton(text()),

    "BT":singleton(text()),

    "CP":singleton(text()),

    "DT":singleton(text()),

    "EV":singleton(text()),

    "GN":singleton(text()),

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

    "ON":singleton(text()),

    "OT":singleton(text()),

    "PB":singleton(text()),

    "PC":singleton(text()),

    "PW":singleton(text()),

    "RE":singleton(text()),

    "RO":singleton(text()),

    "RU":singleton(text()),

    "SO":singleton(text()),

    "TM":singleton(real),

    "US":singleton(text()),

    "WR":singleton(text()),

    "WT":singleton(text()),

    "BL":singleton(real),

    "OB":singleton(number),

    "OW":singleton(number),

    "WL":singleton(real),

    "FG":choose(singleton(empty),singleton(compose(number,text()))), #

    "PM":singleton(number),

    "VW":listOf(point,allowEmpty=True), #

    # go specific

    "HA":singleton(number),

    "KM":singleton(real),

    "TB":listOf(point,allowEmpty=True),

    "TW":listOf(point,allowEmpty=True)

  }

"""def property(str):

  # i=propIdent(str)

  # if i<0: return -1

  # j=i

  # i=propValue(str[i:])

  # while i>=0:

    # j+=i

    # i=propValue(str[i:])

  # return j

def propIdent(str):

  m=re.match(r"[A-Z]+",str)

  if m is None: return -1

  return m.end()

def propValue(str):

  i=cValueType(str[1:])

  if str[0]=="[" and i>=0 and str[i]=="]": return i+1

  else: return -1

class propValue:

  pass

def cValueType(str,start):

  matches=[real,number,double,color,simpleText]

  for f in matches:

    i,x=f(str,start)

    if x is not None: return i,x

  return 1/0

def number(str,start):

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

  m=r.match(str,start)

  if m is None: return (-1,None)

  x=int(m.group(0))

  return (m.end(),x)

def real(str):

  m=re.match(r"(\+|-|)\d+(\.\d+)?",str)

  if m is None: return -1

  return m.end()

def double(str):

  m=re.match(r"1|2",str)

  if m is None: return -1

  return m.end()

def color(str):

  m=re.match(r"B|W",str)

  if m is None: return -1

  return m.end()

def simpleText(str):

  res=r""

  esc=False

  for c in str:

    if esc:

      res+=c

      esc=False

    elif c=="\\":

      esc=True

    elif c=="]":

      break

    else:

      res+=c

  return res"""

sgf=open("in/1-Hora-Simara.sgf").read()

x=Collection(sgf)

# TODO:

# date

"""

# move

B	move

KO	none

MN	number

W	move

# setup

AB	list of stone

AE	list of point

AW	list of stone

PL	color

# node annotation

C	text

DM	double

GB	double

GW	double

HO	double

N	simpleText

UC	double

V	real

# move annotation

BM	double

DO	none

IT	none

TE	double

# markup

AR	list of composed point:point

CR	list of point

DD	elist of point

LB	list of composed point:simpleText

LN	list of composed point:point

MA	list of point

SL	list of point

SQ	list of point

TR	list of point

# root

AP	composed simpleText:simpleText

CA	simpleText

FF	number

GM	number

ST	number

SZ	number | composed number:number

# game info

AN	simpleText

BR	simpleText

BT	simpleText

CP	simpleText

DT	simpleText

EV	simpleText

GN	simpleText

GC	text

ON	simpleText

OT	simpleText

PB	simpleText

PC	simpleText

PW	simpleText

RE	simpleText

RO	simpleText

RU	simpleText

SO	simpleText

TM	real

US	simpleText

WR	simpleText

WT	simpleText

# timing

BL	real

OB	number

OW	number

WL	real

# misc

FG	none | composition of number:simpleText

PM	number

VW	elist of point

"""