random.randint

        checkbox1 = n("data-checkbox",{"id":"checkbox1"})
        checkbox2 = n("data-checkbox",{"id":"checkbox2"})
 
        if random.randint(0,1):
            checkbox1.children.append('checked')
        if random.randint(0,1):
            checkbox2.children.append('checked')
 
        checkboxgroupOptions = ['1','2','3']
        checkboxgroupValues = random.sample(checkboxgroupOptions, random.randint(0,len(checkboxgroupOptions)))
 
        selectOptions = ['1','2','11','12','21','22']
        selectmultipleValues = random.sample(selectOptions, random.randint(0,len(selectOptions)))
        selectone = random.sample(selectOptions, random.randint(0,len(selectOptions)))

        else:
            selectone = None
 
        currency1 = random.randint(1,9999) + random.random()
        currency2 = random.randint(1,9999) + random.random()
 
        return n('command', {'type': 'populate-values'},
            n('data-textinput', {'id':'textinput1'}, str(random.random())),
            n('data-textareainput', {'id':'textareainput1'}, str(random.choice(self.quotes))),
            checkbox1,
            checkbox2,
            n("data-radiogroup",{"id":"radiogroup1"}, str(random.randint(0,3))),

        checkbox1 = n("data-checkbox",{"id":"checkbox1"})
        checkbox2 = n("data-checkbox",{"id":"checkbox2"})
 
        if random.randint(0,1):
            checkbox1.children.append('checked')
        if random.randint(0,1):
            checkbox2.children.append('checked')
 
        checkboxgroupOptions = ['1','2','3']
        checkboxgroupValues = random.sample(checkboxgroupOptions, random.randint(0,len(checkboxgroupOptions)))
 
        selectOptions = ['1','2','11','12','21','22']
        selectmultipleValues = random.sample(selectOptions, random.randint(0,len(selectOptions)))
        selectone = random.sample(selectOptions, random.randint(0,len(selectOptions)))

        else:
            selectone = None
 
        currency1 = random.randint(1,9999) + random.random()
        currency2 = random.randint(1,9999) + random.random()
 
        return n('command', {'type': 'populate-values'},
            n('data-textinput', {'id':'textinput1'}, str(random.random())),
            n('data-textareainput', {'id':'textareainput1'}, str(random.choice(self.quotes))),
            checkbox1,
            checkbox2,
            n("data-radiogroup",{"id":"radiogroup1"}, str(random.randint(0,3))),

 
 
## Some random helpers
rndpt = lambda w, h: (random.randint(-w/2, w/2), random.randint(-h/2, h/2))
rndrct = lambda w, h: rndpt(w, h) + rndpt(w, h)
rndtxt = lambda: ''.join([random.choice(string.letters) for x in range(random.randint(5, 10))])
rndp = lambda: (random.randint(0, 100), )*2

            T.move(T.x+self.hstride, T.y+self.stride)
        else:
            self.firstTime = False
            T.size(random.randint(9, 48))
            T.listFonts().addCallback(lambda fnts: T.font(random.choice(fnts)))
 
 

    def __init__(self, canvas):
        canvas.alpha(random.randint(0, 100))
        Looper.__init__(self, canvas)
 
    def perform(self):
        self.canvas.alpha(self.canvas._alpha+self.stride)
        if self.canvas._alpha < 0 or self.canvas._alpha > 100:

    def onload(self, canvas):
        """Demo of drawing with a CanvasSocket object.
        """
        ## Create a bunch of groups
        for x in xrange(random.randint(5, 15)):
            newGroup = canvas.group()
            if random.choice([True, False]):

    def manipulateACanvas(self, canvas):
        canvas.reposition(*rndpt(self.width, self.height))
        canvas.S = S = canvas.sound('http://localhost/amen.mp3')
        S.play(timesLoop=5)
        for x in range(random.randint(1, 4)):
            canvas.pen( 
                random.randint(1, 10),
                random.randint(0, 0xffffff),
                random.randint(0, 100))
            canvas.move(*rndpt(self.width, self.height))
            choice = random.randint(0, 4)

            if choice == 0:
                canvas.line(*rndpt(self.width, self.height))
            elif choice == 1:
                canvas.fill(random.randint(0, 0xffffff), random.randint(0, 100))
                for x in range(random.randint(3, 20)):
                    if random.randint(0, 1):
                        canvas.line(*rndpt(self.width, self.height))

                imgname = random.choice(os.listdir("flsh/images"))
                I = canvas.image('/images/%s' % imgname)
                I.scale(*rndp())
                I.alpha(random.randint(0, 100))
                rotate = random.randint(-180, 180)
                I.rotate(rotate)
                I.move(*rndpt(self.width, self.height))

    def onKeyDown(self, canvas, key):
        if hasattr(canvas, 'x'):
            T = canvas.text(key, canvas.x, canvas.y, 200, 200)
            T.size(random.randint(9, 48))
            T.listFonts().addCallback(lambda fnts: T.font(random.choice(fnts)))
            canvas.x += 15
 

#!/usr/bin/env python
 
# placed in the public domain by Stavros Korokithakis
 
import time
import copy
from random import randrange, randint, seed, random, choice, triangular

def make_random_genome(node, depth=0):
    if depth >= MAX_DEPTH or random() > 0.7:
        node.opcode = OPCODE_NONE
        node.args = None
        node.value = randrange(MUX_SIZE + DATA_SIZE)
    else:
        node.opcode = randint(OPCODE_AND, OPCODE_IF)

# (c) Bearophile
#
# genetic algorithm
 
from random import random, randint, choice
from math import sin, pi
from copy import copy 

    def mutatePop(self):
        nmutations = int(round(self.popSize * self.genomeSize * self.geneMutationProb))
        for i in xrange(nmutations):
            individual = choice(self.population) 
            gene = randint(0, self.genomeSize-1)
            individual.genome[gene] = not individual.genome[gene] 
 

    def crossingOverPop(self):
        nCrossingOver = int(round(self.popSize * self.crossingOverProb))
        for i in xrange(nCrossingOver):
            ind1 = choice(self.population) 
            ind2 = choice(self.population) 
            crossPosition = randint(0, self.genomeSize-1)
            for j in xrange(crossPosition+1):

   numPens = int(pens)
 
   #start in a random spot
   plotter.goto(random.randint(left, right), random.randint(bottom, top))
   penNum = 1
 
   while True:
       plotter.selectPen(penNum)
 
       whichGesture = random.randint(0,5)
 
       if whichGesture == 0:
           print "circle!"
           plotter.circle(random.randint(10,5000), random.randint(1,180))

 
       elif whichGesture == 1:
           print "rect!"
           plotter.edgeRectRelative(random.randint(10,5000), random.randint(10,5000))        
 
       elif whichGesture == 2:
           print "filled rect!"
           ft = random.randint(1,8)

           if ft == 6 or ft == 7 or ft == 8:
               ft = 4
 
           space = random.randint(10,100)
           angle = random.randint(0,3) * 45
 
           print "fillType: %d space: %d angle: %d" % (ft, space, angle)
           plotter.fillType(ft, space, angle)
           plotter.shadeRectRelative(random.randint(10,2000), random.randint(10,2000))
 
       elif whichGesture == 3:
           print "draw a crazy line!"
           plotter.penDown()
           plotter.goto(random.randint(left, right), random.randint(bottom, top))

 
       elif whichGesture == 4:
           print "draw an abstract shape!"
           numPoints = random.randint(2,4)
           print "numPoints: ", numPoints
           firstX = random.randint(left, right)
           firstY = random.randint(bottom, top)
           plotter.goto(firstX, firstY)
           plotter.penDown()
           xRange = width/5
           yRange = height/5
 
           for i in range(numPoints):
               plotter.nudge(random.randint(int(-xRange), int(xRange)), random.randint(int(-yRange), int(yRange)))

 
       elif whichGesture == 5:
           print "just jump around!"
           plotter.goto(random.randint(left, right), random.randint(bottom, top))
 
       #pick a new pen?
       pickPen = random.randint(0,99)

'''
 
import itertools
from random import seed, randint
seed('Example CAP Database')
 
#Consider the Customers-Agents-Products (CAP) database with schema below.

#orders += list(Order(customers[t[0]], agents[t[1]], products[t[2]], randint(0,100)) for t in itertools.product(range(4), repeat=3))
 
orders = [
        Order(customers[0], agents[0], products[0], randint(0,100)),
        Order(customers[0], agents[1], products[0], randint(0,100)),
        Order(customers[0], agents[2], products[0], randint(0,100)),
        Order(customers[1], agents[3], products[1], randint(0,100)),
        Order(customers[2], agents[0], products[3], randint(0,100)),
        Order(customers[3], agents[1], products[2], randint(0,100)),
        Order(customers[3], agents[2], products[1], randint(0,100)),
        Order(customers[1], agents[3], products[2], randint(0,100)),
        Order(customers[3], agents[3], products[2], randint(0,100)),
        Order(customers[0], agents[3], products[2], randint(0,100)),
        Order(customers[4], agents[3], products[2], randint(0,100)),

        Order(customers[3], agents[3], products[2], randint(0,100)),
        Order(customers[0], agents[3], products[2], randint(0,100)),
        Order(customers[4], agents[3], products[2], randint(0,100)),
        Order(customers[5], agents[3], products[2], randint(0,100)),
        Order(customers[4], agents[1], products[1], randint(0,100)),
        Order(customers[2], agents[1], products[1], randint(0,100)),
    ]

    # Create subtree depending on the plotter to be used
    cc = []
    if pnode == 'PyCurvePlotter' or pnode == 'PyValuePlotter':
        cc = [ns[str(i)] << Meq.Constant(rd.randint(0,100)) for i in range(50)]
 
    elif pnode == 'PyScatterPlotter':
        cc = [ns[str(i)] << Meq.Composer(Meq.Constant(rd.randint(0,100)), Meq.Constant(rd.randint(0,100)))
                                for i in range(25) ]
 
    elif pnode == 'PyCohaerencyMatrixPlotter':
        cc = [ns['matrix:' + str(i)] << Meq.Composer(Meq.Constant(complex(rd.randint(-50,0), rd.randint(0,50))), 
                            Meq.Constant(complex(rd.randint(0,50), rd.randint(0,50))), 
                            Meq.Constant(complex(rd.randint(-50,0), rd.randint(-50,0))), 
                            Meq.Constant(complex(rd.randint(0,50), rd.randint(-50,0))), dims = (2,2))

import sys
import ydbf
from decimal import Decimal
from random import randint, choice
from datetime import date
 
def get_n_random(size, dec):
    assert size < 20, "number cannot be longer than 20 digits (got %s)" % size
    assert dec < size, "size (%s) must be bigger than dec (%s)" % (size, dec)
    n = randint(0, 10**(size-dec-1)-1)
    if dec:
        if size-dec-1 == 0:
            dec = dec -1
        decimal_part = [int(y) for y in str(randint(1, 10**(dec-1)))]

def get_d_random(size, dec):
    try:
        return date(randint(1899, 2030), randint(1,12), randint(1,31))
    except ValueError:
        return get_d_random(size, dec)
 
def get_c_random(size, dec, force_ascii=False):

        alph = alphabet[0]
    else:
        alph = choice(alphabet)
    size = randint(size/2, size)
    while len(c) < size:
        c += choice(alph['consonants']) + choice(alph['vowels'])
        if choice((False, False, False, False, False, True)):

    # most popular field type is a numeric
    # next string, next date and the last -- logical
    typ = choice(('N', 'N', 'N', 'N', 'C', 'C', 'C', 'D', 'D', 'L'))
    size = randint(*size_limits[typ])
    dec = 0
    if typ == 'N' and size > 6:
        rand_dec = randint(0, size/2)

 
        E = []
        for n in xrange(10*len(V)):
            u = V[random.randint(0, len(V) - 1)]
            while True:
                v = V[random.randint(0, len(V) - 1)]
                if v is not u:

if __name__ == '__main__':
    for n in xrange(100):
        G = Graph()
        s = G.V[random.randint(0, len(G.V) - 1)]
        while True:
            t = G.V[random.randint(0, len(G.V) - 1)]
            if t is not s: