python-color-math 0.1.0__py3-none-any.whl

color_math/utils/coloring.py

@@ -0,0 +1,61 @@
+# utils/coloring.py
+
+from ..config import (
+    COLORS,
+    BIG_OPERATORS,
+    INTEGRALS,
+    LIMIT_OPERATORS,
+    ARROWS,
+    SET_SYMBOLS,
+    SPACING_COMMANDS,
+    MULTIPLICATION_SYMBOLS,
+)
+
+
+def latex_color(color: str, value: str) -> str:
+    """
+    Wrap LaTeX text in a color command.
+
+    Example:
+        ("red", "x")
+        -> "\\textcolor{red}{x}"
+    """
+    return rf"\textcolor{{{color}}}{{{value}}}"
+
+
+def command_color(command: str) -> str:
+    """
+    Determine which color category a LaTeX command belongs to.
+
+    Example:
+        "\\sum" -> orange
+        "\\rightarrow" -> arrow color
+        "\\in" -> set color
+    """
+
+    # Big math operators
+    if (
+        command in BIG_OPERATORS
+        or command in INTEGRALS
+        or command in LIMIT_OPERATORS
+    ):
+        return COLORS["orange"]
+
+    # Arrows
+    if command in ARROWS:
+        return COLORS["arrow"]
+
+    # Set theory symbols
+    if command in SET_SYMBOLS:
+        return COLORS["set"]
+
+    # Spacing commands
+    if command in SPACING_COMMANDS:
+        return COLORS["spacing"]
+
+    # Multiplication symbols
+    if command in MULTIPLICATION_SYMBOLS:
+        return COLORS["dot"]
+
+    # Default relations (=, <, >, etc.)
+    return COLORS["relation"]

color_math/utils/latex_helpers.py

