signature:
def textheight ( self , txt , width = None ) :
    '''Returns the height of a string of text according to the current
 font settings .
 : param txt : string to measure
 : param width : width of a line of text in a block'''

implementation:
w = width
return self . textmetrics ( txt , width = w ) [ 1 ]


signature:
def graph_background ( s ) :
    """Graph background color ."""

implementation:
if s . background == None :
    s . _ctx . background ( None )
else :
    s . _ctx . background ( s . background )
if s . depth :
    try :
        clr = colors . color ( s . background ) . darker ( 0.2 )
        p = s . _ctx . rect ( 0 , 0 , s . _ctx . WIDTH , s . _ctx . HEIGHT , draw = False )
        colors . gradientfill ( p , clr , clr . lighter ( 0.35 ) )
        colors . shadow ( dx = 0 , dy = 0 , blur = 2 , alpha = 0.935 , clr = s . background )
    except :
        pass


signature:
def graph_traffic ( s , node , alpha = 1.0 ) :
    """Visualization of traffic - intensive nodes ( based on their centrality ) ."""

implementation:
r = node . __class__ ( None ) . r
r += ( node . weight + 0.5 ) * r * 5
s . _ctx . nostroke ( )
if s . traffic :
    s . _ctx . fill ( s . traffic . r , s . traffic . g , s . traffic . b , s . traffic . a * alpha )
    s . _ctx . oval ( node . x - r , node . y - r , r * 2 , r * 2 )


signature:
def node ( s , node , alpha = 1.0 ) :
    """Visualization of a default node ."""

implementation:
if s . depth :
    try :
        colors . shadow ( dx = 5 , dy = 5 , blur = 10 , alpha = 0.5 * alpha )
    except :
        pass
s . _ctx . nofill ( )
s . _ctx . nostroke ( )
if s . fill :
    s . _ctx . fill ( s . fill . r , s . fill . g , s . fill . b , s . fill . a * alpha )
if s . stroke :
    s . _ctx . strokewidth ( s . strokewidth )
    s . _ctx . stroke ( s . stroke . r , s . stroke . g , s . stroke . b , s . stroke . a * alpha * 3 )
r = node . r
s . _ctx . oval ( node . x - r , node . y - r , r * 2 , r * 2 )


signature:
def node_label ( s , node , alpha = 1.0 ) :
    """Visualization of a node ' s id ."""

implementation:
if s . text : # s . _ ctx . lineheight ( 1)
    s . _ctx . font ( s . font )
    s . _ctx . fontsize ( s . fontsize )
    s . _ctx . nostroke ( )
    s . _ctx . fill ( s . text . r , s . text . g , s . text . b , s . text . a * alpha )
    # Cache an outlined label text and translate it .
    # This enhances the speed and avoids wiggling text .
    try :
        p = node . _textpath
    except :
        txt = node . label
        try :
            txt = unicode ( txt )
        except :
            try :
                txt = txt . decode ( "utf-8" )
            except :
                pass
        # Abbreviation .
        # root = node . graph . root
        # if txt ! = root and txt [ - len ( root ) : ] = = root :
        # txt = txt [ : len ( txt ) - len ( root ) ] + root [ 0 ] + " . "
        dx , dy = 0 , 0
        if s . align == 2 : # CENTER
            dx = - s . _ctx . textwidth ( txt , s . textwidth ) / 2
            dy = s . _ctx . textheight ( txt ) / 2
        node . _textpath = s . _ctx . textpath ( txt , dx , dy , width = s . textwidth )
        p = node . _textpath
    if s . depth :
        try :
            __colors . shadow ( dx = 2 , dy = 4 , blur = 5 , alpha = 0.3 * alpha )
        except :
            pass
    s . _ctx . push ( )
    s . _ctx . translate ( node . x , node . y )
    s . _ctx . scale ( alpha )
    s . _ctx . drawpath ( p . copy ( ) )
    s . _ctx . pop ( )


signature:
def edges ( s , edges , alpha = 1.0 , weighted = False , directed = False ) :
    """Visualization of the edges in a network ."""

implementation:
p = s . _ctx . BezierPath ( )
if directed and s . stroke :
    pd = s . _ctx . BezierPath ( )
if weighted and s . fill :
    pw = [ s . _ctx . BezierPath ( ) for i in range ( 11 ) ]
# Draw the edges in a single BezierPath for speed .
# Weighted edges are divided into ten BezierPaths ,
# depending on their weight rounded between 0 and 10.
if len ( edges ) == 0 :
    return
for e in edges :
    try :
        s2 = e . node1 . graph . styles [ e . node1 . style ]
    except :
        s2 = s
    if s2 . edge :
        s2 . edge ( s2 , p , e , alpha )
        if directed and s . stroke :
            s2 . edge_arrow ( s2 , pd , e , radius = 10 )
        if weighted and s . fill :
            s2 . edge ( s2 , pw [ int ( e . weight * 10 ) ] , e , alpha )
s . _ctx . autoclosepath ( False )
s . _ctx . nofill ( )
s . _ctx . nostroke ( )
# All weighted edges use the default fill .
if weighted and s . fill :
    r = e . node1 . __class__ ( None ) . r
    s . _ctx . stroke ( s . fill . r , s . fill . g , s . fill . b , s . fill . a * 0.65 * alpha )
    for w in range ( 1 , len ( pw ) ) :
        s . _ctx . strokewidth ( r * w * 0.1 )
        s . _ctx . drawpath ( pw [ w ] . copy ( ) )
# All edges use the default stroke .
if s . stroke :
    s . _ctx . strokewidth ( s . strokewidth )
    s . _ctx . stroke ( s . stroke . r , s . stroke . g , s . stroke . b , s . stroke . a * 0.65 * alpha )
s . _ctx . drawpath ( p . copy ( ) )
if directed and s . stroke : # clr = s . _ ctx . stroke ( ) . copy ( )
    clr = s . _ctx . color ( s . stroke . r , s . stroke . g , s . stroke . b , s . stroke . a * 0.65 * alpha )
    clr . a *= 1.3
    s . _ctx . stroke ( clr )
    s . _ctx . drawpath ( pd . copy ( ) )
for e in edges :
    try :
        s2 = self . styles [ e . node1 . style ]
    except :
        s2 = s
    if s2 . edge_label :
        s2 . edge_label ( s2 , e , alpha )


signature:
def edge ( s , path , edge , alpha = 1.0 ) :
    """Visualization of a single edge between two nodes ."""

implementation:
path . moveto ( edge . node1 . x , edge . node1 . y )
if edge . node2 . style == BACK :
    path . curveto ( edge . node1 . x , edge . node2 . y , edge . node2 . x , edge . node2 . y , edge . node2 . x , edge . node2 . y , )
else :
    path . lineto ( edge . node2 . x , edge . node2 . y )


signature:
def edge_label ( s , edge , alpha = 1.0 ) :
    """Visualization of the label accompanying an edge ."""

implementation:
if s . text and edge . label != "" :
    s . _ctx . nostroke ( )
    s . _ctx . fill ( s . text . r , s . text . g , s . text . b , s . text . a * alpha * 0.75 )
    s . _ctx . lineheight ( 1 )
    s . _ctx . font ( s . font )
    s . _ctx . fontsize ( s . fontsize * 0.75 )
    # Cache an outlined label text and translate it .
    # This enhances the speed and avoids wiggling text .
    try :
        p = edge . _textpath
    except :
        try :
            txt = unicode ( edge . label )
        except :
            try :
                txt = edge . label . decode ( "utf-8" )
            except :
                pass
        edge . _textpath = s . _ctx . textpath ( txt , s . _ctx . textwidth ( " " ) , 0 , width = s . textwidth )
        p = edge . _textpath
    # Position the label centrally along the edge line .
    a = degrees ( atan2 ( edge . node2 . y - edge . node1 . y , edge . node2 . x - edge . node1 . x ) )
    d = sqrt ( ( edge . node2 . x - edge . node1 . x ) ** 2 + ( edge . node2 . y - edge . node1 . y ) ** 2 )
    d = abs ( d - s . _ctx . textwidth ( edge . label ) ) * 0.5
    s . _ctx . push ( )
    s . _ctx . transform ( CORNER )
    s . _ctx . translate ( edge . node1 . x , edge . node1 . y )
    s . _ctx . rotate ( - a )
    s . _ctx . translate ( d , s . fontsize * 1.0 )
    s . _ctx . scale ( alpha )
    # Flip labels on the left hand side so they are legible .
    if 90 < a % 360 < 270 :
        s . _ctx . translate ( s . _ctx . textwidth ( edge . label ) , - s . fontsize * 2.0 )
        s . _ctx . transform ( CENTER )
        s . _ctx . rotate ( 180 )
        s . _ctx . transform ( CORNER )
    s . _ctx . drawpath ( p . copy ( ) )
    s . _ctx . pop ( )


signature:
def path ( s , graph , path ) :
    """Visualization of a shortest path between two nodes ."""

implementation:
def end ( n ) :
    r = n . r * 0.35
    s . _ctx . oval ( n . x - r , n . y - r , r * 2 , r * 2 )
if path and len ( path ) > 1 and s . stroke :
    s . _ctx . nofill ( )
    s . _ctx . stroke ( s . stroke . r , s . stroke . g , s . stroke . b , s . stroke . a )
    if s . name != DEFAULT :
        s . _ctx . strokewidth ( s . strokewidth )
    else :
        s . _ctx . strokewidth ( s . strokewidth * 2 )
    first = True
    for id in path :
        n = graph [ id ]
        if first :
            first = False
            s . _ctx . beginpath ( n . x , n . y )
            end ( n )
        else :
            s . _ctx . lineto ( n . x , n . y )
    s . _ctx . endpath ( )
    end ( n )


signature:
def create ( self , stylename , ** kwargs ) :
    """Creates a new style which inherits from the default style ,
 or any other style which name is supplied to the optional template parameter ."""

implementation:
if stylename == "default" :
    self [ stylename ] = style ( stylename , self . _ctx , ** kwargs )
    return self [ stylename ]
k = kwargs . get ( "template" , "default" )
s = self [ stylename ] = self [ k ] . copy ( stylename )
for attr in kwargs :
    if s . __dict__ . has_key ( attr ) :
        s . __dict__ [ attr ] = kwargs [ attr ]
return s


signature:
def copy ( self , graph ) :
    """Returns a copy of all styles and a copy of the styleguide ."""

implementation:
s = styles ( graph )
s . guide = self . guide . copy ( graph )
dict . __init__ ( s , [ ( v . name , v . copy ( ) ) for v in self . values ( ) ] )
return s


signature:
def apply ( self ) :
    """Check the rules for each node in the graph and apply the style ."""

implementation:
sorted = self . order + self . keys ( )
unique = [ ] ;
[ unique . append ( x ) for x in sorted if x not in unique ]
for node in self . graph . nodes :
    for s in unique :
        if self . has_key ( s ) and self [ s ] ( self . graph , node ) :
            node . style = s


signature:
def copy ( self , graph ) :
    """Returns a copy of the styleguide for the given graph ."""

implementation:
g = styleguide ( graph )
g . order = self . order
dict . __init__ ( g , [ ( k , v ) for k , v in self . iteritems ( ) ] )
return g


signature:
def raw_decode ( self , s , ** kw ) :
    """Decode a JSON document from ` ` s ` ` ( a ` ` str ` ` or ` ` unicode ` ` beginning
 with a JSON document ) and return a 2 - tuple of the Python
 representation and the index in ` ` s ` ` where the document ended .
 This can be used to decode a JSON document from a string that may
 have extraneous data at the end ."""

implementation:
kw . setdefault ( 'context' , self )
try :
    obj , end = self . _scanner . iterscan ( s , ** kw ) . next ( )
except StopIteration :
    raise ValueError ( "No JSON object could be decoded" )
return obj , end


signature:
def open_socket ( self ) :
    """Opens the socket and binds to the given host and port . Uses
 SO _ REUSEADDR to be as robust as possible ."""

implementation:
self . socket = socket . socket ( socket . AF_INET , socket . SOCK_DGRAM )
self . socket . setsockopt ( socket . SOL_SOCKET , socket . SO_REUSEADDR , 1 )
self . socket . setblocking ( 0 )
self . socket . bind ( ( self . host , self . port ) )


signature:
def load_profiles ( self ) :
    """Loads all possible TUIO profiles and returns a dictionary with the
 profile addresses as keys and an instance of a profile as the value"""

implementation:
_profiles = { }
for name , klass in inspect . getmembers ( profiles ) :
    if inspect . isclass ( klass ) and name . endswith ( 'Profile' ) and name != 'TuioProfile' : # Adding profile to the self . profiles dictionary
        profile = klass ( )
        _profiles [ profile . address ] = profile
        # setting convenient variable to access objects of profile
        try :
            setattr ( self , profile . list_label , profile . objs )
        except AttributeError :
            continue
        # Mapping callback method to every profile
        self . manager . add ( self . callback , profile . address )
return _profiles


