com.googler.python 1.1.2 → 1.1.4

package/python3.6.2/lib/python3.6/turtledemo/sorting_animate.py

@@ -1,204 +0,0 @@
-#!/usr/bin/env python3
-"""
-
-         sorting_animation.py
-
-A minimal sorting algorithm animation:
-Sorts a shelf of 10 blocks using insertion
-sort, selection sort and quicksort.
-
-Shelfs are implemented using builtin lists.
-
-Blocks are turtles with shape "square", but
-stretched to rectangles by shapesize()
- ---------------------------------------
-       To exit press space button
- ---------------------------------------
-"""
-from turtle import *
-import random
-
-
-class Block(Turtle):
-
-    def __init__(self, size):
-        self.size = size
-        Turtle.__init__(self, shape="square", visible=False)
-        self.pu()
-        self.shapesize(size * 1.5, 1.5, 2) # square-->rectangle
-        self.fillcolor("black")
-        self.st()
-
-    def glow(self):
-        self.fillcolor("red")
-
-    def unglow(self):
-        self.fillcolor("black")
-
-    def __repr__(self):
-        return "Block size: {0}".format(self.size)
-
-
-class Shelf(list):
-
-    def __init__(self, y):
-        "create a shelf. y is y-position of first block"
-        self.y = y
-        self.x = -150
-
-    def push(self, d):
-        width, _, _ = d.shapesize()
-        # align blocks by the bottom edge
-        y_offset = width / 2 * 20
-        d.sety(self.y + y_offset)
-        d.setx(self.x + 34 * len(self))
-        self.append(d)
-
-    def _close_gap_from_i(self, i):
-        for b in self[i:]:
-            xpos, _ = b.pos()
-            b.setx(xpos - 34)
-
-    def _open_gap_from_i(self, i):
-        for b in self[i:]:
-            xpos, _ = b.pos()
-            b.setx(xpos + 34)
-
-    def pop(self, key):
-        b = list.pop(self, key)
-        b.glow()
-        b.sety(200)
-        self._close_gap_from_i(key)
-        return b
-
-    def insert(self, key, b):
-        self._open_gap_from_i(key)
-        list.insert(self, key, b)
-        b.setx(self.x + 34 * key)
-        width, _, _ = b.shapesize()
-        # align blocks by the bottom edge
-        y_offset = width / 2 * 20
-        b.sety(self.y + y_offset)
-        b.unglow()
-
-def isort(shelf):
-    length = len(shelf)
-    for i in range(1, length):
-        hole = i
-        while hole > 0 and shelf[i].size < shelf[hole - 1].size:
-            hole = hole - 1
-        shelf.insert(hole, shelf.pop(i))
-    return
-
-def ssort(shelf):
-    length = len(shelf)
-    for j in range(0, length - 1):
-        imin = j
-        for i in range(j + 1, length):
-            if shelf[i].size < shelf[imin].size:
-                imin = i
-        if imin != j:
-            shelf.insert(j, shelf.pop(imin))
-
-def partition(shelf, left, right, pivot_index):
-    pivot = shelf[pivot_index]
-    shelf.insert(right, shelf.pop(pivot_index))
-    store_index = left
-    for i in range(left, right): # range is non-inclusive of ending value
-        if shelf[i].size < pivot.size:
-            shelf.insert(store_index, shelf.pop(i))
-            store_index = store_index + 1
-    shelf.insert(store_index, shelf.pop(right)) # move pivot to correct position
-    return store_index
-
-def qsort(shelf, left, right):
-    if left < right:
-        pivot_index = left
-        pivot_new_index = partition(shelf, left, right, pivot_index)
-        qsort(shelf, left, pivot_new_index - 1)
-        qsort(shelf, pivot_new_index + 1, right)
-
-def randomize():
-    disable_keys()
-    clear()
-    target = list(range(10))
-    random.shuffle(target)
-    for i, t in enumerate(target):
-        for j in range(i, len(s)):
-            if s[j].size == t + 1:
-                s.insert(i, s.pop(j))
-    show_text(instructions1)
-    show_text(instructions2, line=1)
-    enable_keys()
-
-def show_text(text, line=0):
-    line = 20 * line
-    goto(0,-250 - line)
-    write(text, align="center", font=("Courier", 16, "bold"))
-
-def start_ssort():
-    disable_keys()
-    clear()
-    show_text("Selection Sort")
-    ssort(s)
-    clear()
-    show_text(instructions1)
-    show_text(instructions2, line=1)
-    enable_keys()
-
-def start_isort():
-    disable_keys()
-    clear()
-    show_text("Insertion Sort")
-    isort(s)
-    clear()
-    show_text(instructions1)
-    show_text(instructions2, line=1)
-    enable_keys()
-
-def start_qsort():
-    disable_keys()
-    clear()
-    show_text("Quicksort")
-    qsort(s, 0, len(s) - 1)
-    clear()
-    show_text(instructions1)
-    show_text(instructions2, line=1)
-    enable_keys()
-
-def init_shelf():
-    global s
-    s = Shelf(-200)
-    vals = (4, 2, 8, 9, 1, 5, 10, 3, 7, 6)
-    for i in vals:
-        s.push(Block(i))
-
-def disable_keys():
-    onkey(None, "s")
-    onkey(None, "i")
-    onkey(None, "q")
-    onkey(None, "r")
-
-def enable_keys():
-    onkey(start_isort, "i")
-    onkey(start_ssort, "s")
-    onkey(start_qsort, "q")
-    onkey(randomize, "r")
-    onkey(bye, "space")
-
-def main():
-    getscreen().clearscreen()
-    ht(); penup()
-    init_shelf()
-    show_text(instructions1)
-    show_text(instructions2, line=1)
-    enable_keys()
-    listen()
-    return "EVENTLOOP"
-
-instructions1 = "press i for insertion sort, s for selection sort, q for quicksort"
-instructions2 = "spacebar to quit, r to randomize"
-
-if __name__=="__main__":
-    msg = main()
-    mainloop()

