Instruction:
Can you generate the documentation for the following Python 3 function
def drawimage(self, image, x=None, y=None):
        if x is None:
            x = image.x
        if y is None:
            y = image.y
        self.image(image.path, image.x, image.y, data=image.data)

Response: Draw an image from the cache.


Instruction:
Create a Python 3 function to
move relatively to the last point.

Response:
def relmoveto(self, x, y):
        '''Move relatively to the last point.'''
        if self._path is None:
            raise ShoebotError(_("No current path. Use beginpath() first."))
        self._path.relmoveto(x, y)


Instruction:
How would you code a function in Python 3 to
draw a line using relative coordinates.

Response:
def rellineto(self, x, y):
        '''Draw a line using relative coordinates.'''
        if self._path is None:
            raise ShoebotError(_("No current path. Use beginpath() first."))
        self._path.rellineto(x, y)


Instruction:
Here you have a function in Python 3, explain what it does
def relcurveto(self, h1x, h1y, h2x, h2y, x, y):
        '''Draws a curve relatively to the last point.
        '''
        if self._path is None:
            raise ShoebotError(_("No current path. Use beginpath() first."))
        self._path.relcurveto(h1x, h1y, h2x, h2y, x, y)

Response: Draws a curve relatively to the last point.


Instruction:
Can you write a function in Python 3 where it
constructs a path between the given list of points and determines the curvature of the bezier curve.

Response:
def findpath(self, points, curvature=1.0):

        """Constructs a path between the given list of points.

        Interpolates the list of points and determines
        a smooth bezier path betweem them.

        The curvature parameter offers some control on
        how separate segments are stitched together:
        from straight angles to smooth curves.
        Curvature is only useful if the path has more than  three points.
        """

        # The list of points consists of Point objects,
        # but it shouldn't crash on something straightforward
        # as someone supplying a list of (x,y)-tuples.

        for i, pt in enumerate(points):
            if type(pt) == TupleType:
                points[i] = Point(pt[0], pt[1])

        if len(points) == 0:
            return None
        if len(points) == 1:
            path = self.BezierPath(None)
            path.moveto(points[0].x, points[0].y)
            return path
        if len(points) == 2:
            path = self.BezierPath(None)
            path.moveto(points[0].x, points[0].y)
            path.lineto(points[1].x, points[1].y)
            return path

        # Zero curvature means straight lines.

        curvature = max(0, min(1, curvature))
        if curvature == 0:
            path = self.BezierPath(None)
            path.moveto(points[0].x, points[0].y)
            for i in range(len(points)):
                path.lineto(points[i].x, points[i].y)
            return path

        curvature = 4 + (1.0 - curvature) * 40

        dx = {0: 0, len(points) - 1: 0}
        dy = {0: 0, len(points) - 1: 0}
        bi = {1: -0.25}
        ax = {1: (points[2].x - points[0].x - dx[0]) / 4}
        ay = {1: (points[2].y - points[0].y - dy[0]) / 4}

        for i in range(2, len(points) - 1):
            bi[i] = -1 / (curvature + bi[i - 1])
            ax[i] = -(points[i + 1].x - points[i - 1].x - ax[i - 1]) * bi[i]
            ay[i] = -(points[i + 1].y - points[i - 1].y - ay[i - 1]) * bi[i]

        r = range(1, len(points) - 1)
        r.reverse()
        for i in r:
            dx[i] = ax[i] + dx[i + 1] * bi[i]
            dy[i] = ay[i] + dy[i + 1] * bi[i]

        path = self.BezierPath(None)
        path.moveto(points[0].x, points[0].y)
        for i in range(len(points) - 1):
            path.curveto(points[i].x + dx[i],
                         points[i].y + dy[i],
                         points[i + 1].x - dx[i + 1],
                         points[i + 1].y - dy[i + 1],
                         points[i + 1].x,
                         points[i + 1].y)

        return path


Instruction:
How would you explain what the following Python 3 function does
def transform(self, mode=None):
        '''
        Set the current transform mode.

        :param mode: CENTER or CORNER'''
        if mode:
            self._canvas.mode = mode
        return self._canvas.mode