signature:
def update ( self ) :
    """Tells the connection manager to receive the next 1024 byte of messages
 to analyze ."""

implementation:
try :
    self . manager . handle ( self . socket . recv ( 1024 ) )
except socket . error :
    pass


signature:
def callback ( self , * incoming ) :
    """Gets called by the CallbackManager if a new message was received"""

implementation:
message = incoming [ 0 ]
if message :
    address , command = message [ 0 ] , message [ 2 ]
    profile = self . get_profile ( address )
    if profile is not None :
        try :
            getattr ( profile , command ) ( self , message )
        except AttributeError :
            pass


signature:
def copytree ( src , dst , symlinks = False , ignore = None ) :
    """copytree that works even if folder already exists"""

implementation:
# http : / / stackoverflow . com / questions / 1868714 / how - do - i - copy - an - entire - directory - of - files - into - an - existing - directory - using - pyth
if not os . path . exists ( dst ) :
    os . makedirs ( dst )
    shutil . copystat ( src , dst )
lst = os . listdir ( src )
if ignore :
    excl = ignore ( src , lst )
    lst = [ x for x in lst if x not in excl ]
for item in lst :
    s = os . path . join ( src , item )
    d = os . path . join ( dst , item )
    if symlinks and os . path . islink ( s ) :
        if os . path . lexists ( d ) :
            os . remove ( d )
        os . symlink ( os . readlink ( s ) , d )
        try :
            st = os . lstat ( s )
            mode = stat . S_IMODE ( st . st_mode )
            os . lchmod ( d , mode )
        except :
            pass
            # lchmod not available
    elif os . path . isdir ( s ) :
        copytree ( s , d , symlinks , ignore )
    else :
        shutil . copy2 ( s , d )


signature:
def dumps ( obj , skipkeys = False , ensure_ascii = True , check_circular = True , allow_nan = True , cls = None , indent = None , separators = None , encoding = 'utf-8' , default = None , ** kw ) :
    """Serialize ` ` obj ` ` to a JSON formatted ` ` str ` ` .
 If ` ` skipkeys ` ` is ` ` True ` ` then ` ` dict ` ` keys that are not basic types
 ( ` ` str ` ` , ` ` unicode ` ` , ` ` int ` ` , ` ` long ` ` , ` ` float ` ` , ` ` bool ` ` , ` ` None ` ` )
 will be skipped instead of raising a ` ` TypeError ` ` .
 If ` ` ensure _ ascii ` ` is ` ` False ` ` , then the return value will be a
 ` ` unicode ` ` instance subject to normal Python ` ` str ` ` to ` ` unicode ` `
 coercion rules instead of being escaped to an ASCII ` ` str ` ` .
 If ` ` check _ circular ` ` is ` ` False ` ` , then the circular reference check
 for container types will be skipped and a circular reference will
 result in an ` ` OverflowError ` ` ( or worse ) .
 If ` ` allow _ nan ` ` is ` ` False ` ` , then it will be a ` ` ValueError ` ` to
 serialize out of range ` ` float ` ` values ( ` ` nan ` ` , ` ` inf ` ` , ` ` - inf ` ` ) in
 strict compliance of the JSON specification , instead of using the
 JavaScript equivalents ( ` ` NaN ` ` , ` ` Infinity ` ` , ` ` - Infinity ` ` ) .
 If ` ` indent ` ` is a non - negative integer , then JSON array elements and
 object members will be pretty - printed with that indent level . An indent
 level of 0 will only insert newlines . ` ` None ` ` is the most compact
 representation .
 If ` ` separators ` ` is an ` ` ( item _ separator , dict _ separator ) ` ` tuple
 then it will be used instead of the default ` ` ( ' , ' , ' : ' ) ` ` separators .
 ` ` ( ' , ' , ' : ' ) ` ` is the most compact JSON representation .
 ` ` encoding ` ` is the character encoding for str instances , default is UTF - 8.
 ` ` default ( obj ) ` ` is a function that should return a serializable version
 of obj or raise TypeError . The default simply raises TypeError .
 To use a custom ` ` JSONEncoder ` ` subclass ( e . g . one that overrides the
 ` ` . default ( ) ` ` method to serialize additional types ) , specify it with
 the ` ` cls ` ` kwarg ."""

implementation:
# cached encoder
if ( skipkeys is False and ensure_ascii is True and check_circular is True and allow_nan is True and cls is None and indent is None and separators is None and encoding == 'utf-8' and default is None and not kw ) :
    return _default_encoder . encode ( obj )
if cls is None :
    cls = JSONEncoder
return cls ( skipkeys = skipkeys , ensure_ascii = ensure_ascii , check_circular = check_circular , allow_nan = allow_nan , indent = indent , separators = separators , encoding = encoding , default = default , ** kw ) . encode ( obj )


signature:
def search ( q , start = 0 , wait = 10 , asynchronous = False , cached = False ) :
    """Returns a Google web query formatted as a GoogleSearch list object ."""

implementation:
service = GOOGLE_SEARCH
return GoogleSearch ( q , start , service , "" , wait , asynchronous , cached )


signature:
def search_images ( q , start = 0 , size = "" , wait = 10 , asynchronous = False , cached = False ) :
    """Returns a Google images query formatted as a GoogleSearch list object ."""

implementation:
service = GOOGLE_IMAGES
return GoogleSearch ( q , start , service , size , wait , asynchronous , cached )


signature:
def search_news ( q , start = 0 , wait = 10 , asynchronous = False , cached = False ) :
    """Returns a Google news query formatted as a GoogleSearch list object ."""

implementation:
service = GOOGLE_NEWS
return GoogleSearch ( q , start , service , "" , wait , asynchronous , cached )


signature:
def search_blogs ( q , start = 0 , wait = 10 , asynchronous = False , cached = False ) :
    """Returns a Google blogs query formatted as a GoogleSearch list object ."""

implementation:
service = GOOGLE_BLOGS
return GoogleSearch ( q , start , service , "" , wait , asynchronous , cached )


signature:
def _parse ( self , str ) :
    """Parses the text data from an XML element defined by tag ."""

implementation:
str = replace_entities ( str )
str = strip_tags ( str )
str = collapse_spaces ( str )
return str


signature:
def hash ( self , id ) :
    """Creates a unique filename in the cache for the id ."""

implementation:
h = md5 ( id ) . hexdigest ( )
return os . path . join ( self . path , h + self . type )


signature:
def age ( self , id ) :
    """Returns the age of the cache entry , in days ."""

implementation:
path = self . hash ( id )
if os . path . exists ( path ) :
    modified = datetime . datetime . fromtimestamp ( os . stat ( path ) [ 8 ] )
    age = datetime . datetime . today ( ) - modified
    return age . days
else :
    return 0


signature:
def angle ( x0 , y0 , x1 , y1 ) :
    """Returns the angle between two points ."""

implementation: return degrees ( atan2 ( y1 - y0 , x1 - x0 ) )


signature:
def distance ( x0 , y0 , x1 , y1 ) :
    """Returns the distance between two points ."""

implementation: return sqrt ( pow ( x1 - x0 , 2 ) + pow ( y1 - y0 , 2 ) )


signature:
def coordinates ( x0 , y0 , distance , angle ) :
    """Returns the location of a point by rotating around origin ( x0 , y0 ) ."""

implementation: return ( x0 + cos ( radians ( angle ) ) * distance , y0 + sin ( radians ( angle ) ) * distance )


signature:
def rotate ( x , y , x0 , y0 , angle ) :
    """Returns the coordinates of ( x , y ) rotated around origin ( x0 , y0 ) ."""

implementation:
x , y = x - x0 , y - y0
a , b = cos ( radians ( angle ) ) , sin ( radians ( angle ) )
return ( x * a - y * b + x0 , y * a + x * b + y0 )


signature:
def reflect ( x , y , x0 , y0 , d = 1.0 , a = 180 ) :
    """Returns the reflection of a point through origin ( x0 , y0 ) ."""

implementation: return coordinates ( x0 , y0 , d * distance ( x0 , y0 , x , y ) , a + angle ( x0 , y0 , x , y ) )


signature:
def lerp ( a , b , t ) :
    """Returns the linear interpolation between a and b for time t between 0.0-1.0.
 For example : lerp ( 100 , 200 , 0.5 ) = > 150."""

implementation:
if t < 0.0 :
    return a
if t > 1.0 :
    return b
return a + ( b - a ) * t


signature:
def smoothstep ( a , b , x ) :
    """Returns a smooth transition between 0.0 and 1.0 using Hermite interpolation ( cubic spline ) ,
 where x is a number between a and b . The return value will ease ( slow down ) as x nears a or b .
 For x smaller than a , returns 0.0 . For x bigger than b , returns 1.0."""

implementation:
if x < a :
    return 0.0
if x >= b :
    return 1.0
x = float ( x - a ) / ( b - a )
return x * x * ( 3 - 2 * x )


signature:
def line_line_intersection ( x1 , y1 , x2 , y2 , x3 , y3 , x4 , y4 , infinite = False ) :
    """Determines the intersection point of two lines , or two finite line segments if infinite = False .
 When the lines do not intersect , returns an empty list ."""

implementation:
# Based on : P . Bourke , http : / / local . wasp . uwa . edu . au / ~ pbourke / geometry / lineline2d /
ua = ( x4 - x3 ) * ( y1 - y3 ) - ( y4 - y3 ) * ( x1 - x3 )
ub = ( x2 - x1 ) * ( y1 - y3 ) - ( y2 - y1 ) * ( x1 - x3 )
d = ( y4 - y3 ) * ( x2 - x1 ) - ( x4 - x3 ) * ( y2 - y1 )
if d == 0 :
    if ua == ub == 0 : # The lines are coincident
        return [ ]
    else : # The lines are parallel .
        return [ ]
ua /= float ( d )
ub /= float ( d )
if not infinite and not ( 0 <= ua <= 1 and 0 <= ub <= 1 ) : # Intersection point is not within both line segments .
    return None , None
return [ ( x1 + ua * ( x2 - x1 ) , y1 + ua * ( y2 - y1 ) ) ]


signature:
def circle_line_intersection ( cx , cy , radius , x1 , y1 , x2 , y2 , infinite = False ) :
    """Returns a list of points where the circle and the line intersect .
 Returns an empty list when the circle and the line do not intersect ."""

implementation:
# Based on : http : / / www . vb - helper . com / howto _ net _ line _ circle _ intersections . html
dx = x2 - x1
dy = y2 - y1
A = dx * dx + dy * dy
B = 2 * ( dx * ( x1 - cx ) + dy * ( y1 - cy ) )
C = pow ( x1 - cx , 2 ) + pow ( y1 - cy , 2 ) - radius * radius
det = B * B - 4 * A * C
if A <= 0.0000001 or det < 0 :
    return [ ]
elif det == 0 : # One point of intersection .
    t = - B / ( 2 * A )
    return [ ( x1 + t * dx , y1 + t * dy ) ]
else : # Two points of intersection .
# A point of intersection lies on the line segment if 0 < = t < = 1,
# and on an extension of the segment otherwise .
    points = [ ]
    det2 = sqrt ( det )
    t1 = ( - B + det2 ) / ( 2 * A )
    t2 = ( - B - det2 ) / ( 2 * A )
    if infinite or 0 <= t1 <= 1 :
        points . append ( ( x1 + t1 * dx , y1 + t1 * dy ) )
    if infinite or 0 <= t2 <= 1 :
        points . append ( ( x1 + t2 * dx , y1 + t2 * dy ) )
    return points


signature:
def point_in_polygon ( points , x , y ) :
    """Ray casting algorithm .
 Determines how many times a horizontal ray starting from the point
 intersects with the sides of the polygon .
 If it is an even number of times , the point is outside , if odd , inside .
 The algorithm does not always report correctly when the point is very close to the boundary .
 The polygon is passed as a list of ( x , y ) - tuples ."""

implementation:
odd = False
n = len ( points )
for i in range ( n ) :
    j = i < n - 1 and i + 1 or 0
    x0 , y0 = points [ i ] [ 0 ] , points [ i ] [ 1 ]
    x1 , y1 = points [ j ] [ 0 ] , points [ j ] [ 1 ]
    if ( y0 < y and y1 >= y ) or ( y1 < y and y0 >= y ) :
        if x0 + ( y - y0 ) / ( y1 - y0 ) * ( x1 - x0 ) < x :
            odd = not odd
return odd


signature:
def _mmult ( self , a , b ) :
    """Returns the 3x3 matrix multiplication of A and B .
 Note that scale ( ) , translate ( ) , rotate ( ) work with premultiplication ,
 e . g . the matrix A followed by B = BA and not AB ."""


signature:
def invert ( self ) :
    """Multiplying a matrix by its inverse produces the identity matrix ."""


signature:
def transform_point ( self , x , y ) :
    """Returns the new coordinates of ( x , y ) after transformation ."""


signature:
def transform_path ( self , path ) :
    """Returns a BezierPath object with the transformation applied ."""