package/python3.6.2/lib/python3.6/turtledemo/tree.py

@@ -1,63 +0,0 @@
-#!/usr/bin/env python3
-"""      turtle-example-suite:
-
-             tdemo_tree.py
-
-Displays a 'breadth-first-tree' - in contrast
-to the classical Logo tree drawing programs,
-which use a depth-first-algorithm.
-
-Uses:
-(1) a tree-generator, where the drawing is
-quasi the side-effect, whereas the generator
-always yields None.
-(2) Turtle-cloning: At each branching point
-the current pen is cloned. So in the end
-there are 1024 turtles.
-"""
-from turtle import Turtle, mainloop
-from time import clock
-
-def tree(plist, l, a, f):
-    """ plist is list of pens
-    l is length of branch
-    a is half of the angle between 2 branches
-    f is factor by which branch is shortened
-    from level to level."""
-    if l > 3:
-        lst = []
-        for p in plist:
-            p.forward(l)
-            q = p.clone()
-            p.left(a)
-            q.right(a)
-            lst.append(p)
-            lst.append(q)
-        for x in tree(lst, l*f, a, f):
-            yield None
-
-def maketree():
-    p = Turtle()
-    p.setundobuffer(None)
-    p.hideturtle()
-    p.speed(0)
-    p.getscreen().tracer(30,0)
-    p.left(90)
-    p.penup()
-    p.forward(-210)
-    p.pendown()
-    t = tree([p], 200, 65, 0.6375)
-    for x in t:
-        pass
-    print(len(p.getscreen().turtles()))
-
-def main():
-    a=clock()
-    maketree()
-    b=clock()
-    return "done: %.2f sec." % (b-a)
-
-if __name__ == "__main__":
-    msg = main()
-    print(msg)
-    mainloop()

package/python3.6.2/lib/python3.6/turtledemo/turtle.cfg

@@ -1,10 +0,0 @@
-width = 800
-height = 600
-canvwidth = 1200
-canvheight = 900
-shape = arrow
-mode = standard
-resizemode = auto
-fillcolor = ""
-title = Python turtle graphics demo.
-

package/python3.6.2/lib/python3.6/turtledemo/two_canvases.py