@@ -0,0 +1,232 @@
+# latex_helpers.py
+
+import re
+
+
+COMMAND_RE = re.compile(r"\\[A-Za-z]+|\\.")
+
+
+def read_comment_end(text: str, start: int) -> int:
+    """Return the index after one TeX comment, including its newline."""
+    index = start + 1
+    while index < len(text) and text[index] not in "\r\n":
+        index += 1
+    if text.startswith("\r\n", index):
+        return index + 2
+    return min(index + 1, len(text))
+
+
+def read_verb_end(text: str, start: int) -> tuple[int, bool] | None:
+    r"""Read an exact ``\verb``/``\verb*`` payload without inspecting it."""
+    if not text.startswith(r"\verb", start):
+        return None
+    command_end = start + len(r"\verb")
+    if command_end < len(text) and text[command_end].isalpha():
+        return None
+    if command_end < len(text) and text[command_end] == "*":
+        command_end += 1
+    if command_end >= len(text) or text[command_end].isspace():
+        return len(text), False
+
+    delimiter = text[command_end]
+    closing = text.find(delimiter, command_end + 1)
+    return (
+        (len(text), False)
+        if closing < 0
+        else (closing + 1, True)
+    )
+
+
+def read_braced(text: str, start: int) -> tuple[str, int] | None:
+    """
+    Read a balanced {...} group starting at index 'start'.
+
+    Returns:
+        (captured_text, end_index)
+
+    Example:
+        "{abc}" -> ("{abc}", 5)
+    """
+    if start >= len(text) or text[start] != "{":
+        return None
+
+    depth = 0
+    index = start
+
+    while index < len(text):
+        char = text[index]
+
+        if char == "%":
+            index = read_comment_end(text, index)
+            continue
+
+        if char == "\\":
+            verb = read_verb_end(text, index)
+            if verb is not None:
+                index, closed = verb
+                if not closed:
+                    return None
+                continue
+            command = COMMAND_RE.match(text, index)
+            index = command.end() if command is not None else index + 1
+            continue
+
+        if char == "{":
+            depth += 1
+        elif char == "}":
+            depth -= 1
+            if depth == 0:
+                return text[start:index + 1], index + 1
+
+        index += 1
+
+    return None
+
+
+def read_script_argument(text: str, start: int) -> tuple[str, int] | None:
+    """
+    Read argument after _ or ^
+
+    Handles:
+        x^{abc}
+        x^n
+        x^\\alpha
+    """
+
+    if start >= len(text):
+        return None
+
+    # Braced argument
+    if text[start] == "{":
+        return read_braced(text, start)
+
+    if text[start] in "$\r\n":
+        return None
+
+    # Latex command
+    if text[start] == "\\":
+        match = re.match(r"\\[A-Za-z]+|\\.", text[start:])
+        if match:
+            return match.group(0), start + len(match.group(0))
+
+    # Single character
+    return text[start], start + 1
+
+
+def read_script(text: str, start: int) -> tuple[str, int, bool] | None:
+    """
+    Read full superscript/subscript.
+
+    Example:
+        "^2"
+        "_{abc}"
+        "^\\alpha"
+    """
+
+    marker = text[start]   # _ or ^
+
+    argument_start = start + 1
+
+    if argument_start < len(text) and text[argument_start] == "{":
+        argument_data = read_braced(text, argument_start)
+
+        if argument_data is None:
+            return text[start:], len(text), False
+
+        argument, end = argument_data
+        return f"{marker}{argument}", end, True
+
+    argument_data = read_script_argument(text, argument_start)
+
+    if argument_data is None:
+        return None
+
+    argument, end = argument_data
+
+    return f"{marker}{argument}", end, True
+
+
+def read_color_wrapper(text: str, start: int) -> tuple[str, int] | None:
+    """
+    Read a scoped color wrapper and return its unbraced value and end index.
+
+    Supports current ``\\textcolor{red}{x}`` output and legacy
+    ``\\color{red}{x}`` output. Command names are matched exactly, so macros
+    such as ``\\colorbox`` and ``\\colorful`` are left alone.
+    """
+    command = next(
+        (
+            candidate
+            for candidate in (r"\textcolor", r"\color")
+            if text.startswith(candidate, start)
+            and (
+                start + len(candidate) == len(text)
+                or not text[start + len(candidate)].isalpha()
+            )
+        ),
+        None,
+    )
+    if command is None:
+        return None
+
+    index = start + len(command)
+
+    while index < len(text) and text[index].isspace():
+        index += 1
+
+    color_data = read_braced(text, index)
+    if color_data is None:
+        return None
+
+    _, index = color_data
+
+    while index < len(text) and text[index].isspace():
+        index += 1
+
+    value_data = read_braced(text, index)
+    if value_data is None:
+        return None
+
+    value, end = value_data
+    return value[1:-1], end
+
+
+def read_color_command(text: str, start: int) -> tuple[str, int] | None:
+    """
+    Detect an existing scoped color command.
+
+    Examples:
+        \\textcolor{red}{x}
+        \\color{red}{x}
+
+    Returns:
+        (full_command, end_index)
+        or None
+    """
+    wrapper = read_color_wrapper(text, start)
+    if wrapper is None:
+        return None
+
+    _, end = wrapper
+    return text[start:end], end
+
+
+def contains_color_wrapper(text: str) -> bool:
+    """Find active wrappers, ignoring TeX comments and verbatim payloads."""
+    index = 0
+    while index < len(text):
+        if text[index] == "%":
+            index = read_comment_end(text, index)
+            continue
+        if text[index] == "\\":
+            if read_color_wrapper(text, index) is not None:
+                return True
+            verb = read_verb_end(text, index)
+            if verb is not None:
+                index = verb[0]
+                continue
+            command = COMMAND_RE.match(text, index)
+            index = command.end() if command is not None else index + 1
+            continue
+        index += 1
+    return False

color_math/utils/spans.py

@@ -0,0 +1,77 @@
+"""Apply source-preserving color wrappers to exact LaTeX ranges."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class ColorSpan:
+    """A half-open source range that should receive one color."""
+
+    start: int
+    end: int
+    color: str
+    priority: int = 0
+
+
+def _crosses(left: ColorSpan, right: ColorSpan) -> bool:
+    return (
+        left.start < right.start < left.end < right.end
+        or right.start < left.start < right.end < left.end
+    )
+
+
+def select_color_spans(source: str, spans: list[ColorSpan]) -> list[ColorSpan]:
+    """Keep valid nested/disjoint spans, preferring higher-priority edits."""
+
+    candidates: dict[tuple[int, int], ColorSpan] = {}
+    for span in spans:
+        if not (0 <= span.start < span.end <= len(source)):
+            continue
+        key = (span.start, span.end)
+        previous = candidates.get(key)
+        if previous is None or span.priority > previous.priority:
+            candidates[key] = span
+
+    accepted: list[ColorSpan] = []
+    for span in sorted(
+        candidates.values(),
+        key=lambda item: (-item.priority, item.start, -(item.end - item.start)),
+    ):
+        if any(_crosses(span, other) for other in accepted):
+            continue
+        accepted.append(span)
+
+    return sorted(accepted, key=lambda item: (item.start, -item.end))
+
+
+def apply_color_spans(source: str, spans: list[ColorSpan]) -> str:
+    """Insert ``\\textcolor`` wrappers without changing the source itself."""
+
+    selected = select_color_spans(source, spans)
+    openings: dict[int, list[ColorSpan]] = {}
+    closings: dict[int, list[ColorSpan]] = {}
+    for span in selected:
+        openings.setdefault(span.start, []).append(span)
+        closings.setdefault(span.end, []).append(span)
+
+    pieces: list[str] = []
+    for index in range(len(source) + 1):
+        # Close inner spans first, then open outer spans first.
+        for _ in sorted(
+            closings.get(index, ()),
+            key=lambda item: item.start,
+            reverse=True,
+        ):
+            pieces.append("}")
+        for span in sorted(
+            openings.get(index, ()),
+            key=lambda item: item.end,
+            reverse=True,
+        ):
+            pieces.append(rf"\textcolor{{{span.color}}}{{")
+        if index < len(source):
+            pieces.append(source[index])
+
+    return "".join(pieces)

python_color_math-0.1.0.dist-info/METADATA

@@ -0,0 +1,167 @@
+Metadata-Version: 2.4
+Name: python-color-math
+Version: 0.1.0
+Summary: Pure Python semantic LaTeX and MathJax colorizer for Obsidian Markdown, KaTeX, and math notes.
+Author: 36ty-blip
+License: MIT License
+        
+        Copyright (c) 2026 Aditya
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/36ty-blip/python-color-math
+Project-URL: Repository, https://github.com/36ty-blip/python-color-math
+Project-URL: Issues, https://github.com/36ty-blip/python-color-math/issues
+Keywords: obsidian,latex,math,markdown,colorizer,katex,mathjax,cli
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Education
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Text Processing :: Markup
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# 🎨 color-math (Python)
+
+> Pure Python semantic LaTeX and MathJax colorizer for Obsidian Markdown notes, KaTeX documents, and scientific workflows. Zero dependencies.
+
+[![CI](https://github.com/36ty-blip/python-color-math/actions/workflows/ci.yml/badge.svg)](https://github.com/36ty-blip/python-color-math/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/python-color-math.svg)](https://pypi.org/project/python-color-math/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![Python: 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/)
+
+`python-color-math` is a fast, standalone command-line tool and Python library that automatically parses LaTeX and MathJax expressions and wraps elements in semantic `\textcolor{...}{...}` annotations. It works across plain Markdown, Obsidian notes, Quarto documents, Jupyter notebooks, and raw LaTeX files without modifying surrounding prose or code blocks.
+
+> [!NOTE]
+> **Looking for the Obsidian Plugin?** Check out [obsidian-color-math](https://github.com/36ty-blip/obsidian-color-math) for real-time live preview math coloring directly inside Obsidian!
+
+---
+
+## ✨ Features
+
+- **Zero External Dependencies**: Runs entirely on the Python Standard Library (Python 3.10+).
+- **Physical Units & Metric Prefixes**: Distinguishes units (`\mu m`, `m/s`, `nm`, `kg`) from variables, shielding algebraic variables like $m$ in $F = ma$ or $E = mc^2$.
+- **Calculus Differentials & Derivatives**: Recognizes infinitesimal differentials ($dx$, $dt$, $d\theta$) and derivative fractions ($\frac{d}{dx}$, $\frac{\partial \psi}{\partial t}$), while preserving standalone distance $d$ and relations like $d\iff e$.
+- **Dirac Quantum Bra-Ket Notation**: Formats kets ($|\psi\rangle$), bras ($\langle\phi|$), and expectation values ($\langle\phi|\hat{H}|\psi\rangle$) while protecting absolute values ($|x| < 5$).
+- **Dimensionless Numbers**: Identifies contiguous engineering numbers ($Re$, $Ma$, $Pr$, $Nu$) without capturing separated variables ($R\,e$).
+- **Rainbow Delimiters**: Stack-based delimiter matching that colors nested parentheses, brackets, and braces by nesting depth.
+- **Mathematical Symbol Taxonomy**: Categorizes constants ($\pi, \hbar, \infty$), Greek parameters ($\alpha, \theta, \lambda$), functions ($\sin, \cos, \ln$), and bound summation/limit indices.
+- **Variable Data-Flow Hashing**: Deterministically hashes identifiers across an equation so each unique variable maintains a consistent color across terms.
+- **Boxed Equations**: Preserves `\boxed{...}` wrappers while coloring internal mathematical structures.
+- **Signature Tokyo Night Palette**: Muted pastel tones calibrated for readability and reduced eye strain.
+- **Markdown & TeX Safety**: Fenced code blocks, inline code, TeX comments, and `\verb` blocks are protected and left unmodified.
+- **Lossless & Reversible**: Includes a `--undo` command to cleanly strip all injected colors back to original LaTeX notation.
+
+---
+
+## 🚀 Installation
+
+Install from PyPI:
+
+```bash
+pip install python-color-math
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/36ty-blip/python-color-math.git
+cd python-color-math
+pip install .
+```
+
+---
+
+## 💻 CLI Usage
+
+### Process a Markdown or LaTeX file
+
+```bash
+# Colorize equations in a single note
+color-math note.md
+
+# Colorize an entire directory of notes recursively
+color-math ./vault/
+
+# Preview changes without modifying files (Dry Run)
+color-math --dry-run note.md
+
+# Revert and clean colors back to plain LaTeX
+color-math --undo note.md
+```
+
+### Stdin / Pipe Support
+
+Pipe equations directly through the CLI:
+
+```bash
+echo "$$\frac{d}{dx}f(g(x)) = f'(g(x)) \cdot g'(x)$$" | color-math
+```
+
+---
+
+## 🐍 Python API
+
+Use `color-math` directly as a library in your Python applications, scripts, or data pipelines:
+
+```python
+from color_math import colorize_latex, ColorMathOptions
+
+latex = r"\frac{d}{dx}f(g(x)) = f'(g(x)) \cdot g'(x)"
+
+# Basic coloring with default Tokyo Night palette
+colored = colorize_latex(latex)
+print(colored)
+
+# Enable extended features (Rainbow delimiters, Variable hashing, etc.)
+opts = ColorMathOptions.all_enabled()
+extended_colored = colorize_latex(latex, options=opts)
+```
+
+---
+
+## 🧪 Testing
+
+Run the comprehensive test suites (51 tests):
+
+```bash
+# Run feature test suite
+python -m unittest discover tests
+
+# Run regression self-test suite
+python -m tests.self_test
+```
+
+---
+
+## 📄 License
+
+MIT License. See [LICENSE](LICENSE) for details.

python_color_math-0.1.0.dist-info/RECORD

@@ -0,0 +1,40 @@
+color_math/__init__.py,sha256=Mzp9sKJJHZPEHWiy0UnH1tu6WJ0-VltFtyx_-pU7Dek,336
+color_math/__main__.py,sha256=lU6t3BklI-5H9EdprlceWLr0UcDmfXUu3Th0tjk2ANA,81
+color_math/adapters.py,sha256=4WtoioVJqTRsgiukHvxHHGEd4Mr9v0ATnZituriaXu8,10215
+color_math/config.py,sha256=S_fq5uSoIXPMI8TSlIUc9d4uPsp-zFlR3hvAINIDf9k,5835
+color_math/io.py,sha256=iCWMY1ufPZzFCwuHTn_axNetek8PRXGNnrmz59CrlGw,1591
+color_math/main.py,sha256=lBbgYkNGZLsyxDIF_LXnFNvBZUsTwUpuRXoe4HZa1gU,4393
+color_math/self_test.py,sha256=O-BLG2c_3jXPl9NfuMIKChUxGFih8DtVchdBMI3X2-o,7735
+color_math/undo.py,sha256=2LZCYybQICeDbHGk-KBcGczf0qp8D4_3Af8clD2nYlw,1773
+color_math/converters/__init__.py,sha256=1D8U549JFGecslNKnvdpS1yslzMk30xkFM9ymjeYtDE,718
+color_math/converters/align.py,sha256=bfOuoX_GQXLCqPtONlHCRZIsTv9DA8am5J0S8X8AVO8,461
+color_math/converters/block.py,sha256=VB4CpgvW2Ms1vXG0biUSQdcMWD1bIw562Kuij3iZoUY,3139
+color_math/converters/derivative.py,sha256=hVreur2qv2uH2wrvJQ5j00y5Jpefa4hwUCwmKkVsP20,8241
+color_math/converters/equation.py,sha256=NoUXfLayzkoJJ2cBZmV-9-LLy156K4Ak03-wPx7t67M,105
+color_math/converters/generic.py,sha256=iVg-kTsvadZrQ3MSdpBhEye-wf6MW_Qnru9jO0e5WbA,3426
+color_math/converters/integral.py,sha256=V-HkZVcCLzELR9wCbUz0Lgc3cTIvy4DCuEfEFzCy_jg,414
+color_math/converters/limit.py,sha256=xcakNIFUb_2zC9jHOZmAx9QgzWUbzVp31b1jgfCgP5Q,425
+color_math/converters/matrix.py,sha256=0AHpCLMmGIzMwiMSZ8PpK1-JdCYnoCXzhkmlhmNYyxw,4672
+color_math/converters/semantic.py,sha256=fxAu76l8K57GI2oLvfYSrHpFt1hMWBhBHyt9giLbPy0,1902
+color_math/parsers/__init__.py,sha256=EiZFGRm7aanSJzh5mAA4F8_I94T85kOtJrz9iZBADwc,1722
+color_math/parsers/braket.py,sha256=9FOLa26Yvf9vl-AKF5fjSITw3gS0MEtM-Ke9XkFdmhE,3919
+color_math/parsers/delimiters.py,sha256=vcf29d0QRtAPN5wuxHqdxW8EQ6kVvuwG2fqDLW9lAGE,5057
+color_math/parsers/differentials.py,sha256=VjrVNX38JcGreTeAWo_azwqK3c2hsUrIx38FyX0NXRA,3009
+color_math/parsers/dimensionless.py,sha256=_pGw10Os5iVenry7JWcEE3vtodmt7EAacrkE4obYwOA,2307
+color_math/parsers/latex_spans.py,sha256=UGcSh4qzuCcZjT_tZMsB2RsoSjyLSckXDhzukpioe4Q,31343
+color_math/parsers/markdown_scanner.py,sha256=6KfEeHJ-F9xsaarIKmdyeN2CwQORQLs95q26uY7_JXI,12790
+color_math/parsers/math_parser.py,sha256=pbYfIfJDjUMhfuPzMuLukqtzZXW6mMshQqE4uulKqRM,10415
+color_math/parsers/scanner.py,sha256=eTolv8sg8q7ILg4-CfOFbgSw1ZMpidQDYi0HRnN_R8U,11338
+color_math/parsers/taxonomy.py,sha256=XDCirS4kOKcHQf-6ldqdaeQfr81rJXLnXmdYY9X68FA,5036
+color_math/parsers/units.py,sha256=EhvTdIlels3Tw2MSyt4c7XRSlC4eG4Bz4Hg351SdNSg,3656
+color_math/parsers/variable_hash.py,sha256=-OhQbE7psG4WfqsENFQL75lk9YsFwelRDEmRDXTkTis,5200
+color_math/utils/__init__.py,sha256=y5qebQLJwQjuOuI54QnbDeCr7SEdFQm4-9KgIruWQfc,497
+color_math/utils/coloring.py,sha256=nCihj00f_lOuQ79l_crc7BJ30e6rh9nztOwDMwvEMwc,1240
+color_math/utils/latex_helpers.py,sha256=JMNApj--EvEDMXkRyoRpUqbaJysaMGD0BiEAIvRE_vY,5886
+color_math/utils/spans.py,sha256=vYsvSk3QfRqZswFDQ1OtiXOBIzN_36OtE5AP4xaenFI,2396
+python_color_math-0.1.0.dist-info/licenses/LICENSE,sha256=hveQNxqYFqK9Brs_ruH-8shF2D61hIVKYdCjiE-1wMY,1063
+python_color_math-0.1.0.dist-info/METADATA,sha256=LkbUg3wjQvmAWp8hMi6zb2h7YV6qdQF4Zr5b1p3prRA,7079
+python_color_math-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+python_color_math-0.1.0.dist-info/entry_points.txt,sha256=tYE8pBqTiwj22sVIVaSAiP-ZWbFry_ZN1nssVb6wOPc,52
+python_color_math-0.1.0.dist-info/top_level.txt,sha256=Pxuur7TFdlMD0AW61wir5nCIgzFAupL67n1tWe1B5A8,11
+python_color_math-0.1.0.dist-info/RECORD,,

python_color_math-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

python_color_math-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+color-math = color_math.main:main

python_color_math-0.1.0.dist-info/licenses/LICENSE

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

python_color_math-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+color_math