ColabTurtlePlus 2.0.2__tar.gz → 2.1.1__tar.gz

{colabturtleplus-2.0.2 → colabturtleplus-2.1.1}/ColabTurtlePlus/Turtle.py

@@ -27,6 +27,18 @@ v2.0.1 Oct. 2021
 Lines drawn with drawlines() method now included in saved SVG file.
 Fixes so that graphic window is still displayed when cell executed more than once in Jupyter notebook.
 
+v2.0.2 Aug. 2026
+Fixed Python 3.13+ SyntaxWarning by using raw strings in regular expressions.
+
+v2.1.0 September 2026
+Added register_shape() (alias addshape) to mimic the role of the function register_shape() from Python's turtle.
+This only works to add a polygonal shape (and now component shapes with v2.1.1). It does not work with images.
+
+v2.1.1 September 2026
+Added addcomponent() to create new polygonal turtles. Because turtles are defined as svg strings, also added two
+new functions, addellipsecomponent() and addpathcomponent, to create turtles bassed on ellipical shapes and svg
+paths. To be consistent with Python's turtle, these are first invoked using a call to Shape("compound") and then
+combined using register_shape().
 """
 
 DEFAULT_WINDOW_SIZE = (800, 600)
@@ -61,12 +73,14 @@ VALID_COLORS = ('black', 'navy', 'darkblue', 'mediumblue', 'blue', 'darkgreen',
                 'lightgoldenrodyellow', 'oldlace', 'red', 'fuchsia', 'magenta', 'deeppink', 'orangered', 'tomato', 'hotpink', 'coral', 'darkorange', 
                 'lightsalmon', 'orange', 'lightpink', 'pink', 'gold', 'peachpuff', 'navajowhite', 'moccasin', 'bisque', 'mistyrose', 'blanchedalmond', 
                 'papayawhip', 'lavenderblush', 'seashell', 'cornsilk', 'lemonchiffon', 'floralwhite', 'snow', 'yellow', 'lightyellow', 'ivory', 'white','none','')
-#VALID_COLORS_SET = set(VALID_COLORS)
+VALID_COLORS_SET = set(VALID_COLORS)
 VALID_MODES = ('standard','logo','world','svg')
 DEFAULT_TURTLE_SHAPE = 'classic'
-VALID_TURTLE_SHAPES = ('turtle', 'ring', 'classic', 'arrow', 'square', 'triangle', 'circle', 'turtle2', 'blank') 
+VALID_TURTLE_SHAPES = {'turtle', 'ring', 'classic', 'arrow', 'square', 'triangle', 'circle', 'turtle2', 'blank', 'user'}
 DEFAULT_MODE = 'standard'
 DEFAULT_ANGLE_MODE = 'degrees'
+DEFAULT_POINTS = '-5,-4.5 0,-2.5 5,-4.5 0,4.5'
+DEFAULT_NAME = 'classic'
 SVG_TEMPLATE = """
       <svg width="{window_width}" height="{window_height}">  
         <rect width="100%" height="100%" style="fill:{backcolor};stroke:{kolor};stroke-width:1"/>