implementation:
p = path . __class__ ( )
# Create a new BezierPath .
for pt in path :
    if pt . cmd == "close" :
        p . closepath ( )
    elif pt . cmd == "moveto" :
        p . moveto ( * self . apply ( pt . x , pt . y ) )
    elif pt . cmd == "lineto" :
        p . lineto ( * self . apply ( pt . x , pt . y ) )
    elif pt . cmd == "curveto" :
        vx1 , vy1 = self . apply ( pt . ctrl1 . x , pt . ctrl1 . y )
        vx2 , vy2 = self . apply ( pt . ctrl2 . x , pt . ctrl2 . y )
        x , y = self . apply ( pt . x , pt . y )
        p . curveto ( vx1 , vy1 , vx2 , vy2 , x , y )
return p


signature:
def intersects ( self , b ) :
    """Return True if a part of the two bounds overlaps ."""

implementation: return max ( self . x , b . x ) < min ( self . x + self . width , b . x + b . width ) and max ( self . y , b . y ) < min ( self . y + self . height , b . y + b . height )


signature:
def intersection ( self , b ) :
    """Returns bounds that encompass the intersection of the two .
 If there is no overlap between the two , None is returned ."""

implementation:
if not self . intersects ( b ) :
    return None
mx , my = max ( self . x , b . x ) , max ( self . y , b . y )
return Bounds ( mx , my , min ( self . x + self . width , b . x + b . width ) - mx , min ( self . y + self . height , b . y + b . height ) - my )


signature:
def union ( self , b ) :
    """Returns bounds that encompass the union of the two ."""

implementation:
mx , my = min ( self . x , b . x ) , min ( self . y , b . y )
return Bounds ( mx , my , max ( self . x + self . width , b . x + b . width ) - mx , max ( self . y + self . height , b . y + b . height ) - my )


signature:
def contains ( self , * a ) :
    """Returns True if the given point or rectangle falls within the bounds ."""

implementation:
if len ( a ) == 2 :
    a = [ Point ( a [ 0 ] , a [ 1 ] ) ]
if len ( a ) == 1 :
    a = a [ 0 ]
    if isinstance ( a , Point ) :
        return a . x >= self . x and a . x <= self . x + self . width and a . y >= self . y and a . y <= self . y + self . height
    if isinstance ( a , Bounds ) :
        return a . x >= self . x and a . x + a . width <= self . x + self . width and a . y >= self . y and a . y + a . height <= self . y + self . height


signature:
def error ( message ) :
    '''Prints an error message , the help message and quits'''

implementation:
global parser
print ( _ ( "Error: " ) + message )
print ( )
parser . print_help ( )
sys . exit ( )


signature:
def ellipse ( self , x , y , width , height , draw = True , ** kwargs ) :
    '''Draws an ellipse starting from ( x , y )'''

implementation:
path = self . BezierPath ( ** kwargs )
path . ellipse ( x , y , width , height )
if draw :
    path . draw ( )
return path


signature:
def line ( self , x1 , y1 , x2 , y2 , draw = True ) :
    '''Draws a line from ( x1 , y1 ) to ( x2 , y2)'''

implementation:
p = self . _path
self . newpath ( )
self . moveto ( x1 , y1 )
self . lineto ( x2 , y2 )
self . endpath ( draw = draw )
self . _path = p
return p


signature:
def colormode ( self , mode = None , crange = None ) :
    '''Sets the current colormode ( can be RGB or HSB ) and eventually
 the color range .
 If called without arguments , it returns the current colormode .'''

implementation:
if mode is not None :
    if mode == "rgb" :
        self . color_mode = Bot . RGB
    elif mode == "hsb" :
        self . color_mode = Bot . HSB
    else :
        raise NameError , _ ( "Only RGB and HSB colormodes are supported." )
if crange is not None :
    self . color_range = crange
return self . color_mode


signature:
def fill ( self , * args ) :
    '''Sets a fill color , applying it to new paths .'''

implementation:
self . _fillcolor = self . color ( * args )
return self . _fillcolor


signature:
def stroke ( self , * args ) :
    '''Set a stroke color , applying it to new paths .'''

implementation:
self . _strokecolor = self . color ( * args )
return self . _strokecolor


signature:
def textpath ( self , txt , x , y , width = None , height = 1000000 , enableRendering = False , ** kwargs ) :
    '''Draws an outlined path of the input text'''

implementation:
txt = self . Text ( txt , x , y , width , height , ** kwargs )
path = txt . path
if draw :
    path . draw ( )
return path


signature:
def textmetrics ( self , txt , width = None , height = None , ** kwargs ) :
    '''Returns the width and height of a string of text as a tuple
 ( according to current font settings ) .'''

implementation:
# for now only returns width and height ( as per Nodebox behaviour )
# but maybe we could use the other data from cairo
# we send doRender = False to prevent the actual rendering process , only the path generation is enabled
# not the most efficient way , but it generates accurate results
txt = self . Text ( txt , 0 , 0 , width , height , enableRendering = False , ** kwargs )
return txt . metrics


signature:
def draw_cornu_flat ( x0 , y0 , t0 , t1 , s0 , c0 , flip , cs , ss , cmd ) :
    """Raph Levien ' s code draws fast LINETO segments ."""

implementation:
for j in range ( 0 , 100 ) :
    t = j * .01
    s , c = eval_cornu ( t0 + t * ( t1 - t0 ) )
    s *= flip
    s -= s0
    c -= c0
    # print ' % ' , c , s
    x = c * cs - s * ss
    y = s * cs + c * ss
    print_pt ( x0 + x , y0 + y , cmd )
    cmd = 'lineto'
return cmd


signature:
def draw_cornu_bezier ( x0 , y0 , t0 , t1 , s0 , c0 , flip , cs , ss , cmd , scale , rot ) :
    """Mark Meyer ' s code draws elegant CURVETO segments ."""

implementation:
s = None
for j in range ( 0 , 5 ) : # travel along the function two points at a time ( at time t and t2)
# the first time through we ' ll need to get both points
# after that we only need the second point because the old second point
# becomes the new first point
    t = j * .2
    t2 = t + .2
    curvetime = t0 + t * ( t1 - t0 )
    curvetime2 = t0 + t2 * ( t1 - t0 )
    Dt = ( curvetime2 - curvetime ) * scale
    if not s : # get first point
    # avoid calling this again : the next time though x , y will equal x3 , y3
        s , c = eval_cornu ( curvetime )
        s *= flip
        s -= s0
        c -= c0
        # calculate derivative of fresnel function at point to get tangent slope
        # just take the integrand of the fresnel function
        dx1 = cos ( pow ( curvetime , 2 ) + ( flip * rot ) )
        dy1 = flip * sin ( pow ( curvetime , 2 ) + ( flip * rot ) )
        # x , y = first point on function
        x = ( ( c * cs - s * ss ) + x0 )
        y = ( ( s * cs + c * ss ) + y0 )
    # evaluate the fresnel further along the function to look ahead to the next point
    s2 , c2 = eval_cornu ( curvetime2 )
    s2 *= flip
    s2 -= s0
    c2 -= c0
    dx2 = cos ( pow ( curvetime2 , 2 ) + ( flip * rot ) )
    dy2 = flip * sin ( pow ( curvetime2 , 2 ) + ( flip * rot ) )
    # x3 , y3 = second point on function
    x3 = ( ( c2 * cs - s2 * ss ) + x0 )
    y3 = ( ( s2 * cs + c2 * ss ) + y0 )
    # calculate control points
    x1 = ( x + ( ( Dt / 3.0 ) * dx1 ) )
    y1 = ( y + ( ( Dt / 3.0 ) * dy1 ) )
    x2 = ( x3 - ( ( Dt / 3.0 ) * dx2 ) )
    y2 = ( y3 - ( ( Dt / 3.0 ) * dy2 ) )
    if cmd == 'moveto' :
        print_pt ( x , y , cmd )
        cmd = 'curveto'
    print_crv ( x1 , y1 , x2 , y2 , x3 , y3 )
    dx1 , dy1 = dx2 , dy2
    x , y = x3 , y3
return cmd


signature:
def search ( q , start = 1 , count = 10 , context = None , wait = 10 , asynchronous = False , cached = False ) :
    """Returns a Yahoo web query formatted as a YahooSearch list object ."""

implementation:
service = YAHOO_SEARCH
return YahooSearch ( q , start , count , service , context , wait , asynchronous , cached )


signature:
def search_images ( q , start = 1 , count = 10 , wait = 10 , asynchronous = False , cached = False ) :
    """Returns a Yahoo images query formatted as a YahooSearch list object ."""

implementation:
service = YAHOO_IMAGES
return YahooSearch ( q , start , count , service , None , wait , asynchronous , cached )


signature:
def search_news ( q , start = 1 , count = 10 , wait = 10 , asynchronous = False , cached = False ) :
    """Returns a Yahoo news query formatted as a YahooSearch list object ."""

implementation:
service = YAHOO_NEWS
return YahooSearch ( q , start , count , service , None , wait , asynchronous , cached )


signature:
def suggest_spelling ( q , wait = 10 , asynchronous = False , cached = False ) :
    """Returns list of suggested spelling corrections for the given query ."""

implementation: return YahooSpelling ( q , wait , asynchronous , cached )


signature:
def sort ( words , context = "" , strict = True , relative = True , service = YAHOO_SEARCH , wait = 10 , asynchronous = False , cached = False ) :
    """Performs a Yahoo sort on the given list .
 Sorts the items in the list according to
 the result count Yahoo yields on an item .
 Setting a context sorts the items according
 to their relation to this context ;
 for example sorting [ red , green , blue ] by " love "
 yields red as the highest results ,
 likely because red is the color commonly associated with love ."""

implementation:
results = [ ]
for word in words :
    q = word + " " + context
    q . strip ( )
    if strict :
        q = "\"" + q + "\""
    r = YahooSearch ( q , 1 , 1 , service , context , wait , asynchronous , cached )
    results . append ( r )
results . sort ( YahooResults . __cmp__ )
results . reverse ( )
if relative and len ( results ) > 0 :
    sum = 0.000000000000000001
    for r in results :
        sum += r . total
    for r in results :
        r . total /= float ( sum )
results = [ ( r . query , r . total ) for r in results ]
return results


signature:
def _parse ( self , e , tag ) :
    """Parses the text data from an XML element defined by tag ."""

implementation:
tags = e . getElementsByTagName ( tag )
children = tags [ 0 ] . childNodes
if len ( children ) != 1 :
    return None
assert children [ 0 ] . nodeType == xml . dom . minidom . Element . TEXT_NODE
s = children [ 0 ] . nodeValue
s = format_data ( s )
s = replace_entities ( s )
return s


signature:
def layer ( self , img , x = 0 , y = 0 , name = "" ) :
    """Creates a new layer from file , Layer , PIL Image .
 If img is an image file or PIL Image object ,
 Creates a new layer with the given image file .
 The image is positioned on the canvas at x , y .
 If img is a Layer ,
 uses that layer ' s x and y position and name ."""

implementation:
from types import StringType
if isinstance ( img , Image . Image ) :
    img = img . convert ( "RGBA" )
    self . layers . append ( Layer ( self , img , x , y , name ) )
    return len ( self . layers ) - 1
if isinstance ( img , Layer ) :
    img . canvas = self
    self . layers . append ( img )
    return len ( self . layers ) - 1
if type ( img ) == StringType :
    img = Image . open ( img )
    img = img . convert ( "RGBA" )
    self . layers . append ( Layer ( self , img , x , y , name ) )
    return len ( self . layers ) - 1


signature:
def fill ( self , rgb , x = 0 , y = 0 , w = None , h = None , name = "" ) :
    """Creates a new fill layer .
 Creates a new layer filled with the given rgb color .
 For example , fill ( ( 255,0,0 ) ) creates a red fill .
 The layers fills the entire canvas by default ."""

implementation:
if w == None :
    w = self . w - x
if h == None :
    h = self . h - y
img = Image . new ( "RGBA" , ( w , h ) , rgb )
self . layer ( img , x , y , name )


signature:
def gradient ( self , style = LINEAR , w = 1.0 , h = 1.0 , name = "" ) :
    """Creates a gradient layer .
 Creates a gradient layer , that is usually used
 together with the mask ( ) function .
 All the image functions work on gradients ,
 so they can easily be flipped , rotated , scaled , inverted ,
 made brighter or darker , . . .
 Styles for gradients are LINEAR , RADIAL and DIAMOND ."""

implementation:
from types import FloatType
w0 = self . w
h0 = self . h
if type ( w ) == FloatType :
    w *= w0
if type ( h ) == FloatType :
    h *= h0
img = Image . new ( "L" , ( int ( w ) , int ( h ) ) , 255 )
draw = ImageDraw . Draw ( img )
if style == LINEAR :
    for i in range ( int ( w ) ) :
        k = 255.0 * i / w
        draw . rectangle ( ( i , 0 , i , h ) , fill = int ( k ) )