@@ -1,54 +0,0 @@
-"""turtledemo.two_canvases
-
-Use TurtleScreen and RawTurtle to draw on two
-distinct canvases in a separate windows. The
-new window must be separately closed in
-addition to pressing the STOP button.
-"""
-
-from turtle import TurtleScreen, RawTurtle, TK
-
-def main():
-    root = TK.Tk()
-    cv1 = TK.Canvas(root, width=300, height=200, bg="#ddffff")
-    cv2 = TK.Canvas(root, width=300, height=200, bg="#ffeeee")
-    cv1.pack()
-    cv2.pack()
-
-    s1 = TurtleScreen(cv1)
-    s1.bgcolor(0.85, 0.85, 1)
-    s2 = TurtleScreen(cv2)
-    s2.bgcolor(1, 0.85, 0.85)
-
-    p = RawTurtle(s1)
-    q = RawTurtle(s2)
-
-    p.color("red", (1, 0.85, 0.85))
-    p.width(3)
-    q.color("blue", (0.85, 0.85, 1))
-    q.width(3)
-
-    for t in p,q:
-        t.shape("turtle")
-        t.lt(36)
-
-    q.lt(180)
-
-    for t in p, q:
-        t.begin_fill()
-    for i in range(5):
-        for t in p, q:
-            t.fd(50)
-            t.lt(72)
-    for t in p,q:
-        t.end_fill()
-        t.lt(54)
-        t.pu()
-        t.bk(50)
-
-    return "EVENTLOOP"
-
-
-if __name__ == '__main__':
-    main()
-    TK.mainloop()  # keep window open until user closes it

package/python3.6.2/lib/python3.6/turtledemo/wikipedia.py

@@ -1,65 +0,0 @@
-"""      turtle-example-suite:
-
-          tdemo_wikipedia3.py
-
-This example is
-inspired by the Wikipedia article on turtle
-graphics. (See example wikipedia1 for URLs)
-
-First we create (ne-1) (i.e. 35 in this
-example) copies of our first turtle p.
-Then we let them perform their steps in
-parallel.
-
-Followed by a complete undo().
-"""
-from turtle import Screen, Turtle, mainloop
-from time import clock, sleep
-
-def mn_eck(p, ne,sz):
-    turtlelist = [p]
-    #create ne-1 additional turtles
-    for i in range(1,ne):
-        q = p.clone()
-        q.rt(360.0/ne)
-        turtlelist.append(q)
-        p = q
-    for i in range(ne):
-        c = abs(ne/2.0-i)/(ne*.7)
-        # let those ne turtles make a step
-        # in parallel:
-        for t in turtlelist:
-            t.rt(360./ne)
-            t.pencolor(1-c,0,c)
-            t.fd(sz)
-
-def main():
-    s = Screen()
-    s.bgcolor("black")
-    p=Turtle()
-    p.speed(0)
-    p.hideturtle()
-    p.pencolor("red")
-    p.pensize(3)
-
-    s.tracer(36,0)
-
-    at = clock()
-    mn_eck(p, 36, 19)
-    et = clock()
-    z1 = et-at
-
-    sleep(1)
-
-    at = clock()
-    while any([t.undobufferentries() for t in s.turtles()]):
-        for t in s.turtles():
-            t.undo()
-    et = clock()
-    return "runtime: %.3f sec" % (z1+et-at)
-
-
-if __name__ == '__main__':
-    msg = main()
-    print(msg)
-    mainloop()

package/python3.6.2/lib/python3.6/turtledemo/yinyang.py

@@ -1,49 +0,0 @@
-#!/usr/bin/env python3
-"""       turtle-example-suite:
-
-            tdemo_yinyang.py
-
-Another drawing suitable as a beginner's
-programming example.
-
-The small circles are drawn by the circle
-command.
-
-"""
-
-from turtle import *
-
-def yin(radius, color1, color2):
-    width(3)
-    color("black", color1)
-    begin_fill()
-    circle(radius/2., 180)
-    circle(radius, 180)
-    left(180)
-    circle(-radius/2., 180)
-    end_fill()
-    left(90)
-    up()
-    forward(radius*0.35)
-    right(90)
-    down()
-    color(color1, color2)
-    begin_fill()
-    circle(radius*0.15)
-    end_fill()
-    left(90)
-    up()
-    backward(radius*0.35)
-    down()
-    left(90)
-
-def main():
-    reset()
-    yin(200, "black", "white")
-    yin(200, "white", "black")
-    ht()
-    return "Done!"
-
-if __name__ == '__main__':
-    main()
-    mainloop()

package/python3.6.2/lib/python3.6/types.py

