txtwrap 1.0.0__tar.gz → 1.1.1__tar.gz

txtwrap-1.1.1/PKG-INFO

@@ -0,0 +1,164 @@
+Metadata-Version: 2.1
+Name: txtwrap
+Version: 1.1.1
+Summary: A simple text wrapping tool.
+Author: azzammuhyala
+License: MIT
+Keywords: wrap,wrapper,wrapping,wrapped,wrapping tool,text wrap,text wrapper,simple wrap,align,aligner,aligning,aligned
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# TxTWrap🔡
+A tool for wrapping a text.🔨
+
+> **⚠️All documents are in the each module.⚠️**
+
+All constants and functions❕:
+- `LOREM_IPSUM_W`
+- `LOREM_IPSUM_S`
+- `LOREM_IPSUM_P`
+- `mono`
+- `word`
+- `wrap`
+- `align` (Updated!)
+- `fillstr`
+- `printwrap`
+- `shorten`
+
+Mod `python -m txtwrap` Commands❗:
+```shell
+python -m txtwrap --help
+```
+
+Examples❓:
+## Render a wrap text in PyGame🎮
+```py
+from typing import Literal, Optional
+from txtwrap import align, LOREM_IPSUM_P
+import pygame
+
+def render_wrap(
+
+    font: pygame.Font,
+    text: str,
+    width: int,
+    antialias: bool,
+    color: pygame.Color,
+    background: Optional[pygame.Color] = None,
+    linegap: int = 0,
+    alignment: Literal['left', 'center', 'right', 'fill'] = 'left',
+    method: Literal['word', 'mono'] = 'word',
+    preserve_empty: bool = True,
+    use_min_width: bool = True
+
+) -> pygame.Surface:
+
+    # Only supports in txtwrap 1.1.1+
+    align_info = align(
+        text=text,
+        width=width,
+        linegap=linegap,
+        sizefunc=font.size,
+        method=method,
+        alignment=alignment,
+        preserve_empty=preserve_empty,
+        use_min_width=use_min_width,
+        return_details=True
+    )
+
+    surface = pygame.Surface(align_info['size'], pygame.SRCALPHA)
+
+    if background is not None:
+        surface.fill(background)
+
+    for x, y, text in align_info['aligned']:
+        surface.blit(font.render(text, antialias, color), (x, y))
+
+    return surface
+
+# Example usage:
+pygame.init()
+pygame.display.set_caption("Lorem Ipsum")
+
+running = True
+wscrn, hscrn = 600, 600
+screen = pygame.display.set_mode((wscrn, hscrn))
+clock = pygame.time.Clock()
+surface = render_wrap(
+    font=pygame.font.Font(None, 20),
+    text=LOREM_IPSUM_P,
+    width=wscrn,
+    antialias=True,
+    color='#ffffff',
+    background='#303030',
+    alignment='fill'
+)
+
+wsurf, hsurf = surface.get_size()
+pos = ((wscrn - wsurf) / 2, (hscrn - hsurf) / 2)
+
+while running:
+    for event in pygame.event.get():
+        if event.type == pygame.QUIT:
+            running = False
+    screen.fill('#000000')
+    screen.blit(surface, pos)
+    pygame.display.flip()
+    clock.tick(60)
+```
+
+## Print a wrap text to terminal🔡
+```py
+# Only supports in txtwrap 1.1.0+
+from txtwrap import printwrap, LOREM_IPSUM_W
+
+printwrap(LOREM_IPSUM_W, width=20, alignment='left')
+print('=' * 20)
+printwrap(LOREM_IPSUM_W, width=20, alignment='center')
+print('=' * 20)
+printwrap(LOREM_IPSUM_W, width=20, alignment='right')
+print('=' * 20)
+printwrap(LOREM_IPSUM_W, width=20, alignment='fill')
+```
+
+## Short a long text🔤
+```py
+from txtwrap import shorten, LOREM_IPSUM_S
+
+short_lorem = shorten(LOREM_IPSUM_S, width=20, placeholder='…')
+# Only supports in txtwrap 1.1.0+
+test = shorten('   Helllo,   \t\r\n World!!  \f', width=20, placeholder='…', strip_space=True)
+
+print(short_lorem)
+print(test)
+```
+
+## Bonus🎁 - Print a colorfull text to terminal🔥
+```py
+# Run this code in a terminal that supports ansi characters
+
+from re import compile
+from random import randint
+from txtwrap import printwrap, LOREM_IPSUM_P
+
+# Set the text to be printed here
+text = LOREM_IPSUM_P
+
+remove_ansi_regex = compile(r'\x1b\[[0-9;]*[mK]').sub
+
+def ralen(s: str) -> int:
+    return len(remove_ansi_regex('', s))
+
+while True:
+    # Only supports in txtwrap 1.1.0+
+    printwrap(
+        ''.join(f'\x1b[{randint(31, 36)}m{char}' for char in text) + '\x1b[0m',
+        end='\x1b[H\x1b[J',
+        alignment='fill',
+        lenfunc=ralen
+    )
+```

