TurtleExtension 1.0.0__tar.gz

turtleextension-1.0.0/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2026 Miah M. Sabiq
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, merge, publish, distribute, sublicense,  and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

turtleextension-1.0.0/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: TurtleExtension
+Version: 1.0.0
+Summary: A Python utility library providing turtle extensions on top of Python's original turtle feature.
+Author-email: "Miah M. Sabiq" <miah.sabiq@gibs.at>
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: UniversalFunctions>=2.7.0
+Dynamic: license-file
+
+# TurtleExtension
+
+**Extend Python's turtle graphics with your own tools and functionality.**
+
+TurtleExtension is a Python project dedicated to extending and experimenting with turtle graphics.
+
+## Features
+
+- Built around Python's `turtle` graphics module.
+- Designed for reusable extensions and custom drawing functionality.
+- A foundation for experimenting with geometric designs and turtle-based programming.
+
+## Requirements
+
+- Python 3.14 or later
+
+## Installation
+
+Once published to PyPI, install with:
+
+```bash
+python -m pip install TurtleExtension
+```
+
+## Usage
+
+```python
+import turtle
+
+# Your TurtleExtension functionality goes here.
+```
+
+The public API and usage examples will be documented as the project develops.
+
+## Development
+
+Clone the repository:
+
+```bash
+git clone https://github.com/YOUR-USERNAME/TurtleExtension.git
+cd TurtleExtension
+```
+
+Install the package locally if your project contains a `pyproject.toml`:
+
+```bash
+python -m pip install .
+```
+
+## License
+
+See the repository for licensing information.
+
+---
+
+*More turtle-powered functionality coming soon.* 🐢

turtleextension-1.0.0/README.md

@@ -0,0 +1,56 @@
+# TurtleExtension
+
+**Extend Python's turtle graphics with your own tools and functionality.**
+
+TurtleExtension is a Python project dedicated to extending and experimenting with turtle graphics.
+
+## Features
+
+- Built around Python's `turtle` graphics module.
+- Designed for reusable extensions and custom drawing functionality.
+- A foundation for experimenting with geometric designs and turtle-based programming.
+
+## Requirements
+
+- Python 3.14 or later
+
+## Installation
+
+Once published to PyPI, install with:
+
+```bash
+python -m pip install TurtleExtension
+```
+
+## Usage
+
+```python
+import turtle
+
+# Your TurtleExtension functionality goes here.
+```
+
+The public API and usage examples will be documented as the project develops.
+
+## Development
+
+Clone the repository:
+
+```bash
+git clone https://github.com/YOUR-USERNAME/TurtleExtension.git
+cd TurtleExtension
+```
+
+Install the package locally if your project contains a `pyproject.toml`:
+
+```bash
+python -m pip install .
+```
+
+## License
+
+See the repository for licensing information.
+
+---
+
+*More turtle-powered functionality coming soon.* 🐢

turtleextension-1.0.0/TurtleExtension/Foundations/CustomTurtleShapes.py

@@ -0,0 +1,78 @@
+from ..TurtleHeart import tl
+from numbers import Real
+import UF as uf
+
+
+helper = uf.helper
+
+@uf.cls_deco_superposition(staticmethod)
+class UserShape:
+    def custom_circle():
+        radius: Real = uf.get_num(float, "Enter the radius: ")
+        tl.begin_poly()
+        tl.circle(radius)
+        tl.end_poly()
+        return tl.get_poly()
+
+    def custom_square():
+        length: Real = helper.length_float()
+        tl.begin_poly()
+
+        for _ in range(4):
+            tl.fd(length)
+            tl.lt(90)
+
+        tl.end_poly()
+        return tl.get_poly()
+
+    def custom_triangle():
+        length: Real = helper.length_float()
+        tl.begin_poly()
+
+        for _ in range(3):
+            tl.fd(length)
+            tl.lt(120)
+
+        tl.end_poly()
+        return tl.get_poly()
+
+    def custom_poly():
+        length: Real = helper.length_float()
+        sides: int = helper.sides_num()
+
+        radius = length / (2 * uf.sine(180 / sides))
+        angle_to_right = (180 - (180 * (sides - 2)) / sides) / 2
+        tl.begin_poly()
+
+        tl.rt(angle_to_right)
+        tl.circle(radius, 360, sides)
+        tl.lt(angle_to_right)
+
+        tl.end_poly()
+        return tl.get_poly()
+
+    def custom_SOD():
+        side: Real = helper.length_float()
+        tl.begin_poly()
+
+        for _ in range(6):
+            tl.pu(); tl.fd(side); tl.pd(); tl.rt(60)
+            for _ in range(3):
+                tl.fd(side); tl.rt(120)
+            tl.lt(60); tl.pu(); tl.bk(side); tl.pd(); tl.lt(60)
+
+        tl.end_poly()
+        return tl.get_poly()
+
+    @classmethod
+    def _list_shapes(cls):
+        return uf.classes_to_dict(cls)
+
+def get_UserShape_dict():
+    return {
+        f"cm {name.removeprefix('custom_')}": func
+        for name, func in UserShape._list_shapes().items()
+        if not name.startswith("_")
+    }
+
+CUSTOM_SHAPES = get_UserShape_dict()