@@ -103,9 +117,34 @@ TURTLE_CIRCLE_SVG_TEMPLATE = """<g id="ellipse" visibility="{visibility}" transf
 TURTLE_TURTLE2_SVG_TEMPLATE = """<g id="turtle2" visibility="{visibility}" transform="rotate({degrees},{rotation_x},{rotation_y}) translate({turtle_x}, {turtle_y})">
 <polygon points="0,16 2,14 1,10 4,7 7,9 9,8 6,5 7,1 5,-3 8,-6 6,-8 4,-5 0,-7 -4,-5 -6,-8 -8,-6 -5,-3 -7,1 -6,5 -9,8 -7,9 -4,7 -1,10 -2,14" transform="skewX({sk}) scale({sx},{sy})" style="stroke:{pcolor};stroke-width:1;fill:{turtle_color}" />
 </g>"""
+TURTLE_USER_SVG_TEMPLATE = """<g id="{id}" visibility="{visibility}" transform="rotate({degrees},{rotation_x},{rotation_y}) translate({turtle_x}, {turtle_y})">
+<polygon points="{points}" transform="skewX({sk}) scale({sx},{sy})" style="stroke:{pcolor};fill:{turtle_color};stroke-width:{pw}" />
+</g>"""
+
+TURTLE_COMPONENT_SVG_TEMPLATE = """<g id="user" visibility="{visibility}" transform="rotate({degrees},{rotation_x},{rotation_y}) translate({turtle_x}, {turtle_y})">
+"{component}"
+</g>"""
+
+POLY_TEMPLATE = """<polygon points="{points}" transform="skewX({sk})
+scale({sx},{sy})" style="stroke:{pcolor};fill:{turtle_color};stroke-width:{pw}" />"""
+ELLIPSE_TEMPLATE =  """<ellipse transform="skewX({sk}) scale({sx},{sy})"
+style="stroke:{pcolor};fill:{turtle_color};stroke-width:{pw}" rx="{rx}" ry ="{ry}" cx="{cx}" cy="{cy}" />"""
+PATH_TEMPLATE = """<path d="{path}" style="stroke:{pcolor};fill-rule:evenodd;fill:{turtle_color};fill-opacity:1;" 
+transform="skewX({sk}) scale({sx},{sy})" />"""
+
 
 SPEED_TO_SEC_MAP = {0: 0, 1: 1.0, 2: 0.8, 3: 0.5, 4: 0.3, 5: 0.25, 6: 0.20, 7: 0.15, 8: 0.125, 9: 0.10, 10: 0.08, 11: 0.04, 12: 0.02, 13: 0.005}
 
+shapeDict = {"turtle":TURTLE_TURTLE_SVG_TEMPLATE, 
+              "ring":TURTLE_RING_SVG_TEMPLATE, 
+              "classic":TURTLE_CLASSIC_SVG_TEMPLATE,
+              "arrow":TURTLE_ARROW_SVG_TEMPLATE,
+              "square":TURTLE_SQUARE_SVG_TEMPLATE,
+              "triangle":TURTLE_TRIANGLE_SVG_TEMPLATE,
+              "circle":TURTLE_CIRCLE_SVG_TEMPLATE,
+              "turtle2":TURTLE_TURTLE2_SVG_TEMPLATE,
+              "blank":""}
+
 #------------------------------------------------------------------------------------------------
 
 def Screen():
@@ -163,9 +202,9 @@ class _Screen:
 
         turtle_x = turtle.turtle_pos[0]
         turtle_y = turtle.turtle_pos[1]
-        if self._mode == "standard":
+        if self._mode == 'standard':
             degrees = turtle.turtle_degree - turtle.tilt_angle    
-        elif self._mode == "world":
+        elif self._mode == 'world':
             degrees = turtle.turtle_orient - turtle.tilt_angle
         else:
             degrees = turtle.turtle_degree + turtle.tilt_angle
@@ -175,17 +214,18 @@ class _Screen:
         elif turtle.turtle_shape == 'ring':
             turtle_y += 10*turtle.stretchfactor[1]+4
             degrees -= 90
-        else:
+        else:    #turtle.turtle_shape in {'classic', 'arrow', 'square', 'triangle', 'circle', 'turtle2', 'blank'}:
             degrees -= 90
+        
        
-        svg = turtle.shapeDict[turtle.turtle_shape].format(
+        svg = shapeDict[turtle.turtle_shape].format(
                            turtle_color=turtle.fill_color,
                            pcolor=turtle.pen_color,
                            turtle_x=turtle_x, 
                            turtle_y=turtle_y,
                            visibility=vis, 
                            degrees=degrees,
-                           sx=turtle.stretchfactor[0],
+                           sx=-turtle.stretchfactor[0],
                            sy=turtle.stretchfactor[1],
                            sk=turtle.shear_factor,
                            rx=10*turtle.stretchfactor[0],
@@ -193,7 +233,8 @@ class _Screen:
                            cy=-(10*turtle.stretchfactor[1]+4),
                            pw = turtle.outline_width,
                            rotation_x=turtle.turtle_pos[0], 
-                           rotation_y=turtle.turtle_pos[1])
+                           rotation_y=turtle.turtle_pos[1],
+                           id = turtle.turtle_shape)
         return svg
     
     # helper function for linking svg strings of text
