GeometricalDomination 0.1.0__tar.gz

geometricaldomination-0.1.0/GeometricalDomination.egg-info/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: GeometricalDomination
+Version: 0.1.0
+Summary: A Python turtle graphics library and DSL for creating geometric drawings.
+Author-email: "Miah M. Sabiq" <miah.sabiq@gibs.at>
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+
+# GeometricalDomination
+
+A Python turtle graphics library and DSL for creating drawings, patterns, shapes, and other geometric designs.
+
+## What is GeometricalDomination?
+
+GeometricalDomination is a personal Python project built around Python's `turtle` module.
+
+It provides a collection of tools for controlling turtles, creating geometric patterns, drawing letters and symbols, defining custom commands, and simplifying repetitive turtle operations.
+
+The project is structured as a Python package and is currently being prepared for distribution through `pip`.
+
+> **Please note:** This package is still under active development and is subject to ongoing updates and changes.
+>
+> The package currently installs successfully, but importing it may fail due to internal import issues that are still being addressed.
+
+## Features
+
+* Chained turtle commands through `ChainTurtle`
+* Geometric shapes and patterns
+* Alphabet and symbol drawing
+* Custom turtle shapes
+* User-defined drawing commands
+* Utility and validation functions
+* Reusable decorators
+* Support for multiple turtles
+* Tools for creating complex turtle-based drawings
+
+## Installation
+
+For local development, the package can currently be installed with:
+
+```bash
+python -m pip install .
+```
+
+PyPI installation will be available once the project is published.
+
+## Project Structure
+
+The main components of the project include:
+
+* `TurtleRunner` — main program entry point
+* `TurtleSkeleton` — extended turtle functionality
+* `Designs` — geometric designs and patterns
+* `Alphabets` — letter and symbol drawing
+* `UserCommands` — user-oriented drawing commands
+* `CustomTurtleShapes` — custom turtle shapes
+* `GlobalFunctions` — shared turtle and screen functionality
+* `UniversalFunctions` — reusable helper and utility functions
+
+## Requirements
+
+* Python 3.14 or newer
+* Python's built-in `turtle` module
+
+No external Python packages are currently required.
+
+## Project Status
+
+GeometricalDomination is under active development.
+
+The core functionality has been implemented, while packaging, documentation, testing, and the project's import system are still being developed.
+
+## License
+
+License information will be added in a future release.

geometricaldomination-0.1.0/GeometricalDomination.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+GeometricalDomination.egg-info/PKG-INFO
+GeometricalDomination.egg-info/SOURCES.txt
+GeometricalDomination.egg-info/dependency_links.txt
+GeometricalDomination.egg-info/top_level.txt
+UniversalFunctions2/DecoratorArchive.py
+UniversalFunctions2/GetVariable.py
+UniversalFunctions2/HelperFunctions.py
+UniversalFunctions2/RepeatlessList.py
+UniversalFunctions2/Shapes.py
+UniversalFunctions2/StringCheck.py
+UniversalFunctions2/TypingVariables.py
+UniversalFunctions2/__init__.py

geometricaldomination-0.1.0/GeometricalDomination.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

geometricaldomination-0.1.0/GeometricalDomination.egg-info/top_level.txt

@@ -0,0 +1 @@
+UniversalFunctions2

geometricaldomination-0.1.0/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: GeometricalDomination
+Version: 0.1.0
+Summary: A Python turtle graphics library and DSL for creating geometric drawings.
+Author-email: "Miah M. Sabiq" <miah.sabiq@gibs.at>
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+
+# GeometricalDomination
+
+A Python turtle graphics library and DSL for creating drawings, patterns, shapes, and other geometric designs.
+
+## What is GeometricalDomination?
+
+GeometricalDomination is a personal Python project built around Python's `turtle` module.
+
+It provides a collection of tools for controlling turtles, creating geometric patterns, drawing letters and symbols, defining custom commands, and simplifying repetitive turtle operations.
+
+The project is structured as a Python package and is currently being prepared for distribution through `pip`.
+
+> **Please note:** This package is still under active development and is subject to ongoing updates and changes.
+>
+> The package currently installs successfully, but importing it may fail due to internal import issues that are still being addressed.
+
+## Features
+
+* Chained turtle commands through `ChainTurtle`
+* Geometric shapes and patterns
+* Alphabet and symbol drawing
+* Custom turtle shapes
+* User-defined drawing commands
+* Utility and validation functions
+* Reusable decorators
+* Support for multiple turtles
+* Tools for creating complex turtle-based drawings
+
+## Installation
+
+For local development, the package can currently be installed with:
+
+```bash
+python -m pip install .
+```
+
+PyPI installation will be available once the project is published.
+
+## Project Structure
+
+The main components of the project include:
+
+* `TurtleRunner` — main program entry point
+* `TurtleSkeleton` — extended turtle functionality
+* `Designs` — geometric designs and patterns
+* `Alphabets` — letter and symbol drawing
+* `UserCommands` — user-oriented drawing commands
+* `CustomTurtleShapes` — custom turtle shapes
+* `GlobalFunctions` — shared turtle and screen functionality
+* `UniversalFunctions` — reusable helper and utility functions
+
+## Requirements
+
+* Python 3.14 or newer
+* Python's built-in `turtle` module
+
+No external Python packages are currently required.
+
+## Project Status
+
+GeometricalDomination is under active development.
+
+The core functionality has been implemented, while packaging, documentation, testing, and the project's import system are still being developed.
+
+## License
+
+License information will be added in a future release.

geometricaldomination-0.1.0/README.md

@@ -0,0 +1,67 @@
+# GeometricalDomination
+
+A Python turtle graphics library and DSL for creating drawings, patterns, shapes, and other geometric designs.
+
+## What is GeometricalDomination?
+
+GeometricalDomination is a personal Python project built around Python's `turtle` module.
+
+It provides a collection of tools for controlling turtles, creating geometric patterns, drawing letters and symbols, defining custom commands, and simplifying repetitive turtle operations.
+
+The project is structured as a Python package and is currently being prepared for distribution through `pip`.
+
+> **Please note:** This package is still under active development and is subject to ongoing updates and changes.
+>
+> The package currently installs successfully, but importing it may fail due to internal import issues that are still being addressed.
+
+## Features
+
+* Chained turtle commands through `ChainTurtle`
+* Geometric shapes and patterns
+* Alphabet and symbol drawing
+* Custom turtle shapes
+* User-defined drawing commands
+* Utility and validation functions
+* Reusable decorators
+* Support for multiple turtles
+* Tools for creating complex turtle-based drawings
+
+## Installation
+
+For local development, the package can currently be installed with:
+
+```bash
+python -m pip install .
+```
+
+PyPI installation will be available once the project is published.
+
+## Project Structure
+
+The main components of the project include:
+
+* `TurtleRunner` — main program entry point
+* `TurtleSkeleton` — extended turtle functionality
+* `Designs` — geometric designs and patterns
+* `Alphabets` — letter and symbol drawing
+* `UserCommands` — user-oriented drawing commands
+* `CustomTurtleShapes` — custom turtle shapes
+* `GlobalFunctions` — shared turtle and screen functionality
+* `UniversalFunctions` — reusable helper and utility functions
+
+## Requirements
+
+* Python 3.14 or newer
+* Python's built-in `turtle` module
+
+No external Python packages are currently required.
+
+## Project Status
+
+GeometricalDomination is under active development.
+
+The core functionality has been implemented, while packaging, documentation, testing, and the project's import system are still being developed.
+
+## License
+
+License information will be added in a future release.

geometricaldomination-0.1.0/UniversalFunctions2/DecoratorArchive.py

@@ -0,0 +1,15 @@
+from typing import Callable
+
+
+def class_decorator(decorator: Callable) -> Callable:
+    """
+    DECORATOR!!   Creates a class decorator that applies the given decorator to every user defined function
+    :param decorator: provided decorator function
+    :return: a class decorator that transforms the class (& it's functions) and returns it
+    """
+    def inner(cls):
+        for name, func in vars(cls).items():
+            if callable(func) and not name.startswith("_"):
+                setattr(cls, name, decorator(func))
+        return cls
+    return inner

geometricaldomination-0.1.0/UniversalFunctions2/GetVariable.py

