ConsoleLib 1.3.3__tar.gz → 1.3.4__tar.gz

{consolelib-1.3.3 → consolelib-1.3.4}/ConsoleLib/__init__.py

@@ -10,7 +10,9 @@ import time
 import subprocess as CMD
 import math
 import random
-from typing import Optional, Iterator, List
+import threading
+from typing import Optional, Iterator, List, Tuple, Union
+
 class Colors:
     RESET = "\033[0m"
     BOLD = "\033[1m"
@@ -53,19 +55,25 @@ class Colors:
     BG_BRIGHT_MAGENTA = "\033[105m"
     BG_BRIGHT_CYAN = "\033[106m"
     BG_BRIGHT_WHITE = "\033[107m"
+
     @staticmethod
     def rgb(r, g, b):
         return f"\033[38;2;{r};{g};{b}m"
+
     @staticmethod
     def bg_rgb(r, g, b):
         return f"\033[48;2;{r};{g};{b}m"
+
     @staticmethod
     def colorize(text, color, reset=True):
         reset_code = Colors.RESET if reset else ""
         return f"{color}{text}{reset_code}"
+
+
 class Animate:
     def clear_screen():
-        os.system('cls' if os.name == 'nt' else 'clear')    
+        os.system('cls' if os.name == 'nt' else 'clear')
+
     class ProgressBar:
         def __init__(
             self,
@@ -94,18 +102,18 @@ class Animate:
             self._lock = threading.Lock()
             self._finished = False
             self._cleared = False
-    
+
         def update(self, increment: int = 1) -> None:
             with self._lock:
                 if self._finished:
                     return
                 self.current = min(self.current + increment, self.total)
                 self._print_bar()
-    
+
                 if self.current >= self.total:
                     self._finished = True
                     print()
-    
+
         def set(self, value: int) -> None:
             with self._lock:
                 if self._finished:
@@ -115,6 +123,7 @@ class Animate:
                 if self.current >= self.total:
                     self._finished = True
                     print()
+
         def _print_bar(self) -> None:
             percent = self.current / self.total
             filled_len = int(self.length * percent)
@@ -129,22 +138,25 @@ class Animate:
             line = " ".join(parts)
             sys.stdout.write("\r" + line)
             sys.stdout.flush()
-    
+
         def __enter__(self):
             if self.auto_clear and not self._cleared:
-                clear_screen()
+                Animate.clear_screen()
                 self._cleared = True
                 if self.clear_delay > 0:
                     time.sleep(self.clear_delay)
             return self
+
         def __exit__(self, exc_type, exc_val, exc_tb):
             if not self._finished:
                 self._print_bar()
             print()
+
         def iterate(self, iterable: Iterator) -> Iterator:
             for i, item in enumerate(iterable):
                 yield item
                 self.update(1)
+
     def animate_print(
         text: str,
         delay: float = 0.05,
@@ -177,6 +189,7 @@ class Animate:
             sys.stdout.write(end)
             if flush:
                 sys.stdout.flush()
+
     def spinning_cursor(
         message: str = "Loading",
         duration: float = 3.0,
@@ -185,7 +198,7 @@ class Animate:
         clear_before: bool = False,
     ) -> None:
         if clear_before:
-            clear_screen()        
+            Animate.clear_screen()
         if frames is None:
             frames = ["|", "/", "-", r"\\"]
         end_time = time.time() + duration
@@ -198,16 +211,20 @@ class Animate:
             idx += 1
         sys.stdout.write("\r" + " " * (len(message) + 3) + "\r")
         sys.stdout.flush()
+
     def countdown(seconds: int, message: str = "Countdown", clear_before: bool = False) -> None:
         if clear_before:
-            clear_screen()       
+            Animate.clear_screen()
         for remaining in range(seconds, 0, -1):
             sys.stdout.write(f"\r{message}: {remaining:2d} seconds remaining ")
             sys.stdout.flush()
             time.sleep(1)
         sys.stdout.write(f"\r{message}: 0 seconds remaining! Done!\n")
         sys.stdout.flush()
+
+
 class Render:
+    # ---- CORE ----
     @staticmethod
     def DrawPic(points=None, width=80, height=25, clear_before_draw=False, default_char=' '):
         if clear_before_draw:
@@ -215,15 +232,42 @@ class Render:
         field = [[default_char for _ in range(width)] for _ in range(height)]
         if points:
             for item in points:
-                if len(item) == 3:
-                    x, y, char = item
+                if len(item) >= 3:
+                    x, y, char = item[0], item[1], item[2]
                     if 0 <= x < width and 0 <= y < height:
-                        field[y][x] = char
+                        # Если есть цвет — применяем
+                        if len(item) == 4:
+                            color = item[3]
+                            field[y][x] = f"{color}{char}{Colors.RESET}"
+                        elif len(item) == 5:
+                            color, bg = item[3], item[4]
+                            field[y][x] = f"{color}{bg}{char}{Colors.RESET}"
+                        else:
+                            field[y][x] = char
         for row in field:
             print(''.join(row))
 
+    # ---- POINT GENERATORS WITH COLOR ----
+    @staticmethod
+    def _apply_color(points, color=None, bg=None):
+        if color is None and bg is None:
+            return points
+        result = []
+        for p in points:
+            if len(p) == 3:
+                x, y, char = p
+                if color and bg:
+                    result.append((x, y, char, color, bg))
+                elif color:
+                    result.append((x, y, char, color))
+                else:
+                    result.append((x, y, char, Colors.BG_BLACK + bg))
+            else:
+                result.append(p)
+        return result
+
     @staticmethod
-    def get_line_points(x1, y1, x2, y2, char='#'):
+    def get_line_points(x1, y1, x2, y2, char='#', color=None, bg=None):
         points = []
         dx = abs(x2 - x1)
         dy = abs(y2 - y1)
@@ -241,29 +285,29 @@ class Render:
             if e2 < dx:
                 err += dx
                 y1 += sy
-        return points
+        return Render._apply_color(points, color, bg)
 
     @staticmethod
-    def get_circle_points(cx, cy, r, char='#'):
+    def get_circle_points(cx, cy, r, char='#', color=None, bg=None):
         points = []
         for angle in range(0, 360, 5):
             rad = angle * math.pi / 180
             x = int(cx + r * math.cos(rad))
             y = int(cy + r * math.sin(rad))
             points.append((x, y, char))
-        return points
+        return Render._apply_color(points, color, bg)
 
     @staticmethod
-    def get_filled_circle_points(cx, cy, r, char='#'):
+    def get_filled_circle_points(cx, cy, r, char='#', color=None, bg=None):
         points = []
         for y in range(cy - r, cy + r + 1):
             for x in range(cx - r, cx + r + 1):
                 if (x - cx) ** 2 + (y - cy) ** 2 <= r ** 2:
                     points.append((x, y, char))
-        return points
+        return Render._apply_color(points, color, bg)
 
     @staticmethod
-    def get_rect_points(x1, y1, x2, y2, char='#'):
+    def get_rect_points(x1, y1, x2, y2, char='#', color=None, bg=None):
         points = []
         for x in range(x1, x2 + 1):
             points.append((x, y1, char))
@@ -271,18 +315,18 @@ class Render:
         for y in range(y1, y2 + 1):
             points.append((x1, y, char))
             points.append((x2, y, char))
-        return points
+        return Render._apply_color(points, color, bg)
 
     @staticmethod
-    def get_fill_rect_points(x1, y1, x2, y2, char='#'):
+    def get_fill_rect_points(x1, y1, x2, y2, char='#', color=None, bg=None):
         points = []
         for y in range(y1, y2 + 1):
             for x in range(x1, x2 + 1):
                 points.append((x, y, char))
-        return points
+        return Render._apply_color(points, color, bg)
 
     @staticmethod
-    def get_text_points(x, y, text, char=None):
+    def get_text_points(x, y, text, char=None, color=None, bg=None):
         points = []
         if char is None:
             for i, ch in enumerate(text):
@@ -290,18 +334,18 @@ class Render:
         else:
             for i in range(len(text)):
                 points.append((x + i, y, char))
-        return points
+        return Render._apply_color(points, color, bg)
 
     @staticmethod
-    def get_triangle_points(x1, y1, x2, y2, x3, y3, char='#'):
+    def get_triangle_points(x1, y1, x2, y2, x3, y3, char='#', color=None, bg=None):
         points = []
         points.extend(Render.get_line_points(x1, y1, x2, y2, char))
         points.extend(Render.get_line_points(x2, y2, x3, y3, char))
         points.extend(Render.get_line_points(x3, y3, x1, y1, char))
-        return points
+        return Render._apply_color(points, color, bg)
 
     @staticmethod
-    def get_filled_triangle_points(x1, y1, x2, y2, x3, y3, char='#'):
+    def get_filled_triangle_points(x1, y1, x2, y2, x3, y3, char='#', color=None, bg=None):
         points = []
         min_x = min(x1, x2, x3)
         max_x = max(x1, x2, x3)
@@ -311,19 +355,19 @@ class Render:
             for x in range(min_x, max_x + 1):
                 if Render._point_in_triangle(x, y, x1, y1, x2, y2, x3, y3):
                     points.append((x, y, char))
-        return points
+        return Render._apply_color(points, color, bg)
 
     @staticmethod
-    def get_heart_points(cx, cy, size=5, char='#'):
+    def get_heart_points(cx, cy, size=5, char='#', color=None, bg=None):
         points = []
         for y in range(-size, size + 1):
             for x in range(-size, size + 1):
                 if ((x * x + y * y - size * size) ** 3 <= size * size * x * x * y * y * 0.5):
                     points.append((cx + x, cy - y, char))
-        return points
+        return Render._apply_color(points, color, bg)
 
     @staticmethod
-    def get_star_points(cx, cy, radius=5, points_count=5, char='*'):
+    def get_star_points(cx, cy, radius=5, points_count=5, char='*', color=None, bg=None):
         points = []
         angle = -math.pi / 2
         step = math.pi / points_count
@@ -343,28 +387,28 @@ class Render:
             p3 = outer_points[(i + 1) % points_count]
             points.extend(Render.get_line_points(int(p1[0]), int(p1[1]), int(p2[0]), int(p2[1]), char))
             points.extend(Render.get_line_points(int(p2[0]), int(p2[1]), int(p3[0]), int(p3[1]), char))
-        return points
+        return Render._apply_color(points, color, bg)
 
     @staticmethod
-    def get_bezier_points(x1, y1, x2, y2, x3, y3, steps=20, char='#'):
+    def get_bezier_points(x1, y1, x2, y2, x3, y3, steps=20, char='#', color=None, bg=None):
         points = []
         for t in range(steps + 1):
             t = t / steps
             x = (1 - t) ** 2 * x1 + 2 * (1 - t) * t * x2 + t ** 2 * x3
             y = (1 - t) ** 2 * y1 + 2 * (1 - t) * t * y2 + t ** 2 * y3
             points.append((int(x), int(y), char))
-        return points
+        return Render._apply_color(points, color, bg)
 
     @staticmethod
-    def get_wave_points(cx, cy, amplitude=5, length=20, char='~'):
+    def get_wave_points(cx, cy, amplitude=5, length=20, char='~', color=None, bg=None):
         points = []
         for x in range(length):
             y = cy + int(amplitude * math.sin(x * 0.5))
             points.append((cx + x, y, char))
-        return points
+        return Render._apply_color(points, color, bg)
 
     @staticmethod
-    def get_spiral_points(cx, cy, turns=3, radius=10, step=0.1, char='*'):
+    def get_spiral_points(cx, cy, turns=3, radius=10, step=0.1, char='*', color=None, bg=None):
         points = []
         angle = 0
         r = 0
@@ -374,18 +418,18 @@ class Render:
             points.append((x, y, char))
             angle += step
             r += step * 2
-        return points
+        return Render._apply_color(points, color, bg)
 
     @staticmethod
-    def get_grid_points(x1, y1, x2, y2, step=2, char='+'):
+    def get_grid_points(x1, y1, x2, y2, step=2, char='+', color=None, bg=None):
         points = []
         for x in range(x1, x2 + 1, step):
             for y in range(y1, y2 + 1, step):
                 points.append((x, y, char))
-        return points
+        return Render._apply_color(points, color, bg)
 
     @staticmethod
-    def get_noise_points(cx, cy, radius, count=50, char='.'):
+    def get_noise_points(cx, cy, radius, count=50, char='.', color=None, bg=None):
         points = []
         for _ in range(count):
             angle = random.uniform(0, 2 * math.pi)
@@ -393,8 +437,9 @@ class Render:
             x = int(cx + r * math.cos(angle))
             y = int(cy + r * math.sin(angle))
             points.append((x, y, char))
-        return points
+        return Render._apply_color(points, color, bg)
 
+    # ---- 3D ----
     @staticmethod
     def _point_in_triangle(px, py, x1, y1, x2, y2, x3, y3):
         def sign(a, b, c):
@@ -444,7 +489,7 @@ class Render:
         return x2d, y2d
 
     @staticmethod
-    def get_cube_3d_points(size=5, rotx=0, roty=0, rotz=0, scale=10, cx=40, cy=12, char='#'):
+    def get_cube_3d_points(size=5, rotx=0, roty=0, rotz=0, scale=10, cx=40, cy=12, char='#', color=None, bg=None):
         s = size / 2
         vertices = [
             (-s, -s, -s), (s, -s, -s), (s, s, -s), (-s, s, -s),
@@ -464,10 +509,10 @@ class Render:
             x1, y1 = projected[edge[0]]
             x2, y2 = projected[edge[1]]
             points.extend(Render.get_line_points(x1, y1, x2, y2, char))
-        return points
+        return Render._apply_color(points, color, bg)
 
     @staticmethod
-    def get_pyramid_3d_points(size=5, rotx=0, roty=0, rotz=0, scale=10, cx=40, cy=12, char='#'):
+    def get_pyramid_3d_points(size=5, rotx=0, roty=0, rotz=0, scale=10, cx=40, cy=12, char='#', color=None, bg=None):
         s = size / 2
         vertices = [
             (-s, -s, -s), (s, -s, -s), (s, -s, s), (-s, -s, s),
@@ -486,10 +531,10 @@ class Render:
             x1, y1 = projected[edge[0]]
             x2, y2 = projected[edge[1]]
             points.extend(Render.get_line_points(x1, y1, x2, y2, char))
-        return points
+        return Render._apply_color(points, color, bg)
 
     @staticmethod
-    def get_cylinder_3d_points(radius=5, height=10, segments=12, rotx=0, roty=0, rotz=0, scale=10, cx=40, cy=12, char='#'):
+    def get_cylinder_3d_points(radius=5, height=10, segments=12, rotx=0, roty=0, rotz=0, scale=10, cx=40, cy=12, char='#', color=None, bg=None):
         points = []
         top_points = []
         bottom_points = []
@@ -515,10 +560,10 @@ class Render:
             x1, y1 = projected[i]
             x2, y2 = projected[i + segments]
             points.extend(Render.get_line_points(x1, y1, x2, y2, char))
-        return points
+        return Render._apply_color(points, color, bg)
 
     @staticmethod
-    def get_sphere_3d_points(radius=5, segments=12, rotx=0, roty=0, rotz=0, scale=10, cx=40, cy=12, char='#'):
+    def get_sphere_3d_points(radius=5, segments=12, rotx=0, roty=0, rotz=0, scale=10, cx=40, cy=12, char='#', color=None, bg=None):
         points = []
         for i in range(segments):
             theta = i / segments * math.pi
@@ -529,10 +574,10 @@ class Render:
                 z = radius * math.sin(theta) * math.sin(phi)
                 x2d, y2d = Render._project_3d(x, y, z, rotx, roty, rotz, scale, cx, cy)
                 points.append((x2d, y2d, char))
-        return points
+        return Render._apply_color(points, color, bg)
 
     @staticmethod
-    def get_cone_3d_points(radius=5, height=10, segments=12, rotx=0, roty=0, rotz=0, scale=10, cx=40, cy=12, char='#'):
+    def get_cone_3d_points(radius=5, height=10, segments=12, rotx=0, roty=0, rotz=0, scale=10, cx=40, cy=12, char='#', color=None, bg=None):
         points = []
         base_points = []
         for i in range(segments):
@@ -554,10 +599,10 @@ class Render:
             x1, y1 = projected[i]
             x2, y2 = projected[-1]
             points.extend(Render.get_line_points(x1, y1, x2, y2, char))
-        return points
+        return Render._apply_color(points, color, bg)
 
     @staticmethod
-    def get_torus_3d_points(radius=8, tube=3, segments=16, rotx=0, roty=0, rotz=0, scale=10, cx=40, cy=12, char='#'):
+    def get_torus_3d_points(radius=8, tube=3, segments=16, rotx=0, roty=0, rotz=0, scale=10, cx=40, cy=12, char='#', color=None, bg=None):
         points = []
         for i in range(segments):
             theta = i / segments * 2 * math.pi
@@ -568,10 +613,10 @@ class Render:
                 z = (radius + tube * math.cos(phi)) * math.sin(theta)
                 x2d, y2d = Render._project_3d(x, y, z, rotx, roty, rotz, scale, cx, cy)
                 points.append((x2d, y2d, char))
-        return points
+        return Render._apply_color(points, color, bg)
 
     @staticmethod
-    def get_ico_sphere_3d_points(radius=5, rotx=0, roty=0, rotz=0, scale=10, cx=40, cy=12, char='#'):
+    def get_ico_sphere_3d_points(radius=5, rotx=0, roty=0, rotz=0, scale=10, cx=40, cy=12, char='#', color=None, bg=None):
         points = []
         phi = (1 + math.sqrt(5)) / 2
         vertices = [
@@ -600,118 +645,120 @@ class Render:
             x1, y1 = projected[edge[0]]
             x2, y2 = projected[edge[1]]
             points.extend(Render.get_line_points(x1, y1, x2, y2, char))
-        return points
+        return Render._apply_color(points, color, bg)
 
+    # ---- DRAW WRAPPERS ----
     @staticmethod
-    def draw_cube_3d(size=5, rotx=0, roty=0, rotz=0, scale=10, cx=40, cy=12, char='#', width=80, height=25, clear_before_draw=False):
-        points = Render.get_cube_3d_points(size, rotx, roty, rotz, scale, cx, cy, char)
+    def draw_line(x1, y1, x2, y2, char='#', width=80, height=25, clear_before_draw=False, color=None, bg=None):
+        points = Render.get_line_points(x1, y1, x2, y2, char, color, bg)
         Render.DrawPic(points=points, width=width, height=height, clear_before_draw=clear_before_draw)
 
     @staticmethod
-    def draw_pyramid_3d(size=5, rotx=0, roty=0, rotz=0, scale=10, cx=40, cy=12, char='#', width=80, height=25, clear_before_draw=False):
-        points = Render.get_pyramid_3d_points(size, rotx, roty, rotz, scale, cx, cy, char)
+    def draw_circle(cx, cy, r, char='#', width=80, height=25, clear_before_draw=False, color=None, bg=None):
+        points = Render.get_circle_points(cx, cy, r, char, color, bg)
         Render.DrawPic(points=points, width=width, height=height, clear_before_draw=clear_before_draw)
 
     @staticmethod
-    def draw_cylinder_3d(radius=5, height=10, segments=12, rotx=0, roty=0, rotz=0, scale=10, cx=40, cy=12, char='#', width=80, clear_before_draw=False):
-        points = Render.get_cylinder_3d_points(radius, height, segments, rotx, roty, rotz, scale, cx, cy, char)
+    def draw_filled_circle(cx, cy, r, char='#', width=80, height=25, clear_before_draw=False, color=None, bg=None):
+        points = Render.get_filled_circle_points(cx, cy, r, char, color, bg)
         Render.DrawPic(points=points, width=width, height=height, clear_before_draw=clear_before_draw)
 
     @staticmethod
-    def draw_sphere_3d(radius=5, segments=12, rotx=0, roty=0, rotz=0, scale=10, cx=40, cy=12, char='#', width=80, height=25, clear_before_draw=False):
-        points = Render.get_sphere_3d_points(radius, segments, rotx, roty, rotz, scale, cx, cy, char)
+    def draw_rect(x1, y1, x2, y2, char='#', width=80, height=25, clear_before_draw=False, color=None, bg=None):
+        points = Render.get_rect_points(x1, y1, x2, y2, char, color, bg)
         Render.DrawPic(points=points, width=width, height=height, clear_before_draw=clear_before_draw)
 
     @staticmethod
-    def draw_cone_3d(radius=5, height=10, segments=12, rotx=0, roty=0, rotz=0, scale=10, cx=40, cy=12, char='#', width=80, clear_before_draw=False):
-        points = Render.get_cone_3d_points(radius, height, segments, rotx, roty, rotz, scale, cx, cy, char)
+    def fill_rect(x1, y1, x2, y2, char='#', width=80, height=25, clear_before_draw=False, color=None, bg=None):
+        points = Render.get_fill_rect_points(x1, y1, x2, y2, char, color, bg)
         Render.DrawPic(points=points, width=width, height=height, clear_before_draw=clear_before_draw)
 
     @staticmethod
-    def draw_torus_3d(radius=8, tube=3, segments=16, rotx=0, roty=0, rotz=0, scale=10, cx=40, cy=12, char='#', width=80, height=25, clear_before_draw=False):
-        points = Render.get_torus_3d_points(radius, tube, segments, rotx, roty, rotz, scale, cx, cy, char)
+    def draw_text(x, y, text, width=80, height=25, clear_before_draw=False, color=None, bg=None):
+        points = Render.get_text_points(x, y, text, color=color, bg=bg)
         Render.DrawPic(points=points, width=width, height=height, clear_before_draw=clear_before_draw)
 
     @staticmethod
-    def draw_ico_sphere_3d(radius=5, rotx=0, roty=0, rotz=0, scale=10, cx=40, cy=12, char='#', width=80, height=25, clear_before_draw=False):
-        points = Render.get_ico_sphere_3d_points(radius, rotx, roty, rotz, scale, cx, cy, char)
+    def draw_triangle(x1, y1, x2, y2, x3, y3, char='#', width=80, height=25, clear_before_draw=False, color=None, bg=None):
+        points = Render.get_triangle_points(x1, y1, x2, y2, x3, y3, char, color, bg)
         Render.DrawPic(points=points, width=width, height=height, clear_before_draw=clear_before_draw)
 
     @staticmethod
-    def draw_line(x1, y1, x2, y2, char='#', width=80, height=25, clear_before_draw=False):
-        points = Render.get_line_points(x1, y1, x2, y2, char)
+    def fill_triangle(x1, y1, x2, y2, x3, y3, char='#', width=80, height=25, clear_before_draw=False, color=None, bg=None):
+        points = Render.get_filled_triangle_points(x1, y1, x2, y2, x3, y3, char, color, bg)
         Render.DrawPic(points=points, width=width, height=height, clear_before_draw=clear_before_draw)
 
     @staticmethod
-    def draw_circle(cx, cy, r, char='#', width=80, height=25, clear_before_draw=False):
-        points = Render.get_circle_points(cx, cy, r, char)
+    def draw_heart(cx, cy, size=5, char='#', width=80, height=25, clear_before_draw=False, color=None, bg=None):
+        points = Render.get_heart_points(cx, cy, size, char, color, bg)
         Render.DrawPic(points=points, width=width, height=height, clear_before_draw=clear_before_draw)
 
     @staticmethod
-    def draw_filled_circle(cx, cy, r, char='#', width=80, height=25, clear_before_draw=False):
-        points = Render.get_filled_circle_points(cx, cy, r, char)
+    def draw_star(cx, cy, radius=5, points_count=5, char='#', width=80, height=25, clear_before_draw=False, color=None, bg=None):
+        points = Render.get_star_points(cx, cy, radius, points_count, char, color, bg)
         Render.DrawPic(points=points, width=width, height=height, clear_before_draw=clear_before_draw)
 
     @staticmethod
-    def draw_rect(x1, y1, x2, y2, char='#', width=80, height=25, clear_before_draw=False):
-        points = Render.get_rect_points(x1, y1, x2, y2, char)
+    def draw_bezier(x1, y1, x2, y2, x3, y3, steps=20, char='#', width=80, height=25, clear_before_draw=False, color=None, bg=None):
+        points = Render.get_bezier_points(x1, y1, x2, y2, x3, y3, steps, char, color, bg)
         Render.DrawPic(points=points, width=width, height=height, clear_before_draw=clear_before_draw)
 
     @staticmethod
-    def fill_rect(x1, y1, x2, y2, char='#', width=80, height=25, clear_before_draw=False):
-        points = Render.get_fill_rect_points(x1, y1, x2, y2, char)
+    def draw_wave(cx, cy, amplitude=5, length=20, char='~', width=80, height=25, clear_before_draw=False, color=None, bg=None):
+        points = Render.get_wave_points(cx, cy, amplitude, length, char, color, bg)
         Render.DrawPic(points=points, width=width, height=height, clear_before_draw=clear_before_draw)
 
     @staticmethod
-    def draw_text(x, y, text, width=80, height=25, clear_before_draw=False):
-        points = Render.get_text_points(x, y, text)
+    def draw_spiral(cx, cy, turns=3, radius=10, step=0.1, char='*', width=80, height=25, clear_before_draw=False, color=None, bg=None):
+        points = Render.get_spiral_points(cx, cy, turns, radius, step, char, color, bg)
         Render.DrawPic(points=points, width=width, height=height, clear_before_draw=clear_before_draw)
 
     @staticmethod
-    def draw_triangle(x1, y1, x2, y2, x3, y3, char='#', width=80, height=25, clear_before_draw=False):
-        points = Render.get_triangle_points(x1, y1, x2, y2, x3, y3, char)
+    def draw_grid(x1, y1, x2, y2, step=2, char='+', width=80, height=25, clear_before_draw=False, color=None, bg=None):
+        points = Render.get_grid_points(x1, y1, x2, y2, step, char, color, bg)
         Render.DrawPic(points=points, width=width, height=height, clear_before_draw=clear_before_draw)
 
     @staticmethod
-    def fill_triangle(x1, y1, x2, y2, x3, y3, char='#', width=80, height=25, clear_before_draw=False):
-        points = Render.get_filled_triangle_points(x1, y1, x2, y2, x3, y3, char)
+    def draw_noise(cx, cy, radius, count=50, char='.', width=80, height=25, clear_before_draw=False, color=None, bg=None):
+        points = Render.get_noise_points(cx, cy, radius, count, char, color, bg)
         Render.DrawPic(points=points, width=width, height=height, clear_before_draw=clear_before_draw)
 
     @staticmethod
-    def draw_heart(cx, cy, size=5, char='#', width=80, height=25, clear_before_draw=False):
-        points = Render.get_heart_points(cx, cy, size, char)
+    def draw_cube_3d(size=5, rotx=0, roty=0, rotz=0, scale=10, cx=40, cy=12, char='#', width=80, height=25, clear_before_draw=False, color=None, bg=None):
+        points = Render.get_cube_3d_points(size, rotx, roty, rotz, scale, cx, cy, char, color, bg)
         Render.DrawPic(points=points, width=width, height=height, clear_before_draw=clear_before_draw)
 
     @staticmethod
-    def draw_star(cx, cy, radius=5, points_count=5, char='#', width=80, height=25, clear_before_draw=False):
-        points = Render.get_star_points(cx, cy, radius, points_count, char)
+    def draw_pyramid_3d(size=5, rotx=0, roty=0, rotz=0, scale=10, cx=40, cy=12, char='#', width=80, height=25, clear_before_draw=False, color=None, bg=None):
+        points = Render.get_pyramid_3d_points(size, rotx, roty, rotz, scale, cx, cy, char, color, bg)
         Render.DrawPic(points=points, width=width, height=height, clear_before_draw=clear_before_draw)
 
     @staticmethod
-    def draw_bezier(x1, y1, x2, y2, x3, y3, steps=20, char='#', width=80, height=25, clear_before_draw=False):
-        points = Render.get_bezier_points(x1, y1, x2, y2, x3, y3, steps, char)
+    def draw_cylinder_3d(radius=5,segments=12, rotx=0, roty=0, rotz=0, scale=10, cx=40, cy=12, char='#', width=80, height=25, clear_before_draw=False, color=None, bg=None):
+        points = Render.get_cylinder_3d_points(radius, height, segments, rotx, roty, rotz, scale, cx, cy, char, color, bg)
         Render.DrawPic(points=points, width=width, height=height, clear_before_draw=clear_before_draw)
 
     @staticmethod
-    def draw_wave(cx, cy, amplitude=5, length=20, char='~', width=80, height=25, clear_before_draw=False):
-        points = Render.get_wave_points(cx, cy, amplitude, length, char)
+    def draw_sphere_3d(radius=5, segments=12, rotx=0, roty=0, rotz=0, scale=10, cx=40, cy=12, char='#', width=80, height=25, clear_before_draw=False, color=None, bg=None):
+        points = Render.get_sphere_3d_points(radius, segments, rotx, roty, rotz, scale, cx, cy, char, color, bg)
         Render.DrawPic(points=points, width=width, height=height, clear_before_draw=clear_before_draw)
 
     @staticmethod
-    def draw_spiral(cx, cy, turns=3, radius=10, step=0.1, char='*', width=80, height=25, clear_before_draw=False):
-        points = Render.get_spiral_points(cx, cy, turns, radius, step, char)
+    def draw_cone_3d(radius=5, segments=12, rotx=0, roty=0, rotz=0, scale=10, cx=40, cy=12, char='#', width=80, height=25, clear_before_draw=False, color=None, bg=None):
+        points = Render.get_cone_3d_points(radius, height, segments, rotx, roty, rotz, scale, cx, cy, char, color, bg)
         Render.DrawPic(points=points, width=width, height=height, clear_before_draw=clear_before_draw)
 
     @staticmethod
-    def draw_grid(x1, y1, x2, y2, step=2, char='+', width=80, height=25, clear_before_draw=False):
-        points = Render.get_grid_points(x1, y1, x2, y2, step, char)
+    def draw_torus_3d(radius=8, tube=3, segments=16, rotx=0, roty=0, rotz=0, scale=10, cx=40, cy=12, char='#', width=80, height=25, clear_before_draw=False, color=None, bg=None):
+        points = Render.get_torus_3d_points(radius, tube, segments, rotx, roty, rotz, scale, cx, cy, char, color, bg)
         Render.DrawPic(points=points, width=width, height=height, clear_before_draw=clear_before_draw)
 
     @staticmethod
-    def draw_noise(cx, cy, radius, count=50, char='.', width=80, height=25, clear_before_draw=False):
-        points = Render.get_noise_points(cx, cy, radius, count, char)
+    def draw_ico_sphere_3d(radius=5, rotx=0, roty=0, rotz=0, scale=10, cx=40, cy=12, char='#', width=80, height=25, clear_before_draw=False, color=None, bg=None):
+        points = Render.get_ico_sphere_3d_points(radius, rotx, roty, rotz, scale, cx, cy, char, color, bg)
         Render.DrawPic(points=points, width=width, height=height, clear_before_draw=clear_before_draw)
 
+
 class ConsoleInfo:
     @staticmethod
     def GetConsole():

{consolelib-1.3.3 → consolelib-1.3.4}/ConsoleLib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ConsoleLib
-Version: 1.3.3
+Version: 1.3.4
 Summary: The library for easy and best control on the Console.
 Author-email: Suleiman <steal.apet@mail.ru>
 License: MIT

{consolelib-1.3.3 → consolelib-1.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ConsoleLib
-Version: 1.3.3
+Version: 1.3.4
 Summary: The library for easy and best control on the Console.
 Author-email: Suleiman <steal.apet@mail.ru>
 License: MIT

{consolelib-1.3.3 → consolelib-1.3.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ConsoleLib"
-version = "1.3.3"
+version = "1.3.4"
 description = "The library for easy and best control on the Console."
 authors = [{name = "Suleiman", email = "steal.apet@mail.ru"}]
 readme = "README.md"