turtleextension-1.0.0/TurtleExtension/Foundations/CustomTurtleShapes.pyi

@@ -0,0 +1,71 @@
+"""
+This module contains the class Usershape which contains functions to make a customized turtle shape.
+"""
+
+from numbers import Real
+from collections.abc import Callable, Sequence
+
+
+type return_shape = Sequence[tuple[Real,Real]] | None
+type user_shape_dict = dict[str, Callable[[], return_shape]]
+
+class UserShape:
+    """
+    This class contains different custom turtle shape maker functions
+    """
+    @staticmethod
+    def custom_circle() -> return_shape:
+        """
+        Creates a custom circle turtle shape.
+        :return: the custom shape
+        """
+        ...
+
+    @staticmethod
+    def custom_square() -> return_shape:
+        """
+        Creates a custom square turtle shape.
+        :return: the custom shape
+        """
+        ...
+
+    @staticmethod
+    def custom_triangle() -> return_shape:
+        """
+        Creates a custom equilateral triangle turtle shape.
+        :return: the custom shape
+        """
+        ...
+
+    @staticmethod
+    def custom_poly() -> return_shape:
+        """
+        Creates a custom regular polygon turtle shape.
+        :return: the custom shape
+        """
+        ...
+
+    @staticmethod
+    def custom_SOD() -> return_shape:
+        """
+        Creates a custom star of David turtle shape.
+        :return: the custom shape
+        """
+        ...
+
+    @classmethod
+    def _list_shapes(cls) -> user_shape_dict:
+        """
+        Creates a dictionary with the functions in UserShape and returns it
+        :return: dictionary containing function names -> function
+        """
+        ...
+
+def get_UserShape_dict() -> user_shape_dict:
+    """
+    Takes all custom turtle functions in UserShape and returns a dictionary with them
+    :return: dictionary mapping function names to functions
+    """
+    ...
+
+CUSTOM_SHAPES: user_shape_dict

turtleextension-1.0.0/TurtleExtension/Foundations/GlobalFunctions.py

@@ -0,0 +1,90 @@
+from ..TurtleHeart import tl, ChainTurtle
+from .GlobalVariables import t_shape, UV
+from turtle import TurtleGraphicsError
+from time import sleep as rest
+import UF as uf
+from typing import Final, Literal
+
+
+_screen = None
+
+def get_screen():
+    global _screen
+
+    if _screen is None:
+        _screen = tl.Screen()
+        _screen.getcanvas().winfo_toplevel().state("zoomed")
+        _screen.tracer(0)
+
+    return _screen
+
+def SU():
+    get_screen().update()
+
+def mainloop():
+    get_screen().mainloop()
+
+type turtle_list = list[ChainTurtle]
+
+def tls_color(**options):
+
+    tl_num_name: Final[Literal["tl_num"]] = "tl_num"
+    entry_name: Final[Literal["entry"]] = "entry"
+    index_name: Final[Literal["index"]] = "index"
+
+    if tl_num_name in options:
+        tl_num = options[tl_num_name]
+        uf.int_validate()(tl_num, tl_num_name)
+        uf.Positive()(tl_num, tl_num_name)
+        turtles_num_count = tl_num
+
+    elif entry_name in options:
+        entry = options[entry_name]
+        uf.str_validate()(entry, entry_name)
+        turtles_num_count = uf.get_num(int, entry, MIN=1)
+
+    elif index_name in options:
+        index = options[index_name]
+        uf.int_validate()(index, index_name)
+        uf.Positive()(index, index_name)
+        turtles_num_count = index
+    else:
+        print("NONE of the entered options exist!")
+        return None
+    tls: turtle_list = []
+
+    for color_num in range(turtles_num_count):
+        while True:
+            color_iteration: str = input(f"Enter turtle color {color_num + 1}: ")
+            try:
+                turtle: ChainTurtle = ChainTurtle().color(color_iteration).shape(t_shape())
+                if index_name in options:
+                    UV["tls"].append(turtle)
+                else:
+                    tls.append(turtle)
+                break
+
+            except TurtleGraphicsError:
+                print("Enter a VALID color!"); rest(2)
+
+    if index_name in options:
+        return len(UV["tls"]) - 1
+
+    elif entry_name in options:
+        return tls, turtles_num_count
+
+    elif tl_num_name in options:
+        return tls
+    return None
+
+
+def reset_tls(tls_list):
+
+    tls_list_name: Final[Literal["tls_list"]] = "tls_list"
+    uf.TypeValidate(list)(tls_list, name=tls_list_name)
+    uf.SequenceValidate(ChainTurtle, ...)(tls_list, name=tls_list_name)
+
+    for t in tls_list:
+        t.clear().ht()
+    tls_list.clear()
+    return tls_list

turtleextension-1.0.0/TurtleExtension/Foundations/GlobalFunctions.pyi

@@ -0,0 +1,53 @@
+"""
+This module contains a very useful function: tls_color, which lets the user create any number of turtles with
+colors and get a list with them.
+"""
+
+from ..TurtleHeart import tl, ChainTurtle
+
+
+def get_screen() -> tl.Screen:
+    """
+    Initiates the turtle screen when the function is called.
+    :return: turtle screen object
+    """
+    ...
+
+def SU() -> None:
+    """
+    This function updates the turtle screen.
+    :return: None
+    """
+    ...
+
+def mainloop() -> None:
+    """
+    This function keeps the turtle screen open.
+    :return: None
+    """
+    ...
+
+type turtle_list = list[ChainTurtle]
+
+def tls_color(**options) -> int | tuple[turtle_list, int] | turtle_list | None:
+    """This function creates a turtle list with their colors or adds newly creates turtles to the UV["tls"] list
+    to be used for the user_drawing_ft()
+
+    USERS NOTICE: it is HIGHLY recommended to NOT enter a turtles count of MORE than a few hundred (max. 200) unless required!!!
+
+    :param options: tl_num -> number of turtles to create, entry -> input string, index -> number of turtles to be created for user_drawing_ft()
+    & it returns the index of the last turtle
+    :return: tls_num: turtle list with colored turtles, entry: list with colored turtles + number of turtles ,otherwise: index of last turtle
+    """
+    ...
+
+def reset_tls(tls_list: turtle_list) -> list:
+    """
+    This function deletes the drawings of given turtle list + turtles
+
+    >>> tls = [ChainTurtle(), ChainTurtle()]
+    >>> reset_tls(tls)
+    []
+
+    :return: empty tls_list
+    """

turtleextension-1.0.0/TurtleExtension/Foundations/GlobalVariables.py

@@ -0,0 +1,14 @@
+# UV = UNIVERSAL VARIABLES
+UV = {
+    "delay": None,            # Delay for user_drawing_ft()
+      "t": 0,                   # user_drawing_ft's current turtle
+      "tls": [],                # user_drawing_ft's turtle list
+      "tls_shape": "arrow",     # user_drawing_ft's turtle's current shape
+      "shape_library": [],      # user_drawing_ft's turtle shapes list
+}
+def t_now():
+    return UV["tls"][UV["t"]]
+
+def t_shape():
+    return UV["tls_shape"]
+

turtleextension-1.0.0/TurtleExtension/Foundations/GlobalVariables.pyi

@@ -0,0 +1,40 @@
+"""
+This module contains a dictionary (UV) which contains important info about turtles and user_drawing_ft().
+
+Other functions:
+
+t_now() -> lets users take the current UV turtle
+
+t_shape() -> lets users take the current turtle shape
+"""
+
+from typing import Any
+from ..TurtleHeart import ChainTurtle
+
+
+UV: dict[str, Any]
+
+def t_now() -> ChainTurtle:
+    """
+    This function returns the current UV turtle
+
+    >>> turtle = ChainTurtle()
+    >>> UV["tls"].append(turtle)
+    >>> t_now()
+    ChainTurtle()
+
+    :return: ChainTurtle
+    """
+    ...
+
+def t_shape() -> str:
+    """
+    This function returns the current UV turtle shape
+
+    >>> UV['tls_shape'] = 'turtle'
+    >>> t_shape()
+    'turtle'
+
+    :return: string
+    """
+    ...

