ConsoleFramework 0.9.2__py3-none-any.whl

ConsoleFramework/__init__.py

@@ -0,0 +1,771 @@
+"""
+ConsoleFramework - The best Console Library of the Python.
+By: Suleiman
+Copyright © Suleiman 2026
+All rights are reserved.
+"""
+import os
+import sys
+import time
+import math
+import random
+import socket
+import subprocess as CMD
+import threading
+from http.server import HTTPServer, BaseHTTPRequestHandler
+import urllib.request
+import urllib.parse
+class Colors:
+    RESET = "\033[0m"
+    RED = "\033[31m"
+    GREEN = "\033[32m"
+    BLUE = "\033[34m"
+    CYAN = "\033[36m"
+    MAGENTA = "\033[35m"
+    YELLOW = "\033[33m"
+    WHITE = "\033[37m"
+    BLACK = "\033[30m"
+    BG_RED = "\033[41m"
+    BG_GREEN = "\033[42m"
+    BG_BLUE = "\033[44m"
+    BG_CYAN = "\033[46m"
+    BG_MAGENTA = "\033[45m"
+    BG_YELLOW = "\033[43m"
+    BG_WHITE = "\033[47m"
+    BG_BLACK = "\033[40m"
+    BOLD = "\033[1m"
+    DIM = "\033[2m"
+    ITALIC = "\033[3m"
+    UNDERLINE = "\033[4m"
+    BLINK = "\033[5m"
+    REVERSE = "\033[7m"
+    HIDDEN = "\033[8m"
+    STRIKE = "\033[9m"
+    
+    @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 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[0], item[1], item[2]
+                    if 0 <= x < width and 0 <= y < height:
+                        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))
+    @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='#', color=None, bg=None):
+        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 Render._apply_color(points, color, bg)
+
+    @staticmethod
+    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 Render._apply_color(points, color, bg)
+
+    @staticmethod
+    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 Render._apply_color(points, color, bg)
+
+    @staticmethod
+    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))
+            points.append((x, y2, char))
+        for y in range(y1, y2 + 1):
+            points.append((x1, y, char))
+            points.append((x2, y, char))
+        return Render._apply_color(points, color, bg)
+
+    @staticmethod
+    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 Render._apply_color(points, color, bg)
+
+    @staticmethod
+    def get_text_points(x, y, text, char=None, color=None, bg=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 Render._apply_color(points, color, bg)
+
+    @staticmethod
+    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 Render._apply_color(points, color, bg)
+
+    @staticmethod
+    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)
+        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 Render._apply_color(points, color, bg)
+
+    @staticmethod
+    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 Render._apply_color(points, color, bg)
+
+    @staticmethod
+    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
+        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 Render._apply_color(points, color, bg)
+
+    @staticmethod
+    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 Render._apply_color(points, color, bg)
+
+    @staticmethod
+    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 Render._apply_color(points, color, bg)
+
+    @staticmethod
+    def get_spiral_points(cx, cy, turns=3, radius=10, step=0.1, char='*', color=None, bg=None):
+        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 Render._apply_color(points, color, bg)
+
+    @staticmethod
+    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 Render._apply_color(points, color, bg)
+
+    @staticmethod
+    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)
+            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 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):
+            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='#', color=None, bg=None):
+        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 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='#', color=None, bg=None):
+        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 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='#', color=None, bg=None):
+        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 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='#', color=None, bg=None):
+        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 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='#', color=None, bg=None):
+        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 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='#', color=None, bg=None):
+        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 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='#', color=None, bg=None):
+        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 Render._apply_color(points, color, bg)
+
+class Animate:
+    @staticmethod
+    def clear_screen():
+        os.system("cls" if os.name == "nt" else "clear")
+    
+    @staticmethod
+    def animate_print(text, delay=0.05, end="\n", flush=True, backspace_effect=False):
+        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)
+        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()
+    
+    @staticmethod
+    def spinning_cursor(message="Loading", duration=3.0, delay=0.1, frames=None, clear_before=False):
+        if clear_before:
+            Animate.clear_screen()
+        if frames is None:
+            frames = ["|", "/", "-", "\\"]
+        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()
+    
+    @staticmethod
+    def countdown(seconds, message="Countdown", clear_before=False):
+        if clear_before:
+            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 Keyboard:
+    @staticmethod
+    def GetKey():
+        try:
+            import termios
+            import tty
+            fd = sys.stdin.fileno()
+            old = termios.tcgetattr(fd)
+            try:
+                tty.setraw(fd)
+                return sys.stdin.read(1)
+            finally:
+                termios.tcsetattr(fd, termios.TCSADRAIN, old)
+        except:
+            import msvcrt
+            return msvcrt.getch().decode()
+
+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:
+            return "Error: pip not found"
+
+class Process:
+    @staticmethod
+    def StartPyCode(code, wait=False, args=None, python="python"):
+        try:
+            cmd = [python, "-c", code]
+            if args:
+                cmd.extend(args)
+            if wait:
+                proc = CMD.run(cmd, capture_output=True, text=True)
+                return proc
+            else:
+                proc = CMD.Popen(cmd)
+                return proc
+        except Exception as e:
+            print(f"Error executing code: {e}")
+            return None
+
+    @staticmethod
+    def KillPyScript(pid):
+        try:
+            os.kill(pid, 15)
+            time.sleep(0.2)
+            return True
+        except ProcessLookupError:
+            print(f"Process {pid} not found")
+            return False
+        except PermissionError:
+            print(f"Permission denied to kill process {pid}")
+            return False
+        except Exception as e:
+            print(f"Error killing process: {e}")
+            return False
+
+    @staticmethod
+    def KillPyScriptForce(pid):
+        try:
+            os.kill(pid, 9)
+            return True
+        except ProcessLookupError:
+            print(f"Process {pid} not found")
+            return False
+        except PermissionError:
+            print(f"Permission denied to kill process {pid}")
+            return False
+        except Exception as e:
+            print(f"Error killing process: {e}")
+            return False
+
+    @staticmethod
+    def IsRunning(pid):
+        try:
+            os.kill(pid, 0)
+            return True
+        except ProcessLookupError:
+            return False
+        except PermissionError:
+            return True
+
+    @staticmethod
+    def GetProcessList():
+        try:
+            result = CMD.run(['ps', '-e', '-o', 'pid,comm'], capture_output=True, text=True)
+            lines = result.stdout.strip().split('\n')[1:]
+            processes = []
+            for line in lines:
+                parts = line.strip().split(' ', 1)
+                if len(parts) == 2:
+                    pid = int(parts[0])
+                    name = parts[1]
+                    processes.append({'pid': pid, 'name': name})
+            return processes
+        except Exception:
+            return []
+
+    @staticmethod
+    def GetProcessInfo(pid):
+        try:
+            result = CMD.run(['ps', '-p', str(pid), '-o', 'pid,comm,%cpu,%mem,etime'], capture_output=True, text=True)
+            lines = result.stdout.strip().split('\n')
+            if len(lines) < 2:
+                return None
+            parts = lines[1].strip().split()
+            if len(parts) >= 5:
+                return {
+                    'pid': int(parts[0]),
+                    'name': parts[1],
+                    'cpu': parts[2],
+                    'memory': parts[3],
+                    'time': parts[4]
+                }
+            return None
+        except Exception:
+            return None
+
+    @staticmethod
+    def WaitForProcess(pid, timeout=None):
+        start_time = time.time()
+        while Process.IsRunning(pid):
+            if timeout and (time.time() - start_time) > timeout:
+                return False
+            time.sleep(0.5)
+        return True
+
+    @staticmethod
+    def GetCurrentPID():
+        return os.getpid()
+
+class Channel:
+    def __init__(self):
+        self.connection = None
+        self.host = None
+        self.port = None
+        self.is_server = False
+
+    @staticmethod
+    def _get(url, timeout=5):
+        try:
+            import urllib.request
+            with urllib.request.urlopen(url, timeout=timeout) as response:
+                return response.read().decode()
+        except Exception:
+            return None
+
+    @staticmethod
+    def GetPublicIP():
+        ip = Channel._get('https://api.ipify.org')
+        return ip
+
+    def Connect(self, host='127.0.0.1', port=54321):
+        self.host = host
+        self.port = port
+        try:
+            self.connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            self.connection.connect((host, port))
+            return self.connection
+        except Exception as e:
+            print(f"[Error] Connection failed: {e}")
+            return None
+
+    def ConnectPublic(self, port=54321):
+        public_ip = Channel.GetPublicIP()
+        if not public_ip:
+            print("[Error] Could not get public IP")
+            return None
+        return self.Connect(host=public_ip, port=port)
+
+    def CreateServer(self, port=54321):
+        self.is_server = True
+        self.port = port
+        try:
+            server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            server.bind(('0.0.0.0', port))
+            server.listen(1)
+            self.connection, addr = server.accept()
+            return self.connection
+        except Exception as e:
+            print(f"[Error] Server failed: {e}")
+            return None
+
+    def Disconnect(self):
+        if self.connection:
+            self.connection.close()
+            self.connection = None
+
+    def Send(self, message):
+        if not self.connection:
+            return False
+        try:
+            if isinstance(message, str):
+                message = message.encode()
+            self.connection.send(message + b'\n')
+            return True
+        except Exception:
+            return False
+
+    def Receive(self):
+        if not self.connection:
+            return None
+        try:
+            data = self.connection.recv(1024).decode().strip()
+            return data
+        except Exception:
+            return None
+
+class Web:
+    @staticmethod
+    def StartHTMLCode(html_content, port=None):
+        if port is None:
+            port = Web._get_free_port()
+        class Handler(BaseHTTPRequestHandler):
+            def do_GET(self):
+                self.send_response(200)
+                self.send_header("Content-type", "text/html")
+                self.end_headers()
+                self.wfile.write(html_content.encode("utf-8"))
+        server = HTTPServer(("127.0.0.1", port), Handler)
+        thread = threading.Thread(target=server.serve_forever, daemon=True)
+        thread.start()
+        return port
+    @staticmethod
+    def _get_free_port():
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            s.bind(("", 0))
+            s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            return s.getsockname()[1]

consoleframework-0.9.2.dist-info/METADATA

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: ConsoleFramework
+Version: 0.9.2
+Summary: The best Console Library of the Python.
+Author: Suleiman
+Author-email: steal.apet@mail.ru
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/plain
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary
+
+ConsoleFramework - Pure Python library for console rendering, animations, processes and more. In this module ONLY standart python, no other modules.

consoleframework-0.9.2.dist-info/RECORD

@@ -0,0 +1,6 @@
+ConsoleFramework/__init__.py,sha256=s6-BS6Lle3GIg-rk1Y7RHI2z2EracMjnobpi6BStLBE,27076
+consoleframework-0.9.2.dist-info/licenses/LICENSE,sha256=XABCXMEhX5-sSW6dVui3V35LHqtlwNF4Rj0Rfhuo4_8,1064
+consoleframework-0.9.2.dist-info/METADATA,sha256=OWuy19ZkBCf3wXg4JrndLvshZheV3A2Q1jTgOtlh2Hw,744
+consoleframework-0.9.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+consoleframework-0.9.2.dist-info/top_level.txt,sha256=gA6Vt8NYCghRZGB3TIpgf-e9w61A1zfOrxTMf-ZEoh0,17
+consoleframework-0.9.2.dist-info/RECORD,,

consoleframework-0.9.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

consoleframework-0.9.2.dist-info/licenses/LICENSE

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

consoleframework-0.9.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+ConsoleFramework