ConsoleFramework 2.0.2__tar.gz → 2.0.4__tar.gz

{consoleframework-2.0.2 → consoleframework-2.0.4}/ConsoleFramework/__init__.py

@@ -19,6 +19,8 @@ import stat
 import subprocess as CMD
 import threading
 import urllib.request
+import urllib.parse
+import base64
 class Colors:
     RESET = "\033[0m"
     RED = "\033[31m"
@@ -67,15 +69,39 @@ 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))
-    
     @staticmethod
-    def get_line_points(x1, y1, x2, y2, char='#'):
+    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)
@@ -93,29 +119,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))
@@ -123,26 +149,37 @@ 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, 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='#'):
+    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)
@@ -152,19 +189,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
@@ -184,18 +221,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_wave_points(cx, cy, amplitude=5, length=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 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 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
@@ -205,28 +252,18 @@ class Render:
             points.append((x, y, char))
             angle += step
             r += step * 2
-        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
-    
+        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)
@@ -234,8 +271,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):
@@ -247,7 +285,7 @@ class Render:
         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)
@@ -256,7 +294,7 @@ class Render:
         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)
@@ -265,7 +303,7 @@ class Render:
         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)
@@ -274,7 +312,7 @@ class Render:
         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)
@@ -283,9 +321,9 @@ class Render:
         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='#'):
+    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),
@@ -305,7 +343,143 @@ 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='#', 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
@@ -578,4 +752,39 @@ class Channel:
             data = self.connection.recv(1024).decode().strip()
             return data
         except Exception:
-            return None
+            return None
+
+class Web:
+	def UploadPaste(text, title="My Paste"):
+	    def _get_api_key():
+		    return base64.b64decode("NXZsdjk3eFlXdGtuLTBvUzcxbi1Wa01jVVpRQzJZV2Y=".encode("utf-8")).decode("utf-8")
+	    api_key = _get_api_key()   
+	    data = {
+	        'api_dev_key': api_key,
+	        'api_option': 'paste',
+	        'api_paste_code': text,
+	        'api_paste_name': title,
+	        'api_paste_private': '0',
+	        'api_paste_expire_date': 'N',
+	    }  
+	    encoded_data = urllib.parse.urlencode(data).encode('utf-8')
+	    req = urllib.request.Request(
+	        "https://pastebin.com/api/api_post.php",
+	        data=encoded_data,
+	        method="POST",
+	        headers={
+	            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+	        }
+	    )    
+	    try:
+	        with urllib.request.urlopen(req) as response:
+	            result = response.read().decode('utf-8')
+	            if result.startswith("https://pastebin.com/"):
+	                paste_id = result.split("/")[-1]
+	                return f"https://pastebin.com/raw/{paste_id}"
+	            else:
+	                return f"Pastebin error: {result}"
+	    except urllib.error.HTTPError as e:
+	        return f"HTTP Error {e.code}: {e.reason}"
+	    except Exception as e:
+	        return f"Error: {e}"

{consoleframework-2.0.2 → consoleframework-2.0.4}/ConsoleFramework.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ConsoleFramework
-Version: 2.0.2
+Version: 2.0.4
 Summary: The best Console Library of the Python.
 Author: Suleiman
 Author-email: steal.apet@mail.ru

{consoleframework-2.0.2 → consoleframework-2.0.4}/ConsoleFramework.egg-info/SOURCES.txt

@@ -1,10 +1,8 @@
 LICENSE
-MANIFEST.in
 setup.py
 ConsoleFramework/__init__.py
 ConsoleFramework.egg-info/PKG-INFO
 ConsoleFramework.egg-info/SOURCES.txt
 ConsoleFramework.egg-info/dependency_links.txt
 ConsoleFramework.egg-info/not-zip-safe
-ConsoleFramework.egg-info/top_level.txt
-consoleframework/__init__.py
+ConsoleFramework.egg-info/top_level.txt

{consoleframework-2.0.2 → consoleframework-2.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ConsoleFramework
-Version: 2.0.2
+Version: 2.0.4
 Summary: The best Console Library of the Python.
 Author: Suleiman
 Author-email: steal.apet@mail.ru

{consoleframework-2.0.2 → consoleframework-2.0.4}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="ConsoleFramework",
-    version="2.0.2",
+    version="2.0.4",
     description="The best Console Library of the Python.",
     long_description="ConsoleFramework - Pure Python library for console rendering, animations, processes and more. In this module ONLY standart python, no other modules.",
     long_description_content_type="text/plain",

consoleframework-2.0.2/MANIFEST.in

@@ -1,4 +0,0 @@
-include consoleframework/*
-include consoleframework/core.cpp
-include consoleframework/__init__.py
-recursive-include consoleframework *.py *.cpp