ccg2.py

from pprint import pprint
import json
def application(functor, arg, slash):
    if functor is None or arg is None:
        return None
    if '/' in arg or '\\' in arg:
        arg = '(' + arg + ')'
    arg = slash + arg
    if functor.endswith(arg):
        res = functor[:-len(arg)]
        if '/' in res or '\\' in res:
            return res[1:-1]
        return res


def fwd_app(left, right):
    return application(left, right, '/')


def bwd_app(left, right):
    return application(right, left, '\\')

levels = [[]]
things = input("Enter categories: ").split(" ")
for t in things:
    levels[0].append([t])
j = 0
#pprint(levels)
while j < len(things):
    i = 0
    levels.append([])
    #for t in range(j):
    #    while i < len(levels[j-1-t])-1:
    #        if t == 0:
    #            levels[j].append([])
    #        for x in levels[j-1-t][i]:
    #            #print(levels[j][i])
    #            for y in levels[j-1+t][i+1-t]:
    #                left, right = x, y
    #                if fwd_app(left, right) is not None:
    #                    levels[j][-1].append(fwd_app(left, right))
    #                if bwd_app(left, right) is not None:
    #                    levels[j][-1].append(bwd_app(left, right))
    #        i += 1
    #j += 1
    for current_cell in range(len(levels[j-1])-1):
        levels[j].append([])
        for vertical in range(j):
            left = levels[vertical][current_cell]
            #print(levels[vertical],vertical)
            right = levels[j-vertical-1][current_cell+vertical+1]
            for l in left:
                for r in right:
                    if l != "conj":
                        levels[j][-1].append(bwd_app(l, r))
                        levels[j][-1].append(fwd_app(l, r))
                        #levels[j][-1].append("left: " + str(vertical) +" ,"+ str(current_cell)+ " right: " + str(j-vertical-1) +" ,"+ str(current_cell+vertical+1) + "current: " + str(j) +" ,"+ str(len(levels[j])-1))
                    else:
                        levels[j][-1].append(r+"\\"+r)
    j += 1

chart = levels[::-1][1:]
#print(chart)
#pprint(levels)
#print(json.dumps(levels[::-1][1:] ,indent=4, separators=(',', ': ')))
import re
import copy
from xml.etree import ElementTree

printList = list()

RE_TOKENS = re.compile(r'[()\\/\s]|[a-zA-Z]+')

def tokenize(cat):
    return RE_TOKENS.findall(cat)

def hassep(ccg):
    bracket = 0
    for token in ccg:
        if token == "(":
            bracket += 1
        elif token == ")":
            bracket -= 1
        if bracket == 0:
            if token == "/":
                return "/"
            elif token == "\\":
                return "\\"

    return ""

def getsepdistance(ccg):
    bracket = 0
    i = 0
    for token in ccg:
        if token == "(":
            bracket += 1
        elif token == ")":
            bracket -= 1
        if bracket == 0:
            if token == "/":
                return i
            elif token == "\\":
                return i
        i += 1

    return ""

def stripbrackets(ccg):
    if ccg[0] == "(" and ccg[-1] == ")":
        return ccg[1:-1]
    else:
        return ccg

def ccgparse(ccg):
    i = 0
    for token in ccg:
        if token == " ":
            forward = []
            back = []
            original = i
            brackets = 0
            while i >= 0:
                if ccg[i] == ")":
                    brackets += 1
                elif ccg[i] == "(":
                    brackets -= 1
                if brackets >= 0:
                    forward.append(ccg[i])
                else:
                    break
                i -= 1
            brackets = 0
            i = original
            while i < len(ccg):
                if ccg[i] == ")":
                    brackets -= 1
                elif ccg[i] == "(":
                    brackets += 1
                if brackets >= 0:
                    back.append(ccg[i])
                else:
                    break
                i += 1
            forward.reverse()
            forward = forward[:-1]
            back = back[1:]
            if hassep(forward) == "/":
                d = getsepdistance(forward)
                if stripbrackets(forward[d+1:]) == back:
                    return forward[:d]
            elif hassep(back) == "\\":
                d = getsepdistance(back)
                if stripbrackets(back[d+1:]) == forward:
                    return back[:d]
            return list(["No", " combination!"])
        i += 1

def parse(tokens):
    result = ccgparse(tokens)
    return result

def is_valid(cat1):
    tokens = tokenize(cat1)
    return ccgparse(tokens)

def cellContentToPrint(row, cellsInThisRow, cellWallPadding, cellWall, categories):
    subcategory = list()
    formattedStr = ''
    rowString = ''
    tokenString = ''
    cellString = ''
    separator = ','
    maxNumberOfTokensInRow = 0
    tokensFinished = False
    tokenIdx = 0
    doneForAllTokens = False
    tmpStr = ''

    rows = []
    while not doneForAllTokens:
        tokenString = ''
        for cellCounter in range(cellsInThisRow):
            alreadyAdded = False
            tokenString += cellWall
            for jj in range(len(categories)):
                subcategory = copy.deepcopy(categories[jj])
                if int(subcategory[0]) == row and int(subcategory[1]) == cellCounter:
                    formattedStr = formatStrings(cellWallPadding, subcategory[2])
                    numElements = len(formattedStr.split(separator))
                    if maxNumberOfTokensInRow < numElements:
                        maxNumberOfTokensInRow = numElements
                    if numElements >= tokenIdx + 1:
                        tmpStr = (formattedStr.split(separator))[tokenIdx]
                        break
            if tmpStr == '':
                tokenString += cellWallPadding
            else:
                tokenString += tmpStr
                tmpStr = ''
        tokenString += cellWall
        #print(tokenString)
        printList.append(tokenString)
        tokenString = ''
        #if tokenIdx < maxNumberOfTokensInRow:
        tokenIdx += 1
        if tokenIdx >= maxNumberOfTokensInRow:
            doneForAllTokens = True

def formatStrings(cellWallPadding, unformattedString):
    readyToPrint = ''
    separator = ','
    stringsToFormat = unformattedString.split(separator)
    for stringToFormat in stringsToFormat:
        strLen = len(stringToFormat)
        cellWidth = len(cellWallPadding)
        if strLen > cellWidth:
            readyToPrint += cellWallPadding
            if firstPassCompleted:
                readyToPrint += separator
        else:
            numOfSpaces = cellWidth - strLen
            if numOfSpaces == 0:
                readyToPrint = stringToFormat
                readyToPrint += separator
            elif numOfSpaces == 1: #leave it trailing
                readyToPrint = stringToFormat + ' '
                readyToPrint += separator
            else:
                for jj in range(numOfSpaces - 1):
                   readyToPrint += ' '
                readyToPrint += stringToFormat
                readyToPrint += ' '
                readyToPrint += separator
    #print(readyToPrint[0:-1])
    if readyToPrint == '':
        return cellWallPadding
    else:
        return readyToPrint[0:-1]

def drawDiagram(bottomRowLen, categories):
    cellFloor = '-----------'
    cellWall = '|'
    cellDelimiter = '+'
    cellWallPadding = '           '
    separator = ','

    tmpStrWall = ''
    tmpStrBottomFloor = ''
    for ii in range(bottomRowLen):
        for jj in range(ii + 1):
            tmpStrBottomFloor += cellDelimiter
            tmpStrBottomFloor += cellFloor
        cellContentToPrint(ii, ii + 1, cellWallPadding, cellWall, categories)
        print(tmpStrBottomFloor + cellDelimiter)
        for kk in range(len(printList)):
            print(printList[kk])
        del printList[:]
        if ii < bottomRowLen - 1:
            tmpStrWall = ''
            tmpStrBottomFloor = ''
    print(tmpStrBottomFloor + cellDelimiter)
    tmpStrWall = ''
    tmpStrBottomFloor = ''
    return

categories = list()
v = 0
for row in chart:
    t = 0
    for col in row:
        for x in col:
            if x is not None:
                categories.append([v, t, x])
        t += 1
    v += 1
drawDiagram(len(things), categories)