Response: Set the current transform mode.


Instruction:
Can you tell what is the following Python 3 function doing
def translate(self, xt, yt, mode=None):
        '''
        Translate the current position by (xt, yt) and
        optionally set the transform mode.

        :param xt: Amount to move horizontally
        :param yt: Amount to move vertically
        :mode: Set the transform mode to CENTER or CORNER
        '''
        self._canvas.translate(xt, yt)
        if mode:
            self._canvas.mode = mode

Response: Translate the current position by xt yt and set the transform mode to CENTER or CORNER.


Instruction:
How would you implement a function in Python 3 that
sets a scale at which to draw objects at their natural size.

Response:
def scale(self, x=1, y=None):
        '''
        Set a scale at which to draw objects.

        1.0 draws objects at their natural size

        :param x: Scale on the horizontal plane
        :param y: Scale on the vertical plane
        '''
        if not y:
            y = x
        if x == 0:
            # Cairo borks on zero values
            x = 1
        if y == 0:
            y = 1
        self._canvas.scale(x, y)


Instruction:
Here you have a function in Python 3, explain what it does
def fill(self, *args):
        '''Sets a fill color, applying it to new paths.

        :param args: color in supported format
        '''
        if args is not None:
            self._canvas.fillcolor = self.color(*args)
        return self._canvas.fillcolor

Response: Sets a fill color applying it to new paths.


Instruction:
Implement a Python 3 function for
setting a stroke color applying it to new paths.

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

        :param args: color in supported format
        '''
        if args is not None:
            self._canvas.strokecolor = self.color(*args)
        return self._canvas.strokecolor


Instruction:
Create a Python 3 function for
stopping applying strokes to new paths.

Response:
def nostroke(self):
        ''' Stop applying strokes to new paths.

        :return: stroke color before nostroke was called.
        '''
        c = self._canvas.strokecolor
        self._canvas.strokecolor = None
        return c


Instruction:
Implement a Python 3 function for
setting the stroke width.

Response:
def strokewidth(self, w=None):
        '''Set the stroke width.

        :param w: Stroke width.
        :return: If no width was specified then current width is returned.
        '''
        if w is not None:
            self._canvas.strokewidth = w
        else:
            return self._canvas.strokewidth


Instruction:
Write a Python 3 function for
setting the font to be used with new text instances.

Response:
def font(self, fontpath=None, fontsize=None):
        '''Set the font to be used with new text instances.

        :param fontpath: path to truetype or opentype font.
        :param fontsize: size of font

        :return: current current fontpath (if fontpath param not set)
        Accepts TrueType and OpenType files. Depends on FreeType being
        installed.'''
        if fontpath is not None:
            self._canvas.fontfile = fontpath
        else:
            return self._canvas.fontfile
        if fontsize is not None:
            self._canvas.fontsize = fontsize


Instruction:
How would you explain what the following Python 3 function does
def fontsize(self, fontsize=None):
        '''
        Set or return size of current font.

        :param fontsize: Size of font.
        :return: Size of font (if fontsize was not specified)
        '''
        if fontsize is not None:
            self._canvas.fontsize = fontsize
        else:
            return self._canvas.fontsize

Response: Set or return size of current font.


Instruction:
How would you code a function in Python 3 to
draw a string of text according to current font settings.

Response:
def text(self, txt, x, y, width=None, height=1000000, outline=False, draw=True, **kwargs):
        '''
        Draws a string of text according to current font settings.

        :param txt: Text to output
        :param x: x-coordinate of the top left corner
        :param y: y-coordinate of the top left corner
        :param width: text width
        :param height: text height
        :param outline: If True draws outline text (defaults to False)
        :param draw: Set to False to inhibit immediate drawing (defaults to True)
        :return: Path object representing the text.
        '''
        txt = self.Text(txt, x, y, width, height, outline=outline, ctx=None, **kwargs)
        if outline:
            path = txt.path
            if draw:
                path.draw()
            return path
        else:
            return txt


Instruction:
Make a summary of the following Python 3 code
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
        '''
        w = width
        return self.textmetrics(txt, width=w)[1]

Response:
Returns the height of a string of text according to the current
        font settings.