turtleextension-1.0.0/TurtleExtension/Foundations/TurtleFunctions.py

@@ -0,0 +1,55 @@
+from ..TurtleHeart import tl, ChainTurtle
+from .GlobalVariables import UV
+from .CustomTurtleShapes import CUSTOM_SHAPES
+import UF as uf
+
+
+class TurtleFct:
+    @classmethod
+    def change_shape(cls, tls_num = None):
+        if tls_num is not None:
+            uf.TypeValidate(ChainTurtle)(tls_num, name="tls_num")
+
+        turtle_shapes_list: list[str] = tl.getshapes()
+
+        user_shape: str = uf.get_str(f'''
+            Here are the options for the turtle shape:
+            {turtle_shapes_list}
+            custom -> custom turtle shapes
+            Enter choice: ''', turtle_shapes_list, "custom")
+
+        if user_shape in turtle_shapes_list:
+            if tls_num is not None:
+                tls_num.shape(user_shape)
+                return tls_num
+            else:
+                UV["tls_shape"] = user_shape
+                return user_shape
+        else:
+            if tls_num is not None:
+                return cls.user_tls_shape_ft(tls_num)
+            else:
+                return cls.user_tls_shape_ft()
+
+    @staticmethod
+    def user_tls_shape_ft(tls_num = None):
+        if tls_num is not None:
+            uf.TypeValidate(ChainTurtle)(tls_num, name="tls_num")
+
+        user_shape: str = uf.get_str(f'''
+            Here are some custom options:
+            {CUSTOM_SHAPES.keys()}
+            Enter choice: 
+            ''', CUSTOM_SHAPES)
+        tl.home()
+        shape_made = CUSTOM_SHAPES[user_shape]()
+        tl.addshape(user_shape, shape_made)
+        tl.clear()
+        tl.ht()
+
+        if tls_num is not None:
+            tls_num.shape(user_shape)
+            return tls_num
+        else:
+            UV["tls_shape"] = user_shape
+            return user_shape

turtleextension-1.0.0/TurtleExtension/Foundations/TurtleFunctions.pyi

@@ -0,0 +1,28 @@
+"""
+This module contains the class TurtleFct which lets the user change the turtle shape to a customized one.
+"""
+
+from ..TurtleHeart import ChainTurtle
+
+
+class TurtleFct:
+    """
+    This class contains a function that lets users change the shape of the turtles that will be created in the future with tls_color.
+    """
+    @classmethod
+    def change_shape(cls, tls_num: ChainTurtle|None = None) -> ChainTurtle | str:
+        """
+        This function lets the user choose different turtles shapes, including a custom option.
+        :param tls_num: ChainTurtle() or None
+        :return: ChainTurtle() if tls_num is a ChainTurtle(), otherwise None
+        """
+        ...
+
+    @staticmethod
+    def user_tls_shape_ft(tls_num: ChainTurtle | None = None) -> ChainTurtle | str:
+        """
+        This function lets the user create custom turtle shapes.
+        :param tls_num: ChainTurtle() or None
+        :return: ChainTurtle() if tls_num is a ChainTurtle(), otherwise None
+        """
+        ...

turtleextension-1.0.0/TurtleExtension/Foundations/__init__.py

@@ -0,0 +1,41 @@
+from .GlobalVariables import (
+    UV,
+    t_now,
+    t_shape,
+)
+
+from .GlobalFunctions import (
+    get_screen,
+    SU,
+    mainloop,
+    tls_color,
+    reset_tls,
+)
+
+from .CustomTurtleShapes import (
+    UserShape,
+    get_UserShape_dict,
+    CUSTOM_SHAPES,
+)
+
+from .TurtleFunctions import (
+TurtleFct,
+)
+
+__all__ = [
+    "UV",
+    "t_now",
+    "t_shape",
+
+    "get_screen",
+    "SU",
+    "mainloop",
+    "tls_color",
+    "reset_tls",
+
+    "UserShape",
+    "get_UserShape_dict",
+    "CUSTOM_SHAPES",
+
+    "TurtleFct",
+]

