ConsoleLib 1.3.0__tar.gz → 1.3.2__tar.gz

consolelib-1.3.2/ConsoleLib/__init__.py

@@ -0,0 +1,676 @@
+"""
+ConsoleLib - The best Console Renderer of the Python.
+By: Suleiman
+Copyright © Suleiman 2026
+All rights are reserved.
+"""
+import os
+import sys
+import time
+import subprocess as CMD
+import math
+import random
+from typing import Optional, Iterator, List
+class Animate:
+    def clear_screen():
+        os.system('cls' if os.name == 'nt' else 'clear')    
+    class ProgressBar:
+        def __init__(
+            self,
+            total: int,
+            prefix: str = "Progress:",
+            suffix: str = "Complete",
+            length: int = 40,
+            fill: str = "█",
+            empty: str = "░",
+            show_percent: bool = True,
+            show_counter: bool = True,
+            auto_clear: bool = False,
+            clear_delay: float = 0.5,
+        ):
+            self.total = total
+            self.prefix = prefix
+            self.suffix = suffix
+            self.length = length
+            self.fill = fill
+            self.empty = empty
+            self.show_percent = show_percent
+            self.show_counter = show_counter
+            self.auto_clear = auto_clear
+            self.clear_delay = clear_delay
+            self.current = 0
+            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:
+                    return
+                self.current = max(0, min(value, self.total))
+                self._print_bar()
+                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)
+            bar = self.fill * filled_len + self.empty * (self.length - filled_len)
+            parts = [self.prefix, f"[{bar}]"]
+            if self.show_percent:
+                parts.append(f"{percent:.1%}")
+            if self.show_counter:
+                parts.append(f"({self.current}/{self.total})")
+            if self.suffix:
+                parts.append(self.suffix)
+            line = " ".join(parts)
+            sys.stdout.write("\r" + line)
+            sys.stdout.flush()
+    
+        def __enter__(self):
+            if self.auto_clear and not self._cleared:
+                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,
+        end: str = "\n",
+        flush: bool = True,
+        backspace_effect: bool = False,
+    ) -> None:
+        if backspace_effect:
+            for ch in text:
+                sys.stdout.write(ch)
+                sys.stdout.flush()
+                time.sleep(delay)
+            time.sleep(0.2)
+            for _ in text:
+                sys.stdout.write("\b \b")
+                sys.stdout.flush()
+                time.sleep(delay / 2)
+            for ch in text:
+                sys.stdout.write(ch)
+                sys.stdout.flush()
+                time.sleep(delay)
+            sys.stdout.write(end)
+            sys.stdout.flush()
+        else:
+            for ch in text:
+                sys.stdout.write(ch)
+                if flush:
+                    sys.stdout.flush()
+                time.sleep(delay)
+            sys.stdout.write(end)
+            if flush:
+                sys.stdout.flush()
+    def spinning_cursor(
+        message: str = "Loading",
+        duration: float = 3.0,
+        delay: float = 0.1,
+        frames: Optional[List[str]] = None,
+        clear_before: bool = False,
+    ) -> None:
+        if clear_before:
+            clear_screen()        
+        if frames is None:
+            frames = ["|", "/", "-", r"\\"]
+        end_time = time.time() + duration
+        idx = 0
+        while time.time() < end_time:
+            frame = frames[idx % len(frames)]
+            sys.stdout.write(f"\r{message} {frame} ")
+            sys.stdout.flush()
+            time.sleep(delay)
+            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()       
+        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:
+    @staticmethod
+    def DrawPic(points=None, width=80, height=25, clear_before_draw=False, default_char=' '):
+        if clear_before_draw:
+            os.system("cls" if os.name == "nt" else "clear")
+        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 0 <= x < width and 0 <= y < height:
+                        field[y][x] = char
+        for row in field:
+            print(''.join(row))
+
+    @staticmethod
+    def get_line_points(x1, y1, x2, y2, char='#'):
+        points = []
+        dx = abs(x2 - x1)
+        dy = abs(y2 - y1)
+        sx = 1 if x1 < x2 else -1
+        sy = 1 if y1 < y2 else -1
+        err = dx - dy
+        while True:
+            points.append((x1, y1, char))
+            if x1 == x2 and y1 == y2:
+                break
+            e2 = err * 2
+            if e2 > -dy:
+                err -= dy
+                x1 += sx
+            if e2 < dx:
+                err += dx
+                y1 += sy
+        return points
+
+    @staticmethod
+    def get_circle_points(cx, cy, r, char='#'):
+        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
+
+    @staticmethod
+    def get_filled_circle_points(cx, cy, r, char='#'):
+        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
+
+    @staticmethod
+    def get_rect_points(x1, y1, x2, y2, char='#'):
+        points = []
+        for x in range(x1, x2 + 1):
+            points.append((x, y1, char))
+            points.append((x, y2, char))
+        for y in range(y1, y2 + 1):
+            points.append((x1, y, char))
+            points.append((x2, y, char))
+        return points
+
+    @staticmethod
+    def get_fill_rect_points(x1, y1, x2, y2, char='#'):
+        points = []
+        for y in range(y1, y2 + 1):
+            for x in range(x1, x2 + 1):
+                points.append((x, y, char))
+        return points
+
+    @staticmethod
+    def get_text_points(x, y, text, char=None):
+        points = []
+        if char is None:
+            for i, ch in enumerate(text):
+                points.append((x + i, y, ch))
+        else:
+            for i in range(len(text)):
+                points.append((x + i, y, char))
+        return points
+
+    @staticmethod
+    def get_triangle_points(x1, y1, x2, y2, x3, y3, char='#'):
+        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
+
+    @staticmethod
+    def get_filled_triangle_points(x1, y1, x2, y2, x3, y3, char='#'):
+        points = []
+        min_x = min(x1, x2, x3)
+        max_x = max(x1, x2, x3)
+        min_y = min(y1, y2, y3)
+        max_y = max(y1, y2, y3)
+        for y in range(min_y, max_y + 1):
+            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
+
+    @staticmethod
+    def get_heart_points(cx, cy, size=5, char='#'):
+        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
+
+    @staticmethod
+    def get_star_points(cx, cy, radius=5, points_count=5, char='*'):
+        points = []
+        angle = -math.pi / 2
+        step = math.pi / points_count
+        outer_points = []
+        inner_points = []
+        for i in range(points_count * 2):
+            r = radius if i % 2 == 0 else radius * 0.4
+            x = cx + r * math.cos(angle + i * step)
+            y = cy + r * math.sin(angle + i * step)
+            if i % 2 == 0:
+                outer_points.append((x, y))
+            else:
+                inner_points.append((x, y))
+        for i in range(points_count):
+            p1 = outer_points[i]
+            p2 = inner_points[i]
+            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
+
+    @staticmethod
+    def get_bezier_points(x1, y1, x2, y2, x3, y3, steps=20, char='#'):
+        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
+
+    @staticmethod
+    def get_wave_points(cx, cy, amplitude=5, length=20, char='~'):
+        points = []
+        for x in range(length):
+            y = cy + int(amplitude * math.sin(x * 0.5))
+            points.append((cx + x, y, char))
+        return points
+
+    @staticmethod
+    def get_spiral_points(cx, cy, turns=3, radius=10, step=0.1, char='*'):
+        points = []
+        angle = 0
+        r = 0
+        while r < radius:
+            x = int(cx + r * math.cos(angle))
+            y = int(cy + r * math.sin(angle))
+            points.append((x, y, char))
+            angle += step
+            r += step * 2
+        return points
+
+    @staticmethod
+    def get_grid_points(x1, y1, x2, y2, step=2, char='+'):
+        points = []
+        for x in range(x1, x2 + 1, step):
+            for y in range(y1, y2 + 1, step):
+                points.append((x, y, char))
+        return points
+
+    @staticmethod
+    def get_noise_points(cx, cy, radius, count=50, char='.'):
+        points = []
+        for _ in range(count):
+            angle = random.uniform(0, 2 * math.pi)
+            r = random.uniform(0, radius)
+            x = int(cx + r * math.cos(angle))
+            y = int(cy + r * math.sin(angle))
+            points.append((x, y, char))
+        return points
+
+    @staticmethod
+    def _point_in_triangle(px, py, x1, y1, x2, y2, x3, y3):
+        def sign(a, b, c):
+            return (a[0] - c[0]) * (b[1] - c[1]) - (b[0] - c[0]) * (a[1] - c[1])
+        p = (px, py)
+        d1 = sign(p, (x2, y2), (x1, y1))
+        d2 = sign(p, (x3, y3), (x2, y2))
+        d3 = sign(p, (x1, y1), (x3, y3))
+        has_neg = (d1 < 0) or (d2 < 0) or (d3 < 0)
+        has_pos = (d1 > 0) or (d2 > 0) or (d3 > 0)
+        return not (has_neg and has_pos)
+
+    @staticmethod
+    def _rotx(x, y, z, angle):
+        rad = math.radians(angle)
+        cos_a = math.cos(rad)
+        sin_a = math.sin(rad)
+        y_new = y * cos_a - z * sin_a
+        z_new = y * sin_a + z * cos_a
+        return x, y_new, z_new
+
+    @staticmethod
+    def _roty(x, y, z, angle):
+        rad = math.radians(angle)
+        cos_a = math.cos(rad)
+        sin_a = math.sin(rad)
+        x_new = x * cos_a + z * sin_a
+        z_new = -x * sin_a + z * cos_a
+        return x_new, y, z_new
+
+    @staticmethod
+    def _rotz(x, y, z, angle):
+        rad = math.radians(angle)
+        cos_a = math.cos(rad)
+        sin_a = math.sin(rad)
+        x_new = x * cos_a - y * sin_a
+        y_new = x * sin_a + y * cos_a
+        return x_new, y_new, z
+
+    @staticmethod
+    def _project_3d(x, y, z, rotx, roty, rotz, scale, cx, cy):
+        x, y, z = Render._rotx(x, y, z, rotx)
+        x, y, z = Render._roty(x, y, z, roty)
+        x, y, z = Render._rotz(x, y, z, rotz)
+        x2d = int(x * scale + cx)
+        y2d = int(-y * scale + cy)
+        return x2d, y2d
+
+    @staticmethod
+    def get_cube_3d_points(size=5, rotx=0, roty=0, rotz=0, scale=10, cx=40, cy=12, char='#'):
+        s = size / 2
+        vertices = [
+            (-s, -s, -s), (s, -s, -s), (s, s, -s), (-s, s, -s),
+            (-s, -s, s), (s, -s, s), (s, s, s), (-s, s, s)
+        ]
+        edges = [
+            (0,1), (1,2), (2,3), (3,0),
+            (4,5), (5,6), (6,7), (7,4),
+            (0,4), (1,5), (2,6), (3,7)
+        ]
+        points = []
+        projected = []
+        for v in vertices:
+            x2d, y2d = Render._project_3d(v[0], v[1], v[2], rotx, roty, rotz, scale, cx, cy)
+            projected.append((x2d, y2d))
+        for edge in edges:
+            x1, y1 = projected[edge[0]]
+            x2, y2 = projected[edge[1]]
+            points.extend(Render.get_line_points(x1, y1, x2, y2, char))
+        return points
+
+    @staticmethod
+    def get_pyramid_3d_points(size=5, rotx=0, roty=0, rotz=0, scale=10, cx=40, cy=12, char='#'):
+        s = size / 2
+        vertices = [
+            (-s, -s, -s), (s, -s, -s), (s, -s, s), (-s, -s, s),
+            (0, s, 0)
+        ]
+        edges = [
+            (0,1), (1,2), (2,3), (3,0),
+            (0,4), (1,4), (2,4), (3,4)
+        ]
+        points = []
+        projected = []
+        for v in vertices:
+            x2d, y2d = Render._project_3d(v[0], v[1], v[2], rotx, roty, rotz, scale, cx, cy)
+            projected.append((x2d, y2d))
+        for edge in edges:
+            x1, y1 = projected[edge[0]]
+            x2, y2 = projected[edge[1]]
+            points.extend(Render.get_line_points(x1, y1, x2, y2, char))
+        return points
+
+    @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='#'):
+        points = []
+        top_points = []
+        bottom_points = []
+        for i in range(segments):
+            rad = i / segments * 2 * math.pi
+            x = radius * math.cos(rad)
+            z = radius * math.sin(rad)
+            top_points.append((x, height/2, z))
+            bottom_points.append((x, -height/2, z))
+        all_vertices = top_points + bottom_points
+        projected = []
+        for v in all_vertices:
+            x2d, y2d = Render._project_3d(v[0], v[1], v[2], rotx, roty, rotz, scale, cx, cy)
+            projected.append((x2d, y2d))
+        for i in range(segments):
+            j = (i + 1) % segments
+            x1, y1 = projected[i]
+            x2, y2 = projected[j]
+            points.extend(Render.get_line_points(x1, y1, x2, y2, char))
+            x1, y1 = projected[i + segments]
+            x2, y2 = projected[j + segments]
+            points.extend(Render.get_line_points(x1, y1, x2, y2, char))
+            x1, y1 = projected[i]
+            x2, y2 = projected[i + segments]
+            points.extend(Render.get_line_points(x1, y1, x2, y2, char))
+        return points
+
+    @staticmethod
+    def get_sphere_3d_points(radius=5, segments=12, rotx=0, roty=0, rotz=0, scale=10, cx=40, cy=12, char='#'):
+        points = []
+        for i in range(segments):
+            theta = i / segments * math.pi
+            for j in range(segments):
+                phi = j / segments * 2 * math.pi
+                x = radius * math.sin(theta) * math.cos(phi)
+                y = radius * math.cos(theta)
+                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
+
+    @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='#'):
+        points = []
+        base_points = []
+        for i in range(segments):
+            rad = i / segments * 2 * math.pi
+            x = radius * math.cos(rad)
+            z = radius * math.sin(rad)
+            base_points.append((x, -height/2, z))
+        apex = (0, height/2, 0)
+        all_vertices = base_points + [apex]
+        projected = []
+        for v in all_vertices:
+            x2d, y2d = Render._project_3d(v[0], v[1], v[2], rotx, roty, rotz, scale, cx, cy)
+            projected.append((x2d, y2d))
+        for i in range(segments):
+            j = (i + 1) % segments
+            x1, y1 = projected[i]
+            x2, y2 = projected[j]
+            points.extend(Render.get_line_points(x1, y1, x2, y2, char))
+            x1, y1 = projected[i]
+            x2, y2 = projected[-1]
+            points.extend(Render.get_line_points(x1, y1, x2, y2, char))
+        return points
+
+    @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='#'):
+        points = []
+        for i in range(segments):
+            theta = i / segments * 2 * math.pi
+            for j in range(segments):
+                phi = j / segments * 2 * math.pi
+                x = (radius + tube * math.cos(phi)) * math.cos(theta)
+                y = tube * math.sin(phi)
+                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
+
+    @staticmethod
+    def get_ico_sphere_3d_points(radius=5, rotx=0, roty=0, rotz=0, scale=10, cx=40, cy=12, char='#'):
+        points = []
+        phi = (1 + math.sqrt(5)) / 2
+        vertices = [
+            (-1,  phi, 0), ( 1,  phi, 0), (-1, -phi, 0), ( 1, -phi, 0),
+            ( 0, -1,  phi), ( 0,  1,  phi), ( 0, -1, -phi), ( 0,  1, -phi),
+            ( phi, 0, -1), ( phi, 0,  1), (-phi, 0, -1), (-phi, 0,  1)
+        ]
+        vertices = [(x * radius / 1.618, y * radius / 1.618, z * radius / 1.618) for x, y, z in vertices]
+        edges = [
+            (0,1), (0,4), (0,5), (0,10), (0,11),
+            (1,2), (1,5), (1,7), (1,8), (1,9),
+            (2,3), (2,6), (2,7), (2,10), (2,11),
+            (3,4), (3,6), (3,8), (3,9), (3,11),
+            (4,5), (4,9), (4,11),
+            (5,7), (5,9),
+            (6,7), (6,10),
+            (7,8),
+            (8,9), (8,10),
+            (10,11)
+        ]
+        projected = []
+        for v in vertices:
+            x2d, y2d = Render._project_3d(v[0], v[1], v[2], rotx, roty, rotz, scale, cx, cy)
+            projected.append((x2d, y2d))
+        for edge in edges:
+            x1, y1 = projected[edge[0]]
+            x2, y2 = projected[edge[1]]
+            points.extend(Render.get_line_points(x1, y1, x2, y2, char))
+        return points
+
+    @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)
+        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)
+        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)
+        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)
+        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)
+        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)
+        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)
+        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)
+        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)
+        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)
+        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)
+        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)
+        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)
+        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)
+        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)
+        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)
+        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)
+        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)
+        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)
+        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)
+        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)
+        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)
+        Render.DrawPic(points=points, width=width, height=height, clear_before_draw=clear_before_draw)
+
+class ConsoleInfo:
+    @staticmethod
+    def GetConsole():
+        return sys.stdout
+
+    @staticmethod
+    def GetPipVer():
+        try:
+            result = CMD.run(['python', '-m', 'pip', '--version'], capture_output=True, text=True, check=True)
+            return result.stdout.strip()
+        except CMD.CalledProcessError as e:
+            return f"Error: pip not found (code {e.returncode})"
+        except FileNotFoundError:
+            return "Error: Python not installed or not in PATH"