Instruction:
Make a summary of the following Python 3 code
def graph_traffic(s, node, alpha=1.0):

    """ Visualization of traffic-intensive nodes (based on their centrality).
    """

    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)

Response: Visualization of traffic - intensive nodes.


Instruction:
Can you generate the documentation for the following Python 3 function
def node_label(s, node, alpha=1.0):

    """ Visualization of a node's id.
    """

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

Response: Visualize a node s label.


Instruction:
Create a Python 3 function to
visualize the edges in a network.

Response:
def edges(s, edges, alpha=1.0, weighted=False, directed=False):

    """ Visualization of the edges in a network.
    """

    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)


Instruction:
Given the following Python 3 function, write the documentation
def edge(s, path, edge, alpha=1.0):

    """ Visualization of a single edge between two nodes.
    """

    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
        )

Response: Visualization of a single edge between two nodes.


Instruction:
Explain what the following Python 3 code does
def edge_label(s, edge, alpha=1.0):

    """ Visualization of the label accompanying an edge.
    """

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

Response: Visualizes the label accompanying an edge.


Instruction:
How would you explain what the following Python 3 function does
def create(self, stylename, **kwargs):
        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

Response: Creates a new style which inherits from the default style and returns it.


Instruction:
Write a Python 3 script to
return a copy of all styles and the styleguide.

Response:
def copy(self, graph):
        """ Returns a copy of all styles and a copy of the styleguide.
        """
        s = styles(graph)
        s.guide = self.guide.copy(graph)
        dict.__init__(s, [(v.name, v.copy()) for v in self.values()])
        return s


Instruction:
Explain what the following Python 3 code does
def apply(self):
        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

Response: Check the rules for each node in the graph and apply the style.


Instruction:
Write a Python 3 function for
returning a copy of the styleguide for the given graph.

Response:
def copy(self, graph):
        """ Returns a copy of the styleguide for the given graph.
        """
        g = styleguide(graph)
        g.order = self.order
        dict.__init__(g, [(k, v) for k, v in self.iteritems()])
        return g


Instruction:
Write a Python 3 function for
decoding a JSON document from s and return a 2 - tuple of the Python object representation and the index in s where the document ended.

Response:
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.
        """
        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


Instruction:
How would you explain what the following Python 3 function does
def open_socket(self):
        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))

Response: Opens the socket and binds to the given host and port.


Instruction:
Can you implement a function in Python 3 that
loads all possible TUIO profiles and returns a dictionary with the keys and values as keys and an instance of a profile as the value

Response:
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
        """
        _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


Instruction:
Can you write a function in Python 3 where it
updates the internal state of the internal state of the internal state of the internal state.

Response:
def update(self):
        """
        Tells the connection manager to receive the next 1024 byte of messages
        to analyze.
        """
        try:
            self.manager.handle(self.socket.recv(1024))
        except socket.error:
            pass


Instruction:
How would you implement a function in Python 3 that
calls by the CallbackManager when a new message is received by the user.

Response:
def callback(self, *incoming):
        """
        Gets called by the CallbackManager if a new message was received
        """
        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


Instruction:
Can you tell what is the following Python 3 function doing
def copytree(src, dst, symlinks=False, ignore=None):
    # 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)

Response: copytree that works even if folder already exists


Instruction:
Implement a Python 3 function for
serializing obj to a JSON formatted string.

Response:
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.
    """
    # 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)


Instruction:
Implement a function in Python 3 to
return a Google web query formatted as a GoogleSearch list object.

Response:
def search(q, start=0, wait=10, asynchronous=False, cached=False):

    """ Returns a Google web query formatted as a GoogleSearch list object.
    """

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


Instruction:
Given the following Python 3 function, write the documentation
def search_images(q, start=0, size="", wait=10, asynchronous=False, cached=False):

    """ Returns a Google images query formatted as a GoogleSearch list object.
    """

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

Response: Returns a Google search list formatted as a GoogleSearch list object.


Instruction:
Can you create a Python 3 function that
returns a GoogleSearch list formatted as a GoogleSearch list object.

Response:
def search_news(q, start=0, wait=10, asynchronous=False, cached=False):

    """ Returns a Google news query formatted as a GoogleSearch list object.
    """

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


Instruction:
Can you tell what is the following Python 3 function doing
def search_blogs(q, start=0, wait=10, asynchronous=False, cached=False):

    """ Returns a Google blogs query formatted as a GoogleSearch list object.
    """

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

Response: Returns a GoogleSearch list object formatted as a GoogleSearch list object.


Instruction:
Explain what the following Python 3 code does
def _parse(self, str):

        """ Parses the text data from an XML element defined by tag.
        """

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

Response: Parses the text data from an XML element defined by tag.


Instruction:
Here you have a function in Python 3, explain what it does
def hash(self, id):

        """ Creates a unique filename in the cache for the id.
        """

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

Response: Creates a unique filename in the cache for the id.


Instruction:
Implement a Python 3 function for
returning the age of the cache entry in days.

Response:
def age(self, id):

        """ Returns the age of the cache entry, in days.
        """

        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


Instruction:
Here you have a function in Python 3, explain what it does
def angle(x0, y0, x1, y1):
    return degrees(atan2(y1-y0, x1-x0))

Response: Returns the angle between two points.


Instruction:
How would you implement a function in Python 3 that
returns the distance between two points.

Response:
def distance(x0, y0, x1, y1):
    """ Returns the distance between two points.
    """
    return sqrt(pow(x1-x0, 2) + pow(y1-y0, 2))


Instruction:
Create a Python 3 function for
returning the coordinates of a point in a surface by rotating around origin.

Response:
def coordinates(x0, y0, distance, angle):
    """ Returns the location of a point by rotating around origin (x0,y0).
    """
    return (x0 + cos(radians(angle)) * distance,
            y0 + sin(radians(angle)) * distance)


Instruction:
Write a Python 3 function that can
rotate the coordinates of x y around origin x0 y0 around origin y0 angle degrees.

Response:
def rotate(x, y, x0, y0, angle):
    """ Returns the coordinates of (x,y) rotated around origin (x0,y0).
    """
    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)


Instruction:
Write a Python 3 function for
returning the reflection of a point through origin x y0.

Response:
def reflect(x, y, x0, y0, d=1.0, a=180):
    """ Returns the reflection of a point through origin (x0,y0).
    """
    return coordinates(x0, y0, d * distance(x0, y0, x, y),
                       a + angle(x0, y0, x, y))


Instruction:
Write a Python 3 script for
returning the linear interpolation between a and b for time t between 0. 0 - 1. 0.

Response:
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.
    """
    if t < 0.0:
        return a
    if t > 1.0:
        return b
    return a + (b - a) * t


Instruction:
Can you implement a function in Python 3 that
returns a smooth transition between 0. 0 and 1. 0 using Hermite interpolation.

Response:
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.
    """
    if x < a:
        return 0.0
    if x >= b:
        return 1.0
    x = float(x - a) / (b - a)
    return x * x * (3 - 2 * x)


Instruction:
Make a summary of the following Python 3 code
def line_line_intersection(x1, y1, x2, y2, x3, y3, x4, y4, infinite=False):
    # 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))]

Response: Determines the intersection point of two lines or two finite line segments.


Instruction:
Can you tell what is the following Python 3 function doing
def circle_line_intersection(cx, cy, radius, x1, y1, x2, y2, infinite=False):
    # 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

Response: Returns a list of points where the circle and the line intersect.


Instruction:
Write a Python 3 script for
returning True if the point is inside the polygon.

Response:
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.
    """
    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


Instruction:
Can you implement a function in Python 3 that
returns the 3x3 matrix multiplication of A and B.

