ellipt 0.2.1__py3-none-any.whl

ellipt/__init__.py

@@ -0,0 +1,30 @@
+"""Truncate strings with an ellipsis at the start, middle or end.
+
+Limits can count code points, grapheme clusters, terminal columns or UTF-8 bytes, and
+the cut never splits a grapheme cluster (UAX #29, Unicode 18.0.0 tables embedded).
+"""
+
+from __future__ import annotations
+
+from ._core import ELLIPSIS, Truncation, Where, truncate
+from ._graphemes import iter_graphemes
+from ._measure import UNITS, Unit, measure
+from ._path import shorten_path
+from ._props import UNICODE_VERSION
+from ._shorten import shorten
+
+__version__ = "0.2.1"
+
+__all__ = [
+    "ELLIPSIS",
+    "UNICODE_VERSION",
+    "UNITS",
+    "Truncation",
+    "Unit",
+    "Where",
+    "iter_graphemes",
+    "measure",
+    "shorten",
+    "shorten_path",
+    "truncate",
+]

ellipt/__main__.py

@@ -0,0 +1,9 @@
+"""Allow ``python -m ellipt``."""
+
+from __future__ import annotations
+
+import sys
+
+from ._cli import main
+
+sys.exit(main())

ellipt/_cli.py

@@ -0,0 +1,186 @@
+"""Command line tool: truncate every line of standard input or of the given files."""
+
+from __future__ import annotations
+
+import argparse
+import contextlib
+import errno
+import os
+import sys
+from collections.abc import Iterator, Sequence
+from typing import IO, NoReturn
+
+from . import __version__
+from ._core import ELLIPSIS, truncate
+from ._measure import UNITS
+from ._path import shorten_path
+
+EXAMPLES = """\
+examples:
+  ls | ellipt 20                         end ellipsis at 20 columns
+  ellipt 30 --where middle notes.txt     keep both ends of each line
+  git ls-files | ellipt 28 --path        keep the root and the file name
+  ellipt 255 --unit bytes --marker "" < titles.txt
+                                         fit a 255-byte UTF-8 column
+  tail -f app.log | ellipt 80 --where start --ellipsis
+
+Lines are read as UTF-8 (a leading byte order mark is dropped) and written as UTF-8,
+keeping each LF or CRLF line ending. The limit counts the marker, and no grapheme
+cluster (accent, flag, emoji sequence) is ever split. With --unit columns, tabs are
+expanded to spaces first (--tabsize); ANSI escape sequences are not recognised, so
+strip colours before piping. Errors go to standard error with exit status 1.
+"""
+
+
+class _PipeClosed(Exception):
+    """The reader of standard output went away."""
+
+
+class _Parser(argparse.ArgumentParser):
+    def error(self, message: str) -> NoReturn:
+        self.print_usage(sys.stderr)
+        self.exit(1, f"{self.prog}: error: {message}\n")
+
+
+def _non_negative(value: str) -> int:
+    try:
+        number = int(value)
+    except ValueError:
+        raise argparse.ArgumentTypeError(f"not a whole number: {value!r}") from None
+    if number < 0:
+        raise argparse.ArgumentTypeError(f"must be non-negative: {number}")
+    return number
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Return the argument parser of the ``ellipt`` command."""
+    parser = _Parser(
+        prog="ellipt",
+        description="Truncate each input line to LIMIT with an ellipsis at the start, "
+        "middle or end.",
+        epilog=EXAMPLES,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument("limit", type=_non_negative, metavar="LIMIT", help="maximum size")
+    parser.add_argument("files", nargs="*", metavar="FILE", help="input files (default: stdin)")
+    parser.add_argument(
+        "-w", "--where", choices=("start", "middle", "end"), help="where to cut (default: end)"
+    )
+    parser.add_argument(
+        "-u",
+        "--unit",
+        choices=UNITS,
+        default="columns",
+        help="what LIMIT counts (default: columns, terminal cells)",
+    )
+    marker = parser.add_mutually_exclusive_group()
+    marker.add_argument("-m", "--marker", default="...", help='replacement text (default: "...")')
+    marker.add_argument(
+        "-e",
+        "--ellipsis",
+        dest="marker",
+        action="store_const",
+        const=ELLIPSIS,
+        help="use the single character U+2026 HORIZONTAL ELLIPSIS as the marker",
+    )
+    parser.add_argument("--words", action="store_true", help="cut at whitespace when possible")
+    parser.add_argument(
+        "--path", action="store_true", help="treat lines as paths: drop middle directories"
+    )
+    parser.add_argument(
+        "--ambiguous",
+        type=int,
+        choices=(1, 2),
+        default=1,
+        help="columns of East Asian Ambiguous characters (default: 1)",
+    )
+    parser.add_argument(
+        "--tabsize",
+        type=_non_negative,
+        default=8,
+        help="with --unit columns, expand tabs to this tab stop first; 0 keeps them as "
+        "zero-width characters (default: 8)",
+    )
+    parser.add_argument("-V", "--version", action="version", version=f"ellipt {__version__}")
+    return parser
+
+
+def _lines(names: Sequence[str]) -> Iterator[tuple[str, int, bytes]]:
+    """Yield ``(source name, line number, raw line)`` with any UTF-8 BOM removed."""
+    if not names:
+        yield from _numbered("<stdin>", sys.stdin.buffer)
+        return
+    for name in names:
+        with open(name, "rb") as handle:
+            yield from _numbered(name, handle)
+
+
+def _numbered(name: str, handle: IO[bytes]) -> Iterator[tuple[str, int, bytes]]:
+    for number, raw in enumerate(handle, 1):
+        yield name, number, raw[3:] if number == 1 and raw.startswith(b"\xef\xbb\xbf") else raw
+
+
+def _write(out: IO[bytes], data: bytes) -> None:
+    try:
+        out.write(data)
+    except OSError as exc:
+        # Windows reports a closed pipe as EINVAL rather than EPIPE.
+        if isinstance(exc, BrokenPipeError) or exc.errno in (errno.EPIPE, errno.EINVAL):
+            raise _PipeClosed from None
+        raise
+
+
+def _split_ending(line: str) -> tuple[str, str]:
+    for ending in ("\r\n", "\n", "\r"):
+        if line.endswith(ending):
+            return line[: -len(ending)], ending
+    return line, ""
+
+
+def _run(args: argparse.Namespace, out: IO[bytes]) -> None:
+    for name, number, raw in _lines(args.files):
+        try:
+            line = raw.decode("utf-8")
+        except UnicodeDecodeError as exc:
+            raise ValueError(f"{name}: line {number} is not valid UTF-8: {exc.reason}") from None
+        body, ending = _split_ending(line)
+        if args.unit == "columns" and args.tabsize and "\t" in body:
+            body = body.expandtabs(args.tabsize)
+        if args.path:
+            short = shorten_path(
+                body, args.limit, unit=args.unit, marker=args.marker, ambiguous=args.ambiguous
+            )
+        else:
+            short = truncate(
+                body,
+                args.limit,
+                where=args.where or "end",
+                unit=args.unit,
+                marker=args.marker,
+                words=args.words,
+                ambiguous=args.ambiguous,
+            ).text
+        _write(out, (short + ending).encode("utf-8"))
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    """Run the command line tool and return its exit status."""
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    if args.path and (args.where not in (None, "middle") or args.words):
+        parser.error("--path always cuts in the middle and does not take --words")
+    try:
+        _run(args, sys.stdout.buffer)
+        _write(sys.stdout.buffer, b"")
+        sys.stdout.flush()
+    except (_PipeClosed, BrokenPipeError):
+        # Point stdout at the null device so the flush at exit cannot fail again.
+        with contextlib.suppress(OSError, ValueError, AttributeError):
+            null = os.open(os.devnull, os.O_WRONLY)
+            os.dup2(null, sys.stdout.fileno())
+            os.close(null)
+        return 0
+    except (OSError, ValueError) as exc:
+        print(f"ellipt: error: {exc}", file=sys.stderr)
+        return 1
+    return 0

ellipt/_core.py

@@ -0,0 +1,127 @@
+"""The truncation engine and its typed result."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Literal
+
+from ._cut import cut
+from ._measure import Unit, check_unit, cluster_size, clusters, size_of
+from ._width import check_ambiguous
+
+Where = Literal["start", "middle", "end"]
+ELLIPSIS = "\u2026"
+
+
+@dataclass(frozen=True)
+class Truncation:
+    """The outcome of ``truncate``: the shortened text and how it was built.
+
+    ``text == head + marker + tail`` always holds. ``head`` is a prefix and ``tail`` a
+    suffix of ``original``, both ending on grapheme cluster boundaries. When the text
+    already fit, ``head`` is the whole original and ``marker`` and ``tail`` are empty.
+    ``size`` is the size of ``text`` in ``unit`` and never exceeds ``limit``.
+    """
+
+    text: str
+    head: str
+    marker: str
+    tail: str
+    original: str
+    unit: Unit
+    limit: int
+    size: int
+
+    @property
+    def truncated(self) -> bool:
+        """True when part of the original was removed."""
+        return len(self.head) + len(self.tail) < len(self.original)
+
+    @property
+    def removed_span(self) -> tuple[int, int]:
+        """``(start, stop)`` code point indices of the removed part of ``original``."""
+        return len(self.head), len(self.original) - len(self.tail)
+
+    @property
+    def removed(self) -> str:
+        """The part of ``original`` that the marker replaces (empty when it fit)."""
+        start, stop = self.removed_span
+        return self.original[start:stop]
+
+    def __str__(self) -> str:
+        return self.text
+
+
+def _check(text: str, limit: int, where: str, marker: str) -> None:
+    if not isinstance(text, str):
+        raise TypeError(f"text must be str, not {type(text).__name__}")
+    if not isinstance(marker, str):
+        raise TypeError(f"marker must be str, not {type(marker).__name__}")
+    if isinstance(limit, bool) or not isinstance(limit, int):
+        raise TypeError(f"limit must be int, not {type(limit).__name__}")
+    if where not in ("start", "middle", "end"):
+        raise ValueError(f"where must be 'start', 'middle' or 'end', not {where!r}")
+    if limit < 0:
+        raise ValueError(f"limit must be non-negative, not {limit}")
+
+
+def truncate(
+    text: str,
+    limit: int,
+    *,
+    where: Where = "end",
+    unit: Unit = "chars",
+    marker: str = "...",
+    words: bool = False,
+    ambiguous: int = 1,
+) -> Truncation:
+    """Shorten ``text`` to at most ``limit`` and report exactly what happened.
+
+    ``where`` puts the marker at the ``"end"`` (like CSS ``text-overflow: ellipsis``),
+    the ``"start"`` (keep the tail, for ids and log lines) or the ``"middle"`` (keep
+    both ends, for paths and hashes). ``unit`` is what ``limit`` counts: ``"chars"``
+    (code points), ``"graphemes"``, ``"columns"`` (terminal cells) or ``"bytes"``
+    (UTF-8); see ``measure``. The marker is measured in the same unit and counted inside
+    the limit. The cut always falls on an extended grapheme cluster boundary (UAX #29),
+    so accents, flags and emoji ZWJ sequences are kept whole or dropped whole.
+
+    ``words=True`` moves each cut to whitespace and trims the whitespace next to the
+    marker, unless a single word fills the budget, in which case the cut stays hard.
+    Tabs and other controls are zero columns; expand tabs first if they matter.
+    ``ambiguous`` (1 or 2) is the width of East Asian Ambiguous characters in columns.
+
+    Text that already fits is returned whole. A marker larger than ``limit``, a negative
+    limit or an unknown ``where`` or ``unit`` raises ``ValueError``.
+
+    >>> truncate("hello world", 8).text
+    'hello...'
+    >>> r = truncate("hello brave new world", 15, marker=ELLIPSIS, words=True)
+    >>> r.text, r.removed
+    ('hello brave\u2026', ' new world')
+    >>> truncate("Espa\\U0001f1ea\\U0001f1f8a!", 7, unit="chars", marker="..").text
+    'Espa..'
+    """
+    _check(text, limit, where, marker)
+    unit = check_unit(unit)
+    ambiguous = check_ambiguous(ambiguous)
+    size = size_of(text, unit, ambiguous)
+    if size <= limit:
+        return Truncation(text, text, "", "", text, unit, limit, size)
+    marker_size = size_of(marker, unit, ambiguous)
+    if marker_size > limit:
+        raise ValueError(f"marker of size {marker_size} does not fit in limit {limit} ({unit})")
+    # Cluster boundaries depend only on what precedes them, so an end cut counted in
+    # chars or bytes (every cluster at least 1) only needs the first limit + 1 code points.
+    window = text[: limit + 1] if where == "end" and unit in ("chars", "bytes") else text
+    parts = clusters(window)
+    sizes = [cluster_size(c, unit, ambiguous) for c in parts]
+    spaces = [c.isspace() for c in parts] if words else None
+    for budget in range(limit - marker_size, -1, -1):
+        left, right = cut(sizes, budget, where, spaces)
+        head, tail = "".join(parts[:left]), "".join(parts[right:])
+        result = head + marker + tail
+        # A marker that joins a neighbouring cluster can change its size; re-measure.
+        size = size_of(result, unit, ambiguous)
+        if size <= limit:
+            return Truncation(result, head, marker, tail, text, unit, limit, size)
+    return Truncation(marker, "", marker, "", text, unit, limit, marker_size)

ellipt/_cut.py

@@ -0,0 +1,83 @@
+"""Choose which grapheme clusters to keep on each side of the cut.
+
+Every function works on a list of cluster sizes and returns ``(left, right)``: keep the
+first ``left`` clusters and the clusters from index ``right`` onwards. ``left <= right``
+always holds, so the kept head and tail never overlap.
+"""
+
+from __future__ import annotations
+
+
+def _take_left(sizes: list[int], budget: int, start: int, stop: int) -> tuple[int, int]:
+    """Greedily extend a prefix from ``start`` up to ``stop``; return (end, used)."""
+    used = 0
+    end = start
+    while end < stop and used + sizes[end] <= budget:
+        used += sizes[end]
+        end += 1
+    return end, used
+
+
+def _take_right(sizes: list[int], budget: int, stop: int) -> tuple[int, int]:
+    """Greedily extend a suffix down to index ``stop``; return (start, used)."""
+    used = 0
+    start = len(sizes)
+    while start > stop and used + sizes[start - 1] <= budget:
+        used += sizes[start - 1]
+        start -= 1
+    return start, used
+
+
+def cut(
+    sizes: list[int], budget: int, where: str, spaces: list[bool] | None = None
+) -> tuple[int, int]:
+    """Return ``(left, right)`` keeping at most ``budget`` in total size.
+
+    With ``spaces`` (one flag per cluster: is it whitespace) every cut is moved to a word
+    boundary and the whitespace next to the marker is dropped. If a single word fills
+    the whole budget, the hard cut is used instead of returning nothing.
+    """
+    count = len(sizes)
+    if where == "end":
+        left = _take_left(sizes, budget, 0, count)[0]
+        return (snap_left(spaces, left, False) if spaces else left), count
+    if where == "start":
+        right = _take_right(sizes, budget, 0)[0]
+        return 0, (snap_right(spaces, right, False) if spaces else right)
+    left, used_left = _take_left(sizes, budget - budget // 2, 0, count)
+    if spaces:
+        left = snap_left(spaces, left, True)
+        used_left = sum(sizes[:left])
+    right, used_right = _take_right(sizes, budget - used_left, left)
+    if spaces:
+        right = snap_right(spaces, right, True)
+        used_right = sum(sizes[right:])
+    # A wide cluster or a word snap may have left budget unused: hand it back.
+    more, _ = _take_left(sizes, budget - used_left - used_right, left, right)
+    left = max(left, snap_left(spaces, more, True)) if spaces else more
+    if spaces and left == 0 and right == count:
+        return cut(sizes, budget, where)
+    return left, right
+
+
+def snap_left(spaces: list[bool], left: int, allow_empty: bool) -> int:
+    """Move a head end back to a word boundary and drop the whitespace before it."""
+    end = left
+    if left < len(spaces) and left > 0 and not spaces[left] and not spaces[left - 1]:
+        while end > 0 and not spaces[end - 1]:
+            end -= 1
+    while end > 0 and spaces[end - 1]:
+        end -= 1
+    return end if end > 0 or allow_empty else left
+
+
+def snap_right(spaces: list[bool], right: int, allow_empty: bool) -> int:
+    """Move a tail start forward to a word boundary and drop the whitespace after it."""
+    count = len(spaces)
+    start = right
+    if 0 < right < count and not spaces[right] and not spaces[right - 1]:
+        while start < count and not spaces[start]:
+            start += 1
+    while start < count and spaces[start]:
+        start += 1
+    return start if start < count or allow_empty else right

ellipt/_graphemes.py

@@ -0,0 +1,103 @@
+"""Extended grapheme cluster segmentation per UAX #29, using embedded UCD tables."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+
+from ._props import EXT_PICT_BIT, GCB, INCB_SHIFT, prop
+
+_CR = GCB["CR"]
+_LF = GCB["LF"]
+_CONTROL = GCB["Control"]
+_EXTEND = GCB["Extend"]
+_ZWJ = GCB["ZWJ"]
+_RI = GCB["Regional_Indicator"]
+_PREPEND = GCB["Prepend"]
+_SPACING = GCB["SpacingMark"]
+_L = GCB["L"]
+_V = GCB["V"]
+_T = GCB["T"]
+_LV = GCB["LV"]
+_LVT = GCB["LVT"]
+
+_BREAKERS = frozenset({_CR, _LF, _CONTROL})
+_AFTER_L = frozenset({_L, _V, _LV, _LVT})
+_AFTER_LV_V = frozenset({_V, _T})
+_AFTER_LVT_T = frozenset({_T})
+_INCB_LINKER = 1
+_INCB_CONSONANT = 2
+_INCB_EXTEND = 3
+
+
+def grapheme_ends(s: str) -> Iterator[int]:
+    """Yield the end index (exclusive) of every extended grapheme cluster in ``s``.
+
+    The last value yielded is ``len(s)``; nothing is yielded for the empty string.
+    """
+    if not s:
+        return
+    code = prop(ord(s[0]))
+    prev = code & 0x0F
+    ri_run = 1 if prev == _RI else 0
+    incb = (code >> INCB_SHIFT) & 0x03
+    after_linker = incb == _INCB_LINKER
+    emoji = 1 if code & EXT_PICT_BIT else 0  # 1: pictograph Extend*, 2: then ZWJ
+    for index in range(1, len(s)):
+        code = prop(ord(s[index]))
+        cur = code & 0x0F
+        incb = (code >> INCB_SHIFT) & 0x03
+        pict = code & EXT_PICT_BIT
+        if not _joins(prev, cur, incb, pict, after_linker, emoji, ri_run):
+            yield index
+        after_linker = incb == _INCB_LINKER or (after_linker and incb == _INCB_EXTEND)
+        if pict or (emoji == 1 and cur == _EXTEND):
+            emoji = 1
+        elif emoji == 1 and cur == _ZWJ:
+            emoji = 2
+        else:
+            emoji = 0
+        ri_run = ri_run + 1 if cur == _RI else 0
+        prev = cur
+    yield len(s)
+
+
+def _joins(
+    prev: int, cur: int, incb: int, pict: int, after_linker: bool, emoji: int, ri_run: int
+) -> bool:
+    """Return True when there is no boundary between ``prev`` and ``cur``."""
+    if prev == _CR and cur == _LF:  # GB3
+        return True
+    if prev in _BREAKERS or cur in _BREAKERS:  # GB4, GB5
+        return False
+    if prev == _L and cur in _AFTER_L:  # GB6
+        return True
+    if prev in (_LV, _V) and cur in _AFTER_LV_V:  # GB7
+        return True
+    if prev in (_LVT, _T) and cur in _AFTER_LVT_T:  # GB8
+        return True
+    if cur in (_EXTEND, _ZWJ, _SPACING) or prev == _PREPEND:  # GB9, GB9a, GB9b
+        return True
+    if incb == _INCB_CONSONANT and after_linker:  # GB9c
+        return True
+    if pict and prev == _ZWJ and emoji == 2:  # GB11
+        return True
+    return prev == _RI and cur == _RI and ri_run % 2 == 1  # GB12, GB13
+
+
+def iter_graphemes(s: str) -> Iterator[str]:
+    """Yield the extended grapheme clusters of ``s`` (UAX #29), left to right.
+
+    A grapheme cluster is what a reader perceives as one character: a base letter with
+    its combining marks, a Hangul syllable built from jamo, an emoji ZWJ sequence, a
+    flag made of two regional indicators, an Indic conjunct, or a CR LF pair. The
+    clusters concatenate back to ``s`` exactly.
+
+    >>> [len(g) for g in iter_graphemes("e\\u0301\\U0001f1ea\\U0001f1f8")]
+    [2, 2]
+    """
+    if not isinstance(s, str):
+        raise TypeError(f"iter_graphemes expects str, not {type(s).__name__}")
+    start = 0
+    for end in grapheme_ends(s):
+        yield s[start:end]
+        start = end

ellipt/_measure.py

@@ -0,0 +1,69 @@
+"""Units of measure for a limit and the cluster sizes they assign."""
+
+from __future__ import annotations
+
+from typing import Literal
+
+from ._graphemes import grapheme_ends
+from ._width import check_ambiguous, cluster_width
+
+Unit = Literal["chars", "graphemes", "columns", "bytes"]
+UNITS: tuple[Unit, ...] = ("chars", "graphemes", "columns", "bytes")
+
+
+def check_unit(unit: str) -> Unit:
+    """Return ``unit`` after checking it names a supported unit."""
+    for known in UNITS:
+        if unit == known:
+            return known
+    raise ValueError(f"unit must be one of {', '.join(map(repr, UNITS))}, not {unit!r}")
+
+
+def clusters(text: str) -> list[str]:
+    """Split ``text`` into extended grapheme clusters (UAX #29)."""
+    found: list[str] = []
+    start = 0
+    for end in grapheme_ends(text):
+        found.append(text[start:end])
+        start = end
+    return found
+
+
+def cluster_size(cluster: str, unit: Unit, ambiguous: int) -> int:
+    """Size of one grapheme cluster in ``unit``."""
+    if unit == "chars":
+        return len(cluster)
+    if unit == "graphemes":
+        return 1
+    if unit == "columns":
+        return cluster_width(cluster, ambiguous)
+    return len(cluster.encode("utf-8", "surrogatepass"))
+
+
+def size_of(text: str, unit: Unit, ambiguous: int) -> int:
+    """Size of ``text`` in ``unit`` without validating the arguments."""
+    if unit == "chars":
+        return len(text)
+    if unit == "bytes":
+        return len(text.encode("utf-8", "surrogatepass"))
+    return sum(cluster_size(c, unit, ambiguous) for c in clusters(text))
+
+
+def measure(text: str, unit: Unit = "chars", *, ambiguous: int = 1) -> int:
+    """Return the size of ``text`` in ``unit``, the way ``truncate`` measures it.
+
+    ``"chars"`` counts code points (``len``), ``"graphemes"`` counts extended grapheme
+    clusters (UAX #29, what a reader sees as one character), ``"columns"`` counts
+    terminal display cells (UAX #11 East Asian Width, emoji sequences as one wide
+    glyph, East Asian Ambiguous characters as ``ambiguous`` cells) and ``"bytes"``
+    counts UTF-8 bytes.
+
+    >>> flag = "\\U0001f1ea\\U0001f1f8"
+    >>> [measure(flag, u) for u in ("chars", "graphemes", "columns", "bytes")]
+    [2, 1, 2, 8]
+    >>> measure("\\u2026", "bytes"), measure("...", "bytes")
+    (3, 3)
+    """
+    if not isinstance(text, str):
+        raise TypeError(f"text must be str, not {type(text).__name__}")
+    return size_of(text, check_unit(unit), check_ambiguous(ambiguous))

ellipt/_path.py

@@ -0,0 +1,90 @@
+"""Middle truncation of file system paths that keeps the root and the file name."""
+
+from __future__ import annotations
+
+from ._core import truncate
+from ._graphemes import grapheme_ends
+from ._measure import Unit, check_unit, size_of
+from ._width import check_ambiguous
+
+
+def _separators(path: str, sep: str | None) -> list[int]:
+    """Indices of separators that sit on grapheme cluster boundaries on both sides."""
+    chars = "/\\" if sep is None else sep
+    bounds = {0, *grapheme_ends(path)}
+    return [i for i, ch in enumerate(path) if ch in chars and i in bounds and i + 1 in bounds]
+
+
+def _shorten_name(name: str, limit: int, unit: Unit, marker: str, ambiguous: int) -> str:
+    """Shorten a file name in the middle of its stem, keeping the extension if it can."""
+    dot = name.rfind(".")
+    if name[:dot].lower().endswith(".tar"):  # keep .tar.gz, .tar.xz and friends together
+        dot -= 4
+    if 0 < dot < len(name) - 1 and dot in {0, *grapheme_ends(name)}:
+        stem, ext = name[:dot], name[dot:]
+        room = limit - size_of(ext, unit, ambiguous)
+        if room > size_of(marker, unit, ambiguous):
+            short = truncate(
+                stem, room, where="middle", unit=unit, marker=marker, ambiguous=ambiguous
+            )
+            candidate = short.text + ext
+            if size_of(candidate, unit, ambiguous) <= limit:
+                return candidate
+    return truncate(name, limit, where="middle", unit=unit, marker=marker, ambiguous=ambiguous).text
+
+
+def shorten_path(
+    path: str,
+    limit: int,
+    *,
+    unit: Unit = "chars",
+    marker: str = "...",
+    sep: str | None = None,
+    ambiguous: int = 1,
+) -> str:
+    r"""Shorten a path to at most ``limit`` by dropping whole directories from the middle.
+
+    The first component (``/``, ``C:\``, ``~/``, ``\\server\share\`` or a relative
+    top directory) and the file name are kept, and as many directories next to the file
+    name as fit, like the middle truncation of macOS Finder and editor tab titles. When
+    only ``marker/name`` fits the root goes too, and when even that is too long the file
+    name alone is shown, shortened in the middle of its stem with the extension (``.gz``
+    or a compound ``.tar.gz``) kept. ``sep`` is the
+    separator; by default both ``/`` and ``\`` count. ``unit``, ``marker`` and
+    ``ambiguous`` mean the same as in ``truncate``; an empty marker is rejected because
+    the result would read as a different, real path, and the result never exceeds
+    ``limit`` in ``unit``.
+
+    >>> shorten_path("/home/me/projects/app/src/main.py", 24)
+    '/.../app/src/main.py'
+    >>> shorten_path(r"C:\Users\me\Documents\report.pdf", 27)
+    'C:\\...\\Documents\\report.pdf'
+    >>> shorten_path("photos/2026/an_extremely_long_holiday_name.jpeg", 20)
+    'an_ext...y_name.jpeg'
+    """
+    if sep is not None and (not isinstance(sep, str) or len(sep) != 1):
+        raise ValueError(f"sep must be a single character, not {sep!r}")
+    if marker == "":
+        raise ValueError("marker must not be empty: the result would look like a real path")
+    result = truncate(path, limit, where="middle", unit=unit, marker=marker, ambiguous=ambiguous)
+    if not result.truncated:
+        return path
+    unit = check_unit(unit)
+    ambiguous = check_ambiguous(ambiguous)
+    stops = _separators(path.rstrip("/\\" if sep is None else sep), sep)
+    name_start = stops[-1] + 1 if stops else 0
+    # The root is the first component; a UNC or //host root also keeps host and share.
+    first = 3 if len(stops) > 4 and stops[:2] == [0, 1] else 0
+    candidates: list[str] = []
+    if len(stops) > first + 1:
+        head = path[: stops[first] + 1]
+        candidates += [head + marker + path[i:] for i in stops[first + 1 :] if i > stops[first] + 1]
+    if stops:
+        candidates.append(marker + path[name_start - 1 :])
+    for candidate in candidates:
+        if size_of(candidate, unit, ambiguous) <= limit:
+            return candidate
+    name = path[name_start:]
+    if size_of(name, unit, ambiguous) <= limit:
+        return name
+    return _shorten_name(name, limit, unit, marker, ambiguous)

ellipt/_props.py

@@ -0,0 +1,61 @@
+"""Lookup of the embedded Unicode properties: width class, grapheme and emoji data."""
+
+from __future__ import annotations
+
+from bisect import bisect_right
+
+from ._ucd_data import (
+    EMOJI_BIT,
+    EXT_PICT_BIT,
+    GCB_NAMES,
+    INCB_SHIFT,
+    MODIFIER_BIT,
+    RUNS,
+    UNICODE_VERSION,
+    WIDTH_SHIFT,
+)
+
+__all__ = [
+    "AMBIGUOUS",
+    "EMOJI_BIT",
+    "EXT_PICT_BIT",
+    "GCB",
+    "INCB_SHIFT",
+    "MODIFIER_BIT",
+    "UNICODE_VERSION",
+    "WIDTH_SHIFT",
+    "prop",
+]
+
+GCB = {name: index for index, name in enumerate(GCB_NAMES)}
+AMBIGUOUS = 3
+
+
+def _decode(runs: str) -> tuple[list[int], list[int]]:
+    """Expand the run tokens into parallel lists of run starts and property codes."""
+    starts: list[int] = []
+    codes: list[int] = []
+    position = 0
+    for token in runs.split():
+        starts.append(position)
+        codes.append(int(token[:3], 36))
+        position += int(token[3:], 36)
+    if position != 0x110000:
+        raise RuntimeError("embedded Unicode tables do not cover the code space")
+    return starts, codes
+
+
+_STARTS, _CODES = _decode(RUNS)
+_LATIN = tuple(_CODES[bisect_right(_STARTS, cp) - 1] for cp in range(0x300))
+
+
+def prop(cp: int) -> int:
+    """Return the packed property code of code point ``cp``.
+
+    Bits 0-3 hold Grapheme_Cluster_Break (an index into ``GCB_NAMES``), bit 4 is
+    Extended_Pictographic, bits 5-6 Indic_Conjunct_Break, bit 7 Emoji, bit 8
+    Emoji_Modifier and bits 9-10 the width class (0 zero, 1 narrow, 2 wide, 3 ambiguous).
+    """
+    if cp < 0x300:
+        return _LATIN[cp]
+    return _CODES[bisect_right(_STARTS, cp) - 1]

ellipt/_shorten.py

@@ -0,0 +1,46 @@
+"""Truncate strings with an ellipsis at the start, middle or end."""
+
+from __future__ import annotations
+
+from ._core import Where, truncate
+from ._measure import Unit
+
+__all__ = ["Where", "shorten"]
+
+
+def shorten(
+    text: str,
+    width: int,
+    *,
+    where: Where = "end",
+    marker: str = "...",
+    width_aware: bool = False,
+    unit: Unit | None = None,
+    words: bool = False,
+    ambiguous: int = 1,
+) -> str:
+    """Return text clipped to width, with marker marking where it was cut.
+
+    The result never exceeds width, measured in ``unit``: ``"chars"`` (code points, the
+    default), ``"graphemes"``, ``"columns"`` (display cells) or ``"bytes"`` (UTF-8).
+    ``width_aware=True`` is a shorthand for ``unit="columns"``. The marker counts inside
+    the width, and the cut never splits a grapheme cluster. ``words=True`` cuts at
+    whitespace when it can. Text that already fits is returned unchanged. A width that
+    cannot even hold the marker, or an unknown position or unit, raises ValueError.
+    Use ``truncate`` for a typed result that also says what was removed.
+
+    >>> shorten("hello world", 8)
+    'hello...'
+    >>> shorten("/var/log/app/service.log", 16, where="middle")
+    '/var/lo...ce.log'
+    >>> shorten("\\u5e7f\\u5e7f\\u5e7fx", 5, marker="..", width_aware=True)
+    '\u5e7f..'
+    """
+    if unit is None:
+        unit = "columns" if width_aware else "chars"
+    elif width_aware and unit != "columns":
+        raise ValueError(f"width_aware=True conflicts with unit={unit!r}")
+    result = truncate(
+        text, width, where=where, unit=unit, marker=marker, words=words, ambiguous=ambiguous
+    )
+    return result.text

ellipt/_ucd_data.py

@@ -0,0 +1,31 @@
+"""Index of the generated Unicode property data."""
+
+# Generated by scripts/gen_ucd_tables.py from data/ucd/. Do not edit.
+
+from __future__ import annotations
+
+from ._ucd_part1 import RUNS as _R0
+
+UNICODE_VERSION = "18.0.0"
+GCB_NAMES = (
+    "Other",
+    "CR",
+    "LF",
+    "Control",
+    "Extend",
+    "ZWJ",
+    "Regional_Indicator",
+    "Prepend",
+    "SpacingMark",
+    "L",
+    "V",
+    "T",
+    "LV",
+    "LVT",
+)
+EXT_PICT_BIT = 16
+INCB_SHIFT = 5
+EMOJI_BIT = 128
+MODIFIER_BIT = 256
+WIDTH_SHIFT = 9
+RUNS = _R0

ellipt/_ucd_part1.py

@@ -0,0 +1,166 @@
+"""Run-length property data, part 1."""
+
+# Generated by scripts/gen_ucd_tables.py from data/ucd/. Do not edit.
+
+RUNS = (
+    "003a 0021 0032 0011 003i 0e83 0hs1 0e86 0hs1 0e85 0hsa 0e81x 003x 0e81 16o1 0e82 16o1 "
+    "0e82 16o2 0i81 16o1 0e82 16r1 1ao1 0e81 16o5 0e81 16o5 0e81 16o4 0e86 16o1 0e89 16o1 "
+    "0e86 16o2 0e85 16o4 0e84 16o1 0e81 16o3 0e81 16o2 0e82 16o1 0e81 16o2 0e83 16o4 0e81 "
+    "16o1 0e81 16o1 0e82 16o1 0e8f 16o1 0e81 16o1 0e87 16o1 0e8a 16o2 0e83 16o1 0e85 16o3 "
+    "0e84 16o1 0e86 16o4 0e81 16o1 0e83 16o4 0e81 16o1 0e84 16o2 0e8i 16o2 0e83 16o1 0e82q "
+    "16o1 0e81 16o1 0e81 16o1 0e81 16o1 0e81 16o1 0e81 16o1 0e81 16o1 0e81 16o1 0e838 16o1 "
+    "0e8f 16o1 0e82q 16o1 0e82 16o1 0e81 16o3 0e81 16o1 0e82 16o1 0e87 16o4 0e81 16o1 0e81 "
+    "16o1 0e8w 02s34 0e8x 16oh 0e81 16o7 0e87 16oh 0e81 16o7 0e81j 16o1 0e8e 16o1s 0e81 16o1 "
+    "0e81d 02s7 0e87b 02s19 0e81 02s1 0e81 02s2 0e81 02s2 0e81 02s3 0e81i 0076 0e8a 02sb "
+    "0e81 0031 0e81a 02sl 0e8g 02s1 0e82t 02s7 0071 0e81 02s6 0e82 02s2 0e81 02s4 0e8x 0071 "
+    "0e81 02s1 0e8u 02sr 0e82j 02sb 0e81m 02s9 0e89 02s1 0e8o 02s4 0e81 02s9 0e81 02s3 0e81 "
+    "02s5 0e817 02s3 0e81g 0072 0e85 02s9 0e816 02so 0071 02sw 0eg1 0e8h 0g011 02s1 0eg1 "
+    "02s1 0e81 0eg3 02s8 0eg4 0101 0eg2 0e81 02s7 0g08 0e82 02s2 0e8k 0g08 0e81 02s1 0eg2 "
+    "0e8h 0g0k 0e81 0g07 0e81 0g01 0e83 0g04 0e82 02s1 0e81 0h01 0eg2 02s4 0e82 0eg2 0e82 "
+    "0eg2 0101 0e89 0h01 0e84 0g02 0e81 0g01 0e82 02s2 0e8c 0g02 0e8c 02s1 0e82 02s2 0eg1 "
+    "0e81k 02s1 0e81 0eg3 02s2 0e84 02s2 0e82 02s3 0e83 02s1 0e8u 02s2 0e83 02s1 0e8b 02s2 "
+    "0eg1 0e8h 0g0k 0e81 0g07 0e81 0g02 0e81 0g05 0e82 02s1 0e81 0eg3 02s5 0e81 02s2 0eg1 "
+    "0e81 0eg2 0101 0e8k 02s2 0e8l 0g01 02s6 0e81 02s1 0eg2 0e8h 0g0k 0e81 0g07 0e81 0g02 "
+    "0e81 0g05 0e82 02s1 0e81 0h01 02s1 0eg1 02s4 0e82 0eg2 0e82 0eg2 0101 0e85 02s4 0h01 "
+    "0e84 0g02 0e81 0g01 0e82 02s2 0e8d 0g01 0e8g 02s1 0e81n 0h01 0eg1 02s1 0eg2 0e83 0eg3 "
+    "0e81 0eg3 02s1 0e89 0h01 0e814 02s1 0eg3 02s1 0e8g 0g0k 0e81 0g0g 0e82 02s1 0e81 02s3 "
+    "0eg4 0e81 02s3 0e81 02s3 0101 0e87 02s2 0e81 0g03 0e87 02s2 0e8t 02s1 0eg2 0e81k 02s1 "
+    "0e81 0eg1 02s1 0h01 0eg1 0h01 0eg2 0e81 02s1 0h02 0e81 0h02 02s2 0e87 0h02 0e8b 02s2 "
+    "0e8f 0eg1 0e8c 02s2 0eg2 0e8h 0g012 02s2 0e81 0h01 0eg2 02s4 0e81 0eg3 0e81 0eg3 0101 "
+    "0ef1 0e88 0h01 0e8a 02s2 0e8t 02s1 0eg2 0e81y 02s1 0e84 0h01 0eg2 02s3 0e81 02s1 0e81 "
+    "0eg7 0h01 0e8i 0eg2 0e81p 02s1 0e81 0eg1 02s7 0e8c 02s8 0e82q 02s1 0e81 0eg1 02s9 0e8b "
+    "02s7 0e821 02s2 0e8r 02s1 0e81 02s1 0e81 02s1 0e84 0eg2 0e81d 02se 0eg1 02s5 0e81 02s2 "
+    "0e85 02sb 0e81 02s10 0e89 02s1 0e81l 0g017 0e82 02s4 0eg1 02s6 0e81 0101 02s1 0eg2 02s2 "
+    "0g01 0e8g 0g06 0eg2 02s2 0g04 02s3 0g01 0e83 0g02 0e87 0g03 02s4 0g0d 02s1 0e81 0eg1 "
+    "02s2 0e86 02s1 0g01 0e8e 02s1 0e82q 0sp2o 00a20 00b2g 0e89p 02s3 0e8qa 02s3 0h01 0e8s "
+    "02s2 0h01 0e8t 02s2 0e8u 02s2 0e8c 0g01g 02s2 0eg1 02s7 0eg8 02s1 0eg2 02s9 0101 02s1 "
+    "0e89 02s1 0e819 02s3 0031 02s1 0e839 02s2 0e8y 02s1 0e83a 02s3 0eg4 02s2 0eg3 0e84 0eg2 "
+    "02s1 0eg6 02s3 0e863 02s2 0eg2 02s1 0e84 0g01h 0eg1 02s1 0eg1 02s7 0e81 0101 0e81 02s1 "
+    "0e82 02s8 0eg6 02sa 0e82 02s1 0e81c 02s1t 0e8f 02s4 0eg1 0e86 0g02 0e86 0g0x 02s1 0h01 "
+    "02s5 0h01 02s1 0h01 0eg4 02s1 0h01 0f81 0g08 0e8u 02s9 0e8c 02s2 0eg1 0g0u 0eg1 02s4 "
+    "0eg2 02s2 0h01 0101 02s2 0g02 0e8b 0g03 0e814 02s1 0eg1 02s2 0eg3 02s1 0eg1 02s3 0h02 "
+    "0e81c 0eg8 02s8 0eg2 02s2 0e848 02s3 0e81 02sd 0eg1 02s7 0e84 02s1 0e86 02s1 0f42 0eg1 "
+    "02s2 0e85i 02s1s 0e8ej 0031 0041 02t1 0032 16o1 0e82 16o4 0e81 16o2 0e82 16o2 0e82 16o3 "
+    "0e81 16o4 0eb2 0035 0e81 16o1 0e81 16o2 0e81 16o1 0e85 16o1 0i81 0e81 16o1 0e8a 0i81 "
+    "0e8m 0035 0eb1 003a 0e84 16o1 0e8a 16o1 0e81 16o4 0e813 16o1 0e8z 02sx 0e8i 16o1 0e81 "
+    "16o1 0e83 16o1 0e89 16o1 0e82 16o1 0e8a 16o1 1ao1 0e83 16o1 0e84 16o1 0e8d 0i81 0e8p "
+    "16o2 0e86 16o4 0e81 16oc 0e84 16oa 0e8f 16o1 0e86 16o4 1ao6 0e8f 0i82 0e8d 16o2 0e8o "
+    "16o1 0e81 16o1 0e8i 16o1 0e8o 16o1 0e81 16o2 0e83 16o2 0e82 16o1 0e83 16o1 0e81 16o1 "
+    "0e83 16o1 0e84 16o1 0e82 16o4 0e82 16o1 0e81 16o1 0e81 16o6 0e81 16o1 0e85 16o4 0e84 "
+    "16o2 0e8a 16o1 0e83 16o1 0e85 16o1 0e8d 16o2 0e82 16o4 0e82 16o2 0e82 16o2 0e8i 16o2 "
+    "0e82 16o2 0e8d 16o1 0e83 16o1 0e8b 16o1 0e8p 16o1 0e82a 16o1 0e87 0wg2 0e8c 0i81 0sg2 "
+    "0e84k 0i81 0e8p 0wg4 0i83 0wg1 0i82 0wg1 0e84 0i83 0e82t 16o2q 1ao1 16o13 0e81 16o2p "
+    "0e84 16o10 0e8c 16og 0e82 16o4 0e8a 16o2 0e81 16o7 0i82 0e86 16o2 0e82 1ao1 16o1 0e84 "
+    "16o2 0e82 1ao1 16o1 0e84 16o3 0e82 16o1 0e82 16o4 0e8g 16o4 0e89 16o1 0e8b 0i82 0wg2 "
+    "0e81 0i85 16o2 0e82 16o1 0e84 1ao1 16o1 0e81 0i81 0e82 0wg2 0e82 0i81 0e83 16o1 0i81 "
+    "16o1 0e81 0i81 0e81 0i82 0e82 0i81 0e83 0i81 0e83 0i82 0sg8 0i83 0e85 1ao1 0e81 1ao1 "
+    "0e85 0wgc 0e8b 0i81 1ao1 16o1 0e81 1ao1 16o1 1ao1 0i81 16o1 1ao1 16o2 0e81 16o2 0e81 "
+    "16o1 0e8b 0i81 0e82 0i81 0wg1 0e8a 0sg6 0e82 0i81 0wg1 0i84 0e81 0i81 0e81 0i82 0e81 "
+    "16o2 0i81 0wg1 0e85 0i81 0e82 0wg2 0e84 0i82 0e8b 0wg2 16o1 0e84 0wg2 16o2 1ao1 16o5 "
+    "0wg1 1ao1 16o1 1ao1 16o1 1ao1 0wg1 16od 0e81 16o1 0e84 16o1 1ao1 0wg1 16o5 1ao2 0wg2 "
+    "1ao1 0wg1 16o1 1ao3 0wg1 16o2 0wg1 16o2 0e82 0i81 0e82 0wg1 0e82 0i82 0wg2 0i82 0e81 "
+    "0i81 0e82 0i81 0e81 0i81 0e81 0i81 0e86 0i81 0e83 0i81 0e86 0wg1 0e8a 0i82 0e88 16o1 "
+    "0e86 0i81 0e82 0i81 0e84 0wg1 0e81 0wg1 0e84 0wg3 0e81 0wg1 0e8b 0i82 0e8h 16oa 0e8l "
+    "0wg3 0e89 0i81 0e8e 0wg1 0e8e 0wg1 0e8ac 0i82 0e8cv 0i83 0e8j 0wg2 0e81f 0wg1 0e84 0wg1 "
+    "16o4 0e8b9 02s3 0e83x 02s1 0e82o 02sw 0e83k 0sgq 0e81 0sg2h 0e8c 0sg5y 0e8q 0sg1m 02s4 "
+    "0v82 0wg1 0sgc 0wg1 0sg1 0e82 0sg2e 0e82 02s2 0sg2t 0e85 0sg17 0e81 0sg2m 0e81 0sg2e "
+    "0e89 0sg1c 0e81 0sg14 16o8 0sg1z 0wg1 0sg1 0wg1 0sgmib 0e83 0sg1j 0e8bs 02s4 0e81 02sa "
+    "0e8w 02s2 0e828 02s2 0e87k 02s1 0e83 02s1 0e84 02s1 0e8n 0eg2 02s2 0eg1 0e84 02s1 0e82b "
+    "0eg2 0e81e 0egg 02s2 0e8q 02si 0e8d 02s1 0e812 02s8 0e8p 02sb 0eg1 0h01 0e8c 0spt 0e83 "
+    "02s3 0eg1 0e85 0g03 0e83 0g010 02s1 0eg2 02s4 0eg2 02s2 0eg2 0f81 0e8v 0g05 02s1 0e81 "
+    "0g09 0e8a 0g05 0e816 02s6 0eg2 02s2 0eg2 02s2 0e8c 02s1 0e88 02s1 0eg1 0e8i 0g0g 0e81 "
+    "0g03 0e86 0g01 0e81 02s1 0e81 0g02 0e81c 02s1 0e81 02s3 0e82 02s2 0e85 02s2 0e81 02s1 "
+    "0e8u 0g0b 0eg1 02s2 0eg2 0e85 0eg1 0101 0e85l 0g0r 0e88 0eg2 02s1 0eg2 02s1 0eg2 0e81 "
+    "0eg1 02s1 0e8i 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str "
+    "0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 "
+    "0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str "
+    "0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 "
+    "0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str "
+    "0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 "
+    "0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str "
+    "0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 "
+    "0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str "
+    "0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 "
+    "0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str "
+    "0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 "
+    "0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str "
+    "0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 "
+    "0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str "
+    "0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 "
+    "0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str "
+    "0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 "
+    "0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str "
+    "0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 "
+    "0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str "
+    "0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 "
+    "0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str "
+    "0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 "
+    "0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str "
+    "0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 "
+    "0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str "
+    "0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 "
+    "0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str "
+    "0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 "
+    "0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str "
+    "0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 "
+    "0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str "
+    "0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 "
+    "0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str "
+    "0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 "
+    "0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str "
+    "0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 "
+    "0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str "
+    "0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 "
+    "0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str "
+    "0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 "
+    "0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str "
+    "0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 "
+    "0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str "
+    "0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 "
+    "0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str 0ss1 0str "
+    "0ss1 0str 0e8c 00an 0004 00b1d 0004 0e81kw 16o4xs 0sge8 0e8u 02s1 0e8kh 02sg 0sga 0e86 "
+    "02sg 0sgz 0e81 0sgj 0e81 0sg4 0e843 0031 0e81 0sg2o 0e81p 0h02 0e81s 0sg7 0e89 0eb9 "
+    "0033 0e81 16o1 0e8e7 02s1 0e86a 02s1 0e845 02s5 0e81ad 0g01 02s3 0e81 02s2 0e85 02s4 "
+    "0g04 0e81 0g03 0e81 0g0t 0e82 02s3 0e84 0101 0e84l 02s2 0e8fx 02s4 0e81t 02s5 0e88t "
+    "02s2 0e8u 02s5 0e8w 02sg 0e81y 02sb 0e81d 02s4 0e83e 0eg1 02s1 0eg1 0e81h 02sf 0e815 "
+    "02s1 0e82 02s2 0e8a 02s3 0eg1 0e819 0eg3 02s4 0eg2 02s2 0e82 0071 0e84 02s1 0e8a 0071 "
+    "0e81e 02s3 0g010 02s5 0eg1 02s6 0101 02s1 0e8f 0g01 0eg2 0g01 0e817 02s1 0e8c 02s2 0eg1 "
+    "0e81c 0eg3 02s9 0eg1 0h01 0e81 0ef2 0e85 02s4 0e81 0eg1 02s1 0e82k 0eg3 02s3 0eg2 02s1 "
+    "0h01 02s2 0e86 02s1 0e82 02s1 0e84d 02s1 0eg3 02s8 0e8l 02s2 0eg2 0e81j 02s2 0e81 0h01 "
+    "0eg1 02s1 0eg4 0e82 0eg2 0e82 0eg2 0h01 0e89 0h01 0e8a 0eg2 0e82 02s7 0e83 02s5 0e8b "
+    "0g0a 0e81 0g01 0e82 0g01 0e81 0g012 0e82 0h01 0eg2 02s6 0e81 0h01 0e82 0h01 0e81 0h03 "
+    "0eg1 0e81 0eg2 02s1 0h01 0101 0ef1 02s1 0e8e 02s2 0e82a 0eg3 02s8 0eg2 02s3 0eg1 02s1 "
+    "0e8n 02s1 0e829 0h01 0eg2 02s6 0eg1 02s1 0eg2 0h01 0eg1 02s2 0eg1 02s2 0e86j 0h01 0eg2 "
+    "02s4 0e82 0eg4 02s2 0eg1 02s2 0e8r 02s2 0e82a 0eg3 02s8 0eg2 02s1 0eg1 02s2 0e82y 02s1 "
+    "0eg1 02s1 0eg2 02s6 0h01 02s1 0e82t 02s1 0eg1 02s1 0e82 02s4 0eg1 02s5 0e874 0eg3 02s9 "
+    "0eg1 02s2 0e85h 0g07 0e82 0g01 0e82 0g08 0e81 0g02 0e81 0g0o 0h01 0eg5 0e81 0eg2 0e82 "
+    "02s2 0h01 0101 0ef1 0eg1 0ef1 0eg1 02s1 0e83x 0eg3 02s4 0e82 02s2 0eg4 02s1 0e83 0eg1 "
+    "0e8r 0g01 02sa 0g014 02s6 0eg1 0f41 02s4 0e88 0101 0e88 0g01 02s6 0eg2 02s3 0g014 0ef6 "
+    "02sd 0eg1 02s1 0101 0e834 0g01 0e82d 02s1 0eg1 02s3 0eg1 02s1 0eg1 0e85j 0eg1 02s7 0e81 "
+    "02s6 0eg1 02s1 0e82a 02sm 0e81 0eg1 02s7 0eg1 02s2 0eg1 02s2 0e83e 02s6 0e83 02s1 0e81 "
+    "02s2 0e81 02s7 0ef1 02s1 0e81u 0eg5 0e81 02s2 0e81 0eg2 02s1 0eg1 02s1 0e82g 02s1 0g01 "
+    "0e875 02s2 0eg2 0e89 02s2 0ef1 0eg1 0g0d 0e81 0g0y 0eg2 02s5 0e83 0eg2 02s1 0h01 0101 "
+    "0e8n 02s1 0e8445 003g 02s1 0e86 02sf 0e88ug 02sc 0eg3 02s3 0e81xc 02s5 0e81n 02s7 0e8fg "
+    "0ei1 0e83 0ei4 0e8dg 02s1 0e81 0eg1j 0e87 02s4 0e825 0sg4 02s1 0e8b 0v82 0sg5 0e89 "
+    "0sg5p7 0e810 0sgy 0e82n 0sg37 0e8d 0sgpe 0e8e 0sg1f 0e85y5 0sg4 0e81 0sg7 0e81 0sg2 "
+    "0e81 0sg89 0e89 0sg1 0e8t 0sg3 0e82 0sg1 0e8e 0sg5 0e87 0sgb0 0e81wh 02s2 0e81 0034 "
+    "0e83mk 02s1a 0e82 02sn 0e8dc 02s2 0e81o 0h02 02s3 0e83 0h06 0038 02s8 0e82 02s7 0e8u "
+    "02s4 0e844 02s3 0e8b 0h03 0e88 02s2 0e82 0h01 0e8w 0h02 0e83i 0sg2f 0e89 0sgn 0e81ah "
+    "02s1j 0e84 02s1e 0e88 02s1 0e8e 02s1 0e8m 02s5 0e81 02sf 0e811s 02s7 0e81 02sh 0e82 "
+    "02s7 0e81 02s2 0e81 02s5 0e82s 02s1 0e84g 02s7 0e8af 02s1 0e81p 02s4 0e8e4 02s4 0e872 "
+    "02s2 0e86r 02s1 0e82 02s1 0e87 02s2 0e85 02s1 0e8d6 02s7 0e831 02s7 0e81bt 0wg1 0e813 "
+    "0eo4 0e82s 0eoc 0e8f 0eo2 0e8f 0eo1 0e8e 0wg1 0eo1 0e811 0eoa 16ob 0e85 16ou 0e82 16o1m "
+    "0e86 1ao2 16oc 1ao2 16oe 0wg1 16o2 0wga 16oi 0e81 0sg1 0eo1j 0hyq 0sg1 0wg2 0eod 0sga "
+    "0wg1 0sgk 0wg1 0sg2 0wg9 0sg1 0eo4 0sg9 0eo7 0wg2 0eoe 0sg6 0eo4a 0wgx 0i81 0e82 0i89 "
+    "0wg9 0i81 0wg1y 0i81 0wgm 0e82 0i82 0e81 0i83 0e82 0i82 0wg17 0i84 0wg5 0i8c 0wgh 0e82 "
+    "0i81 0wg1 0i81 0e81 0i81 0wg3 15w5 0wg1r 0i81 0wg1 0i81 0wg57 0i81 0e81 0wg1r 0e8b 0i82 "
+    "0wg4 0e81 0wgo 0e87 0i82 0e82 0i87 0wg1 0e8c 0i81 0e82 0i84 0e82 0i81 0e84 0wg2 0e8d "
+    "0wg1 0i81 0e82 0i81 0e88 0i82 0e89 0i81 0e85 0i83 0e8c 0i83 0e88 0i83 0e82 0i81 0e81 "
+    "0i81 0e84 0i81 0e86 0i81 0e83 0i81 0e86 0i81 0wg2d 0e81c 0wg1y 0e85 0i81 0wg1 0i83 0wg3 "
+    "0e82 0wg5 0eo2 0wg4 0i86 0e83 0i81 0e81 0wg2 0eo3 0i81 0e82 0i81 0wg9 0eo3 0e862 0sg1 "
+    "0e81 0eo4 0wgc 0eo4 0wg1 0e8r 0eo4 0e81k 0eo8 0e8a 0eo6 0e814 0eo8 0e8u 0eo2 0e8c 0eo4 "
+    "0e82 0eoe 0e89 0eo13 0e8c 0wg1b 0e81 0wga 0e81 0wg55 0e82g 0eo8 0e8e 0eo2 0wgd 0eo3 "
+    "0wg1z 0eo1 0wg1 0eo3 0wgi 0eo1 0wgd 0eo3 0wgc 0eo5 0e874 0eose 0e82 0sg1eke 0e82 "
+    "0sg1eke 0e8e1oi 0eb1 0031 0ebu 02s2o 0eb3k 02s6o 0eb2s0 0e81beo 16o1eke 0e82 16o1eke "
+    "0e82 "
+)

ellipt/_width.py

@@ -0,0 +1,50 @@
+"""Display width (UAX #11 East Asian Width plus emoji presentation) of clusters and text."""
+
+from __future__ import annotations
+
+from ._props import AMBIGUOUS, EMOJI_BIT, EXT_PICT_BIT, GCB, MODIFIER_BIT, WIDTH_SHIFT, prop
+
+_RI = GCB["Regional_Indicator"]
+_VS15 = "\ufe0e"
+_VS16 = "\ufe0f"
+_ZWJ = "\u200d"
+_TAGS = range(0xE0020, 0xE0080)
+
+
+def check_ambiguous(ambiguous: int) -> int:
+    """Return ``ambiguous`` after checking it is 1 or 2."""
+    if isinstance(ambiguous, bool) or ambiguous not in (1, 2):
+        raise ValueError(f"ambiguous must be 1 or 2, not {ambiguous!r}")
+    return ambiguous
+
+
+def _code_width(code: int, ambiguous: int) -> int:
+    width = code >> WIDTH_SHIFT
+    return ambiguous if width == AMBIGUOUS else width
+
+
+def cluster_width(cluster: str, ambiguous: int = 1) -> int:
+    """Return the display width of one extended grapheme cluster.
+
+    Emoji sequences draw as one glyph: an emoji with VS16, a skin tone modifier, a ZWJ
+    sequence, a tag sequence or a regional indicator pair (a flag) is two cells and an
+    emoji with VS15 is one. Any other cluster is the sum of its code points.
+    """
+    code = prop(ord(cluster[0]))
+    if len(cluster) == 1:
+        return _code_width(code, ambiguous)
+    rest = cluster[1:]
+    if code & EMOJI_BIT and not code & MODIFIER_BIT:
+        if _VS15 in rest:
+            return 1
+        if _VS16 in rest:
+            return 2
+    if (
+        code & (EMOJI_BIT | EXT_PICT_BIT)
+        and not code & MODIFIER_BIT
+        and (_ZWJ in rest or any(prop(ord(ch)) & MODIFIER_BIT or ord(ch) in _TAGS for ch in rest))
+    ):
+        return 2
+    if code & 0x0F == _RI and prop(ord(rest[0])) & 0x0F == _RI:
+        return 2
+    return sum(_code_width(prop(ord(ch)), ambiguous) for ch in cluster)

ellipt-0.2.1.dist-info/METADATA

@@ -0,0 +1,134 @@
+Metadata-Version: 2.5
+Name: ellipt
+Version: 0.2.1
+Summary: Truncate strings with an ellipsis at the start, middle or end, by characters, grapheme clusters, display columns or UTF-8 bytes, without splitting emoji or accents
+Project-URL: Homepage, https://lianes8studio.com
+Project-URL: Repository, https://github.com/JaviLianes8/ellipt
+Project-URL: Issues, https://github.com/JaviLianes8/ellipt/issues
+Project-URL: Changelog, https://github.com/JaviLianes8/ellipt/blob/main/CHANGELOG.md
+Project-URL: LinkedIn, https://www.linkedin.com/in/jlianes/
+Project-URL: Funding, https://buymeacoffee.com/jlianesglrs
+Author-email: Javier Lianes <javier@lianes8studio.com>
+License-Expression: MIT
+License-File: LICENSE
+License-File: LICENSE-UNICODE
+Keywords: cli,display-width,ellipsis,grapheme,path,shorten,string,truncate,unicode
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Text Processing
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: twine; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# ellipt
+
+Truncate strings with an ellipsis at the start, middle or end. The limit can count code
+points, grapheme clusters, terminal columns or UTF-8 bytes, the marker is counted inside
+the limit, and the cut never splits an accent, a flag or an emoji sequence. Typed, zero
+dependencies, Unicode 18.0.0 tables embedded.
+
+## Install
+
+```
+pip install ellipt
+```
+
+## Usage
+
+```python
+from ellipt import ELLIPSIS, measure, shorten, shorten_path, truncate
+
+shorten("hello world", 8)  # -> 'hello...'
+shorten("hello world", 8, where="start")  # -> '...world'
+shorten("hello world", 9, where="middle")  # -> 'hel...rld'
+shorten("hello world", 6, marker=ELLIPSIS)  # -> 'hello…'
+
+# Text that already fits is returned unchanged.
+shorten("short", 20)  # -> 'short'
+```
+
+### Pick the unit of the limit
+
+```python
+family = "\U0001f468\u200d\U0001f469\u200d\U0001f467"  # one emoji, five code points
+text = "ab" + family + "cd"
+
+measure(text, "chars")  # -> 9
+measure(text, "graphemes")  # -> 5
+measure(text, "columns")  # -> 6
+measure(text, "bytes")  # -> 22
+
+# The family is kept whole or dropped whole, never cut into pieces.
+shorten(text, 6, marker=ELLIPSIS)  # -> 'ab…'
+shorten(text, 4, unit="graphemes", marker=ELLIPSIS)  # -> 'ab👨\u200d👩\u200d👧…'
+shorten("你好世界", 5, unit="columns", marker=ELLIPSIS)  # -> '你好…'
+shorten("café crème", 8, unit="bytes", marker="")  # -> 'café cr'
+```
+
+`width_aware=True` from 0.1.0 still works and means `unit="columns"`.
+
+### Know what was removed
+
+```python
+r = truncate("The quick brown fox jumps", 14, words=True, marker=ELLIPSIS)
+r.text  # -> 'The quick…'
+r.removed  # -> ' brown fox jumps'
+r.truncated  # -> True
+r.size <= r.limit  # -> True
+```
+
+`words=True` backs the cut off to whitespace; with one long word it cuts hard instead.
+
+### Shorten paths the way file browsers do
+
+```python
+shorten_path("/home/me/projects/app/src/main.py", 20)  # -> '/.../app/src/main.py'
+shorten_path("/home/me/projects/app/src/main.py", 11)  # -> '.../main.py'
+shorten_path("photos/an_extremely_long_holiday_name.jpeg", 20)  # -> 'an_ext...y_name.jpeg'
+```
+
+## Command line
+
+```
+$ printf 'hello world\n' | ellipt 8
+hello...
+$ git ls-files | ellipt 28 --path
+$ ellipt 30 --where middle --ellipsis notes.txt
+$ ellipt 255 --unit bytes --marker "" < titles.txt
+```
+
+The command reads standard input (or the files given) as UTF-8, keeps each LF or CRLF
+line ending, and counts terminal columns by default, expanding tabs to 8-column stops
+first (`--tabsize`). `--ellipsis` uses U+2026 as the marker without having to type it.
+`ellipt --help` lists every option. Errors go to standard error with exit status 1, and
+a reader that stops early (`| head`) is not an error.
+
+## Why
+
+`textwrap.shorten` only cuts at the end, collapses whitespace and always cuts on words.
+Plain slicing (`s[:n] + "..."`) splits emoji and accents, overflows a terminal with wide
+characters and can exceed a byte limit. `ellipt` cuts where you ask, in the unit you
+need, and guarantees the result is never longer than the limit. See [GUIDE.md](GUIDE.md)
+for the exact rules, the Unicode sources and the edge cases.
+
+## License
+
+MIT. See [LICENSE](LICENSE). The embedded Unicode data is covered by the Unicode
+License v3, see [LICENSE-UNICODE](LICENSE-UNICODE).
+
+## Links
+
+- Website: https://lianes8studio.com
+- GitHub: https://github.com/JaviLianes8
+- LinkedIn: https://www.linkedin.com/in/jlianes/

ellipt-0.2.1.dist-info/RECORD

@@ -0,0 +1,20 @@
+ellipt/__init__.py,sha256=n7BOVntpg0yfH2JisRQjrUoQHe6XUb4OYXGwJCmXtkI,735
+ellipt/__main__.py,sha256=K2Z-jKrpRnWHwy828VLCc_qzA1AG_3dSyXHNsGkHiWg,124
+ellipt/_cli.py,sha256=ONO44Q0TYjOk2HV9uRi4Bv8kjNLyU71NDy4sJyqXVyc,6775
+ellipt/_core.py,sha256=eW16PucnoQAtWo9xoLuHJaVMs9Vf4vaEYpEuYV7oqJg,5284
+ellipt/_cut.py,sha256=WApqSK9HhiIIJ9bcr8_jyJDPNJuuj58AG_RKoGYdSEY,3362
+ellipt/_graphemes.py,sha256=ZQgxcpf3iOGwopjEflpX8SzZyECokjRvT-di45XzLWA,3409
+ellipt/_measure.py,sha256=hO376PMBXY1ae3FwmRyKCEgskoyVY69QvbxUhqpFYZo,2480
+ellipt/_path.py,sha256=oMH-Y8CgCGv8DJAHCZ6EDbsQMnqzfQaAMQDX3ceFeWQ,4126
+ellipt/_props.py,sha256=NrdqRp33hAv7Escf7APSSoWUb0ZEkWyRyNBAu3PkCEY,1604
+ellipt/_shorten.py,sha256=dQ-jOfbBnPVTvgPXNI3H4TC3dczDEtZo_soAa27jEis,1663
+ellipt/_ucd_data.py,sha256=dSWD1BP9fsV9zYR-fehbMt4WBzUQWTGLmEDLZGFBNi0,516
+ellipt/_ucd_part1.py,sha256=CpJg26U_HgS3_dMtQrBeRzZrgDNd58WZ8cvhE3BziYg,14858
+ellipt/_width.py,sha256=PPqlKtbm-TKD67WSnGXQMj_ydzv7-EmG2r7xCHtrros,1764
+ellipt/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ellipt-0.2.1.dist-info/METADATA,sha256=JHfIrRAIPVcd-9U9yoOmaF7St_sfeds8OhvIrGmi5Hs,4899
+ellipt-0.2.1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+ellipt-0.2.1.dist-info/entry_points.txt,sha256=10m7FYfoLaGt9SPlgisutoFwLOPLnK_BnsfSZW6QPm4,44
+ellipt-0.2.1.dist-info/licenses/LICENSE,sha256=_WmABlQG__oqlx4Rzp-qDJ10xND5KCLScftbhXbLC_c,1070
+ellipt-0.2.1.dist-info/licenses/LICENSE-UNICODE,sha256=56k7AJVlz85VkZo4FDesTbiD6dohJvoouR0ScyvFPZY,1995
+ellipt-0.2.1.dist-info/RECORD,,

ellipt-0.2.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

ellipt-0.2.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ellipt = ellipt._cli:main

ellipt-0.2.1.dist-info/licenses/LICENSE

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

ellipt-0.2.1.dist-info/licenses/LICENSE-UNICODE

@@ -0,0 +1,39 @@
+UNICODE LICENSE V3
+
+COPYRIGHT AND PERMISSION NOTICE
+
+Copyright © 1991-2026 Unicode, Inc.
+
+NOTICE TO USER: Carefully read the following legal agreement. BY
+DOWNLOADING, INSTALLING, COPYING OR OTHERWISE USING DATA FILES, AND/OR
+SOFTWARE, YOU UNEQUIVOCALLY ACCEPT, AND AGREE TO BE BOUND BY, ALL OF THE
+TERMS AND CONDITIONS OF THIS AGREEMENT. IF YOU DO NOT AGREE, DO NOT
+DOWNLOAD, INSTALL, COPY, DISTRIBUTE OR USE THE DATA FILES OR SOFTWARE.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of data files and any associated documentation (the "Data Files") or
+software and any associated documentation (the "Software") to deal in the
+Data Files or Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, and/or sell
+copies of the Data Files or Software, and to permit persons to whom the
+Data Files or Software are furnished to do so, provided that either (a)
+this copyright and permission notice appear with all copies of the Data
+Files or Software, or (b) this copyright and permission notice appear in
+associated Documentation.
+
+THE DATA FILES AND SOFTWARE ARE 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 OF
+THIRD PARTY RIGHTS.
+
+IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS NOTICE
+BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES,
+OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THE DATA
+FILES OR SOFTWARE.
+
+Except as contained in this notice, the name of a copyright holder shall
+not be used in advertising or otherwise to promote the sale, use or other
+dealings in these Data Files or Software without prior written
+authorization of the copyright holder.