@@ -0,0 +1,95 @@
+from time import sleep as rest
+from typing import overload
+
+
+@overload
+def get_num(TYPE: type[int], entry: str, **options) -> int: ...
+
+@overload
+def get_num(TYPE: type[float], entry: str, **options) -> float: ...
+
+def get_num(TYPE: type[float]|type[int], entry: str, **options) -> float|int:
+    """
+    Gets a real numerical value from the user
+
+    :param TYPE: float or int;  which type of value to check for
+    :param entry: str; input string
+    :param options: MAX, MIN, STORE
+    :return: float or int
+    """
+    if TYPE not in (int, float):
+        raise TypeError("TYPE must be type float or int")
+
+    elif not isinstance(entry, str):
+        raise TypeError("entry must be a string")
+
+    if "MIN" in options:
+        if not isinstance(options["MIN"], (float, int)):
+            raise TypeError("MIN must be type float or int")
+
+    if "MAX" in options:
+        if not isinstance(options["MAX"], (float, int)):
+            raise TypeError("MAX must be type float or int")
+
+    if "MIN" in options and "MAX" in options:
+        if options["MIN"] >= options["MAX"]:
+            raise ValueError("MIN has to be less than MAX!")
+
+    if "store" in options:
+        if not isinstance(options["store"], (float, int, type(None))):
+            raise TypeError("store must be type float or int or None!")
+        if not isinstance(options["store"], (TYPE, type(None))):
+            raise TypeError(f"store must be type {TYPE} or None!")
+
+    if (
+        "store" in options
+        and "MIN" in options
+        and "MAX" in options
+        and options["store"] is not None
+        and (options["MIN"] > options["store"] or options["MAX"] < options["store"])
+    ):
+        raise ValueError("Stored value must be between MIN and MAX!")
+    #if "store" and "MIN" and "MAX" in options and options["MIN"] > options["store"] or options["store"] > options["MAX"]:
+    #    raise ValueError("stored value in store must be: min <= store <= max!")
+
+    while True:
+        try:
+            if "store" in options:
+                reserve: str = input(entry)
+                if reserve == "ans":
+                    if options["store"] is not None and isinstance(options["store"], (float,int)):
+                        value: float|int = options["store"]
+                    else:
+                        print("\nThere is no value stored yet!")
+                        continue
+                else:
+                    value: float|int = TYPE(reserve)
+            else:
+                value: float|int = TYPE(input(entry))
+            if "MIN" in options and "MAX" in options and (value < options["MIN"] or value > options["MAX"]):
+                if TYPE == int:
+                    print(f"INTEGER must be between {options['MIN']} and {options['MAX']}!")
+                elif TYPE == float:
+                    print(f"RATIONAL NUMBER must be between {options['MIN']} and {options['MAX']}!")
+                rest(1.5); continue
+            elif "MIN" in options and value < options["MIN"]:
+                if TYPE == int:
+                    print(f"Enter INTEGER > {options['MIN']}!")
+                elif TYPE == float:
+                    print(f"Enter RATIONAL NUMBER > {options['MIN']}!")
+                rest(1.5); continue
+            elif "MAX" in options and value > options['MAX']:
+                if TYPE == int:
+                    print(f"Enter INTEGER < {options['MAX']}!")
+                elif TYPE == float:
+                    print(f"Enter RATIONAL NUMBER < {options['MAX']}!")
+                rest(1.5); continue
+            elif "store" in options:
+                options["store"] = value
+            return value
+        except ValueError:
+            if TYPE == int:
+                print(f"Enter INTEGER!")
+            elif TYPE == float:
+                print("Enter RATIONAL NUMBER!")
+            rest(1.5)

geometricaldomination-0.1.0/UniversalFunctions2/HelperFunctions.py

@@ -0,0 +1,93 @@
+from typing import Generator, Any, Annotated
+from math import sqrt, sin, radians
+from UniversalFunctions.GetVariable import get_num
+from UniversalFunctions.DecoratorArchive import class_decorator
+from UniversalFunctions.TypingVariables import Real
+
+
+@class_decorator(staticmethod)
+class HelperFunctions:
+
+    def intervals_f() -> Real:
+        """Asks the user for rational intervals"""
+        interval_num: float = get_num(float, "Enter intervals(ℚ>0): ", MIN=0)
+        return interval_num
+
+    def length_float() -> Real:
+        """Asks the user for rational lengths"""
+        length: float = get_num(float, "Enter side length(ℚ>0): ", MIN=0)
+        return length
+
+    def radius_float() -> Real:
+        """Asks the user for rational radius"""
+        radius: float = get_num(float, "Enter radius(ℚ>0): ", MIN=0)
+        return radius
+
+    def object_num() -> int:
+        """Asks the user for the number of objects"""
+        object_count: int = get_num(int, "Enter object count(ℕ≥1): ", MIN=1)
+        return object_count
+
+    def sides_num() -> int:
+        """Asks the user for the number of sides"""
+        sides: int = get_num(int, "Enter sides count(ℕ≥3): ", MIN=3)
+        return sides
+
+    def row_num() -> int:
+        """Asks the user for the number of rows"""
+        row_count: int = get_num(int, "Enter row count(ℕ≥1): ", MIN=1)
+        return row_count
+
+    def row_pair() -> int:
+        """Asks the user for the number of pairs of rows"""
+        row_count: int = get_num(int, "Enter row pairs count(ℕ≥1): ", MIN=1)
+        return row_count
+
+    def diameter_sq(length: Real) -> tuple[Real,Real]:
+        """
+        Calculates the diameter of a square with given length
+        :return: diameter, diameter/2
+        """
+        if not isinstance(length, Real):
+            raise TypeError("Length must be a real number")
+        if length <= 0:
+            raise ValueError("Length must be greater than 0")
+
+        diameter: float = length*sqrt(2); d_half: Real = diameter / 2
+        return diameter, d_half
+
+    def x_ft() -> Real:
+        """Asks the user for the x value (on the coordinate system)"""
+        x_val: float = get_num(float, "Enter x value: ")
+        return x_val
+
+    def y_ft() -> Real:
+        """Asks the user for the y value (on the coordinate system)"""
+        y_val: float = get_num(float, "Enter y value: ")
+        return y_val
+helper = HelperFunctions
+
+def sine(angle: Real) -> Real:
+    """
+    Calculates the sine of a given angle
+    :param angle: value required in degrees
+    """
+    if not isinstance(angle, Real):
+        raise TypeError("Angle must be a real number")
+    return sin(radians(angle))
+
+def range_f(start: Real,stop: Annotated[Real, "stop >= start"],step: Annotated[Real, "step > 0"]) -> Generator[Real,Any,None]:
+    """
+    Lets the user choose rational inputs for start, stop and step
+    :param start: start value; Real number
+    :param stop: stop value; Real number >= start
+    :param step: step value; Real number > 0
+    """
+    if stop < start:
+        raise ValueError("Stop value must be greater than start value")
+    elif step <= 0:
+        raise ValueError("Step value must be greater than 0")
+
+    while start < stop:
+        yield start
+        start += step

geometricaldomination-0.1.0/UniversalFunctions2/RepeatlessList.py

@@ -0,0 +1,26 @@
+from typing import Any
+
+
+def repeatless_list(old_list: list[Any], new_list: list[Any]) -> list[Any]:
+    """
+    Takes the 1st list and adds the items to the 2nd list, with no repetitions in the 2nd list
+    :param old_list: 1st list
+    :param new_list: 2nd list
+    :return: 2nd list
+    """
+    for item in old_list:
+        if item not in new_list:
+            new_list.append(item)
+    return new_list
+
+def repeatless_list2(old_list: list[Any]) -> list[Any]:
+    """
+    Takes the items from a list and adds its items to a new made list, with no repetitions in the new list
+    :param old_list: 1st list
+    :return: 2nd list
+    """
+    new_list: list[Any] = []
+    for item in old_list:
+        if item not in new_list:
+            new_list.append(item)
+    return new_list

geometricaldomination-0.1.0/UniversalFunctions2/Shapes.py

@@ -0,0 +1,191 @@
+from typing import Literal
+from GeometricalDomination.TurtleSkeleton import ChainTurtle
+from UniversalFunctions.HelperFunctions import sine
+from UniversalFunctions.DecoratorArchive import class_decorator
+from UniversalFunctions.TypingVariables import Real
+
+
+@class_decorator(staticmethod)
+class Shapes:
+# ====== STAR OF DAVID ======
+    def SOD(side: Real,tls_num: ChainTurtle) -> None:
+        """
+        Draws a star of David
+        :param side: length of star of David
+        :param tls_num: a given ChainTurtle
+        """
+        for _ in range(6):
+            tls_num.pu().fd(side).pd().rt(60)
+            for _ in range(3): tls_num.fd(side).rt(120)
+            tls_num.lt(60).pu().bk(side).pd().lt(60)
+# ====== STAR OF DAVID FILL ======
+    def SOD_fill(side: Real,tls_num: ChainTurtle) -> None:
+        """
+        Draws a filled star of David
+        :param side: length of star of David
+        :param tls_num: a given ChainTurtle
+        """
+        for _ in range(6):
+            tls_num.pu().fd(side).pd().rt(60).begin_fill()
+            for _ in range(3): tls_num.fd(side).rt(120)
+            tls_num.end_fill().lt(60).pu().bk(side).pd().lt(60)
+# ====== HEXAGON ======
+    def hexagon_ft(side: Real,tls_num: ChainTurtle) -> None:
+        """
+        Draws a hexagon
+        :param side: length of hexagon
+        :param tls_num: a given ChainTurtle
+        """
+        tls_num.pu().fd(side).pd().lt(90).circle(side,360,6)
+# ====== TRIANGLE ======
+    def triangle_ft(side: Real, tls_num: ChainTurtle) -> None:
+        """
+        Draws a triangle
+        :param side: length of triangle
+        :param tls_num: a given ChainTurtle
+        """
+        for _ in range(3): tls_num.fd(side).lt(120)
+
+    def triangle_fill(side: Real,tls_num: ChainTurtle) -> None:
+        """
+        Draws a filled triangle
+        :param side: length of triangle
+        :param tls_num: a given ChainTurtle
+        """
+        tls_num.begin_fill(); Shapes.triangle_ft(side,tls_num); tls_num.end_fill()
+
+    def triangle_half(side: Real, tls_num: ChainTurtle) -> None:
+        """
+        Draws a triangle from the middle of a side
+        :param side: length of triangle
+        :param tls_num: a given ChainTurtle
+        """
+        tls_num.fd(side/2).lt(120)
+        for _ in range(2): tls_num.fd(side).lt(120)
+        tls_num.fd(side/2)
+# ====== SQUARE ======
+    def square(side: Real,tls_num: ChainTurtle) -> None:
+        """
+        Draws a square
+        :param side: length of square
+        :param tls_num: a given ChainTurtle
+        """
+        for _ in range(4): tls_num.fd(side).lt(90)
+
+    def square_fill(side: Real,tls_num: ChainTurtle) -> None:
+        """
+        Draws a filled square
+        :param side: length of square
+        :param tls_num: a given ChainTurtle
+        """
+        tls_num.begin_fill(); Shapes.square(side,tls_num); tls_num.end_fill()
+
+    def square_half(side: Real,tls_num: ChainTurtle) -> None:
+        """
+        Draws a square from the middle of a side
+        :param side: length of square
+        :param tls_num: a given ChainTurtle
+        """
+        tls_num.fd(side/2).lt(90)
+        for _ in range(3): tls_num.fd(side).lt(90)
+        tls_num.fd(side/2)
+# ====== RECTANGLE ======
+
+    def rectangle(length: Real,width: Real,direction: Literal[-1,1],tls_num: ChainTurtle) -> None:
+        """
+        Draws a rectangle
+        :param length: longer side
+        :param width: shorter side
+        :param direction: -1 draws to the right, 1 draws to the left
+        :param tls_num: a given ChainTurtle
+        """
+        turn = direction * 90
+        for _ in range(2): tls_num.fd(length).lt(turn).fd(width).lt(turn)
+
+    def rectangle_fill(length: Real,width: Real,direction: Literal[-1,1],tls_num: ChainTurtle) -> None:
+        """
+        Draws a filled rectangle
+        :param length: longer side
+        :param width: shorter side
+        :param direction: -1 draws to the right, 1 draws to the left
+        :param tls_num: a given ChainTurtle
+        """
+        tls_num.begin_fill(); Shapes.rectangle(length,width,direction,tls_num); tls_num.end_fill()
+# ====== HEXAFLOWER ======
+
+    def hexaflower_tri(length: Real,tls_num: ChainTurtle) -> None:
+        """
+        Draws a 12 triangled flower
+        :param length: side length of triangles
+        :param tls_num: a given ChainTurtle
+        """
+        diagonal = (length*sine(120))/sine(30)
+        for _ in range(6):
+            tls_num.fd(diagonal).lt(150).fd(length).rt(120).bk(length)
+            tls_num.fd(length).lt(60).fd(length).rt(30).bk(diagonal)
+
+    def hexa_flower(radius: Real,tls_num: ChainTurtle) -> None:
+        """
+        Draws a 6 petalled flower
+        :param radius: radius of flower
+        :param tls_num: a given ChainTurtle
+        """
+        for _ in range(6): tls_num.circle(-radius,60).rt(120).circle(-radius,60).rt(60)
+# ====== LOTUS FLOWER ======
+
+    def lotus_flower(radius: Real,tls_num: ChainTurtle) -> None:
+        """
+        Draws a 12 petalled flower
+        :param radius: radius of flower
+        :param tls_num: a given ChainTurtle
+        """
+        for n in range(2): Shapes.hexa_flower(radius,tls_num); tls_num.lt((-1)**n*30)
+# ====== LINES ======
+
+    def lines(distance: Real,lines_num: int,tls_num: ChainTurtle) -> None:
+        """
+        Draws a chosen number of lines, evenly spaced apart
+
+        :param distance: length of lines
+        :param lines_num: number of lines
+        :param tls_num: a given ChainTurtle
+        """
+        angle = int(360/lines_num)
+        for _ in range(lines_num): tls_num.fd(distance).bk(distance).lt(angle)
+# ====== CIRCLE ======
+
+    def circle_ft(radius: Real,tls_num: ChainTurtle) -> None:
+        """
+        Draws a circle with given radius and turtle
+        :param radius: radius of circle
+        :param tls_num: a given ChainTurtle
+        """
+        tls_num.circle(radius)
+
+    def circle_filler(radius: Real,tls_num: ChainTurtle) -> None:
+        """
+        Draws a filled circle with given radius and turtle
+        :param radius: radius of circle
+        :param tls_num: a given ChainTurtle
+        """
+        tls_num.begin_fill().circle(radius).end_fill()
+# ====== POLYGON ======
+
+    def polygon(length: Real,sides: int,tls_num: ChainTurtle) -> None:
+        """
+        Draws a polygon with given length and sides
+        :param length: length of polygon
+        :param sides: number of sides
+        :param tls_num: a given ChainTurtle
+        """
+        radius = length / (2 * sine(180 / sides)); angle_to_right = (180-(180*(sides-2))/sides) / 2
+        tls_num.rt(angle_to_right).circle(radius,360,sides).lt(angle_to_right)
+
+    def polygon_fill(length: Real,sides: int,tls_num: ChainTurtle) -> None:
+        """
+        Draws a filled polygon with given length and sides
+        :param length: length of polygon
+        :param sides: number of sides
+        :param tls_num: a given ChainTurtle
+        """
+        tls_num.begin_fill(); Shapes.polygon(length,sides,tls_num); tls_num.end_fill()

geometricaldomination-0.1.0/UniversalFunctions2/StringCheck.py

@@ -0,0 +1,23 @@
+from time import sleep as rest
+
+
+def get_str(str_input: str, *check_values: str|dict|list|tuple) -> str:
+    """
+    Checks whether the input string matches the allowed values (*check_values)
+    :param str_input: input string
+    :param check_values: allowed string values (all lowercase), options: str, dict, list, tuple
+    """
+    if not isinstance(str_input, str):
+        raise TypeError("str_input must be a string")
+
+    while True:
+        value: str = input(str_input).lower()
+        for check in check_values:
+            if not isinstance(check, (str, dict, list, tuple)):
+                raise TypeError("check_values must be a string, dict, list, or tuple")
+            if isinstance(check, str) and check == value:
+                return value
+            elif isinstance(check, (dict, list, tuple)) and value in check:
+                return value
+        print("Enter something VALID!")
+        rest(1.5)

geometricaldomination-0.1.0/UniversalFunctions2/TypingVariables.py

@@ -0,0 +1,3 @@
+from typing import TypeAlias
+
+Real: TypeAlias = float | int

geometricaldomination-0.1.0/UniversalFunctions2/__init__.py

@@ -0,0 +1,6 @@
+from .DecoratorArchive import class_decorator
+from .GetVariable import get_num
+from .HelperFunctions import helper, sine, range_f
+from .RepeatlessList import repeatless_list, repeatless_list2
+from .Shapes import Shapes
+from .StringCheck import get_str

geometricaldomination-0.1.0/pyproject.toml

@@ -0,0 +1,14 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "GeometricalDomination"
+version = "0.1.0"
+description = "A Python turtle graphics library and DSL for creating geometric drawings."
+readme = "README.md"
+requires-python = ">=3.14"
+
+authors = [
+    { name = "Miah M. Sabiq", email = "miah.sabiq@gibs.at"}
+]

geometricaldomination-0.1.0/setup.cfg

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