easygradients 0.1.0__tar.gz

easygradients-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,34 @@
+name: Put my code on PyPI
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  build-and-put:
+    name: Build the package and send to PyPI
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - name: Get Python ready
+      uses: actions/setup-python@v5
+      with:
+        python-version: "3.x"
+    - name: Install the builder tool
+      run: >-
+        python -m
+        pip install
+        build
+        --user
+    - name: Make the files for distribution
+      run: >-
+        python -m
+        build
+        --sdist
+        --wheel
+        --outdir dist/
+    - name: Send everything to PyPI
+      uses: pypa/gh-action-pypi-publish@release/v1
+      with:
+        password: ${{ secrets.PYPI_TOKEN }}

easygradients-0.1.0/.gitignore

@@ -0,0 +1,21 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+.pytest_cache/

easygradients-0.1.0/.python-version

@@ -0,0 +1 @@
+3.13

easygradients-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DraxonV1
+
+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.

easygradients-0.1.0/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: easygradients
+Version: 0.1.0
+Summary: A very good library to make your terminal very colorful and nice. easy to use also.
+Project-URL: My GitHub, https://github.com/DraxonV1/EasyGradients
+Author-email: DraxonV1 <drxxn@draxonshop.xyz>
+License: MIT
+License-File: LICENSE
+Keywords: color,easy,gradient,nice-text,terminal
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# EasyGradients 🌈
+
+Hello friend! I made this library because I love colors in my terminal. It is very easy to use and even a small child can use it. No complex coding here, just simple things that work like magic!
+
+## How to Install this?
+
+Just type this simple command in your black screen (terminal):
+
+```bash
+pip install easygradients
+```
+
+## How to use it? (Examples for you)
+
+First you must bring the library in your code:
+
+```python
+import easygradients as eg
+```
+
+### 1. Simple Colors
+If you want to make text red or green, just do this:
+
+```python
+# Use hex code like this
+print(eg.color("I am red color!", "#FF0000"))
+
+# Or use simple numbers (RGB)
+print(eg.color("I am green color!", (0, 255, 0)))
+```
+
+### 2. Beautiful Gradients
+Gradient means many colors mixing together. It looks very nice!
+
+```python
+# Mix red and blue
+print(eg.gradient("Mixing colors wow!", ["#FF0000", "#0000FF"]))
+
+# You can even use many colors
+print(eg.gradient("So many colors!", ["#FF0000", "#FFFF00", "#00FF00", "#0000FF"]))
+```
+
+### 3. Using Presets (Shortcuts)
+I have already made some nice color sets for you. You don't need to find hex codes!
+
+```python
+print(eg.gradient("Sunset is looking good", "sunset"))
+print(eg.gradient("Ocean is blue", "ocean"))
+print(eg.gradient("I am hacker in matrix", "matrix"))
+```
+
+### 4. Background Colors
+You can even change the back side of the text:
+
+```python
+print(eg.bg_color("Black background here", "#000000"))
+print(eg.bg_gradient("Gradient background is crazy!", ["#FF5F6D", "#FFC371"]))
+```
+
+### 5. Styling Text
+Make it bold or italic or draw line under it:
+
+```python
+print(eg.style("I am very BOLD", "bold"))
+print(eg.style("I am leaning (italic)", "italic"))
+print(eg.style("Line under me", "underline"))
+```
+
+### 6. Special Tricks
+Some more things I added because I was bored:
+
+```python
+# Rainbow!
+print(eg.rainbow("FULL RAINBOW TEXT!!!"))
+
+# Type like a movie hacker
+eg.typewriter("System is hacking now... please wait...")
+
+# Put text in the middle
+print(eg.center("I am sitting in the middle"))
+
+# Put text inside a box
+print(eg.box("Special Message for you", border_col="gold"))
+```
+
+### 7. Random (If you are lazy)
+If you can't choose color, let the computer choose:
+
+```python
+# Computer will pick anything!
+my_luck = eg.random(show_info=True) 
+print(eg.gradient("I don't know what color this is!", my_luck))
+
+# Ask for random preset only
+preset_luck = eg.random(what_you_want='preset', show_info=True)
+print(eg.gradient("Random preset used!", preset_luck))
+```
+
+## All my Presets:
+`rainbow`, `sunset`, `ocean`, `morning`, `matrix`, `fire`, `night`, `candy`, `neon`, `cool`, `hot`, `simple`, `grass`, `sky`, `blood`, `gold`.
+
+## License
+It is MIT license. You can use it anywhere you want, I don't care! Just enjoy the colors.
+
+Made with love by DraxonV1.

easygradients-0.1.0/README.md

@@ -0,0 +1,105 @@
+# EasyGradients 🌈
+
+Hello friend! I made this library because I love colors in my terminal. It is very easy to use and even a small child can use it. No complex coding here, just simple things that work like magic!
+
+## How to Install this?
+
+Just type this simple command in your black screen (terminal):
+
+```bash
+pip install easygradients
+```
+
+## How to use it? (Examples for you)
+
+First you must bring the library in your code:
+
+```python
+import easygradients as eg
+```
+
+### 1. Simple Colors
+If you want to make text red or green, just do this:
+
+```python
+# Use hex code like this
+print(eg.color("I am red color!", "#FF0000"))
+
+# Or use simple numbers (RGB)
+print(eg.color("I am green color!", (0, 255, 0)))
+```
+
+### 2. Beautiful Gradients
+Gradient means many colors mixing together. It looks very nice!
+
+```python
+# Mix red and blue
+print(eg.gradient("Mixing colors wow!", ["#FF0000", "#0000FF"]))
+
+# You can even use many colors
+print(eg.gradient("So many colors!", ["#FF0000", "#FFFF00", "#00FF00", "#0000FF"]))
+```
+
+### 3. Using Presets (Shortcuts)
+I have already made some nice color sets for you. You don't need to find hex codes!
+
+```python
+print(eg.gradient("Sunset is looking good", "sunset"))
+print(eg.gradient("Ocean is blue", "ocean"))
+print(eg.gradient("I am hacker in matrix", "matrix"))
+```
+
+### 4. Background Colors
+You can even change the back side of the text:
+
+```python
+print(eg.bg_color("Black background here", "#000000"))
+print(eg.bg_gradient("Gradient background is crazy!", ["#FF5F6D", "#FFC371"]))
+```
+
+### 5. Styling Text
+Make it bold or italic or draw line under it:
+
+```python
+print(eg.style("I am very BOLD", "bold"))
+print(eg.style("I am leaning (italic)", "italic"))
+print(eg.style("Line under me", "underline"))
+```
+
+### 6. Special Tricks
+Some more things I added because I was bored:
+
+```python
+# Rainbow!
+print(eg.rainbow("FULL RAINBOW TEXT!!!"))
+
+# Type like a movie hacker
+eg.typewriter("System is hacking now... please wait...")
+
+# Put text in the middle
+print(eg.center("I am sitting in the middle"))
+
+# Put text inside a box
+print(eg.box("Special Message for you", border_col="gold"))
+```
+
+### 7. Random (If you are lazy)
+If you can't choose color, let the computer choose:
+
+```python
+# Computer will pick anything!
+my_luck = eg.random(show_info=True) 
+print(eg.gradient("I don't know what color this is!", my_luck))
+
+# Ask for random preset only
+preset_luck = eg.random(what_you_want='preset', show_info=True)
+print(eg.gradient("Random preset used!", preset_luck))
+```
+
+## All my Presets:
+`rainbow`, `sunset`, `ocean`, `morning`, `matrix`, `fire`, `night`, `candy`, `neon`, `cool`, `hot`, `simple`, `grass`, `sky`, `blood`, `gold`.
+
+## License
+It is MIT license. You can use it anywhere you want, I don't care! Just enjoy the colors.
+
+Made with love by DraxonV1.

easygradients-0.1.0/easygradients/__init__.py

@@ -0,0 +1,4 @@
+__version__ = "0.1.0"
+
+from .core import color, gradient, random, style, bg_color, bg_gradient, rainbow, typewriter, center, box
+from .presets import gradients

easygradients-0.1.0/easygradients/core.py