txtwrap-1.1.1/README.md

@@ -0,0 +1,150 @@
+# TxTWrap🔡
+A tool for wrapping a text.🔨
+
+> **⚠️All documents are in the each module.⚠️**
+
+All constants and functions❕:
+- `LOREM_IPSUM_W`
+- `LOREM_IPSUM_S`
+- `LOREM_IPSUM_P`
+- `mono`
+- `word`
+- `wrap`
+- `align` (Updated!)
+- `fillstr`
+- `printwrap`
+- `shorten`
+
+Mod `python -m txtwrap` Commands❗:
+```shell
+python -m txtwrap --help
+```
+
+Examples❓:
+## Render a wrap text in PyGame🎮
+```py
+from typing import Literal, Optional
+from txtwrap import align, LOREM_IPSUM_P
+import pygame
+
+def render_wrap(
+
+    font: pygame.Font,
+    text: str,
+    width: int,
+    antialias: bool,
+    color: pygame.Color,
+    background: Optional[pygame.Color] = None,
+    linegap: int = 0,
+    alignment: Literal['left', 'center', 'right', 'fill'] = 'left',
+    method: Literal['word', 'mono'] = 'word',
+    preserve_empty: bool = True,
+    use_min_width: bool = True
+
+) -> pygame.Surface:
+
+    # Only supports in txtwrap 1.1.1+
+    align_info = align(
+        text=text,
+        width=width,
+        linegap=linegap,
+        sizefunc=font.size,
+        method=method,
+        alignment=alignment,
+        preserve_empty=preserve_empty,
+        use_min_width=use_min_width,
+        return_details=True
+    )
+
+    surface = pygame.Surface(align_info['size'], pygame.SRCALPHA)
+
+    if background is not None:
+        surface.fill(background)
+
+    for x, y, text in align_info['aligned']:
+        surface.blit(font.render(text, antialias, color), (x, y))
+
+    return surface
+
+# Example usage:
+pygame.init()
+pygame.display.set_caption("Lorem Ipsum")
+
+running = True
+wscrn, hscrn = 600, 600
+screen = pygame.display.set_mode((wscrn, hscrn))
+clock = pygame.time.Clock()
+surface = render_wrap(
+    font=pygame.font.Font(None, 20),
+    text=LOREM_IPSUM_P,
+    width=wscrn,
+    antialias=True,
+    color='#ffffff',
+    background='#303030',
+    alignment='fill'
+)
+
+wsurf, hsurf = surface.get_size()
+pos = ((wscrn - wsurf) / 2, (hscrn - hsurf) / 2)
+
+while running:
+    for event in pygame.event.get():
+        if event.type == pygame.QUIT:
+            running = False
+    screen.fill('#000000')
+    screen.blit(surface, pos)
+    pygame.display.flip()
+    clock.tick(60)
+```
+
+## Print a wrap text to terminal🔡
+```py
+# Only supports in txtwrap 1.1.0+
+from txtwrap import printwrap, LOREM_IPSUM_W
+
+printwrap(LOREM_IPSUM_W, width=20, alignment='left')
+print('=' * 20)
+printwrap(LOREM_IPSUM_W, width=20, alignment='center')
+print('=' * 20)
+printwrap(LOREM_IPSUM_W, width=20, alignment='right')
+print('=' * 20)
+printwrap(LOREM_IPSUM_W, width=20, alignment='fill')
+```
+
+## Short a long text🔤
+```py
+from txtwrap import shorten, LOREM_IPSUM_S
+
+short_lorem = shorten(LOREM_IPSUM_S, width=20, placeholder='…')
+# Only supports in txtwrap 1.1.0+
+test = shorten('   Helllo,   \t\r\n World!!  \f', width=20, placeholder='…', strip_space=True)
+
+print(short_lorem)
+print(test)
+```
+
+## Bonus🎁 - Print a colorfull text to terminal🔥
+```py
+# Run this code in a terminal that supports ansi characters
+
+from re import compile
+from random import randint
+from txtwrap import printwrap, LOREM_IPSUM_P
+
+# Set the text to be printed here
+text = LOREM_IPSUM_P
+
+remove_ansi_regex = compile(r'\x1b\[[0-9;]*[mK]').sub
+
+def ralen(s: str) -> int:
+    return len(remove_ansi_regex('', s))
+
+while True:
+    # Only supports in txtwrap 1.1.0+
+    printwrap(
+        ''.join(f'\x1b[{randint(31, 36)}m{char}' for char in text) + '\x1b[0m',
+        end='\x1b[H\x1b[J',
+        alignment='fill',
+        lenfunc=ralen
+    )
+```

