nercone-modern 1.6.1__py3-none-any.whl → 1.7.0__py3-none-any.whl

nercone_modern/__main__.py

@@ -10,8 +10,11 @@ import time
 from nercone_modern.logging import ModernLogging
 from nercone_modern.progressbar import ModernProgressBar
 
-logger1 = ModernLogging("Main", display_level="DEBUG")
-logger2 = ModernLogging("Sub", display_level="DEBUG")
+logger0 = ModernLogging("Demo", display_level="DEBUG", show_level=False)
+show_proc = logger0.prompt("Show process name?", default="N", choices=["y", "N"], interrupt_ignore=True) == "Y"
+show_level = logger0.prompt("Show level name?", default="N", choices=["y", "N"], interrupt_ignore=True) == "Y"
+logger1 = ModernLogging("Main", display_level="DEBUG", show_proc=show_proc, show_level=show_level)
+logger2 = ModernLogging("Sub", display_level="DEBUG", show_proc=show_proc, show_level=show_level)
 
 try:
     logger1.log("This is a debug message", "DEBUG")
@@ -22,10 +25,9 @@ try:
     logger1.log("This is a warning message", "WARNING")
     logger1.log("This is a error message", "ERROR")
     logger1.log("This is a critical error message", "CRITICAL")
-    prompt_result = logger1.prompt("Continue demo?", default="Y", choices=["Y", "n"])
-    logger1.log(f"Answer is: {prompt_result}", "INFO")
+    prompt_result = logger1.prompt("Continue demo?", default="Y", choices=["Y", "n"], interrupt_ignore=True, interrupt_default="n")
     if prompt_result == "n":
-        print("Exiting demo. See you!")
+        logger1.log("Exiting demo. See you!", "INFO")
         raise SystemExit(0)
 
     progress_bar1 = ModernProgressBar(total=100, process_name="Task 1", spinner_mode=False)

nercone_modern/color.py

@@ -1,28 +1,28 @@
 class ModernColor:
-    def ansi_color_by_code(color_code: int | str = 0):
+    def color_by_code(color_code: int | str = 0):
         return f"\033[{color_code}m"
 
-    def ansi_color(color_name: str = "reset"):
+    def color(color_name: str = "reset"):
         if color_name == "reset":
-            return ModernColor.ansi_color_by_code(0)
+            return ModernColor.color_by_code(0)
         elif color_name == "black":
-            return ModernColor.ansi_color_by_code(30)
+            return ModernColor.color_by_code(30)
         elif color_name == "red":
-            return ModernColor.ansi_color_by_code(31)
+            return ModernColor.color_by_code(31)
         elif color_name == "green":
-            return ModernColor.ansi_color_by_code(32)
+            return ModernColor.color_by_code(32)
         elif color_name == "yellow":
-            return ModernColor.ansi_color_by_code(33)
+            return ModernColor.color_by_code(33)
         elif color_name == "blue":
-            return ModernColor.ansi_color_by_code(34)
+            return ModernColor.color_by_code(34)
         elif color_name == "magenta":
-            return ModernColor.ansi_color_by_code(35)
+            return ModernColor.color_by_code(35)
         elif color_name == "cyan":
-            return ModernColor.ansi_color_by_code(36)
+            return ModernColor.color_by_code(36)
         elif color_name == "white":
-            return ModernColor.ansi_color_by_code(37)
+            return ModernColor.color_by_code(37)
         elif color_name in ("gray", "grey"):
-            return ModernColor.ansi_color_by_code(90)
+            return ModernColor.color_by_code(90)
         else:
             return ""
 

nercone_modern/logging.py

@@ -6,6 +6,9 @@
 # Copyright (c) 2025 DiamondGotCat                                #
 # ---------------------------------------------- DiamondGotCat -- #
 