@@ -312,6 +353,60 @@ class _Screen:
         text_file.write(output)
         text_file.close()   
 
+    def register_shape(self, name, shape=None):
+        """Adds a turtle shape to to the shape list.
+
+        Arg:
+           name is an arbitrary string
+           points is a list or tuple of pairs of coordinates that define a polygon, 
+           or a (compound) Shape object
+       
+        Installs the corresponding polygon shape or the corresponding compound shape.
+        If no points are given, the turtle shape will be blank.
+        Note: This version does NOT include shapes that are images
+        """
+            
+        if not isinstance(name,str):
+            raise TypeError("The name must be a string")
+        if shape is None:
+            self.points = None
+        elif isinstance(shape, (list, tuple)):
+            points = shape
+            if len(points) < 2:
+                raise ValueError("The points must contain at least 2 coordinate pairs.")
+            for i, point in enumerate(points):
+                if not isinstance(point, (list, tuple)):
+                    raise TypeError(
+                        f"The point[{i}] must be a coordinate pair."
+                    )
+                if len(point) != 2:
+                   raise ValueError(
+                       f"The point[{i}] must contain exactly two coordinates."
+                    )
+                if not all(isinstance(x, (int, float)) for x in point):
+                   raise TypeError(
+                       f"The point[{i}] must contain numeric coordinates."
+                   )  
+            name = name.lower()    
+            VALID_TURTLE_SHAPES.add(name)
+            pointstr = " ".join(f"{x},{y}" for x, y in points)
+            shapeDict[name] = TURTLE_USER_SVG_TEMPLATE.replace("{points}",pointstr)   #TURTLE_USER_SVG_TEMPLATE
+        else:  #assume compound shape
+            tmp=TURTLE_COMPONENT_SVG_TEMPLATE.format(
+                    component=shape._data,
+                    visibility="{visibility}",
+                    degrees="{degrees}",
+                    rotation_x="{rotation_x}",
+                    rotation_y="{rotation_y}",
+                    turtle_x="{turtle_x}",
+                    turtle_y="{turtle_y}",
+                    )
+           # componentDict[shape] = tm
+            name = name.lower()    
+            VALID_TURTLE_SHAPES.add(name)
+            shapeDict[name] = tmp
+    addshape=register_shape
+        
     #=========================
     # screen drawing functions
     #=========================
@@ -710,8 +805,8 @@ class _Screen:
 
     def turtles(self):
         """Return the list of turtles on the screen."""
