turtleshell 1.1.0__tar.gz → 1.3.0__tar.gz

{turtleshell-1.1.0 → turtleshell-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: turtleshell
-Version: 1.1.0
+Version: 1.3.0
 Summary: Convenience wrapper around turtle.Turtle and turtle.Screen
 Author-email: Sam Mangan <sam.mangan2@gmail.com>
 License-Expression: MIT

{turtleshell-1.1.0 → turtleshell-1.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "turtleshell"
-version = "1.1.0"
+version = "1.3.0"
 authors = [
   { name="Sam Mangan", email="sam.mangan2@gmail.com" },
 ]
@@ -27,7 +27,7 @@ addopts = [
 ]
 
 [tool.bumpver]
-current_version = "1.1.0"
+current_version = "1.3.0"
 version_pattern = "MAJOR.MINOR.PATCH"
 commit_message  = "Bump version {old_version} -> {new_version}"
 commit          = true

{turtleshell-1.1.0 → turtleshell-1.3.0}/src/turtleshell/__init__.py

@@ -1,3 +1,3 @@
 from .core import Screen, Turtle
 
-__version__ = "1.1.0"
+__version__ = "1.3.0"

turtleshell-1.3.0/src/turtleshell/core.py

@@ -0,0 +1,291 @@
+"""Convenience wrappers around turtle.Turtle and turtle.Screen
+  See https://github.com/python/cpython/blob/main/Lib/turtle.py
+  """
+#TODO handle floats, randcoords, default screensize, default shape
+#TODO # def _polytrafo(self, poly):
+
+import colorsys, math, turtle
+from dataclasses import dataclass
+
+sign = lambda x: round(math.copysign(1, x))
+
+@dataclass
+class HSV:
+  hue: float
+  sat: float
+  val: float
+  def __iter__(self):
+    return iter(self.__dict__.values())
+
+def Screen():
+    """Return the singleton screen object."""
+    if Turtle._screen is None:
+        Turtle._screen = _Screen()
+    return Turtle._screen
+
+class _Screen(turtle._Screen):
+  def __init__(self):
+    super().__init__()
+    turtle.TurtleScreen.__init__(self, _Screen._canvas)
+    if turtle.Turtle._screen is None:
+      turtle.Turtle._screen = self
+    self.colormode(255)
+    self.timers = {}
+
+  @property
+  def width(self):
+    return self.window_width()
+  
+  @property
+  def height(self):
+    return self.window_height()
+  
+  def setup(self, width=turtle._CFG["width"], height=turtle._CFG["height"],
+            startx=turtle._CFG["leftright"], starty=turtle._CFG["topbottom"]):
+    super().setup(width, height, startx, starty)
+    self.screensize(self.width-20, self.height-20)
+
+  def _onkeypress(self, fun, key=None):
+    if fun is None:
+      if key is None:
+        for key in self._keys:
+          self._keys.remove(key)
+          self.cv.unbind("<KeyPress-%s>" % key, None)
+      else:
+        self.cv.unbind("<KeyPress-%s>" % key, None)
+    else:
+      def eventfun(event):
+        fun()
+      if key is None:
+        self.cv.bind("<KeyPress>", eventfun)
+      else:
+        self.cv.bind("<KeyPress-%s>" % key, eventfun)
+
+  def onmove(self, fun):
+    def eventfun(event):
+      x, y = (self.cv.canvasx(event.x)/self.xscale,
+              -self.cv.canvasy(event.y)/self.yscale)
+      fun(x, y)
+    self.cv.bind("<Motion>", eventfun)
+
+  def cancel_timer(self, func):
+    if not func in self.timers:
+      return
+    for id in self.timers.pop(func):
+      self.getcanvas().after_cancel(id)
+
+  def set_timer(self, func, ms, add=False):
+    if not add and func in self.timers:
+      self.cancel_timer(func)
+    id = self.getcanvas().after(ms, func)
+    if func in self.timers:
+      self.timers[func].append(id)
+    else:
+      self.timers[func] = [id]
+
+  def _colorstr(self, color):
+    isnumber = lambda x: isinstance(x, (int, float))
+    if isinstance(color, tuple) and len(color) == 1:
+      color = color[0]
+    if len(color) == 3 and all([isnumber(c) for c in color]):
+      lower, upper = 0, Turtle._screen.colormode()
+      color = [max(min(upper, round(c)), lower) for c in color]
+    return super()._colorstr(color)
+
+def _hsv_to_rgb(hsv):
+  rgb = colorsys.hsv_to_rgb(*hsv)
+  return [round(c*Turtle._screen.colormode()) for c in rgb]
+
+class Turtle(turtle.RawTurtle):
+
+  _pen = None
+  _screen = None
+  MULT = 20
+
+  def __init__(self,
+              shape=turtle._CFG["shape"],
+              undobuffersize=turtle._CFG["undobuffersize"],
+              visible=turtle._CFG["visible"]):
+    if Turtle._screen is None:
+      Turtle._screen = Screen()
+    turtle.RawTurtle.__init__(self, Turtle._screen,
+                        shape=shape,
+                        undobuffersize=undobuffersize,
+                        visible=visible)
+    self.shapesize(Turtle.MULT)
+    self._pen_hsv = HSV(0, 1, 1)
+    self._fill_hsv = HSV(0, 1, 1)
+
+  def __lt__(self, other):
+    if isinstance(other, Turtle):
+      return self.y < other.y
+    return NotImplemented
+  
+  def __eq__(self, other):
+    if isinstance(other, Turtle):
+      return self.y == other.y
+    return NotImplemented
+
+  def onenter(self, fun):
+    titem = self.turtle._item
+    if fun is None:
+      self.screen.cv.tag_unbind(titem, "<Enter>")
+    else:
+      def eventfun(event):
+        x, y = (self.screen.cv.canvasx(event.x)/self.screen.xscale,
+                -self.screen.cv.canvasy(event.y)/self.screen.yscale)
+        fun(x, y)
+      self.screen.cv.tag_bind(titem, "<Enter>", eventfun)
+
+  def onexit(self, fun):
+    titem = self.turtle._item
+    if fun is None:
+      self.screen.cv.tag_unbind(titem, "<Leave>")
+    else:
+      def eventfun(event):
+        x, y = (self.screen.cv.canvasx(event.x)/self.screen.xscale,
+                -self.screen.cv.canvasy(event.y)/self.screen.yscale)
+        fun(x, y)
+      self.screen.cv.tag_bind(titem, "<Leave>", eventfun)
+
+  def bring_forward(self):
+      titem = self.turtle._item
+      for item in self.items:
+        self.screen.cv.tag_raise(item)
+      titem = self.turtle._item
+      self.screen.cv.tag_raise(titem)
+
+  def send_backward(self):
+      titem = self.turtle._item
+      self.screen.cv.tag_lower(titem)
+
+  def face(self, x, y):
+    self.setheading(self.towards(x, y))
+
+  @property
+  def x(self):
+    return self.xcor()
+
+  @x.setter
+  def x(self, value):
+    self.setx(value)
+
+  @property
+  def y(self):
+    return self.ycor()
+
+  @y.setter
+  def y(self, value):
+    self.sety(value)
+
+  def shapesize(self, stretch_wid=None, stretch_len=None, outline=None):
+
+    if stretch_wid is None and stretch_len is None and outline is None:
+      stretch_wid, stretch_len, outline = super().shapesize()
+      return stretch_wid*Turtle.MULT, stretch_len*Turtle.MULT, outline
+
+    stretch_wid = stretch_wid/Turtle.MULT if stretch_wid else None
+    stretch_len = stretch_len/Turtle.MULT if stretch_len else None
+    ret = super().shapesize(stretch_wid, stretch_len, outline)
+    return ret
+
+  def teleport(self, x, y):
+    pendown = self.isdown()
+    if pendown:
+      self.pen(pendown=False)
+    self.penup()
+    self._position = turtle.Vec2D(x, y)
+    self.pen(pendown=pendown)
+  
+  def _write(self, txt, align, font):
+        """Performs the writing for write()
+        """
+        item, end = self.screen._write(self._position, txt, align, font,
+                                                          self._pencolor)
+        
+        self._update()
+        self.items.append(item)
+        if self.undobuffer:
+            self.undobuffer.push(("wri", item))
+        return end
+  
+  def write(self, arg, move=False, align="center", font=("Courier New", 20, "bold")):
+    super().write(arg, move, align, font)
+    self.bring_forward() # TODO this will be undone if Screen.update() is called
+
+  def to_front(self):
+    self.goto(self.position())
+
+  ## HSV colour methods
+  def hsv(self, hue, sat, val):
+    return
+
+  def penhsv(self, *args):
+    print(args)
+
+  def fillhsv(self, *args):
+    print(args)
+    
+  def hue(self, degrees=None):
+    return (self.penhue(degrees), self.fillhue(degrees))
+
+  def penhue(self, degrees=None):
+    if degrees is None:
+      return self._pen_hsv.hue * 360
+    self._pen_hsv.hue = degrees/360
+    self.pencolor(_hsv_to_rgb(self._pen_hsv))
+    return degrees
+
+  def fillhue(self, degrees=None):
+    if degrees is None:
+      return self._fill_hsv.hue * 360
+    self._fill_hsv.hue = degrees/360
+    self.fillcolor(_hsv_to_rgb(self._fill_hsv))
+
+  def sat(self, value=None):
+    return(self.pensat(value), self.fillsat(value))
+
+  def pensat(self, value=None):
+    if value is None:
+      return self._pen_hsv.sat * 100
+    self._pen_hsv.sat = value/100
+    self.pencolor(_hsv_to_rgb(self._pen_hsv))
+
+  def fillsat(self, value=None):
+    if value is None:
+      return self._fill_hsv.sat * 100
+    self._fill_hsv.sat = value/100
+    self.fillcolor(_hsv_to_rgb(self._fill_hsv))
+
+  def val(self, value=None):
+    return (self.penval(value), self.fillval(value))
+
+  def penval(self, value=None):
+    if value is None:
+      return self._pen_hsv.val * 100
+    self._pen_hsv.val = value/100
+    self.pencolor(_hsv_to_rgb(self._pen_hsv))
+
+  def fillval(self, value=None):
+    if value is None:
+      return self._fill_hsv.val * 100
+    self._fill_hsv.val = value/100
+    self.fillcolor(_hsv_to_rgb(self._fill_hsv))
+
+Pen = Turtle
+
+def turtle_test(screen):
+  pen = Turtle()
+  print(f"\n\n***\nTURTLE TYPE: {type(pen)}\nSCREEN TYPE: {type(screen)}\n***\n")
+  pen.shape("square")
+  pen.shapesize(30, 25)
+  pen.hsv(100, 50, 50)
+  pen.stamp()
+
+if __name__ == "__main__":
+  import os;os.system("clear")
+  screen = Screen()
+  screen.setup(400,400,0,0)
+  screen.bgcolor("gold")
+  turtle_test(screen)
+  screen.exitonclick()

{turtleshell-1.1.0 → turtleshell-1.3.0}/src/turtleshell.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: turtleshell
-Version: 1.1.0
+Version: 1.3.0
 Summary: Convenience wrapper around turtle.Turtle and turtle.Screen
 Author-email: Sam Mangan <sam.mangan2@gmail.com>
 License-Expression: MIT

{turtleshell-1.1.0 → turtleshell-1.3.0}/tests/test_turtle.py

@@ -28,8 +28,10 @@ def test_y(pen):
 def test_shapesize_set(pen):
   pen.shape("square")
   pen.shapesize(30,40)
-  assert pen.shapewidth == 30
-  assert pen.shapeheight == 40
+  width, height, outline = pen.shapesize()
+  assert width == 30
+  assert height == 40
+  assert outline == 1
 
 def test_shapesize_get(pen):
   pen.shape("square")

turtleshell-1.1.0/src/turtleshell/core.py

@@ -1,174 +0,0 @@
-"""Convenience wrappers around turtle.Turtle and turtle.Screen
-  See https://github.com/python/cpython/blob/main/Lib/turtle.py
-  """
-#TODO handle floats, randcoords, default screensize, default shape
-
-import colorsys
-from dataclasses import dataclass
-import turtle
-
-@dataclass
-class HSV:
-  hue: float
-  sat: float
-  val: float
-  def __iter__(self):
-    return iter(self.__dict__.values())
-
-def Screen():
-    """Return the singleton screen object."""
-    if Turtle._screen is None:
-        Turtle._screen = _Screen()
-    return Turtle._screen
-
-class _Screen(turtle._Screen):
-  def __init__(self):
-    super().__init__()
-    turtle.TurtleScreen.__init__(self, _Screen._canvas)
-    if turtle.Turtle._screen is None:
-      turtle.Turtle._screen = self
-    self.colormode(255)
-  
-  def _colorstr(self, color):
-    isnumber = lambda x: isinstance(x, (int, float))
-    if len(color) == 3 and all([isnumber(c) for c in color]):
-      lower, upper = 0, Turtle._screen.colormode()
-      color = [max(min(upper, round(c)), lower) for c in color]
-    return super()._colorstr(color)
-
-def _hsv_to_rgb(hsv):
-  rgb = colorsys.hsv_to_rgb(*hsv)
-  return [round(c*Turtle._screen.colormode()) for c in rgb]
-
-class Turtle(turtle.RawTurtle):
-
-  _pen = None
-  _screen = None
-  MULT = 20
-
-  def __init__(self,
-              shape=turtle._CFG["shape"],
-              undobuffersize=turtle._CFG["undobuffersize"],
-              visible=turtle._CFG["visible"]):
-    if Turtle._screen is None:
-      Turtle._screen = Screen()
-    turtle.RawTurtle.__init__(self, Turtle._screen,
-                        shape=shape,
-                        undobuffersize=undobuffersize,
-                        visible=visible)
-    self.shapesize(Turtle.MULT)
-    self._pen_hsv = HSV(0, 1, 1)
-    self._fill_hsv = HSV(0, 1, 1)
-
-  @property
-  def x(self):
-    return self.xcor()
-
-  @x.setter
-  def x(self, value):
-    self.setx(value)
-
-  @property
-  def y(self):
-    return self.ycor()
-
-  @y.setter
-  def y(self, value):
-    self.sety(value)
-
-  @property
-  def shapewidth(self):
-    xcoords = [vertex[0] for vertex in self.get_shapepoly()]
-    return max(xcoords) - min(xcoords)
-
-  @property
-  def shapeheight(self):
-    ycoords = [vertex[1] for vertex in self.get_shapepoly()]
-    return max(ycoords) - min(ycoords)
-
-  def hue(self, degrees):
-    self.penhue(degrees)
-    self.fillhue(degrees)
-
-  def penhue(self, degrees):
-    self._pen_hsv.hue = degrees/360
-    self.pencolor(_hsv_to_rgb(self._pen_hsv))
-
-  def fillhue(self, degrees):
-    self._fill_hsv.hue = degrees/360
-    self.fillcolor(_hsv_to_rgb(self._fill_hsv))
-
-  def sat(self, value):
-    self.pensat(value)
-    self.fillsat(value)
-
-  def pensat(self, value):
-    self._pen_hsv.sat = value/100
-    self.pencolor(_hsv_to_rgb(self._pen_hsv))
-
-  def fillsat(self, value):
-    self._fill_hsv.sat = value/100
-    self.fillcolor(_hsv_to_rgb(self._fill_hsv))
-
-  def val(self, value):
-    self.penval(value)
-    self.fillval(value)
-
-  def penval(self, value):
-    self._pen_hsv.val = value/100
-    self.pencolor(_hsv_to_rgb(self._pen_hsv))
-
-  def fillval(self, value):
-    self._fill_hsv.val = value/100
-    self.fillcolor(_hsv_to_rgb(self._fill_hsv))
-
-  def shapesize(self, stretch_wid=None, stretch_len=None, outline=None):
-    if stretch_wid is None and stretch_len is None and outline is None:
-      stretch_wid, stretch_len, outline = super().shapesize()
-      return stretch_wid*Turtle.MULT, stretch_len*Turtle.MULT, outline
-
-    stretch_wid = stretch_wid/Turtle.MULT if stretch_wid else None
-    stretch_len = stretch_len/Turtle.MULT if stretch_len else None
-    ret = super().shapesize(stretch_wid, stretch_len, outline)
-    return ret
-
-  def teleport(self, x, y):
-    pendown = self.isdown()
-    if pendown:
-      self.pen(pendown=False)
-    self.penup()
-    self._position = turtle.Vec2D(x, y)
-    self.pen(pendown=pendown)
-
-  def write(self, arg, move=False, align="center", font=("Arial", 18, "bold")):
-    super().write(arg, move, align, font)
-
-Pen = Turtle
-
-if __name__ == "__main__":
-  canvas = Screen()
-  canvas.bgcolor("gold")
-  pen = Turtle()
-  print(f"\n\n***\nTURTLE TYPE: {type(pen)}\nSCREEN TYPE: {type(canvas)}\n***\n")
-
-  pen.shape("square")
-  print(f"{pen.shapewidth}, {pen.shapeheight}")
-  pen.shapesize(30, 25)
-  print(f"{pen.shapewidth}, {pen.shapeheight}")
-
-  pen.hue(0)
-  pen.stamp()
-  pen.forward(50)
-  pen.hue(60)
-  pen.stamp()
-  pen.forward(50)
-  pen.hue(120)
-  pen.stamp()
-  pen.forward(50)
-  pen.hue(180)
-  pen.stamp()
-  pen.forward(50)
-  pen.hue(240)
-  pen.stamp()
-
-  canvas.exitonclick()