+import sys
+from .color import ModernColor
+
 ModernLoggingLevels = ["DEBUG", "INFO", "WARN", "ERROR", "CRITICAL"]
 MAX_LOG_LEVEL_WIDTH = max(len(level) for level in ModernLoggingLevels)
 LEVEL_ALIASES = {
@@ -40,10 +43,12 @@ def is_higher_priority(level_a: str, level_b: str) -> bool:
         raise ValueError(f"Unknown log level: {level_a} or {level_b}")
 
 class ModernLogging:
-    def __init__(self, process_name: str = "App", display_level: str = "INFO", filepath: str | None = None):
+    def __init__(self, process_name: str = "App", display_level: str = "INFO", filepath: str | None = None, show_proc: bool | None = None, show_level: bool | None = None):
         self.process_name = process_name
         self.display_level = display_level
         self.filepath = filepath
+        self.show_proc = show_proc
+        self.show_level = show_level
         global _max_proc_width
         _max_proc_width = max(_max_proc_width, len(process_name))
 
@@ -59,7 +64,7 @@ class ModernLogging:
             with open(self.filepath, "a") as f:
                 f.write(f"{log_line}\n")
 
-    def prompt(self, message: str = "", level_text: str = "INFO", level_color: str | None = None, ignore_kbdinterrupt: bool = True, default: str | None = None, show_default: bool = False, choices: list[str] | None = None, show_choices: bool = True) -> str:
+    def prompt(self, message: str = "", level_text: str = "INFO", level_color: str | None = None, default: str | None = None, show_default: bool = False, choices: list[str] | None = None, show_choices: bool = True, interrupt_ignore: bool = False, interrupt_default: str | None = None) -> str:
         if not is_higher_priority(level_text, self.display_level):
             return
         global _last_process, _last_level
@@ -74,10 +79,14 @@ class ModernLogging:
         _last_process = self.process_name
         _last_level = normalize_level(level_text.strip().upper())
         answer = ""
+        used_default = False
         try:
             answer = input()
         except KeyboardInterrupt:
-            if ignore_kbdinterrupt:
+            if interrupt_ignore:
+                if interrupt_default:
+                    answer = interrupt_default
+                    used_default = True
                 print()
             else:
                 raise
@@ -86,8 +95,12 @@ class ModernLogging:
                 selected_default = self._select_choice(default, choices)
                 if selected_default is not None:
                     answer = default
+                    used_default = True
             else:
                 answer = default
+                used_default = True
+        if used_default:
+            self._rewrite_prompt_line_with_answer(log_line, answer)
         if self.filepath:
             with open(self.filepath, "a") as f:
                 f.write(f"{log_line}{answer}\n")
@@ -107,10 +120,25 @@ class ModernLogging:
                     try:
                         answer = input()
                     except KeyboardInterrupt:
-                        if ignore_kbdinterrupt:
+                        if interrupt_ignore:
+                            if interrupt_default:
+                                answer = interrupt_default
+                                used_default = True
                             print()
                         else:
                             raise
+                    used_default = False
+                    if answer.strip() == "" and default is not None:
+                        if choices:
+                            selected_default = self._select_choice(default, choices)
+                            if selected_default is not None:
+                                answer = default
+                                used_default = True
+                        else:
+                            answer = default
+                            used_default = True
+                    if used_default:
+                        self._rewrite_prompt_line_with_answer(log_line, answer)
                     if self.filepath:
                         with open(self.filepath, "a") as f:
                             f.write(f"{log_line}{answer}\n")
@@ -124,6 +152,15 @@ class ModernLogging:
                     selected = self._select_choice(answer, choices)
                     if selected is not None:
                         return selected
+        return answer
+
+    def _rewrite_prompt_line_with_answer(self, log_line: str, answer: str) -> None:
+        try:
+            sys.stdout.write("\033[F\r")
+            sys.stdout.write(f"{log_line}{answer}  \n")
+            sys.stdout.flush()
+        except Exception:
+            print(f"{log_line}{answer}")
 
     def _select_choice(self, answer: str, choices: list[str]) -> str | None:
         if answer in choices:
@@ -138,10 +175,10 @@ class ModernLogging:
             return lower_map[stripped.lower()]
         return None
 
-    def make(self, message: str = "", level_text: str = "INFO", level_color: str | None = None):
+    def make(self, message: str = "", level_text: str = "INFO", level_color: str | None = None, show_proc: bool | None = None, show_level: bool | None = None):
         level_text = normalize_level(level_text.strip().upper())
-        show_proc = (self.process_name != _last_process)
-        show_level = show_proc or (level_text != _last_level)
+        system_show_proc = (self.process_name != _last_process)
+        system_show_level = system_show_proc or (level_text != _last_level)
 
         if not level_color:
             if level_text == "DEBUG":
@@ -157,45 +194,47 @@ class ModernLogging:
             else:
                 level_color = 'blue'
 
-        return self._make(message, level_text, level_color, show_proc, show_level)
+        if show_proc is None:
+            if self.show_proc is not None:
+                show_proc = self.show_proc
+            else:
+                show_proc = True
+
+        if show_level is None:
+            if self.show_level is not None:
+                show_level = self.show_level
+            else:
+                show_level = True
+
+        return self._make(message=message, level_text=level_text, level_color=level_color, show_proc=show_proc, show_level=show_level, system_show_proc=system_show_proc, system_show_level=system_show_level)
 
-    def _make(self, message: str, level_text: str, level_color: str, show_proc: bool, show_level: bool):
+    def _make(self, message: str = "", level_text: str = "INFO", level_color: str = "blue", show_proc: bool = False, show_level: bool = False, system_show_proc: bool = True, system_show_level: bool = True):
         global _max_proc_width
         level_width = max(MAX_LOG_LEVEL_WIDTH, len(level_text))
+        color_bar = f"{ModernColor.color(level_color)}|{ModernColor.color('reset')}"
 
-        proc_part = self.process_name if show_proc else ""
-        proc_part = proc_part.ljust(_max_proc_width) if proc_part else " " * _max_proc_width
-
-        if show_level:
-            level_part = f"{self._color(level_color)}{level_text.ljust(level_width)} |{self._color('reset')}"
-        else:
-            level_part = (" " * level_width) + f"{self._color(level_color)} |{self._color('reset')}"
-
-        return f"{proc_part} {level_part} {str(message)}"
-
-    def _color(self, color_name: str = "reset"):
-        if color_name == "cyan":
-            return self._color_by_code(36)
-        elif color_name == "magenta":
-            return self._color_by_code(35)
-        elif color_name == "yellow":
-            return self._color_by_code(33)
-        elif color_name == "green":
-            return self._color_by_code(32)
-        elif color_name == "red":
-            return self._color_by_code(31)
-        elif color_name == "blue":
-            return self._color_by_code(34)
-        elif color_name == "white":
-            return self._color_by_code(37)
-        elif color_name == "black":
-            return self._color_by_code(30)
-        elif color_name in ("gray", "grey"):
-            return self._color_by_code(90)
-        elif color_name == "reset":
-            return self._color_by_code(0)
+        if not show_proc and not show_level:
+            prefix = ""
         else:
-            return ""
-
-    def _color_by_code(self, color_code: int | str = 0):
-        return f"\033[{color_code}m"
+            prefix = ""
+            if show_proc:
+                if system_show_proc:
+                    proc_part = self.process_name[:_max_proc_width].ljust(_max_proc_width)
+                else:
+                    proc_part = " " * _max_proc_width
+                prefix += proc_part
+                prefix += " "
+            else:
+                if show_level:
+                    prefix += " " * (_max_proc_width + 1)
+            if show_level:
+                if system_show_level:
+                    level_part = level_text.ljust(level_width)
+                    level_part = f"{ModernColor.color(level_color)}{level_part}{ModernColor.color('reset')}"
+                else:
+                    level_part = " " * level_width
+                prefix += level_part
+                if show_proc:
+                    prefix += " " * (_max_proc_width + 1)
+
+        return f"{prefix}{color_bar} {str(message)}"

nercone_modern/progressbar.py

@@ -8,17 +8,23 @@
 
 import sys
 import threading
+from .color import ModernColor
+from .logging import ModernLogging
 
 class ModernProgressBar:
     _active_bars = []
     _last_rendered = False
     _lock = threading.RLock()
 
-    def __init__(self, total: int, process_name: str, spinner_mode=False):
+    def __init__(self, total: int, process_name: str, spinner_mode: bool = False, primary_color: str = "blue", secondary_color: str = "cyan", box_left: str = "[", box_right: str = "]"):
         self.total = total
+        self.process_name = process_name.strip()
         self.spinner_mode = spinner_mode
+        self.primary_color = primary_color
+        self.secondary_color = secondary_color
+        self.box_left = box_left
+        self.box_right = box_right
         self.current = 0
-        self.process_name = process_name.strip()
         self.index = len(ModernProgressBar._active_bars)
         ModernProgressBar._active_bars.append(self)
         self.log_lines = 0
@@ -62,7 +68,7 @@ class ModernProgressBar:
         self._render(advance_spinner=False)
         self._start_spinner_thread_if_needed()
 
-    def update(self, amount=1):
+    def update(self, amount: int = 1):
         if self._should_spin():
             self._render(advance_spinner=False)
             return
@@ -78,18 +84,12 @@ class ModernProgressBar:
         self._stop_spinner_thread()
         self._render(final=True, advance_spinner=False)
 
-    def makeModernLogging(self, process_name: str = None):
-        from .logging import ModernLogging
-        if not process_name:
-            process_name = self.process_name
-        return ModernLogging(process_name)
-
-    def logging(self, message: str = "", level: str = "INFO", modernLogging=None):
+    def log(self, message: str = "", level_text: str = "INFO", level_color: str | None = None, show_proc: bool | None = None, show_level: bool | None = None, modernLogging: ModernLogging = None):
         with ModernProgressBar._lock:
             self.log_lines = 0
             if modernLogging is None:
-                modernLogging = self.makeModernLogging(self.process_name)
-            result = modernLogging._make(message, level)
+                modernLogging = ModernLogging(self.process_name)
+            result = modernLogging.make(message=message, level_text=level_text, level_color=level_color, show_proc=show_proc, show_level=show_level)
             if self.log_lines > 0:
                 move_up = self.log_lines
             else:
@@ -129,12 +129,12 @@ class ModernProgressBar:
             percentage = f"{percentage_value:3d}%"
             total_width = max(len(str(self.total)), 1)
             if final:
-                status = "(DONE)"
+                status = f"{self.box_left}DONE{self.box_right}"
             elif self.spinner_mode and self._spinner_ready:
-                status = "(RUNN)"
+                status = f"{self.box_left}RUNN{self.box_right}"
             else:
-                status = f"({self.current:>{total_width}}/{self.total})"
-            line = f"({self._color('gray')}{bar}{self._color('reset')}) {self.process_name} - {'....' if self.spinner_mode else percentage} {status} | {self.message}"
+                status = f"{self.box_left}{self.current:>{total_width}}/{self.total}{self.box_right}"
+            line = f"{ModernColor.color(self.primary_color)}{self.box_left}{ModernColor.color('reset')}{ModernColor.color('gray')}{bar}{ModernColor.color('reset')}{ModernColor.color(self.primary_color)}{self.box_right}{ModernColor.color('reset')} {self.process_name} - {'....' if self.spinner_mode else percentage} {status} | {self.message}"
             total_move_up = self.log_lines + (len(ModernProgressBar._active_bars) - self.index)
             if total_move_up > 0:
                 sys.stdout.write(f"\033[{total_move_up}A")
@@ -157,48 +157,21 @@ class ModernProgressBar:
                 center_bar = "-"
             filled_bar = "-"
             if self.current <= 0 and not self._spinner_ready:
-                return f"{self._color('gray')}{empty_bar * (bar_length + 1)}"
+                return f"{ModernColor.color('gray')}{empty_bar * (bar_length + 1)}"
             if self.current == self.total:
                 filled_length = int(progress * bar_length) + 1
             else:
                 filled_length = int(progress * bar_length)
-            return f"{self._color('blue')}{filled_bar * filled_length}{self._color('cyan')}{center_bar}{self._color('gray')}{empty_bar * (bar_length - filled_length)}"
+            return f"{ModernColor.color(self.primary_color)}{filled_bar * filled_length}{ModernColor.color(self.secondary_color)}{center_bar}{ModernColor.color('gray')}{empty_bar * (bar_length - filled_length)}"
         else:
             if self.current <= 0 and not self._spinner_ready:
-                return f"{self._color('gray')}{'-' * (bar_length + 1)}"
+                return f"{ModernColor.color('gray')}{'-' * (bar_length + 1)}"
             spinner_symbol_length = 1
             spinner_end_bar_length = bar_length - self.spinner_step
             spinner_start_bar_length = bar_length - spinner_end_bar_length
             if advance_spinner:
                 self.spinner_step = (self.spinner_step + 1) % (bar_length + 1)
-            return f"{self._color('gray')}{'-' * spinner_start_bar_length}{self._color('blue')}{'-' * spinner_symbol_length}{self._color('gray')}{'-' * spinner_end_bar_length}"
+            return f"{ModernColor.color('gray')}{'-' * spinner_start_bar_length}{ModernColor.color(self.secondary_color)}{'-' * spinner_symbol_length}{ModernColor.color('gray')}{'-' * spinner_end_bar_length}"
 
     def _should_spin(self):
         return self.spinner_mode and self._spinner_ready
-
-    def _color(self, color_name: str = "reset"):
-        if color_name == "cyan":
-            return self._color_by_code(36)
-        elif color_name == "magenta":
-            return self._color_by_code(35)
-        elif color_name == "yellow":
-            return self._color_by_code(33)
-        elif color_name == "green":
-            return self._color_by_code(32)
-        elif color_name == "red":
-            return self._color_by_code(31)
-        elif color_name == "blue":
-            return self._color_by_code(34)
-        elif color_name == "white":
-            return self._color_by_code(37)
-        elif color_name == "black":
-            return self._color_by_code(30)
-        elif color_name in ("gray", "grey"):
-            return self._color_by_code(90)
-        elif color_name == "reset":
-            return self._color_by_code(0)
-        else:
-            return ""
-
-    def _color_by_code(self, color_code: int | str = 0):
-        return f"\033[{color_code}m"

nercone_modern-1.7.0.dist-info/METADATA

@@ -0,0 +1,185 @@
+Metadata-Version: 2.3
+Name: nercone-modern
+Version: 1.7.0
+Summary: Modern CLI Library
+Author: Nercone
+Author-email: Nercone <nercone@diamondgotcat.net>
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Project-URL: Homepage, https://github.com/DiamondGotCat/nercone-modern
+Description-Content-Type: text/markdown
+
+
+<img width="1920" alt="nercone_modern" src="https://github.com/user-attachments/assets/15056f45-ab02-4d0d-b525-4dd51d859738" />
+
+# nercone-modern
+Modern CLI Library
+
+## Installation
+
+### uv
+**Install to venv and Add to project dependencies:**
+```
+uv add nercone-modern
+```
+
+**Install to venv:**
+```
+uv pip install nercone-modern
+```
+
+### pip
+```
+pip3 install nercone-modern
+```
+
+## Usage
+
+### Import
+
+```python
+from nercone_modern.color import ModernColor
+from nercone_modern.text import ModernText
+from nercone_modern.logging import ModernLogging
+from nercone_modern.progressbar import ModernProgressBar
+```
+
+### Color
+```python
+from nercone_modern.color import ModernColor as Color
+print(f"Build {Color.GREEN}Success{Color.RESET}")
+```
+
+**Supported colors:**
+- `CYAN`
+- `MAGENTA`
+- `YELLOW`
+- `GREEN`
+- `RED`
+- `BLUE`
+- `WHITE`
+- `BLACK`
+- `GRAY`
+- `RESET`
+
+### Text
+```python
+from nercone_modern.text import ModernText as Text
+from nercone_modern.color import ModernColor as Color
+print("Build" + Text("Success", color="green"))
+print("Build" + Text("Failed", color=Color.RED))
+```
+
+### Logging
+```python
+ModernLogging(
+  process_name: str = "App",           # Process name to show in the log
+  display_level: str = "INFO",         # The minimum level to show in the log
+  filepath: str | None = None,         # Log file path
+  show_proc: bool | None = None,       # Whether to show process names
+  show_level: bool | None = None       # Whether to show level names
+)
+ModernLogging().log(
+  message: str = "",                   # Log contents
+  level_text: str = "INFO",            # Level from "DEBUG", "INFO", "WARN", "ERROR" and "CRITICAL"
+  level_color: str                     # Custom color for Level (see ModernLogging.color.ModernColor)
+)
+ModernLogging().prompt(
+  message: str = "",                   # Log contents
+  level_text: str = "INFO",            # Level from "DEBUG", "INFO", "WARN", "ERROR" and "CRITICAL"
+  level_color: str | None = None,      # Custom color for Level (see ModernColor)
+  default: str | None = None,          # Default answer
+  show_default: bool = False,          # Whether to show default answer
+  choices: list[str] | None = None,    # List of possible answers
+  show_choices: bool = True,           # Whether to show choices
+  interrupt_ignore: bool = False,      # Whether to raise an exception on KeyboardInterrupt or continue using the default argument.
+  interrupt_default: str | None = None # Value to use instead of the default argument when interrupt_ignore is True.
+)
+```
+
+```python
+from nercone_modern.logging import ModernLogging
+logger = ModernLogging("Main", display_level="DEBUG")
+logger.log("This is a test message", level_text="INFO", level_color="magenta")
+answer = logger.prompt("What's your name?", level_text="INFO")
+logger.log(f"Answer: {answer}", level_text="DEBUG")
+answer2 = logger.prompt("Select mode", default="A", choices=["A", "b", "c", "d"], level_text="INFO")
+logger.log(f"Mode: {answer2}", level_text="DEBUG")
+```
+
+**Supported levels:**
+- `DEBUG`
+- `INFO`
+- `WARN`
+- `ERROR`
+- `CRITICAL`
+
+### Progress Bar
+```python
+ModernProgressBar(
+  total: int,                          # Total number of steps (max progress value)
+  process_name: str,                   # Name of the process shown next to the bar
+  spinner_mode: bool = False,          # Whether to start in spinner mode instead of progress (spinner-only) mode
+  primary_color: str = "blue",         # Color used for filled bar and brackets (see ModernColor)
+  secondary_color: str = "cyan",       # Color used for center marker / spinner (see ModernColor)
+  box_left: str = "[",                 # Left bracket surrounding the bar and status
+  box_right: str = "]"                 # Right bracket surrounding the bar and status
+)
+ModernProgressBar().spinner(
+  enabled: bool = True                 # Enable or disable spinner mode dynamically
+)
+ModernProgressBar().spin_start()       # Start spinner animation immediately
+ModernProgressBar().setMessage(
+  message: str = ""                    # Message to show after the status (e.g. current step description)
+)
+ModernProgressBar().start()            # Initial rendering and start of spinner (if enabled)
+ModernProgressBar().update(
+  amount: int = 1                      # Increase current progress by the specified amount and re-render
+)
+ModernProgressBar().finish()           # Mark as complete, stop spinner and render final DONE state
+ModernProgressBar().log(
+  message: str = "",                   # Log contents printed above the progress bar
+  level_text: str = "INFO",            # Level from "DEBUG", "INFO", "WARN", "ERROR" and "CRITICAL"
+  level_color: str | None = None,      # Custom color for Level (see ModernColor)
+  show_proc: bool | None = None,       # Whether to show process names (fallbacks to ModernLogging settings)
+  show_level: bool | None = None,      # Whether to show level names (fallbacks to ModernLogging settings)
+  modernLogging: ModernLogging = None  # Existing ModernLogging instance to reuse. If None, a new one is created.
+)
+```
+
+```python
+from nercone_modern.progressbar import ModernProgressBar
+progress_bar = ModernProgressBar(total=100, process_name="Task 1", spinner_mode=True)
+
+progress_bar.start()
+time.sleep(5)
+
+progress_bar.spinner(False)
+
+progress_bar.setMessage("Step 1")
+
+for i in range(50):
+  time.sleep(0.05)
+  progress_bar.update(amount=1)
+
+progress_bar.setMessage("Step 2")
+
+for i in range(25):
+  time.sleep(0.03)
+  progress_bar.update(amount=1)
+
+progress_bar.setMessage("Step 3")
+
+for i in range(5):
+  time.sleep(1)
+  progress_bar.update(amount=5)
+
+progress_bar.finish()
+```
+
+---
+
+![PyPI - Version](https://img.shields.io/pypi/v/nercone-modern)

nercone_modern-1.7.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+nercone_modern/__init__.py,sha256=ArF3T8FdWIhwGcL4MfYcHqMse3n5gjuyzbLNlcqRcxs,443
+nercone_modern/__main__.py,sha256=5XLj1f0jTdi1IhDq79gXCQeGDIBLAkW4b_PzK9B4zj8,2458
+nercone_modern/color.py,sha256=e2P9WXeGosHLCAasdE7IQW29GPZOVDMLsUCsLj6hBkM,1268
+nercone_modern/logging.py,sha256=61ixjR37-ewS1RUwnNZnkNGQEBazhiSJJv5g-rLq834,10158
+nercone_modern/progressbar.py,sha256=QaDqfxa9XUmI3kfw7ueuRHwylAZGm-L3d7sG7PzV1tE,7782
+nercone_modern/text.py,sha256=eGxGQOJ3b-783ocLibkG62cOcYD4HLG_3diA52tU8jI,1031
+nercone_modern-1.7.0.dist-info/WHEEL,sha256=w4ZtLaDgMAZW2MMZZwtH8zENekoQYBCeullI-zsXJQk,78
+nercone_modern-1.7.0.dist-info/METADATA,sha256=mYxhpUMYgG2N9Fu2XcSudMC3rp7HQt8zwf10BLxKIr4,6127
+nercone_modern-1.7.0.dist-info/RECORD,,

{nercone_modern-1.6.1.dist-info → nercone_modern-1.7.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.9.8
+Generator: uv 0.9.9
 Root-Is-Purelib: true
 Tag: py3-none-any

nercone_modern-1.6.1.dist-info/METADATA

@@ -1,121 +0,0 @@
-Metadata-Version: 2.3
-Name: nercone-modern
-Version: 1.6.1
-Summary: Modern CLI Library
-Author: Nercone
-Author-email: Nercone <nercone@diamondgotcat.net>
-License: MIT
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
-Project-URL: Homepage, https://github.com/DiamondGotCat/nercone-modern
-Description-Content-Type: text/markdown
-
-
-<img width="1920" alt="Nercone Modern" src="https://github.com/user-attachments/assets/c92b0407-916f-46ec-9116-c3388b38c88c" />
-
-# nercone-modern
-Modern CLI Library
-
-## Installation
-
-### uv
-**Install to venv and Add to project dependencies:**
-```
-uv add nercone-modern
-```
-
-**Install to venv:**
-```
-uv pip install nercone-modern
-```
-
-### pip
-```
-pip3 install nercone-modern
-```
-
-## Usage
-
-### Import
-
-```python
-from nercone_modern.color import ModernColor
-from nercone_modern.text import ModernText
-from nercone_modern.logging import ModernLogging
-from nercone_modern.progressbar import ModernProgressBar
-```
-
-### Color
-```python
-from nercone_modern.color import ModernColor as Color
-print(f"Build {Color.GREEN}Success{Color.RESET}")
-```
-
-**Supported colors:**
-- `CYAN`
-- `MAGENTA`
-- `YELLOW`
-- `GREEN`
-- `RED`
-- `BLUE`
-- `WHITE`
-- `BLACK`
-- `GRAY`
-- `RESET`
-
-### Text
-```python
-from nercone_modern.text import ModernText as Text
-from nercone_modern.color import ModernColor as Color
-print("Build" + Text("Success", color="green"))
-print("Build" + Text("Failed", color=Color.RED))
-```
-
-### Logging
-```python
-from nercone_modern.logging import ModernLogging
-logger = ModernLogging("Main", display_level="DEBUG")
-logger.log("This is a test message", level="INFO")
-answer = logger.prompt("What's your name?", level="INFO")
-logger.log(f"Answer: {answer}", level="DEBUG")
-```
-
-**Supported levels:**
-- `DEBUG`
-- `INFO`
-- `WARN`
-- `ERROR`
-- `CRITICAL`
-
-### Progress Bar
-```python
-from nercone_modern.progressbar import ModernProgressBar
-progress_bar = ModernProgressBar(total=100, process_name="Task 1", spinner_mode=True)
-
-progress_bar.start()
-time.sleep(5)
-
-progress_bar.spinner(False)
-
-progress_bar.setMessage("Step 1")
-
-for i in range(50):
-  time.sleep(0.05)
-  progress_bar.update(amount=1)
-
-progress_bar.setMessage("Step 2")
-
-for i in range(25):
-  time.sleep(0.03)
-  progress_bar.update(amount=1)
-
-progress_bar.setMessage("Step 3")
-
-for i in range(5):
-  time.sleep(1)
-  progress_bar.update(amount=5)
-
-progress_bar.finish()
-```

nercone_modern-1.6.1.dist-info/RECORD

@@ -1,9 +0,0 @@
-nercone_modern/__init__.py,sha256=ArF3T8FdWIhwGcL4MfYcHqMse3n5gjuyzbLNlcqRcxs,443
-nercone_modern/__main__.py,sha256=EDFIQTNrAwT4V5nzcjyn-FtAbR1g8iskDiBR7Kco1WQ,2069
-nercone_modern/color.py,sha256=sy7f0Fe07PZWNfM1AOt7HeuhF7uGK2_IuZHEckwgxc4,1328
-nercone_modern/logging.py,sha256=S_OyfAe-XbqII0wvB0wgyjlfKPokWBSG5aOu0YsPgJE,8219
-nercone_modern/progressbar.py,sha256=bzlGg0dSj88eli2lM0cI4xTw2FNJqlJb352jdtJbsWQ,8088
-nercone_modern/text.py,sha256=eGxGQOJ3b-783ocLibkG62cOcYD4HLG_3diA52tU8jI,1031
-nercone_modern-1.6.1.dist-info/WHEEL,sha256=DpNsHFUm_gffZe1FgzmqwuqiuPC6Y-uBCzibcJcdupM,78
-nercone_modern-1.6.1.dist-info/METADATA,sha256=SseIvl73T1dY3ypUeuHVr2zUB7nREj1yBgQSwPxIyLw,2472
-nercone_modern-1.6.1.dist-info/RECORD,,