-        return self._turtles
-
+        return self._turtles        
+        
     def initializescreen(self,window=DEFAULT_WINDOW_SIZE,mode=DEFAULT_MODE):
         """Initializes the drawing window
     
@@ -720,7 +815,7 @@ class _Screen:
             mode: (optional) one of "standard, "logo", "world", or "sv
     
         The defaults are (800,600) and "standard".
-    """
+        """
         if window is not None:
             if not (isinstance(window, tuple) and len(window) == 2 and isinstance(
                     window[0], int) and isinstance(window[1], int)):
@@ -774,7 +869,109 @@ class _Screen:
             err = 'The color parameter ' + color + ' must be a color string or a tuple'
             raise ValueError(err)
 
+#----------------------------------------------------------------------------------------------        
+class Shape(object):
+    def __init__(self, type_, data=None):
+      self._type = type_
+      if type_ == "compound":
+        data = ""
+      self._data = data
+
+        
+    def addcomponent(self, points, fill=None, outline=None):
+      """Add polygonal component to a shape of type compound.
+
+      Arguments: poly is a polygon, i. e. a tuple of number pairs.
+           fill is the fillcolor of the polygon,
+           outline is the outline color of the polygon.
+
+      Example:
+        >>> poly = ((0,0),(10,-5),(0,10),(-10,-5))
+        >>> s = Shape("compound")
+        >>> s.addcomponent(poly, "red", "blue")
+        >>> # .. add more components and then use register_shape()
+      """
+        
+      tmp = self._data
+      p = " ".join(f"{x},{y}" for x, y in points)
+      template = POLY_TEMPLATE.replace("{points}",p) + "\n"
+      if fill is not None:
+        template = template.replace("{turtle_color}",fill) 
+        if outline is None:
+          template = template.replace("{pcolor}",fill)
+        else:
+          template = template.replace("{pcolor}", outline)
+      elif outline is not None:
+        template = template.replace("{pcolor}",outline)
+      self._data = tmp + template
+
+    def addellipsecomponent(self, center, radii, fill=None, outline=None):
+      """Add elliptical component to a shape of type compound.
+
+      Arguments: center is a tuple (cx,cy) that is the center of the ellipse
+           radii is a tuple (rx, ry) giving the radius of the ellipse in the x and y directions.
+              Can use just radii = r as a substitute for (r,r) to do a circle of radius r
+           fill is the fillcolor of the ellipse,
+           outline is the outline color of the ellipse.
+
+      Example:
+        >>> s = Shape("compound")
+        >>> s.addellipsecomponent((0,0), (50,100), "red", "blue")
+        >>> # .. add more components and then use register_shape()
+      """
+      tmp = self._data
+      if isinstance(radii, (float,int)):
+        xradius = radii
+        yradius = radii
+      elif isinstance(radii, tuple):
+        xradius = radii[0]
+        yradius = radii[1]
+      replacements = {
+        "{cx}": str(center[0]),
+        "{cy}": str(center[1]),
+        "{rx}": str(xradius),
+        "{ry}": str(yradius)
+      }
+      pattern = re.compile("|".join(re.escape(key) for key in replacements.keys()))
+      template = pattern.sub(lambda match: replacements[match.group(0)], ELLIPSE_TEMPLATE)
+      if fill is not None:
+        template = template.replace("{turtle_color}",fill) 
+        if outline is None:
+          template = template.replace("{pcolor}",fill)
+        else:
+          template = template.replace("{pcolor}", outline)
+      elif outline is not None:
+        template = template.replace("{pcolor}",outline)
+      self._data = tmp + template + "\n"
+
+    def addpathcomponent(self, path, fill=None, outline=None):
+      """Add an SVG path component to a shape of type compound.
+
+      Arguments: path is an SVG string defining a path
+           fill is the fillcolor of the component,
+           outline is the outline color of the component.
+
+      Example:
+        >>> curve = "M -50 -50 Q 0 100 50 -50"   (quadratic Bezier curve)
+        >>> s = Shape("compound")
+        >>> s.addpathcomponent(curve, "red", "blue")
+        >>> # .. add more components and then use register_shape()
+      """
+      tmp = self._data
+      template = PATH_TEMPLATE.replace("{path}",path)
+      if fill is not None:
+        template = template.replace("{turtle_color}",fill) 
+        if outline is None:
+          template = template.replace("{pcolor}",fill)
+        else:
+          template = template.replace("{pcolor}", outline)
+      elif outline is not None:
+        template = template.replace("{pcolor}",outline)
+      self._data = tmp + template + "\n"
 
+    addEllipseComponet = addellipsecomponent
+    addPathComponent = addpathcomponent
+#-------------------------------------------------------------
 
 #----------------------------------------------------------------------------------------------        
       
@@ -821,16 +1018,9 @@ class RawTurtle:
         self.stampdictT = {}
         self.stampnum = 0
         self.stamplist=[]
-        self.shapeDict = {"turtle":TURTLE_TURTLE_SVG_TEMPLATE, 
-              "ring":TURTLE_RING_SVG_TEMPLATE, 
-              "classic":TURTLE_CLASSIC_SVG_TEMPLATE,
-              "arrow":TURTLE_ARROW_SVG_TEMPLATE,
-              "square":TURTLE_SQUARE_SVG_TEMPLATE,
-              "triangle":TURTLE_TRIANGLE_SVG_TEMPLATE,
-              "circle":TURTLE_CIRCLE_SVG_TEMPLATE,
-              "turtle2":TURTLE_TURTLE2_SVG_TEMPLATE,
-              "blank":""}
-        if screen._mode == "svg": self.shapeDict.update({"circle":TURTLE_RING_SVG_TEMPLATE})                                          
+        self.points = DEFAULT_POINTS            
+
+        if screen._mode == "svg": shapeDict.update({"circle":TURTLE_RING_SVG_TEMPLATE})                                          
         screen._add(self)
         
         
@@ -906,10 +1096,10 @@ class RawTurtle:
             self.screen._updateDrawing(turtle=self)
         elif self.turtle_shape != 'ring' and self.stretchfactor[0]==self.stretchfactor[1]:
             stretchfactor_orig = self.stretchfactor
-            template = self.shapeDict[self.turtle_shape]        
+            template = shapeDict[self.turtle_shape]        
             tmp = """<animateTransform id = "one" attributeName="transform" 
                       type="scale"