if style == RADIAL :
    r = min ( w , h ) / 2
    for i in range ( int ( r ) ) :
        k = 255 - 255.0 * i / r
        draw . ellipse ( ( w / 2 - r + i , h / 2 - r + i , w / 2 + r - i , h / 2 + r - i ) , fill = int ( k ) )
if style == DIAMOND :
    r = max ( w , h )
    for i in range ( int ( r ) ) :
        x = int ( i * w / r * 0.5 )
        y = int ( i * h / r * 0.5 )
        k = 255.0 * i / r
        draw . rectangle ( ( x , y , w - x , h - y ) , outline = int ( k ) )
img = img . convert ( "RGBA" )
self . layer ( img , 0 , 0 , name = "" )


signature:
def merge ( self , layers ) :
    """Flattens the given layers on the canvas .
 Merges the given layers with the indices in the list
 on the bottom layer in the list .
 The other layers are discarded ."""

implementation:
layers . sort ( )
if layers [ 0 ] == 0 :
    del layers [ 0 ]
self . flatten ( layers )


signature:
def flatten ( self , layers = [ ] ) :
    """Flattens all layers according to their blend modes .
 Merges all layers to the canvas ,
 using the blend mode and opacity defined for each layer .
 Once flattened , the stack of layers is emptied except
 for the transparent background ( bottom layer ) ."""

implementation:
# When the layers argument is omitted ,
# flattens all the layers on the canvas .
# When given , merges the indexed layers .
# Layers that fall outside of the canvas are cropped :
# this should be fixed by merging to a transparent background
# large enough to hold all the given layers ' data
# ( = time consuming ) .
if layers == [ ] :
    layers = range ( 1 , len ( self . layers ) )
background = self . layers . _get_bg ( )
background . name = "Background"
for i in layers :
    layer = self . layers [ i ]
    # Determine which portion of the canvas
    # needs to be updated with the overlaying layer .
    x = max ( 0 , layer . x )
    y = max ( 0 , layer . y )
    w = min ( background . w , layer . x + layer . w )
    h = min ( background . h , layer . y + layer . h )
    base = background . img . crop ( ( x , y , w , h ) )
    # Determine which piece of the layer
    # falls within the canvas .
    x = max ( 0 , - layer . x )
    y = max ( 0 , - layer . y )
    w -= layer . x
    h -= layer . y
    blend = layer . img . crop ( ( x , y , w , h ) )
    # Buffer layer blend modes :
    # the base below is a flattened version
    # of all the layers below this one ,
    # on which to merge this blended layer .
    if layer . blend == NORMAL :
        buffer = blend
    if layer . blend == MULTIPLY :
        buffer = ImageChops . multiply ( base , blend )
    if layer . blend == SCREEN :
        buffer = ImageChops . screen ( base , blend )
    if layer . blend == OVERLAY :
        buffer = Blend ( ) . overlay ( base , blend )
    if layer . blend == HUE :
        buffer = Blend ( ) . hue ( base , blend )
    if layer . blend == COLOR :
        buffer = Blend ( ) . color ( base , blend )
    # Buffer a merge between the base and blend
    # according to the blend ' s alpha channel :
    # the base shines through where the blend is less opaque .
    # Merging the first layer to the transparent canvas
    # works slightly different than the other layers .
    alpha = buffer . split ( ) [ 3 ]
    if i == 1 :
        buffer = Image . composite ( base , buffer , base . split ( ) [ 3 ] )
    else :
        buffer = Image . composite ( buffer , base , alpha )
    # The alpha channel becomes a composite of
    # this layer and the base :
    # the base ' s ( optional ) tranparent background
    # is retained in arrays where the blend layer
    # is transparent as well .
    alpha = ImageChops . lighter ( alpha , base . split ( ) [ 3 ] )
    buffer . putalpha ( alpha )
    # Apply the layer ' s opacity ,
    # merging the buffer to the base with
    # the given layer opacity .
    base = Image . blend ( base , buffer , layer . alpha )
    # Merge the base to the flattened canvas .
    x = max ( 0 , layer . x )
    y = max ( 0 , layer . y )
    background . img . paste ( base , ( x , y ) )
layers . reverse ( )
for i in layers :
    del self . layers [ i ]
img = Image . new ( "RGBA" , ( self . w , self . h ) , ( 255 , 255 , 255 , 0 ) )
self . layers . _set_bg ( Layer ( self , img , 0 , 0 , name = "_bg" ) )
if len ( self . layers ) == 1 :
    self . layers . append ( background )
else :
    self . layers . insert ( layers [ - 1 ] , background )


signature:
def export ( self , filename ) :
    """Exports the flattened canvas .
 Flattens the canvas .
 PNG retains the alpha channel information .
 Other possibilities are JPEG and GIF ."""

implementation:
self . flatten ( )
self . layers [ 1 ] . img . save ( filename )
return filename


signature:
def draw ( self , x , y ) :
    """Places the flattened canvas in NodeBox .
 Exports to a temporary PNG file .
 Draws the PNG in NodeBox using the image ( ) command .
 Removes the temporary file ."""

implementation:
try :
    from time import time
    import md5
    from os import unlink
    m = md5 . new ( )
    m . update ( str ( time ( ) ) )
    filename = "photobot" + str ( m . hexdigest ( ) ) + ".png"
    self . export ( filename )
    _ctx . image ( filename , x , y )
    unlink ( filename )
except :
    pass


signature:
def index ( self ) :
    """Returns this layer ' s index in the canvas . layers [ ] .
 Searches the position of this layer in the canvas '
 layers list , return None when not found ."""

implementation:
for i in range ( len ( self . canvas . layers ) ) :
    if self . canvas . layers [ i ] == self :
        break
if self . canvas . layers [ i ] == self :
    return i
else :
    return None


signature:
def copy ( self ) :
    """Returns a copy of the layer .
 This is different from the duplicate ( ) method ,
 which duplicates the layer as a new layer on the canvas .
 The copy ( ) method returns a copy of the layer
 that can be added to a different canvas ."""

implementation:
layer = Layer ( None , self . img . copy ( ) , self . x , self . y , self . name )
layer . w = self . w
layer . h = self . h
layer . alpha = self . alpha
layer . blend = self . blend
return layer


signature:
def delete ( self ) :
    """Removes this layer from the canvas ."""

implementation:
i = self . index ( )
if i != None :
    del self . canvas . layers [ i ]


signature:
def up ( self ) :
    """Moves the layer up in the stacking order ."""

implementation:
i = self . index ( )
if i != None :
    del self . canvas . layers [ i ]
    i = min ( len ( self . canvas . layers ) , i + 1 )
    self . canvas . layers . insert ( i , self )


signature:
def down ( self ) :
    """Moves the layer down in the stacking order ."""

implementation:
i = self . index ( )
if i != None :
    del self . canvas . layers [ i ]
    i = max ( 0 , i - 1 )
    self . canvas . layers . insert ( i , self )


signature:
def select ( self , path , feather = True ) :
    """Applies the polygonal lasso tool on a layer .
 The path paramater is a list of points ,
 either [ x1 , y1 , x2 , y2 , x3 , y3 , . . . ]
 or [ ( x1 , y1 ) , ( x2 , y2 ) , ( x3 , y3 ) , . . . ]
 The parts of the layer that fall outside
 this polygonal area are cut .
 The selection is not anti - aliased ,
 but the feather parameter creates soft edges ."""

implementation:
w , h = self . img . size
mask = Image . new ( "L" , ( w , h ) , 0 )
draw = ImageDraw . Draw ( mask )
draw = ImageDraw . Draw ( mask )
draw . polygon ( path , fill = 255 )
if feather :
    mask = mask . filter ( ImageFilter . SMOOTH_MORE )
    mask = mask . filter ( ImageFilter . SMOOTH_MORE )
mask = ImageChops . darker ( mask , self . img . split ( ) [ 3 ] )
self . img . putalpha ( mask )


signature:
def mask ( self ) :
    """Masks the layer below with this layer .
 Commits the current layer to the alpha channel of
 the previous layer . Primarily , mask ( ) is useful when
 using gradient layers as masks on images below .
 For example :
 canvas . layer ( " image . jpg " )
 canvas . gradient ( )
 canvas . layer ( 2 ) . flip ( )
 canvas . layer ( 2 ) . mask ( )
 Adds a white - to - black linear gradient to
 the alpha channel of image . jpg ,
 making it evolve from opaque on
 the left to transparent on the right ."""

implementation:
if len ( self . canvas . layers ) < 2 :
    return
i = self . index ( )
if i == 0 :
    return
layer = self . canvas . layers [ i - 1 ]
alpha = Image . new ( "L" , layer . img . size , 0 )
# Make a composite of the mask layer in grayscale
# and its own alpha channel .
mask = self . canvas . layers [ i ]
flat = ImageChops . darker ( mask . img . convert ( "L" ) , mask . img . split ( ) [ 3 ] )
alpha . paste ( flat , ( mask . x , mask . y ) )
alpha = ImageChops . darker ( alpha , layer . img . split ( ) [ 3 ] )
layer . img . putalpha ( alpha )
self . delete ( )


signature:
def duplicate ( self ) :
    """Creates a copy of the current layer .
 This copy becomes the top layer on the canvas ."""

implementation:
i = self . canvas . layer ( self . img . copy ( ) , self . x , self . y , self . name )
clone = self . canvas . layers [ i ]
clone . alpha = self . alpha
clone . blend = self . blend


signature:
def brightness ( self , value = 1.0 ) :
    """Increases or decreases the brightness in the layer .
 The given value is a percentage to increase
 or decrease the image brightness ,
 for example 0.8 means brightness at 80 % ."""

implementation:
b = ImageEnhance . Brightness ( self . img )
self . img = b . enhance ( value )


signature:
def contrast ( self , value = 1.0 ) :
    """Increases or decreases the contrast in the layer .
 The given value is a percentage to increase
 or decrease the image contrast ,
 for example 1.2 means contrast at 120 % ."""

implementation:
c = ImageEnhance . Contrast ( self . img )
self . img = c . enhance ( value )


signature:
def desaturate ( self ) :
    """Desaturates the layer , making it grayscale .
 Instantly removes all color information from the layer ,
 while maintaing its alpha channel ."""

implementation:
alpha = self . img . split ( ) [ 3 ]
self . img = self . img . convert ( "L" )
self . img = self . img . convert ( "RGBA" )
self . img . putalpha ( alpha )


signature:
def invert ( self ) :
    """Inverts the layer ."""

implementation:
alpha = self . img . split ( ) [ 3 ]
self . img = self . img . convert ( "RGB" )
self . img = ImageOps . invert ( self . img )
self . img = self . img . convert ( "RGBA" )
self . img . putalpha ( alpha )


signature:
def translate ( self , x , y ) :
    """Positions the layer at the given coordinates .
 The x and y parameters define where to position
 the top left corner of the layer ,
 measured from the top left of the canvas ."""

implementation:
self . x = x
self . y = y


signature:
def scale ( self , w = 1.0 , h = 1.0 ) :
    """Resizes the layer to the given width and height .
 When width w or height h is a floating - point number ,
 scales percentual ,
 otherwise scales to the given size in pixels ."""

implementation:
from types import FloatType
w0 , h0 = self . img . size
if type ( w ) == FloatType :
    w = int ( w * w0 )
if type ( h ) == FloatType :
    h = int ( h * h0 )
self . img = self . img . resize ( ( w , h ) , INTERPOLATION )
self . w = w
self . h = h


signature:
def distort ( self , x1 = 0 , y1 = 0 , x2 = 0 , y2 = 0 , x3 = 0 , y3 = 0 , x4 = 0 , y4 = 0 ) :
    """Distorts the layer .
 Distorts the layer by translating
 the four corners of its bounding box to the given coordinates :
 upper left ( x1 , y1 ) , upper right ( x2 , y2 ) ,
 lower right ( x3 , y3 ) and lower left ( x4 , y4 ) ."""

implementation:
w , h = self . img . size
quad = ( - x1 , - y1 , - x4 , h - y4 , w - x3 , w - y3 , w - x2 , - y2 )
self . img = self . img . transform ( self . img . size , Image . QUAD , quad , INTERPOLATION )


signature:
def rotate ( self , angle ) :
    """Rotates the layer .
 Rotates the layer by given angle .
 Positive numbers rotate counter - clockwise ,
 negative numbers rotate clockwise .
 Rotate commands are executed instantly ,
 so many subsequent rotates will distort the image ."""

implementation:
# When a layer rotates , its corners will fall outside
# of its defined width and height .
# Thus , its bounding box needs to be expanded .
# Calculate the diagonal width , and angle from the layer center .
# This way we can use the layers ' s corners
# to calculate the bounding box .
from math import sqrt , pow , sin , cos , degrees , radians , asin
w0 , h0 = self . img . size
d = sqrt ( pow ( w0 , 2 ) + pow ( h0 , 2 ) )
d_angle = degrees ( asin ( ( w0 * 0.5 ) / ( d * 0.5 ) ) )
angle = angle % 360
if angle > 90 and angle <= 270 :
    d_angle += 180