turtleextension-1.0.0/TurtleExtension/TurtleHeart/TurtleSkeleton.py

@@ -0,0 +1,100 @@
+import turtle as tl
+import UF as uf
+
+
+class ChainTurtle(tl.Turtle):
+    def fd(self, distance):
+        super().fd(distance)
+        return self
+
+    def fd_inv(self,distance):
+        self.pu().fd(distance).pd()
+        return self
+
+    def bk(self, distance):
+        super().bk(distance)
+        return self
+
+    def bk_inv(self,distance):
+        self.pu().bk(distance).pd()
+        return self
+
+    def rt(self, angle):
+        super().rt(angle)
+        return self
+
+    def lt(self, angle):
+        super().lt(angle)
+        return self
+
+    def setpos(self, x_val, y_val):
+        super().setpos(x_val, y_val)
+        return self
+
+    def pu(self):
+        super().pu()
+        return self
+
+    def pd(self):
+        super().pd()
+        return self
+
+    def seth(self, direction):
+        super().seth(direction)
+        return self
+
+    def home(self):
+        super().home()
+        return self
+
+    def home_inv(self):
+        self.pu().home().pd()
+        return self
+
+    def begin_fill(self):
+        super().begin_fill()
+        return self
+
+    def end_fill(self):
+        super().end_fill()
+        return self
+
+    def circle(self, radius, extent=None, steps=None):
+        super().circle(radius, extent, steps)
+        return self
+
+    def circle_fill(self,radius,angle=None,sides=None):
+        self.begin_fill().circle(radius,angle,sides).end_fill()
+        return self
+
+    def dot(self, radius):
+        self.begin_fill().circle(radius).end_fill()
+        return self
+
+    def color(self, turtle_color):
+        super().color(turtle_color)
+        return self
+
+    def teleport(self, x, y, *, fill_gap: bool=False):
+        super().teleport(x,y)
+        return self
+
+    def shape(self, shape_name):
+        super().shape(shape_name)
+        return self
+
+    def undo(self):
+        super().undo()
+        return self
+
+    def clear(self):
+        super().clear()
+        return self
+
+    def ht(self):
+        super().ht()
+        return self
+
+    @classmethod
+    def list_methods(cls):
+        return uf.classes_to_dict(cls)

turtleextension-1.0.0/TurtleExtension/TurtleHeart/TurtleSkeleton.pyi

