neulab/docprompting-conala huggingface dataset:
class tuple([iterable])  
Tuples may be constructed in a number of ways:  Using a pair of parentheses to denote the empty tuple: ()
 Using a trailing comma for a singleton tuple: a, or (a,)
 Separating items with commas: a, b, c or (a, b, c)
 Using the tuple() built-in: tuple() or tuple(iterable)
  The constructor builds a tuple whose items are the same and in the same order as iterable’s items. iterable may be either a sequence, a container that supports iteration, or an iterator object. If iterable is already a tuple, it is returned unchanged. For example, tuple('abc') returns ('a', 'b', 'c') and tuple( [1, 2, 3] ) returns (1, 2, 3). If no argument is given, the constructor creates a new empty tuple, (). Note that it is actually the comma which makes a tuple, not the parentheses. The parentheses are optional, except in the empty tuple case, or when they are needed to avoid syntactic ambiguity. For example, f(a, b, c) is a function call with three arguments, while f((a, b, c)) is a function call with a 3-tuple as the sole argument. Tuples implement all of the common sequence operations.
class tuple([iterable])  
Rather than being a function, tuple is actually an immutable sequence type, as documented in Tuples and Sequence Types — list, tuple, range.
turtle.register_shape(name, shape=None)  
turtle.addshape(name, shape=None)  
There are three different ways to call this function:  
name is the name of a gif-file and shape is None: Install the corresponding image shape. >>> screen.register_shape("turtle.gif")
  Note Image shapes do not rotate when turning the turtle, so they do not display the heading of the turtle!   
name is an arbitrary string and shape is a tuple of pairs of coordinates: Install the corresponding polygon shape. >>> screen.register_shape("triangle", ((5,-3), (0,5), (-5,-3)))
  
name is an arbitrary string and shape is a (compound) Shape object: Install the corresponding compound shape.  Add a turtle shape to TurtleScreen’s shapelist. Only thusly registered shapes can be used by issuing the command shape(shapename).
turtle.back(distance)  
turtle.bk(distance)  
turtle.backward(distance)  
 Parameters 
distance – a number   Move the turtle backward by distance, opposite to the direction the turtle is headed. Do not change the turtle’s heading. >>> turtle.position()
(0.00,0.00)
>>> turtle.backward(30)
>>> turtle.position()
(-30.00,0.00)
turtle.begin_poly()  
Start recording the vertices of a polygon. Current turtle position is first vertex of polygon.
turtle.bgcolor(*args)  
 Parameters 
args – a color string or three numbers in the range 0..colormode or a 3-tuple of such numbers   Set or return background color of the TurtleScreen. >>> screen.bgcolor("orange")
>>> screen.bgcolor()
'orange'
>>> screen.bgcolor("#800080")
>>> screen.bgcolor()
(128.0, 0.0, 128.0)
turtle.bgpic(picname=None)  
 Parameters 
picname – a string, name of a gif-file or "nopic", or None   Set background image or return name of current backgroundimage. If picname is a filename, set the corresponding image as background. If picname is "nopic", delete background image, if present. If picname is None, return the filename of the current backgroundimage. >>> screen.bgpic()
'nopic'
>>> screen.bgpic("landscape.gif")
>>> screen.bgpic()
"landscape.gif"
turtle.circle(radius, extent=None, steps=None)  
 Parameters 
 
radius – a number 
extent – a number (or None) 
steps – an integer (or None)    Draw a circle with given radius. The center is radius units left of the turtle; extent – an angle – determines which part of the circle is drawn. If extent is not given, draw the entire circle. If extent is not a full circle, one endpoint of the arc is the current pen position. Draw the arc in counterclockwise direction if radius is positive, otherwise in clockwise direction. Finally the direction of the turtle is changed by the amount of extent. As the circle is approximated by an inscribed regular polygon, steps determines the number of steps to use. If not given, it will be calculated automatically. May be used to draw regular polygons. >>> turtle.home()
>>> turtle.position()
(0.00,0.00)
>>> turtle.heading()
0.0
>>> turtle.circle(50)
>>> turtle.position()
(-0.00,0.00)
>>> turtle.heading()
0.0
>>> turtle.circle(120, 180)  # draw a semicircle
>>> turtle.position()
(0.00,240.00)
>>> turtle.heading()
180.0
turtle.clear()  
turtle.clearscreen()  
Delete all drawings and all turtles from the TurtleScreen. Reset the now empty TurtleScreen to its initial state: white background, no background image, no event bindings and tracing on.  Note This TurtleScreen method is available as a global function only under the name clearscreen. The global function clear is a different one derived from the Turtle method clear.
turtle.clearstamp(stampid)  
 Parameters 