w = sin ( radians ( d_angle + angle ) ) * d
w = max ( w , sin ( radians ( d_angle - angle ) ) * d )
w = int ( abs ( w ) )
h = cos ( radians ( d_angle + angle ) ) * d
h = max ( h , cos ( radians ( d_angle - angle ) ) * d )
h = int ( abs ( h ) )
dx = int ( ( w - w0 ) / 2 )
dy = int ( ( h - h0 ) / 2 )
d = int ( d )
# The rotation box ' s background color
# is the mean pixel value of the rotating image .
# This is the best option to avoid borders around
# the rotated image .
bg = ImageStat . Stat ( self . img ) . mean
bg = ( int ( bg [ 0 ] ) , int ( bg [ 1 ] ) , int ( bg [ 2 ] ) , 0 )
box = Image . new ( "RGBA" , ( d , d ) , bg )
box . paste ( self . img , ( ( d - w0 ) / 2 , ( d - h0 ) / 2 ) )
box = box . rotate ( angle , INTERPOLATION )
box = box . crop ( ( ( d - w ) / 2 + 2 , ( d - h ) / 2 , d - ( d - w ) / 2 , d - ( d - h ) / 2 ) )
self . img = box
# Since rotate changes the bounding box size ,
# update the layers ' width , height , and position ,
# so it rotates from the center .
self . x += ( self . w - w ) / 2
self . y += ( self . h - h ) / 2
self . w = w
self . h = h


signature:
def flip ( self , axis = HORIZONTAL ) :
    """Flips the layer , either HORIZONTAL or VERTICAL ."""

implementation:
if axis == HORIZONTAL :
    self . img = self . img . transpose ( Image . FLIP_LEFT_RIGHT )
if axis == VERTICAL :
    self . img = self . img . transpose ( Image . FLIP_TOP_BOTTOM )


signature:
def sharpen ( self , value = 1.0 ) :
    """Increases or decreases the sharpness in the layer .
 The given value is a percentage to increase
 or decrease the image sharpness ,
 for example 0.8 means sharpness at 80 % ."""

implementation:
s = ImageEnhance . Sharpness ( self . img )
self . img = s . enhance ( value )


signature:
def levels ( self ) :
    """Returns a histogram for each RGBA channel .
 Returns a 4 - tuple of lists , r , g , b , and a .
 Each list has 255 items , a count for each pixel value ."""


signature:
def overlay ( self , img1 , img2 ) :
    """Applies the overlay blend mode .
 Overlays image img2 on image img1.
 The overlay pixel combines multiply and screen :
 it multiplies dark pixels values and screen light values .
 Returns a composite image with the alpha channel retained ."""

implementation:
p1 = list ( img1 . getdata ( ) )
p2 = list ( img2 . getdata ( ) )
for i in range ( len ( p1 ) ) :
    p3 = ( )
    for j in range ( len ( p1 [ i ] ) ) :
        a = p1 [ i ] [ j ] / 255.0
        b = p2 [ i ] [ j ] / 255.0
        # When overlaying the alpha channels ,
        # take the alpha of the most transparent layer .
        if j == 3 : # d = ( a + b ) * 0.5
        # d = a
            d = min ( a , b )
        elif a > 0.5 :
            d = 2 * ( a + b - a * b ) - 1
        else :
            d = 2 * a * b
        p3 += ( int ( d * 255 ) , )
    p1 [ i ] = p3
img = Image . new ( "RGBA" , img1 . size , 255 )
img . putdata ( p1 )
return img


signature:
def hue ( self , img1 , img2 ) :
    """Applies the hue blend mode .
 Hues image img1 with image img2.
 The hue filter replaces the hues of pixels in img1
 with the hues of pixels in img2.
 Returns a composite image with the alpha channel retained ."""

implementation:
import colorsys
p1 = list ( img1 . getdata ( ) )
p2 = list ( img2 . getdata ( ) )
for i in range ( len ( p1 ) ) :
    r1 , g1 , b1 , a1 = p1 [ i ]
    r1 = r1 / 255.0
    g1 = g1 / 255.0
    b1 = b1 / 255.0
    h1 , s1 , v1 = colorsys . rgb_to_hsv ( r1 , g1 , b1 )
    r2 , g2 , b2 , a2 = p2 [ i ]
    r2 = r2 / 255.0
    g2 = g2 / 255.0
    b2 = b2 / 255.0
    h2 , s2 , v2 = colorsys . rgb_to_hsv ( r2 , g2 , b2 )
    r3 , g3 , b3 = colorsys . hsv_to_rgb ( h2 , s1 , v1 )
    r3 = int ( r3 * 255 )
    g3 = int ( g3 * 255 )
    b3 = int ( b3 * 255 )
    p1 [ i ] = ( r3 , g3 , b3 , a1 )
img = Image . new ( "RGBA" , img1 . size , 255 )
img . putdata ( p1 )
return img


signature:
def convolute ( self , kernel , scale = None , offset = 0 ) :
    """A ( 3,3 ) or ( 5,5 ) convolution kernel .
 The kernel argument is a list with either 9 or 25 elements ,
 the weight for each surrounding pixels to convolute ."""

implementation:
if len ( kernel ) == 9 :
    size = ( 3 , 3 )
elif len ( kernel ) == 25 :
    size = ( 5 , 5 )
else :
    return
if scale == None :
    scale = 0
    for x in kernel :
        scale += x
    if scale == 0 :
        scale = 1
f = ImageFilter . BuiltinFilter ( )
f . filterargs = size , scale , offset , kernel
self . layer . img = self . layer . img . filter ( f )


signature:
def _load_namespace ( self , namespace , filename = None ) :
    """Initialise bot namespace with info in shoebot . data
 : param filename : Will be set to _ _ file _ _ in the namespace"""

implementation:
from shoebot import data
for name in dir ( data ) :
    namespace [ name ] = getattr ( data , name )
for name in dir ( self ) :
    if name [ 0 ] != '_' :
        namespace [ name ] = getattr ( self , name )
namespace [ '_ctx' ] = self
# Used in older nodebox scripts .
namespace [ '__file__' ] = filename


signature:
def _should_run ( self , iteration , max_iterations ) :
    '''Return False if bot should quit'''

implementation:
if iteration == 0 : # First frame always runs
    return True
if max_iterations :
    if iteration < max_iterations :
        return True
elif max_iterations is None :
    if self . _dynamic :
        return True
    else :
        return False
    return True
if not self . _dynamic :
    return False
return False


signature:
def _frame_limit ( self , start_time ) :
    """Limit to framerate , should be called after
 rendering has completed
 : param start _ time : When execution started"""

implementation:
if self . _speed :
    completion_time = time ( )
    exc_time = completion_time - start_time
    sleep_for = ( 1.0 / abs ( self . _speed ) ) - exc_time
    if sleep_for > 0 :
        sleep ( sleep_for )


signature:
def _run_frame ( self , executor , limit = False , iteration = 0 ) :
    """Run single frame of the bot
 : param source _ or _ code : path to code to run , or actual code .
 : param limit : Time a frame should take to run ( float - seconds )"""

implementation:
# Gets a bit complex here . . .
# Nodebox ( which we are trying to be compatible with ) supports two
# kinds of bot ' dynamic ' which has a ' draw ' function and non dynamic
# which doesn ' t have one .
# Dynamic bots :
# First run :
# run body and ' setup ' if it exists , then ' draw '
# Later runs :
# run ' draw '
# Non Dynamic bots :
# Just have a ' body ' and run once . . .
# UNLESS . . . a ' var ' is changed , then run it again .
# Livecoding :
# Code can be ' known _ good ' or ' tenous ' ( when it has been edited ) .
# If code is tenous and an exception occurs , attempt to roll
# everything back .
# Livecoding and vars
# If vars are added / removed or renamed then attempt to update
# the GUI
start_time = time ( )
if iteration != 0 and self . _speed != 0 :
    self . _canvas . reset_canvas ( )
self . _set_dynamic_vars ( )
if iteration == 0 : # First frame
    executor . run ( )
    # run setup and draw
    # ( assume user hasn ' t live edited already )
    executor . ns [ 'setup' ] ( )
    executor . ns [ 'draw' ] ( )
    self . _canvas . flush ( self . _frame )
else : # Subsequent frames
    if self . _dynamic :
        if self . _speed != 0 : # speed 0 is paused , so do nothing
            with executor . run_context ( ) as ( known_good , source , ns ) : # Code in main block may redefine ' draw '
                if not known_good :
                    executor . reload_functions ( )
                    with VarListener . batch ( self . _vars , self . _oldvars , ns ) :
                        self . _oldvars . clear ( )
                        # Re - run the function body - ideally this would only
                        # happen if the body had actually changed
                        # - Or perhaps if the line included a variable declaration
                        exec source in ns
                ns [ 'draw' ] ( )
                self . _canvas . flush ( self . _frame )
    else : # Non " dynamic " bots
    # TODO - This part is overly complex , before live - coding it
    # was just exec source in ns . . . have to see if it
    # can be simplified again .
        with executor . run_context ( ) as ( known_good , source , ns ) :
            if not known_good :
                executor . reload_functions ( )
                with VarListener . batch ( self . _vars , self . _oldvars , ns ) :
                    self . _oldvars . clear ( )
                    # Re - run the function body - ideally this would only
                    # happen if the body had actually changed
                    # - Or perhaps if the line included a variable declaration
                    exec source in ns
            else : exec
                source in ns
            self . _canvas . flush ( self . _frame )
if limit :
    self . _frame_limit ( start_time )
# Can set speed to go backwards using the shell if you really want
# or pause by setting speed = = 0
if self . _speed > 0 :
    self . _frame += 1
elif self . _speed < 0 :
    self . _frame -= 1


signature:
def run ( self , inputcode , iterations = None , run_forever = False , frame_limiter = False , verbose = False , break_on_error = False ) :
    '''Executes the contents of a Nodebox / Shoebot script
 in current surface ' s context .
 : param inputcode : Path to shoebot source or string containing source
 : param iterations : None or Maximum amount of frames to run
 : param run _ forever : If True then run until user quits the bot
 : param frame _ limiter : If True then sleep between frames to respect speed ( ) command .'''

implementation:
source = None
filename = None
if os . path . isfile ( inputcode ) :
    source = open ( inputcode ) . read ( )
    filename = inputcode
elif isinstance ( inputcode , basestring ) :
    filename = 'shoebot_code'
    source = inputcode
self . _load_namespace ( self . _namespace , filename )
self . _executor = executor = LiveExecution ( source , ns = self . _namespace , filename = filename )
try :
    if not iterations :
        if run_forever :
            iterations = None
        else :
            iterations = 1
    iteration = 0
    event = None
    while iteration != iterations and not event_is ( event , QUIT_EVENT ) : # do the magic
    # First iteration
        self . _run_frame ( executor , limit = frame_limiter , iteration = iteration )
        if iteration == 0 :
            self . _initial_namespace = copy . copy ( self . _namespace )
            # Stored so script can be rewound
        iteration += 1
        # Subsequent iterations
        while self . _should_run ( iteration , iterations ) and event is None :
            iteration += 1
            self . _run_frame ( executor , limit = frame_limiter , iteration = iteration )
            event = next_event ( )
            if not event :
                self . _canvas . sink . main_iteration ( )
        # update GUI , may generate events . .
        while run_forever : # Running in GUI , bot has finished
        # Either -
        # receive quit event and quit
        # receive any other event and loop ( e . g . if var changed or source edited )
            while event is None :
                self . _canvas . sink . main_iteration ( )
                event = next_event ( block = True , timeout = 0.05 )
                if not event :
                    self . _canvas . sink . main_iteration ( )
            # update GUI , may generate events . .
            if event . type == QUIT_EVENT :
                break
            elif event . type == SOURCE_CHANGED_EVENT : # Debounce SOURCE _ CHANGED events -
            # gedit generates two events for changing a single character -
            # delete and then add
                while event and event . type == SOURCE_CHANGED_EVENT :
                    event = next_event ( block = True , timeout = 0.001 )
            elif event . type == SET_WINDOW_TITLE :
                self . _canvas . sink . set_title ( event . data )
            event = None
            # this loop is a bit weird . . .
            break
except Exception as e : # this makes KeyboardInterrupts still work
# if something goes wrong , print verbose system output
# maybe this is too verbose , but okay for now
    import sys
    if verbose :
        errmsg = traceback . format_exc ( )
    else :
        errmsg = simple_traceback ( e , executor . known_good or '' )
    print >> sys . stderr , errmsg
    if break_on_error :
        raise


signature:
def _addvar ( self , v ) :
    '''Sets a new accessible variable .
 : param v : Variable .'''

implementation:
oldvar = self . _oldvars . get ( v . name )
if oldvar is not None :
    if isinstance ( oldvar , Variable ) :
        if oldvar . compliesTo ( v ) :
            v . value = oldvar . value
    else : # Set from commandline
        v . value = v . sanitize ( oldvar )
