Chromite 0.6.0__tar.gz

chromite-0.6.0/Chromite/__init__.py

@@ -0,0 +1,24 @@
+"""
+
+    Copyright (C) 2026 NastyaNoTamashii.
+
+"""
+
+__title__ = "Chromite"
+__author__ = "NastyaNoTamashii"
+__license__ = "MIT"
+__copyright__ = "Copyright 2026-present NastyaNoTamashii"
+__version__ = "0.6.0"
+
+from .formatting import color as _color, color_bg as _color_bg, style as _style
+from .io import (
+    Write, Catch, clear, sjoin
+)
+
+from .table import Table
+
+Color = _color
+ColorBG = _color_bg
+Style = _style
+
+__all__ = ["Write", "Catch", "Color", "ColorBG", "Style", "Table", "clear", "sjoin"]

chromite-0.6.0/Chromite/codes.py

@@ -0,0 +1,43 @@
+"""
+
+    Copyright (C) 2026 NastyaNoTamashii.
+
+"""
+
+import os
+
+# Инициализируем поддержку ANSI в Windows-консолях
+os.system("")
+
+CSI = "\033["
+
+class ANSIElement(str):
+    """
+    Custom string for ANSI codes.
+    """
+    pass
+
+def make_ansi(code: int) -> ANSIElement:
+    return ANSIElement(f"{CSI}{code}m")
+
+# --- Новые функции для работы с курсором ---
+
+def move_cursor(x: int, y: int) -> ANSIElement:
+    """Перемещает курсор на позицию (x, y) / (col, row). Нумерация с 1,1."""
+    return ANSIElement(f"{CSI}{y};{x}H")
+
+def hide_cursor() -> ANSIElement:
+    """Скрывает курсор"""
+    return ANSIElement(f"{CSI}?25l")
+
+def show_cursor() -> ANSIElement:
+    """Показывает курсор"""
+    return ANSIElement(f"{CSI}?25h")
+
+def save_cursor() -> ANSIElement:
+    """Сохраняет текущую позицию курсора"""
+    return ANSIElement(f"{CSI}s")
+
+def restore_cursor() -> ANSIElement:
+    """Восстанавливает сохраненную позицию курсора"""
+    return ANSIElement(f"{CSI}u")

chromite-0.6.0/Chromite/formatting.py

@@ -0,0 +1,75 @@
+"""
+
+    Copyright (C) 2026 NastyaNoTamashii.
+
+"""
+
+import random
+from .codes import ANSIElement, make_ansi
+
+__all__ = ['color', 'color_bg', 'style']
+
+class BaseCodes:
+    RESET = make_ansi(0)
+
+class Color(BaseCodes):
+    black  = make_ansi(30)
+    red    = make_ansi(31)
+    green  = make_ansi(32)
+    yellow = make_ansi(33)
+    blue   = make_ansi(34)
+    violet = make_ansi(35)
+    cyan   = make_ansi(36)
+    white  = make_ansi(37)
+    pink   = make_ansi('38;5;206')
+
+    light_red    = make_ansi(91)
+    light_green  = make_ansi(92)
+    light_yellow = make_ansi(93)
+    light_blue   = make_ansi(94)
+    light_violet = make_ansi(95)
+    light_cyan   = make_ansi(96)
+    light_yellow = make_ansi(97)
+
+    @property
+    def random(self) -> ANSIElement:
+        """Returns a random text color each time."""
+        return make_ansi(random.randint(30, 37))
+
+class ColorBG(BaseCodes):
+    black  = make_ansi(40)
+    red    = make_ansi(41)
+    green  = make_ansi(42)
+    yellow = make_ansi(43)
+    blue   = make_ansi(44)
+    violet = make_ansi(45)
+    cyan   = make_ansi(46)
+    white  = make_ansi(47)
+
+    light_red    = make_ansi(101)
+    light_green  = make_ansi(102)
+    light_yellow = make_ansi(103)
+    light_blue   = make_ansi(104)
+    light_violet = make_ansi(105)
+    light_cyan   = make_ansi(106)
+    light_yellow = make_ansi(107)
+
+    @property
+    def random(self) -> ANSIElement:
+        """Returns a random background color each time."""
+        return make_ansi(random.randint(40, 47))
+
+class Style(BaseCodes):
+    bold      = make_ansi(1)
+    dim       = make_ansi(2)
+    italic    = make_ansi(3)
+    underline = make_ansi(4)
+    blink     = make_ansi(5)
+  # blink     = make_ansi(6) Also blink
+    inversed  = make_ansi(7)
+    hide      = make_ansi(8)
+    strike    = make_ansi(9)
+    
+color = Color()
+color_bg = ColorBG()
+style = Style()

chromite-0.6.0/Chromite/io.py

@@ -0,0 +1,233 @@
+"""
+
+    Copyright (C) 2026 NastyaNoTamashii.
+
+"""
+
+__all__ = ['Write', 'Catch', 'sjoin', 'clear']
+
+import sys
+from typing import Union, List, Tuple, Optional
+from .codes import ANSIElement, move_cursor, show_cursor
+from .formatting import BaseCodes
+
+# Тип-хинт для стилей: один элемент или список/кортеж элементов
+StyleType = Union[ANSIElement, List[ANSIElement], Tuple[ANSIElement, ...]]
+
+PosType = Tuple[int, int]  # (x, y) или (col, row)
+
+try:
+    import msvcrt
+    WINDOWS = True
+except ImportError:
+    import tty
+    import termios
+    WINDOWS = False
+
+def _read_masked_input(mask_char: str) -> str:
+    """Считывает ввод с маскировкой символов без стандартного эха терминала."""
+    buf = []
+    while True:
+        if WINDOWS:
+            ch = msvcrt.getch()
+            if ch in (b"\r", b"\n"):
+                print()
+                break
+            elif ch == b"\x08":  # Backspace
+                if buf:
+                    buf.pop()
+                    sys.stdout.write("\b \b")
+                    sys.stdout.flush()
+            elif ch not in (b"\x00", b"\xe0"):
+                try:
+                    char_str = ch.decode("utf-8")
+                    buf.append(char_str)
+                    sys.stdout.write(mask_char)
+                    sys.stdout.flush()
+                except UnicodeDecodeError:
+                    pass
+        else:
+            fd = sys.stdin.fileno()
+            old_settings = termios.tcgetattr(fd)
+            try:
+                tty.setraw(fd)
+                ch = sys.stdin.read(1)
+            finally:
+                termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+
+            if ch in ("\r", "\n"):
+                print()
+                break
+            elif ch in ("\x7f", "\x08"):  # Backspace
+                if buf:
+                    buf.pop()
+                    sys.stdout.write("\b \b")
+                    sys.stdout.flush()
+            elif ch == "\x03":  # Ctrl+C
+                raise KeyboardInterrupt
+            else:
+                buf.append(ch)
+                sys.stdout.write(mask_char)
+                sys.stdout.flush()
+
+    return "".join(buf)
+
+class Write:
+    __slots__ = ("text", "compose", "pos",)
+
+    def __init__(
+        self, 
+        text: str, 
+        *, 
+        compose: StyleType = None, 
+        pos: Optional[PosType] = None
+    ):
+        """
+        :param text: Text
+        :param compose: Set style for text.
+        :param pos: Set position (x, y).
+        """
+        self.text = str(text)
+        self.pos = pos
+
+        if compose:
+            # 1. Если передан один правильный ANSI-стиль
+            if isinstance(compose, ANSIElement):
+                self.text = f"{compose}{self.text}{BaseCodes.RESET}"
+            
+            # 2. Если передана коллекция стилей (например: style=[color.red, style.bold])
+            elif isinstance(compose, (list, tuple)) and all(isinstance(comp, ANSIElement) for comp in compose):
+                ansi_sequence = "".join(compose)
+                self.text = f"{ansi_sequence}{self.text}{BaseCodes.RESET}"
+            
+            # 3. Если подсунули левую строку или не тот объект
+            else:
+                raise TypeError("Style must be an ANSIElement or a collection of ANSIElements (from Chromite).")
+
+    def render_list(self, items: list) -> None:
+        """Красиво выводит нумерованный список в консоль"""
+        for index, item in enumerate(items):
+            print(f"{index}. {item}")
+    
+    def flush(self) -> str:
+        """Возвращает строку с учетом позиционирования курсора"""
+        if self.pos is not None:
+            x, y = self.pos
+            # Приводим к 1-based координатам терминала (1, 1 — верхний левый угол)
+            ansi_pos = move_cursor(max(1, x + 1), max(1, y + 1))
+            return f"{ansi_pos}{self.text}"
+        return self.text
+
+    def display(self) -> None:
+        """Сразу выводит текст в консоль"""
+        print(self.flush(), end="", flush=True)
+
+    def __str__(self) -> str:
+        return self.flush()
+
+class Catch:
+    __slots__ = ("prompt", "compose", "catch_compose", "pos", "type")
+
+    def __init__(
+        self,
+        prompt: str = "> ",
+        *,
+        compose: StyleType = None,
+        catch_compose: StyleType = None,
+        pos: Optional[PosType] = None,
+        type: str = "text",
+    ):
+        """
+        :param prompt: Prompt text.
+        :param compose: Set style for prompt text.
+        :param catch_compose: Стиль для вводимого текста и возвращаемого Write.
+        :param pos: Позиция (x, y) для отрисовки поля ввода.
+        :param type: Тип ввода ("text", "password", "pin", "hidden", "int").
+        :param mask_char: Символ маскировки при type="password".
+        """
+        self.prompt = str(prompt)
+        self.compose = compose
+        self.catch_compose = catch_compose
+        self.pos = pos
+        self.type = type.lower()
+
+        # Применяем стили к промпту
+        if self.compose:
+            if isinstance(self.compose, ANSIElement):
+                self.prompt = f"{self.compose}{self.prompt}{BaseCodes.RESET}"
+            elif isinstance(self.compose, (list, tuple)) and all(isinstance(comp, ANSIElement) for comp in self.compose):
+                ansi_seq = "".join(str(comp) for comp in self.compose)
+                self.prompt = f"{ansi_seq}{self.prompt}{BaseCodes.RESET}"
+
+    def up(self) -> Write:
+        """
+        Перемещает курсор (если задан pos), активирует style для ввода,
+        считывает текст с учетом type и сбрасывает стили.
+        """
+        formatted_prompt = self.prompt
+
+        # 1. Если заданы координаты, добавляем перемещение курсора
+        if self.pos is not None:
+            x, y = self.pos
+            ansi_pos = move_cursor(max(1, x + 1), max(1, y + 1))
+            formatted_prompt = f"{ansi_pos}{self.prompt}"
+
+        # 2. Подготавливаем ANSI-код для стиля ввода
+        input_ansi_start = ""
+        if self.catch_compose:
+            if isinstance(self.catch_compose, ANSIElement):
+                input_ansi_start = str(self.catch_compose)
+            elif isinstance(self.catch_compose, (list, tuple)) and all(isinstance(s, ANSIElement) for s in self.catch_compose):
+                input_ansi_start = "".join(str(s) for s in self.catch_compose)
+
+        # 3. Включаем отображение курсора и накладываем стиль на сам ввод
+        full_prompt = f"{show_cursor()}{formatted_prompt}{input_ansi_start}"
+
+        try:
+            # 4. Обработка ввода в зависимости от type
+            if self.type == "password":
+                sys.stdout.write(full_prompt)
+                sys.stdout.flush()
+                user_input = _read_masked_input(mask_char='*')
+
+            elif self.type == "pin":
+                sys.stdout.write(full_prompt)
+                sys.stdout.flush()
+                user_input = _read_masked_input(mask_char='•')
+
+            elif self.type == "hidden":
+                sys.stdout.write(full_prompt)
+                sys.stdout.flush()
+                user_input = _read_masked_input(mask_char="")
+
+            elif self.type in ("int", "number"):
+                while True:
+                    raw = input(full_prompt)
+                    if raw.strip().isdigit():
+                        user_input = raw
+                        break
+                    # Если введено не число — очищаем строку и повторяем
+                    sys.stdout.write(f"\033[1A\033[2K")
+                    sys.stdout.flush()
+
+            else:
+                # Стандартный текстовый ввод
+                user_input = input(full_prompt)
+
+        finally:
+            # Сбрасываем стили терминала
+            sys.stdout.write(str(BaseCodes.RESET))
+            sys.stdout.flush()
+
+        # Возвращаем объект Write, сохраняя в нем catch_compose
+        return Write(user_input, compose=self.catch_compose)
+
+    def __call__(self) -> Write:
+        return self.up()
+
+def sjoin(text: str, compose: StyleType) -> str:
+    return f"{compose}{text}{BaseCodes.RESET}"
+
+def clear() -> None:
+    """Clears the terminal screen."""
+    print('\x1b[2J\x1b[H')