{txtwrap-1.0.0 → txtwrap-1.1.1}/setup.py

@@ -5,7 +5,7 @@ with open('README.md', encoding='utf-8') as readme:
 
 setup(
     name='txtwrap',
-    version='1.0.0',
+    version='1.1.1',
     description='A simple text wrapping tool.',
     long_description=long_description,
     long_description_content_type='text/markdown',
@@ -14,8 +14,8 @@ setup(
     python_requires='>=3.8',
     packages=find_packages(),
     include_package_data=True,
-    keywords=['wrap', 'wrapper', 'wrapping', 'wrapping tool', 'text wrap', 'text wrapper',
-              'simple wrap', 'align', 'aligner', 'aligning'],
+    keywords=['wrap', 'wrapper', 'wrapping', 'wrapped', 'wrapping tool', 'text wrap',
+              'text wrapper', 'simple wrap', 'align', 'aligner', 'aligning', 'aligned'],
     classifiers=[
         'Programming Language :: Python :: 3',
         'Programming Language :: Python :: 3.8',

{txtwrap-1.0.0 → txtwrap-1.1.1}/txtwrap/__init__.py

@@ -5,14 +5,15 @@ A simple text wrapping tool
 # Supports only in Python 3.8+
 
 from .txtwrap import (
+    version,
     LOREM_IPSUM_W, LOREM_IPSUM_S, LOREM_IPSUM_P,
-    mono, word, wrap, align,
+    mono, word, wrap, align, fillstr, printwrap,
     shorten
 )
 
-__version__ = '1.0.0'
+__version__ = version
+__author__ = 'azzammuhyala'
 __license__ = 'MIT'
-__author__ = 'Azzam Muhyala'
 __all__ = [
     'LOREM_IPSUM_W',
     'LOREM_IPSUM_S',
@@ -21,5 +22,7 @@ __all__ = [
     'word',
     'wrap',
     'align',
+    'fillstr',
+    'printwrap',
     'shorten'
 ]

txtwrap-1.1.1/txtwrap/__main__.py

@@ -0,0 +1,111 @@
+from argparse import ArgumentParser
+from txtwrap import version, printwrap, shorten
+
+parser = ArgumentParser(
+    description='Command-line tool for wrapping, aligning, or shortening text.'
+)
+
+parser.add_argument(
+    'text',
+    type=str,
+    help='Text to be wrapped, aligned, or shorted'
+)
+
+parser.add_argument(
+    '-v', '--version',
+    action='version',
+    version=version,
+    help='Show the version of the txtwrap'
+)
+
+parser.add_argument(
+    '-f', '--fill',
+    type=str,
+    default=' ',
+    metavar='<str (1 character)>',
+    help='Fill character (default: " ")'
+)
+
+parser.add_argument(
+    '-w', '--width',
+    type=int,
+    default=None,
+    metavar='<int>',
+    help='Width of the text wrapping (default: current width terminal or 70)'
+)
+
+parser.add_argument(
+    '-m', '--method',
+    type=str,
+    choices={'word', 'mono', 'shorten'},
+    default='word',
+    metavar='{word|mono|shorten}',
+    help='Method to be applied to the text (default: "word")'
+)
+
+parser.add_argument(
+    '-a', '--alignment',
+    type=str,
+    choices={'left', 'center', 'right', 'fill'},
+    default='left',
+    metavar='{left|center|right|fill}',
+    help='Alignment of the text (default: "left")'
+)
+
+parser.add_argument(
+    '-n', '--neglect-empty',
+    action='store_false',
+    help='Neglect empty lines in the text'
+)
+
+parser.add_argument(
+    '-s', '--start',
+    type=int,
+    default=0,
+    metavar='<int>',
+    help='start index of the text to be shorten (default: 0)'
+)
+
+parser.add_argument(
+    '-p', '--placeholder',
+    type=str,
+    default='...',
+    metavar='<str>',
+    help='Placeholder to be used when shortening the text (default: "...")'
+)
+
+parser.add_argument(
+    '-r', '--no-strip',
+    action='store_false',
+    help='Do not strip the space in the text'
+)
+
+args = parser.parse_args()
+
+if args.method == 'shorten':
+    from os import get_terminal_size
+
+    if args.width is None:
+        try:
+            args.width = get_terminal_size().columns
+        except:
+            args.width = 70
+
+    print(
+        shorten(
+            text=args.text,
+            width=args.width,
+            start=args.start,
+            placeholder=args.placeholder,
+            strip_space=args.no_strip
+        )
+    )
+else:
+    printwrap(
+        args.text,
+        fill=args.fill,
+        width=args.width,
+        method=args.method,
+        alignment=args.alignment,
+        preserve_empty=args.neglect_empty
+    )

{txtwrap-1.0.0 → txtwrap-1.1.1}/txtwrap/txtwrap.py

@@ -1,7 +1,9 @@
-from typing import Callable, List, Literal, Tuple, Union
+from typing import Any, Callable, Dict, List, Literal, Optional, Tuple, Union
+from os import get_terminal_size
 from re import compile
 
 hyphenated_regex = compile(r'(?<=-)(?=(?!-).)')
+version = '1.1.1'
 
 LOREM_IPSUM_W = 'Lorem ipsum odor amet, consectetuer adipiscing elit.'
 LOREM_IPSUM_S = ('Lorem ipsum odor amet, consectetuer adipiscing elit. In malesuada eros natoque '
@@ -197,9 +199,12 @@ def align(
     sizefunc: Callable[[str], Tuple[Union[int, float], Union[int, float]]] = lambda s : (len(s), 1),
     method: Literal['mono', 'word'] = 'word',
     alignment: Literal['left', 'center', 'right', 'fill'] = 'left',
-    preserve_empty: bool = True
+    preserve_empty: bool = True,
+    use_min_width: bool = True,
+    return_details: bool = False
 
-) -> List[Tuple[Union[int, float], Union[int, float], str]]:
+) -> List[Union[Tuple[Union[int, float], Union[int, float], str],
+                Dict[Literal['aligned', 'wrapped', 'size'], Any]]]:
 
     """
     Wraps and aligns text within a specified width and yields the position and content of each line.
@@ -223,10 +228,19 @@ def align(
                                                                           or 'fill'.
                                                                           Defaults to 'left'.
         preserve_empty (bool, optional): Whether to preserve empty lines. Defaults to True.
+        use_min_width (bool, optional): Whether to use the manimum width of the wrapped text.
+                                        Defaults to True.
+        return_details (bool, optional): Whether to return the aligned text, wrapped text, and
+                                         the size.
+                                         Defaults to False.
 
     Returns:
-        list[tuple[int | float, int | float, str]]: A list of tuples containing the position and
-                                                    content of each line.
+        list[tuple[int | float, int | float, str] |
+             dict[Literal['aligned', 'wrapped', 'size'], Any]]: A list of tuples containing the
+                                                                position and content of each line.
+                                                                If return_details, a dictionary
+                                                                containing the wrapped text, and
+                                                                the size is returned.
     """
 
     assert isinstance(linegap, (int, float)), "linegap must be an integer or float"
@@ -234,47 +248,228 @@ def align(
 
     assert linegap >= 0, "linegap must be equal to or greater than 0"
 
-    wrapped = []
+    wrapped = wrap(text, width, lambda s : sizefunc(s)[0], method, preserve_empty)
+    size_wrapped = {i: sizefunc(line) for i, line in enumerate(wrapped)}
+    aligned_positions = []
     offset_y = 0
 
-    for line in wrap(text, width, lambda s : sizefunc(s)[0], method, preserve_empty):
+    if use_min_width:
+        max_width = max(size[0] for size in size_wrapped.values())
+        use_width = max_width
+    else:
+        use_width = width
+
+    if alignment == 'left':
+        for i, line in enumerate(wrapped):
+            height_line = size_wrapped[i][1]
+            aligned_positions.append((0, offset_y, line))
+            offset_y += height_line + linegap
+
+    elif alignment == 'center':
+        for i, line in enumerate(wrapped):
+            width_line, height_line = size_wrapped[i]
+            aligned_positions.append(((use_width - width_line) / 2, offset_y, line))
+            offset_y += height_line + linegap
+
+    elif alignment == 'right':
+        for i, line in enumerate(wrapped):
+            width_line, height_line = size_wrapped[i]
+            aligned_positions.append((use_width - width_line, offset_y, line))
+            offset_y += height_line + linegap
+
+    elif alignment == 'fill':
+        no_spaces = True
+        for i, line in enumerate(wrapped):
+            height_line = size_wrapped[i][1]
+            words = line.split()
+            total_words = len(words)
+            word_widths = {i: sizefunc(w)[0] for i, w in enumerate(words)}
+            extra_space = width - sum(word_widths.values())
+            offset_x = 0
 
-        width_line, height_line = sizefunc(line)
+            if total_words > 1:
+                space_between_words = extra_space / (total_words - 1)
+                no_spaces = False
+            else:
+                space_between_words = extra_space
 
-        if alignment == 'left':
-            wrapped.append((0, offset_y, line))
+            for i, w in enumerate(words):
+                aligned_positions.append((offset_x, offset_y, w))
+                offset_x += word_widths[i] + space_between_words
 
-        elif alignment == 'center':
-            wrapped.append(((width - width_line) / 2, offset_y, line))
+            offset_y += height_line + linegap
 
-        elif alignment == 'right':
-            wrapped.append((width - width_line, offset_y, line))
+    else:
+        raise ValueError(f"{alignment=} is invalid, must be 'left', 'center', 'right', or 'fill'")
+
+    if return_details:
+        if use_min_width and alignment == 'fill':
+            if no_spaces:
+                size_width = max_width
+            elif text:
+                size_width = width
+            else:
+                size_width = 0
+        else:
+            size_width = use_width
 
-        elif alignment == 'fill':
-            offset_x = 0
+        return {
+            'aligned': aligned_positions,
+            'wrapped': wrapped,
+            'size': (size_width, offset_y - linegap)
+        }
+
+    return aligned_positions
+
+def fillstr(
+
+    text: str,
+    width: Union[int, float] = 70,
+    fill: str = ' ',
+    lenfunc: Callable[[str], Union[int, float]] = len,
+    method: Literal['mono', 'word'] = 'word',
+    alignment: Union[Callable[[str], str], Literal['left', 'center', 'right', 'fill']] = 'left',
+    preserve_empty: bool = True
+
+) -> str:
+
+    """
+    String formats a given text to fit within a specified width, using various alignment methods.
+
+    Parameters:
+        text (str): The text to be formatted.
+        width (Union[int, float], optional): The width of the formatted text. Defaults to 70.
+        fill (str, optional): The character used to fill the space. Must be a single character.
+                              Defaults to ' '.
+        lenfunc (Callable[[str], Union[int, float]], optional): A function to calculate the
+                                                                length of a string. Defaults to len.
+        method (Literal['mono', 'word'], optional): The method to use for wrapping.
+                                                    'mono' for character-based wrapping, 'word'
+                                                    for word-based wrapping. Defaults to 'word'.
+        alignment (Union[Callable[[str], str],
+                   Literal['left', 'center', 'right', 'fill']], optional): The alignment of the
+                                                                           text. 'left', 'center',
+                                                                           'right', or 'fill'.
+                                                                           Defaults to 'left'.
+        preserve_empty (bool, optional): Whether to preserve empty lines. Defaults to True.
+
+    Returns:
+        str: The formatted text.
+    """
+
+    assert isinstance(fill, str), "fill must be a string"
+    assert len(fill) == 1, "fill must be a single character"
+
+    wrapped = wrap(text, width, lenfunc, method, preserve_empty)
+    justified_lines = ''
+
+    if callable(alignment):
+        return '\n'.join(alignment(line) for line in wrapped)
+
+    elif alignment == 'left':
+        for line in wrapped:
+            justified_lines += line + fill * (width - lenfunc(line)) + '\n'
+
+    elif alignment == 'center':
+        for line in wrapped:
+            extra_space = width - lenfunc(line)
+            left_space = extra_space // 2
+            justified_lines += fill * left_space + line + fill * (extra_space - left_space) + '\n'
+
+    elif alignment == 'right':
+        for line in wrapped:
+            justified_lines += fill * (width - lenfunc(line)) + line + '\n'
+
+    elif alignment == 'fill':
+        for line in wrapped:
             words = line.split()
             total_words = len(words)
-            widths = {i: sizefunc(w)[0] for i, w in enumerate(words)}
-            total_words_width = sum(widths.values())
+            total_words_width = sum(lenfunc(w) for w in words)
             extra_space = width - total_words_width
 
             if total_words > 1:
-                space_between_words = extra_space / (total_words - 1)
+                space_between_words = extra_space // (total_words - 1)
+                extra_padding = extra_space % (total_words - 1)
             else:
                 space_between_words = extra_space
+                extra_padding = 0
 
-            for i, w in enumerate(words):
-                wrapped.append((offset_x, offset_y, w))
-                offset_x += widths[i] + space_between_words
+            justified_line = ''
+            for i, word in enumerate(words):
+                justified_line += word
+                if i < total_words - 1:
+                    justified_line += fill * (space_between_words + (1 if i < extra_padding else 0))
 
-        else:
-            raise ValueError(
-                f"{alignment=} is invalid, must be 'left', 'center', 'right', or 'fill'"
-            )
+            justified_lines += justified_line + '\n'
 
-        offset_y += height_line + linegap
+    else:
+        raise ValueError(
+            f"{alignment=} is invalid, must be 'left', 'center', 'right', 'fill' or "
+            'a callable function'
+        )
+
+    return justified_lines[:-1]
+
+def printwrap(
+
+    *values: object,
+    sep: Optional[str] = ' ',
+    end: Optional[str] = '\n',
+    fill: str = ' ',
+    width: Optional[int] = None,
+    lenfunc: Callable[[str], Union[int, float]] = len,
+    method: Literal['word', 'mono'] = 'word',
+    alignment: Union[Callable[[str], str], Literal['left', 'center', 'right', 'fill']] = 'left',
+    file: Optional[object] = None,
+    flush: bool = False,
+    preserve_empty: bool = True
+
+) -> None:
 
-    return wrapped
+    """
+    Print the given values with word wrapping and alignment.
+
+    Parameters:
+        *values (object): Values to be printed.
+        sep (Optional[str]): Separator between values. Default to ' '.
+        end (Optional[str]): String appended after the last value. Default to '\\n'.
+        fill (str): Fill character for padding. Default to ' '.
+        width (Optional[int]): Width of the output. If None, it tries to use the terminal width or
+                               defaults to 70.
+        lenfunc (Callable[[str], Union[int, float]]): Function to calculate the length of a string.
+                                                      Default is len.
+        method (Literal['word', 'mono']): The method to use for wrapping. 'mono' for character-based
+                                          wrapping, 'word' for word-based wrapping.
+                                          Defaults to 'word'.
+        alignment (Union[Callable[[str], str],
+                   Literal['left', 'center', 'right', 'fill']]): Alignment of the text.
+                                                                 Default is 'left'.
+        file (Optional[object]): A file-like object (stream) to write the output to.
+                                 Default is None, which means sys.stdout.
+        flush (bool): Whether to forcibly flush the stream. Default is False.
+        preserve_empty (bool, optional): Whether to preserve empty lines. Defaults to True.
+    """
+
+    if width is None:
+        try:
+            width = get_terminal_size().columns
+        except:
+            width = 70
+
+    print(
+        fillstr(
+            (' ' if sep is None else sep).join(map(str, values)),
+            width,
+            fill,
+            lenfunc,
+            method,
+            alignment,
+            preserve_empty
+        ),
+        end=end,
+        file=file,
+        flush=flush
+    )
 
 def shorten(
 
@@ -282,7 +477,8 @@ def shorten(
     width: Union[int, float] = 70,
     start: int = 0,
     lenfunc: Callable[[str], Union[int, float]] = len,
-    placeholder: str = '...'
+    placeholder: str = '...',
+    strip_space: bool = True
 
 ) -> str:
 
@@ -297,6 +493,7 @@ def shorten(
                                                           the length of a string. Defaults to len.
         placeholder (str, optional): The placeholder to append to the shortened text.
                                      Defaults to '...'.
+        strip_space (bool, optional): Whether to strip extra spaces in the text. Defaults to True.
 
     Returns:
         str: The shortened text with the placeholder appended if necessary.
@@ -311,8 +508,13 @@ def shorten(
     assert width >= lenfunc(placeholder), "width must be greater than length of the placeholder"
     assert start >= 0, "start must be equal to or greater than 0"
 
+    if strip_space:
+        text = ' '.join(text.split())
+
     if start == 0:
         current_char = ''
+    elif start >= len(text):
+        return ''
     else:
         current_char = placeholder
 
@@ -320,6 +522,9 @@ def shorten(
         if lenfunc(current_char + char + placeholder) <= width:
             current_char += char
         else:
-            return current_char + placeholder
+            current_char += placeholder
+            if lenfunc(current_char) > width:
+                return placeholder
+            return current_char
 
     return current_char

txtwrap-1.1.1/txtwrap.egg-info/PKG-INFO

@@ -0,0 +1,164 @@
+Metadata-Version: 2.1
+Name: txtwrap
+Version: 1.1.1
+Summary: A simple text wrapping tool.
+Author: azzammuhyala
+License: MIT
+Keywords: wrap,wrapper,wrapping,wrapped,wrapping tool,text wrap,text wrapper,simple wrap,align,aligner,aligning,aligned
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# TxTWrap🔡
+A tool for wrapping a text.🔨
+
+> **⚠️All documents are in the each module.⚠️**
+
+All constants and functions❕:
+- `LOREM_IPSUM_W`
+- `LOREM_IPSUM_S`
+- `LOREM_IPSUM_P`
+- `mono`
+- `word`
+- `wrap`
+- `align` (Updated!)
+- `fillstr`
+- `printwrap`
+- `shorten`
+
+Mod `python -m txtwrap` Commands❗:
+```shell
+python -m txtwrap --help
+```
+
+Examples❓:
+## Render a wrap text in PyGame🎮
+```py
+from typing import Literal, Optional
+from txtwrap import align, LOREM_IPSUM_P
+import pygame
+
+def render_wrap(
+
+    font: pygame.Font,
+    text: str,
+    width: int,
+    antialias: bool,
+    color: pygame.Color,
+    background: Optional[pygame.Color] = None,
+    linegap: int = 0,
+    alignment: Literal['left', 'center', 'right', 'fill'] = 'left',
+    method: Literal['word', 'mono'] = 'word',
+    preserve_empty: bool = True,
+    use_min_width: bool = True
+
+) -> pygame.Surface:
+
+    # Only supports in txtwrap 1.1.1+
+    align_info = align(
+        text=text,
+        width=width,
+        linegap=linegap,
+        sizefunc=font.size,
+        method=method,
+        alignment=alignment,
+        preserve_empty=preserve_empty,
+        use_min_width=use_min_width,
+        return_details=True
+    )
+
+    surface = pygame.Surface(align_info['size'], pygame.SRCALPHA)
+
+    if background is not None:
+        surface.fill(background)
+
+    for x, y, text in align_info['aligned']:
+        surface.blit(font.render(text, antialias, color), (x, y))
+
+    return surface
+
+# Example usage:
+pygame.init()
+pygame.display.set_caption("Lorem Ipsum")
+
+running = True
+wscrn, hscrn = 600, 600
+screen = pygame.display.set_mode((wscrn, hscrn))
+clock = pygame.time.Clock()
+surface = render_wrap(
+    font=pygame.font.Font(None, 20),
+    text=LOREM_IPSUM_P,
+    width=wscrn,
+    antialias=True,
+    color='#ffffff',
+    background='#303030',
+    alignment='fill'
+)
+
+wsurf, hsurf = surface.get_size()
+pos = ((wscrn - wsurf) / 2, (hscrn - hsurf) / 2)
+
+while running:
+    for event in pygame.event.get():
+        if event.type == pygame.QUIT:
+            running = False
+    screen.fill('#000000')
+    screen.blit(surface, pos)
+    pygame.display.flip()
+    clock.tick(60)
+```
+
+## Print a wrap text to terminal🔡
+```py
+# Only supports in txtwrap 1.1.0+
+from txtwrap import printwrap, LOREM_IPSUM_W
+
+printwrap(LOREM_IPSUM_W, width=20, alignment='left')
+print('=' * 20)
+printwrap(LOREM_IPSUM_W, width=20, alignment='center')
+print('=' * 20)
+printwrap(LOREM_IPSUM_W, width=20, alignment='right')
+print('=' * 20)
+printwrap(LOREM_IPSUM_W, width=20, alignment='fill')
+```
+
+## Short a long text🔤
+```py
+from txtwrap import shorten, LOREM_IPSUM_S
+
+short_lorem = shorten(LOREM_IPSUM_S, width=20, placeholder='…')
+# Only supports in txtwrap 1.1.0+
+test = shorten('   Helllo,   \t\r\n World!!  \f', width=20, placeholder='…', strip_space=True)
+
+print(short_lorem)
+print(test)
+```
+
+## Bonus🎁 - Print a colorfull text to terminal🔥
+```py
+# Run this code in a terminal that supports ansi characters
+
+from re import compile
+from random import randint
+from txtwrap import printwrap, LOREM_IPSUM_P
+
+# Set the text to be printed here
+text = LOREM_IPSUM_P
+
+remove_ansi_regex = compile(r'\x1b\[[0-9;]*[mK]').sub
+
+def ralen(s: str) -> int:
+    return len(remove_ansi_regex('', s))
+
+while True:
+    # Only supports in txtwrap 1.1.0+
+    printwrap(
+        ''.join(f'\x1b[{randint(31, 36)}m{char}' for char in text) + '\x1b[0m',
+        end='\x1b[H\x1b[J',
+        alignment='fill',
+        lenfunc=ralen
+    )
+```

txtwrap-1.0.0/PKG-INFO

@@ -1,33 +0,0 @@
-Metadata-Version: 2.1
-Name: txtwrap
-Version: 1.0.0
-Summary: A simple text wrapping tool.
-Author: azzammuhyala
-License: MIT
-Keywords: wrap,wrapper,wrapping,wrapping tool,text wrap,text wrapper,simple wrap,align,aligner,aligning
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: License :: OSI Approved :: MIT License
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-
-# TxTWrap 🔤
-A tool for wrapping a text.🔨
-
-> **⚠️All documents are in the each module.⚠️**
-
-All constants and functions❕:
-- `LOREM_IPSUM_W`
-- `LOREM_IPSUM_S`
-- `LOREM_IPSUM_P`
-- `mono`
-- `word`
-- `wrap`
-- `align`
-- `shorten`
-
-Mod `python -m txtwrap` Commands❗:
-```shell
-python -m txtwrap --help
-```

txtwrap-1.0.0/README.md

@@ -1,19 +0,0 @@
-# TxTWrap 🔤
-A tool for wrapping a text.🔨
-
-> **⚠️All documents are in the each module.⚠️**
-
-All constants and functions❕:
-- `LOREM_IPSUM_W`
-- `LOREM_IPSUM_S`
-- `LOREM_IPSUM_P`
-- `mono`
-- `word`
-- `wrap`
-- `align`
-- `shorten`
-
-Mod `python -m txtwrap` Commands❗:
-```shell
-python -m txtwrap --help
-```

txtwrap-1.0.0/txtwrap/__main__.py

@@ -1,105 +0,0 @@
-from argparse import ArgumentParser
-from os import get_terminal_size
-from txtwrap import wrap, shorten
-
-parser = ArgumentParser(
-    description='Command-line tool for wrapping, aligning, or shortening text.'
-)
-
-parser.add_argument(
-    'text',
-    type=str,
-    help='Text to be wrapped, aligned, or shorted'
-)
-
-try:
-    width = get_terminal_size()[0]
-except:
-    width = 70
-
-parser.add_argument(
-    '-w', '--width',
-    type=int,
-    default=width,
-    metavar='<number>',
-    help='Width of the text wrapping (default: current width terminal or 70)'
-)
-
-parser.add_argument(
-    '-m', '--method',
-    type=str,
-    choices={'word', 'mono', 'shorten'},
-    default='word',
-    metavar='{word|mono|shorten}',
-    help='Method to be applied to the text (default: word)'
-)
-
-parser.add_argument(
-    '-a', '--alignment',
-    type=str,
-    choices={'left', 'center', 'right', 'fill'},
-    default='left',
-    metavar='{left|center|right|fill}',
-    help='Alignment of the text (default: left)'
-)
-
-parser.add_argument(
-    '-ne', '--neglect-empty',
-    action='store_false',
-    help='Neglect empty lines in the text'
-)
-
-parser.add_argument(
-    '-s', '--start',
-    type=int,
-    default=0,
-    metavar='<number>',
-    help='start index of the text to be shorten (default: 0)'
-)
-
-parser.add_argument(
-    '-ph', '--placeholder',
-    type=str,
-    default='...',
-    metavar='<str>',
-    help='Placeholder to be used when shortening the text (default: ...)'
-)
-
-args = parser.parse_args()
-
-if args.method == 'shorten':
-    print(shorten(args.text, args.width, args.start, placeholder=args.placeholder))
-else:
-    wrapped = wrap(args.text, args.width, method=args.method, preserve_empty=args.neglect_empty)
-
-    if args.alignment == 'left':
-        print('\n'.join(wrapped))
-    elif args.alignment == 'center':
-        print('\n'.join(line.center(args.width) for line in wrapped))
-    elif args.alignment == 'right':
-        print('\n'.join(line.rjust(args.width) for line in wrapped))
-    elif args.alignment == 'fill':
-        justified_lines = ''
-
-        for line in wrapped:
-            words = line.split()
-            total_words = len(words)
-            total_words_width = sum(len(w) for w in words)
-            extra_space = args.width - total_words_width
-
-            if total_words > 1:
-                space_between_words = extra_space // (total_words - 1)
-                extra_padding = extra_space % (total_words - 1)
-            else:
-                space_between_words = extra_space
-                extra_padding = 0
-
-            justified_line = ''
-            for i, word in enumerate(words):
-                justified_line += word
-                if i < total_words - 1:
-                    justified_line += ' ' * (space_between_words + (1 if i < extra_padding else 0))
-
-            justified_lines += justified_line + '\n'
-
-        print(justified_lines, end='')

txtwrap-1.0.0/txtwrap.egg-info/PKG-INFO

@@ -1,33 +0,0 @@
-Metadata-Version: 2.1
-Name: txtwrap
-Version: 1.0.0
-Summary: A simple text wrapping tool.
-Author: azzammuhyala
-License: MIT
-Keywords: wrap,wrapper,wrapping,wrapping tool,text wrap,text wrapper,simple wrap,align,aligner,aligning
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: License :: OSI Approved :: MIT License
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-
-# TxTWrap 🔤
-A tool for wrapping a text.🔨
-
-> **⚠️All documents are in the each module.⚠️**
-
-All constants and functions❕:
-- `LOREM_IPSUM_W`
-- `LOREM_IPSUM_S`
-- `LOREM_IPSUM_P`
-- `mono`
-- `word`
-- `wrap`
-- `align`
-- `shorten`
-
-Mod `python -m txtwrap` Commands❗:
-```shell
-python -m txtwrap --help
-```