@@ -0,0 +1,138 @@
+from . import utils as help_tools
+from . import presets as my_styles
+import shutil
+
+STYLE_CODES = {
+    'bold': '1',
+    'dim': '2',
+    'italic': '3',
+    'underline': '4',
+    'blink': '5',
+    'reverse': '7',
+    'hidden': '8',
+    'strikethrough': '9'
+}
+
+def _put_rgb(r, g, b, back_ground=False):
+    layer_num = 48 if back_ground else 38
+    return f"\033[{layer_num};2;{r};{g};{b}m"
+
+def _clear_all():
+    return "\033[0m"
+
+def style(input_text, style_names):
+    if isinstance(style_names, str):
+        style_names = [style_names]
+    
+    start_codes = ""
+    for s in style_names:
+        if s.lower() in STYLE_CODES:
+            start_codes += f"\033[{STYLE_CODES[s.lower()]}m"
+            
+    return f"{start_codes}{input_text}{_clear_all()}"
+
+def color(input_text, col_code, back_ground=False):
+    if isinstance(col_code, str):
+        if col_code.startswith('#'):
+            col_code = help_tools.hex_to_rgb(col_code)
+        elif col_code in my_styles.gradients:
+            col_code = help_tools.hex_to_rgb(my_styles.gradients[col_code][0])
+            
+    r_val, g_val, b_val = col_code
+    return f"{_put_rgb(r_val, g_val, b_val, back_ground)}{input_text}{_clear_all()}"
+
+def gradient(input_text, list_of_cols, back_ground=False):
+    if not input_text:
+        return ""
+    
+    if isinstance(list_of_cols, str):
+        if list_of_cols in my_styles.gradients:
+            list_of_cols = my_styles.gradients[list_of_cols]
+        else:
+             list_of_cols = [list_of_cols] 
+
+    real_rgb_list = []
+    for ek_col in list_of_cols:
+        if isinstance(ek_col, str) and ek_col.startswith('#'):
+            real_rgb_list.append(help_tools.hex_to_rgb(ek_col))
+        elif isinstance(ek_col, tuple):
+            real_rgb_list.append(ek_col)
+        else:
+            real_rgb_list.append((255, 255, 255))
+            
+    every_step = help_tools.make_steps(real_rgb_list, len(input_text))
+    
+    final_output = ""
+    for letter, rgb_val in zip(input_text, every_step):
+        rv, gv, bv = rgb_val
+        final_output += f"{_put_rgb(rv, gv, bv, back_ground)}{letter}"
+        
+    final_output += _clear_all()
+    return final_output
+
+def bg_color(input_text, col_code):
+    return color(input_text, col_code, back_ground=True)
+
+def bg_gradient(input_text, list_of_cols):
+    return gradient(input_text, list_of_cols, back_ground=True)
+
+def rainbow(input_text, back_ground=False):
+    return gradient(input_text, my_styles.gradients['rainbow'], back_ground=back_ground)
+
+def random(what_you_want=None, show_info=False):
+    import random as radom_tool
+    
+    output_val = None
+    messge = ""
+    
+    if what_you_want == 'color':
+        output_val = help_tools.rand_col()
+        messge = f"Color: {output_val}"
+    elif what_you_want == 'gradient':
+        output_val = [help_tools.rand_col(), help_tools.rand_col()]
+        messge = f"Gradient: {output_val}"
+    elif what_you_want == 'preset':
+        output_val = radom_tool.choice(list(my_styles.gradients.keys()))
+        messge = f"Preset: {output_val}"
+    else:
+        luck = radom_tool.choice(['color', 'gradient', 'preset'])
+        if luck == 'color':
+            output_val = help_tools.rand_col()
+            messge = f"Color: {output_val}"
+        elif luck == 'gradient':
+            output_val = [help_tools.rand_col(), help_tools.rand_col()]
+            messge = f"Gradient: {output_val}"
+        else:
+            output_val = radom_tool.choice(list(my_styles.gradients.keys()))
+            messge = f"Preset: {output_val}"
+            
+    if show_info:
+        print(f"I found this radom {messge} for you!")
+        
+    return output_val
+
+def typewriter(input_text, wait_time=0.05):
+    help_tools.slow_print(input_text, wait_time)
+
+def center(input_text):
+    screen_width, _ = shutil.get_terminal_size()
+    return input_text.center(screen_width)
+
+def box(input_text, border_col=None):
+    all_lines = input_text.split('\n')
+    max_len = max(len(ek_line) for ek_line in all_lines)
+    
+    top_border = "+" + "-" * (max_len + 2) + "+"
+    bottom_border = "+" + "-" * (max_len + 2) + "+"
+    
+    full_box = top_border + "\n"
+    for ek_line in all_lines:
+        full_box += "| " + ek_line.ljust(max_len) + " |\n"
+    full_box += bottom_border
+    
+    if border_col:
+        if isinstance(border_col, list) or (isinstance(border_col, str) and border_col in my_styles.gradients):
+            return gradient(full_box, border_col)
+        else:
+            return color(full_box, border_col)
+    return full_box

easygradients-0.1.0/easygradients/presets.py

@@ -0,0 +1,18 @@
+gradients = {
+    'rainbow': ['#FF0000', '#FF7F00', '#FFFF00', '#00FF00', '#0000FF', '#4B0082', '#9400D3'],
+    'sunset': ['#FDC830', '#F37335'],
+    'ocean': ['#2E3192', '#1BFFFF'],
+    'morning': ['#FF5F6D', '#FFC371'],
+    'matrix': ['#000000', '#00FF00', '#000000'],
+    'fire': ['#f12711', '#f5af19'],
+    'night': ['#2b5876', '#4e4376'],
+    'candy': ['#D4145A', '#FBB03B'],
+    'neon': ['#00F260', '#0575E6'],
+    'cool': ['#2193b0', '#6dd5ed'],
+    'hot': ['#ff416c', '#ff4b2b'],
+    'simple': ['#000000', '#ffffff'],
+    'grass': ['#11998e', '#38ef7d'],
+    'sky': ['#00b4db', '#0083b0'],
+    'blood': ['#870000', '#190a05'],
+    'gold': ['#bf953f', '#fcf6ba', '#b38728']
+}

easygradients-0.1.0/easygradients/utils.py

@@ -0,0 +1,49 @@
+import random
+import time
+import sys
+
+def hex_to_rgb(hex_code):
+    hex_code = hex_code.lstrip('#')
+    return tuple(int(hex_code[i:i+2], 16) for i in (0, 2, 4))
+
+def rand_col():
+    return (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255))
+
+def mixer(col1, col2, factor):
+    r = int(col1[0] + (col2[0] - col1[0]) * factor)
+    g = int(col1[1] + (col2[1] - col1[1]) * factor)
+    b = int(col1[2] + (col2[2] - col1[2]) * factor)
+    return (r, g, b)
+
+def make_steps(all_cols, total_steps):
+    if total_steps < 2:
+        return [all_cols[0]] * total_steps
+    if len(all_cols) < 2:
+        return [all_cols[0]] * total_steps
+    
+    final_list = []
+    sections = len(all_cols) - 1
+    steps_per_sec = total_steps // sections
+    extra_steps = total_steps % sections
+    
+    for i in range(sections):
+        start_c = all_cols[i]
+        end_c = all_cols[i+1]
+        
+        current_steps = steps_per_sec + (1 if i < extra_steps else 0)
+        
+        for j in range(current_steps):
+            f = j / current_steps
+            final_list.append(mixer(start_c, end_c, f))
+            
+    if len(final_list) < total_steps:
+        final_list.append(all_cols[-1])
+        
+    return final_list[:total_steps]
+
+def slow_print(my_text, my_speed=0.05):
+    for ek_char in my_text:
+        sys.stdout.write(ek_char)
+        sys.stdout.flush()
+        time.sleep(my_speed)
+    print()

easygradients-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[project]
+name = "easygradients"
+version = "0.1.0"
+description = "A very good library to make your terminal very colorful and nice. easy to use also."
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = []
+authors = [
+    { name = "DraxonV1", email = "drxxn@draxonshop.xyz" }
+]
+license = { text = "MIT" }
+keywords = ["color", "gradient", "terminal", "nice-text", "easy"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+"My GitHub" = "https://github.com/DraxonV1/EasyGradients"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

easygradients-0.1.0/tests/test_core.py

@@ -0,0 +1,36 @@
+import unittest
+import easygradients as eg
+from io import StringIO
+import sys
+
+class TestMyCode(unittest.TestCase):
+
+    def test_styling(self):
+        styled_txt = eg.style("hello", "bold")
+        self.assertIn("\033[1m", styled_txt)
+
+    def test_coloring(self):
+        colored_txt = eg.color("hello", "#FF0000")
+        self.assertIn("255;0;0", colored_txt)
+
+    def test_gradient_mixing(self):
+        grad_txt = eg.gradient("hello", ["#FF0000", "#0000FF"])
+        self.assertIn("\033[38;2;", grad_txt)
+
+    def test_radom_info(self):
+        temp_screen = StringIO()
+        sys.stdout = temp_screen
+        eg.random(show_info=True)
+        sys.stdout = sys.__stdout__
+        self.assertIn("I found this radom", temp_screen.getvalue())
+
+    def test_presets_work(self):
+        sun_txt = eg.gradient("hello", "sunset")
+        self.assertIn("\033[38;2;", sun_txt)
+
+    def test_making_box(self):
+        box_txt = eg.box("hi")
+        self.assertIn("+----+", box_txt)
+
+if __name__ == '__main__':
+    unittest.main()