{consolelib-1.3.0 → consolelib-1.3.2}/ConsoleLib.egg-info/PKG-INFO

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

{consolelib-1.3.0 → consolelib-1.3.2}/PKG-INFO

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

{consolelib-1.3.0 → consolelib-1.3.2}/pyproject.toml

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

consolelib-1.3.0/ConsoleLib/__init__.py

@@ -1,226 +0,0 @@
-"""
-ConsoleLib - The best Console Renderer of the Python.
-By: Suleiman
-Copyright © Suleiman 2026
-All rights are reserved.
-"""
-import os
-import sys
-import time
-import subprocess as CMD
-import math
-class Render:
-    @staticmethod
-    def DrawPic(points=None, width=80, height=25, clear_before_draw=False, default_char=' '):
-        if clear_before_draw:
-            os.system("cls" if os.name == "nt" else "clear")
-        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 0 <= x < width and 0 <= y < height:
-                        field[y][x] = char
-        for row in field:
-            print(''.join(row))
-    @staticmethod
-    def get_line_points(x1, y1, x2, y2, char='#'):
-        points = []
-        dx = abs(x2 - x1)
-        dy = abs(y2 - y1)
-        sx = 1 if x1 < x2 else -1
-        sy = 1 if y1 < y2 else -1
-        err = dx - dy
-        while True:
-            points.append((x1, y1, char))
-            if x1 == x2 and y1 == y2:
-                break
-            e2 = err * 2
-            if e2 > -dy:
-                err -= dy
-                x1 += sx
-            if e2 < dx:
-                err += dx
-                y1 += sy
-        return points
-    @staticmethod
-    def get_circle_points(cx, cy, r, char='#'):
-        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
-    @staticmethod
-    def get_filled_circle_points(cx, cy, r, char='#'):
-        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
-    @staticmethod
-    def get_rect_points(x1, y1, x2, y2, char='#'):
-        points = []
-        for x in range(x1, x2 + 1):
-            points.append((x, y1, char))
-            points.append((x, y2, char))
-        for y in range(y1, y2 + 1):
-            points.append((x1, y, char))
-            points.append((x2, y, char))
-        return points
-    @staticmethod
-    def get_fill_rect_points(x1, y1, x2, y2, char='#'):
-        points = []
-        for y in range(y1, y2 + 1):
-            for x in range(x1, x2 + 1):
-                points.append((x, y, char))
-        return points
-    @staticmethod
-    def get_text_points(x, y, text, char=None):
-        points = []
-        if char is None:
-            for i, ch in enumerate(text):
-                points.append((x + i, y, ch))
-        else:
-            for i in range(len(text)):
-                points.append((x + i, y, char))
-        return points
-    @staticmethod
-    def get_triangle_points(x1, y1, x2, y2, x3, y3, char='#'):
-        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
-    @staticmethod
-    def get_filled_triangle_points(x1, y1, x2, y2, x3, y3, char='#'):
-        points = []
-        min_x = min(x1, x2, x3)
-        max_x = max(x1, x2, x3)
-        min_y = min(y1, y2, y3)
-        max_y = max(y1, y2, y3)
-        for y in range(min_y, max_y + 1):
-            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
-    @staticmethod
-    def get_heart_points(cx, cy, size=5, char='#'):
-        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
-    @staticmethod
-    def get_star_points(cx, cy, radius=5, points_count=5, char='*'):
-        points = []
-        angle = -math.pi / 2
-        step = math.pi / points_count
-        outer_points = []
-        inner_points = []
-        for i in range(points_count * 2):
-            r = radius if i % 2 == 0 else radius * 0.4
-            x = cx + r * math.cos(angle + i * step)
-            y = cy + r * math.sin(angle + i * step)
-            if i % 2 == 0:
-                outer_points.append((x, y))
-            else:
-                inner_points.append((x, y))
-        for i in range(points_count):
-            p1 = outer_points[i]
-            p2 = inner_points[i]
-            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
-    @staticmethod
-    def get_bezier_points(x1, y1, x2, y2, x3, y3, steps=20, char='#'):
-        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
-    @staticmethod
-    def get_wave_points(cx, cy, amplitude=5, length=20, char='~'):
-        points = []
-        for x in range(length):
-            y = cy + int(amplitude * math.sin(x * 0.5))
-            points.append((cx + x, y, char))
-        return points
-    @staticmethod
-    def _point_in_triangle(px, py, x1, y1, x2, y2, x3, y3):
-        def sign(a, b, c):
-            return (a[0] - c[0]) * (b[1] - c[1]) - (b[0] - c[0]) * (a[1] - c[1])
-        p = (px, py)
-        d1 = sign(p, (x2, y2), (x1, y1))
-        d2 = sign(p, (x3, y3), (x2, y2))
-        d3 = sign(p, (x1, y1), (x3, y3))
-        has_neg = (d1 < 0) or (d2 < 0) or (d3 < 0)
-        has_pos = (d1 > 0) or (d2 > 0) or (d3 > 0)
-        return not (has_neg and has_pos)
-    @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)
-        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)
-        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)
-        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)
-        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)
-        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)
-        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)
-        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)
-        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)
-        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)
-        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)
-        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)
-        Render.DrawPic(points=points, width=width, height=height, clear_before_draw=clear_before_draw)
-class ConsoleInfo:
-    @staticmethod
-    def GetConsole():
-        return sys.stdout
-    @staticmethod
-    def GetPipVer():
-        try:
-            result = CMD.run(['python', '-m', 'pip', '--version'], capture_output=True, text=True, check=True)
-            return result.stdout.strip()
-        except CMD.CalledProcessError as e:
-            return f"Error: pip not found (code {e.returncode})"
-        except FileNotFoundError:
-            return "Error: Python not installed or not in PATH"