@@ -0,0 +1,200 @@
+"""
+This module contains the class ChainTurtle() which is the foundational object around which this entire software has been made.
+"""
+
+from numbers import Real
+from collections.abc import Callable
+
+
+tl = tl
+
+class ChainTurtle:
+    """This class adds chaining functionality to turtle.Turtle"""
+    def fd(self, distance: Real) -> ChainTurtle:
+        """
+        Makes the turtle go forward with trace.
+        :param distance: distance in pixels
+        :return: ChainTurtle()
+        """
+        ...
+
+    def fd_inv(self, distance: Real) -> ChainTurtle:
+        """
+        Makes the turtle go forward with no trace.
+        :param distance: distance in pixels
+        :return: ChainTurtle()
+        """
+        ...
+
+    def bk(self, distance: Real) -> ChainTurtle:
+        """
+        Makes the turtle go backwards with trace.
+        :param distance: distance in pixels
+        :return: ChainTurtle()
+        """
+        ...
+
+    def bk_inv(self, distance: Real) -> ChainTurtle:
+        """
+        Makes the turtle go backward with no trace.
+        :param distance: distance in pixels
+        :return: ChainTurtle()
+        """
+        ...
+
+    def rt(self, angle: Real) -> ChainTurtle:
+        """
+        Makes the turtle turn right.
+        :param angle: angle in degrees
+        :return: ChainTurtle()
+        """
+        ...
+
+    def lt(self, angle: Real) -> ChainTurtle:
+        """
+        Makes the turtle turn left.
+        :param angle: angle in degrees
+        :return: ChainTurtle()
+        """
+        ...
+
+    def setpos(self, x_val: Real, y_val: Real) -> ChainTurtle:
+        """
+        Makes the turtle go to a specific position with a trace.
+        :param x_val: x position in pixels
+        :param y_val: y position in pixels
+        :return: ChainTurtle()
+        """
+        ...
+
+    def pu(self) -> ChainTurtle:
+        """
+        Puts the pen down to leave a trace.
+        :return: ChainTurtle()
+        """
+        ...
+
+    def pd(self) -> ChainTurtle:
+        """
+        Puts the pen up to not leave a trace.
+        :return: ChainTurtle()
+        """
+        ...
+
+    def seth(self, direction: Real) -> ChainTurtle:
+        """
+        Sets the direction of the turtle starting East, going counterclockwise.
+        :param direction: direction in degrees
+        """
+        ...
+
+    def home(self) -> ChainTurtle:
+        """
+        Sets the position of the turtle to home (0, 0) with trace, heading = 0 .
+        :return: ChainTurtle()
+        """
+        ...
+
+    def home_inv(self) -> ChainTurtle:
+        """
+        Sets the position of the turtle to home (0, 0) without trace, heading = 0 .
+        :return: ChainTurtle()
+        """
+        ...
+
+    def begin_fill(self) -> ChainTurtle:
+        """
+        Makes the turtle begin fill for a closed shape.
+        :return: ChainTurtle()
+        """
+        ...
+
+    def end_fill(self) -> ChainTurtle:
+        """
+        Ends the turtle fill for a closed shape, therefore fills the shapes.
+        :return: ChainTurtle()
+        """
+        ...
+
+    def circle(self,
+               radius: Real,
+               extent: Real | None = None,
+               steps: int = None) -> ChainTurtle:
+        """
+        Makes the turtle draw a circle
+        :param radius: radius in pixels
+        :param extent: extent in degrees
+        :param steps: number of sides
+        :return: ChainTurtle()
+        """
+        ...
+
+    def circle_fill(self,
+                    radius: Real,
+                    angle: Real | None = None,
+                    sides: int = None) -> ChainTurtle:
+        """
+        Makes the turtle draw a circle and fills it
+        :param radius: radius in degrees
+        :param angle: angle in degrees
+        :param sides: number of sides
+        """
+        ...
+
+    def dot(self, radius: Real) -> ChainTurtle:
+        """
+        Makes the turtle draw a colored dot
+        :param radius: radius in pixels
+        """
+        ...
+
+    def color(self, turtle_color: str) -> ChainTurtle:
+        """
+        Lets the user change the color of the turtle trace and turtle color itself
+        :param turtle_color: valid turtle color
+        """
+        ...
+
+    def teleport(self, x: Real, y: Real, *, fill_gap: bool = False) -> ChainTurtle:
+        """
+        Makes the turtle to go a specific coordinate with no trace
+        :param x: x position in pixels
+        :param y: y position in pixels
+        """
+        ...
+
+    def shape(self, shape_name: str) -> ChainTurtle:
+        """
+        Changes the shape of the turtle shape
+        :param shape_name: name of the shape
+        """
+        ...
+
+    def undo(self) -> ChainTurtle:
+        """
+        Undoes the last turtle command.
+        :return: ChainTurtle()
+        """
+        ...
+
+    def clear(self) -> ChainTurtle:
+        """
+        Deletes the turtles drawings.
+        :return: ChainTurtle()
+        """
+        ...
+
+    def ht(self) -> ChainTurtle:
+        """
+        Hides the turtle.
+        :return: ChainTurtle()
+        """
+        ...
+
+    @classmethod
+    def list_methods(cls) -> dict[str, Callable]:
+        """
+        Creates a dictionary with all ChainTurtle methods and returns it
+        :return: dictionary
+        """
+        ...

turtleextension-1.0.0/TurtleExtension/TurtleHeart/__init__.py

@@ -0,0 +1,6 @@
+from .TurtleSkeleton import ChainTurtle, tl
+
+__all__ = [
+    "ChainTurtle",
+    "tl",
+]

turtleextension-1.0.0/TurtleExtension/__init__.py