chromite-0.6.0/Chromite/table.py

@@ -0,0 +1,64 @@
+"""
+
+    Copyright (C) 2026 NastyaNoTamashii.
+
+"""
+
+class Table:
+            
+    def createTable(
+        data,
+        *, 
+        cellUpper: str = None, 
+        cellSep: str = None, 
+        header_separator = None
+    ) -> str:
+        """
+        An example of creating tables:
+            >>> import Chromite
+            >>> data = [["Product", "Cost"],{"Strawberry": "2$","Blueberry":"2,71$","Banana":"1,63$","Apple":"30¢","Limon":"2$",}]
+            >>> tableCreate = Chromite.Table()
+            >>> print (tableCreate.createTable(data = data))
+    
+               Product |  Cost
+            -----------+------
+            Strawberry |    2$
+             Blueberry | 2,71$
+                Banana | 1,63$
+                 Apple |   30¢
+                 Limon |    2$
+        """
+        dataСount = [
+            data[0]
+        ]
+        dataСount += [(k, v) for k, v in data[1].items()]
+
+        rows = len(dataСount)
+        cols = len(dataСount[0])
+
+        cellU =  "-"  if cellUpper is None else cellUpper
+        cellS = " | " if cellSep is None else " {} ".format(cellSep)
+
+        col_width = []
+        for col in range(cols):
+            columns = [str(dataСount[row][col]) for row in range(rows)]
+            col_width.append(len(max(columns, key=len)))
+
+        separator = "{}+{}".format(cellU, cellU).join(cellU * n for n in col_width)
+
+        lines = []
+
+        for i, row in enumerate(range(rows)):
+            result = []
+            for col in range(cols):
+                item = str(dataСount[row][col]).rjust(col_width[col])
+                result.append(item)
+
+            lines.append(cellS.join(result))
+
+            if i == 0 and header_separator:
+                lines.append(separator)
+
+        return (
+                "\n".join(lines)
+        )

chromite-0.6.0/LICENSE.txt

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

chromite-0.6.0/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.5
+Name: Chromite
+Version: 0.6.0
+Summary: Chromite is a framework for text and ASCI formatting in Python.
+Project-URL: Documentation (GitHub), https://github.com/NastyaNoTamashii/Chromite/blob/main/README.md
+Project-URL: Source (GitHub), https://github.com/NastyaNoTamashii/Chromite
+Author: NastyaNoTamashii
+License: MIT
+License-File: LICENSE.txt
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Communications :: Chat
+Classifier: Topic :: Internet
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <h1>
+    Chromite
+  </h1>
+</p>
+
+<h3 align="center">
+    This library is currently under development.
+</h3>
+
+## About
+<strong>Chromite</strong> Chromite is a framework for text and ASCI formatting in Python.
+
+An optimized library that simplifies writing code and helps with the tasks provided.
+
+---
+## Install Chromite
+
+### Installing from PyPi:
+```commandline
+pip install Chromite
+```
+### Installing from Git:
+```commandline
+pip install git+https://github.com/NastyaNoTamashii/Chromite
+```
+
+---
+
+<a href="https://github.com/NastyaNoTamashii/Chromite/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=NastyaNoTamashii/Chromite" />
+</a>
+
+---
+### If a feature doesn't work, check if your console supports it.
+---
+
+## Do you have any questions?
+
+Сontact [me](https://discord.gg/). For help with Chromite.

chromite-0.6.0/README.md

@@ -0,0 +1,40 @@
+<p align="center">
+  <h1>
+    Chromite
+  </h1>
+</p>
+
+<h3 align="center">
+    This library is currently under development.
+</h3>
+
+## About
+<strong>Chromite</strong> Chromite is a framework for text and ASCI formatting in Python.
+
+An optimized library that simplifies writing code and helps with the tasks provided.
+
+---
+## Install Chromite
+
+### Installing from PyPi:
+```commandline
+pip install Chromite
+```
+### Installing from Git:
+```commandline
+pip install git+https://github.com/NastyaNoTamashii/Chromite
+```
+
+---
+
+<a href="https://github.com/NastyaNoTamashii/Chromite/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=NastyaNoTamashii/Chromite" />
+</a>
+
+---
+### If a feature doesn't work, check if your console supports it.
+---
+
+## Do you have any questions?
+
+Сontact [me](https://discord.gg/). For help with Chromite.

chromite-0.6.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "Chromite"
+dynamic = ["version"]
+description = "Chromite is a framework for text and ASCI formatting in Python."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [
+    { name = "NastyaNoTamashii" }
+]
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Intended Audience :: Developers",
+    "Natural Language :: English",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: Implementation :: CPython",
+    "Topic :: Communications :: Chat",
+    "Topic :: Internet :: WWW/HTTP",
+    "Topic :: Internet",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Software Development :: Libraries :: Application Frameworks",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Utilities",
+    "Typing :: Typed",
+]
+
+[project.urls]
+"Documentation (GitHub)" = "https://github.com/NastyaNoTamashii/Chromite/blob/main/README.md"
+"Source (GitHub)" = "https://github.com/NastyaNoTamashii/Chromite"
+
+[tool.hatch.version]
+path = "Chromite/__init__.py"