stampid – an integer, must be return value of previous stamp() call   Delete stamp with given stampid. >>> turtle.position()
(150.00,-0.00)
>>> turtle.color("blue")
>>> astamp = turtle.stamp()
>>> turtle.fd(50)
>>> turtle.position()
(200.00,-0.00)
>>> turtle.clearstamp(astamp)
>>> turtle.position()
(200.00,-0.00)
turtle.clearstamps(n=None)  
 Parameters 
n – an integer (or None)   Delete all or first/last n of turtle’s stamps. If n is None, delete all stamps, if n > 0 delete first n stamps, else if n < 0 delete last n stamps. >>> for i in range(8):
...     turtle.stamp(); turtle.fd(30)
13
14
15
16
17
18
19
20
>>> turtle.clearstamps(2)
>>> turtle.clearstamps(-2)
>>> turtle.clearstamps()
turtle.clone()  
Create and return a clone of the turtle with same position, heading and turtle properties. >>> mick = Turtle()
>>> joe = mick.clone()
turtle.color(*args)  
Return or set pencolor and fillcolor. Several input formats are allowed. They use 0 to 3 arguments as follows:  
color() 

Return the current pencolor and the current fillcolor as a pair of color specification strings or tuples as returned by pencolor() and fillcolor().  
color(colorstring), color((r,g,b)), color(r,g,b) 

Inputs as in pencolor(), set both, fillcolor and pencolor, to the given value.  
color(colorstring1, colorstring2), color((r1,g1,b1), (r2,g2,b2)) 

Equivalent to pencolor(colorstring1) and fillcolor(colorstring2) and analogously if the other input format is used.   If turtleshape is a polygon, outline and interior of that polygon is drawn with the newly set colors.  >>> turtle.color("red", "green")
 >>> turtle.color()
 ('red', 'green')
 >>> color("#285078", "#a0c8f0")
 >>> color()
 ((40.0, 80.0, 120.0), (160.0, 200.0, 240.0))
turtle.colormode(cmode=None)  
 Parameters 
cmode – one of the values 1.0 or 255   Return the colormode or set it to 1.0 or 255. Subsequently r, g, b values of color triples have to be in the range 0..cmode. >>> screen.colormode(1)
>>> turtle.pencolor(240, 160, 80)
Traceback (most recent call last):
     ...
TurtleGraphicsError: bad color sequence: (240, 160, 80)
>>> screen.colormode()
1.0
>>> screen.colormode(255)
>>> screen.colormode()
255
>>> turtle.pencolor(240,160,80)
turtle.degrees(fullcircle=360.0)  
 Parameters 
fullcircle – a number   Set angle measurement units, i.e. set number of “degrees” for a full circle. Default value is 360 degrees. >>> turtle.home()
>>> turtle.left(90)
>>> turtle.heading()
90.0

Change angle measurement unit to grad (also known as gon,
grade, or gradian and equals 1/100-th of the right angle.)
>>> turtle.degrees(400.0)
>>> turtle.heading()
100.0
>>> turtle.degrees(360)
>>> turtle.heading()
90.0
turtle.delay(delay=None)  
 Parameters 
delay – positive integer   Set or return the drawing delay in milliseconds. (This is approximately the time interval between two consecutive canvas updates.) The longer the drawing delay, the slower the animation. Optional argument: >>> screen.delay()
10
>>> screen.delay(5)
>>> screen.delay()
5
turtle.distance(x, y=None)  
 Parameters 
 
x – a number or a pair/vector of numbers or a turtle instance 
y – a number if x is a number, else None
    Return the distance from the turtle to (x,y), the given vector, or the given other turtle, in turtle step units. >>> turtle.home()