else :
    for listener in VarListener . listeners :
        listener . var_added ( v )
self . _vars [ v . name ] = v
self . _namespace [ v . name ] = v . value
self . _oldvars [ v . name ] = v
return v


signature:
def parse_color ( v , color_range = 1 ) :
    '''Receives a colour definition and returns a ( r , g , b , a ) tuple .
 Accepts :
 - ( v , a )
 - ( r , g , b )
 - ( r , g , b , a )
 - # RRGGBB
 - RRGGBB
 - # RRGGBBAA
 - RRGGBBAA
 Returns a ( red , green , blue , alpha ) tuple , with values ranging from
 0 to 1.
 The ' color _ range ' parameter sets the colour range in which the
 colour data values are specified ( except in hexstrings ) .'''

implementation:
# unpack one - element tuples , they show up sometimes
while isinstance ( v , ( tuple , list ) ) and len ( v ) == 1 :
    v = v [ 0 ]
if isinstance ( v , ( int , float ) ) :
    red = green = blue = v / color_range
    alpha = 1.
elif isinstance ( v , data . Color ) :
    red , green , blue , alpha = v
elif isinstance ( v , ( tuple , list ) ) : # normalise values according to the supplied colour range
# for this we make a list with the normalised data
    color = [ ]
    for index in range ( 0 , len ( v ) ) :
        color . append ( v [ index ] / color_range )
    if len ( color ) == 1 :
        red = green = blue = alpha = color [ 0 ]
    elif len ( color ) == 2 :
        red = green = blue = color [ 0 ]
        alpha = color [ 1 ]
    elif len ( color ) == 3 :
        red = color [ 0 ]
        green = color [ 1 ]
        blue = color [ 2 ]
        alpha = 1.
    elif len ( color ) == 4 :
        red = color [ 0 ]
        green = color [ 1 ]
        blue = color [ 2 ]
        alpha = color [ 3 ]
elif isinstance ( v , basestring ) : # got a hexstring : first remove hash character , if any
    v = v . strip ( '#' )
    if len ( data ) == 6 : # RRGGBB
        red = hex2dec ( v [ 0 : 2 ] ) / 255.
        green = hex2dec ( v [ 2 : 4 ] ) / 255.
        blue = hex2dec ( v [ 4 : 6 ] ) / 255.
        alpha = 1.
    elif len ( v ) == 8 :
        red = hex2dec ( v [ 0 : 2 ] ) / 255.
        green = hex2dec ( v [ 2 : 4 ] ) / 255.
        blue = hex2dec ( v [ 4 : 6 ] ) / 255.
        alpha = hex2dec ( v [ 6 : 8 ] ) / 255.
return red , green , blue , alpha


signature:
def hex_to_rgb ( hex ) :
    """Returns RGB values for a hex color string ."""


signature:
def cmyk_to_rgb ( c , m , y , k ) :
    """Cyan , magenta , yellow , black to red , green , blue .
 ReportLab , http : / / www . koders . com / python / fid5C006F554616848C01AC7CB96C21426B69D2E5A9 . aspx
 Results will differ from the way NSColor converts color spaces ."""


signature:
def hsv_to_rgb ( h , s , v ) :
    """Hue , saturation , brightness to red , green , blue .
 http : / / www . koders . com / python / fidB2FE963F658FE74D9BF74EB93EFD44DCAE45E10E . aspx
 Results will differ from the way NSColor converts color spaces ."""

implementation:
if s == 0 :
    return v , v , v
h = h / ( 60.0 / 360 )
i = floor ( h )
f = h - i
p = v * ( 1 - s )
q = v * ( 1 - s * f )
t = v * ( 1 - s * ( 1 - f ) )
if i == 0 :
    r , g , b = v , t , p
elif i == 1 :
    r , g , b = q , v , p
elif i == 2 :
    r , g , b = p , v , t
elif i == 3 :
    r , g , b = p , q , v
elif i == 4 :
    r , g , b = t , p , v
else :
    r , g , b = v , p , q
return r , g , b


signature:
def simple_traceback ( ex , source ) :
    """Format traceback , showing line number and surrounding source ."""

implementation:
exc_type , exc_value , exc_tb = sys . exc_info ( )
exc = traceback . format_exception ( exc_type , exc_value , exc_tb )
source_arr = source . splitlines ( )
# Defaults . . .
exc_location = exc [ - 2 ]
for i , err in enumerate ( exc ) :
    if 'exec source in ns' in err :
        exc_location = exc [ i + 1 ]
        break
# extract line number from traceback
fn = exc_location . split ( ',' ) [ 0 ] [ 8 : - 1 ]
line_number = int ( exc_location . split ( ',' ) [ 1 ] . replace ( 'line' , '' ) . strip ( ) )
# Build error messages
err_msgs = [ ]
# code around the error
err_where = ' ' . join ( exc [ i - 1 ] . split ( ',' ) [ 1 : ] ) . strip ( )
# ' line 37 in blah "
err_msgs . append ( 'Error in the Shoebot script at %s:' % err_where )
for i in xrange ( max ( 0 , line_number - 5 ) , line_number ) :
    if fn == "<string>" :
        line = source_arr [ i ]
    else :
        line = linecache . getline ( fn , i + 1 )
    err_msgs . append ( '%s: %s' % ( i + 1 , line . rstrip ( ) ) )
err_msgs . append ( '  %s^ %s' % ( len ( str ( i ) ) * ' ' , exc [ - 1 ] . rstrip ( ) ) )
err_msgs . append ( '' )
# traceback
err_msgs . append ( exc [ 0 ] . rstrip ( ) )
for err in exc [ 3 : ] :
    err_msgs . append ( err . rstrip ( ) )
return '\n' . join ( err_msgs )


signature:
def connect ( self , name ) :
    """Generic database .
 Opens the SQLite database with the given name .
 The . db extension is automatically appended to the name .
 For each table in the database an attribute is created ,
 and assigned a Table object .
 You can do : database . table or database [ table ] ."""

implementation:
self . _name = name . rstrip ( ".db" )
self . _con = sqlite . connect ( self . _name + ".db" )
self . _cur = self . _con . cursor ( )
self . _tables = [ ]
self . _cur . execute ( "select name from sqlite_master where type='table'" )
for r in self . _cur :
    self . _tables . append ( r [ 0 ] )
self . _indices = [ ]
self . _cur . execute ( "select name from sqlite_master where type='index'" )
for r in self . _cur :
    self . _indices . append ( r [ 0 ] )
for t in self . _tables :
    self . _cur . execute ( "pragma table_info(" + t + ")" )
    fields = [ ]
    key = ""
    for r in self . _cur :
        fields . append ( r [ 1 ] )
        if r [ 2 ] == "integer" :
            key = r [ 1 ]
    setattr ( self , t , Table ( self , t , key , fields ) )


signature:
def create ( self , name , overwrite = True ) :
    """Creates an SQLite database file .
 Creates an SQLite database with the given name .
 The . box file extension is added automatically .
 Overwrites any existing database by default ."""

implementation:
self . _name = name . rstrip ( ".db" )
from os import unlink
if overwrite :
    try :
        unlink ( self . _name + ".db" )
    except :
        pass
self . _con = sqlite . connect ( self . _name + ".db" )
self . _cur = self . _con . cursor ( )


signature:
def create_table ( self , name , fields = [ ] , key = "id" ) :
    """Creates a new table .
 Creates a table with the given name ,
 containing the list of given fields .
 Since SQLite uses manifest typing , no data type need be supplied .
 The primary key is " id " by default ,
 an integer that can be set or otherwise autoincrements ."""

implementation:
for f in fields :
    if f == key :
        fields . remove ( key )
sql = "create table " + name + " "
sql += "(" + key + " integer primary key"
for f in fields :
    sql += ", " + f + " varchar(255)"
sql += ")"
self . _cur . execute ( sql )
self . _con . commit ( )
self . index ( name , key , unique = True )
self . connect ( self . _name )


signature:
def create_index ( self , table , field , unique = False , ascending = True ) :
    """Creates a table index .
 Creates an index on the given table ,
 on the given field with unique values enforced or not ,
 in ascending or descending order ."""

implementation:
if unique :
    u = "unique "
else :
    u = ""
if ascending :
    a = "asc"
else :
    a = "desc"
sql = "create " + u + "index index_" + table + "_" + field + " "
sql += "on " + table + "(" + field + " " + a + ")"
self . _cur . execute ( sql )
self . _con . commit ( )


signature:
def close ( self ) :
    """Commits any pending transactions and closes the database ."""

implementation:
self . _con . commit ( )
self . _cur . close ( )
self . _con . close ( )


signature:
def sql ( self , sql ) :
    """Executes a raw SQL statement on the database ."""

implementation:
self . _cur . execute ( sql )
if sql . lower ( ) . find ( "select" ) >= 0 :
    matches = [ ]
    for r in self . _cur :
        matches . append ( r )
    return matches


signature:
def find ( self , q , operator = "=" , fields = "*" , key = None ) :
    """A simple SQL SELECT query .
 Retrieves all rows from the table
 where the given query value is found in the given column ( primary key if None ) .
 A different comparison operator ( e . g . > , < , like ) can be set .
 The wildcard character is * and automatically sets the operator to " like " .
 Optionally , the fields argument can be a list of column names to select .
 Returns a list of row tuples containing fields ."""

implementation:
if key == None :
    key = self . _key
if fields != "*" :
    fields = ", " . join ( fields )
try :
    q = unicode ( q )
except :
    pass
if q != "*" and ( q [ 0 ] == "*" or q [ - 1 ] == "*" ) :
    if q [ 0 ] == "*" :
        q = "%" + q . lstrip ( "*" )
    if q [ - 1 ] == "*" :
        q = q . rstrip ( "*" ) + "%"
    operator = "like"
if q != "*" :
    sql = "select " + fields + " from " + self . _name + " where " + key + " " + operator + " ?"
    self . _db . _cur . execute ( sql , ( q , ) )
else :
    sql = "select " + fields + " from " + self . _name
    self . _db . _cur . execute ( sql )
# You need to watch out here when bad unicode data
# has entered the database : pysqlite will throw an OperationalError .
# http : / / lists . initd . org / pipermail / pysqlite / 2006 - April / 000488 . html
matches = [ ]
for r in self . _db . _cur :
    matches . append ( r )
return matches


signature:
def append ( self , * args , ** kw ) :
    """Adds a new row to a table .
 Adds a row to the given table .
 The column names and their corresponding values
 must either be supplied as a dictionary of { fields : values } ,
 or a series of keyword arguments of field = value style ."""

implementation:
if args and kw :
    return
if args and type ( args [ 0 ] ) == dict :
    fields = [ k for k in args [ 0 ] ]
    v = [ args [ 0 ] [ k ] for k in args [ 0 ] ]
if kw :
    fields = [ k for k in kw ]
    v = [ kw [ k ] for k in kw ]
q = ", " . join ( [ "?" for x in fields ] )
sql = "insert into " + self . _name + " (" + ", " . join ( fields ) + ") "
sql += "values (" + q + ")"
self . _db . _cur . execute ( sql , v )
self . _db . _i += 1
if self . _db . _i >= self . _db . _commit :
    self . _db . _i = 0
    self . _db . _con . commit ( )


signature:
def edit ( self , id , * args , ** kw ) :
    """Edits the row with given id ."""

implementation:
if args and kw :
    return
if args and type ( args [ 0 ] ) == dict :
    fields = [ k for k in args [ 0 ] ]
    v = [ args [ 0 ] [ k ] for k in args [ 0 ] ]
if kw :
    fields = [ k for k in kw ]
    v = [ kw [ k ] for k in kw ]
sql = "update " + self . _name + " set " + "=?, " . join ( fields ) + "=? where " + self . _key + "=" + unicode ( id )
self . _db . _cur . execute ( sql , v )
self . _db . _i += 1
if self . _db . _i >= self . _db . _commit :
    self . _db . _i = 0
    self . _db . _con . commit ( )


signature:
def remove ( self , id , operator = "=" , key = None ) :
    """Deletes the row with given id ."""

implementation:
if key == None :
    key = self . _key
try :
    id = unicode ( id )
except :
    pass
sql = "delete from " + self . _name + " where " + key + " " + operator + " ?"
self . _db . _cur . execute ( sql , ( id , ) )


signature:
def next_event ( block = False , timeout = None ) :
    """Get the next available event or None
 : param block :
 : param timeout :
 : return : None or ( event , data )"""

implementation:
try :
    return channel . listen ( block = block , timeout = timeout ) . next ( ) [ 'data' ]
except StopIteration :
    return None


signature:
def publish_event ( event_t , data = None , extra_channels = None , wait = None ) :
    """Publish an event ot any subscribers .
 : param event _ t : event type
 : param data : event data
 : param extra _ channels :
 : param wait :
 : return :"""

