Python script for generating random C code

Question

I'm writing a Python script to randomly generate C functions. This is my first time using classes in Python and I'm basically doing my best to pretend I'm using Java.

I'm looking for a review of my OOP, Python style, and in general whether or not I'm doing things in the "Pythonic" way, whatever that means.

import random
import sys
import string

# writes text to a stored outputString
# fetch the outputString later for outputting
class Output:
    def __init__(self):
        self.clear()

    def clear(self):
        self.outputString = ''
        self.__lineStart = True
        self.lineCount = 0
        self.nestingLevel = 0           

    def __write(self, str):
        self.outputString += str    

    def line(self):
        self.__write('\n')
        self.__lineStart = True
        self.lineCount += 1

    def output(self, str):
        # start each line with tabs equal to nesting level      
        if(self.__lineStart == True):
            for q in range(0, self.nestingLevel):
                self.__write('\t')
            self.__lineStart = False

        self.__write(str)

    def incNesting(self):
        self.nestingLevel += 1

    def decNesting(self):
        self.nestingLevel -= 1

class Variables:
    def __init__(self, varCount):
        if varCount > 26:
            raise Exception('Don\'t you think you\'re being a bit too aggressive?')
        self.varCount = varCount
        lowercase = list(string.ascii_lowercase)
        self.variables = lowercase[0:varCount]

    def Rand(self, count = 1):
        if count > self.varCount:
            raise Exception('Variables.Rand requested more variables than available')
        elif count == 1:
            return random.choice(self.variables)
        elif count > 1:
            return random.sample(self.variables, count)
        else:
            raise Exception('Variables.Rand invalid argument')

    def InitStatement(self, out):
        out.output('int ')
        vars = []
        for var in self.variables:
            vars.append('%s = %i' % (var, random.randint(-0xFFFFFFF, 0xFFFFFFF)))
        out.output(', '.join(vars))
        out.output(';')
        out.line()      

class Action:
    def __init__(self, variables, output):
        self.variables = variables
        self.out = output
        self.labelCount = 0

class ControlSelector:
    @staticmethod
    def RandomControl(output, variables):
        controlType = random.choice(ControlType.implementedTypes)
        return ControlType.Make(controlType, output, variables)

class ControlType:
    STATEMENT = 1
    CONDITIONAL = 2
    GOTO = 3
    CALLGEN = 4
    CALLREAL = 5
    CALLAPI = 6
    STOP = 7
    allTypes = [STATEMENT, CONDITIONAL, GOTO, CALLGEN, CALLREAL, CALLAPI, STOP]
    implementedTypes = [STATEMENT, CONDITIONAL, STOP]

    @staticmethod
    def Make(controlType, output, variables): # factory pattern .. I think
        if(controlType ==  ControlType.STATEMENT):
            return StatementControl(output, variables)
        elif(controlType ==  ControlType.CONDITIONAL):
            return ConditionalControl(output, variables)
        elif(controlType ==  ControlType.STOP):
            return StopControl(output, variables)
        else:
            raise Exception('ControlType.Make bad argument')

    def __init__(self, output, variables):
        self.out = output
        self.variables = variables

    def Exec(self):
        raise NotImplementedError("")

    def PutCode(self):  
        control = ControlSelector.RandomControl(self.out, self.variables)

        control.Exec()

class PutCodeControl(ControlType):
    def Exec(self):
        self.PutCode()

class StatementControl(ControlType):
    def PutAssignment(self):
        dest, src = self.variables.Rand(2)
        self.out.output(src + ' = ' + dest + ';')
        self.out.line()     

    def Exec(self):
        self.PutAssignment()
        self.PutCode()

class ConditionalControl(ControlType):
    def PutConditional(self):
        first, second = self.variables.Rand(2)
        self.out.output('if(')
        self.out.output(first + ' == ' + second)
        self.out.output('){')
        self.out.line()     

    def PutCloseBrace(self):
        self.out.output('}')
        self.out.line()

    def PutIf(self):
        self.PutConditional()
        self.out.incNesting()
        self.PutCode()
        self.PutCloseBrace()
        self.out.decNesting()   

    def Exec(self):
        self.PutIf()
        self.PutCode()