-                      from="1 1" to="{sx} {sy}"
+                      from="{sx} {sy}" to="{sx} {sy}"                      
                       begin="0s" dur="0.01s"
                       repeatCount="1"
                       additive="sum"
@@ -923,13 +1113,13 @@ class RawTurtle:
                     fill="freeze"
                 /></g>""".format(extent=deg, t=self.timeout*abs(deg)/90, sx=self.stretchfactor[0], sy=self.stretchfactor[1])
             newtemplate = template.replace("</g>",tmp)
-            self.shapeDict.update({self.turtle_shape:newtemplate})
+            shapeDict.update({self.turtle_shape:newtemplate})
             self.stretchfactor = 1,1
             self.timeout = self.timeout*abs(deg)/90+0.001
             self.screen._updateDrawing(self)
             self.turtle_degree = (self.turtle_degree + deg) % 360
             self.turtle_orient = self._turtleOrientation()
-            self.shapeDict.update({self.turtle_shape:template})
+            shapeDict.update({self.turtle_shape:template})
             self.stretchfactor = stretchfactor_orig
             self.timeout = timeout_orig
         else: #_turtle_shape == 'ring' or _stretchfactor[0] != _stretchfactor[1]
@@ -1581,6 +1771,19 @@ class RawTurtle:
             deg = math.degrees(math.atan2(-Dxy[1],Dxy[0])) % 360
             return 360-deg
 
+    def extract_points(self):
+        svg_string = shapeDict[self.turtle_shape]
+        match = re.search(r'points="([^"]*)"', svg_string)
+        if not match:
+            raise ValueError("No points attribute found")
+        def number(s):
+            value = float(s)
+            return int(value) if value.is_integer() else value
+        return tuple(
+            (number(x), number(y))
+            for x, y in (point.split(",") for point in match.group(1).split())
+        )
+            
     #========================================
     # Turtle Motion - Setting and Measurement
     #========================================
@@ -1856,6 +2059,7 @@ class RawTurtle:
 
         return self.is_filling
 
+        
     # Initialize the string for the svg path of the filled shape.
     # Modified from aronma/ColabTurtle_2 github repo
     # The current _svg_lines_string is stored to be used when the fill is finished because the svg_fill_string will include
@@ -2109,10 +2313,11 @@ class RawTurtle:
     #==========================
     # Turtle State - Appearance
     #==========================
-
+  
     # Set turtle shape to shape with given name or, if name is not given, return name of current shape
     def shape(self, name=None):
         """Sets turtle shape to shape with given name / return current shapename.
+           Can also create a user-defined custom polygonal shape
 
         Args:
             name: an optional string, which is a valid shapename
@@ -2125,6 +2330,8 @@ class RawTurtle:
         The 'turtle' shape is the one that Tolga Atam included in his original 
         ColabTurtle version. Use 'turtle2' for the polygonal turtle shape form 
         turtle.py. The circle shape from the original ColabTurtle was renamed 'ring'.