>>> turtle.distance(30,40)
50.0
>>> turtle.distance((30,40))
50.0
>>> joe = Turtle()
>>> joe.forward(77)
>>> turtle.distance(joe)
77.0
turtle.mainloop()  
turtle.done()  
Starts event loop - calling Tkinter’s mainloop function. Must be the last statement in a turtle graphics program. Must not be used if a script is run from within IDLE in -n mode (No subprocess) - for interactive use of turtle graphics. >>> screen.mainloop()
turtle.dot(size=None, *color)  
 Parameters 
 
size – an integer >= 1 (if given) 
color – a colorstring or a numeric color tuple    Draw a circular dot with diameter size, using color. If size is not given, the maximum of pensize+4 and 2*pensize is used. >>> turtle.home()
>>> turtle.dot()
>>> turtle.fd(50); turtle.dot(20, "blue"); turtle.fd(50)
>>> turtle.position()
(100.00,-0.00)
>>> turtle.heading()
0.0
turtle.pendown()  
turtle.pd()  
turtle.down()  
Pull the pen down – drawing when moving.
turtle.end_fill()  
Fill the shape drawn after the last call to begin_fill(). Whether or not overlap regions for self-intersecting polygons or multiple shapes are filled depends on the operating system graphics, type of overlap, and number of overlaps. For example, the Turtle star above may be either all yellow or have some white regions. >>> turtle.color("black", "red")
>>> turtle.begin_fill()
>>> turtle.circle(80)
>>> turtle.end_fill()
turtle.end_poly()  
Stop recording the vertices of a polygon. Current turtle position is last vertex of polygon. This will be connected with the first vertex.
turtle.exitonclick()  
Bind bye() method to mouse clicks on the Screen. If the value “using_IDLE” in the configuration dictionary is False (default value), also enter mainloop. Remark: If IDLE with the -n switch (no subprocess) is used, this value should be set to True in turtle.cfg. In this case IDLE’s own mainloop is active also for the client script.
turtle.forward(distance)  
turtle.fd(distance)  
 Parameters 
distance – a number (integer or float)   Move the turtle forward by the specified distance, in the direction the turtle is headed. >>> turtle.position()
(0.00,0.00)
>>> turtle.forward(25)
>>> turtle.position()
(25.00,0.00)
>>> turtle.forward(-75)
>>> turtle.position()
(-50.00,0.00)
turtle.fillcolor(*args)  
Return or set the fillcolor. Four input formats are allowed:  
fillcolor() 

Return the current fillcolor as color specification string, possibly in tuple format (see example). May be used as input to another color/pencolor/fillcolor call.  
fillcolor(colorstring) 

Set fillcolor to colorstring, which is a Tk color specification string, such as "red", "yellow", or "#33cc8c".  
fillcolor((r, g, b)) 

Set fillcolor to the RGB color represented by the tuple of r, g, and b. Each of r, g, and b must be in the range 0..colormode, where colormode is either 1.0 or 255 (see colormode()).  
fillcolor(r, g, b) 

Set fillcolor to the RGB color represented by r, g, and b. Each of r, g, and b must be in the range 0..colormode.   If turtleshape is a polygon, the interior of that polygon is drawn with the newly set fillcolor.  >>> turtle.fillcolor("violet")
 >>> turtle.fillcolor()
 'violet'
 >>> turtle.pencolor()
 (50.0, 193.0, 143.0)
 >>> turtle.fillcolor((50, 193, 143))  # Integers, not floats
 >>> turtle.fillcolor()
 (50.0, 193.0, 143.0)
 >>> turtle.fillcolor('#ffffff')
 >>> turtle.fillcolor()
 (255.0, 255.0, 255.0)
turtle.filling()  
Return fillstate (True if filling, False else).  >>> turtle.begin_fill()
 >>> if turtle.filling():
 ...    turtle.pensize(5)
 ... else:
 ...    turtle.pensize(3)
turtle.getcanvas()  
Return the Canvas of this TurtleScreen. Useful for insiders who know what to do with a Tkinter Canvas. >>> cv = screen.getcanvas()
>>> cv
<turtle.ScrolledCanvas object ...>
turtle.getturtle()  
turtle.getpen()  
Return the Turtle object itself. Only reasonable use: as a function to return the “anonymous turtle”: >>> pet = getturtle()
>>> pet.fd(50)
>>> pet
<turtle.Turtle object at 0x...>
turtle.getscreen()  
Return the TurtleScreen object the turtle is drawing on. TurtleScreen methods can then be called for that object. >>> ts = turtle.getscreen()
>>> ts
<turtle._Screen object at 0x...>
>>> ts.bgcolor("pink")
turtle.getshapes()  
Return a list of names of all currently available turtle shapes. >>> screen.getshapes()
['arrow', 'blank', 'circle', ..., 'turtle']
turtle.get_poly()  
Return the last recorded polygon. >>> turtle.home()
>>> turtle.begin_poly()
>>> turtle.fd(100)
>>> turtle.left(20)
>>> turtle.fd(30)
>>> turtle.left(60)
>>> turtle.fd(50)
>>> turtle.end_poly()
>>> p = turtle.get_poly()
>>> register_shape("myFavouriteShape", p)
turtle.get_shapepoly()  
Return the current shape polygon as tuple of coordinate pairs. This can be used to define a new shape or components of a compound shape. >>> turtle.shape("square")
>>> turtle.shapetransform(4, -1, 0, 2)
>>> turtle.get_shapepoly()
((50, -20), (30, 20), (-50, 20), (-30, -20))
turtle.goto(x, y=None)  
turtle.setpos(x, y=None)  
turtle.setposition(x, y=None)  
 Parameters 
 
x – a number or a pair/vector of numbers 
y – a number or None
    If y is None, x must be a pair of coordinates or a Vec2D (e.g. as returned by pos()). Move turtle to an absolute position. If the pen is down, draw line. Do not change the turtle’s orientation.  >>> tp = turtle.pos()
 >>> tp
 (0.00,0.00)
 >>> turtle.setpos(60,30)
 >>> turtle.pos()
 (60.00,30.00)
 >>> turtle.setpos((20,80))
 >>> turtle.pos()
 (20.00,80.00)
 >>> turtle.setpos(tp)
 >>> turtle.pos()
 (0.00,0.00)
turtle.heading()  
Return the turtle’s current heading (value depends on the turtle mode, see mode()). >>> turtle.home()
>>> turtle.left(67)
>>> turtle.heading()
67.0
turtle.hideturtle()  
turtle.ht()  
Make the turtle invisible. It’s a good idea to do this while you’re in the middle of doing some complex drawing, because hiding the turtle speeds up the drawing observably. >>> turtle.hideturtle()
turtle.home()  
Move turtle to the origin – coordinates (0,0) – and set its heading to its start-orientation (which depends on the mode, see mode()). >>> turtle.heading()
90.0
>>> turtle.position()
(0.00,-10.00)
>>> turtle.home()
>>> turtle.position()
(0.00,0.00)
>>> turtle.heading()
0.0
turtle.isdown()  
Return True if pen is down, False if it’s up. >>> turtle.penup()
>>> turtle.isdown()
False
>>> turtle.pendown()
>>> turtle.isdown()
True
turtle.isvisible()  
Return True if the Turtle is shown, False if it’s hidden. >>> turtle.hideturtle()
>>> turtle.isvisible()
False
>>> turtle.showturtle()
>>> turtle.isvisible()
True
turtle.left(angle)  
turtle.lt(angle)  
 Parameters 
angle – a number (integer or float)   Turn turtle left by angle units. (Units are by default degrees, but can be set via the degrees() and radians() functions.) Angle orientation depends on the turtle mode, see mode(). >>> turtle.heading()
22.0
>>> turtle.left(45)
>>> turtle.heading()
67.0
turtle.listen(xdummy=None, ydummy=None)  
Set focus on TurtleScreen (in order to collect key-events). Dummy arguments are provided in order to be able to pass listen() to the onclick method.
turtle.mode(mode=None)  
 Parameters 
mode – one of the strings “standard”, “logo” or “world”   Set turtle mode (“standard”, “logo” or “world”) and perform reset. If mode is not given, current mode is returned. Mode “standard” is compatible with old turtle. Mode “logo” is compatible with most Logo turtle graphics. Mode “world” uses user-defined “world coordinates”. Attention: in this mode angles appear distorted if x/y unit-ratio doesn’t equal 1.   
Mode Initial turtle heading positive angles   
“standard” to the right (east) counterclockwise  
“logo” upward (north) clockwise   >>> mode("logo")   # resets turtle heading to north
>>> mode()
'logo'
turtle.numinput(title, prompt, default=None, minval=None, maxval=None)  
 Parameters 
 
title – string 
prompt – string 
default – number (optional) 
minval – number (optional) 
maxval – number (optional)    Pop up a dialog window for input of a number. title is the title of the dialog window, prompt is a text mostly describing what numerical information to input. default: default value, minval: minimum value for input, maxval: maximum value for input The number input must be in the range minval .. maxval if these are given. If not, a hint is issued and the dialog remains open for correction. Return the number input. If the dialog is canceled, return None. >>> screen.numinput("Poker", "Your stakes:", 1000, minval=10, maxval=10000)
turtle.onclick(fun, btn=1, add=None)  
turtle.onscreenclick(fun, btn=1, add=None)  
 Parameters 
 
fun – a function with two arguments which will be called with the coordinates of the clicked point on the canvas 
btn – number of the mouse-button, defaults to 1 (left mouse button) 
add – True or False – if True, a new binding will be added, otherwise it will replace a former binding    Bind fun to mouse-click events on this screen. If fun is None, existing bindings are removed. Example for a TurtleScreen instance named screen and a Turtle instance named turtle: >>> screen.onclick(turtle.goto) # Subsequently clicking into the TurtleScreen will
>>>                             # make the turtle move to the clicked point.
>>> screen.onclick(None)        # remove event binding again
  Note This TurtleScreen method is available as a global function only under the name onscreenclick. The global function onclick is another one derived from the Turtle method onclick.
turtle.ondrag(fun, btn=1, add=None)  
 Parameters 
 
fun – a function with two arguments which will be called with the coordinates of the clicked point on the canvas 
btn – number of the mouse-button, defaults to 1 (left mouse button) 
add – True or False – if True, a new binding will be added, otherwise it will replace a former binding    Bind fun to mouse-move events on this turtle. If fun is None, existing bindings are removed. Remark: Every sequence of mouse-move-events on a turtle is preceded by a mouse-click event on that turtle. >>> turtle.ondrag(turtle.goto)
 Subsequently, clicking and dragging the Turtle will move it across the screen thereby producing handdrawings (if pen is down).
turtle.onkey(fun, key)  
turtle.onkeyrelease(fun, key)  
 Parameters 
 
fun – a function with no arguments or None
 
key – a string: key (e.g. “a”) or key-symbol (e.g. “space”)    Bind fun to key-release event of key. If fun is None, event bindings are removed. Remark: in order to be able to register key-events, TurtleScreen must have the focus. (See method listen().) >>> def f():
...     fd(50)
...     lt(60)
...
>>> screen.onkey(f, "Up")
>>> screen.listen()
turtle.onkeypress(fun, key=None)  
 Parameters 
 
fun – a function with no arguments or None
 
key – a string: key (e.g. “a”) or key-symbol (e.g. “space”)    Bind fun to key-press event of key if key is given, or to any key-press-event if no key is given. Remark: in order to be able to register key-events, TurtleScreen must have focus. (See method listen().) >>> def f():
...     fd(50)
...
>>> screen.onkey(f, "Up")
>>> screen.listen()
turtle.onrelease(fun, btn=1, add=None)  
 Parameters 
 
fun – a function with two arguments which will be called with the coordinates of the clicked point on the canvas 
btn – number of the mouse-button, defaults to 1 (left mouse button) 
add – True or False – if True, a new binding will be added, otherwise it will replace a former binding    Bind fun to mouse-button-release events on this turtle. If fun is None, existing bindings are removed. >>> class MyTurtle(Turtle):
...     def glow(self,x,y):
...         self.fillcolor("red")
...     def unglow(self,x,y):
...         self.fillcolor("")
...
>>> turtle = MyTurtle()
>>> turtle.onclick(turtle.glow)     # clicking on turtle turns fillcolor red,
>>> turtle.onrelease(turtle.unglow) # releasing turns it to transparent.
turtle.ontimer(fun, t=0)  
 Parameters 
 
fun – a function with no arguments 
t – a number >= 0    Install a timer that calls fun after t milliseconds. >>> running = True
>>> def f():
...     if running:
...         fd(50)
...         lt(60)
...         screen.ontimer(f, 250)
>>> f()   ### makes the turtle march around
>>> running = False
turtle.pen(pen=None, **pendict)  
 Parameters 
 