class StopControl(ControlType):
    def Exec(self):
        return

class Function:
    totalFuncCounter = 0

    def __init__(self):
        self.funcNum = Function.totalFuncCounter
        Function.totalFuncCounter += 1

        self.variables = Variables(8)
        self.out = Output()
        self.name = 'RandFunc' + str(self.funcNum)

        self.action = Action(self.variables, self.out)

    def __FunctionHeader(self):
        self.out.output('int ' + self.name + '()')
        self.out.line()
        self.out.output('{')
        self.out.line()

    def __FunctionFooter(self):
        retval = self.variables.Rand()
        self.out.output('return ' + retval + ';')
        self.out.line()
        self.out.output('}')
        self.out.line()     

    def __Generate(self):       
        # int functionname()
        # {
        self.__FunctionHeader()

        # int a = 1, b = 2, etc
        self.variables.InitStatement(self.out)

        # [function body]
        PutCodeControl(self.out, self.variables).Exec()

        # return a;
        self.__FunctionFooter()

    def Generate(self, minLines = None):
        if minLines == None:
            minLines = 1 # < 1 will cause errors

        while self.out.lineCount < minLines:
            self.out.clear()
            self.__Generate()

    def OutputString(self):
        return self.out.outputString

def PrintLongFunction():
    func = Function()
    func.Generate(minLines = 50)
    sys.stdout.write(func.OutputString())

if __name__ == "__main__":
    PrintLongFunction()

Sample output is available here.

Answer 1

Welcome to python :)

pep8

If you want to go "pythonic" you may want to read pep8. It is the common coding guideline in the world of python.

Python Version

I assume you are writing python3 (your code works in 2.x and 3.x). If you are targeting 2.x you should add explicit inheritance from object. (keyword: new-style classes)

Doc-Strings

Doc-strings (the python equivalent to java-doc comments) are strings inside the block you comment:

class Output:
    """writes text to a stored outputString
       fetch the outputString later for outputting"""

underscores

def __write(self, str):
    self.outputString += str

In your use case there is no reason to prefix functions with __. It is not just a convention but does have a meaning for the interpreter as well.

shadowing built-in

Don't use str as variable name. There is a built-in type called str.

ControlSelector.RandomControl

If you want a function you make a function - not a method. There is no reason for having the class ControlSelector.

def random_control(output, variables):
    controlType = random.choice(ControlType.implementedTypes)
    return ControlType.Make(controlType, output, variables)

minLines == None

The line

if minLines == None:

was suggested to be replaced with

if not minLines:

be aware that this changes the behavior in case of Generate(minLines=0) since if not 0 is True while 0 == None evaluates to False. If you want to check for None use is:

if minLine is None:

The __main__ pattern

if __name__ == "__main__":
    PrintLongFunction()

Awesome. Using the __name__ == "__main__" pattern is something you should get used to. Great start.

Answer 2

In class Output:

def output(self, str):
    # start each line with tabs equal to nesting level      
    if(self.__lineStart == True):
        for q in range(0, self.nestingLevel):
            self.__write('\t')
        self.__lineStart = False

    self.__write(str)

can be rewritten as

def output(self, str):
    if self.__lineStart:
        self.__write('\t' * self.nestingLevel)
        self.__lineStart = False

    self.__write(str)

You thus remove the useless parenthesis of if condition and make the code shorter and cleaner.

You also can rewrite

Exception('Don\'t you think you\'re being a bit too aggressive?') 

as

Exception("Don't you think you're being a bit too aggressive?")

Some list comprehension :

vars = []
for var in self.variables:
  vars.append('%s = %i' % (var, random.randint(-0xFFFFFFF, 0xFFFFFFF)))

is equivalent to

vars = ['%s = %i' % (var, random.randint(-0xFFFFFFF, 0xFFFFFFF))
          for var in self.variables]

Replace

if minLines == None:

with

if not minLines: