e2D 1.4.19__py3-none-any.whl → 1.4.21__py3-none-any.whl

e2D/__init__.py

@@ -10,6 +10,7 @@ PI_QUARTER = PI/4
 PI_DOUBLE = PI*2
 
 sign = lambda val: -1 if val < 0 else (1 if val > 0 else 0)
+clamp = lambda x, minn, maxx: x if x > minn and x < maxx else (minn if x < minn else maxx)
 
 class Vector2D:
     round_values_on_print = 2
@@ -34,6 +35,22 @@ class Vector2D:
     @angle.setter
     def angle(self, new_angle) -> None:
         self.rotate(new_angle - self.angle)
+    
+    @property
+    def aspect_x(self) -> float:
+        return self.x / self.y if self.y != 0 else 0
+
+    @aspect_x.setter
+    def aspect_x(self, new_aspect) -> None:
+        self.x = self.y * new_aspect
+
+    @property
+    def aspect_y(self) -> float:
+        return self.y / self.x if self.x != 0 else 0
+
+    @aspect_y.setter
+    def aspect_y(self, new_aspect) -> None:
+        self.y = self.x * new_aspect
 
     @property
     def copy(self) -> "Vector2D":
@@ -42,9 +59,16 @@ class Vector2D:
     @property
     def sign(self) -> "Vector2D":
         return Vector2D(sign(self.x), sign(self.y))
+    
+    def clamp(self, min_val: Vector2D, max_val: Vector2D) -> "Vector2D":
+        return Vector2D(clamp(self.x, min_val.x, max_val.x), clamp(self.y, min_val.y, max_val.y))
+
+    def iclamp(self, min_val: Vector2D, max_val: Vector2D) -> None:
+        self.x = clamp(self.x, min_val.x, max_val.x)
+        self.y = clamp(self.y, min_val.y, max_val.y)
 
     @property
-    def normalize(self) -> "Vector2D":
+    def normalized(self) -> "Vector2D":
         if (mag:=self.length) == 0:
             return self.copy
         return Vector2D(self.x / mag, self.y / mag)
@@ -52,11 +76,31 @@ class Vector2D:
     @property
     def length(self) -> float:
         return (self.x ** 2 + self.y ** 2) ** .5
-    
+
+    @length.setter
+    def length(self, new_length: float) -> None:
+        current_length = self.length
+        if current_length == 0:
+            self.x = new_length
+            self.y = 0
+        else:
+            self.x *= new_length / current_length
+            self.y *= new_length / current_length
+
     @property
     def length_sqrd(self) -> float:
         return self.x ** 2 + self.y ** 2
-    
+
+    @length_sqrd.setter
+    def length_sqrd(self, new_length_sqrd: float) -> None:
+        current_length = self.length
+        if current_length == 0:
+            self.x = _mt.sqrt(new_length_sqrd)
+            self.y = 0
+        else:
+            self.x *= _mt.sqrt(new_length_sqrd) / current_length
+            self.y *= _mt.sqrt(new_length_sqrd) / current_length
+
     @property
     def inverse(self) -> "Vector2D":
         return self.mult(-1)
@@ -111,6 +155,13 @@ class Vector2D:
     def complex_to_cartesian(cls, complex_n) -> "Vector2D":
         return cls(complex_n.real, complex_n.imag)
 
+    def cartesian_to_linear(self, size) -> int:
+        return int(self.x + self.y * size)
+
+    @classmethod
+    def linear_to_cartesian(cls, linear, size) -> "Vector2D":
+        return cls(linear % size, linear // size)
+
     def lerp(self, other, t=.1) -> "Vector2D":
         return Vector2D(self.x + (other.x - self.x) * t, self.y + (other.y - self.y) * t)
 
@@ -487,10 +538,10 @@ V2down_right = Vector2D(1, -1)
 V2up_left = Vector2D(-1, 1)
 V2down_left = Vector2D(-1, -1)
 
-V2up_right_norm = V2up_right.normalize
-V2down_right_norm = V2down_right.normalize
-V2up_left_norm = V2up_left.normalize
-V2down_left_norm = V2down_left.normalize
+V2up_right_norm = V2up_right.normalized
+V2down_right_norm = V2down_right.normalized
+V2up_left_norm = V2up_left.normalized
+V2down_left_norm = V2down_left.normalized
 
 VECTORS_4_DIRECTIONS = (V2right, V2down, V2left, V2up)
 VECTORS_4_SEMIDIRECTIONS = (V2down_right, V2down_left, V2up_left, V2up_right)

e2D/__init__.pyi

@@ -12,6 +12,7 @@ PI_DOUBLE : float
 # 
 
 sign : Callable[[int|float], Literal[-1,0,1]]
+clamp: Callable[[int|float, int|float, int|float], int|float]
 
 class Vector2D:
     round_values_on_print : int|float
@@ -140,10 +141,59 @@ class Vector2D:
         ...
 
     @property
-    def angle(self:"Vector2D") -> int|float: ...
+    def angle(self:"Vector2D") -> int|float:
+        """
+        # Vector Angle
+        ## Returns:
+            float: The angle (in radians) of the vector from the positive x-axis.
+        ## Example:
+            v = Vector2D(1, 1)
+            angle = v.angle
+            print(angle)  # Output: 0.7853981633974483
+        ## Explanation:
+            This property calculates the angle of the vector from the positive x-axis using the `atan2` function.
+        """
+        ...
 
     @angle.setter
-    def angle(self:"Vector2D", argv) -> None: ...
+    def angle(self:"Vector2D", argv) -> None:
+        ...
+
+    @property
+    def aspect_x(self: "Vector2D") -> float:
+        """
+        # Aspect Ratio (X over Y)
+        ## Returns:
+            float: The aspect ratio of the vector, calculated as the x component divided by the y component. Returns 0 if the y component is zero.
+        ## Example:
+            v = Vector2D(4, 2)
+            aspect = v.aspect_x
+            print(aspect)  # Output: 2.0
+        ## Explanation:
+            This property computes the ratio of the x component to the y component of the vector. If the y component is zero, it returns 0 to avoid division by zero.
+        """
+        ...
+
+    @aspect_x.setter
+    def aspect_x(self: "Vector2D", new_aspect) -> None: ...
+
+    @property
+    def aspect_y(self: "Vector2D") -> float:
+        """
+        # Aspect Ratio (Y over X)
+        ## Returns:
+            float: The aspect ratio of the vector, calculated as the y component divided by the x component. Returns 0 if the x component is zero.
+        ## Example:
+            v = Vector2D(2, 4)
+            aspect = v.aspect_y
+            print(aspect)  # Output: 2.0
+        ## Explanation:
+            This property computes the ratio of the y component to the x component of the vector. If the x component is zero, it returns 0 to avoid division by zero.
+        """
+        ...
+
+    @aspect_y.setter
+    def aspect_y(self: "Vector2D", new_aspect) -> None: ...
 
     @property
     def copy(self:"Vector2D") -> "Vector2D":
@@ -211,8 +261,56 @@ class Vector2D:
         """
         ...
     
+    def clamp(self, min_val: Vector2D, max_val: Vector2D) -> "Vector2D":
+        """
+        # Clamp the vector's components between the corresponding components of two other vectors.
+
+        ## Parameters:
+            min_val (Vector2D): The minimum vector for clamping.
+            max_val (Vector2D): The maximum vector for clamping.
+
+        ## Returns:
+            Vector2D: A new vector with its components clamped between the corresponding components of `min_val` and `max_val`.
+
+        ## Example:
+            v = Vector2D(5, 10)
+            min_val = Vector2D(0, 8)
+            max_val = Vector2D(6, 12)
+            clamped_v = v.clamp(min_val, max_val)
+            print(clamped_v)  # Output: (5, 10)
+
+        ## Explanation:
+            This method clamps the x and y components of the current vector between the corresponding x and y components
+            of the `min_val` and `max_val` vectors. The resulting vector is returned as a new Vector2D instance.
+        """
+        ...
+
+    def iclamp(self, min_val: Vector2D, max_val: Vector2D) -> None:
+        """
+        # Clamp the vector's components in place between the corresponding components of two other vectors.
+
+        ## Parameters:
+            min_val (Vector2D): The minimum vector for clamping.
+            max_val (Vector2D): The maximum vector for clamping.
+
+        ## Returns:
+            None
+
+        ## Example:
+            v = Vector2D(5, 10)
+            min_val = Vector2D(0, 8)
+            max_val = Vector2D(6, 12)
+            v.iclamp(min_val, max_val)
+            print(v)  # Output: (5, 10)
+
+        ## Explanation:
+            This method clamps the x and y components of the current vector in place between the corresponding x and y components
+            of the `min_val` and `max_val` vectors. The method modifies the current vector directly.
+        """
+        ...
+    
     @property
-    def normalize(self:"Vector2D") -> "Vector2D":
+    def normalized(self:"Vector2D") -> "Vector2D":
         """
         # Vector Normalization
 
@@ -224,7 +322,7 @@ class Vector2D:
 
         ## Example:
             v = Vector2D(3, 4)
-            normalized_v = v.normalize()  # Normalize the vector (3, 4)
+            normalized_v = v.normalized()  # Normalize the vector (3, 4)
             print(normalized_v)  # Output: (0.6, 0.8)
 
         ## Explanation:
@@ -244,23 +342,123 @@ class Vector2D:
     
     @property
     def length(self:"Vector2D") -> float:
+        """
+        # Vector Length
+
+        ## Returns:
+            float: The length (magnitude) of the vector.
+
+        ## Example:
+            v = Vector2D(3, 4)
+            length = v.length
+            print(length)  # Output: 5.0
+
+        ## Explanation:
+            This property calculates the length (magnitude) of the vector using the Pythagorean theorem.
+        """
         ...
 
     @property
     def length_sqrd(self:"Vector2D") -> float:
+        """
+        # Vector Length Squared
+
+        ## Returns:
+            float: The squared length (magnitude) of the vector.
+
+        ## Example:
+            v = Vector2D(3, 4)
+            length_sqrd = v.length_sqrd
+            print(length_sqrd)  # Output: 25
+
+        ## Explanation:
+            This property calculates the squared length (magnitude) of the vector.
+            It is more efficient than calculating the actual length, as it avoids the
+            square root calculation.
+        """
         ...
     
     @property
     def inverse(self:"Vector2D") -> "Vector2D":
+        """
+        # Vector Inversion
+
+        ## Returns:
+            Vector2D: A new vector with inverted components.
+
+        ## Example:
+            v = Vector2D(3, 4)
+            inverted_v = v.inverse()
+            print(inverted_v)  # Output: (-3, -4)
+
+        ## Explanation:
+            This method calculates the inverted version of the current vector, which means a new vector with the same magnitude
+            but opposite direction.
+
+            The inverted vector is obtained by negating each component of the current vector.
+
+            The resulting inverted vector is returned.
+        """
         ...
 
     def floor(self:"Vector2D", n:"int|float|Vector2D"=1) -> "Vector2D":
+        """
+        # Round the Vector2D components down to the nearest integer or specified decimal place.
+
+        ## Parameters:
+            n (int|float|Vector2D, optional): The decimal place to round down to. Default is 1.
+
+        ## Returns:
+            Vector2D: A new vector with rounded-down components.
+
+        ## Example:
+            v = Vector2D(3.14159, 2.71828)
+            rounded_v = v.floor(2)
+            print(rounded_v)  # Output: (3.14, 2.71)
+
+        ## Explanation:
+            This method rounds each component of the vector down to the nearest integer or specified decimal place.
+        """
         ...
 
     def ceil(self:"Vector2D", n:"int|float|Vector2D"=1) -> "Vector2D":
+        """
+        # Round the Vector2D components up to the nearest integer or specified decimal place.
+
+        ## Parameters:
+            n (int|float|Vector2D, optional): The decimal place to round up to. Default is 1.
+
+        ## Returns:
+            Vector2D: A new vector with rounded-up components.
+
+        ## Example:
+            v = Vector2D(3.14159, 2.71828)
+            rounded_v = v.ceil(2)
+            print(rounded_v)  # Output: (3.15, 2.72)
+
+        ## Explanation:
+            This method rounds each component of the vector up to the nearest integer or specified decimal place.
+        """
         ...
     
     def round(self:"Vector2D", n:"int|float|Vector2D"=1) -> "Vector2D":
+        """
+        # Round the Vector2D components to the nearest integer or specified decimal place.
+
+        ## Parameters:
+            n (int|float|Vector2D, optional): The decimal place to round to. Default is 1.
+
+        ## Returns:
+            Vector2D: A new vector with rounded components.
+
+        ## Example:
+            v = Vector2D(3.14159, 2.71828)
+            rounded_v = v.round(2)
+            print(rounded_v)  # Output: (3.14, 2.72)
+
+        ## Explanation:
+            This method rounds each component of the vector to the nearest integer or specified decimal place.
+        """
         ...
 
     @classmethod
@@ -451,7 +649,65 @@ class Vector2D:
     def cartesian_to_complex(self:"Vector2D") -> complex: ...
 
     @classmethod
-    def complex_to_cartesian(cls, complex_n: complex) -> "Vector2D": ...
+    def complex_to_cartesian(cls, complex_n: complex) -> "Vector2D":
+        """
+        # Convert a Complex Number to Cartesian Coordinates
+
+        ## Parameters:
+            complex_n (complex): The complex number to convert.
+
+        ## Returns:
+            Vector2D: The corresponding (x, y) coordinates as a Vector2D.
+
+        ## Example:
+            v = Vector2D.complex_to_cartesian(3 + 4j)  # v = Vector2D(3, 4)
+
+        ## Explanation:
+            This class method converts a complex number (a + bi) to Cartesian coordinates (x, y).
+            The real part 'a' becomes the x-coordinate, and the imaginary part 'b' becomes the y-coordinate.
+        """
+        ...
+
+    def cartesian_to_linear(self:"Vector2D", size:int|float) -> int:
+        """
+        # Convert 2D Cartesian coordinates to a linear index.
+
+        ## Parameters:
+            size (int|float): The width of the grid (number of columns).
+
+        ## Returns:
+            int: The linear index corresponding to the (x, y) coordinates.
+
+        ## Example:
+            v = Vector2D(3, 2)
+            idx = v.cartesian_to_linear(5)  # idx = 3 + 2*5 = 13
+
+        ## Explanation:
+            This method converts the (x, y) coordinates of the vector to a single linear index,
+            assuming row-major order in a 2D grid of the given width.
+        """
+        ...
+
+    @classmethod
+    def linear_to_cartesian(cls, linear:int, size:int|float) -> "Vector2D":
+        """
+        # Convert a linear index to 2D Cartesian coordinates.
+
+        ## Parameters:
+            linear (int): The linear index.
+            size (int|float): The width of the grid (number of columns).
+
+        ## Returns:
+            Vector2D: The corresponding (x, y) coordinates as a Vector2D.
+
+        ## Example:
+            v = Vector2D.linear_to_cartesian(13, 5)  # v = Vector2D(3, 2)
+
+        ## Explanation:
+            This class method converts a linear index to (x, y) coordinates,
+            assuming row-major order in a 2D grid of the given width.
+        """
+        ...
 
     def lerp(self:"Vector2D", other:"int|float|Vector2D|list|tuple", t:float=.1) -> "Vector2D":
         """
@@ -1046,4 +1302,37 @@ def distance_line_point(line_point_a:Vector2D, line_point_b:Vector2D, point_c:Ve
     ...
 
 def optimize_value_string(value: int|float, precision: int) -> str:
+    """
+    # Optimize the string representation of a numeric value based on its magnitude and the specified precision.
+
+    ## Parameters:
+        value (int | float): The numeric value to be formatted.
+        precision (int): The number of decimal places or significant digits to use in the formatted string.
+
+    ## Returns:
+        str: The optimized string representation of the value.
+
+    ## Example:
+        value = 0.000012345
+        precision = 3
+        result = optimize_value_string(value, precision)
+        print(result)
+        # Output: '1.235e-05'
+
+        value = 123.456789
+        precision = 2
+        result = optimize_value_string(value, precision)
+        print(result)
+        # Output: '123.46'
+
+    ## Explanation:
+        The function formats the input value as a string, choosing between fixed-point and scientific notation
+        based on the magnitude of the value relative to the specified precision:
+            - If the absolute value is very small (less than 1 divided by 10 to the power of precision, but not zero),
+                scientific notation is used.
+            - If the absolute value is less than 10 to the power of precision, fixed-point notation is used,
+                with trailing zeros and decimal points removed for brevity.
+            - Otherwise, scientific notation is used.
+        This ensures that the string representation is concise and readable, while maintaining the requested precision.
+    """
     ...

e2D/colors.py

@@ -1,7 +1,8 @@
+from __future__ import annotations
 from colorsys import hsv_to_rgb as __hsv_to_rgb_def__, hls_to_rgb as __hls_to_rgb_def__, rgb_to_hls as __rgb_to_hls__, rgb_to_hsv as __rgb_to_hsv__
 from typing import Any, Callable, Generator, Literal
 from pygame.color import Color as __color_pygame__
-from random import randint as __randint__
+from random import random as __rand__
 
 RGB_COLOR_MODE = "rgb"
 RGBA_COLOR_MODE = "rgba"
@@ -15,11 +16,11 @@ HLS_COLOR_MODE = "hls"
 
 __LITERAL_COLOR_MODES__ = Literal["rgb","rgba","bgr","bgra","g","hsv","hls"] #,"cmyk","lab"]
 
-def __hsv_to_rgb__(h:int|float, s:int|float, v:int|float) -> tuple[int|float, int|float, int|float]:
+def __hsv_to_rgb__(h:"int|float", s:"int|float", v:"int|float") -> tuple["int|float", "int|float", "int|float"]:
     r,g,b = __hsv_to_rgb_def__(h, s, v)
     return r*255, g*255, b*255
 
-def __hls_to_rgb__(h:int|float, s:int|float, v:int|float) -> tuple[int|float, int|float, int|float]:
+def __hls_to_rgb__(h:"int|float", s:"int|float", v:"int|float") -> tuple["int|float", "int|float", "int|float"]:
     r,g,b = __hls_to_rgb_def__(h, s, v)
     return r*255, g*255, b*255
     
@@ -82,6 +83,12 @@ __conversion_table__ :dict[__LITERAL_COLOR_MODES__, dict[__LITERAL_COLOR_MODES__
         },
 }
 
+def pygamize_color(color: "__color_pygame__|Color") -> "__color_pygame__":
+    return color() if isinstance(color, Color) else color
+
+def unpygamize_color(color: "__color_pygame__|Color") -> "Color":
+    return Color(*color[:], mode=RGBA_COLOR_MODE) if isinstance(color, __color_pygame__) else color
+
 class Color:
     def __init__(self, *values, mode:__LITERAL_COLOR_MODES__=RGB_COLOR_MODE) -> None:
         self.__dict__ = dict(zip(mode, values))
@@ -104,35 +111,35 @@ class Color:
         return (d ** .5) if rooted else d
     
     @classmethod
-    def new_rgb(cls, r:int|float, g:int|float, b:int|float) -> "Color":
+    def new_rgb(cls, r:"int|float", g:"int|float", b:"int|float") -> "Color":
         return Color(r,g,b, mode=RGB_COLOR_MODE)
     @classmethod
-    def new_rgba(cls, r:int|float, g:int|float, b:int|float, a:int|float) -> "Color":
+    def new_rgba(cls, r:"int|float", g:"int|float", b:"int|float", a:"int|float") -> "Color":
         return Color(r,g,b,a, mode=RGBA_COLOR_MODE)
     @classmethod
-    def new_bgr(cls, b:int|float, g:int|float, r:int|float) -> "Color":
+    def new_bgr(cls, b:"int|float", g:"int|float", r:"int|float") -> "Color":
         return Color(b,g,r, mode=BGR_COLOR_MODE)
     @classmethod
-    def new_bgra(cls, b:int|float, g:int|float, r:int|float, a:int|float) -> "Color":
+    def new_bgra(cls, b:"int|float", g:"int|float", r:"int|float", a:"int|float") -> "Color":
         return Color(b,g,r,a, mode=BGRA_COLOR_MODE)
     @classmethod
     def new_g(cls, g) -> "Color":
         return Color(g, mode=GRAY_COLOR_MODE)
     @classmethod
-    def new_hsv(cls, h:int|float, s:int|float, v:int|float) -> "Color":
+    def new_hsv(cls, h:"int|float", s:"int|float", v:"int|float") -> "Color":
         return Color(h,s,v, mode=HSV_COLOR_MODE)
     @classmethod
-    def new_hls(cls, h:int|float, l:int|float, s:int|float) -> "Color":
+    def new_hls(cls, h:"int|float", l:"int|float", s:"int|float") -> "Color":
         return Color(h,l,s, mode=HLS_COLOR_MODE)
     # @classmethod
-    # def new_cmyk(cls, c:int|float, m:int|float, y:int|float, k:int|float) -> Color:
+    # def new_cmyk(cls, c:"int|float", m:"int|float", y:"int|float", k:"int|float") -> Color:
     #     return Color(c,m,y,k, mode=CMYK_COLOR_MODE)
     # @classmethod
-    # def new_lab(cls, l:int|float, a:int|float, b:int|float) -> Color:
+    # def new_lab(cls, l:"int|float", a:"int|float", b:"int|float") -> Color:
     #     return Color(l,a,b, mode=LAB_COLOR_MODE)
 
     @property
-    def values(self) -> tuple[int|float, ...]:
+    def values(self) -> tuple["int|float", ...]:
         return tuple(self.__dict__.values())[:-1]
 
     @property
@@ -140,7 +147,7 @@ class Color:
         return tuple(self.__dict__.keys())[:-1]
     
     @property
-    def items(self) -> tuple[tuple[str, int|float], ...]:
+    def items(self) -> tuple[tuple[str, "int|float"], ...]:
         return tuple(self.__dict__.items())[:-1]
 
     def copy(self) -> "Color":
@@ -179,7 +186,7 @@ class Color:
         return "Color(" + ", ".join(f"{k}:{v}" for k, v in self.items) + ")"
 
     def __call__(self) -> __color_pygame__:
-        return __color_pygame__(int(self.r), int(self.g), int(self.b))
+        return __color_pygame__(int(self.r), int(self.g), int(self.b)) if self.mode == RGB_COLOR_MODE else __color_pygame__(int(self.r), int(self.g), int(self.b), int(self.a))
     
     # fast operations     Vector2D.operation(both,x,y)
     def add(self, all3=.0, r=.0, g=.0, b=.0) -> "Color":
@@ -386,7 +393,7 @@ class Color:
     def __float__(self) -> "Color":
         return Color(float(self.r), float(self.g), float(self.b))
 
-    def __getitem__(self, n) -> int|float:
+    def __getitem__(self, n) -> "int|float":
         return self.values[n] if isinstance(n, int) else self.values[self.keys.index(n)]
     
     def __iter__(self) -> Generator[float, Any, None]:
@@ -406,8 +413,10 @@ class Color:
         try:
             return cls(*other.values, mode=other.mode)
         except:
-            raise TypeError(f"The value {other} of type {type(other)} is not a num type: [{int|float}] nor an array type: [{list|tuple}]")
+            raise TypeError(f"The value {other} of type {type(other)} is not a num type: [{"int|float"}] nor an array type: [{list|tuple}]")
     
+    @classmethod
+    def transparent(cls) -> "Color": return Color(0,0,0,0, mode=RGBA_COLOR_MODE)
     @classmethod
     def white(cls) -> "Color": return Color(255,255,255)
     @classmethod
@@ -418,23 +427,44 @@ class Color:
     def green(cls) -> "Color": return Color(0,255,0)
     @classmethod
     def blue(cls) -> "Color": return Color(0,0,255)
-    
-    # @classmethod
-    # def (cls) -> "Color": return Color(0,0,255)
-
     @classmethod
-    def randomize(cls) -> "Color":
-        return Color(__randint__(0,255), __randint__(0,255), __randint__(0,255))
-
+    def cyan(cls) -> "Color": return Color(0,255,255)
+    @classmethod
+    def magenta(cls) -> "Color": return Color(255,0,255)
+    @classmethod
+    def yellow(cls) -> "Color": return Color(255,255,0)
 
+    @classmethod
+    def randomize(cls, start=0, end=255, func=lambda val:val) -> "Color":
+        if not isinstance(start, Color):
+            if isinstance(start, (int, float)):
+                start = Color(start, start, start)
+            else:
+                raise Exception(f"\nArg start must be in [Color, int, float, tuple, list] not a [{type(start)}]\n")
+        if not isinstance(end, Color):
+            if isinstance(end, (int, float)):
+                end = Color(end, end, end)
+            else:
+                raise Exception(f"\nArg end must be in [Color, int, float, tuple, list] not a [{type(end)}]\n")
+        return start + Color(func(__rand__()), func(__rand__()), func(__rand__())) * (end - start)
+
+
+TRANSPARENT_COLOR = Color.transparent()
 WHITE_COLOR = Color.white()
 BLACK_COLOR = Color.black()
 RED_COLOR = Color.red()
 GREEN_COLOR = Color.green()
 BLUE_COLOR = Color.blue()
+CYAN_COLOR = Color.cyan()
+MAGENTA_COLOR = Color.magenta()
+YELLOW_COLOR = Color.yellow()
 
+TRANSPARENT_COLOR_PYG = TRANSPARENT_COLOR() 
 WHITE_COLOR_PYG = WHITE_COLOR()
 BLACK_COLOR_PYG = BLACK_COLOR()
 RED_COLOR_PYG = RED_COLOR()
 GREEN_COLOR_PYG = GREEN_COLOR()
 BLUE_COLOR_PYG = BLUE_COLOR()
+CYAN_COLOR_PYG = CYAN_COLOR()
+MAGENTA_COLOR_PYG = MAGENTA_COLOR()
+YELLOW_COLOR_PYG = YELLOW_COLOR()