implementation:
event = Event ( event_t , data )
pubsub . publish ( "shoebot" , event )
for channel_name in extra_channels or [ ] :
    pubsub . publish ( channel_name , event )
if wait is not None :
    channel = pubsub . subscribe ( wait )
    channel . listen ( wait )


signature:
def _set_mode ( self , mode ) :
    '''Sets call _ transform _ mode to point to the
 center _ transform or corner _ transform'''

implementation:
if mode == CENTER :
    self . _call_transform_mode = self . _center_transform
elif mode == CORNER :
    self . _call_transform_mode = self . _corner_transform
else :
    raise ValueError ( 'mode must be CENTER or CORNER' )


signature:
def _center_transform ( self , transform ) :
    '''Works like setupTransform of a version of java nodebox
 http : / / dev . nodebox . net / browser / nodebox - java / branches / rewrite / src / java / net / nodebox / graphics / Grob . java'''

implementation:
dx , dy = self . _get_center ( )
t = cairo . Matrix ( )
t . translate ( dx , dy )
t = transform * t
t . translate ( - dx , - dy )
return t


signature:
def inheritFromContext ( self , ignore = ( ) ) :
    """Doesn ' t store exactly the same items as Nodebox for ease of implementation ,
 it has enough to get the Nodebox Dentrite example working ."""

implementation:
for canvas_attr , grob_attr in STATES . items ( ) :
    if canvas_attr in ignore :
        continue
    setattr ( self , grob_attr , getattr ( self . _bot . _canvas , canvas_attr ) )


signature:
def load_edited_source ( self , source , good_cb = None , bad_cb = None , filename = None ) :
    """Load changed code into the execution environment .
 Until the code is executed correctly , it will be
 in the ' tenuous ' state ."""

implementation:
with LiveExecution . lock :
    self . good_cb = good_cb
    self . bad_cb = bad_cb
    try : # text compile
        compile ( source + '\n\n' , filename or self . filename , "exec" )
        self . edited_source = source
    except Exception as e :
        if bad_cb :
            self . edited_source = None
            tb = traceback . format_exc ( )
            self . call_bad_cb ( tb )
        return
    if filename is not None :
        self . filename = filename


signature:
def reload_functions ( self ) :
    """Replace functions in namespace with functions from edited _ source ."""

implementation:
with LiveExecution . lock :
    if self . edited_source :
        tree = ast . parse ( self . edited_source )
        for f in [ n for n in ast . walk ( tree ) if isinstance ( n , ast . FunctionDef ) ] :
            self . ns [ f . name ] . __code__ = meta . decompiler . compile_func ( f , self . filename , self . ns ) . __code__


signature:
def run_tenuous ( self ) :
    """Run edited source , if no exceptions occur then it
 graduates to known good ."""

implementation:
with LiveExecution . lock :
    ns_snapshot = copy . copy ( self . ns )
    try :
        source = self . edited_source
        self . edited_source = None
        self . do_exec ( source , ns_snapshot )
        self . known_good = source
        self . call_good_cb ( )
        return True , None
    except Exception as ex :
        tb = traceback . format_exc ( )
        self . call_bad_cb ( tb )
        self . ns . clear ( )
        self . ns . update ( ns_snapshot )
        return False , ex


signature:
def run ( self ) :
    """Attempt to known good or tenuous source ."""

implementation:
with LiveExecution . lock :
    if self . edited_source :
        success , ex = self . run_tenuous ( )
        if success :
            return
    self . do_exec ( self . known_good , self . ns )


signature:
def call_bad_cb ( self , tb ) :
    """If bad _ cb returns True then keep it
 : param tb : traceback that caused exception
 : return :"""

implementation:
with LiveExecution . lock :
    if self . bad_cb and not self . bad_cb ( tb ) :
        self . bad_cb = None


signature:
def call_good_cb ( self ) :
    """If good _ cb returns True then keep it
 : return :"""

implementation:
with LiveExecution . lock :
    if self . good_cb and not self . good_cb ( ) :
        self . good_cb = None


signature:
def run_context ( self ) :
    """Context in which the user can run the source in a custom manner .
 If no exceptions occur then the source will move from ' tenuous '
 to ' known good ' .
 > > > with run _ context ( ) as ( known _ good , source , ns ) :
 > > > . . . exec source in ns
 > > > . . . ns [ ' draw ' ] ( )"""

implementation:
with LiveExecution . lock :
    if self . edited_source is None :
        yield True , self . known_good , self . ns
        return
    ns_snapshot = copy . copy ( self . ns )
    try :
        yield False , self . edited_source , self . ns
        self . known_good = self . edited_source
        self . edited_source = None
        self . call_good_cb ( )
        return
    except Exception as ex :
        tb = traceback . format_exc ( )
        self . call_bad_cb ( tb )
        self . edited_source = None
        self . ns . clear ( )
        self . ns . update ( ns_snapshot )


signature:
def cohesion ( self , d = 100 ) :
    """Boids move towards the flock ' s centre of mass .
 The centre of mass is the average position of all boids ,
 not including itself ( the " perceived centre " ) ."""

implementation:
vx = vy = vz = 0
for b in self . boids :
    if b != self :
        vx , vy , vz = vx + b . x , vy + b . y , vz + b . z
n = len ( self . boids ) - 1
vx , vy , vz = vx / n , vy / n , vz / n
return ( vx - self . x ) / d , ( vy - self . y ) / d , ( vz - self . z ) / d


signature:
def separation ( self , r = 10 ) :
    """Boids keep a small distance from other boids .
 Ensures that boids don ' t collide into each other ,
 in a smoothly accelerated motion ."""

implementation:
vx = vy = vz = 0
for b in self . boids :
    if b != self :
        if abs ( self . x - b . x ) < r :
            vx += ( self . x - b . x )
        if abs ( self . y - b . y ) < r :
            vy += ( self . y - b . y )
        if abs ( self . z - b . z ) < r :
            vz += ( self . z - b . z )
return vx , vy , vz


signature:
def alignment ( self , d = 5 ) :
    """Boids match velocity with other boids ."""

implementation:
vx = vy = vz = 0
for b in self . boids :
    if b != self :
        vx , vy , vz = vx + b . vx , vy + b . vy , vz + b . vz
n = len ( self . boids ) - 1
vx , vy , vz = vx / n , vy / n , vz / n
return ( vx - self . vx ) / d , ( vy - self . vy ) / d , ( vz - self . vz ) / d


signature:
def limit ( self , max = 30 ) :
    """The speed limit for a boid .
 Boids can momentarily go very fast ,
 something that is impossible for real animals ."""

implementation:
if abs ( self . vx ) > max :
    self . vx = self . vx / abs ( self . vx ) * max
if abs ( self . vy ) > max :
    self . vy = self . vy / abs ( self . vy ) * max
if abs ( self . vz ) > max :
    self . vz = self . vz / abs ( self . vz ) * max


signature:
def _angle ( self ) :
    """Returns the angle towards which the boid is steering ."""

implementation:
from math import atan , pi , degrees
a = degrees ( atan ( self . vy / self . vx ) ) + 360
if self . vx < 0 :
    a += 180
return a


signature:
def goal ( self , x , y , z , d = 50.0 ) :
    """Tendency towards a particular place ."""

implementation: return ( x - self . x ) / d , ( y - self . y ) / d , ( z - self . z ) / d


signature:
def constrain ( self ) :
    """Cages the flock inside the x , y , w , h area .
 The actual cage is a bit larger ,
 so boids don ' t seem to bounce of invisible walls
 ( they are rather " encouraged " to stay in the area ) .
 If a boid touches the ground level ,
 it may decide to perch there for a while ."""

implementation:
dx = self . w * 0.1
dy = self . h * 0.1
for b in self :
    if b . x < self . x - dx :
        b . vx += _ctx . random ( dx )
    if b . y < self . y - dy :
        b . vy += _ctx . random ( dy )
    if b . x > self . x + self . w + dx :
        b . vx -= _ctx . random ( dx )
    if b . y > self . y + self . h + dy :
        b . vy -= _ctx . random ( dy )
    if b . z < 0 :
        b . vz += 10
    if b . z > 100 :
        b . vz -= 10
    if b . y > self . _perch_y and _ctx . random ( ) < self . _perch :
        b . y = self . _perch_y
        b . vy = - abs ( b . vy ) * 0.2
        b . is_perching = True
        try :
            b . _perch_t = self . _perch_t ( )
        except :
            b . _perch_t = self . _perch_t


signature:
def update ( self , shuffled = True , cohesion = 100 , separation = 10 , alignment = 5 , goal = 20 , limit = 30 ) :
    """Calculates the next motion frame for the flock ."""

implementation:
# Shuffling the list of boids ensures fluid movement .
# If you need the boids to retain their position in the list
# each update , set the shuffled parameter to False .
from random import shuffle
if shuffled :
    shuffle ( self )
m1 = 1.0
# cohesion
m2 = 1.0
# separation
m3 = 1.0
# alignment
m4 = 1.0
# goal
# The flock scatters randomly with a Boids . scatter chance .
# This means their cohesion ( m1 ) is reversed ,
# and their joint alignment ( m3 ) is dimished ,
# causing boids to oscillate in confusion .
# Setting Boids . scatter ( chance = 0 ) ensures they never scatter .
if not self . scattered and _ctx . random ( ) < self . _scatter :
    self . scattered = True
if self . scattered :
    m1 = - m1
    m3 *= 0.25
    self . _scatter_i += 1
if self . _scatter_i >= self . _scatter_t :
    self . scattered = False
    self . _scatter_i = 0
# A flock can have a goal defined with Boids . goal ( x , y , z ) ,
# a place of interest to flock around .
if not self . has_goal :
    m4 = 0
if self . flee :
    m4 = - m4
for b in self : # A boid that is perching will continue to do so
# until Boid . _ perch _ t reaches zero .
    if b . is_perching :
        if b . _perch_t > 0 :
            b . _perch_t -= 1
            continue
        else :
            b . is_perching = False
    vx1 , vy1 , vz1 = b . cohesion ( cohesion )
    vx2 , vy2 , vz2 = b . separation ( separation )
    vx3 , vy3 , vz3 = b . alignment ( alignment )
    vx4 , vy4 , vz4 = b . goal ( self . _gx , self . _gy , self . _gz , goal )
    b . vx += m1 * vx1 + m2 * vx2 + m3 * vx3 + m4 * vx4
    b . vy += m1 * vy1 + m2 * vy2 + m3 * vy3 + m4 * vy4
    b . vz += m1 * vz1 + m2 * vz2 + m3 * vz3 + m4 * vz4
    b . limit ( limit )
    b . x += b . vx
    b . y += b . vy
    b . z += b . vz
self . constrain ( )


signature:
def iterscan ( self , string , idx = 0 , context = None ) :
    """Yield match , end _ idx for each match"""

implementation:
match = self . scanner . scanner ( string , idx ) . match
actions = self . actions
lastend = idx
end = len ( string )
while True :
    m = match ( )
    if m is None :
        break
    matchbegin , matchend = m . span ( )
    if lastend == matchend :
        break
    action = actions [ m . lastindex ]
    if action is not None :
        rval , next_pos = action ( m , context )
        if next_pos is not None and next_pos != matchend : # " fast forward " the scanner
            matchend = next_pos
            match = self . scanner . scanner ( string , matchend ) . match
        yield rval , matchend
    lastend = matchend


signature:
def copy ( self , graph ) :
    """Returns a copy of the layout for the given graph ."""

implementation:
l = self . __class__ ( graph , self . n )
l . i = 0
return l


signature:
def create ( iterations = 1000 , distance = 1.0 , layout = LAYOUT_SPRING , depth = True ) :
    """Returns a new graph with predefined styling ."""

implementation:
# global _ ctx
_ctx . colormode ( _ctx . RGB )
g = graph ( iterations , distance , layout )
# Styles for different types of nodes .
s = style . style
g . styles . append ( s ( style . LIGHT , _ctx , fill = _ctx . color ( 0.0 , 0.0 , 0.0 , 0.20 ) ) )
g . styles . append ( s ( style . DARK , _ctx , fill = _ctx . color ( 0.3 , 0.5 , 0.7 , 0.75 ) ) )
g . styles . append ( s ( style . BACK , _ctx , fill = _ctx . color ( 0.5 , 0.8 , 0.0 , 0.50 ) ) )
g . styles . append ( s ( style . IMPORTANT , _ctx , fill = _ctx . color ( 0.3 , 0.6 , 0.8 , 0.75 ) ) )
g . styles . append ( s ( style . HIGHLIGHT , _ctx , stroke = _ctx . color ( 1.0 , 0.0 , 0.5 ) , strokewidth = 1.5 ) )
g . styles . append ( s ( style . MARKED , _ctx ) )
g . styles . append ( s ( style . ROOT , _ctx , text = _ctx . color ( 1.0 , 0.0 , 0.4 , 1.00 ) , stroke = _ctx . color ( 0.8 , 0.8 , 0.8 , 0.60 ) , strokewidth = 1.5 , fontsize = 16 , textwidth = 150 ) )
# Important nodes get a double stroke .
def important_node ( s , node , alpha = 1.0 ) :
    style . style ( None , _ctx ) . node ( s , node , alpha )
    r = node . r * 1.4
    _ctx . nofill ( )
    _ctx . oval ( node . x - r , node . y - r , r * 2 , r * 2 )