Response:
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.
        """
        # No need to optimize (C version is just as fast).
        return [
            a[0] * b[0] + a[1] * b[3],
            a[0] * b[1] + a[1] * b[4],
            0,
            a[3] * b[0] + a[4] * b[3],
            a[3] * b[1] + a[4] * b[4],
            0,
            a[6] * b[0] + a[7] * b[3] + b[6],
            a[6] * b[1] + a[7] * b[4] + b[7],
            1
        ]


Instruction:
Can you create a Python 3 function that
inverts the matrix by its inverse produces the identity matrix.

Response:
def invert(self):
        """ Multiplying a matrix by its inverse produces the identity matrix.
        """
        m = self.matrix
        d = m[0] * m[4] - m[1] * m[3]
        self.matrix = [
             m[4] / d, -m[1] / d, 0,
             -m[3] / d,  m[0] / d, 0,
             (m[3] * m[7] - m[4] * m[6]) / d,
             -(m[0] * m[7] - m[1] * m[6]) / d,
             1
        ]


Instruction:
Create a Python 3 function for
returning the new coordinates of x y after transformation.

Response:
def transform_point(self, x, y):
        """ Returns the new coordinates of (x,y) after transformation.
        """
        m = self.matrix
        return (x*m[0]+y*m[3]+m[6], x*m[1]+y*m[4]+m[7])


Instruction:
Can you generate the documentation for the following Python 3 function
def transform_path(self, path):
        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

Response: Returns a new BezierPath object with the transformation applied.


Instruction:
Can you create a Python 3 function that
returns True if a part of the two bounds overlaps.

Response:
def intersects(self, b):
        """ Return True if a part of the two bounds overlaps.
        """
        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)


Instruction:
Make a summary of the following Python 3 code
def intersection(self, b):
        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)

Response: Returns a new bounds that encompasses the intersection of the two sets.


Instruction:
Explain what the following Python 3 code does
def union(self, b):
        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)

Response: Returns a new bounds that encompasses the union of the two locations.


Instruction:
Can you tell what is the following Python 3 function doing
def contains(self, *a):
        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

Response: Returns True if the given point or rectangle falls within the bounds.


Instruction:
Create a Python 3 function to
print an error message the help message and quits

Response:
def error(message):
    '''Prints an error message, the help message and quits'''
    global parser
    print (_("Error: ") + message)
    print ()
    parser.print_help()
    sys.exit()


Instruction:
Can you tell what is the following Python 3 function doing
def ellipse(self, x, y, width, height, draw=True, **kwargs):
        '''Draws an ellipse starting from (x,y)'''
        path = self.BezierPath(**kwargs)
        path.ellipse(x,y,width,height)
        if draw:
            path.draw()
        return path

Response: Draws an ellipse starting from x y width height


Instruction:
Create a Python 3 function for
drawing a line from x1 y1 to x2 y2

Response:
def line(self, x1, y1, x2, y2, draw=True):
        '''Draws a line from (x1,y1) to (x2,y2)'''
        p = self._path
        self.newpath()
        self.moveto(x1,y1)
        self.lineto(x2,y2)
        self.endpath(draw=draw)
        self._path = p
        return p


Instruction:
Implement a function in Python 3 to
set the current colormode and eventually the current color range.

Response:
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.
        '''
        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


Instruction:
Given the following Python 3 function, write the documentation
def fill(self,*args):
        '''Sets a fill color, applying it to new paths.'''
        self._fillcolor = self.color(*args)
        return self._fillcolor

Response: Sets a fill color applying it to new paths.


Instruction:
Can you generate the documentation for the following Python 3 function
def stroke(self,*args):
        '''Set a stroke color, applying it to new paths.'''
        self._strokecolor = self.color(*args)
        return self._strokecolor

Response: Set a stroke color applying it to new paths.


Instruction:
Write a Python 3 function that can
draw an outlined path of the input text.

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


Instruction:
How would you implement a function in Python 3 that
returns the width and height of a string of text as a tuple

Response:
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).
        '''
        # 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


Instruction:
Can you write a function in Python 3 where it
draws a flat LINETO segment with the given parameters.

Response:
def draw_cornu_flat(x0, y0, t0, t1, s0, c0, flip, cs, ss, cmd):

    """ Raph Levien's code draws fast LINETO segments.
    """

    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


Instruction:
Can you generate the documentation for the following Python 3 function
def draw_cornu_bezier(x0, y0, t0, t1, s0, c0, flip, cs, ss, cmd, scale, rot):

    """ Mark Meyer's code draws elegant CURVETO segments.
    """

    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

Response: Draw elegant CURVETO segments.


Instruction:
Implement a Python 3 function for
returning a YahooSearch list object formatted as a YahooSearch list object.

Response:
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.
    """

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