@@ -1,266 +0,0 @@
-"""
-Define names for built-in types that aren't directly accessible as a builtin.
-"""
-import sys
-
-# Iterators in Python aren't a matter of type but of protocol.  A large
-# and changing number of builtin types implement *some* flavor of
-# iterator.  Don't check the type!  Use hasattr to check for both
-# "__iter__" and "__next__" attributes instead.
-
-def _f(): pass
-FunctionType = type(_f)
-LambdaType = type(lambda: None)         # Same as FunctionType
-CodeType = type(_f.__code__)
-MappingProxyType = type(type.__dict__)
-SimpleNamespace = type(sys.implementation)
-
-def _g():
-    yield 1
-GeneratorType = type(_g())
-
-async def _c(): pass
-_c = _c()
-CoroutineType = type(_c)
-_c.close()  # Prevent ResourceWarning
-
-async def _ag():
-    yield
-_ag = _ag()
-AsyncGeneratorType = type(_ag)
-
-class _C:
-    def _m(self): pass
-MethodType = type(_C()._m)
-
-BuiltinFunctionType = type(len)
-BuiltinMethodType = type([].append)     # Same as BuiltinFunctionType
-
-ModuleType = type(sys)
-
-try:
-    raise TypeError
-except TypeError:
-    tb = sys.exc_info()[2]
-    TracebackType = type(tb)
-    FrameType = type(tb.tb_frame)
-    tb = None; del tb
-
-# For Jython, the following two types are identical
-GetSetDescriptorType = type(FunctionType.__code__)
-MemberDescriptorType = type(FunctionType.__globals__)
-
-del sys, _f, _g, _C, _c,                           # Not for export
-
-
-# Provide a PEP 3115 compliant mechanism for class creation
-def new_class(name, bases=(), kwds=None, exec_body=None):
-    """Create a class object dynamically using the appropriate metaclass."""
-    meta, ns, kwds = prepare_class(name, bases, kwds)
-    if exec_body is not None:
-        exec_body(ns)
-    return meta(name, bases, ns, **kwds)
-
-def prepare_class(name, bases=(), kwds=None):
-    """Call the __prepare__ method of the appropriate metaclass.
-
-    Returns (metaclass, namespace, kwds) as a 3-tuple
-
-    *metaclass* is the appropriate metaclass
-    *namespace* is the prepared class namespace
-    *kwds* is an updated copy of the passed in kwds argument with any
-    'metaclass' entry removed. If no kwds argument is passed in, this will
-    be an empty dict.
-    """
-    if kwds is None:
-        kwds = {}
-    else:
-        kwds = dict(kwds) # Don't alter the provided mapping
-    if 'metaclass' in kwds:
-        meta = kwds.pop('metaclass')
-    else:
-        if bases:
-            meta = type(bases[0])
-        else:
-            meta = type
-    if isinstance(meta, type):
-        # when meta is a type, we first determine the most-derived metaclass
-        # instead of invoking the initial candidate directly
-        meta = _calculate_meta(meta, bases)
-    if hasattr(meta, '__prepare__'):
-        ns = meta.__prepare__(name, bases, **kwds)
-    else:
-        ns = {}
-    return meta, ns, kwds
-
-def _calculate_meta(meta, bases):
-    """Calculate the most derived metaclass."""
-    winner = meta
-    for base in bases:
-        base_meta = type(base)
-        if issubclass(winner, base_meta):
-            continue
-        if issubclass(base_meta, winner):
-            winner = base_meta
-            continue
-        # else:
-        raise TypeError("metaclass conflict: "
-                        "the metaclass of a derived class "
-                        "must be a (non-strict) subclass "
-                        "of the metaclasses of all its bases")
-    return winner
-
-class DynamicClassAttribute:
-    """Route attribute access on a class to __getattr__.
-
-    This is a descriptor, used to define attributes that act differently when
-    accessed through an instance and through a class.  Instance access remains
-    normal, but access to an attribute through a class will be routed to the
-    class's __getattr__ method; this is done by raising AttributeError.
-
-    This allows one to have properties active on an instance, and have virtual
-    attributes on the class with the same name (see Enum for an example).
-
-    """
-    def __init__(self, fget=None, fset=None, fdel=None, doc=None):
-        self.fget = fget
-        self.fset = fset
-        self.fdel = fdel
-        # next two lines make DynamicClassAttribute act the same as property
-        self.__doc__ = doc or fget.__doc__
-        self.overwrite_doc = doc is None
-        # support for abstract methods
-        self.__isabstractmethod__ = bool(getattr(fget, '__isabstractmethod__', False))
-
-    def __get__(self, instance, ownerclass=None):
-        if instance is None:
-            if self.__isabstractmethod__:
-                return self
-            raise AttributeError()
-        elif self.fget is None:
-            raise AttributeError("unreadable attribute")
-        return self.fget(instance)
-
-    def __set__(self, instance, value):
-        if self.fset is None:
-            raise AttributeError("can't set attribute")
-        self.fset(instance, value)
-
-    def __delete__(self, instance):
-        if self.fdel is None:
-            raise AttributeError("can't delete attribute")
-        self.fdel(instance)
-
-    def getter(self, fget):
-        fdoc = fget.__doc__ if self.overwrite_doc else None
-        result = type(self)(fget, self.fset, self.fdel, fdoc or self.__doc__)
-        result.overwrite_doc = self.overwrite_doc
-        return result
-
-    def setter(self, fset):
-        result = type(self)(self.fget, fset, self.fdel, self.__doc__)
-        result.overwrite_doc = self.overwrite_doc
-        return result
-
-    def deleter(self, fdel):
-        result = type(self)(self.fget, self.fset, fdel, self.__doc__)
-        result.overwrite_doc = self.overwrite_doc
-        return result
-
-
-import functools as _functools
-import collections.abc as _collections_abc
-
-class _GeneratorWrapper:
-    # TODO: Implement this in C.
-    def __init__(self, gen):
-        self.__wrapped = gen
-        self.__isgen = gen.__class__ is GeneratorType
-        self.__name__ = getattr(gen, '__name__', None)
-        self.__qualname__ = getattr(gen, '__qualname__', None)
-    def send(self, val):
-        return self.__wrapped.send(val)
-    def throw(self, tp, *rest):
-        return self.__wrapped.throw(tp, *rest)
-    def close(self):
-        return self.__wrapped.close()
-    @property
-    def gi_code(self):
-        return self.__wrapped.gi_code
-    @property
-    def gi_frame(self):
-        return self.__wrapped.gi_frame
-    @property
-    def gi_running(self):
-        return self.__wrapped.gi_running
-    @property
-    def gi_yieldfrom(self):
-        return self.__wrapped.gi_yieldfrom
-    cr_code = gi_code
-    cr_frame = gi_frame
-    cr_running = gi_running
-    cr_await = gi_yieldfrom
-    def __next__(self):
-        return next(self.__wrapped)
-    def __iter__(self):
-        if self.__isgen:
-            return self.__wrapped
-        return self
-    __await__ = __iter__
-
-def coroutine(func):
-    """Convert regular generator function to a coroutine."""
-
-    if not callable(func):
-        raise TypeError('types.coroutine() expects a callable')
-
-    if (func.__class__ is FunctionType and
-        getattr(func, '__code__', None).__class__ is CodeType):
-
-        co_flags = func.__code__.co_flags
-
-        # Check if 'func' is a coroutine function.
-        # (0x180 == CO_COROUTINE | CO_ITERABLE_COROUTINE)
-        if co_flags & 0x180:
-            return func
-
-        # Check if 'func' is a generator function.
-        # (0x20 == CO_GENERATOR)
-        if co_flags & 0x20:
-            # TODO: Implement this in C.
-            co = func.__code__
-            func.__code__ = CodeType(
-                co.co_argcount, co.co_kwonlyargcount, co.co_nlocals,
-                co.co_stacksize,
-                co.co_flags | 0x100,  # 0x100 == CO_ITERABLE_COROUTINE
-                co.co_code,
-                co.co_consts, co.co_names, co.co_varnames, co.co_filename,
-                co.co_name, co.co_firstlineno, co.co_lnotab, co.co_freevars,
-                co.co_cellvars)
-            return func
-
-    # The following code is primarily to support functions that
-    # return generator-like objects (for instance generators
-    # compiled with Cython).
-
-    @_functools.wraps(func)
-    def wrapped(*args, **kwargs):
-        coro = func(*args, **kwargs)
-        if (coro.__class__ is CoroutineType or
-            coro.__class__ is GeneratorType and coro.gi_code.co_flags & 0x100):
-            # 'coro' is a native coroutine object or an iterable coroutine
-            return coro
-        if (isinstance(coro, _collections_abc.Generator) and
-            not isinstance(coro, _collections_abc.Coroutine)):
-            # 'coro' is either a pure Python generator iterator, or it
-            # implements collections.abc.Generator (and does not implement
-            # collections.abc.Coroutine).
-            return _GeneratorWrapper(coro)
-        # 'coro' is either an instance of collections.abc.Coroutine or
-        # some other object -- pass it through.
-        return coro
-
-    return wrapped
-
-
-__all__ = [n for n in globals() if n[:1] != '_']