pen – a dictionary with some or all of the below listed keys 
pendict – one or more keyword-arguments with the below listed keys as keywords    Return or set the pen’s attributes in a “pen-dictionary” with the following key/value pairs:  “shown”: True/False “pendown”: True/False “pencolor”: color-string or color-tuple “fillcolor”: color-string or color-tuple “pensize”: positive number “speed”: number in range 0..10 “resizemode”: “auto” or “user” or “noresize” “stretchfactor”: (positive number, positive number) “outline”: positive number “tilt”: number  This dictionary can be used as argument for a subsequent call to pen() to restore the former pen-state. Moreover one or more of these attributes can be provided as keyword-arguments. This can be used to set several pen attributes in one statement. >>> turtle.pen(fillcolor="black", pencolor="red", pensize=10)
>>> sorted(turtle.pen().items())
[('fillcolor', 'black'), ('outline', 1), ('pencolor', 'red'),
 ('pendown', True), ('pensize', 10), ('resizemode', 'noresize'),
 ('shearfactor', 0.0), ('shown', True), ('speed', 9),
 ('stretchfactor', (1.0, 1.0)), ('tilt', 0.0)]
>>> penstate=turtle.pen()
>>> turtle.color("yellow", "")
>>> turtle.penup()
>>> sorted(turtle.pen().items())[:3]
[('fillcolor', ''), ('outline', 1), ('pencolor', 'yellow')]
>>> turtle.pen(penstate, fillcolor="green")
>>> sorted(turtle.pen().items())[:3]
[('fillcolor', 'green'), ('outline', 1), ('pencolor', 'red')]
turtle.pencolor(*args)  
Return or set the pencolor. Four input formats are allowed:  
pencolor() 

Return the current pencolor as color specification string or as a tuple (see example). May be used as input to another color/pencolor/fillcolor call.  
pencolor(colorstring) 

Set pencolor to colorstring, which is a Tk color specification string, such as "red", "yellow", or "#33cc8c".  
pencolor((r, g, b)) 

Set pencolor to the RGB color represented by the tuple of r, g, and b. Each of r, g, and b must be in the range 0..colormode, where colormode is either 1.0 or 255 (see colormode()).  
pencolor(r, g, b) 

Set pencolor to the RGB color represented by r, g, and b. Each of r, g, and b must be in the range 0..colormode.   If turtleshape is a polygon, the outline of that polygon is drawn with the newly set pencolor.  >>> colormode()
 1.0
 >>> turtle.pencolor()
 'red'
 >>> turtle.pencolor("brown")
 >>> turtle.pencolor()
 'brown'
 >>> tup = (0.2, 0.8, 0.55)
 >>> turtle.pencolor(tup)
 >>> turtle.pencolor()
 (0.2, 0.8, 0.5490196078431373)
 >>> colormode(255)
 >>> turtle.pencolor()
 (51.0, 204.0, 140.0)
 >>> turtle.pencolor('#32c18f')
 >>> turtle.pencolor()
 (50.0, 193.0, 143.0)
turtle.pensize(width=None)  
turtle.width(width=None)  
 Parameters 
width – a positive number   Set the line thickness to width or return it. If resizemode is set to “auto” and turtleshape is a polygon, that polygon is drawn with the same line thickness. If no argument is given, the current pensize is returned. >>> turtle.pensize()
1
>>> turtle.pensize(10)   # from here on lines of width 10 are drawn
turtle.penup()  
turtle.pu()  
turtle.up()  
Pull the pen up – no drawing when moving.
turtle.position()  
turtle.pos()  
Return the turtle’s current location (x,y) (as a Vec2D vector). >>> turtle.pos()
(440.00,-0.00)
turtle.radians()  
Set the angle measurement units to radians. Equivalent to degrees(2*math.pi). >>> turtle.home()
>>> turtle.left(90)
>>> turtle.heading()
90.0
>>> turtle.radians()
>>> turtle.heading()
1.5707963267948966
class turtle.RawTurtle(canvas)  
class turtle.RawPen(canvas)  
 Parameters 
canvas – a tkinter.Canvas, a ScrolledCanvas or a TurtleScreen   Create a turtle. The turtle has all methods described above as “methods of Turtle/RawTurtle”.
turtle.reset()  
turtle.resetscreen()  
Reset all Turtles on the Screen to their initial state.  Note This TurtleScreen method is available as a global function only under the name resetscreen. The global function reset is another one derived from the Turtle method reset.