# Marked nodes have an inner dot .
def marked_node ( s , node , alpha = 1.0 ) :
    style . style ( None , _ctx ) . node ( s , node , alpha )
    r = node . r * 0.3
    _ctx . fill ( s . stroke )
    _ctx . oval ( node . x - r , node . y - r , r * 2 , r * 2 )
g . styles . important . node = important_node
g . styles . marked . node = marked_node
g . styles . depth = depth
# Styling guidelines . All nodes have the default style , except :
# 1 ) a node directly connected to the root gets the LIGHT style .
# 2 ) a node with more than 4 edges gets the DARK style .
# 3 ) a node with a weight of 0.75-1.0 gets the IMPORTANT style .
# 4 ) the graph . root node gets the ROOT style .
# 5 ) the node last clicked gets the BACK style .
g . styles . guide . append ( style . LIGHT , lambda graph , node : graph . root in node . links )
g . styles . guide . append ( style . DARK , lambda graph , node : len ( node . links ) > 4 )
g . styles . guide . append ( style . IMPORTANT , lambda graph , node : node . weight > 0.75 )
g . styles . guide . append ( style . ROOT , lambda graph , node : node == graph . root )
g . styles . guide . append ( style . BACK , lambda graph , node : node == graph . events . clicked )
# An additional rule applies every node ' s weight to its radius .
def balance ( graph , node ) :
    node . r = node . r * 0.75 + node . r * node . weight * 0.75
g . styles . guide . append ( "balance" , balance )
# An additional rule that keeps leaf nodes closely clustered .
def cluster ( graph , node ) :
    if len ( node . links ) == 1 :
        node . links . edge ( node . links [ 0 ] ) . length *= 0.5
g . styles . guide . append ( "cluster" , cluster )
g . styles . guide . order = [ style . LIGHT , style . DARK , style . IMPORTANT , style . ROOT , style . BACK , "balance" , "nurse" ]
return g


signature:
def can_reach ( self , node , traversable = lambda node , edge : True ) :
    """Returns True if given node can be reached over traversable edges .
 To enforce edge direction , use a node = = edge . node1 traversable ."""

implementation:
if isinstance ( node , str ) :
    node = self . graph [ node ]
for n in self . graph . nodes :
    n . _visited = False
return proximity . depth_first_search ( self , visit = lambda n : node == n , traversable = traversable )


signature:
def copy ( self , empty = False ) :
    """Create a copy of the graph ( by default with nodes and edges ) ."""

implementation:
g = graph ( self . layout . n , self . distance , self . layout . type )
g . layout = self . layout . copy ( g )
g . styles = self . styles . copy ( g )
g . events = self . events . copy ( g )
if not empty :
    for n in self . nodes :
        g . add_node ( n . id , n . r , n . style , n . category , n . label , ( n == self . root ) , n . __dict__ )
    for e in self . edges :
        g . add_edge ( e . node1 . id , e . node2 . id , e . weight , e . length , e . label , e . __dict__ )
return g


signature:
def clear ( self ) :
    """Remove nodes and edges and reset the layout ."""

implementation:
dict . clear ( self )
self . nodes = [ ]
self . edges = [ ]
self . root = None
self . layout . i = 0
self . alpha = 0


signature:
def add_node ( self , id , radius = 8 , style = style . DEFAULT , category = "" , label = None , root = False , properties = { } ) :
    """Add node from id and return the node object ."""

implementation:
if self . has_key ( id ) :
    return self [ id ]
if not isinstance ( style , str ) and style . __dict__ . has_key [ "name" ] :
    style = style . name
n = node ( self , id , radius , style , category , label , properties )
self [ n . id ] = n
self . nodes . append ( n )
if root :
    self . root = n
return n


signature:
def add_edge ( self , id1 , id2 , weight = 0.0 , length = 1.0 , label = "" , properties = { } ) :
    """Add weighted ( 0.0-1.0 ) edge between nodes , creating them if necessary .
 The weight represents the importance of the connection ( not the cost ) ."""

implementation:
if id1 == id2 :
    return None
if not self . has_key ( id1 ) :
    self . add_node ( id1 )
if not self . has_key ( id2 ) :
    self . add_node ( id2 )
n1 = self [ id1 ]
n2 = self [ id2 ]
# If a - > b already exists , don ' t re - create it .
# However , b - > a may still pass .
if n1 in n2 . links :
    if n2 . links . edge ( n1 ) . node1 == n1 :
        return self . edge ( id1 , id2 )
weight = max ( 0.0 , min ( weight , 1.0 ) )
e = edge ( n1 , n2 , weight , length , label , properties )
self . edges . append ( e )
n1 . links . append ( n2 , e )
n2 . links . append ( n1 , e )
return e


signature:
def remove_node ( self , id ) :
    """Remove node with given id ."""

implementation:
if self . has_key ( id ) :
    n = self [ id ]
    self . nodes . remove ( n )
    del self [ id ]
    # Remove all edges involving id and all links to it .
    for e in list ( self . edges ) :
        if n in ( e . node1 , e . node2 ) :
            if n in e . node1 . links :
                e . node1 . links . remove ( n )
            if n in e . node2 . links :
                e . node2 . links . remove ( n )
            self . edges . remove ( e )


signature:
def remove_edge ( self , id1 , id2 ) :
    """Remove edges between nodes with given id ' s ."""

implementation:
for e in list ( self . edges ) :
    if id1 in ( e . node1 . id , e . node2 . id ) and id2 in ( e . node1 . id , e . node2 . id ) :
        e . node1 . links . remove ( e . node2 )
        e . node2 . links . remove ( e . node1 )
        self . edges . remove ( e )


signature:
def edge ( self , id1 , id2 ) :
    """Returns the edge between the nodes with given id1 and id2."""

implementation:
if id1 in self and id2 in self and self [ id2 ] in self [ id1 ] . links :
    return self [ id1 ] . links . edge ( id2 )
return None


signature:
def update ( self , iterations = 10 ) :
    """Iterates the graph layout and updates node positions ."""

implementation:
# The graph fades in when initially constructed .
self . alpha += 0.05
self . alpha = min ( self . alpha , 1.0 )
# Iterates over the graph ' s layout .
# Each step the graph ' s bounds are recalculated
# and a number of iterations are processed ,
# more and more as the layout progresses .
if self . layout . i == 0 :
    self . layout . prepare ( )
    self . layout . i += 1
elif self . layout . i == 1 :
    self . layout . iterate ( )
elif self . layout . i < self . layout . n :
    n = min ( iterations , self . layout . i / 10 + 1 )
    for i in range ( n ) :
        self . layout . iterate ( )
# Calculate the absolute center of the graph .
min_ , max = self . layout . bounds
self . x = _ctx . WIDTH - max . x * self . d - min_ . x * self . d
self . y = _ctx . HEIGHT - max . y * self . d - min_ . y * self . d
self . x /= 2
self . y /= 2
return not self . layout . done


signature:
def offset ( self , node ) :
    """Returns the distance from the center to the given node ."""

implementation:
x = self . x + node . x - _ctx . WIDTH / 2
y = self . y + node . y - _ctx . HEIGHT / 2
return x , y


signature:
def draw ( self , dx = 0 , dy = 0 , weighted = False , directed = False , highlight = [ ] , traffic = None ) :
    """Layout the graph incrementally .
 The graph is drawn at the center of the canvas .
 The weighted and directed parameters visualize edge weight and direction .
 The highlight specifies list of connected nodes .
 The path will be colored according to the " highlight " style .
 Clicking and dragging events are monitored ."""

implementation:
self . update ( )
# Draw the graph background .
s = self . styles . default
s . graph_background ( s )
# Center the graph on the canvas .
_ctx . push ( )
_ctx . translate ( self . x + dx , self . y + dy )
# Indicate betweenness centrality .
if traffic :
    if isinstance ( traffic , bool ) :
        traffic = 5
    for n in self . nodes_by_betweenness ( ) [ : traffic ] :
        try :
            s = self . styles [ n . style ]
        except :
            s = self . styles . default
        if s . graph_traffic :
            s . graph_traffic ( s , n , self . alpha )
# Draw the edges and their labels .
s = self . styles . default
if s . edges :
    s . edges ( s , self . edges , self . alpha , weighted , directed )
# Draw each node in the graph .
# Apply individual style to each node ( or default ) .
for n in self . nodes :
    try :
        s = self . styles [ n . style ]
    except :
        s = self . styles . default
    if s . node :
        s . node ( s , n , self . alpha )
# Highlight the given shortest path .
try :
    s = self . styles . highlight
except :
    s = self . styles . default
if s . path :
    s . path ( s , self , highlight )
# Draw node id ' s as labels on each node .
for n in self . nodes :
    try :
        s = self . styles [ n . style ]
    except :
        s = self . styles . default
    if s . node_label :
        s . node_label ( s , n , self . alpha )
# Events for clicked and dragged nodes .
# Nodes will resist being dragged by attraction and repulsion ,
# put the event listener on top to get more direct feedback .
# self . events . update ( )
_ctx . pop ( )


signature:
def prune ( self , depth = 0 ) :
    """Removes all nodes with less or equal links than depth ."""

implementation:
for n in list ( self . nodes ) :
    if len ( n . links ) <= depth :
        self . remove_node ( n . id )


signature:
def betweenness_centrality ( self , normalized = True ) :
    """Calculates betweenness centrality and returns an node id - > weight dictionary .
 Node betweenness weights are updated in the process ."""

implementation:
bc = proximity . brandes_betweenness_centrality ( self , normalized )
for id , w in bc . iteritems ( ) :
    self [ id ] . _betweenness = w
return bc


signature:
def eigenvector_centrality ( self , normalized = True , reversed = True , rating = { } , start = None , iterations = 100 , tolerance = 0.0001 ) :
    """Calculates eigenvector centrality and returns an node id - > weight dictionary .
 Node eigenvalue weights are updated in the process ."""

implementation:
ec = proximity . eigenvector_centrality ( self , normalized , reversed , rating , start , iterations , tolerance )
for id , w in ec . iteritems ( ) :
    self [ id ] . _eigenvalue = w
return ec


signature:
def nodes_by_betweenness ( self , treshold = 0.0 ) :
    """Returns nodes sorted by betweenness centrality .
 Nodes with a lot of passing traffic will be at the front of the list ."""

implementation:
nodes = [ ( n . betweenness , n ) for n in self . nodes if n . betweenness > treshold ]
nodes . sort ( ) ;
nodes . reverse ( )
return [ n for w , n in nodes ]


signature:
def nodes_by_eigenvalue ( self , treshold = 0.0 ) :
    """Returns nodes sorted by eigenvector centrality .
 Nodes with a lot of incoming traffic will be at the front of the list"""

implementation:
nodes = [ ( n . eigenvalue , n ) for n in self . nodes if n . eigenvalue > treshold ]
nodes . sort ( ) ;
nodes . reverse ( )
return [ n for w , n in nodes ]


signature:
def nodes_by_category ( self , category ) :
    """Returns nodes with the given category attribute ."""

implementation: return [ n for n in self . nodes if n . category == category ]


signature:
def crown ( self , depth = 2 ) :
    """Returns a list of leaves , nodes connected to leaves , etc ."""

implementation:
nodes = [ ]
for node in self . leaves :
    nodes += node . flatten ( depth - 1 )
return cluster . unique ( nodes )


signature:
def _density ( self ) :
    """The number of edges in relation to the total number of possible edges ."""

implementation: return 2.0 * len ( self . edges ) / ( len ( self . nodes ) * ( len ( self . nodes ) - 1 ) )


signature:
def load ( self , id ) :
    """Rebuilds the graph around the given node id ."""

implementation:
self . clear ( )
# Root node .
self . add_node ( id , root = True )
# Directly connected nodes have priority .
for w , id2 in self . get_links ( id ) :
    self . add_edge ( id , id2 , weight = w )
    if len ( self ) > self . max :
        break
# Now get all the other nodes in the cluster .
for w , id2 , links in self . get_cluster ( id ) :
    for id3 in links :
        self . add_edge ( id3 , id2 , weight = w )
        self . add_edge ( id , id3 , weight = w )
    # if len ( links ) = = 0:
    # self . add _ edge ( id , id2)
    if len ( self ) > self . max :
        break
# Provide a backlink to the previous root .
if self . event . clicked :
    g . add_node ( self . event . clicked )


signature:
def click ( self , node ) :
    """Callback from graph . events when a node is clicked ."""

implementation:
if not self . has_node ( node . id ) :
    return
if node == self . root :
    return
self . _dx , self . _dy = self . offset ( node )
self . previous = self . root . id
self . load ( node . id )