@@ -0,0 +1,58 @@
+"""
+This package is part of the GeometricalDomination project ecosystem.
+
+It contains a chainable turtle class called ChainTurtle and a collection of extra provided features along with it:
+
+1. tls_color -> this function make a list of colored turtles and returns it
+2. get_screen -> turtle screen initializer function
+3. SU -> screen update function
+
+And a lot more.
+
+Author: Miah M. Sabiq
+"""
+
+from .Foundations import (
+   UV,
+   t_now,
+   t_shape,
+
+   get_screen,
+   SU,
+   mainloop,
+   tls_color,
+   reset_tls,
+
+   UserShape,
+   get_UserShape_dict,
+   CUSTOM_SHAPES,
+
+   TurtleFct,
+)
+
+from .TurtleHeart import (
+ChainTurtle,
+tl,
+)
+
+__all__ = [
+    "UV",
+    "t_now",
+    "t_shape",
+
+    "get_screen",
+    "SU",
+    "mainloop",
+    "tls_color",
+    "reset_tls",
+
+    "UserShape",
+    "get_UserShape_dict",
+    "CUSTOM_SHAPES",
+
+    "TurtleFct",
+
+
+   "ChainTurtle",
+   "tl",
+]

turtleextension-1.0.0/TurtleExtension.egg-info/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: TurtleExtension
+Version: 1.0.0
+Summary: A Python utility library providing turtle extensions on top of Python's original turtle feature.
+Author-email: "Miah M. Sabiq" <miah.sabiq@gibs.at>
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: UniversalFunctions>=2.7.0
+Dynamic: license-file
+
+# TurtleExtension
+
+**Extend Python's turtle graphics with your own tools and functionality.**
+
+TurtleExtension is a Python project dedicated to extending and experimenting with turtle graphics.
+
+## Features
+
+- Built around Python's `turtle` graphics module.
+- Designed for reusable extensions and custom drawing functionality.
+- A foundation for experimenting with geometric designs and turtle-based programming.
+
+## Requirements
+
+- Python 3.14 or later
+
+## Installation
+
+Once published to PyPI, install with:
+
+```bash
+python -m pip install TurtleExtension
+```
+
+## Usage
+
+```python
+import turtle
+
+# Your TurtleExtension functionality goes here.
+```
+
+The public API and usage examples will be documented as the project develops.
+
+## Development
+
+Clone the repository:
+
+```bash
+git clone https://github.com/YOUR-USERNAME/TurtleExtension.git
+cd TurtleExtension
+```
+
+Install the package locally if your project contains a `pyproject.toml`:
+
+```bash
+python -m pip install .
+```
+
+## License
+
+See the repository for licensing information.
+
+---
+
+*More turtle-powered functionality coming soon.* 🐢

turtleextension-1.0.0/TurtleExtension.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+LICENSE
+README.md
+pyproject.toml
+TurtleExtension/__init__.py
+TurtleExtension.egg-info/PKG-INFO
+TurtleExtension.egg-info/SOURCES.txt
+TurtleExtension.egg-info/dependency_links.txt
+TurtleExtension.egg-info/requires.txt
+TurtleExtension.egg-info/top_level.txt
+TurtleExtension/Foundations/CustomTurtleShapes.py
+TurtleExtension/Foundations/CustomTurtleShapes.pyi
+TurtleExtension/Foundations/GlobalFunctions.py
+TurtleExtension/Foundations/GlobalFunctions.pyi
+TurtleExtension/Foundations/GlobalVariables.py
+TurtleExtension/Foundations/GlobalVariables.pyi
+TurtleExtension/Foundations/TurtleFunctions.py
+TurtleExtension/Foundations/TurtleFunctions.pyi
+TurtleExtension/Foundations/__init__.py
+TurtleExtension/TurtleHeart/TurtleSkeleton.py
+TurtleExtension/TurtleHeart/TurtleSkeleton.pyi
+TurtleExtension/TurtleHeart/__init__.py

turtleextension-1.0.0/TurtleExtension.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

turtleextension-1.0.0/TurtleExtension.egg-info/requires.txt

@@ -0,0 +1 @@
+UniversalFunctions>=2.7.0

turtleextension-1.0.0/TurtleExtension.egg-info/top_level.txt

@@ -0,0 +1 @@
+TurtleExtension

turtleextension-1.0.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "TurtleExtension"
+version = "1.0.0"
+description = "A Python utility library providing turtle extensions on top of Python's original turtle feature."
+readme = "README.md"
+requires-python = ">= 3.14"
+
+dependencies = [
+    "UniversalFunctions>=2.7.0",
+]
+
+authors = [
+    { name = "Miah M. Sabiq", email = "miah.sabiq@gibs.at"}
+]
+
+[tool.setuptools.packages.find]
+include = [
+    "TurtleExtension*",
+]

turtleextension-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+