+        
+        Use register_shape (alias addshape) to create a polygonal shape with a chosen name.
         """
 
         if name is None:
@@ -2133,7 +2340,7 @@ class RawTurtle:
             raise ValueError('Shape is invalid. Valid options are: ' + str(VALID_TURTLE_SHAPES)) 
         self.turtle_shape = name.lower()
         self.screen._updateDrawing(turtle=self)
- 
+        
     # Scale the size of the turtle
     # stretch_wid scales perpendicular to orientation
     # stretch_len scales in direction of turtle's orientation
@@ -2172,7 +2379,8 @@ class RawTurtle:
             outline = self.outline_width
         elif not isinstance(outline, (int,float)):
             raise ValueError('The outline must be a positive number.')        
-        self.outline_width = outline   
+        self.outline_width = outline 
+        self.screen._updateDrawing(turtle=self, delay=False)
     turtlesize = shapesize #alias
 
     # Set or return the current shearfactor. Shear the turtleshape according to the given shearfactor shear, which is the tangent of the shear angle. 
@@ -2376,16 +2584,18 @@ def getcolor(n):
     return VALID_COLORS[n]
 
 
-_tg_screen_functions = ['bgcolor', 'clearscreen', 'drawline', 'hideborder', 
-         'initializescreen','initializeTurtle', 'showSVG', 'saveSVG',  'line',  'mode', 'resetscreen',  'setup', 
+_tg_screen_functions = ['addshape', 'bgcolor', 'clearscreen', 'drawline', 'hideborder', 
+         'initializescreen','initializeTurtle', 'showSVG', 'saveSVG',  'line',  'mode', 'register_shape', 'resetscreen',  'setup', 
          'setworldcoordinates', 'showborder', 'turtles',  'window_width', 'window_height' ]
 
+_tg_shape_functions = ['addcomponent', 'addellipsecomponent', 'addpathcomponent']
+
 _tg_turtle_functions = ['animationOff', 'animationOn', 'bk', 'back', 'backward', 'begin_fill',
        'circle', 'clear', 'clearstamp', 'clearstamps', 'color', 'degrees', 'delay', 'distance', 'done',  
-       'dot', 'down', 'end_fill', 'face', 'fd', 'fillcolor', 'filling', 'fillopacity', 'fillrule', 'forward',  
+       'dot', 'down', 'end_fill', 'extract_points', 'face', 'fd', 'fillcolor', 'filling', 'fillopacity', 'fillrule', 'forward',  
        'getheading', 'getx', 'gety', 'goto', 'heading', 'hideturtle', 'home', 'ht', 'isdown',
        'isvisible', 'jumpto', 'left', 'lt', 'pd', 'pen', 'pencolor', 'pensize', 'pendown', 'penup', 'pos', 
-       'position',  'pu', 'radians', 'regularPolygon', 'reset', 'right', 'rt',  'setheading', 'seth',  
+       'position',  'pu', 'radians', 'regularPolygon', 'reset', 'right', 'rt', 'setheading', 'seth',  
        'setpos', 'setposition', 'settiltangle', 'setx','sety', 'shape', 'shapesize', 'shearfactor',  
        'showturtle', 'speed', 'st', 'stamp', 'tilt', 'tiltangle', 'turtlesize', 'towards', 'up', 'update',  
        'width', 'write', 'xcor', 'ycor' ]
@@ -2445,7 +2655,6 @@ def _screen_docrevise(docstr):
     newdocstr = parexp.sub(":", newdocstr)
     return newdocstr
 
-
 __func_body = """\
 def {name}{paramslist}:
     if {obj} is None:
@@ -2471,3 +2680,4 @@ _make_global_funcs(_tg_screen_functions, _Screen, 'Turtle._screen', 'Screen()',_
 
 
 
+

{colabturtleplus-2.0.2 → colabturtleplus-2.1.1}/ColabTurtlePlus.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ColabTurtlePlus
-Version: 2.0.2
+Version: 2.1.1
 Summary: An HTML based Turtle implementation with classes for Google Colab and Jupyter Labs
 Home-page: https://github.com/mathriddle/ColabTurtlePlus
 Author: Larry Riddle
@@ -33,6 +33,12 @@ The ColabTurtlePlus module provides turtle graphics primitives, in both object-o
 
 To use multiple turtles on a screen one has to use the object-oriented interface for the turtles.
 
+What's New:
+----
+Sept. 2026: Version 2.1.0 adds a register_shape (alias addshape) function to create a polygonal turtle shape. It does not work with images.
+
+Sept. 2026: Version 2.1.1 allows use of addcomponent() to add a polygon to a component turtle shape. There are two new ways to build additional components: addellipsecomponent() adds an elliptical shape, and addpathcompenent adds a path defined using svg path commands.
+
 Installation
 ----
 Create an empty code cell and type:
@@ -53,7 +59,6 @@ Example 1
 ---
 This example uses the procedure-oriented interface.
 ```
-from ColabTurtlePlus.Turtle import *
 clearscreen()
 setup(300,300)
 showborder()
@@ -77,7 +82,6 @@ Example 2
 ----
 This example has two turtles and uses the object-oriented interface.
 ```
-from ColabTurtlePlus.Turtle import *
 clearscreen()
 setup(500,300)
 T = Turtle()
@@ -105,6 +109,48 @@ S.end_fill()
 The resulting image is  
 ![](https://github.com/mathriddle/ColabTurtlePlus/raw/main/stars.svg)
 
+Example 3:
+----
+This example uses components.
+```
+clearscreen()
+setup(300,300)
+
+comp_shape = Shape("compound")
+poly = ((-50,0),(-50,100),(50,100),(50,0))
+comp_shape.addcomponent(poly,"blue")
+comp_shape.addellipsecomponent((0,120),50,"red")
+
+star_coords = ((-10,-13.8), (0,17), (10,-13.8), (-16.2,5.3), (16.2,5.3))
+
+addshape("box_with_ball", comp_shape)
+addshape("star", star_coords)
+
+t = Turtle()
+t.shapesize(0.5,0.5)
+t.fillcolor("yellow")
+t.shapesize(0.25)
+t.shape("box_with_ball")
+t.pensize(2)
+t.speed(5)
+t.begin_fill()
+
+for _ in range(4):
+  t.forward(100)
+  t.left(90)
+t.end_fill()
+t.forward(100)
+t.left(90)
+
+s = Turtle()
+s.shapesize(1.5)
+s.shape("star")
+s.circle(-50)
+s.color("black","green")
+```
+The resulting image is  
+![](https://github.com/mathriddle/ColabTurtlePlus/raw/main/example3.svg)
+
 Main differences with ColabTurtle
 ----
 This version implements classes. 

{colabturtleplus-2.0.2 → colabturtleplus-2.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ColabTurtlePlus
-Version: 2.0.2
+Version: 2.1.1
 Summary: An HTML based Turtle implementation with classes for Google Colab and Jupyter Labs
 Home-page: https://github.com/mathriddle/ColabTurtlePlus
 Author: Larry Riddle
@@ -33,6 +33,12 @@ The ColabTurtlePlus module provides turtle graphics primitives, in both object-o
 
 To use multiple turtles on a screen one has to use the object-oriented interface for the turtles.
 
+What's New:
+----
+Sept. 2026: Version 2.1.0 adds a register_shape (alias addshape) function to create a polygonal turtle shape. It does not work with images.
+
+Sept. 2026: Version 2.1.1 allows use of addcomponent() to add a polygon to a component turtle shape. There are two new ways to build additional components: addellipsecomponent() adds an elliptical shape, and addpathcompenent adds a path defined using svg path commands.
+
 Installation
 ----
 Create an empty code cell and type:
@@ -53,7 +59,6 @@ Example 1
 ---
 This example uses the procedure-oriented interface.
 ```
-from ColabTurtlePlus.Turtle import *
 clearscreen()
 setup(300,300)
 showborder()
@@ -77,7 +82,6 @@ Example 2
 ----
 This example has two turtles and uses the object-oriented interface.
 ```
-from ColabTurtlePlus.Turtle import *
 clearscreen()
 setup(500,300)
 T = Turtle()
@@ -105,6 +109,48 @@ S.end_fill()
 The resulting image is  
 ![](https://github.com/mathriddle/ColabTurtlePlus/raw/main/stars.svg)
 
+Example 3:
+----
+This example uses components.
+```
+clearscreen()
+setup(300,300)
+
+comp_shape = Shape("compound")
+poly = ((-50,0),(-50,100),(50,100),(50,0))
+comp_shape.addcomponent(poly,"blue")
+comp_shape.addellipsecomponent((0,120),50,"red")
+
+star_coords = ((-10,-13.8), (0,17), (10,-13.8), (-16.2,5.3), (16.2,5.3))
+
+addshape("box_with_ball", comp_shape)
+addshape("star", star_coords)
+
+t = Turtle()
+t.shapesize(0.5,0.5)
+t.fillcolor("yellow")
+t.shapesize(0.25)
+t.shape("box_with_ball")
+t.pensize(2)
+t.speed(5)
+t.begin_fill()
+
+for _ in range(4):
+  t.forward(100)
+  t.left(90)
+t.end_fill()
+t.forward(100)
+t.left(90)
+
+s = Turtle()
+s.shapesize(1.5)
+s.shape("star")
+s.circle(-50)
+s.color("black","green")
+```
+The resulting image is  
+![](https://github.com/mathriddle/ColabTurtlePlus/raw/main/example3.svg)
+
 Main differences with ColabTurtle
 ----
 This version implements classes. 

{colabturtleplus-2.0.2 → colabturtleplus-2.1.1}/README.md

@@ -8,6 +8,12 @@ The ColabTurtlePlus module provides turtle graphics primitives, in both object-o
 
 To use multiple turtles on a screen one has to use the object-oriented interface for the turtles.
 
+What's New:
+----
+Sept. 2026: Version 2.1.0 adds a register_shape (alias addshape) function to create a polygonal turtle shape. It does not work with images.
+
+Sept. 2026: Version 2.1.1 allows use of addcomponent() to add a polygon to a component turtle shape. There are two new ways to build additional components: addellipsecomponent() adds an elliptical shape, and addpathcompenent adds a path defined using svg path commands.
+
 Installation
 ----
 Create an empty code cell and type:
@@ -28,7 +34,6 @@ Example 1
 ---
 This example uses the procedure-oriented interface.
 ```
-from ColabTurtlePlus.Turtle import *
 clearscreen()
 setup(300,300)
 showborder()
@@ -52,7 +57,6 @@ Example 2
 ----
 This example has two turtles and uses the object-oriented interface.
 ```
-from ColabTurtlePlus.Turtle import *
 clearscreen()
 setup(500,300)
 T = Turtle()
@@ -80,6 +84,48 @@ S.end_fill()
 The resulting image is  
 ![](https://github.com/mathriddle/ColabTurtlePlus/raw/main/stars.svg)
 
+Example 3:
+----
+This example uses components.
+```
+clearscreen()
+setup(300,300)
+
+comp_shape = Shape("compound")
+poly = ((-50,0),(-50,100),(50,100),(50,0))
+comp_shape.addcomponent(poly,"blue")
+comp_shape.addellipsecomponent((0,120),50,"red")
+
+star_coords = ((-10,-13.8), (0,17), (10,-13.8), (-16.2,5.3), (16.2,5.3))
+
+addshape("box_with_ball", comp_shape)
+addshape("star", star_coords)
+
+t = Turtle()
+t.shapesize(0.5,0.5)
+t.fillcolor("yellow")
+t.shapesize(0.25)
+t.shape("box_with_ball")
+t.pensize(2)
+t.speed(5)
+t.begin_fill()
+
+for _ in range(4):
+  t.forward(100)
+  t.left(90)
+t.end_fill()
+t.forward(100)
+t.left(90)
+
+s = Turtle()
+s.shapesize(1.5)
+s.shape("star")
+s.circle(-50)
+s.color("black","green")
+```
+The resulting image is  
+![](https://github.com/mathriddle/ColabTurtlePlus/raw/main/example3.svg)
+
 Main differences with ColabTurtle
 ----
 This version implements classes. 

{colabturtleplus-2.0.2 → colabturtleplus-2.1.1}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = ColabTurtlePlus
-version = 2.0.2
+version = 2.1.1
 author = Larry Riddle
 author_email = lriddle@agnesscott.edu
 description = 'An HTML based Turtle implementation with classes for Google Colab and Jupyter Labs'

{colabturtleplus-2.0.2 → colabturtleplus-2.1.1}/setup.py

@@ -9,7 +9,7 @@ README = (HERE / "README.md").read_text()
 
 setup(
     name='ColabTurtlePlus',
-    version='2.0.2',
+    version='2.1.1',
     packages=['ColabTurtlePlus'],
     url='https://github.com/mathriddle/ColabTurtlePlus',
     license='MIT',