Instruction:
Create a Python 3 function to
return a YahooSearch list object formatted as a YahooSearch list object.

Response:
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.
    """

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


Instruction:
How would you code a function in Python 3 to
return a YahooSearch list object formatted as a YahooSearch list object.

Response:
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.
    """

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


Instruction:
Given the following Python 3 function, write the documentation
def suggest_spelling(q, wait=10, asynchronous=False, cached=False):

    """ Returns list of suggested spelling corrections for the given query.
    """

    return YahooSpelling(q, wait, asynchronous, cached)

Response: Returns a list of suggested spelling corrections for the given query.


Instruction:
Can you generate a brief explanation for the following Python 3 code
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.

    """

    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

Response: Perform a Yahoo sort on the given list of words.


Instruction:
Make a summary of the following Python 3 code
def _parse(self, e, tag):

        """ Parses the text data from an XML element defined by tag.
        """

        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

Response: Parses the text data from an XML element defined by tag.


Instruction:
Given the following Python 3 function, write the documentation
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.

        """

        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

Response: Creates a new layer from file Layer Image. Image object or Image. Image object.


Instruction:
Can you generate the documentation for the following Python 3 function
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.

        """

        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)

Response: Fill the image with the given rgb color.


Instruction:
Can you implement a function in Python 3 that
creates a gradient layer.

Response:
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.

        """

        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="")


Instruction:
How would you explain what the following Python 3 function does
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.

        """

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

Response: Merges the given list of layers into the current list.


Instruction:
Explain what the following Python 3 code does
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).

        """

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

Response: Flattens all layers according to their blend modes and opacity defined for each layer.


Instruction:
Write a Python 3 script for
exporting the flattened canvas to a file.

Response:
def export(self, filename):

        """Exports the flattened canvas.

        Flattens the canvas.
        PNG retains the alpha channel information.
        Other possibilities are JPEG and GIF.

        """

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


Instruction:
Can you write a function in Python 3 where it
places the flattened canvas in a temporary PNG file.

Response:
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.

        """

        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


Instruction:
Can you create a Python 3 function that
returns the index of this layer in the canvas. layers list or None when not found.

Response:
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.

        """

        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


Instruction:
Write a Python 3 script to
return a copy of the layer.

Response:
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.

        """

        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


Instruction:
Can you implement a function in Python 3 that
removes this layer from the canvas.

Response:
def delete(self):

        """Removes this layer from the canvas.

        """

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


Instruction:
Can you generate the documentation for the following Python 3 function
def up(self):

        """Moves the layer up in the stacking order.

        """

        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)

Response: Moves the layer up in the stacking order.


Instruction:
Make a summary of the following Python 3 code
def down(self):

        """Moves the layer down in the stacking order.

        """

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

Response: Moves the layer down in the stacking order.


Instruction:
How would you explain what the following Python 3 function does
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.

        """

        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)

Response: Applies the polygonal lasso tool on a layer.


Instruction:
Can you generate the documentation for the following Python 3 function
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.

        """

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

Response: Masks the current layer below with this layer.


Instruction:
Explain what the following Python 3 code does
def duplicate(self):

        """Creates a copy of the current layer.

        This copy becomes the top layer on the canvas.

        """

        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

Response: Creates a copy of the current layer.


Instruction:
Given the following Python 3 function, write the documentation
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%.

        """

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

Response: Increases or decreases the brightness in the layer.


Instruction:
Here you have a function in Python 3, explain what it does
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%.

        """

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

Response: Increases or decreases the contrast in the layer.


Instruction:
Given the following Python 3 function, write the documentation
def desaturate(self):

        """Desaturates the layer, making it grayscale.

        Instantly removes all color information from the layer,
        while maintaing its alpha channel.

        """

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

Response: Desaturates the layer making it grayscale.


Instruction:
How would you code a function in Python 3 to
position the layer at the given coordinates.

Response:
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.

        """

        self.x = x
        self.y = y


Instruction:
Can you tell what is the following Python 3 function doing
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.

        """

        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

Response: Resizes the layer to the given width and height.


Instruction:
Write a Python 3 function that can
distort the image by translating the four corners of the layer to the given coordinates.

Response:
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).

        """

        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)


Instruction:
Can you implement a function in Python 3 that
rotates the image by given angle.

Response:
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.

        """

        #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


Instruction:
Can you tell what is the following Python 3 function doing
def flip(self, axis=HORIZONTAL):

        """Flips the layer, either HORIZONTAL or VERTICAL.

        """

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

Response: Flips the layer either HORIZONTAL or VERTICAL.


Instruction:
Here you have a function in Python 3, explain what it does
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%.

        """

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

Response: Increases or decreases the sharpness in the layer.


Instruction:
Here you have a function in Python 3, explain what it does
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.

        """

        h = self.img.histogram()
        r = h[0:255]
        g = h[256:511]
        b = h[512:767]
        a = h[768:1024]

        return r, g, b, a

Response: Returns a 4 - tuple of lists r g b and a count for each RGBA channel.


Instruction:
Explain what the following Python 3 code does
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.

        """

        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

Response: Applies the overlay blend mode on image img1 and img2.


Instruction:
Can you tell what is the following Python 3 function doing
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.

        """

        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

Response: Applies the hue blend mode.


Instruction:
How would you explain what the following Python 3 function does
def _load_namespace(self, namespace, filename=None):
        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

Response: Load bot namespace with info in shoebot. data


Instruction:
How would you implement a function in Python 3 that
returns True if bot should quit

Response:
def _should_run(self, iteration, max_iterations):
        ''' Return False if bot should quit '''
        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


Instruction:
Create a Python 3 function to
limit to framerate for the current time.

Response:
def _frame_limit(self, start_time):
        """
        Limit to framerate, should be called after
        rendering has completed

        :param start_time: When execution started
        """
        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)


Instruction:
How would you code a function in Python 3 to
run a single frame of the bot.

Response:
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)
        """
        #
        # 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


Instruction:
Can you implement a function in Python 3 that
runs a single nodebox script in current surface s context.

Response:
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.
        '''
        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


Instruction:
How would you code a function in Python 3 to
set a new accessible variable.

Response:
def _addvar(self, v):
        ''' Sets a new accessible variable.

        :param v: Variable.
        '''
        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


Instruction:
Can you implement a function in Python 3 that
receives a colour definition and returns a tuple.

Response:
def parse_color(v, color_range=1):
    '''Receives a colour definition and returns a (r,g,b,a) tuple.

    Accepts:
    - v
    - (v)
    - (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).
    '''

    # 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


Instruction:
Create a Python 3 function for
converting a hex color string to RGB values.

Response:
def hex_to_rgb(hex):
    """ Returns RGB values for a hex color string.
    """
    hex = hex.lstrip("#")
    if len(hex) < 6:
        hex += hex[-1] * (6 - len(hex))
    if len(hex) == 6:
        r, g, b = hex[0:2], hex[2:4], hex[4:]
        r, g, b = [int(n, 16) / 255.0 for n in (r, g, b)]
        a = 1.0
    elif len(hex) == 8:
        r, g, b, a = hex[0:2], hex[2:4], hex[4:6], hex[6:]
        r, g, b, a = [int(n, 16) / 255.0 for n in (r, g, b, a)]
    return r, g, b, a


Instruction:
Implement a Python 3 function for
converting from CMYK color to RGB.

Response:
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.
    """

    r = 1.0 - min(1.0, c + k)
    g = 1.0 - min(1.0, m + k)
    b = 1.0 - min(1.0, y + k)

    return r, g, b


Instruction:
Can you generate the documentation for the following Python 3 function
def hsv_to_rgb(h, s, v):

    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

Response: Hue saturation brightness to red green blue.


Instruction:
Can you implement a function in Python 3 that
formats traceback showing line number and surrounding source.

Response:
def simple_traceback(ex, source):
    """
    Format traceback, showing line number and surrounding source.
    """
    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)


Instruction:
Can you tell what is the following Python 3 function doing
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].

        """

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

Response:
Generic database.
                Opens the SQLite database with the given name.


Instruction:
Can you implement a function in Python 3 that
creates an SQLite database file with the given name.

Response:
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.

        """

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


Instruction:
Write a Python 3 script to
create a new table with the given name containing the list of fields.

Response:
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.

        """

        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)


Instruction:
How would you explain what the following Python 3 function does
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.

        """

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

Response: Creates an index on the given table field with unique values enforced or not ascending or descending order.


Instruction:
Here you have a function in Python 3, explain what it does
def close(self):

        """Commits any pending transactions and closes the database.
        """

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

Response: Commits any pending transactions and closes the database.


Instruction:
How would you implement a function in Python 3 that
executes a raw SQL statement on the database and returns a list of the records that were found in the database.

Response:
def sql(self, sql):

        """ Executes a raw SQL statement on the database.
        """

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


Instruction:
Can you tell what is the following Python 3 function doing
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.

        """

        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

Response: A simple SQL SELECT query.


Instruction:
How would you explain what the following Python 3 function does
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.

        """

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

Response: Adds a new row to the given table.


Instruction:
How would you explain what the following Python 3 function does
def edit(self, id, *args, **kw):

        """ Edits the row with given id.
        """

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

Response: Edits the row with given id.


Instruction:
How would you explain what the following Python 3 function does
def remove(self, id, operator="=", key=None):

        """ Deletes the row with given id.
        """

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

Response: Deletes the row with given id.


Instruction:
Write a Python 3 script for
getting the next available event or None

Response:
def next_event(block=False, timeout=None):
    """
    Get the next available event or None

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


Instruction:
Can you tell what is the following Python 3 function doing
def publish_event(event_t, data=None, extra_channels=None, wait=None):
    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)

Response: Publish an event to any subscribers.


Instruction:
How would you implement a function in Python 3 that
sets the mode of the call transform.

Response:
def _set_mode(self, mode):
        '''
        Sets call_transform_mode to point to the
        center_transform or corner_transform
        '''
        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')


Instruction:
Implement a function in Python 3 to
return a matrix that transforms the image from the center to the given transform.

Response:
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
        '''
        dx, dy = self._get_center()
        t = cairo.Matrix()
        t.translate(dx, dy)
        t = transform * t
        t.translate(-dx, -dy)
        return t


Instruction:
Here you have a function in Python 3, explain what it does
def inheritFromContext(self, ignore=()):
        for canvas_attr, grob_attr in STATES.items():
            if canvas_attr in ignore:
                continue
            setattr(self, grob_attr, getattr(self._bot._canvas, canvas_attr))

Response: Inherit from the current context.


Instruction:
Can you implement a function in Python 3 that
loads the source code into the execution environment and call the bad_cb function if the source is not None.

Response:
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.
        """
        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


Instruction:
Can you create a Python 3 function that
reloads functions in namespace with functions from edited_source.

Response:
def reload_functions(self):
        """
        Replace functions in namespace with functions from edited_source.
        """
        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__


Instruction:
Create a Python 3 function for
running the tenuous command.

Response:
def run_tenuous(self):
        """
        Run edited source, if no exceptions occur then it
        graduates to known good.
        """
        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


Instruction:
Write a Python 3 function for
running the current process.

Response:
def run(self):
        """
        Attempt to known good or tenuous source.
        """
        with LiveExecution.lock:
            if self.edited_source:
                success, ex = self.run_tenuous()
                if success:
                    return

            self.do_exec(self.known_good, self.ns)


Instruction:
Given the following Python 3 function, write the documentation
def call_bad_cb(self, tb):
        with LiveExecution.lock:
            if self.bad_cb and not self.bad_cb(tb):
                self.bad_cb = None

Response:
keep it
            if bad_cb returns True


Instruction:
Write a Python 3 function for
calling the good_cb function if it returns True then keep it

Response:
def call_good_cb(self):
        """
        If good_cb returns True then keep it
        :return:
        """
        with LiveExecution.lock:
            if self.good_cb and not self.good_cb():
                self.good_cb = None


Instruction:
Explain what the following Python 3 code does
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").

        """

        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

Response: Returns the cohesion of the current object.