From e4e89a3d0e52cd066f177b5f152a9de3dd54ffb9 Mon Sep 17 00:00:00 2001 From: Abbas Ali Date: Sat, 11 Oct 2025 19:43:58 +0500 Subject: [PATCH 1/8] Fix: Trigger docs build only on release publish --- .github/workflows/docs.yml | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml index b27df12..bd79eb2 100644 --- a/.github/workflows/docs.yml +++ b/.github/workflows/docs.yml @@ -2,9 +2,8 @@ name: website # build the documentation whenever there are new commits on main on: - push: - branches: - - main + release: + - published # Alternative: only build for tags. # tags: # - '*' From 6cf037c08403ed8c4aa3260c7ebb5c40b88e2dcd Mon Sep 17 00:00:00 2001 From: Abbas Ali Date: Sun, 12 Oct 2025 19:23:04 +0500 Subject: [PATCH 2/8] Fix #66 --- .github/workflows/docs.yml | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml index bd79eb2..eefba42 100644 --- a/.github/workflows/docs.yml +++ b/.github/workflows/docs.yml @@ -29,6 +29,11 @@ jobs: cache-dependency-glob: "uv.lock" - name: Install the project run: uv sync --all-extras --dev + - name: Extract version from tag + run: | + VERSION=${GITHUB_REF#refs/tags/} + echo "VERSION=$VERSION" >> $GITHUB_ENV + echo "Building docs for version: $VERSION" - run: uv run pdoc -o docs/ redlines - uses: actions/upload-pages-artifact@v3 with: From 23b3e36f0347c569c4a1b07bf5b14e21e08654fa Mon Sep 17 00:00:00 2001 From: Abbas Ali Date: Sun, 12 Oct 2025 19:47:26 +0500 Subject: [PATCH 3/8] Fix #67 --- .github/workflows/docs.yml | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml index eefba42..b6b05a9 100644 --- a/.github/workflows/docs.yml +++ b/.github/workflows/docs.yml @@ -34,6 +34,29 @@ jobs: VERSION=${GITHUB_REF#refs/tags/} echo "VERSION=$VERSION" >> $GITHUB_ENV echo "Building docs for version: $VERSION" + - name: Create version wrapper + run: | + mv docs generated-docs + mkdir -p docs + cat > docs/index.html << 'EOF' + + + + + Documentation + + + +
+ Documentation for version $VERSION +
+

Documentation for version $VERSION

+

Redirecting to documentation...

+ + + EOF + mv generated-docs docs/ + - run: uv run pdoc -o docs/ redlines - uses: actions/upload-pages-artifact@v3 with: From 06475ffe219974fc27b4b6f1009565ab3c6ec8fa Mon Sep 17 00:00:00 2001 From: Abbas Ali Date: Sun, 12 Oct 2025 20:00:28 +0500 Subject: [PATCH 4/8] Fix #68 --- CONTRIBUTING.md | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index c798ce6..0a02a9d 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -152,6 +152,37 @@ and respectful in your tone. To preview documentation, you can clone the project, install development dependencies, and then run `pdoc redlines` to see your changes. +## Documentation + +Our documentation is automatically generated from source code using `pdoc`. + +### How It Works +- Documentation builds automatically **when a new release is published**. +- The release tag (for example `v1.2.3`) is extracted by the CI workflow and exposed to the build as the `VERSION` environment variable. +- The version number is displayed in the published documentation. + +### To Update Documentation +1. Make code changes and update docstrings as needed. +2. Create and publish a new release on GitHub (use tags like `vMAJOR.MINOR.PATCH`). +3. The documentation workflow will run automatically and rebuild the docs for that release. +4. Check the deployed docs to verify the version banner and content. + +### Manual Documentation Build (for testing) +To build docs locally before releasing: + +```bash +# install pdoc locally +pip install pdoc +``` + +# generate HTML into docs/ +pdoc --html --output-dir docs/ your_package_name + +# preview locally +cd docs +python -m http.server 8000 +# then open http://localhost:8000 in your browser + ## Styleguides For code, we use the [Black formatter](https://black.readthedocs.io/en/stable/index.html). Please be encouraged to use From 8ab27eaf254c8d1a8be3529c6f3e2f38c3306b04 Mon Sep 17 00:00:00 2001 From: Abbas Ali Date: Sun, 12 Oct 2025 21:42:56 +0500 Subject: [PATCH 5/8] Adding the index.html for fix#67 --- docs/generated-docs/index.html | 7 + docs/generated-docs/redlines.html | 390 +++ docs/generated-docs/redlines/cli.html | 514 ++++ docs/generated-docs/redlines/document.html | 530 ++++ docs/generated-docs/redlines/enums.html | 493 ++++ docs/generated-docs/redlines/processor.html | 1127 +++++++++ docs/generated-docs/redlines/redlines.html | 2488 +++++++++++++++++++ docs/generated-docs/search.js | 46 + docs/index.html | 15 + 9 files changed, 5610 insertions(+) create mode 100644 docs/generated-docs/index.html create mode 100644 docs/generated-docs/redlines.html create mode 100644 docs/generated-docs/redlines/cli.html create mode 100644 docs/generated-docs/redlines/document.html create mode 100644 docs/generated-docs/redlines/enums.html create mode 100644 docs/generated-docs/redlines/processor.html create mode 100644 docs/generated-docs/redlines/redlines.html create mode 100644 docs/generated-docs/search.js create mode 100644 docs/index.html diff --git a/docs/generated-docs/index.html b/docs/generated-docs/index.html new file mode 100644 index 0000000..16484a8 --- /dev/null +++ b/docs/generated-docs/index.html @@ -0,0 +1,7 @@ + + + + + + + diff --git a/docs/generated-docs/redlines.html b/docs/generated-docs/redlines.html new file mode 100644 index 0000000..4597aa1 --- /dev/null +++ b/docs/generated-docs/redlines.html @@ -0,0 +1,390 @@ + + + + + + + redlines API documentation + + + + + + + + + +
+
+

+redlines

+ +

Redlines

+ +

Redlines produces a text showing the differences between two strings/text. The changes are represented with +strike-throughs and underlines, which looks similar to Microsoft Word's track changes. This method of showing changes is +more familiar to lawyers and is more compact for long series of characters.

+ +

Redlines uses SequenceMatcher +to find differences between words used. +The output can be in HTML, Markdown, or rich format.

+ +

Example

+ +

Given an original string:

+ +
The quick brown fox jumps over the lazy dog.
+
+ +

And the string to be tested with:

+ +
The quick brown fox walks past the lazy dog.
+
+ +

The library gives a result of:

+ +
"The quick brown fox <span style='color:red;font-weight:700;text-decoration:line-through;'>jumps over </span><span style='color:green;font-weight:700;'>walks past </span>the lazy dog."
+
+ +

Which is rendered like this:

+ +

The quick brown fox jumps over walks past the lazy dog.

+ +

Install

+ +

Use your regular package manager to install the library in your python environment.

+ +
pip install redlines
+
+ +

Quickstart

+ +

This is the most direct way to produce the example.

+ +
+
# import the class
+from redlines import Redlines
+
+# Create a Redlines object using the two strings to compare
+test = Redlines(
+    "The quick brown fox jumps over the lazy dog.",
+    "The quick brown fox walks past the lazy dog.",
+)
+
+# This produces an output in markdown format
+test.output_markdown
+
+
+ +

Common Issues

+ +

The documentation contains other information on common issues users have faced while using this library:

+ + +
+ + + + + + 
 1"""
+ 2# Redlines
+ 3
+ 4`Redlines` produces a text showing the differences between two strings/text. The changes are represented with
+ 5strike-throughs and underlines, which looks similar to Microsoft Word's track changes. This method of showing changes is
+ 6more familiar to lawyers and is more compact for long series of characters.
+ 7
+ 8Redlines uses [SequenceMatcher](https://docs.python.org/3/library/difflib.html#difflib.SequenceMatcher)
+ 9to find differences between words used.
+10The output can be in HTML, Markdown, or `rich` format.
+11
+12## Example
+13
+14Given an original string:
+15
+16    The quick brown fox jumps over the lazy dog.
+17
+18And the string to be tested with:
+19
+20    The quick brown fox walks past the lazy dog.
+21
+22The library gives a result of:
+23
+24    "The quick brown fox <span style='color:red;font-weight:700;text-decoration:line-through;'>jumps over </span><span style='color:green;font-weight:700;'>walks past </span>the lazy dog."
+25
+26
+27Which is rendered like this:
+28
+29The quick brown fox <span style='color:red;font-weight:700;text-decoration:line-through;'>jumps over </span><span style='color:green;font-weight:700;'>walks past </span>the lazy dog.
+30
+31## Install
+32
+33Use your regular package manager to install the library in your python environment.
+34
+35```terminal
+36pip install redlines
+37```
+38
+39## Quickstart
+40
+41This is the most direct way to produce the example.
+42
+43```python
+44# import the class
+45from redlines import Redlines
+46
+47# Create a Redlines object using the two strings to compare
+48test = Redlines(
+49    "The quick brown fox jumps over the lazy dog.",
+50    "The quick brown fox walks past the lazy dog.",
+51)
+52
+53# This produces an output in markdown format
+54test.output_markdown
+55```
+56
+57## Common Issues
+58
+59The documentation contains other information on common issues users have faced while using this library:
+60
+61* [Styling](redlines/redlines.html#styling-markdown)
+62* [Ensuring styling appears in environments such as Jupyter Notebooks, Streamlit, CoLab etc](redlines/redlines.html#markdown-output-in-specific-environments)
+63* [Using plain text files and others as input](redlines/document.html)
+64* [Using the CLI](redlines/cli.html)
+65
+66"""
+67
+68from .document import *
+69from .enums import *
+70from .processor import *
+71from .redlines import *
+
+ + +
+
+ + \ No newline at end of file diff --git a/docs/generated-docs/redlines/cli.html b/docs/generated-docs/redlines/cli.html new file mode 100644 index 0000000..320bf55 --- /dev/null +++ b/docs/generated-docs/redlines/cli.html @@ -0,0 +1,514 @@ + + + + + + + redlines.cli API documentation + + + + + + + + + +
+
+

+redlines.cli

+ +

Command line interface for redlines.

+ +

A command line interface for the redlines library that allows you to compare two strings +and see the differences in the terminal.

+ +

NAME

+ +

redlines - A command line interface for the redlines library to compare text differences

+ +

SYNOPSIS

+ +
+
redlines [COMMAND] [OPTIONS] SOURCE TEST
+
+
+ +

DESCRIPTION

+ +

Redlines is a command line utility that shows the differences between two strings/text. +The changes are represented with strike-throughs and underlines, similar to Microsoft Word's track changes. +This method of showing changes is more familiar to lawyers and is more compact for long series of characters.

+ +

COMMANDS

+ +
+
text
+
+
+ +

Compares the strings SOURCE and TEST and produces a redline in the terminal in a display that shows the original, new, and redlined text.

+ +
+
simple_text
+
+
+ +

Compares the strings SOURCE and TEST and outputs the redline in the terminal.

+ +
+
markdown
+
+
+ +

Compares the strings SOURCE and TEST and outputs the redline as a markdown.

+ +

OPTIONS

+ +
+
-h, --help
+
+
+ +

Show this help message and exit.

+ +

EXAMPLES

+ +

Compare two strings and display the differences in a detailed layout:

+ +
+
redlines text "The quick brown fox jumps over the lazy dog." "The quick brown fox walks past the lazy dog."
+
+
+ +

Compare two strings and output the redline directly:

+ +
+
redlines simple_text "The quick brown fox jumps over the lazy dog." "The quick brown fox walks past the lazy dog."
+
+
+ +

LIMITATIONS

+ +
    +
  • The text command is not able to show more than 6 lines of text. You may want to use simple_text for longer text.
    • +
+ +

You may also want to consider a related textual project if you want to use redlines in the terminal, +redlines-textual.

+
+ + + + + + 
  1"""
+  2# Command line interface for redlines.
+  3
+  4A command line interface for the redlines library that allows you to compare two strings
+  5and see the differences in the terminal.
+  6
+  7
+  8## NAME
+  9`redlines` - A command line interface for the redlines library to compare text differences
+ 10
+ 11## SYNOPSIS
+ 12```sh
+ 13redlines [COMMAND] [OPTIONS] SOURCE TEST
+ 14```
+ 15
+ 16## DESCRIPTION
+ 17`Redlines` is a command line utility that shows the differences between two strings/text.
+ 18The changes are represented with strike-throughs and underlines, similar to Microsoft Word's track changes.
+ 19This method of showing changes is more familiar to lawyers and is more compact for long series of characters.
+ 20
+ 21## COMMANDS
+ 22```sh
+ 23text
+ 24```
+ 25Compares the strings SOURCE and TEST and produces a redline in the terminal in a display that shows the original, new, and redlined text.
+ 26
+ 27```sh
+ 28simple_text
+ 29```
+ 30Compares the strings SOURCE and TEST and outputs the redline in the terminal.
+ 31
+ 32```sh
+ 33markdown
+ 34```
+ 35Compares the strings SOURCE and TEST and outputs the redline as a markdown.
+ 36
+ 37## OPTIONS
+ 38```sh
+ 39-h, --help
+ 40```
+ 41Show this help message and exit.
+ 42
+ 43## EXAMPLES
+ 44
+ 45Compare two strings and display the differences in a detailed layout:
+ 46```sh
+ 47redlines text "The quick brown fox jumps over the lazy dog." "The quick brown fox walks past the lazy dog."
+ 48```
+ 49
+ 50Compare two strings and output the redline directly:
+ 51```sh
+ 52redlines simple_text "The quick brown fox jumps over the lazy dog." "The quick brown fox walks past the lazy dog."
+ 53```
+ 54
+ 55## LIMITATIONS
+ 56* The `text` command is not able to show more than 6 lines of text. You may want to use `simple_text` for longer text.
+ 57
+ 58You may also want to consider a related textual project if you want to use redlines in the terminal,
+ 59[redlines-textual](https://github.com/houfu/redlines-textual).
+ 60"""
+ 61
+ 62import sys
+ 63import typing as t
+ 64from importlib.metadata import version
+ 65
+ 66import rich_click as click
+ 67from rich.console import Console, group
+ 68from rich.layout import Layout
+ 69from rich.panel import Panel
+ 70from rich.text import Text
+ 71
+ 72from .enums import MarkdownStyle
+ 73from .redlines import Redlines
+ 74
+ 75# Use Rich markup
+ 76click.rich_click.USE_RICH_MARKUP = True
+ 77click.rich_click.SHOW_ARGUMENTS = True
+ 78
+ 79
+ 80if sys.version_info < (3, 10):
+ 81    raise RuntimeError(
+ 82        "redlines requires Python 3.10 or higher. Please upgrade your Python version."
+ 83    )
+ 84
+ 85
+ 86@group()
+ 87def print_intro() -> t.Generator[Text, None, None]:
+ 88    """@private"""
+ 89    yield Text.from_markup(
+ 90        f"\n[bold red]--__--[/] [b]Redlines CLI[/b] [magenta]v{version('redlines')}[/] [bold red]--__--[/]\n\n"
+ 91        f"[dim]➡️ Showing differences in text in the terminal⬅️ \n "
+ 92        f"[b]🏠 [link=https://github.com/houfu/redlines]Homepage[/][/]",
+ 93        justify="center",
+ 94    )
+ 95
+ 96
+ 97@click.group()
+ 98def cli() -> None:
+ 99    """
+100    [red on black]Redlines[/] shows the differences between two strings/text.
+101
+102    The changes are represented with strike-throughs and underlines, which looks similar to Microsoft Word's
+103    track changes. This method of showing changes is more familiar to lawyers and is more compact for
+104    long series of characters.
+105
+106    [b][link=https://github.com/houfu/redlines]Homepage[/][/]
+107    \f
+108    @private
+109    """
+110    pass
+111
+112
+113@cli.command()
+114@click.argument("source", required=True)
+115@click.argument("test", required=True)
+116def text(source: str, test: str) -> None:
+117    """
+118    Compares the strings SOURCE and TEST and produce a redline in the terminal in a display that shows the original, new and redlined text.
+119
+120    \f
+121    @private
+122    """
+123
+124    redlines = Redlines(source, test)
+125
+126    console = Console()
+127    layout = Layout()
+128    layout.split_column(
+129        Layout(print_intro()),
+130        Layout(
+131            Panel(redlines.output_rich, title="redline", title_align="left"),
+132            name="redline",
+133        ),
+134        Layout(name="lower"),
+135    )
+136    layout["lower"].split_row(
+137        Layout(Panel(source, title="Source", title_align="left"), name="source"),
+138        Layout(Panel(test, title="Test", title_align="left"), name="test"),
+139    )
+140    console.print(layout)
+141
+142
+143@cli.command()
+144@click.argument("source", required=True)
+145@click.argument("test", required=True)
+146def simple_text(source: str, test: str) -> None:
+147    """
+148    Compares the strings SOURCE and TEST and outputs the redline in the terminal.
+149
+150    \f
+151    @private
+152    """
+153    from rich import print
+154
+155    redlines = Redlines(source, test)
+156    print(redlines.output_rich)
+157
+158
+159@cli.command()
+160@click.argument("source", required=True)
+161@click.argument("test", required=True)
+162@click.option(
+163    "markdown_style",
+164    "--markdown-style",
+165    "-m",
+166    type=click.Choice(list(MarkdownStyle), case_sensitive=False),
+167    default="red_green",
+168    help="The markdown style to use.",
+169)
+170def markdown(source: str, test: str, markdown_style: MarkdownStyle) -> None:
+171    """
+172    Compares the strings SOURCE and TEST and outputs the redline as a markdown.
+173
+174    \f
+175    @private
+176    """
+177    from rich import print
+178
+179    redlines = Redlines(source, test, markdown_style=markdown_style)
+180    print(redlines.output_markdown)
+
+ + +
+
+ + \ No newline at end of file diff --git a/docs/generated-docs/redlines/document.html b/docs/generated-docs/redlines/document.html new file mode 100644 index 0000000..1553eb6 --- /dev/null +++ b/docs/generated-docs/redlines/document.html @@ -0,0 +1,530 @@ + + + + + + + redlines.document API documentation + + + + + + + + + +
+
+

+redlines.document

+ + + + + + + 
 1import os
+ 2from abc import ABC, abstractmethod
+ 3
+ 4__all__: tuple[str, ...] = ("Document", "PlainTextFile")
+ 5
+ 6
+ 7class Document(ABC):
+ 8    """
+ 9    An abstract base class used as a common data interchange with the redlines with formats other than python text strings.
+10    To see a basic implementation, you can look at the `PlainTextFile` class for text files
+11
+12    |Supported File Formats | Class |
+13    |---| --- |
+14    |Plain Text files | `PlainTextFile` |
+15    """
+16
+17    @property
+18    @abstractmethod
+19    def text(self) -> str:
+20        """
+21        This property is used by the redlines library to obtain the text to compare. Implement this method to return
+22        the text to be compared by redlines.
+23        """
+24        pass
+25
+26
+27class PlainTextFile(Document):
+28    """
+29    Use this class so that Redlines can read plain text files.
+30
+31    ```python
+32    from redlines import PlainTextFile
+33
+34    source = PlainTextFile("tests/documents/PlainTextFile/source.txt")
+35    test = PlainTextFile("tests/documents/PlainTextFile/test.txt")
+36
+37    redline = Redlines(source, test)
+38    assert (
+39        redline.output_markdown
+40        == "The quick brown fox <span style='color:red;font-weight:700;text-decoration:line-through;'>jumps over </span><span style='color:green;font-weight:700;'>walks past </span>the lazy dog."
+41    )
+42    ```
+43
+44    """
+45
+46    @property
+47    def text(self) -> str:
+48        """
+49        :return: The text of the file referred to when the Document was created.
+50        """
+51        return self._text
+52
+53    def __init__(self, file_path: str | bytes | os.PathLike[str]) -> None:
+54        """
+55        Use this class so that Redlines can read plain text files.
+56
+57        :param file_path: Path to the text file.
+58        :type file_path: str | bytes | os.PathLike[str]
+59        """
+60        with open(file_path) as f:
+61            self._text = f.read()
+
+ + +
+
+ +
+ + class + Document(abc.ABC): + + + +
+ + 
 8class Document(ABC):
+ 9    """
+10    An abstract base class used as a common data interchange with the redlines with formats other than python text strings.
+11    To see a basic implementation, you can look at the `PlainTextFile` class for text files
+12
+13    |Supported File Formats | Class |
+14    |---| --- |
+15    |Plain Text files | `PlainTextFile` |
+16    """
+17
+18    @property
+19    @abstractmethod
+20    def text(self) -> str:
+21        """
+22        This property is used by the redlines library to obtain the text to compare. Implement this method to return
+23        the text to be compared by redlines.
+24        """
+25        pass
+
+ + +

An abstract base class used as a common data interchange with the redlines with formats other than python text strings. +To see a basic implementation, you can look at the PlainTextFile class for text files

+ + + + + + + + + + + + + + +
Supported File FormatsClass
Plain Text filesPlainTextFile
+
+ + +
+ +
+ text: str + + + +
+ + 
18    @property
+19    @abstractmethod
+20    def text(self) -> str:
+21        """
+22        This property is used by the redlines library to obtain the text to compare. Implement this method to return
+23        the text to be compared by redlines.
+24        """
+25        pass
+
+ + +

This property is used by the redlines library to obtain the text to compare. Implement this method to return +the text to be compared by redlines.

+
+ + +
+
+
+ +
+ + class + PlainTextFile(Document): + + + +
+ + 
28class PlainTextFile(Document):
+29    """
+30    Use this class so that Redlines can read plain text files.
+31
+32    ```python
+33    from redlines import PlainTextFile
+34
+35    source = PlainTextFile("tests/documents/PlainTextFile/source.txt")
+36    test = PlainTextFile("tests/documents/PlainTextFile/test.txt")
+37
+38    redline = Redlines(source, test)
+39    assert (
+40        redline.output_markdown
+41        == "The quick brown fox <span style='color:red;font-weight:700;text-decoration:line-through;'>jumps over </span><span style='color:green;font-weight:700;'>walks past </span>the lazy dog."
+42    )
+43    ```
+44
+45    """
+46
+47    @property
+48    def text(self) -> str:
+49        """
+50        :return: The text of the file referred to when the Document was created.
+51        """
+52        return self._text
+53
+54    def __init__(self, file_path: str | bytes | os.PathLike[str]) -> None:
+55        """
+56        Use this class so that Redlines can read plain text files.
+57
+58        :param file_path: Path to the text file.
+59        :type file_path: str | bytes | os.PathLike[str]
+60        """
+61        with open(file_path) as f:
+62            self._text = f.read()
+
+ + +

Use this class so that Redlines can read plain text files.

+ +
+
from redlines import PlainTextFile
+
+source = PlainTextFile("tests/documents/PlainTextFile/source.txt")
+test = PlainTextFile("tests/documents/PlainTextFile/test.txt")
+
+redline = Redlines(source, test)
+assert (
+    redline.output_markdown
+    == "The quick brown fox <span style='color:red;font-weight:700;text-decoration:line-through;'>jumps over </span><span style='color:green;font-weight:700;'>walks past </span>the lazy dog."
+)
+
+
+
+ + +
+ +
+ + PlainTextFile(file_path: str | bytes | os.PathLike[str]) + + + +
+ + 
54    def __init__(self, file_path: str | bytes | os.PathLike[str]) -> None:
+55        """
+56        Use this class so that Redlines can read plain text files.
+57
+58        :param file_path: Path to the text file.
+59        :type file_path: str | bytes | os.PathLike[str]
+60        """
+61        with open(file_path) as f:
+62            self._text = f.read()
+
+ + +

Use this class so that Redlines can read plain text files.

+ +
Parameters
+ +
    +
  • file_path: Path to the text file.
    • +
+
+ + +
+
+ +
+ text: str + + + +
+ + 
47    @property
+48    def text(self) -> str:
+49        """
+50        :return: The text of the file referred to when the Document was created.
+51        """
+52        return self._text
+
+ + +
Returns
+ +
+

The text of the file referred to when the Document was created.

+
+
+ + +
+
+
+ + \ No newline at end of file diff --git a/docs/generated-docs/redlines/enums.html b/docs/generated-docs/redlines/enums.html new file mode 100644 index 0000000..74622eb --- /dev/null +++ b/docs/generated-docs/redlines/enums.html @@ -0,0 +1,493 @@ + + + + + + + redlines.enums API documentation + + + + + + + + + +
+
+

+redlines.enums

+ + + + + + + 
 1import enum
+ 2
+ 3__all__: tuple[str, ...] = (
+ 4    "MarkdownStyle",
+ 5    "OutputType",
+ 6)
+ 7
+ 8
+ 9class MarkdownStyle(str, enum.Enum):
+10    """The markdown styles supported by redlines."""
+11
+12    RED_GREEN = "red_green"
+13    """Red and green colors for deletions and additions respectively."""
+14
+15    NONE = "none"
+16    """No colors."""
+17
+18    RED = "red"
+19    """Only red color for changes."""
+20
+21    GHFM = "ghfm"
+22    """GitHub Flavored Markdown style."""
+23
+24    BBCODE = "bbcode"
+25    """BBCode style."""
+26
+27    STREAMLIT = "streamlit"
+28    """Streamlit style."""
+29
+30
+31class OutputType(str, enum.Enum):
+32    """The output types supported by redlines."""
+33
+34    MARKDOWN = "markdown"
+35    """Markdown format."""
+36
+37    RICH = "rich"
+38    """Rich format for terminal output."""
+
+ + +
+
+ +
+ + class + MarkdownStyle(builtins.str, enum.Enum): + + + +
+ + 
10class MarkdownStyle(str, enum.Enum):
+11    """The markdown styles supported by redlines."""
+12
+13    RED_GREEN = "red_green"
+14    """Red and green colors for deletions and additions respectively."""
+15
+16    NONE = "none"
+17    """No colors."""
+18
+19    RED = "red"
+20    """Only red color for changes."""
+21
+22    GHFM = "ghfm"
+23    """GitHub Flavored Markdown style."""
+24
+25    BBCODE = "bbcode"
+26    """BBCode style."""
+27
+28    STREAMLIT = "streamlit"
+29    """Streamlit style."""
+
+ + +

The markdown styles supported by redlines.

+
+ + +
+
+ RED_GREEN = +<MarkdownStyle.RED_GREEN: 'red_green'> + + +
+ + +

Red and green colors for deletions and additions respectively.

+
+ + +
+
+
+ NONE = +<MarkdownStyle.NONE: 'none'> + + +
+ + +

No colors.

+
+ + +
+
+
+ RED = +<MarkdownStyle.RED: 'red'> + + +
+ + +

Only red color for changes.

+
+ + +
+
+
+ GHFM = +<MarkdownStyle.GHFM: 'ghfm'> + + +
+ + +

GitHub Flavored Markdown style.

+
+ + +
+
+
+ BBCODE = +<MarkdownStyle.BBCODE: 'bbcode'> + + +
+ + +

BBCode style.

+
+ + +
+
+
+ STREAMLIT = +<MarkdownStyle.STREAMLIT: 'streamlit'> + + +
+ + +

Streamlit style.

+
+ + +
+
+
+ +
+ + class + OutputType(builtins.str, enum.Enum): + + + +
+ + 
32class OutputType(str, enum.Enum):
+33    """The output types supported by redlines."""
+34
+35    MARKDOWN = "markdown"
+36    """Markdown format."""
+37
+38    RICH = "rich"
+39    """Rich format for terminal output."""
+
+ + +

The output types supported by redlines.

+
+ + +
+
+ MARKDOWN = +<OutputType.MARKDOWN: 'markdown'> + + +
+ + +

Markdown format.

+
+ + +
+
+
+ RICH = +<OutputType.RICH: 'rich'> + + +
+ + +

Rich format for terminal output.

+
+ + +
+
+
+ + \ No newline at end of file diff --git a/docs/generated-docs/redlines/processor.html b/docs/generated-docs/redlines/processor.html new file mode 100644 index 0000000..4b64a62 --- /dev/null +++ b/docs/generated-docs/redlines/processor.html @@ -0,0 +1,1127 @@ + + + + + + + redlines.processor API documentation + + + + + + + + + +
+
+

+redlines.processor

+ + + + + + + 
  1from __future__ import annotations
+  2
+  3import re
+  4from abc import ABC, abstractmethod
+  5from dataclasses import dataclass
+  6from difflib import SequenceMatcher
+  7from typing import Literal
+  8
+  9from .document import Document
+ 10
+ 11__all__: tuple[str, ...] = (
+ 12    "RedlinesProcessor",
+ 13    "WholeDocumentProcessor",
+ 14    "Redline",
+ 15    "Stats",
+ 16    "DiffOperation",
+ 17    "Chunk",
+ 18)
+ 19
+ 20tokenizer = re.compile(r"((?:[^()\s]+|[().?!-])\s*)")
+ 21r"""
+ 22This regular expression matches a group of characters that can include any character except for parentheses
+ 23and whitespace characters (which include spaces, tabs, and line breaks) or any character
+ 24that is a parenthesis or punctuation mark (.?!-).
+ 25The group can also include any whitespace characters that follow these characters.
+ 26
+ 27Breaking it down further:
+ 28
+ 29* `(` and `)` indicate a capturing group
+ 30* `(?: )` is a non-capturing group, meaning it matches the pattern but doesn't capture the matched text
+ 31* `[^()\s]+` matches one or more characters that are not parentheses or whitespace characters
+ 32* `|` indicates an alternative pattern
+ 33* `[().?!-]` matches any character that is a parenthesis or punctuation mark `(.?!-)`
+ 34* `\s*` matches zero or more whitespace characters (spaces, tabs, or line breaks) that follow the previous pattern.
+ 35"""
+ 36# This pattern matches one or more newline characters `\n`, and any spaces between them.
+ 37
+ 38paragraph_pattern = re.compile(r"((?:\n *)+)")
+ 39r"""
+ 40It is used to split the text into paragraphs.
+ 41
+ 42* `(?:\\n *)` is a non-capturing group that must start with a `\\n`   and be followed by zero or more spaces.
+ 43* `((?:\\n *)+)` is the previous non-capturing group repeated one or more times.
+ 44"""
+ 45
+ 46space_pattern = re.compile(r"(\s+)")
+ 47"""It is used to detect space."""
+ 48
+ 49
+ 50def tokenize_text(text: str) -> list[str]:
+ 51    """
+ 52    Tokenizes a string into a list of tokens. A token is defined as a group of characters that can include any character except for parentheses
+ 53    and whitespace characters (which include spaces, tabs, and line breaks) or any character that is a parenthesis or punctuation mark (.?!-).
+ 54    The group can also include any whitespace characters that follow these characters.
+ 55    For example, if the text is "Hello, world! This is a test.", the result will be:
+ 56    ['Hello, ', 'world! ', 'This ', 'is ', 'a ', 'test.']
+ 57
+ 58    :param text: The text to tokenize.
+ 59    :type text: str
+ 60    :return: a list of tokens.
+ 61    :rtype: list[str]
+ 62    """
+ 63    # NOTE: Single capturing group hence findall returns list of strings
+ 64    matches: list[str] = re.findall(tokenizer, text)
+ 65    return matches
+ 66
+ 67
+ 68def split_paragraphs(text: str) -> list[str]:
+ 69    """
+ 70    Splits a string into a list of paragraphs. One or more `\n` splits the paragraphs.
+ 71    For example, if the text is "Hello\nWorld\nThis is a test", the result will be:
+ 72    ['Hello', 'World', 'This is a test']
+ 73
+ 74    :param text: The text to split.
+ 75    :type text: str
+ 76    :return: a list of paragraphs.
+ 77    :rtype: list[str]
+ 78    """
+ 79    # NOTE: Single capturing group hence split returns list of strings
+ 80    split_text: list[str] = re.split(paragraph_pattern, text)
+ 81    result: list[str] = []
+ 82    for s in split_text:
+ 83        if s and not re.fullmatch(space_pattern, s):
+ 84            result.append(s.strip())
+ 85
+ 86    return result
+ 87
+ 88
+ 89def concatenate_paragraphs_and_add_chr_182(text: str) -> str:
+ 90    """
+ 91    Split paragraphs and concatenate them. Then add a character '¶' between paragraphs.
+ 92    For example, if the text is "Hello\nWorld\nThis is a test", the result will be:
+ 93    "Hello¶World¶This is a test"
+ 94
+ 95    :param text: The text to split.
+ 96    :type text: str
+ 97    :return: a list of paragraphs.
+ 98    :rtype: str
+ 99    """
+100    paragraphs = split_paragraphs(text)
+101
+102    result: list[str] = []
+103    for p in paragraphs:
+104        result.append(p)
+105        result.append(" ¶ ")
+106        # Add a string ' ¶ ' between paragraphs.
+107    if len(paragraphs) > 0:
+108        result.pop()
+109
+110    return "".join(result)
+111
+112
+113@dataclass
+114class Chunk:
+115    """A chunk of text that is being compared. In some cases, it may be the whole document"""
+116
+117    text: list[str]
+118    """The tokens of the chunk"""
+119    chunk_location: str | None
+120    """An optional string describing the location of the chunk in the document. For example, a PDF page number"""
+121
+122
+123@dataclass
+124class DiffOperation:
+125    """Internal representation of a diff operation (includes 'equal' operations for rendering)"""
+126
+127    source_chunk: Chunk
+128    test_chunk: Chunk
+129    """The chunk of text that is being compared"""
+130    opcodes: tuple[str, int, int, int, int]
+131    """The opcodes that describe the operation. See the difflib documentation for more information"""
+132
+133
+134@dataclass
+135class Redline:
+136    """
+137    A structured representation of a single change between source and test text.
+138
+139    This class provides a user-friendly interface for accessing diff information,
+140    with direct access to the changed text and position information.
+141    """
+142
+143    operation: Literal["delete", "insert", "replace"]
+144    """The type of change: 'delete', 'insert', or 'replace'"""
+145
+146    source_text: str | None
+147    """The text from the source document. Present for 'delete' and 'replace' operations."""
+148
+149    test_text: str | None
+150    """The text from the test document. Present for 'insert' and 'replace' operations."""
+151
+152    source_position: tuple[int, int] | None
+153    """Position in source tokens as (start, end). None for 'insert' operations."""
+154
+155    test_position: tuple[int, int] | None
+156    """Position in test tokens as (start, end). None for 'delete' operations."""
+157
+158
+159@dataclass
+160class Stats:
+161    """
+162    Statistics about the changes between source and test text.
+163
+164    Provides a summary of all changes including counts by operation type.
+165    """
+166
+167    total_changes: int
+168    """Total number of changes (deletions + insertions + replacements)"""
+169
+170    deletions: int
+171    """Number of deletion operations"""
+172
+173    insertions: int
+174    """Number of insertion operations"""
+175
+176    replacements: int
+177    """Number of replacement operations"""
+178
+179
+180class RedlinesProcessor(ABC):
+181    """
+182    An abstract class that defines the interface for a redlines processor.
+183    A redlines processor is a class that takes two documents and generates diff operations from them.
+184    Use this class as a base class if you want to create a custom redlines processor.
+185    See `WholeDocumentProcessor` for an example of a redlines processor.
+186    """
+187
+188    @abstractmethod
+189    def process(self, source: Document | str, test: Document | str) -> list[DiffOperation]:
+190        pass
+191
+192
+193class WholeDocumentProcessor(RedlinesProcessor):
+194    """
+195    A redlines processor that compares two documents. It compares the entire documents as a single chunk.
+196    """
+197
+198    def process(self, source: Document | str, test: Document | str) -> list[DiffOperation]:
+199        """
+200        Compare two documents as a single chunk.
+201
+202        :param source: The source document to compare.
+203        :type source: Document | str
+204        :param test: The test document to compare.
+205        :type test: Document | str
+206        :return: A list of `DiffOperation` that describe the differences between the two documents.
+207        :rtype: list[DiffOperation]
+208        """
+209        # Extract text from documents if needed
+210        source_text = source.text if isinstance(source, Document) else source
+211        test_text = test.text if isinstance(test, Document) else test
+212
+213        # Tokenize the texts
+214        source_tokens = tokenize_text(
+215            concatenate_paragraphs_and_add_chr_182(source_text)
+216        )
+217        test_tokens = tokenize_text(concatenate_paragraphs_and_add_chr_182(test_text))
+218
+219        # Normalize tokens by stripping whitespace for comparison
+220        # This allows the matcher to focus on content differences rather than whitespace variations
+221        # while still preserving the original tokens (including whitespace) for display in the output
+222        seq_source_normalized = [token.strip() for token in source_tokens]
+223        seq_test_normalized = [token.strip() for token in test_tokens]
+224
+225        matcher = SequenceMatcher(None, seq_source_normalized, seq_test_normalized)
+226
+227        return [
+228            DiffOperation(
+229                source_chunk=Chunk(text=source_tokens, chunk_location=None),
+230                test_chunk=Chunk(text=test_tokens, chunk_location=None),
+231                opcodes=opcode,
+232            )
+233            for opcode in matcher.get_opcodes()
+234        ]
+
+ + +
+
+ +
+ + class + RedlinesProcessor(abc.ABC): + + + +
+ + 
181class RedlinesProcessor(ABC):
+182    """
+183    An abstract class that defines the interface for a redlines processor.
+184    A redlines processor is a class that takes two documents and generates diff operations from them.
+185    Use this class as a base class if you want to create a custom redlines processor.
+186    See `WholeDocumentProcessor` for an example of a redlines processor.
+187    """
+188
+189    @abstractmethod
+190    def process(self, source: Document | str, test: Document | str) -> list[DiffOperation]:
+191        pass
+
+ + +

An abstract class that defines the interface for a redlines processor. +A redlines processor is a class that takes two documents and generates diff operations from them. +Use this class as a base class if you want to create a custom redlines processor. +See WholeDocumentProcessor for an example of a redlines processor.

+
+ + +
+ +
+
@abstractmethod
+ + def + process( self, source: redlines.document.Document | str, test: redlines.document.Document | str) -> list[DiffOperation]: + + + +
+ + 
189    @abstractmethod
+190    def process(self, source: Document | str, test: Document | str) -> list[DiffOperation]:
+191        pass
+
+ + + + +
+
+
+ +
+ + class + WholeDocumentProcessor(RedlinesProcessor): + + + +
+ + 
194class WholeDocumentProcessor(RedlinesProcessor):
+195    """
+196    A redlines processor that compares two documents. It compares the entire documents as a single chunk.
+197    """
+198
+199    def process(self, source: Document | str, test: Document | str) -> list[DiffOperation]:
+200        """
+201        Compare two documents as a single chunk.
+202
+203        :param source: The source document to compare.
+204        :type source: Document | str
+205        :param test: The test document to compare.
+206        :type test: Document | str
+207        :return: A list of `DiffOperation` that describe the differences between the two documents.
+208        :rtype: list[DiffOperation]
+209        """
+210        # Extract text from documents if needed
+211        source_text = source.text if isinstance(source, Document) else source
+212        test_text = test.text if isinstance(test, Document) else test
+213
+214        # Tokenize the texts
+215        source_tokens = tokenize_text(
+216            concatenate_paragraphs_and_add_chr_182(source_text)
+217        )
+218        test_tokens = tokenize_text(concatenate_paragraphs_and_add_chr_182(test_text))
+219
+220        # Normalize tokens by stripping whitespace for comparison
+221        # This allows the matcher to focus on content differences rather than whitespace variations
+222        # while still preserving the original tokens (including whitespace) for display in the output
+223        seq_source_normalized = [token.strip() for token in source_tokens]
+224        seq_test_normalized = [token.strip() for token in test_tokens]
+225
+226        matcher = SequenceMatcher(None, seq_source_normalized, seq_test_normalized)
+227
+228        return [
+229            DiffOperation(
+230                source_chunk=Chunk(text=source_tokens, chunk_location=None),
+231                test_chunk=Chunk(text=test_tokens, chunk_location=None),
+232                opcodes=opcode,
+233            )
+234            for opcode in matcher.get_opcodes()
+235        ]
+
+ + +

A redlines processor that compares two documents. It compares the entire documents as a single chunk.

+
+ + +
+ +
+ + def + process( self, source: redlines.document.Document | str, test: redlines.document.Document | str) -> list[DiffOperation]: + + + +
+ + 
199    def process(self, source: Document | str, test: Document | str) -> list[DiffOperation]:
+200        """
+201        Compare two documents as a single chunk.
+202
+203        :param source: The source document to compare.
+204        :type source: Document | str
+205        :param test: The test document to compare.
+206        :type test: Document | str
+207        :return: A list of `DiffOperation` that describe the differences between the two documents.
+208        :rtype: list[DiffOperation]
+209        """
+210        # Extract text from documents if needed
+211        source_text = source.text if isinstance(source, Document) else source
+212        test_text = test.text if isinstance(test, Document) else test
+213
+214        # Tokenize the texts
+215        source_tokens = tokenize_text(
+216            concatenate_paragraphs_and_add_chr_182(source_text)
+217        )
+218        test_tokens = tokenize_text(concatenate_paragraphs_and_add_chr_182(test_text))
+219
+220        # Normalize tokens by stripping whitespace for comparison
+221        # This allows the matcher to focus on content differences rather than whitespace variations
+222        # while still preserving the original tokens (including whitespace) for display in the output
+223        seq_source_normalized = [token.strip() for token in source_tokens]
+224        seq_test_normalized = [token.strip() for token in test_tokens]
+225
+226        matcher = SequenceMatcher(None, seq_source_normalized, seq_test_normalized)
+227
+228        return [
+229            DiffOperation(
+230                source_chunk=Chunk(text=source_tokens, chunk_location=None),
+231                test_chunk=Chunk(text=test_tokens, chunk_location=None),
+232                opcodes=opcode,
+233            )
+234            for opcode in matcher.get_opcodes()
+235        ]
+
+ + +

Compare two documents as a single chunk.

+ +
Parameters
+ +
    +
  • source: The source document to compare.
    • +
  • test: The test document to compare.
    • +
+ +
Returns
+ +
+

A list of DiffOperation that describe the differences between the two documents.

+
+
+ + +
+
+
+ +
+
@dataclass
+ + class + Redline: + + + +
+ + 
135@dataclass
+136class Redline:
+137    """
+138    A structured representation of a single change between source and test text.
+139
+140    This class provides a user-friendly interface for accessing diff information,
+141    with direct access to the changed text and position information.
+142    """
+143
+144    operation: Literal["delete", "insert", "replace"]
+145    """The type of change: 'delete', 'insert', or 'replace'"""
+146
+147    source_text: str | None
+148    """The text from the source document. Present for 'delete' and 'replace' operations."""
+149
+150    test_text: str | None
+151    """The text from the test document. Present for 'insert' and 'replace' operations."""
+152
+153    source_position: tuple[int, int] | None
+154    """Position in source tokens as (start, end). None for 'insert' operations."""
+155
+156    test_position: tuple[int, int] | None
+157    """Position in test tokens as (start, end). None for 'delete' operations."""
+
+ + +

A structured representation of a single change between source and test text.

+ +

This class provides a user-friendly interface for accessing diff information, +with direct access to the changed text and position information.

+
+ + +
+
+ + Redline( operation: Literal['delete', 'insert', 'replace'], source_text: str | None, test_text: str | None, source_position: tuple[int, int] | None, test_position: tuple[int, int] | None) + + +
+ + + + +
+
+
+ operation: Literal['delete', 'insert', 'replace'] + + +
+ + +

The type of change: 'delete', 'insert', or 'replace'

+
+ + +
+
+
+ source_text: str | None + + +
+ + +

The text from the source document. Present for 'delete' and 'replace' operations.

+
+ + +
+
+
+ test_text: str | None + + +
+ + +

The text from the test document. Present for 'insert' and 'replace' operations.

+
+ + +
+
+
+ source_position: tuple[int, int] | None + + +
+ + +

Position in source tokens as (start, end). None for 'insert' operations.

+
+ + +
+
+
+ test_position: tuple[int, int] | None + + +
+ + +

Position in test tokens as (start, end). None for 'delete' operations.

+
+ + +
+
+
+ +
+
@dataclass
+ + class + Stats: + + + +
+ + 
160@dataclass
+161class Stats:
+162    """
+163    Statistics about the changes between source and test text.
+164
+165    Provides a summary of all changes including counts by operation type.
+166    """
+167
+168    total_changes: int
+169    """Total number of changes (deletions + insertions + replacements)"""
+170
+171    deletions: int
+172    """Number of deletion operations"""
+173
+174    insertions: int
+175    """Number of insertion operations"""
+176
+177    replacements: int
+178    """Number of replacement operations"""
+
+ + +

Statistics about the changes between source and test text.

+ +

Provides a summary of all changes including counts by operation type.

+
+ + +
+
+ + Stats( total_changes: int, deletions: int, insertions: int, replacements: int) + + +
+ + + + +
+
+
+ total_changes: int + + +
+ + +

Total number of changes (deletions + insertions + replacements)

+
+ + +
+
+
+ deletions: int + + +
+ + +

Number of deletion operations

+
+ + +
+
+
+ insertions: int + + +
+ + +

Number of insertion operations

+
+ + +
+
+
+ replacements: int + + +
+ + +

Number of replacement operations

+
+ + +
+
+
+ +
+
@dataclass
+ + class + DiffOperation: + + + +
+ + 
124@dataclass
+125class DiffOperation:
+126    """Internal representation of a diff operation (includes 'equal' operations for rendering)"""
+127
+128    source_chunk: Chunk
+129    test_chunk: Chunk
+130    """The chunk of text that is being compared"""
+131    opcodes: tuple[str, int, int, int, int]
+132    """The opcodes that describe the operation. See the difflib documentation for more information"""
+
+ + +

Internal representation of a diff operation (includes 'equal' operations for rendering)

+
+ + +
+
+ + DiffOperation( source_chunk: Chunk, test_chunk: Chunk, opcodes: tuple[str, int, int, int, int]) + + +
+ + + + +
+
+
+ source_chunk: Chunk + + +
+ + + + +
+
+
+ test_chunk: Chunk + + +
+ + +

The chunk of text that is being compared

+
+ + +
+
+
+ opcodes: tuple[str, int, int, int, int] + + +
+ + +

The opcodes that describe the operation. See the difflib documentation for more information

+
+ + +
+
+
+ +
+
@dataclass
+ + class + Chunk: + + + +
+ + 
114@dataclass
+115class Chunk:
+116    """A chunk of text that is being compared. In some cases, it may be the whole document"""
+117
+118    text: list[str]
+119    """The tokens of the chunk"""
+120    chunk_location: str | None
+121    """An optional string describing the location of the chunk in the document. For example, a PDF page number"""
+
+ + +

A chunk of text that is being compared. In some cases, it may be the whole document

+
+ + +
+
+ + Chunk(text: list[str], chunk_location: str | None) + + +
+ + + + +
+
+
+ text: list[str] + + +
+ + +

The tokens of the chunk

+
+ + +
+
+
+ chunk_location: str | None + + +
+ + +

An optional string describing the location of the chunk in the document. For example, a PDF page number

+
+ + +
+
+
+ + \ No newline at end of file diff --git a/docs/generated-docs/redlines/redlines.html b/docs/generated-docs/redlines/redlines.html new file mode 100644 index 0000000..58538fb --- /dev/null +++ b/docs/generated-docs/redlines/redlines.html @@ -0,0 +1,2488 @@ + + + + + + + redlines.redlines API documentation + + + + + + + + + +
+
+

+redlines.redlines

+ + + + + + + 
  1from __future__ import annotations
+  2
+  3import re
+  4import typing as t
+  5
+  6from rich.text import Text
+  7from typing_extensions import Unpack
+  8
+  9from .document import Document
+ 10from .enums import MarkdownStyle, OutputType
+ 11from .processor import DiffOperation, Redline, Stats, WholeDocumentProcessor
+ 12
+ 13__all__: tuple[str, ...] = (
+ 14    "Redlines",
+ 15    "RedlinesOptions",
+ 16)
+ 17
+ 18# Workaround for enum + literal support in type hints
+ 19# See: https://github.com/python/typing/issues/781
+ 20OutputTypeLike = OutputType | t.Literal["markdown", "rich"]
+ 21
+ 22
+ 23class RedlinesOptions(t.TypedDict, total=False):
+ 24    markdown_style: str | MarkdownStyle | None
+ 25    """The style to use for markdown output. See `Redlines.output_markdown` for more information."""
+ 26    ins_class: str
+ 27    """The CSS class to use for insertions when `markdown_style` is set to `custom_css`. Defaults to 'redline-inserted'."""
+ 28    del_class: str
+ 29    """The CSS class to use for deletions when `markdown_style` is set to `custom_css`. Defaults to 'redline-deleted'."""
+ 30
+ 31
+ 32class Redlines:
+ 33    _source: str | None = None
+ 34    _test: str | None = None
+ 35    _seq1: list[str] | None = None
+ 36    _seq2: list[str] | None = None
+ 37    _diff_operations: list[DiffOperation] | None = None
+ 38
+ 39    @property
+ 40    def source(self) -> str:
+ 41        """
+ 42        Get the source text to be used as a basis for comparison.
+ 43
+ 44        :return: The source text to be used as a basis for comparison.
+ 45        :rtype: str
+ 46        """
+ 47        if self._source is None:
+ 48            raise ValueError("No source string was provided.")
+ 49        return self._source
+ 50
+ 51    @source.setter
+ 52    def source(self, value: str | Document) -> None:
+ 53        self._source = value.text if isinstance(value, Document) else value
+ 54
+ 55        # If test is already set, process the new source against it
+ 56        if self._test is not None:
+ 57            self._diff_operations = self.processor.process(self._source, self._test)
+ 58
+ 59    @property
+ 60    def test(self) -> str:
+ 61        """
+ 62        Get the text to be compared with the source.
+ 63
+ 64        :return: The text to be compared with the source.
+ 65        :rtype: str
+ 66        """
+ 67        if self._test is None:
+ 68            raise ValueError("No test string was provided.")
+ 69        return self._test
+ 70
+ 71    @test.setter
+ 72    def test(self, value: str | Document) -> None:
+ 73        self._test = value.text if isinstance(value, Document) else value
+ 74
+ 75        # Process the text against the source
+ 76        if self._source is not None:
+ 77            self._diff_operations = self.processor.process(self._source, self._test)
+ 78
+ 79    @property
+ 80    def _diff_ops(self) -> list[DiffOperation]:
+ 81        """
+ 82        Internal property: Return the list of DiffOperation objects (includes 'equal' operations).
+ 83        For internal rendering code.
+ 84
+ 85        :return: List of DiffOperation objects
+ 86        """
+ 87        if self._diff_operations is None:
+ 88            raise ValueError(
+ 89                "No test string was provided when the function was called, or during initialisation."
+ 90            )
+ 91        return self._diff_operations
+ 92
+ 93    @property
+ 94    def redlines(self) -> list[Redline]:
+ 95        """
+ 96        Return the list of Redline objects representing actual changes between source and test.
+ 97
+ 98        This is an alias for the `changes` property and provides the same functionality.
+ 99        Only actual changes are returned (equal operations are excluded).
+100
+101        :return: List of Redline objects
+102        :rtype: list[Redline]
+103        """
+104        return self.changes
+105
+106    def __init__(
+107        self,
+108        source: str | Document,
+109        test: str | Document | None = None,
+110        **options: Unpack[RedlinesOptions],
+111    ):
+112        """
+113        Redline is a class used to compare text, and producing human-readable differences or deltas
+114        which look like track changes in Microsoft Word.
+115
+116        ```python
+117        # import the class
+118        from redlines import Redlines
+119
+120        # Create a Redlines object using the two strings to compare
+121        test = Redlines(
+122            "The quick brown fox jumps over the lazy dog.",
+123            "The quick brown fox walks past the lazy dog.",
+124        )
+125
+126        # This produces an output in Markdown format
+127        test.output_markdown
+128        ```
+129
+130        Besides strings, Redlines can also receive an input in another format if it is supported by the Document class
+131
+132        ```python
+133        from redlines import PlainTextFile
+134
+135        source = PlainTextFile("tests/documents/PlainTextFile/source.txt")
+136        test = PlainTextFile("tests/documents/PlainTextFile/test.txt")
+137
+138        redline = Redlines(source, test)
+139        assert (
+140            redline.output_markdown
+141            == "The quick brown fox <span style='color:red;font-weight:700;text-decoration:line-through;'>jumps over </span><span style='color:green;font-weight:700;'>walks past </span>the lazy dog."
+142        )
+143
+144        ```
+145
+146        :param source: The source text to be used as a basis for comparison.
+147        :type source: str | Document
+148        :param test: Optional test text to compare with the source.
+149        :type test: str | Document | None
+150        :param options: Additional options for comparison and output formatting.
+151        :type options: RedlinesOptions
+152        """
+153        self.processor = WholeDocumentProcessor()
+154        self.source = source.text if isinstance(source, Document) else source
+155        self.options = options
+156        self._diff_operations = None
+157        if test:
+158            self.test = test.text if isinstance(test, Document) else test
+159            # self.compare()
+160
+161    @property
+162    def opcodes(self) -> list[tuple[str, int, int, int, int]]:
+163        """
+164        Return list of 5-tuples describing how to turn `source` into `test`.
+165        Similar to [`SequenceMatcher.get_opcodes`](https://docs.python.org/3/library/difflib.html#difflib.SequenceMatcher.get_opcodes).
+166
+167        ```pycon
+168        >>> test_string_1 = 'The quick brown fox jumps over the lazy dog.'
+169        ... test_string_2 = 'The quick brown fox walks past the lazy dog.'
+170        ... s = Redlines(test_string_1, test_string_2)
+171        ... s.opcodes
+172        [('equal', 0, 4, 0, 4), ('replace', 4, 6, 4, 6), ('equal', 6, 9, 6, 9)]
+173        ```
+174
+175        :return: List of 5-tuples describing how to turn `source` into `test`.
+176        :rtype: list[tuple[str, int, int, int, int]]
+177        """
+178        return [diff_op.opcodes for diff_op in self._diff_ops]
+179
+180    @property
+181    def changes(self) -> list[Redline]:
+182        """
+183        Return list of Redline objects representing the differences between source and test.
+184
+185        This provides a user-friendly interface for programmatically accessing changes,
+186        with direct access to the changed text and position information. Only actual
+187        changes are returned (equal operations are excluded).
+188
+189        ```python
+190        from redlines import Redlines
+191
+192        test = Redlines(
+193            "The quick brown fox jumps over the lazy dog.",
+194            "The quick brown fox walks past the lazy dog."
+195        )
+196
+197        for redline in test.changes:
+198            print(f"{redline.operation}: {redline.source_text} -> {redline.test_text}")
+199        # Output: replace: jumps over  -> walks past
+200        ```
+201
+202        :return: List of Redline objects (only actual changes, no 'equal' operations)
+203        """
+204        result = []
+205        for diff_op in self._diff_ops:
+206            tag, i1, i2, j1, j2 = diff_op.opcodes
+207
+208            # Skip equal operations - only return actual changes
+209            if tag == "equal":
+210                continue
+211
+212            source_tokens = diff_op.source_chunk.text
+213            test_tokens = diff_op.test_chunk.text
+214
+215            # Extract text and positions based on operation type
+216            if tag == "delete":
+217                redline = Redline(
+218                    operation="delete",
+219                    source_text="".join(source_tokens[i1:i2]),
+220                    test_text=None,
+221                    source_position=(i1, i2),
+222                    test_position=None,
+223                )
+224            elif tag == "insert":
+225                redline = Redline(
+226                    operation="insert",
+227                    source_text=None,
+228                    test_text="".join(test_tokens[j1:j2]),
+229                    source_position=None,
+230                    test_position=(j1, j2),
+231                )
+232            elif tag == "replace":
+233                redline = Redline(
+234                    operation="replace",
+235                    source_text="".join(source_tokens[i1:i2]),
+236                    test_text="".join(test_tokens[j1:j2]),
+237                    source_position=(i1, i2),
+238                    test_position=(j1, j2),
+239                )
+240            else:
+241                continue
+242
+243            result.append(redline)
+244
+245        return result
+246
+247    def get_changes(
+248        self, operation: str | None = None
+249    ) -> list[Redline]:
+250        """
+251        Get changes (redlines), optionally filtered by operation type.
+252
+253        ```python
+254        from redlines import Redlines
+255
+256        test = Redlines(
+257            "The quick brown fox jumps over the lazy dog.",
+258            "The quick brown fox walks past the lazy dog."
+259        )
+260
+261        # Get all changes
+262        all_changes = test.get_changes()
+263
+264        # Get only replacements
+265        replacements = test.get_changes(operation="replace")
+266
+267        # Get deletions
+268        deletions = test.get_changes(operation="delete")
+269
+270        # Get insertions
+271        insertions = test.get_changes(operation="insert")
+272        ```
+273
+274        :param operation: Filter by operation type: "delete", "insert", or "replace". If None, returns all changes.
+275        :return: List of Redline objects matching the filter
+276        """
+277        changes = self.changes
+278
+279        if operation is None:
+280            return changes
+281
+282        if operation not in ("delete", "insert", "replace"):
+283            raise ValueError(
+284                f"Invalid operation '{operation}'. Must be 'delete', 'insert', or 'replace'."
+285            )
+286
+287        return [r for r in changes if r.operation == operation]
+288
+289    def stats(self) -> Stats:
+290        """
+291        Get statistics about the changes between source and test.
+292
+293        ```python
+294        from redlines import Redlines
+295
+296        test = Redlines(
+297            "The quick brown fox jumps over the lazy dog.",
+298            "The quick brown fox walks past the lazy dog."
+299        )
+300
+301        stats = test.stats()
+302        print(f"Total changes: {stats.total_changes}")
+303        print(f"Deletions: {stats.deletions}")
+304        print(f"Insertions: {stats.insertions}")
+305        print(f"Replacements: {stats.replacements}")
+306        ```
+307
+308        :return: Stats object with change counts
+309        """
+310        changes = self.changes
+311
+312        deletions = sum(1 for c in changes if c.operation == "delete")
+313        insertions = sum(1 for c in changes if c.operation == "insert")
+314        replacements = sum(1 for c in changes if c.operation == "replace")
+315
+316        return Stats(
+317            total_changes=len(changes),
+318            deletions=deletions,
+319            insertions=insertions,
+320            replacements=replacements,
+321        )
+322
+323    @property
+324    def output_markdown(self) -> str:
+325        """
+326        Returns the delta in Markdown format.
+327
+328        ## Styling Markdown
+329        To output markdown in a particular manner, you must pass a `markdown_style` option when the `Redlines` object
+330        is created or when `Redlines.compare` is called.
+331
+332        ```python
+333        from redlines import Redlines
+334
+335        test = Redlines(
+336            "The quick brown fox jumps over the lazy dog.",
+337            "The quick brown fox walks past the lazy dog.",
+338            markdown_style="red"  # This option specifies the style as red
+339        )
+340
+341        test.compare(markdown_style="none") # This option specifies the style as none
+342        ```
+343
+344        ### Available styles
+345
+346        | Style | Preview |
+347        |-------| -------|
+348        |red-green (**default**) | "The quick brown fox <span style='color:red;font-weight:700;text-decoration:line-through;'>jumps over </span><span style='color:green;font-weight:700;'>walks past </span>the lazy dog."|
+349        |none | 'The quick brown fox <del>jumps over </del><ins>walks past </ins>the lazy dog.'|
+350        |red | "The quick brown fox <span style='color:red;font-weight:700;text-decoration:line-through;'>jumps over </span><span style='color:red;font-weight:700;'>walks past </span>the lazy dog."|
+351        |ghfm (GitHub Flavored Markdown)| 'The quick brown fox ~~jumps over ~~**walks past **the lazy dog.' |
+352        |bbcode (BBCode) | 'The quick brown fox [s][color=red]jumps over [/color][/s][b][color=green]walks past [/color][/b]the lazy dog.' |
+353        |streamlit | 'The quick brown fox ~~:red[jumps over ]~~ **:green[walks past ]** the lazy dog.' |
+354
+355        ### Custom styling
+356
+357        You can also use css classes to provide custom styling by setting `markdown_style` as "custom_css".
+358        Insertions and deletions are now styled using the "redline-inserted" and "redline-deleted" CSS classes.
+359        You can also set your own CSS classes by specifying the name of the CSS class in the options `ins_class`
+360        and `del_class` respectively in the constructor or compare function.
+361
+362        ## Markdown output in specific environments
+363
+364        Users have reported that the output doesn't display correctly in their environments.
+365        This is because styling may not appear in markdown environments which disallow HTML.
+366        There is no consistent support for strikethroughs and colors in the markdown standard,
+367        and styling is largely accomplished through raw HTML. If you are using GitHub or Streamlit, you may not get
+368        the formatting you expect or see any change at all.
+369
+370        If you are facing this kind of difficulty, here are some recommendations. If your experience doesn't match
+371        the hints or description below, or you continue to face problems, please raise an issue.
+372
+373        ### Jupyter Notebooks
+374        This library was first written for the Jupyter notebook environment, so all the available styles, including
+375        the default (`red-green`), `red` and `none` work.
+376
+377        ### Streamlit
+378
+379        Try this:
+380
+381        * If streamlit version is >= 1.16.0, consider the markdown style "streamlit"
+382        * If streamlit version is < 1.16.0, consider the markdown style `ghfm`
+383        * Enable parsing of HTML. In Streamlit, you need to set the `unsafe_allow_html` argument in `st.write` or
+384        `st.markdown` to `True`.
+385
+386        ### Colab
+387
+388        Try this:
+389        * Use the markdown style `none` or `ghfm`
+390        * `Redlines.output_rich` has been reported to work in Colab
+391
+392        :return: The delta in Markdown format.
+393        :rtype: str
+394        """
+395        result: list[str] = []
+396
+397        # default_style = "red_green"
+398
+399        md_styles = {
+400            "ins": (
+401                f"<span style='color:green;font-weight:700;'>",
+402                "</span>",
+403            ),
+404            "del": (
+405                f"<span style='color:red;font-weight:700;text-decoration:line-through;'>",
+406                "</span>",
+407            ),
+408        }
+409
+410        if "markdown_style" in self.options:
+411            style = self.options["markdown_style"]
+412
+413            if style == "none" or style is None:
+414                md_styles = {"ins": ("<ins>", "</ins>"), "del": ("<del>", "</del>")}
+415            elif style == "red":
+416                md_styles = {
+417                    "ins": (
+418                        f"<span style='color:red;font-weight:700;'>",
+419                        "</span>",
+420                    ),
+421                    "del": (
+422                        f"<span style='color:red;font-weight:700;text-decoration:line-through;'>",
+423                        "</span>",
+424                    ),
+425                }
+426            elif style == "custom_css":
+427                ins_class = (
+428                    self.options["ins_class"]
+429                    if "ins_class" in self.options
+430                    else "redline-inserted"
+431                )
+432                del_class = (
+433                    self.options["del_class"]
+434                    if "del_class" in self.options
+435                    else "redline-deleted"
+436                )
+437
+438                elem_attributes = {
+439                    "ins": f"class='{ins_class}'",
+440                    "del": f"class='{del_class}'",
+441                }
+442
+443                md_styles = {
+444                    "ins": (
+445                        f"<span {elem_attributes['ins']}>",
+446                        "</span>",
+447                    ),
+448                    "del": (
+449                        f"<span {elem_attributes['del']}>",
+450                        "</span>",
+451                    ),
+452                }
+453            elif style == "ghfm":
+454                md_styles = {"ins": ("**", "**"), "del": ("~~", "~~")}
+455            elif style == "bbcode":
+456                md_styles = {
+457                    "ins": ("[b][color=green]", "[/color][/b]"),
+458                    "del": ("[s][color=red]", "[/color][/s]"),
+459                }
+460            elif style == "streamlit":
+461                md_styles = {"ins": ("**:green[", "]** "), "del": ("~~:red[", "]~~ ")}
+462
+463        for diff_op in self._diff_ops:
+464            tag, i1, i2, j1, j2 = diff_op.opcodes
+465            source_tokens = diff_op.source_chunk.text
+466            test_tokens = diff_op.test_chunk.text
+467
+468            if tag == "equal":
+469                temp_str = "".join(source_tokens[i1:i2])
+470                temp_str = re.sub("¶ ", "\n\n", temp_str)
+471                # here we use '¶ ' instead of ' ¶ ', because the leading space will be included in the previous token,
+472                # according to tokenizer = re.compile(r"((?:[^()\s]+|[().?!-])\s*)")
+473                result.append(temp_str)
+474            elif tag == "insert":
+475                temp_str = "".join(test_tokens[j1:j2])
+476                splits = re.split("¶ ", temp_str)
+477                for split in splits:
+478                    result.append(f"{md_styles['ins'][0]}{split}{md_styles['ins'][1]}")
+479                    result.append("\n\n")
+480                if len(splits) > 0:
+481                    result.pop()
+482            elif tag == "delete":
+483                result.append(
+484                    f"{md_styles['del'][0]}{''.join(source_tokens[i1:i2])}{md_styles['del'][1]}"
+485                )
+486                # for 'delete', we make no change, because otherwise there will be two times '\n\n' than the original
+487                # text.
+488            elif tag == "replace":
+489                result.append(
+490                    f"{md_styles['del'][0]}{''.join(source_tokens[i1:i2])}{md_styles['del'][1]}"
+491                )
+492                temp_str = "".join(test_tokens[j1:j2])
+493                splits = re.split("¶ ", temp_str)
+494                for split in splits:
+495                    result.append(f"{md_styles['ins'][0]}{split}{md_styles['ins'][1]}")
+496                    result.append("\n\n")
+497                if len(splits) > 0:
+498                    result.pop()
+499
+500        return "".join(result)
+501
+502    @property
+503    def output_rich(self) -> Text:
+504        """
+505        Returns the delta in text with colors/style for the console.
+506
+507        :return: The delta in text with colors/style for the console.
+508        :rtype: Text
+509        """
+510        console_text = Text()
+511
+512        for diff_op in self._diff_ops:
+513            tag, i1, i2, j1, j2 = diff_op.opcodes
+514            source_tokens = diff_op.source_chunk.text
+515            test_tokens = diff_op.test_chunk.text
+516
+517            if tag == "equal":
+518                temp_str = "".join(source_tokens[i1:i2])
+519                temp_str = re.sub("¶ ", "\n\n", temp_str)
+520                console_text.append(temp_str)
+521            elif tag == "insert":
+522                temp_str = "".join(test_tokens[j1:j2])
+523                splits = re.split("¶ ", temp_str)
+524                for split in splits:
+525                    console_text.append(split, "green")
+526            elif tag == "delete":
+527                console_text.append("".join(source_tokens[i1:i2]), "strike red")
+528            elif tag == "replace":
+529                console_text.append("".join(source_tokens[i1:i2]), "strike red")
+530                temp_str = "".join(test_tokens[j1:j2])
+531                splits = re.split("¶ ", temp_str)
+532                for split in splits:
+533                    console_text.append(split, "green")
+534
+535        return console_text
+536
+537    def compare(
+538        self,
+539        test: str | None = None,
+540        output: OutputTypeLike = OutputType.MARKDOWN,
+541        **options: Unpack[RedlinesOptions],
+542    ) -> Text | str:
+543        """
+544        Compare `test` with `source`, and produce a delta in a format specified by `output`.
+545
+546        :param test: Optional test string to compare. If None, uses the test string provided during initialisation.
+547        :type test: str | None
+548        :param output: The format which the delta should be produced. Currently, "markdown" and "rich" are supported. Defaults to "markdown".
+549        :type output: OutputTypeLike
+550        :param options: Additional options for comparison and output formatting.
+551        :type options: RedlinesOptions
+552        :return: The delta in the format specified by `output`.
+553        :rtype: Text | str
+554        """
+555        if options:
+556            self.options = options
+557
+558        if test:
+559            if self._test and test == self._test:
+560                # If we've already processed this test string, no need to reprocess
+561                pass
+562            else:
+563                self.test = test
+564        elif self._test is None:
+565            raise ValueError(
+566                "No test string was provided when the function was called, or during initialisation."
+567            )
+568
+569        if output == OutputType.MARKDOWN:
+570            return self.output_markdown
+571        elif output == OutputType.RICH:
+572            return self.output_rich
+573        return self.output_markdown
+
+ + +
+
+ +
+ + class + Redlines: + + + +
+ + 
 33class Redlines:
+ 34    _source: str | None = None
+ 35    _test: str | None = None
+ 36    _seq1: list[str] | None = None
+ 37    _seq2: list[str] | None = None
+ 38    _diff_operations: list[DiffOperation] | None = None
+ 39
+ 40    @property
+ 41    def source(self) -> str:
+ 42        """
+ 43        Get the source text to be used as a basis for comparison.
+ 44
+ 45        :return: The source text to be used as a basis for comparison.
+ 46        :rtype: str
+ 47        """
+ 48        if self._source is None:
+ 49            raise ValueError("No source string was provided.")
+ 50        return self._source
+ 51
+ 52    @source.setter
+ 53    def source(self, value: str | Document) -> None:
+ 54        self._source = value.text if isinstance(value, Document) else value
+ 55
+ 56        # If test is already set, process the new source against it
+ 57        if self._test is not None:
+ 58            self._diff_operations = self.processor.process(self._source, self._test)
+ 59
+ 60    @property
+ 61    def test(self) -> str:
+ 62        """
+ 63        Get the text to be compared with the source.
+ 64
+ 65        :return: The text to be compared with the source.
+ 66        :rtype: str
+ 67        """
+ 68        if self._test is None:
+ 69            raise ValueError("No test string was provided.")
+ 70        return self._test
+ 71
+ 72    @test.setter
+ 73    def test(self, value: str | Document) -> None:
+ 74        self._test = value.text if isinstance(value, Document) else value
+ 75
+ 76        # Process the text against the source
+ 77        if self._source is not None:
+ 78            self._diff_operations = self.processor.process(self._source, self._test)
+ 79
+ 80    @property
+ 81    def _diff_ops(self) -> list[DiffOperation]:
+ 82        """
+ 83        Internal property: Return the list of DiffOperation objects (includes 'equal' operations).
+ 84        For internal rendering code.
+ 85
+ 86        :return: List of DiffOperation objects
+ 87        """
+ 88        if self._diff_operations is None:
+ 89            raise ValueError(
+ 90                "No test string was provided when the function was called, or during initialisation."
+ 91            )
+ 92        return self._diff_operations
+ 93
+ 94    @property
+ 95    def redlines(self) -> list[Redline]:
+ 96        """
+ 97        Return the list of Redline objects representing actual changes between source and test.
+ 98
+ 99        This is an alias for the `changes` property and provides the same functionality.
+100        Only actual changes are returned (equal operations are excluded).
+101
+102        :return: List of Redline objects
+103        :rtype: list[Redline]
+104        """
+105        return self.changes
+106
+107    def __init__(
+108        self,
+109        source: str | Document,
+110        test: str | Document | None = None,
+111        **options: Unpack[RedlinesOptions],
+112    ):
+113        """
+114        Redline is a class used to compare text, and producing human-readable differences or deltas
+115        which look like track changes in Microsoft Word.
+116
+117        ```python
+118        # import the class
+119        from redlines import Redlines
+120
+121        # Create a Redlines object using the two strings to compare
+122        test = Redlines(
+123            "The quick brown fox jumps over the lazy dog.",
+124            "The quick brown fox walks past the lazy dog.",
+125        )
+126
+127        # This produces an output in Markdown format
+128        test.output_markdown
+129        ```
+130
+131        Besides strings, Redlines can also receive an input in another format if it is supported by the Document class
+132
+133        ```python
+134        from redlines import PlainTextFile
+135
+136        source = PlainTextFile("tests/documents/PlainTextFile/source.txt")
+137        test = PlainTextFile("tests/documents/PlainTextFile/test.txt")
+138
+139        redline = Redlines(source, test)
+140        assert (
+141            redline.output_markdown
+142            == "The quick brown fox <span style='color:red;font-weight:700;text-decoration:line-through;'>jumps over </span><span style='color:green;font-weight:700;'>walks past </span>the lazy dog."
+143        )
+144
+145        ```
+146
+147        :param source: The source text to be used as a basis for comparison.
+148        :type source: str | Document
+149        :param test: Optional test text to compare with the source.
+150        :type test: str | Document | None
+151        :param options: Additional options for comparison and output formatting.
+152        :type options: RedlinesOptions
+153        """
+154        self.processor = WholeDocumentProcessor()
+155        self.source = source.text if isinstance(source, Document) else source
+156        self.options = options
+157        self._diff_operations = None
+158        if test:
+159            self.test = test.text if isinstance(test, Document) else test
+160            # self.compare()
+161
+162    @property
+163    def opcodes(self) -> list[tuple[str, int, int, int, int]]:
+164        """
+165        Return list of 5-tuples describing how to turn `source` into `test`.
+166        Similar to [`SequenceMatcher.get_opcodes`](https://docs.python.org/3/library/difflib.html#difflib.SequenceMatcher.get_opcodes).
+167
+168        ```pycon
+169        >>> test_string_1 = 'The quick brown fox jumps over the lazy dog.'
+170        ... test_string_2 = 'The quick brown fox walks past the lazy dog.'
+171        ... s = Redlines(test_string_1, test_string_2)
+172        ... s.opcodes
+173        [('equal', 0, 4, 0, 4), ('replace', 4, 6, 4, 6), ('equal', 6, 9, 6, 9)]
+174        ```
+175
+176        :return: List of 5-tuples describing how to turn `source` into `test`.
+177        :rtype: list[tuple[str, int, int, int, int]]
+178        """
+179        return [diff_op.opcodes for diff_op in self._diff_ops]
+180
+181    @property
+182    def changes(self) -> list[Redline]:
+183        """
+184        Return list of Redline objects representing the differences between source and test.
+185
+186        This provides a user-friendly interface for programmatically accessing changes,
+187        with direct access to the changed text and position information. Only actual
+188        changes are returned (equal operations are excluded).
+189
+190        ```python
+191        from redlines import Redlines
+192
+193        test = Redlines(
+194            "The quick brown fox jumps over the lazy dog.",
+195            "The quick brown fox walks past the lazy dog."
+196        )
+197
+198        for redline in test.changes:
+199            print(f"{redline.operation}: {redline.source_text} -> {redline.test_text}")
+200        # Output: replace: jumps over  -> walks past
+201        ```
+202
+203        :return: List of Redline objects (only actual changes, no 'equal' operations)
+204        """
+205        result = []
+206        for diff_op in self._diff_ops:
+207            tag, i1, i2, j1, j2 = diff_op.opcodes
+208
+209            # Skip equal operations - only return actual changes
+210            if tag == "equal":
+211                continue
+212
+213            source_tokens = diff_op.source_chunk.text
+214            test_tokens = diff_op.test_chunk.text
+215
+216            # Extract text and positions based on operation type
+217            if tag == "delete":
+218                redline = Redline(
+219                    operation="delete",
+220                    source_text="".join(source_tokens[i1:i2]),
+221                    test_text=None,
+222                    source_position=(i1, i2),
+223                    test_position=None,
+224                )
+225            elif tag == "insert":
+226                redline = Redline(
+227                    operation="insert",
+228                    source_text=None,
+229                    test_text="".join(test_tokens[j1:j2]),
+230                    source_position=None,
+231                    test_position=(j1, j2),
+232                )
+233            elif tag == "replace":
+234                redline = Redline(
+235                    operation="replace",
+236                    source_text="".join(source_tokens[i1:i2]),
+237                    test_text="".join(test_tokens[j1:j2]),
+238                    source_position=(i1, i2),
+239                    test_position=(j1, j2),
+240                )
+241            else:
+242                continue
+243
+244            result.append(redline)
+245
+246        return result
+247
+248    def get_changes(
+249        self, operation: str | None = None
+250    ) -> list[Redline]:
+251        """
+252        Get changes (redlines), optionally filtered by operation type.
+253
+254        ```python
+255        from redlines import Redlines
+256
+257        test = Redlines(
+258            "The quick brown fox jumps over the lazy dog.",
+259            "The quick brown fox walks past the lazy dog."
+260        )
+261
+262        # Get all changes
+263        all_changes = test.get_changes()
+264
+265        # Get only replacements
+266        replacements = test.get_changes(operation="replace")
+267
+268        # Get deletions
+269        deletions = test.get_changes(operation="delete")
+270
+271        # Get insertions
+272        insertions = test.get_changes(operation="insert")
+273        ```
+274
+275        :param operation: Filter by operation type: "delete", "insert", or "replace". If None, returns all changes.
+276        :return: List of Redline objects matching the filter
+277        """
+278        changes = self.changes
+279
+280        if operation is None:
+281            return changes
+282
+283        if operation not in ("delete", "insert", "replace"):
+284            raise ValueError(
+285                f"Invalid operation '{operation}'. Must be 'delete', 'insert', or 'replace'."
+286            )
+287
+288        return [r for r in changes if r.operation == operation]
+289
+290    def stats(self) -> Stats:
+291        """
+292        Get statistics about the changes between source and test.
+293
+294        ```python
+295        from redlines import Redlines
+296
+297        test = Redlines(
+298            "The quick brown fox jumps over the lazy dog.",
+299            "The quick brown fox walks past the lazy dog."
+300        )
+301
+302        stats = test.stats()
+303        print(f"Total changes: {stats.total_changes}")
+304        print(f"Deletions: {stats.deletions}")
+305        print(f"Insertions: {stats.insertions}")
+306        print(f"Replacements: {stats.replacements}")
+307        ```
+308
+309        :return: Stats object with change counts
+310        """
+311        changes = self.changes
+312
+313        deletions = sum(1 for c in changes if c.operation == "delete")
+314        insertions = sum(1 for c in changes if c.operation == "insert")
+315        replacements = sum(1 for c in changes if c.operation == "replace")
+316
+317        return Stats(
+318            total_changes=len(changes),
+319            deletions=deletions,
+320            insertions=insertions,
+321            replacements=replacements,
+322        )
+323
+324    @property
+325    def output_markdown(self) -> str:
+326        """
+327        Returns the delta in Markdown format.
+328
+329        ## Styling Markdown
+330        To output markdown in a particular manner, you must pass a `markdown_style` option when the `Redlines` object
+331        is created or when `Redlines.compare` is called.
+332
+333        ```python
+334        from redlines import Redlines
+335
+336        test = Redlines(
+337            "The quick brown fox jumps over the lazy dog.",
+338            "The quick brown fox walks past the lazy dog.",
+339            markdown_style="red"  # This option specifies the style as red
+340        )
+341
+342        test.compare(markdown_style="none") # This option specifies the style as none
+343        ```
+344
+345        ### Available styles
+346
+347        | Style | Preview |
+348        |-------| -------|
+349        |red-green (**default**) | "The quick brown fox <span style='color:red;font-weight:700;text-decoration:line-through;'>jumps over </span><span style='color:green;font-weight:700;'>walks past </span>the lazy dog."|
+350        |none | 'The quick brown fox <del>jumps over </del><ins>walks past </ins>the lazy dog.'|
+351        |red | "The quick brown fox <span style='color:red;font-weight:700;text-decoration:line-through;'>jumps over </span><span style='color:red;font-weight:700;'>walks past </span>the lazy dog."|
+352        |ghfm (GitHub Flavored Markdown)| 'The quick brown fox ~~jumps over ~~**walks past **the lazy dog.' |
+353        |bbcode (BBCode) | 'The quick brown fox [s][color=red]jumps over [/color][/s][b][color=green]walks past [/color][/b]the lazy dog.' |
+354        |streamlit | 'The quick brown fox ~~:red[jumps over ]~~ **:green[walks past ]** the lazy dog.' |
+355
+356        ### Custom styling
+357
+358        You can also use css classes to provide custom styling by setting `markdown_style` as "custom_css".
+359        Insertions and deletions are now styled using the "redline-inserted" and "redline-deleted" CSS classes.
+360        You can also set your own CSS classes by specifying the name of the CSS class in the options `ins_class`
+361        and `del_class` respectively in the constructor or compare function.
+362
+363        ## Markdown output in specific environments
+364
+365        Users have reported that the output doesn't display correctly in their environments.
+366        This is because styling may not appear in markdown environments which disallow HTML.
+367        There is no consistent support for strikethroughs and colors in the markdown standard,
+368        and styling is largely accomplished through raw HTML. If you are using GitHub or Streamlit, you may not get
+369        the formatting you expect or see any change at all.
+370
+371        If you are facing this kind of difficulty, here are some recommendations. If your experience doesn't match
+372        the hints or description below, or you continue to face problems, please raise an issue.
+373
+374        ### Jupyter Notebooks
+375        This library was first written for the Jupyter notebook environment, so all the available styles, including
+376        the default (`red-green`), `red` and `none` work.
+377
+378        ### Streamlit
+379
+380        Try this:
+381
+382        * If streamlit version is >= 1.16.0, consider the markdown style "streamlit"
+383        * If streamlit version is < 1.16.0, consider the markdown style `ghfm`
+384        * Enable parsing of HTML. In Streamlit, you need to set the `unsafe_allow_html` argument in `st.write` or
+385        `st.markdown` to `True`.
+386
+387        ### Colab
+388
+389        Try this:
+390        * Use the markdown style `none` or `ghfm`
+391        * `Redlines.output_rich` has been reported to work in Colab
+392
+393        :return: The delta in Markdown format.
+394        :rtype: str
+395        """
+396        result: list[str] = []
+397
+398        # default_style = "red_green"
+399
+400        md_styles = {
+401            "ins": (
+402                f"<span style='color:green;font-weight:700;'>",
+403                "</span>",
+404            ),
+405            "del": (
+406                f"<span style='color:red;font-weight:700;text-decoration:line-through;'>",
+407                "</span>",
+408            ),
+409        }
+410
+411        if "markdown_style" in self.options:
+412            style = self.options["markdown_style"]
+413
+414            if style == "none" or style is None:
+415                md_styles = {"ins": ("<ins>", "</ins>"), "del": ("<del>", "</del>")}
+416            elif style == "red":
+417                md_styles = {
+418                    "ins": (
+419                        f"<span style='color:red;font-weight:700;'>",
+420                        "</span>",
+421                    ),
+422                    "del": (
+423                        f"<span style='color:red;font-weight:700;text-decoration:line-through;'>",
+424                        "</span>",
+425                    ),
+426                }
+427            elif style == "custom_css":
+428                ins_class = (
+429                    self.options["ins_class"]
+430                    if "ins_class" in self.options
+431                    else "redline-inserted"
+432                )
+433                del_class = (
+434                    self.options["del_class"]
+435                    if "del_class" in self.options
+436                    else "redline-deleted"
+437                )
+438
+439                elem_attributes = {
+440                    "ins": f"class='{ins_class}'",
+441                    "del": f"class='{del_class}'",
+442                }
+443
+444                md_styles = {
+445                    "ins": (
+446                        f"<span {elem_attributes['ins']}>",
+447                        "</span>",
+448                    ),
+449                    "del": (
+450                        f"<span {elem_attributes['del']}>",
+451                        "</span>",
+452                    ),
+453                }
+454            elif style == "ghfm":
+455                md_styles = {"ins": ("**", "**"), "del": ("~~", "~~")}
+456            elif style == "bbcode":
+457                md_styles = {
+458                    "ins": ("[b][color=green]", "[/color][/b]"),
+459                    "del": ("[s][color=red]", "[/color][/s]"),
+460                }
+461            elif style == "streamlit":
+462                md_styles = {"ins": ("**:green[", "]** "), "del": ("~~:red[", "]~~ ")}
+463
+464        for diff_op in self._diff_ops:
+465            tag, i1, i2, j1, j2 = diff_op.opcodes
+466            source_tokens = diff_op.source_chunk.text
+467            test_tokens = diff_op.test_chunk.text
+468
+469            if tag == "equal":
+470                temp_str = "".join(source_tokens[i1:i2])
+471                temp_str = re.sub("¶ ", "\n\n", temp_str)
+472                # here we use '¶ ' instead of ' ¶ ', because the leading space will be included in the previous token,
+473                # according to tokenizer = re.compile(r"((?:[^()\s]+|[().?!-])\s*)")
+474                result.append(temp_str)
+475            elif tag == "insert":
+476                temp_str = "".join(test_tokens[j1:j2])
+477                splits = re.split("¶ ", temp_str)
+478                for split in splits:
+479                    result.append(f"{md_styles['ins'][0]}{split}{md_styles['ins'][1]}")
+480                    result.append("\n\n")
+481                if len(splits) > 0:
+482                    result.pop()
+483            elif tag == "delete":
+484                result.append(
+485                    f"{md_styles['del'][0]}{''.join(source_tokens[i1:i2])}{md_styles['del'][1]}"
+486                )
+487                # for 'delete', we make no change, because otherwise there will be two times '\n\n' than the original
+488                # text.
+489            elif tag == "replace":
+490                result.append(
+491                    f"{md_styles['del'][0]}{''.join(source_tokens[i1:i2])}{md_styles['del'][1]}"
+492                )
+493                temp_str = "".join(test_tokens[j1:j2])
+494                splits = re.split("¶ ", temp_str)
+495                for split in splits:
+496                    result.append(f"{md_styles['ins'][0]}{split}{md_styles['ins'][1]}")
+497                    result.append("\n\n")
+498                if len(splits) > 0:
+499                    result.pop()
+500
+501        return "".join(result)
+502
+503    @property
+504    def output_rich(self) -> Text:
+505        """
+506        Returns the delta in text with colors/style for the console.
+507
+508        :return: The delta in text with colors/style for the console.
+509        :rtype: Text
+510        """
+511        console_text = Text()
+512
+513        for diff_op in self._diff_ops:
+514            tag, i1, i2, j1, j2 = diff_op.opcodes
+515            source_tokens = diff_op.source_chunk.text
+516            test_tokens = diff_op.test_chunk.text
+517
+518            if tag == "equal":
+519                temp_str = "".join(source_tokens[i1:i2])
+520                temp_str = re.sub("¶ ", "\n\n", temp_str)
+521                console_text.append(temp_str)
+522            elif tag == "insert":
+523                temp_str = "".join(test_tokens[j1:j2])
+524                splits = re.split("¶ ", temp_str)
+525                for split in splits:
+526                    console_text.append(split, "green")
+527            elif tag == "delete":
+528                console_text.append("".join(source_tokens[i1:i2]), "strike red")
+529            elif tag == "replace":
+530                console_text.append("".join(source_tokens[i1:i2]), "strike red")
+531                temp_str = "".join(test_tokens[j1:j2])
+532                splits = re.split("¶ ", temp_str)
+533                for split in splits:
+534                    console_text.append(split, "green")
+535
+536        return console_text
+537
+538    def compare(
+539        self,
+540        test: str | None = None,
+541        output: OutputTypeLike = OutputType.MARKDOWN,
+542        **options: Unpack[RedlinesOptions],
+543    ) -> Text | str:
+544        """
+545        Compare `test` with `source`, and produce a delta in a format specified by `output`.
+546
+547        :param test: Optional test string to compare. If None, uses the test string provided during initialisation.
+548        :type test: str | None
+549        :param output: The format which the delta should be produced. Currently, "markdown" and "rich" are supported. Defaults to "markdown".
+550        :type output: OutputTypeLike
+551        :param options: Additional options for comparison and output formatting.
+552        :type options: RedlinesOptions
+553        :return: The delta in the format specified by `output`.
+554        :rtype: Text | str
+555        """
+556        if options:
+557            self.options = options
+558
+559        if test:
+560            if self._test and test == self._test:
+561                # If we've already processed this test string, no need to reprocess
+562                pass
+563            else:
+564                self.test = test
+565        elif self._test is None:
+566            raise ValueError(
+567                "No test string was provided when the function was called, or during initialisation."
+568            )
+569
+570        if output == OutputType.MARKDOWN:
+571            return self.output_markdown
+572        elif output == OutputType.RICH:
+573            return self.output_rich
+574        return self.output_markdown
+
+ + + + +
+ +
+ + Redlines( source: str | redlines.document.Document, test: str | redlines.document.Document | None = None, **options: Unpack[RedlinesOptions]) + + + +
+ + 
107    def __init__(
+108        self,
+109        source: str | Document,
+110        test: str | Document | None = None,
+111        **options: Unpack[RedlinesOptions],
+112    ):
+113        """
+114        Redline is a class used to compare text, and producing human-readable differences or deltas
+115        which look like track changes in Microsoft Word.
+116
+117        ```python
+118        # import the class
+119        from redlines import Redlines
+120
+121        # Create a Redlines object using the two strings to compare
+122        test = Redlines(
+123            "The quick brown fox jumps over the lazy dog.",
+124            "The quick brown fox walks past the lazy dog.",
+125        )
+126
+127        # This produces an output in Markdown format
+128        test.output_markdown
+129        ```
+130
+131        Besides strings, Redlines can also receive an input in another format if it is supported by the Document class
+132
+133        ```python
+134        from redlines import PlainTextFile
+135
+136        source = PlainTextFile("tests/documents/PlainTextFile/source.txt")
+137        test = PlainTextFile("tests/documents/PlainTextFile/test.txt")
+138
+139        redline = Redlines(source, test)
+140        assert (
+141            redline.output_markdown
+142            == "The quick brown fox <span style='color:red;font-weight:700;text-decoration:line-through;'>jumps over </span><span style='color:green;font-weight:700;'>walks past </span>the lazy dog."
+143        )
+144
+145        ```
+146
+147        :param source: The source text to be used as a basis for comparison.
+148        :type source: str | Document
+149        :param test: Optional test text to compare with the source.
+150        :type test: str | Document | None
+151        :param options: Additional options for comparison and output formatting.
+152        :type options: RedlinesOptions
+153        """
+154        self.processor = WholeDocumentProcessor()
+155        self.source = source.text if isinstance(source, Document) else source
+156        self.options = options
+157        self._diff_operations = None
+158        if test:
+159            self.test = test.text if isinstance(test, Document) else test
+160            # self.compare()
+
+ + +

Redline is a class used to compare text, and producing human-readable differences or deltas +which look like track changes in Microsoft Word.

+ +
+
# import the class
+from redlines import Redlines
+
+# Create a Redlines object using the two strings to compare
+test = Redlines(
+    "The quick brown fox jumps over the lazy dog.",
+    "The quick brown fox walks past the lazy dog.",
+)
+
+# This produces an output in Markdown format
+test.output_markdown
+
+
+ +

Besides strings, Redlines can also receive an input in another format if it is supported by the Document class

+ +
+
from redlines import PlainTextFile
+
+source = PlainTextFile("tests/documents/PlainTextFile/source.txt")
+test = PlainTextFile("tests/documents/PlainTextFile/test.txt")
+
+redline = Redlines(source, test)
+assert (
+    redline.output_markdown
+    == "The quick brown fox <span style='color:red;font-weight:700;text-decoration:line-through;'>jumps over </span><span style='color:green;font-weight:700;'>walks past </span>the lazy dog."
+)
+
+
+ +
Parameters
+ +
    +
  • source: The source text to be used as a basis for comparison.
    • +
  • test: Optional test text to compare with the source.
    • +
  • options: Additional options for comparison and output formatting.
    • +
+
+ + +
+
+ +
+ source: str + + + +
+ + 
40    @property
+41    def source(self) -> str:
+42        """
+43        Get the source text to be used as a basis for comparison.
+44
+45        :return: The source text to be used as a basis for comparison.
+46        :rtype: str
+47        """
+48        if self._source is None:
+49            raise ValueError("No source string was provided.")
+50        return self._source
+
+ + +

Get the source text to be used as a basis for comparison.

+ +
Returns
+ +
+

The source text to be used as a basis for comparison.

+
+
+ + +
+
+ +
+ test: str + + + +
+ + 
60    @property
+61    def test(self) -> str:
+62        """
+63        Get the text to be compared with the source.
+64
+65        :return: The text to be compared with the source.
+66        :rtype: str
+67        """
+68        if self._test is None:
+69            raise ValueError("No test string was provided.")
+70        return self._test
+
+ + +

Get the text to be compared with the source.

+ +
Returns
+ +
+

The text to be compared with the source.

+
+
+ + +
+
+ +
+ redlines: list[redlines.processor.Redline] + + + +
+ + 
 94    @property
+ 95    def redlines(self) -> list[Redline]:
+ 96        """
+ 97        Return the list of Redline objects representing actual changes between source and test.
+ 98
+ 99        This is an alias for the `changes` property and provides the same functionality.
+100        Only actual changes are returned (equal operations are excluded).
+101
+102        :return: List of Redline objects
+103        :rtype: list[Redline]
+104        """
+105        return self.changes
+
+ + +

Return the list of Redline objects representing actual changes between source and test.

+ +

This is an alias for the changes property and provides the same functionality. +Only actual changes are returned (equal operations are excluded).

+ +
Returns
+ +
+

List of Redline objects

+
+
+ + +
+
+
+ processor + + +
+ + + + +
+
+
+ options + + +
+ + + + +
+
+ +
+ opcodes: list[tuple[str, int, int, int, int]] + + + +
+ + 
162    @property
+163    def opcodes(self) -> list[tuple[str, int, int, int, int]]:
+164        """
+165        Return list of 5-tuples describing how to turn `source` into `test`.
+166        Similar to [`SequenceMatcher.get_opcodes`](https://docs.python.org/3/library/difflib.html#difflib.SequenceMatcher.get_opcodes).
+167
+168        ```pycon
+169        >>> test_string_1 = 'The quick brown fox jumps over the lazy dog.'
+170        ... test_string_2 = 'The quick brown fox walks past the lazy dog.'
+171        ... s = Redlines(test_string_1, test_string_2)
+172        ... s.opcodes
+173        [('equal', 0, 4, 0, 4), ('replace', 4, 6, 4, 6), ('equal', 6, 9, 6, 9)]
+174        ```
+175
+176        :return: List of 5-tuples describing how to turn `source` into `test`.
+177        :rtype: list[tuple[str, int, int, int, int]]
+178        """
+179        return [diff_op.opcodes for diff_op in self._diff_ops]
+
+ + +

Return list of 5-tuples describing how to turn source into test. +Similar to SequenceMatcher.get_opcodes.

+ +
+
>>> test_string_1 = 'The quick brown fox jumps over the lazy dog.'
+... test_string_2 = 'The quick brown fox walks past the lazy dog.'
+... s = Redlines(test_string_1, test_string_2)
+... s.opcodes
+[('equal', 0, 4, 0, 4), ('replace', 4, 6, 4, 6), ('equal', 6, 9, 6, 9)]
+
+
+ +
Returns
+ +
+

List of 5-tuples describing how to turn source into test.

+
+
+ + +
+
+ +
+ changes: list[redlines.processor.Redline] + + + +
+ + 
181    @property
+182    def changes(self) -> list[Redline]:
+183        """
+184        Return list of Redline objects representing the differences between source and test.
+185
+186        This provides a user-friendly interface for programmatically accessing changes,
+187        with direct access to the changed text and position information. Only actual
+188        changes are returned (equal operations are excluded).
+189
+190        ```python
+191        from redlines import Redlines
+192
+193        test = Redlines(
+194            "The quick brown fox jumps over the lazy dog.",
+195            "The quick brown fox walks past the lazy dog."
+196        )
+197
+198        for redline in test.changes:
+199            print(f"{redline.operation}: {redline.source_text} -> {redline.test_text}")
+200        # Output: replace: jumps over  -> walks past
+201        ```
+202
+203        :return: List of Redline objects (only actual changes, no 'equal' operations)
+204        """
+205        result = []
+206        for diff_op in self._diff_ops:
+207            tag, i1, i2, j1, j2 = diff_op.opcodes
+208
+209            # Skip equal operations - only return actual changes
+210            if tag == "equal":
+211                continue
+212
+213            source_tokens = diff_op.source_chunk.text
+214            test_tokens = diff_op.test_chunk.text
+215
+216            # Extract text and positions based on operation type
+217            if tag == "delete":
+218                redline = Redline(
+219                    operation="delete",
+220                    source_text="".join(source_tokens[i1:i2]),
+221                    test_text=None,
+222                    source_position=(i1, i2),
+223                    test_position=None,
+224                )
+225            elif tag == "insert":
+226                redline = Redline(
+227                    operation="insert",
+228                    source_text=None,
+229                    test_text="".join(test_tokens[j1:j2]),
+230                    source_position=None,
+231                    test_position=(j1, j2),
+232                )
+233            elif tag == "replace":
+234                redline = Redline(
+235                    operation="replace",
+236                    source_text="".join(source_tokens[i1:i2]),
+237                    test_text="".join(test_tokens[j1:j2]),
+238                    source_position=(i1, i2),
+239                    test_position=(j1, j2),
+240                )
+241            else:
+242                continue
+243
+244            result.append(redline)
+245
+246        return result
+
+ + +

Return list of Redline objects representing the differences between source and test.

+ +

This provides a user-friendly interface for programmatically accessing changes, +with direct access to the changed text and position information. Only actual +changes are returned (equal operations are excluded).

+ +
+
from redlines import Redlines
+
+test = Redlines(
+    "The quick brown fox jumps over the lazy dog.",
+    "The quick brown fox walks past the lazy dog."
+)
+
+for redline in test.changes:
+    print(f"{redline.operation}: {redline.source_text} -> {redline.test_text}")
+# Output: replace: jumps over  -> walks past
+
+
+ +
Returns
+ +
+

List of Redline objects (only actual changes, no 'equal' operations)

+
+
+ + +
+
+ +
+ + def + get_changes(self, operation: str | None = None) -> list[redlines.processor.Redline]: + + + +
+ + 
248    def get_changes(
+249        self, operation: str | None = None
+250    ) -> list[Redline]:
+251        """
+252        Get changes (redlines), optionally filtered by operation type.
+253
+254        ```python
+255        from redlines import Redlines
+256
+257        test = Redlines(
+258            "The quick brown fox jumps over the lazy dog.",
+259            "The quick brown fox walks past the lazy dog."
+260        )
+261
+262        # Get all changes
+263        all_changes = test.get_changes()
+264
+265        # Get only replacements
+266        replacements = test.get_changes(operation="replace")
+267
+268        # Get deletions
+269        deletions = test.get_changes(operation="delete")
+270
+271        # Get insertions
+272        insertions = test.get_changes(operation="insert")
+273        ```
+274
+275        :param operation: Filter by operation type: "delete", "insert", or "replace". If None, returns all changes.
+276        :return: List of Redline objects matching the filter
+277        """
+278        changes = self.changes
+279
+280        if operation is None:
+281            return changes
+282
+283        if operation not in ("delete", "insert", "replace"):
+284            raise ValueError(
+285                f"Invalid operation '{operation}'. Must be 'delete', 'insert', or 'replace'."
+286            )
+287
+288        return [r for r in changes if r.operation == operation]
+
+ + +

Get changes (redlines), optionally filtered by operation type.

+ +
+
from redlines import Redlines
+
+test = Redlines(
+    "The quick brown fox jumps over the lazy dog.",
+    "The quick brown fox walks past the lazy dog."
+)
+
+# Get all changes
+all_changes = test.get_changes()
+
+# Get only replacements
+replacements = test.get_changes(operation="replace")
+
+# Get deletions
+deletions = test.get_changes(operation="delete")
+
+# Get insertions
+insertions = test.get_changes(operation="insert")
+
+
+ +
Parameters
+ +
    +
  • operation: Filter by operation type: "delete", "insert", or "replace". If None, returns all changes.
    • +
+ +
Returns
+ +
+

List of Redline objects matching the filter

+
+
+ + +
+
+ +
+ + def + stats(self) -> redlines.processor.Stats: + + + +
+ + 
290    def stats(self) -> Stats:
+291        """
+292        Get statistics about the changes between source and test.
+293
+294        ```python
+295        from redlines import Redlines
+296
+297        test = Redlines(
+298            "The quick brown fox jumps over the lazy dog.",
+299            "The quick brown fox walks past the lazy dog."
+300        )
+301
+302        stats = test.stats()
+303        print(f"Total changes: {stats.total_changes}")
+304        print(f"Deletions: {stats.deletions}")
+305        print(f"Insertions: {stats.insertions}")
+306        print(f"Replacements: {stats.replacements}")
+307        ```
+308
+309        :return: Stats object with change counts
+310        """
+311        changes = self.changes
+312
+313        deletions = sum(1 for c in changes if c.operation == "delete")
+314        insertions = sum(1 for c in changes if c.operation == "insert")
+315        replacements = sum(1 for c in changes if c.operation == "replace")
+316
+317        return Stats(
+318            total_changes=len(changes),
+319            deletions=deletions,
+320            insertions=insertions,
+321            replacements=replacements,
+322        )
+
+ + +

Get statistics about the changes between source and test.

+ +
+
from redlines import Redlines
+
+test = Redlines(
+    "The quick brown fox jumps over the lazy dog.",
+    "The quick brown fox walks past the lazy dog."
+)
+
+stats = test.stats()
+print(f"Total changes: {stats.total_changes}")
+print(f"Deletions: {stats.deletions}")
+print(f"Insertions: {stats.insertions}")
+print(f"Replacements: {stats.replacements}")
+
+
+ +
Returns
+ +
+

Stats object with change counts

+
+
+ + +
+
+ +
+ output_markdown: str + + + +
+ + 
324    @property
+325    def output_markdown(self) -> str:
+326        """
+327        Returns the delta in Markdown format.
+328
+329        ## Styling Markdown
+330        To output markdown in a particular manner, you must pass a `markdown_style` option when the `Redlines` object
+331        is created or when `Redlines.compare` is called.
+332
+333        ```python
+334        from redlines import Redlines
+335
+336        test = Redlines(
+337            "The quick brown fox jumps over the lazy dog.",
+338            "The quick brown fox walks past the lazy dog.",
+339            markdown_style="red"  # This option specifies the style as red
+340        )
+341
+342        test.compare(markdown_style="none") # This option specifies the style as none
+343        ```
+344
+345        ### Available styles
+346
+347        | Style | Preview |
+348        |-------| -------|
+349        |red-green (**default**) | "The quick brown fox <span style='color:red;font-weight:700;text-decoration:line-through;'>jumps over </span><span style='color:green;font-weight:700;'>walks past </span>the lazy dog."|
+350        |none | 'The quick brown fox <del>jumps over </del><ins>walks past </ins>the lazy dog.'|
+351        |red | "The quick brown fox <span style='color:red;font-weight:700;text-decoration:line-through;'>jumps over </span><span style='color:red;font-weight:700;'>walks past </span>the lazy dog."|
+352        |ghfm (GitHub Flavored Markdown)| 'The quick brown fox ~~jumps over ~~**walks past **the lazy dog.' |
+353        |bbcode (BBCode) | 'The quick brown fox [s][color=red]jumps over [/color][/s][b][color=green]walks past [/color][/b]the lazy dog.' |
+354        |streamlit | 'The quick brown fox ~~:red[jumps over ]~~ **:green[walks past ]** the lazy dog.' |
+355
+356        ### Custom styling
+357
+358        You can also use css classes to provide custom styling by setting `markdown_style` as "custom_css".
+359        Insertions and deletions are now styled using the "redline-inserted" and "redline-deleted" CSS classes.
+360        You can also set your own CSS classes by specifying the name of the CSS class in the options `ins_class`
+361        and `del_class` respectively in the constructor or compare function.
+362
+363        ## Markdown output in specific environments
+364
+365        Users have reported that the output doesn't display correctly in their environments.
+366        This is because styling may not appear in markdown environments which disallow HTML.
+367        There is no consistent support for strikethroughs and colors in the markdown standard,
+368        and styling is largely accomplished through raw HTML. If you are using GitHub or Streamlit, you may not get
+369        the formatting you expect or see any change at all.
+370
+371        If you are facing this kind of difficulty, here are some recommendations. If your experience doesn't match
+372        the hints or description below, or you continue to face problems, please raise an issue.
+373
+374        ### Jupyter Notebooks
+375        This library was first written for the Jupyter notebook environment, so all the available styles, including
+376        the default (`red-green`), `red` and `none` work.
+377
+378        ### Streamlit
+379
+380        Try this:
+381
+382        * If streamlit version is >= 1.16.0, consider the markdown style "streamlit"
+383        * If streamlit version is < 1.16.0, consider the markdown style `ghfm`
+384        * Enable parsing of HTML. In Streamlit, you need to set the `unsafe_allow_html` argument in `st.write` or
+385        `st.markdown` to `True`.
+386
+387        ### Colab
+388
+389        Try this:
+390        * Use the markdown style `none` or `ghfm`
+391        * `Redlines.output_rich` has been reported to work in Colab
+392
+393        :return: The delta in Markdown format.
+394        :rtype: str
+395        """
+396        result: list[str] = []
+397
+398        # default_style = "red_green"
+399
+400        md_styles = {
+401            "ins": (
+402                f"<span style='color:green;font-weight:700;'>",
+403                "</span>",
+404            ),
+405            "del": (
+406                f"<span style='color:red;font-weight:700;text-decoration:line-through;'>",
+407                "</span>",
+408            ),
+409        }
+410
+411        if "markdown_style" in self.options:
+412            style = self.options["markdown_style"]
+413
+414            if style == "none" or style is None:
+415                md_styles = {"ins": ("<ins>", "</ins>"), "del": ("<del>", "</del>")}
+416            elif style == "red":
+417                md_styles = {
+418                    "ins": (
+419                        f"<span style='color:red;font-weight:700;'>",
+420                        "</span>",
+421                    ),
+422                    "del": (
+423                        f"<span style='color:red;font-weight:700;text-decoration:line-through;'>",
+424                        "</span>",
+425                    ),
+426                }
+427            elif style == "custom_css":
+428                ins_class = (
+429                    self.options["ins_class"]
+430                    if "ins_class" in self.options
+431                    else "redline-inserted"
+432                )
+433                del_class = (
+434                    self.options["del_class"]
+435                    if "del_class" in self.options
+436                    else "redline-deleted"
+437                )
+438
+439                elem_attributes = {
+440                    "ins": f"class='{ins_class}'",
+441                    "del": f"class='{del_class}'",
+442                }
+443
+444                md_styles = {
+445                    "ins": (
+446                        f"<span {elem_attributes['ins']}>",
+447                        "</span>",
+448                    ),
+449                    "del": (
+450                        f"<span {elem_attributes['del']}>",
+451                        "</span>",
+452                    ),
+453                }
+454            elif style == "ghfm":
+455                md_styles = {"ins": ("**", "**"), "del": ("~~", "~~")}
+456            elif style == "bbcode":
+457                md_styles = {
+458                    "ins": ("[b][color=green]", "[/color][/b]"),
+459                    "del": ("[s][color=red]", "[/color][/s]"),
+460                }
+461            elif style == "streamlit":
+462                md_styles = {"ins": ("**:green[", "]** "), "del": ("~~:red[", "]~~ ")}
+463
+464        for diff_op in self._diff_ops:
+465            tag, i1, i2, j1, j2 = diff_op.opcodes
+466            source_tokens = diff_op.source_chunk.text
+467            test_tokens = diff_op.test_chunk.text
+468
+469            if tag == "equal":
+470                temp_str = "".join(source_tokens[i1:i2])
+471                temp_str = re.sub("¶ ", "\n\n", temp_str)
+472                # here we use '¶ ' instead of ' ¶ ', because the leading space will be included in the previous token,
+473                # according to tokenizer = re.compile(r"((?:[^()\s]+|[().?!-])\s*)")
+474                result.append(temp_str)
+475            elif tag == "insert":
+476                temp_str = "".join(test_tokens[j1:j2])
+477                splits = re.split("¶ ", temp_str)
+478                for split in splits:
+479                    result.append(f"{md_styles['ins'][0]}{split}{md_styles['ins'][1]}")
+480                    result.append("\n\n")
+481                if len(splits) > 0:
+482                    result.pop()
+483            elif tag == "delete":
+484                result.append(
+485                    f"{md_styles['del'][0]}{''.join(source_tokens[i1:i2])}{md_styles['del'][1]}"
+486                )
+487                # for 'delete', we make no change, because otherwise there will be two times '\n\n' than the original
+488                # text.
+489            elif tag == "replace":
+490                result.append(
+491                    f"{md_styles['del'][0]}{''.join(source_tokens[i1:i2])}{md_styles['del'][1]}"
+492                )
+493                temp_str = "".join(test_tokens[j1:j2])
+494                splits = re.split("¶ ", temp_str)
+495                for split in splits:
+496                    result.append(f"{md_styles['ins'][0]}{split}{md_styles['ins'][1]}")
+497                    result.append("\n\n")
+498                if len(splits) > 0:
+499                    result.pop()
+500
+501        return "".join(result)
+
+ + +

Returns the delta in Markdown format.

+ +

Styling Markdown

+ +

To output markdown in a particular manner, you must pass a markdown_style option when the Redlines object +is created or when Redlines.compare is called.

+ +
+
from redlines import Redlines
+
+test = Redlines(
+    "The quick brown fox jumps over the lazy dog.",
+    "The quick brown fox walks past the lazy dog.",
+    markdown_style="red"  # This option specifies the style as red
+)
+
+test.compare(markdown_style="none") # This option specifies the style as none
+
+
+ +

Available styles

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
StylePreview
red-green (default)"The quick brown fox jumps over walks past the lazy dog."
none'The quick brown fox jumps over walks past the lazy dog.'
red"The quick brown fox jumps over walks past the lazy dog."
ghfm (GitHub Flavored Markdown)'The quick brown fox ~~jumps over ~~*walks past *the lazy dog.'
bbcode (BBCode)'The quick brown fox [s][color=red]jumps over [/color][/s][b][color=green]walks past [/color][/b]the lazy dog.'
streamlit'The quick brown fox :red[jumps over ] :green[walks past ] the lazy dog.'
+ +

Custom styling

+ +

You can also use css classes to provide custom styling by setting markdown_style as "custom_css". +Insertions and deletions are now styled using the "redline-inserted" and "redline-deleted" CSS classes. +You can also set your own CSS classes by specifying the name of the CSS class in the options ins_class +and del_class respectively in the constructor or compare function.

+ +

Markdown output in specific environments

+ +

Users have reported that the output doesn't display correctly in their environments. +This is because styling may not appear in markdown environments which disallow HTML. +There is no consistent support for strikethroughs and colors in the markdown standard, +and styling is largely accomplished through raw HTML. If you are using GitHub or Streamlit, you may not get +the formatting you expect or see any change at all.

+ +

If you are facing this kind of difficulty, here are some recommendations. If your experience doesn't match +the hints or description below, or you continue to face problems, please raise an issue.

+ +

Jupyter Notebooks

+ +

This library was first written for the Jupyter notebook environment, so all the available styles, including +the default (red-green), red and none work.

+ +

Streamlit

+ +

Try this:

+ +
    +
  • If streamlit version is >= 1.16.0, consider the markdown style "streamlit"
    • +
  • If streamlit version is < 1.16.0, consider the markdown style ghfm
    • +
  • Enable parsing of HTML. In Streamlit, you need to set the unsafe_allow_html argument in st.write or +st.markdown to True.
    • +
+ +

Colab

+ +

Try this:

+ + + +
Returns
+ +
+

The delta in Markdown format.

+
+
+ + +
+
+ +
+ output_rich: rich.text.Text + + + +
+ + 
503    @property
+504    def output_rich(self) -> Text:
+505        """
+506        Returns the delta in text with colors/style for the console.
+507
+508        :return: The delta in text with colors/style for the console.
+509        :rtype: Text
+510        """
+511        console_text = Text()
+512
+513        for diff_op in self._diff_ops:
+514            tag, i1, i2, j1, j2 = diff_op.opcodes
+515            source_tokens = diff_op.source_chunk.text
+516            test_tokens = diff_op.test_chunk.text
+517
+518            if tag == "equal":
+519                temp_str = "".join(source_tokens[i1:i2])
+520                temp_str = re.sub("¶ ", "\n\n", temp_str)
+521                console_text.append(temp_str)
+522            elif tag == "insert":
+523                temp_str = "".join(test_tokens[j1:j2])
+524                splits = re.split("¶ ", temp_str)
+525                for split in splits:
+526                    console_text.append(split, "green")
+527            elif tag == "delete":
+528                console_text.append("".join(source_tokens[i1:i2]), "strike red")
+529            elif tag == "replace":
+530                console_text.append("".join(source_tokens[i1:i2]), "strike red")
+531                temp_str = "".join(test_tokens[j1:j2])
+532                splits = re.split("¶ ", temp_str)
+533                for split in splits:
+534                    console_text.append(split, "green")
+535
+536        return console_text
+
+ + +

Returns the delta in text with colors/style for the console.

+ +
Returns
+ +
+

The delta in text with colors/style for the console.

+
+
+ + +
+
+ +
+ + def + compare( self, test: str | None = None, output: Union[redlines.enums.OutputType, Literal['markdown', 'rich']] = <OutputType.MARKDOWN: 'markdown'>, **options: Unpack[RedlinesOptions]) -> rich.text.Text | str: + + + +
+ + 
538    def compare(
+539        self,
+540        test: str | None = None,
+541        output: OutputTypeLike = OutputType.MARKDOWN,
+542        **options: Unpack[RedlinesOptions],
+543    ) -> Text | str:
+544        """
+545        Compare `test` with `source`, and produce a delta in a format specified by `output`.
+546
+547        :param test: Optional test string to compare. If None, uses the test string provided during initialisation.
+548        :type test: str | None
+549        :param output: The format which the delta should be produced. Currently, "markdown" and "rich" are supported. Defaults to "markdown".
+550        :type output: OutputTypeLike
+551        :param options: Additional options for comparison and output formatting.
+552        :type options: RedlinesOptions
+553        :return: The delta in the format specified by `output`.
+554        :rtype: Text | str
+555        """
+556        if options:
+557            self.options = options
+558
+559        if test:
+560            if self._test and test == self._test:
+561                # If we've already processed this test string, no need to reprocess
+562                pass
+563            else:
+564                self.test = test
+565        elif self._test is None:
+566            raise ValueError(
+567                "No test string was provided when the function was called, or during initialisation."
+568            )
+569
+570        if output == OutputType.MARKDOWN:
+571            return self.output_markdown
+572        elif output == OutputType.RICH:
+573            return self.output_rich
+574        return self.output_markdown
+
+ + +

Compare test with source, and produce a delta in a format specified by output.

+ +
Parameters
+ +
    +
  • test: Optional test string to compare. If None, uses the test string provided during initialisation.
    • +
  • output: The format which the delta should be produced. Currently, "markdown" and "rich" are supported. Defaults to "markdown".
    • +
  • options: Additional options for comparison and output formatting.
    • +
+ +
Returns
+ +
+

The delta in the format specified by output.

+
+
+ + +
+
+
+ +
+ + class + RedlinesOptions(typing.TypedDict): + + + +
+ + 
24class RedlinesOptions(t.TypedDict, total=False):
+25    markdown_style: str | MarkdownStyle | None
+26    """The style to use for markdown output. See `Redlines.output_markdown` for more information."""
+27    ins_class: str
+28    """The CSS class to use for insertions when `markdown_style` is set to `custom_css`. Defaults to 'redline-inserted'."""
+29    del_class: str
+30    """The CSS class to use for deletions when `markdown_style` is set to `custom_css`. Defaults to 'redline-deleted'."""
+
+ + + + +
+
+ markdown_style: str | redlines.enums.MarkdownStyle | None + + +
+ + +

The style to use for markdown output. See Redlines.output_markdown for more information.

+
+ + +
+
+
+ ins_class: str + + +
+ + +

The CSS class to use for insertions when markdown_style is set to custom_css. Defaults to 'redline-inserted'.

+
+ + +
+
+
+ del_class: str + + +
+ + +

The CSS class to use for deletions when markdown_style is set to custom_css. Defaults to 'redline-deleted'.

+
+ + +
+
+
+ + \ No newline at end of file diff --git a/docs/generated-docs/search.js b/docs/generated-docs/search.js new file mode 100644 index 0000000..20ea74a --- /dev/null +++ b/docs/generated-docs/search.js @@ -0,0 +1,46 @@ +window.pdocSearch = (function(){ +/** elasticlunr - http://weixsong.github.io * Copyright (C) 2017 Oliver Nightingale * Copyright (C) 2017 Wei Song * MIT Licensed */!function(){function e(e){if(null===e||"object"!=typeof e)return e;var t=e.constructor();for(var n in e)e.hasOwnProperty(n)&&(t[n]=e[n]);return t}var t=function(e){var n=new t.Index;return n.pipeline.add(t.trimmer,t.stopWordFilter,t.stemmer),e&&e.call(n,n),n};t.version="0.9.5",lunr=t,t.utils={},t.utils.warn=function(e){return function(t){e.console&&console.warn&&console.warn(t)}}(this),t.utils.toString=function(e){return void 0===e||null===e?"":e.toString()},t.EventEmitter=function(){this.events={}},t.EventEmitter.prototype.addListener=function(){var e=Array.prototype.slice.call(arguments),t=e.pop(),n=e;if("function"!=typeof t)throw new TypeError("last argument must be a function");n.forEach(function(e){this.hasHandler(e)||(this.events[e]=[]),this.events[e].push(t)},this)},t.EventEmitter.prototype.removeListener=function(e,t){if(this.hasHandler(e)){var n=this.events[e].indexOf(t);-1!==n&&(this.events[e].splice(n,1),0==this.events[e].length&&delete this.events[e])}},t.EventEmitter.prototype.emit=function(e){if(this.hasHandler(e)){var t=Array.prototype.slice.call(arguments,1);this.events[e].forEach(function(e){e.apply(void 0,t)},this)}},t.EventEmitter.prototype.hasHandler=function(e){return e in this.events},t.tokenizer=function(e){if(!arguments.length||null===e||void 0===e)return[];if(Array.isArray(e)){var n=e.filter(function(e){return null===e||void 0===e?!1:!0});n=n.map(function(e){return t.utils.toString(e).toLowerCase()});var i=[];return n.forEach(function(e){var n=e.split(t.tokenizer.seperator);i=i.concat(n)},this),i}return e.toString().trim().toLowerCase().split(t.tokenizer.seperator)},t.tokenizer.defaultSeperator=/[\s\-]+/,t.tokenizer.seperator=t.tokenizer.defaultSeperator,t.tokenizer.setSeperator=function(e){null!==e&&void 0!==e&&"object"==typeof e&&(t.tokenizer.seperator=e)},t.tokenizer.resetSeperator=function(){t.tokenizer.seperator=t.tokenizer.defaultSeperator},t.tokenizer.getSeperator=function(){return t.tokenizer.seperator},t.Pipeline=function(){this._queue=[]},t.Pipeline.registeredFunctions={},t.Pipeline.registerFunction=function(e,n){n in t.Pipeline.registeredFunctions&&t.utils.warn("Overwriting existing registered function: "+n),e.label=n,t.Pipeline.registeredFunctions[n]=e},t.Pipeline.getRegisteredFunction=function(e){return e in t.Pipeline.registeredFunctions!=!0?null:t.Pipeline.registeredFunctions[e]},t.Pipeline.warnIfFunctionNotRegistered=function(e){var n=e.label&&e.label in this.registeredFunctions;n||t.utils.warn("Function is not registered with pipeline. This may cause problems when serialising the index.\n",e)},t.Pipeline.load=function(e){var n=new t.Pipeline;return e.forEach(function(e){var i=t.Pipeline.getRegisteredFunction(e);if(!i)throw new Error("Cannot load un-registered function: "+e);n.add(i)}),n},t.Pipeline.prototype.add=function(){var e=Array.prototype.slice.call(arguments);e.forEach(function(e){t.Pipeline.warnIfFunctionNotRegistered(e),this._queue.push(e)},this)},t.Pipeline.prototype.after=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var i=this._queue.indexOf(e);if(-1===i)throw new Error("Cannot find existingFn");this._queue.splice(i+1,0,n)},t.Pipeline.prototype.before=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var i=this._queue.indexOf(e);if(-1===i)throw new Error("Cannot find existingFn");this._queue.splice(i,0,n)},t.Pipeline.prototype.remove=function(e){var t=this._queue.indexOf(e);-1!==t&&this._queue.splice(t,1)},t.Pipeline.prototype.run=function(e){for(var t=[],n=e.length,i=this._queue.length,o=0;n>o;o++){for(var r=e[o],s=0;i>s&&(r=this._queue[s](r,o,e),void 0!==r&&null!==r);s++);void 0!==r&&null!==r&&t.push(r)}return t},t.Pipeline.prototype.reset=function(){this._queue=[]},t.Pipeline.prototype.get=function(){return this._queue},t.Pipeline.prototype.toJSON=function(){return this._queue.map(function(e){return t.Pipeline.warnIfFunctionNotRegistered(e),e.label})},t.Index=function(){this._fields=[],this._ref="id",this.pipeline=new t.Pipeline,this.documentStore=new t.DocumentStore,this.index={},this.eventEmitter=new t.EventEmitter,this._idfCache={},this.on("add","remove","update",function(){this._idfCache={}}.bind(this))},t.Index.prototype.on=function(){var e=Array.prototype.slice.call(arguments);return this.eventEmitter.addListener.apply(this.eventEmitter,e)},t.Index.prototype.off=function(e,t){return this.eventEmitter.removeListener(e,t)},t.Index.load=function(e){e.version!==t.version&&t.utils.warn("version mismatch: current "+t.version+" importing "+e.version);var n=new this;n._fields=e.fields,n._ref=e.ref,n.documentStore=t.DocumentStore.load(e.documentStore),n.pipeline=t.Pipeline.load(e.pipeline),n.index={};for(var i in e.index)n.index[i]=t.InvertedIndex.load(e.index[i]);return n},t.Index.prototype.addField=function(e){return this._fields.push(e),this.index[e]=new t.InvertedIndex,this},t.Index.prototype.setRef=function(e){return this._ref=e,this},t.Index.prototype.saveDocument=function(e){return this.documentStore=new t.DocumentStore(e),this},t.Index.prototype.addDoc=function(e,n){if(e){var n=void 0===n?!0:n,i=e[this._ref];this.documentStore.addDoc(i,e),this._fields.forEach(function(n){var o=this.pipeline.run(t.tokenizer(e[n]));this.documentStore.addFieldLength(i,n,o.length);var r={};o.forEach(function(e){e in r?r[e]+=1:r[e]=1},this);for(var s in r){var u=r[s];u=Math.sqrt(u),this.index[n].addToken(s,{ref:i,tf:u})}},this),n&&this.eventEmitter.emit("add",e,this)}},t.Index.prototype.removeDocByRef=function(e){if(e&&this.documentStore.isDocStored()!==!1&&this.documentStore.hasDoc(e)){var t=this.documentStore.getDoc(e);this.removeDoc(t,!1)}},t.Index.prototype.removeDoc=function(e,n){if(e){var n=void 0===n?!0:n,i=e[this._ref];this.documentStore.hasDoc(i)&&(this.documentStore.removeDoc(i),this._fields.forEach(function(n){var o=this.pipeline.run(t.tokenizer(e[n]));o.forEach(function(e){this.index[n].removeToken(e,i)},this)},this),n&&this.eventEmitter.emit("remove",e,this))}},t.Index.prototype.updateDoc=function(e,t){var t=void 0===t?!0:t;this.removeDocByRef(e[this._ref],!1),this.addDoc(e,!1),t&&this.eventEmitter.emit("update",e,this)},t.Index.prototype.idf=function(e,t){var n="@"+t+"/"+e;if(Object.prototype.hasOwnProperty.call(this._idfCache,n))return this._idfCache[n];var i=this.index[t].getDocFreq(e),o=1+Math.log(this.documentStore.length/(i+1));return this._idfCache[n]=o,o},t.Index.prototype.getFields=function(){return this._fields.slice()},t.Index.prototype.search=function(e,n){if(!e)return[];e="string"==typeof e?{any:e}:JSON.parse(JSON.stringify(e));var i=null;null!=n&&(i=JSON.stringify(n));for(var o=new t.Configuration(i,this.getFields()).get(),r={},s=Object.keys(e),u=0;u0&&t.push(e);for(var i in n)"docs"!==i&&"df"!==i&&this.expandToken(e+i,t,n[i]);return t},t.InvertedIndex.prototype.toJSON=function(){return{root:this.root}},t.Configuration=function(e,n){var e=e||"";if(void 0==n||null==n)throw new Error("fields should not be null");this.config={};var i;try{i=JSON.parse(e),this.buildUserConfig(i,n)}catch(o){t.utils.warn("user configuration parse failed, will use default configuration"),this.buildDefaultConfig(n)}},t.Configuration.prototype.buildDefaultConfig=function(e){this.reset(),e.forEach(function(e){this.config[e]={boost:1,bool:"OR",expand:!1}},this)},t.Configuration.prototype.buildUserConfig=function(e,n){var i="OR",o=!1;if(this.reset(),"bool"in e&&(i=e.bool||i),"expand"in e&&(o=e.expand||o),"fields"in e)for(var r in e.fields)if(n.indexOf(r)>-1){var s=e.fields[r],u=o;void 0!=s.expand&&(u=s.expand),this.config[r]={boost:s.boost||0===s.boost?s.boost:1,bool:s.bool||i,expand:u}}else t.utils.warn("field name in user configuration not found in index instance fields");else this.addAllFields2UserConfig(i,o,n)},t.Configuration.prototype.addAllFields2UserConfig=function(e,t,n){n.forEach(function(n){this.config[n]={boost:1,bool:e,expand:t}},this)},t.Configuration.prototype.get=function(){return this.config},t.Configuration.prototype.reset=function(){this.config={}},lunr.SortedSet=function(){this.length=0,this.elements=[]},lunr.SortedSet.load=function(e){var t=new this;return t.elements=e,t.length=e.length,t},lunr.SortedSet.prototype.add=function(){var e,t;for(e=0;e1;){if(r===e)return o;e>r&&(t=o),r>e&&(n=o),i=n-t,o=t+Math.floor(i/2),r=this.elements[o]}return r===e?o:-1},lunr.SortedSet.prototype.locationFor=function(e){for(var t=0,n=this.elements.length,i=n-t,o=t+Math.floor(i/2),r=this.elements[o];i>1;)e>r&&(t=o),r>e&&(n=o),i=n-t,o=t+Math.floor(i/2),r=this.elements[o];return r>e?o:e>r?o+1:void 0},lunr.SortedSet.prototype.intersect=function(e){for(var t=new lunr.SortedSet,n=0,i=0,o=this.length,r=e.length,s=this.elements,u=e.elements;;){if(n>o-1||i>r-1)break;s[n]!==u[i]?s[n]u[i]&&i++:(t.add(s[n]),n++,i++)}return t},lunr.SortedSet.prototype.clone=function(){var e=new lunr.SortedSet;return e.elements=this.toArray(),e.length=e.elements.length,e},lunr.SortedSet.prototype.union=function(e){var t,n,i;this.length>=e.length?(t=this,n=e):(t=e,n=this),i=t.clone();for(var o=0,r=n.toArray();oRedlines\n\n

Redlines produces a text showing the differences between two strings/text. The changes are represented with\nstrike-throughs and underlines, which looks similar to Microsoft Word's track changes. This method of showing changes is\nmore familiar to lawyers and is more compact for long series of characters.

\n\n

Redlines uses SequenceMatcher\nto find differences between words used.\nThe output can be in HTML, Markdown, or rich format.

\n\n

Example

\n\n

Given an original string:

\n\n
The quick brown fox jumps over the lazy dog.\n
\n\n

And the string to be tested with:

\n\n
The quick brown fox walks past the lazy dog.\n
\n\n

The library gives a result of:

\n\n
\"The quick brown fox <span style='color:red;font-weight:700;text-decoration:line-through;'>jumps over </span><span style='color:green;font-weight:700;'>walks past </span>the lazy dog.\"\n
\n\n

Which is rendered like this:

\n\n

The quick brown fox jumps over walks past the lazy dog.

\n\n

Install

\n\n

Use your regular package manager to install the library in your python environment.

\n\n
pip install redlines\n
\n\n

Quickstart

\n\n

This is the most direct way to produce the example.

\n\n
\n
# import the class\nfrom redlines import Redlines\n\n# Create a Redlines object using the two strings to compare\ntest = Redlines(\n    "The quick brown fox jumps over the lazy dog.",\n    "The quick brown fox walks past the lazy dog.",\n)\n\n# This produces an output in markdown format\ntest.output_markdown\n
\n
\n\n

Common Issues

\n\n

The documentation contains other information on common issues users have faced while using this library:

\n\n\n"}, "redlines.cli": {"fullname": "redlines.cli", "modulename": "redlines.cli", "kind": "module", "doc": "

Command line interface for redlines.

\n\n

A command line interface for the redlines library that allows you to compare two strings\nand see the differences in the terminal.

\n\n

NAME

\n\n

redlines - A command line interface for the redlines library to compare text differences

\n\n

SYNOPSIS

\n\n
\n
redlines [COMMAND] [OPTIONS] SOURCE TEST\n
\n
\n\n

DESCRIPTION

\n\n

Redlines is a command line utility that shows the differences between two strings/text.\nThe changes are represented with strike-throughs and underlines, similar to Microsoft Word's track changes.\nThis method of showing changes is more familiar to lawyers and is more compact for long series of characters.

\n\n

COMMANDS

\n\n
\n
text\n
\n
\n\n

Compares the strings SOURCE and TEST and produces a redline in the terminal in a display that shows the original, new, and redlined text.

\n\n
\n
simple_text\n
\n
\n\n

Compares the strings SOURCE and TEST and outputs the redline in the terminal.

\n\n
\n
markdown\n
\n
\n\n

Compares the strings SOURCE and TEST and outputs the redline as a markdown.

\n\n

OPTIONS

\n\n
\n
-h, --help\n
\n
\n\n

Show this help message and exit.

\n\n

EXAMPLES

\n\n

Compare two strings and display the differences in a detailed layout:

\n\n
\n
redlines text "The quick brown fox jumps over the lazy dog." "The quick brown fox walks past the lazy dog."\n
\n
\n\n

Compare two strings and output the redline directly:

\n\n
\n
redlines simple_text "The quick brown fox jumps over the lazy dog." "The quick brown fox walks past the lazy dog."\n
\n
\n\n

LIMITATIONS

\n\n
    \n
  • The text command is not able to show more than 6 lines of text. You may want to use simple_text for longer text.
    • \n
\n\n

You may also want to consider a related textual project if you want to use redlines in the terminal,\nredlines-textual.

\n"}, "redlines.document": {"fullname": "redlines.document", "modulename": "redlines.document", "kind": "module", "doc": "

\n"}, "redlines.document.Document": {"fullname": "redlines.document.Document", "modulename": "redlines.document", "qualname": "Document", "kind": "class", "doc": "

An abstract base class used as a common data interchange with the redlines with formats other than python text strings.\nTo see a basic implementation, you can look at the PlainTextFile class for text files

\n\n\n\n\n \n \n\n\n\n\n \n \n\n\n
Supported File FormatsClass
Plain Text filesPlainTextFile
\n", "bases": "abc.ABC"}, "redlines.document.Document.text": {"fullname": "redlines.document.Document.text", "modulename": "redlines.document", "qualname": "Document.text", "kind": "variable", "doc": "

This property is used by the redlines library to obtain the text to compare. Implement this method to return\nthe text to be compared by redlines.

\n", "annotation": ": str"}, "redlines.document.PlainTextFile": {"fullname": "redlines.document.PlainTextFile", "modulename": "redlines.document", "qualname": "PlainTextFile", "kind": "class", "doc": "

Use this class so that Redlines can read plain text files.

\n\n
\n
from redlines import PlainTextFile\n\nsource = PlainTextFile("tests/documents/PlainTextFile/source.txt")\ntest = PlainTextFile("tests/documents/PlainTextFile/test.txt")\n\nredline = Redlines(source, test)\nassert (\n    redline.output_markdown\n    == "The quick brown fox <span style='color:red;font-weight:700;text-decoration:line-through;'>jumps over </span><span style='color:green;font-weight:700;'>walks past </span>the lazy dog."\n)\n
\n
\n", "bases": "Document"}, "redlines.document.PlainTextFile.__init__": {"fullname": "redlines.document.PlainTextFile.__init__", "modulename": "redlines.document", "qualname": "PlainTextFile.__init__", "kind": "function", "doc": "

Use this class so that Redlines can read plain text files.

\n\n
Parameters
\n\n
    \n
  • file_path: Path to the text file.
    • \n
\n", "signature": "(file_path: str | bytes | os.PathLike[str])"}, "redlines.document.PlainTextFile.text": {"fullname": "redlines.document.PlainTextFile.text", "modulename": "redlines.document", "qualname": "PlainTextFile.text", "kind": "variable", "doc": "
Returns
\n\n
\n

The text of the file referred to when the Document was created.

\n
\n", "annotation": ": str"}, "redlines.enums": {"fullname": "redlines.enums", "modulename": "redlines.enums", "kind": "module", "doc": "

\n"}, "redlines.enums.MarkdownStyle": {"fullname": "redlines.enums.MarkdownStyle", "modulename": "redlines.enums", "qualname": "MarkdownStyle", "kind": "class", "doc": "

The markdown styles supported by redlines.

\n", "bases": "builtins.str, enum.Enum"}, "redlines.enums.MarkdownStyle.RED_GREEN": {"fullname": "redlines.enums.MarkdownStyle.RED_GREEN", "modulename": "redlines.enums", "qualname": "MarkdownStyle.RED_GREEN", "kind": "variable", "doc": "

Red and green colors for deletions and additions respectively.

\n", "default_value": "<MarkdownStyle.RED_GREEN: 'red_green'>"}, "redlines.enums.MarkdownStyle.NONE": {"fullname": "redlines.enums.MarkdownStyle.NONE", "modulename": "redlines.enums", "qualname": "MarkdownStyle.NONE", "kind": "variable", "doc": "

No colors.

\n", "default_value": "<MarkdownStyle.NONE: 'none'>"}, "redlines.enums.MarkdownStyle.RED": {"fullname": "redlines.enums.MarkdownStyle.RED", "modulename": "redlines.enums", "qualname": "MarkdownStyle.RED", "kind": "variable", "doc": "

Only red color for changes.

\n", "default_value": "<MarkdownStyle.RED: 'red'>"}, "redlines.enums.MarkdownStyle.GHFM": {"fullname": "redlines.enums.MarkdownStyle.GHFM", "modulename": "redlines.enums", "qualname": "MarkdownStyle.GHFM", "kind": "variable", "doc": "

GitHub Flavored Markdown style.

\n", "default_value": "<MarkdownStyle.GHFM: 'ghfm'>"}, "redlines.enums.MarkdownStyle.BBCODE": {"fullname": "redlines.enums.MarkdownStyle.BBCODE", "modulename": "redlines.enums", "qualname": "MarkdownStyle.BBCODE", "kind": "variable", "doc": "

BBCode style.

\n", "default_value": "<MarkdownStyle.BBCODE: 'bbcode'>"}, "redlines.enums.MarkdownStyle.STREAMLIT": {"fullname": "redlines.enums.MarkdownStyle.STREAMLIT", "modulename": "redlines.enums", "qualname": "MarkdownStyle.STREAMLIT", "kind": "variable", "doc": "

Streamlit style.

\n", "default_value": "<MarkdownStyle.STREAMLIT: 'streamlit'>"}, "redlines.enums.OutputType": {"fullname": "redlines.enums.OutputType", "modulename": "redlines.enums", "qualname": "OutputType", "kind": "class", "doc": "

The output types supported by redlines.

\n", "bases": "builtins.str, enum.Enum"}, "redlines.enums.OutputType.MARKDOWN": {"fullname": "redlines.enums.OutputType.MARKDOWN", "modulename": "redlines.enums", "qualname": "OutputType.MARKDOWN", "kind": "variable", "doc": "

Markdown format.

\n", "default_value": "<OutputType.MARKDOWN: 'markdown'>"}, "redlines.enums.OutputType.RICH": {"fullname": "redlines.enums.OutputType.RICH", "modulename": "redlines.enums", "qualname": "OutputType.RICH", "kind": "variable", "doc": "

Rich format for terminal output.

\n", "default_value": "<OutputType.RICH: 'rich'>"}, "redlines.processor": {"fullname": "redlines.processor", "modulename": "redlines.processor", "kind": "module", "doc": "

\n"}, "redlines.processor.RedlinesProcessor": {"fullname": "redlines.processor.RedlinesProcessor", "modulename": "redlines.processor", "qualname": "RedlinesProcessor", "kind": "class", "doc": "

An abstract class that defines the interface for a redlines processor.\nA redlines processor is a class that takes two documents and generates diff operations from them.\nUse this class as a base class if you want to create a custom redlines processor.\nSee WholeDocumentProcessor for an example of a redlines processor.

\n", "bases": "abc.ABC"}, "redlines.processor.RedlinesProcessor.process": {"fullname": "redlines.processor.RedlinesProcessor.process", "modulename": "redlines.processor", "qualname": "RedlinesProcessor.process", "kind": "function", "doc": "

\n", "signature": "(\tself,\tsource: redlines.document.Document | str,\ttest: redlines.document.Document | str) -> list[redlines.processor.DiffOperation]:", "funcdef": "def"}, "redlines.processor.WholeDocumentProcessor": {"fullname": "redlines.processor.WholeDocumentProcessor", "modulename": "redlines.processor", "qualname": "WholeDocumentProcessor", "kind": "class", "doc": "

A redlines processor that compares two documents. It compares the entire documents as a single chunk.

\n", "bases": "RedlinesProcessor"}, "redlines.processor.WholeDocumentProcessor.process": {"fullname": "redlines.processor.WholeDocumentProcessor.process", "modulename": "redlines.processor", "qualname": "WholeDocumentProcessor.process", "kind": "function", "doc": "

Compare two documents as a single chunk.

\n\n
Parameters
\n\n
    \n
  • source: The source document to compare.
    • \n
  • test: The test document to compare.
    • \n
\n\n
Returns
\n\n
\n

A list of DiffOperation that describe the differences between the two documents.

\n
\n", "signature": "(\tself,\tsource: redlines.document.Document | str,\ttest: redlines.document.Document | str) -> list[redlines.processor.DiffOperation]:", "funcdef": "def"}, "redlines.processor.Redline": {"fullname": "redlines.processor.Redline", "modulename": "redlines.processor", "qualname": "Redline", "kind": "class", "doc": "

A structured representation of a single change between source and test text.

\n\n

This class provides a user-friendly interface for accessing diff information,\nwith direct access to the changed text and position information.

\n"}, "redlines.processor.Redline.__init__": {"fullname": "redlines.processor.Redline.__init__", "modulename": "redlines.processor", "qualname": "Redline.__init__", "kind": "function", "doc": "

\n", "signature": "(\toperation: Literal['delete', 'insert', 'replace'],\tsource_text: str | None,\ttest_text: str | None,\tsource_position: tuple[int, int] | None,\ttest_position: tuple[int, int] | None)"}, "redlines.processor.Redline.operation": {"fullname": "redlines.processor.Redline.operation", "modulename": "redlines.processor", "qualname": "Redline.operation", "kind": "variable", "doc": "

The type of change: 'delete', 'insert', or 'replace'

\n", "annotation": ": Literal['delete', 'insert', 'replace']"}, "redlines.processor.Redline.source_text": {"fullname": "redlines.processor.Redline.source_text", "modulename": "redlines.processor", "qualname": "Redline.source_text", "kind": "variable", "doc": "

The text from the source document. Present for 'delete' and 'replace' operations.

\n", "annotation": ": str | None"}, "redlines.processor.Redline.test_text": {"fullname": "redlines.processor.Redline.test_text", "modulename": "redlines.processor", "qualname": "Redline.test_text", "kind": "variable", "doc": "

The text from the test document. Present for 'insert' and 'replace' operations.

\n", "annotation": ": str | None"}, "redlines.processor.Redline.source_position": {"fullname": "redlines.processor.Redline.source_position", "modulename": "redlines.processor", "qualname": "Redline.source_position", "kind": "variable", "doc": "

Position in source tokens as (start, end). None for 'insert' operations.

\n", "annotation": ": tuple[int, int] | None"}, "redlines.processor.Redline.test_position": {"fullname": "redlines.processor.Redline.test_position", "modulename": "redlines.processor", "qualname": "Redline.test_position", "kind": "variable", "doc": "

Position in test tokens as (start, end). None for 'delete' operations.

\n", "annotation": ": tuple[int, int] | None"}, "redlines.processor.Stats": {"fullname": "redlines.processor.Stats", "modulename": "redlines.processor", "qualname": "Stats", "kind": "class", "doc": "

Statistics about the changes between source and test text.

\n\n

Provides a summary of all changes including counts by operation type.

\n"}, "redlines.processor.Stats.__init__": {"fullname": "redlines.processor.Stats.__init__", "modulename": "redlines.processor", "qualname": "Stats.__init__", "kind": "function", "doc": "

\n", "signature": "(\ttotal_changes: int,\tdeletions: int,\tinsertions: int,\treplacements: int)"}, "redlines.processor.Stats.total_changes": {"fullname": "redlines.processor.Stats.total_changes", "modulename": "redlines.processor", "qualname": "Stats.total_changes", "kind": "variable", "doc": "

Total number of changes (deletions + insertions + replacements)

\n", "annotation": ": int"}, "redlines.processor.Stats.deletions": {"fullname": "redlines.processor.Stats.deletions", "modulename": "redlines.processor", "qualname": "Stats.deletions", "kind": "variable", "doc": "

Number of deletion operations

\n", "annotation": ": int"}, "redlines.processor.Stats.insertions": {"fullname": "redlines.processor.Stats.insertions", "modulename": "redlines.processor", "qualname": "Stats.insertions", "kind": "variable", "doc": "

Number of insertion operations

\n", "annotation": ": int"}, "redlines.processor.Stats.replacements": {"fullname": "redlines.processor.Stats.replacements", "modulename": "redlines.processor", "qualname": "Stats.replacements", "kind": "variable", "doc": "

Number of replacement operations

\n", "annotation": ": int"}, "redlines.processor.DiffOperation": {"fullname": "redlines.processor.DiffOperation", "modulename": "redlines.processor", "qualname": "DiffOperation", "kind": "class", "doc": "

Internal representation of a diff operation (includes 'equal' operations for rendering)

\n"}, "redlines.processor.DiffOperation.__init__": {"fullname": "redlines.processor.DiffOperation.__init__", "modulename": "redlines.processor", "qualname": "DiffOperation.__init__", "kind": "function", "doc": "

\n", "signature": "(\tsource_chunk: redlines.processor.Chunk,\ttest_chunk: redlines.processor.Chunk,\topcodes: tuple[str, int, int, int, int])"}, "redlines.processor.DiffOperation.source_chunk": {"fullname": "redlines.processor.DiffOperation.source_chunk", "modulename": "redlines.processor", "qualname": "DiffOperation.source_chunk", "kind": "variable", "doc": "

\n", "annotation": ": redlines.processor.Chunk"}, "redlines.processor.DiffOperation.test_chunk": {"fullname": "redlines.processor.DiffOperation.test_chunk", "modulename": "redlines.processor", "qualname": "DiffOperation.test_chunk", "kind": "variable", "doc": "

The chunk of text that is being compared

\n", "annotation": ": redlines.processor.Chunk"}, "redlines.processor.DiffOperation.opcodes": {"fullname": "redlines.processor.DiffOperation.opcodes", "modulename": "redlines.processor", "qualname": "DiffOperation.opcodes", "kind": "variable", "doc": "

The opcodes that describe the operation. See the difflib documentation for more information

\n", "annotation": ": tuple[str, int, int, int, int]"}, "redlines.processor.Chunk": {"fullname": "redlines.processor.Chunk", "modulename": "redlines.processor", "qualname": "Chunk", "kind": "class", "doc": "

A chunk of text that is being compared. In some cases, it may be the whole document

\n"}, "redlines.processor.Chunk.__init__": {"fullname": "redlines.processor.Chunk.__init__", "modulename": "redlines.processor", "qualname": "Chunk.__init__", "kind": "function", "doc": "

\n", "signature": "(text: list[str], chunk_location: str | None)"}, "redlines.processor.Chunk.text": {"fullname": "redlines.processor.Chunk.text", "modulename": "redlines.processor", "qualname": "Chunk.text", "kind": "variable", "doc": "

The tokens of the chunk

\n", "annotation": ": list[str]"}, "redlines.processor.Chunk.chunk_location": {"fullname": "redlines.processor.Chunk.chunk_location", "modulename": "redlines.processor", "qualname": "Chunk.chunk_location", "kind": "variable", "doc": "

An optional string describing the location of the chunk in the document. For example, a PDF page number

\n", "annotation": ": str | None"}, "redlines.redlines": {"fullname": "redlines.redlines", "modulename": "redlines.redlines", "kind": "module", "doc": "

\n"}, "redlines.redlines.Redlines": {"fullname": "redlines.redlines.Redlines", "modulename": "redlines.redlines", "qualname": "Redlines", "kind": "class", "doc": "

\n"}, "redlines.redlines.Redlines.__init__": {"fullname": "redlines.redlines.Redlines.__init__", "modulename": "redlines.redlines", "qualname": "Redlines.__init__", "kind": "function", "doc": "

Redline is a class used to compare text, and producing human-readable differences or deltas\nwhich look like track changes in Microsoft Word.

\n\n
\n
# import the class\nfrom redlines import Redlines\n\n# Create a Redlines object using the two strings to compare\ntest = Redlines(\n    "The quick brown fox jumps over the lazy dog.",\n    "The quick brown fox walks past the lazy dog.",\n)\n\n# This produces an output in Markdown format\ntest.output_markdown\n
\n
\n\n

Besides strings, Redlines can also receive an input in another format if it is supported by the Document class

\n\n
\n
from redlines import PlainTextFile\n\nsource = PlainTextFile("tests/documents/PlainTextFile/source.txt")\ntest = PlainTextFile("tests/documents/PlainTextFile/test.txt")\n\nredline = Redlines(source, test)\nassert (\n    redline.output_markdown\n    == "The quick brown fox <span style='color:red;font-weight:700;text-decoration:line-through;'>jumps over </span><span style='color:green;font-weight:700;'>walks past </span>the lazy dog."\n)\n
\n
\n\n
Parameters
\n\n
    \n
  • source: The source text to be used as a basis for comparison.
    • \n
  • test: Optional test text to compare with the source.
    • \n
  • options: Additional options for comparison and output formatting.
    • \n
\n", "signature": "(\tsource: str | redlines.document.Document,\ttest: str | redlines.document.Document | None = None,\t**options: Unpack[redlines.redlines.RedlinesOptions])"}, "redlines.redlines.Redlines.source": {"fullname": "redlines.redlines.Redlines.source", "modulename": "redlines.redlines", "qualname": "Redlines.source", "kind": "variable", "doc": "

Get the source text to be used as a basis for comparison.

\n\n
Returns
\n\n
\n

The source text to be used as a basis for comparison.

\n
\n", "annotation": ": str"}, "redlines.redlines.Redlines.test": {"fullname": "redlines.redlines.Redlines.test", "modulename": "redlines.redlines", "qualname": "Redlines.test", "kind": "variable", "doc": "

Get the text to be compared with the source.

\n\n
Returns
\n\n
\n

The text to be compared with the source.

\n
\n", "annotation": ": str"}, "redlines.redlines.Redlines.redlines": {"fullname": "redlines.redlines.Redlines.redlines", "modulename": "redlines.redlines", "qualname": "Redlines.redlines", "kind": "variable", "doc": "

Return the list of Redline objects representing actual changes between source and test.

\n\n

This is an alias for the changes property and provides the same functionality.\nOnly actual changes are returned (equal operations are excluded).

\n\n
Returns
\n\n
\n

List of Redline objects

\n
\n", "annotation": ": list[redlines.processor.Redline]"}, "redlines.redlines.Redlines.processor": {"fullname": "redlines.redlines.Redlines.processor", "modulename": "redlines.redlines", "qualname": "Redlines.processor", "kind": "variable", "doc": "

\n"}, "redlines.redlines.Redlines.options": {"fullname": "redlines.redlines.Redlines.options", "modulename": "redlines.redlines", "qualname": "Redlines.options", "kind": "variable", "doc": "

\n"}, "redlines.redlines.Redlines.opcodes": {"fullname": "redlines.redlines.Redlines.opcodes", "modulename": "redlines.redlines", "qualname": "Redlines.opcodes", "kind": "variable", "doc": "

Return list of 5-tuples describing how to turn source into test.\nSimilar to SequenceMatcher.get_opcodes.

\n\n
\n
>>> test_string_1 = 'The quick brown fox jumps over the lazy dog.'\n... test_string_2 = 'The quick brown fox walks past the lazy dog.'\n... s = Redlines(test_string_1, test_string_2)\n... s.opcodes\n[('equal', 0, 4, 0, 4), ('replace', 4, 6, 4, 6), ('equal', 6, 9, 6, 9)]\n
\n
\n\n
Returns
\n\n
\n

List of 5-tuples describing how to turn source into test.

\n
\n", "annotation": ": list[tuple[str, int, int, int, int]]"}, "redlines.redlines.Redlines.changes": {"fullname": "redlines.redlines.Redlines.changes", "modulename": "redlines.redlines", "qualname": "Redlines.changes", "kind": "variable", "doc": "

Return list of Redline objects representing the differences between source and test.

\n\n

This provides a user-friendly interface for programmatically accessing changes,\nwith direct access to the changed text and position information. Only actual\nchanges are returned (equal operations are excluded).

\n\n
\n
from redlines import Redlines\n\ntest = Redlines(\n    "The quick brown fox jumps over the lazy dog.",\n    "The quick brown fox walks past the lazy dog."\n)\n\nfor redline in test.changes:\n    print(f"{redline.operation}: {redline.source_text} -> {redline.test_text}")\n# Output: replace: jumps over  -> walks past\n
\n
\n\n
Returns
\n\n
\n

List of Redline objects (only actual changes, no 'equal' operations)

\n
\n", "annotation": ": list[redlines.processor.Redline]"}, "redlines.redlines.Redlines.get_changes": {"fullname": "redlines.redlines.Redlines.get_changes", "modulename": "redlines.redlines", "qualname": "Redlines.get_changes", "kind": "function", "doc": "

Get changes (redlines), optionally filtered by operation type.

\n\n
\n
from redlines import Redlines\n\ntest = Redlines(\n    "The quick brown fox jumps over the lazy dog.",\n    "The quick brown fox walks past the lazy dog."\n)\n\n# Get all changes\nall_changes = test.get_changes()\n\n# Get only replacements\nreplacements = test.get_changes(operation="replace")\n\n# Get deletions\ndeletions = test.get_changes(operation="delete")\n\n# Get insertions\ninsertions = test.get_changes(operation="insert")\n
\n
\n\n
Parameters
\n\n
    \n
  • operation: Filter by operation type: \"delete\", \"insert\", or \"replace\". If None, returns all changes.
    • \n
\n\n
Returns
\n\n
\n

List of Redline objects matching the filter

\n
\n", "signature": "(self, operation: str | None = None) -> list[redlines.processor.Redline]:", "funcdef": "def"}, "redlines.redlines.Redlines.stats": {"fullname": "redlines.redlines.Redlines.stats", "modulename": "redlines.redlines", "qualname": "Redlines.stats", "kind": "function", "doc": "

Get statistics about the changes between source and test.

\n\n
\n
from redlines import Redlines\n\ntest = Redlines(\n    "The quick brown fox jumps over the lazy dog.",\n    "The quick brown fox walks past the lazy dog."\n)\n\nstats = test.stats()\nprint(f"Total changes: {stats.total_changes}")\nprint(f"Deletions: {stats.deletions}")\nprint(f"Insertions: {stats.insertions}")\nprint(f"Replacements: {stats.replacements}")\n
\n
\n\n
Returns
\n\n
\n

Stats object with change counts

\n
\n", "signature": "(self) -> redlines.processor.Stats:", "funcdef": "def"}, "redlines.redlines.Redlines.output_markdown": {"fullname": "redlines.redlines.Redlines.output_markdown", "modulename": "redlines.redlines", "qualname": "Redlines.output_markdown", "kind": "variable", "doc": "

Returns the delta in Markdown format.

\n\n

Styling Markdown

\n\n

To output markdown in a particular manner, you must pass a markdown_style option when the Redlines object\nis created or when Redlines.compare is called.

\n\n
\n
from redlines import Redlines\n\ntest = Redlines(\n    "The quick brown fox jumps over the lazy dog.",\n    "The quick brown fox walks past the lazy dog.",\n    markdown_style="red"  # This option specifies the style as red\n)\n\ntest.compare(markdown_style="none") # This option specifies the style as none\n
\n
\n\n

Available styles

\n\n\n\n\n \n \n\n\n\n\n \n \n\n\n \n \n\n\n \n \n\n\n \n \n\n\n \n \n\n\n \n \n\n\n
StylePreview
red-green (default)\"The quick brown fox jumps over walks past the lazy dog.\"
none'The quick brown fox jumps over walks past the lazy dog.'
red\"The quick brown fox jumps over walks past the lazy dog.\"
ghfm (GitHub Flavored Markdown)'The quick brown fox ~~jumps over ~~*walks past *the lazy dog.'
bbcode (BBCode)'The quick brown fox [s][color=red]jumps over [/color][/s][b][color=green]walks past [/color][/b]the lazy dog.'
streamlit'The quick brown fox :red[jumps over ] :green[walks past ] the lazy dog.'
\n\n

Custom styling

\n\n

You can also use css classes to provide custom styling by setting markdown_style as \"custom_css\".\nInsertions and deletions are now styled using the \"redline-inserted\" and \"redline-deleted\" CSS classes.\nYou can also set your own CSS classes by specifying the name of the CSS class in the options ins_class\nand del_class respectively in the constructor or compare function.

\n\n

Markdown output in specific environments

\n\n

Users have reported that the output doesn't display correctly in their environments.\nThis is because styling may not appear in markdown environments which disallow HTML.\nThere is no consistent support for strikethroughs and colors in the markdown standard,\nand styling is largely accomplished through raw HTML. If you are using GitHub or Streamlit, you may not get\nthe formatting you expect or see any change at all.

\n\n

If you are facing this kind of difficulty, here are some recommendations. If your experience doesn't match\nthe hints or description below, or you continue to face problems, please raise an issue.

\n\n

Jupyter Notebooks

\n\n

This library was first written for the Jupyter notebook environment, so all the available styles, including\nthe default (red-green), red and none work.

\n\n

Streamlit

\n\n

Try this:

\n\n
    \n
  • If streamlit version is >= 1.16.0, consider the markdown style \"streamlit\"
    • \n
  • If streamlit version is < 1.16.0, consider the markdown style ghfm
    • \n
  • Enable parsing of HTML. In Streamlit, you need to set the unsafe_allow_html argument in st.write or\nst.markdown to True.
    • \n
\n\n

Colab

\n\n

Try this:

\n\n
    \n
  • Use the markdown style none or ghfm
    • \n
  • Redlines.output_rich has been reported to work in Colab
    • \n
\n\n
Returns
\n\n
\n

The delta in Markdown format.

\n
\n", "annotation": ": str"}, "redlines.redlines.Redlines.output_rich": {"fullname": "redlines.redlines.Redlines.output_rich", "modulename": "redlines.redlines", "qualname": "Redlines.output_rich", "kind": "variable", "doc": "

Returns the delta in text with colors/style for the console.

\n\n
Returns
\n\n
\n

The delta in text with colors/style for the console.

\n
\n", "annotation": ": rich.text.Text"}, "redlines.redlines.Redlines.compare": {"fullname": "redlines.redlines.Redlines.compare", "modulename": "redlines.redlines", "qualname": "Redlines.compare", "kind": "function", "doc": "

Compare test with source, and produce a delta in a format specified by output.

\n\n
Parameters
\n\n
    \n
  • test: Optional test string to compare. If None, uses the test string provided during initialisation.
    • \n
  • output: The format which the delta should be produced. Currently, \"markdown\" and \"rich\" are supported. Defaults to \"markdown\".
    • \n
  • options: Additional options for comparison and output formatting.
    • \n
\n\n
Returns
\n\n
\n

The delta in the format specified by output.

\n
\n", "signature": "(\tself,\ttest: str | None = None,\toutput: Union[redlines.enums.OutputType, Literal['markdown', 'rich']] = <OutputType.MARKDOWN: 'markdown'>,\t**options: Unpack[redlines.redlines.RedlinesOptions]) -> rich.text.Text | str:", "funcdef": "def"}, "redlines.redlines.RedlinesOptions": {"fullname": "redlines.redlines.RedlinesOptions", "modulename": "redlines.redlines", "qualname": "RedlinesOptions", "kind": "class", "doc": "

\n", "bases": "typing.TypedDict"}, "redlines.redlines.RedlinesOptions.markdown_style": {"fullname": "redlines.redlines.RedlinesOptions.markdown_style", "modulename": "redlines.redlines", "qualname": "RedlinesOptions.markdown_style", "kind": "variable", "doc": "

The style to use for markdown output. See Redlines.output_markdown for more information.

\n", "annotation": ": str | redlines.enums.MarkdownStyle | None"}, "redlines.redlines.RedlinesOptions.ins_class": {"fullname": "redlines.redlines.RedlinesOptions.ins_class", "modulename": "redlines.redlines", "qualname": "RedlinesOptions.ins_class", "kind": "variable", "doc": "

The CSS class to use for insertions when markdown_style is set to custom_css. Defaults to 'redline-inserted'.

\n", "annotation": ": str"}, "redlines.redlines.RedlinesOptions.del_class": {"fullname": "redlines.redlines.RedlinesOptions.del_class", "modulename": "redlines.redlines", "qualname": "RedlinesOptions.del_class", "kind": "variable", "doc": "

The CSS class to use for deletions when markdown_style is set to custom_css. Defaults to 'redline-deleted'.

\n", "annotation": ": str"}}, "docInfo": {"redlines": {"qualname": 0, "fullname": 1, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 422}, "redlines.cli": {"qualname": 0, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 462}, "redlines.document": {"qualname": 0, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "redlines.document.Document": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 77}, "redlines.document.Document.text": {"qualname": 2, "fullname": 4, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 29}, "redlines.document.PlainTextFile": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 175}, "redlines.document.PlainTextFile.__init__": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 33}, "redlines.document.PlainTextFile.text": {"qualname": 2, "fullname": 4, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 22}, "redlines.enums": {"qualname": 0, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "redlines.enums.MarkdownStyle": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 4, "doc": 9}, "redlines.enums.MarkdownStyle.RED_GREEN": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 11, "signature": 0, "bases": 0, "doc": 12}, "redlines.enums.MarkdownStyle.NONE": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 5}, "redlines.enums.MarkdownStyle.RED": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 8}, "redlines.enums.MarkdownStyle.GHFM": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 7}, "redlines.enums.MarkdownStyle.BBCODE": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 5}, "redlines.enums.MarkdownStyle.STREAMLIT": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 5}, "redlines.enums.OutputType": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 4, "doc": 9}, "redlines.enums.OutputType.MARKDOWN": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 5}, "redlines.enums.OutputType.RICH": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 8}, "redlines.processor": {"qualname": 0, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "redlines.processor.RedlinesProcessor": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 57}, "redlines.processor.RedlinesProcessor.process": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 85, "bases": 0, "doc": 3}, "redlines.processor.WholeDocumentProcessor": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 19}, "redlines.processor.WholeDocumentProcessor.process": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 85, "bases": 0, "doc": 63}, "redlines.processor.Redline": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 39}, "redlines.processor.Redline.__init__": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 141, "bases": 0, "doc": 3}, "redlines.processor.Redline.operation": {"qualname": 2, "fullname": 4, "annotation": 12, "default_value": 0, "signature": 0, "bases": 0, "doc": 11}, "redlines.processor.Redline.source_text": {"qualname": 3, "fullname": 5, "annotation": 4, "default_value": 0, "signature": 0, "bases": 0, "doc": 15}, "redlines.processor.Redline.test_text": {"qualname": 3, "fullname": 5, "annotation": 4, "default_value": 0, "signature": 0, "bases": 0, "doc": 15}, "redlines.processor.Redline.source_position": {"qualname": 3, "fullname": 5, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 14}, "redlines.processor.Redline.test_position": {"qualname": 3, "fullname": 5, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 14}, "redlines.processor.Stats": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 26}, "redlines.processor.Stats.__init__": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 49, "bases": 0, "doc": 3}, "redlines.processor.Stats.total_changes": {"qualname": 3, "fullname": 5, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 12}, "redlines.processor.Stats.deletions": {"qualname": 2, "fullname": 4, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 6}, "redlines.processor.Stats.insertions": {"qualname": 2, "fullname": 4, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 6}, "redlines.processor.Stats.replacements": {"qualname": 2, "fullname": 4, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 6}, "redlines.processor.DiffOperation": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 14}, "redlines.processor.DiffOperation.__init__": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 89, "bases": 0, "doc": 3}, "redlines.processor.DiffOperation.source_chunk": {"qualname": 3, "fullname": 5, "annotation": 4, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "redlines.processor.DiffOperation.test_chunk": {"qualname": 3, "fullname": 5, "annotation": 4, "default_value": 0, "signature": 0, "bases": 0, "doc": 10}, "redlines.processor.DiffOperation.opcodes": {"qualname": 2, "fullname": 4, "annotation": 6, "default_value": 0, "signature": 0, "bases": 0, "doc": 15}, "redlines.processor.Chunk": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 19}, "redlines.processor.Chunk.__init__": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 37, "bases": 0, "doc": 3}, "redlines.processor.Chunk.text": {"qualname": 2, "fullname": 4, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 7}, "redlines.processor.Chunk.chunk_location": {"qualname": 3, "fullname": 5, "annotation": 4, "default_value": 0, "signature": 0, "bases": 0, "doc": 20}, "redlines.redlines": {"qualname": 0, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "redlines.redlines.Redlines": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "redlines.redlines.Redlines.__init__": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 100, "bases": 0, "doc": 373}, "redlines.redlines.Redlines.source": {"qualname": 2, "fullname": 4, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 36}, "redlines.redlines.Redlines.test": {"qualname": 2, "fullname": 4, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 30}, "redlines.redlines.Redlines.redlines": {"qualname": 2, "fullname": 4, "annotation": 4, "default_value": 0, "signature": 0, "bases": 0, "doc": 56}, "redlines.redlines.Redlines.processor": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "redlines.redlines.Redlines.options": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "redlines.redlines.Redlines.opcodes": {"qualname": 2, "fullname": 4, "annotation": 6, "default_value": 0, "signature": 0, "bases": 0, "doc": 188}, "redlines.redlines.Redlines.changes": {"qualname": 2, "fullname": 4, "annotation": 4, "default_value": 0, "signature": 0, "bases": 0, "doc": 230}, "redlines.redlines.Redlines.get_changes": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 53, "bases": 0, "doc": 267}, "redlines.redlines.Redlines.stats": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 24, "bases": 0, "doc": 243}, "redlines.redlines.Redlines.output_markdown": {"qualname": 3, "fullname": 5, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 732}, "redlines.redlines.Redlines.output_rich": {"qualname": 3, "fullname": 5, "annotation": 4, "default_value": 0, "signature": 0, "bases": 0, "doc": 32}, "redlines.redlines.Redlines.compare": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 164, "bases": 0, "doc": 106}, "redlines.redlines.RedlinesOptions": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 3}, "redlines.redlines.RedlinesOptions.markdown_style": {"qualname": 3, "fullname": 5, "annotation": 8, "default_value": 0, "signature": 0, "bases": 0, "doc": 19}, "redlines.redlines.RedlinesOptions.ins_class": {"qualname": 3, "fullname": 5, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 26}, "redlines.redlines.RedlinesOptions.del_class": {"qualname": 3, "fullname": 5, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 26}}, "length": 65, "save": true}, "index": {"qualname": {"root": {"docs": {"redlines.document.PlainTextFile.__init__": {"tf": 1}, "redlines.processor.Redline.__init__": {"tf": 1}, "redlines.processor.Stats.__init__": {"tf": 1}, "redlines.processor.DiffOperation.__init__": {"tf": 1}, "redlines.processor.Chunk.__init__": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 6, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"redlines.document.Document": {"tf": 1}, "redlines.document.Document.text": {"tf": 1}}, "df": 2}}}}}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {"redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.Stats.deletions": {"tf": 1}}, "df": 1}}}}}}}}, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.processor.DiffOperation": {"tf": 1}, "redlines.processor.DiffOperation.__init__": {"tf": 1}, "redlines.processor.DiffOperation.source_chunk": {"tf": 1}, "redlines.processor.DiffOperation.test_chunk": {"tf": 1}, "redlines.processor.DiffOperation.opcodes": {"tf": 1}}, "df": 5}}}}}}}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {"redlines.document.Document.text": {"tf": 1}, "redlines.document.PlainTextFile.text": {"tf": 1}, "redlines.processor.Redline.source_text": {"tf": 1}, "redlines.processor.Redline.test_text": {"tf": 1}, "redlines.processor.Chunk.text": {"tf": 1}}, "df": 5}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"redlines.processor.Redline.test_text": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}, "redlines.processor.DiffOperation.test_chunk": {"tf": 1}, "redlines.redlines.Redlines.test": {"tf": 1}}, "df": 4}}}, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"redlines.processor.Stats.total_changes": {"tf": 1}}, "df": 1}}}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.document.PlainTextFile": {"tf": 1}, "redlines.document.PlainTextFile.__init__": {"tf": 1}, "redlines.document.PlainTextFile.text": {"tf": 1}}, "df": 3}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.RedlinesProcessor.process": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}}, "df": 2, "o": {"docs": {}, "df": 0, "r": {"docs": {"redlines.redlines.Redlines.processor": {"tf": 1}}, "df": 1}}}}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}}, "df": 2}}}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"redlines.document.PlainTextFile.__init__": {"tf": 1}, "redlines.processor.Redline.__init__": {"tf": 1}, "redlines.processor.Stats.__init__": {"tf": 1}, "redlines.processor.DiffOperation.__init__": {"tf": 1}, "redlines.processor.Chunk.__init__": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 6}}, "s": {"docs": {"redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.Stats.insertions": {"tf": 1}}, "df": 1}}}}}}}}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "n": {"docs": {"redlines.enums.OutputType.MARKDOWN": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1}}, "df": 3, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.enums.MarkdownStyle": {"tf": 1}, "redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1}, "redlines.enums.MarkdownStyle.NONE": {"tf": 1}, "redlines.enums.MarkdownStyle.RED": {"tf": 1}, "redlines.enums.MarkdownStyle.GHFM": {"tf": 1}, "redlines.enums.MarkdownStyle.BBCODE": {"tf": 1}, "redlines.enums.MarkdownStyle.STREAMLIT": {"tf": 1}}, "df": 7}}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1}, "redlines.enums.MarkdownStyle.RED": {"tf": 1}}, "df": 2, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.Redline": {"tf": 1}, "redlines.processor.Redline.__init__": {"tf": 1}, "redlines.processor.Redline.operation": {"tf": 1}, "redlines.processor.Redline.source_text": {"tf": 1}, "redlines.processor.Redline.test_text": {"tf": 1}, "redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}}, "df": 7, "s": {"docs": {"redlines.redlines.Redlines": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.source": {"tf": 1}, "redlines.redlines.Redlines.test": {"tf": 1}, "redlines.redlines.Redlines.redlines": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.processor": {"tf": 1}, "redlines.redlines.Redlines.options": {"tf": 1}, "redlines.redlines.Redlines.opcodes": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}, "redlines.redlines.Redlines.output_rich": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 14, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.processor.RedlinesProcessor.process": {"tf": 1}}, "df": 2}}}}}}}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.RedlinesOptions": {"tf": 1}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 4}}}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.Stats.replacements": {"tf": 1}}, "df": 1}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"redlines.enums.OutputType.RICH": {"tf": 1}, "redlines.redlines.Redlines.output_rich": {"tf": 1}}, "df": 2}}}}, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1}}, "df": 1}}}}, "h": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "m": {"docs": {"redlines.enums.MarkdownStyle.GHFM": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {"redlines.redlines.Redlines.get_changes": {"tf": 1}}, "df": 1}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"redlines.enums.MarkdownStyle.NONE": {"tf": 1}}, "df": 1}}}}, "b": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"redlines.enums.MarkdownStyle.BBCODE": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"redlines.enums.MarkdownStyle.STREAMLIT": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.Stats": {"tf": 1}, "redlines.processor.Stats.__init__": {"tf": 1}, "redlines.processor.Stats.total_changes": {"tf": 1}, "redlines.processor.Stats.deletions": {"tf": 1}, "redlines.processor.Stats.insertions": {"tf": 1}, "redlines.processor.Stats.replacements": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 1}}, "df": 7}}}, "y": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.Redline.source_text": {"tf": 1}, "redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.DiffOperation.source_chunk": {"tf": 1}, "redlines.redlines.Redlines.source": {"tf": 1}}, "df": 4}}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}, "redlines.redlines.Redlines.output_rich": {"tf": 1}}, "df": 2, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"redlines.enums.OutputType": {"tf": 1}, "redlines.enums.OutputType.MARKDOWN": {"tf": 1}, "redlines.enums.OutputType.RICH": {"tf": 1}}, "df": 3}}}}}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.processor.Redline.operation": {"tf": 1}}, "df": 1}}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.DiffOperation.opcodes": {"tf": 1}, "redlines.redlines.Redlines.opcodes": {"tf": 1}}, "df": 2}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.options": {"tf": 1}}, "df": 1}}}}}}}, "w": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"redlines.processor.WholeDocumentProcessor": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}}, "df": 2}}}}}}}}}}}}}}}}}}}}}}, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.Stats.total_changes": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1}}, "df": 3}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "k": {"docs": {"redlines.processor.DiffOperation.source_chunk": {"tf": 1}, "redlines.processor.DiffOperation.test_chunk": {"tf": 1}, "redlines.processor.Chunk": {"tf": 1}, "redlines.processor.Chunk.__init__": {"tf": 1}, "redlines.processor.Chunk.text": {"tf": 1}, "redlines.processor.Chunk.chunk_location": {"tf": 1.4142135623730951}}, "df": 6}}}}, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 1}}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 2}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.processor.Chunk.chunk_location": {"tf": 1}}, "df": 1}}}}}}}}}}, "fullname": {"root": {"docs": {"redlines.document.PlainTextFile.__init__": {"tf": 1}, "redlines.processor.Redline.__init__": {"tf": 1}, "redlines.processor.Stats.__init__": {"tf": 1}, "redlines.processor.DiffOperation.__init__": {"tf": 1}, "redlines.processor.Chunk.__init__": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 6, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1}, "redlines.enums.MarkdownStyle.RED": {"tf": 1}}, "df": 2, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.Redline": {"tf": 1}, "redlines.processor.Redline.__init__": {"tf": 1}, "redlines.processor.Redline.operation": {"tf": 1}, "redlines.processor.Redline.source_text": {"tf": 1}, "redlines.processor.Redline.test_text": {"tf": 1}, "redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}}, "df": 7, "s": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1}, "redlines.document": {"tf": 1}, "redlines.document.Document": {"tf": 1}, "redlines.document.Document.text": {"tf": 1}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.document.PlainTextFile.__init__": {"tf": 1}, "redlines.document.PlainTextFile.text": {"tf": 1}, "redlines.enums": {"tf": 1}, "redlines.enums.MarkdownStyle": {"tf": 1}, "redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1}, "redlines.enums.MarkdownStyle.NONE": {"tf": 1}, "redlines.enums.MarkdownStyle.RED": {"tf": 1}, "redlines.enums.MarkdownStyle.GHFM": {"tf": 1}, "redlines.enums.MarkdownStyle.BBCODE": {"tf": 1}, "redlines.enums.MarkdownStyle.STREAMLIT": {"tf": 1}, "redlines.enums.OutputType": {"tf": 1}, "redlines.enums.OutputType.MARKDOWN": {"tf": 1}, "redlines.enums.OutputType.RICH": {"tf": 1}, "redlines.processor": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.processor.RedlinesProcessor.process": {"tf": 1}, "redlines.processor.WholeDocumentProcessor": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}, "redlines.processor.Redline": {"tf": 1}, "redlines.processor.Redline.__init__": {"tf": 1}, "redlines.processor.Redline.operation": {"tf": 1}, "redlines.processor.Redline.source_text": {"tf": 1}, "redlines.processor.Redline.test_text": {"tf": 1}, "redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}, "redlines.processor.Stats": {"tf": 1}, "redlines.processor.Stats.__init__": {"tf": 1}, "redlines.processor.Stats.total_changes": {"tf": 1}, "redlines.processor.Stats.deletions": {"tf": 1}, "redlines.processor.Stats.insertions": {"tf": 1}, "redlines.processor.Stats.replacements": {"tf": 1}, "redlines.processor.DiffOperation": {"tf": 1}, "redlines.processor.DiffOperation.__init__": {"tf": 1}, "redlines.processor.DiffOperation.source_chunk": {"tf": 1}, "redlines.processor.DiffOperation.test_chunk": {"tf": 1}, "redlines.processor.DiffOperation.opcodes": {"tf": 1}, "redlines.processor.Chunk": {"tf": 1}, "redlines.processor.Chunk.__init__": {"tf": 1}, "redlines.processor.Chunk.text": {"tf": 1}, "redlines.processor.Chunk.chunk_location": {"tf": 1}, "redlines.redlines": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.__init__": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.source": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.test": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.redlines": {"tf": 2}, "redlines.redlines.Redlines.processor": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.options": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.opcodes": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.changes": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.get_changes": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.stats": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.output_rich": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.compare": {"tf": 1.7320508075688772}, "redlines.redlines.RedlinesOptions": {"tf": 1.4142135623730951}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1.4142135623730951}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1.4142135623730951}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1.4142135623730951}}, "df": 65, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.processor.RedlinesProcessor.process": {"tf": 1}}, "df": 2}}}}}}}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.RedlinesOptions": {"tf": 1}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 4}}}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.Stats.replacements": {"tf": 1}}, "df": 1}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"redlines.enums.OutputType.RICH": {"tf": 1}, "redlines.redlines.Redlines.output_rich": {"tf": 1}}, "df": 2}}}}, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {"redlines.cli": {"tf": 1}}, "df": 1}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 2}}}}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.Stats.total_changes": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1}}, "df": 3}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "k": {"docs": {"redlines.processor.DiffOperation.source_chunk": {"tf": 1}, "redlines.processor.DiffOperation.test_chunk": {"tf": 1}, "redlines.processor.Chunk": {"tf": 1}, "redlines.processor.Chunk.__init__": {"tf": 1}, "redlines.processor.Chunk.text": {"tf": 1}, "redlines.processor.Chunk.chunk_location": {"tf": 1.4142135623730951}}, "df": 6}}}}, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 1}}}}}}}, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"redlines.document": {"tf": 1}, "redlines.document.Document": {"tf": 1.4142135623730951}, "redlines.document.Document.text": {"tf": 1.4142135623730951}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.document.PlainTextFile.__init__": {"tf": 1}, "redlines.document.PlainTextFile.text": {"tf": 1}}, "df": 6}}}}}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {"redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.Stats.deletions": {"tf": 1}}, "df": 1}}}}}}}}, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.processor.DiffOperation": {"tf": 1}, "redlines.processor.DiffOperation.__init__": {"tf": 1}, "redlines.processor.DiffOperation.source_chunk": {"tf": 1}, "redlines.processor.DiffOperation.test_chunk": {"tf": 1}, "redlines.processor.DiffOperation.opcodes": {"tf": 1}}, "df": 5}}}}}}}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {"redlines.document.Document.text": {"tf": 1}, "redlines.document.PlainTextFile.text": {"tf": 1}, "redlines.processor.Redline.source_text": {"tf": 1}, "redlines.processor.Redline.test_text": {"tf": 1}, "redlines.processor.Chunk.text": {"tf": 1}}, "df": 5}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"redlines.processor.Redline.test_text": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}, "redlines.processor.DiffOperation.test_chunk": {"tf": 1}, "redlines.redlines.Redlines.test": {"tf": 1}}, "df": 4}}}, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"redlines.processor.Stats.total_changes": {"tf": 1}}, "df": 1}}}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.document.PlainTextFile": {"tf": 1}, "redlines.document.PlainTextFile.__init__": {"tf": 1}, "redlines.document.PlainTextFile.text": {"tf": 1}}, "df": 3}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.RedlinesProcessor.process": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}}, "df": 2, "o": {"docs": {}, "df": 0, "r": {"docs": {"redlines.processor": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.processor.RedlinesProcessor.process": {"tf": 1}, "redlines.processor.WholeDocumentProcessor": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}, "redlines.processor.Redline": {"tf": 1}, "redlines.processor.Redline.__init__": {"tf": 1}, "redlines.processor.Redline.operation": {"tf": 1}, "redlines.processor.Redline.source_text": {"tf": 1}, "redlines.processor.Redline.test_text": {"tf": 1}, "redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}, "redlines.processor.Stats": {"tf": 1}, "redlines.processor.Stats.__init__": {"tf": 1}, "redlines.processor.Stats.total_changes": {"tf": 1}, "redlines.processor.Stats.deletions": {"tf": 1}, "redlines.processor.Stats.insertions": {"tf": 1}, "redlines.processor.Stats.replacements": {"tf": 1}, "redlines.processor.DiffOperation": {"tf": 1}, "redlines.processor.DiffOperation.__init__": {"tf": 1}, "redlines.processor.DiffOperation.source_chunk": {"tf": 1}, "redlines.processor.DiffOperation.test_chunk": {"tf": 1}, "redlines.processor.DiffOperation.opcodes": {"tf": 1}, "redlines.processor.Chunk": {"tf": 1}, "redlines.processor.Chunk.__init__": {"tf": 1}, "redlines.processor.Chunk.text": {"tf": 1}, "redlines.processor.Chunk.chunk_location": {"tf": 1}, "redlines.redlines.Redlines.processor": {"tf": 1}}, "df": 28}}}}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}}, "df": 2}}}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"redlines.document.PlainTextFile.__init__": {"tf": 1}, "redlines.processor.Redline.__init__": {"tf": 1}, "redlines.processor.Stats.__init__": {"tf": 1}, "redlines.processor.DiffOperation.__init__": {"tf": 1}, "redlines.processor.Chunk.__init__": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 6}}, "s": {"docs": {"redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.Stats.insertions": {"tf": 1}}, "df": 1}}}}}}}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"redlines.enums": {"tf": 1}, "redlines.enums.MarkdownStyle": {"tf": 1}, "redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1}, "redlines.enums.MarkdownStyle.NONE": {"tf": 1}, "redlines.enums.MarkdownStyle.RED": {"tf": 1}, "redlines.enums.MarkdownStyle.GHFM": {"tf": 1}, "redlines.enums.MarkdownStyle.BBCODE": {"tf": 1}, "redlines.enums.MarkdownStyle.STREAMLIT": {"tf": 1}, "redlines.enums.OutputType": {"tf": 1}, "redlines.enums.OutputType.MARKDOWN": {"tf": 1}, "redlines.enums.OutputType.RICH": {"tf": 1}}, "df": 11}}}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "n": {"docs": {"redlines.enums.OutputType.MARKDOWN": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1}}, "df": 3, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.enums.MarkdownStyle": {"tf": 1}, "redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1}, "redlines.enums.MarkdownStyle.NONE": {"tf": 1}, "redlines.enums.MarkdownStyle.RED": {"tf": 1}, "redlines.enums.MarkdownStyle.GHFM": {"tf": 1}, "redlines.enums.MarkdownStyle.BBCODE": {"tf": 1}, "redlines.enums.MarkdownStyle.STREAMLIT": {"tf": 1}}, "df": 7}}}}}}}}}}}}}, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1}}, "df": 1}}}}, "h": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "m": {"docs": {"redlines.enums.MarkdownStyle.GHFM": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {"redlines.redlines.Redlines.get_changes": {"tf": 1}}, "df": 1}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"redlines.enums.MarkdownStyle.NONE": {"tf": 1}}, "df": 1}}}}, "b": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"redlines.enums.MarkdownStyle.BBCODE": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"redlines.enums.MarkdownStyle.STREAMLIT": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.Stats": {"tf": 1}, "redlines.processor.Stats.__init__": {"tf": 1}, "redlines.processor.Stats.total_changes": {"tf": 1}, "redlines.processor.Stats.deletions": {"tf": 1}, "redlines.processor.Stats.insertions": {"tf": 1}, "redlines.processor.Stats.replacements": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 1}}, "df": 7}}}, "y": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.Redline.source_text": {"tf": 1}, "redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.DiffOperation.source_chunk": {"tf": 1}, "redlines.redlines.Redlines.source": {"tf": 1}}, "df": 4}}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}, "redlines.redlines.Redlines.output_rich": {"tf": 1}}, "df": 2, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"redlines.enums.OutputType": {"tf": 1}, "redlines.enums.OutputType.MARKDOWN": {"tf": 1}, "redlines.enums.OutputType.RICH": {"tf": 1}}, "df": 3}}}}}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.processor.Redline.operation": {"tf": 1}}, "df": 1}}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.DiffOperation.opcodes": {"tf": 1}, "redlines.redlines.Redlines.opcodes": {"tf": 1}}, "df": 2}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.options": {"tf": 1}}, "df": 1}}}}}}}, "w": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"redlines.processor.WholeDocumentProcessor": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}}, "df": 2}}}}}}}}}}}}}}}}}}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.processor.Chunk.chunk_location": {"tf": 1}}, "df": 1}}}}}}}}}}, "annotation": {"root": {"docs": {"redlines.document.Document.text": {"tf": 1}, "redlines.document.PlainTextFile.text": {"tf": 1}, "redlines.processor.Redline.operation": {"tf": 1.4142135623730951}, "redlines.processor.Redline.source_text": {"tf": 1.4142135623730951}, "redlines.processor.Redline.test_text": {"tf": 1.4142135623730951}, "redlines.processor.Redline.source_position": {"tf": 1.4142135623730951}, "redlines.processor.Redline.test_position": {"tf": 1.4142135623730951}, "redlines.processor.Stats.total_changes": {"tf": 1}, "redlines.processor.Stats.deletions": {"tf": 1}, "redlines.processor.Stats.insertions": {"tf": 1}, "redlines.processor.Stats.replacements": {"tf": 1}, "redlines.processor.DiffOperation.source_chunk": {"tf": 1}, "redlines.processor.DiffOperation.test_chunk": {"tf": 1}, "redlines.processor.DiffOperation.opcodes": {"tf": 1}, "redlines.processor.Chunk.text": {"tf": 1}, "redlines.processor.Chunk.chunk_location": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.source": {"tf": 1}, "redlines.redlines.Redlines.test": {"tf": 1}, "redlines.redlines.Redlines.redlines": {"tf": 1}, "redlines.redlines.Redlines.opcodes": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}, "redlines.redlines.Redlines.output_rich": {"tf": 1}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1.7320508075688772}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 26, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"redlines.document.Document.text": {"tf": 1}, "redlines.document.PlainTextFile.text": {"tf": 1}, "redlines.processor.Redline.source_text": {"tf": 1}, "redlines.processor.Redline.test_text": {"tf": 1}, "redlines.processor.Chunk.chunk_location": {"tf": 1}, "redlines.redlines.Redlines.source": {"tf": 1}, "redlines.redlines.Redlines.test": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 11}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"redlines.processor.Redline.operation": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"redlines.processor.Chunk.text": {"tf": 1}}, "df": 1}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.redlines": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}}, "df": 2}}}}}}}}, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"redlines.redlines.Redlines.opcodes": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "x": {"2": {"7": {"docs": {"redlines.processor.Redline.operation": {"tf": 2.449489742783178}}, "df": 1}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.Redline.operation": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"redlines.processor.Redline.operation": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {"redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}, "redlines.processor.Stats.total_changes": {"tf": 1}, "redlines.processor.Stats.deletions": {"tf": 1}, "redlines.processor.Stats.insertions": {"tf": 1}, "redlines.processor.Stats.replacements": {"tf": 1}, "redlines.processor.DiffOperation.opcodes": {"tf": 2}, "redlines.redlines.Redlines.opcodes": {"tf": 2}}, "df": 8}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.Redline.operation": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.redlines": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}}, "df": 2, "s": {"docs": {"redlines.processor.DiffOperation.source_chunk": {"tf": 1}, "redlines.processor.DiffOperation.test_chunk": {"tf": 1}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1}}, "df": 3}}}}}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"redlines.redlines.Redlines.output_rich": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.Redline.source_text": {"tf": 1}, "redlines.processor.Redline.test_text": {"tf": 1}, "redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}, "redlines.processor.Chunk.chunk_location": {"tf": 1}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1}}, "df": 6}}}}, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}}, "df": 2}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"redlines.processor.DiffOperation.opcodes": {"tf": 1}}, "df": 1}}}}}}}}, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {"redlines.redlines.Redlines.output_rich": {"tf": 1.4142135623730951}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"redlines.processor.DiffOperation.source_chunk": {"tf": 1}, "redlines.processor.DiffOperation.test_chunk": {"tf": 1}, "redlines.redlines.Redlines.redlines": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}}, "df": 4}}}}}}}}}, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "k": {"docs": {"redlines.processor.DiffOperation.source_chunk": {"tf": 1}, "redlines.processor.DiffOperation.test_chunk": {"tf": 1}}, "df": 2}}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1}}, "df": 1}}}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}, "default_value": {"root": {"docs": {"redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1.4142135623730951}, "redlines.enums.MarkdownStyle.NONE": {"tf": 1.4142135623730951}, "redlines.enums.MarkdownStyle.RED": {"tf": 1.4142135623730951}, "redlines.enums.MarkdownStyle.GHFM": {"tf": 1.4142135623730951}, "redlines.enums.MarkdownStyle.BBCODE": {"tf": 1.4142135623730951}, "redlines.enums.MarkdownStyle.STREAMLIT": {"tf": 1.4142135623730951}, "redlines.enums.OutputType.MARKDOWN": {"tf": 1.4142135623730951}, "redlines.enums.OutputType.RICH": {"tf": 1.4142135623730951}}, "df": 8, "l": {"docs": {}, "df": 0, "t": {"docs": {"redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1}, "redlines.enums.MarkdownStyle.NONE": {"tf": 1}, "redlines.enums.MarkdownStyle.RED": {"tf": 1}, "redlines.enums.MarkdownStyle.GHFM": {"tf": 1}, "redlines.enums.MarkdownStyle.BBCODE": {"tf": 1}, "redlines.enums.MarkdownStyle.STREAMLIT": {"tf": 1}, "redlines.enums.OutputType.MARKDOWN": {"tf": 1}, "redlines.enums.OutputType.RICH": {"tf": 1}}, "df": 8}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "n": {"docs": {"redlines.enums.OutputType.MARKDOWN": {"tf": 1.4142135623730951}}, "df": 1, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1}, "redlines.enums.MarkdownStyle.NONE": {"tf": 1}, "redlines.enums.MarkdownStyle.RED": {"tf": 1}, "redlines.enums.MarkdownStyle.GHFM": {"tf": 1}, "redlines.enums.MarkdownStyle.BBCODE": {"tf": 1}, "redlines.enums.MarkdownStyle.STREAMLIT": {"tf": 1}}, "df": 6}}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1.4142135623730951}, "redlines.enums.MarkdownStyle.RED": {"tf": 1.4142135623730951}}, "df": 2}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"redlines.enums.OutputType.RICH": {"tf": 1.4142135623730951}}, "df": 1}}}}, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1.4142135623730951}}, "df": 1}}}}, "t": {"docs": {"redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1}, "redlines.enums.MarkdownStyle.NONE": {"tf": 1}, "redlines.enums.MarkdownStyle.RED": {"tf": 1}, "redlines.enums.MarkdownStyle.GHFM": {"tf": 1}, "redlines.enums.MarkdownStyle.BBCODE": {"tf": 1}, "redlines.enums.MarkdownStyle.STREAMLIT": {"tf": 1}, "redlines.enums.OutputType.MARKDOWN": {"tf": 1}, "redlines.enums.OutputType.RICH": {"tf": 1}}, "df": 8}, "h": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "m": {"docs": {"redlines.enums.MarkdownStyle.GHFM": {"tf": 1.4142135623730951}}, "df": 1}}}}, "x": {"2": {"7": {"docs": {"redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1.4142135623730951}, "redlines.enums.MarkdownStyle.NONE": {"tf": 1.4142135623730951}, "redlines.enums.MarkdownStyle.RED": {"tf": 1.4142135623730951}, "redlines.enums.MarkdownStyle.GHFM": {"tf": 1.4142135623730951}, "redlines.enums.MarkdownStyle.BBCODE": {"tf": 1.4142135623730951}, "redlines.enums.MarkdownStyle.STREAMLIT": {"tf": 1.4142135623730951}, "redlines.enums.OutputType.MARKDOWN": {"tf": 1.4142135623730951}, "redlines.enums.OutputType.RICH": {"tf": 1.4142135623730951}}, "df": 8}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"redlines.enums.MarkdownStyle.NONE": {"tf": 1.4142135623730951}}, "df": 1}}}}, "b": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"redlines.enums.MarkdownStyle.BBCODE": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"redlines.enums.MarkdownStyle.STREAMLIT": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"redlines.enums.OutputType.MARKDOWN": {"tf": 1}, "redlines.enums.OutputType.RICH": {"tf": 1}}, "df": 2}}}}}}}}}}}}, "signature": {"root": {"3": {"9": {"docs": {"redlines.processor.Redline.__init__": {"tf": 2.449489742783178}, "redlines.redlines.Redlines.compare": {"tf": 2.449489742783178}}, "df": 2}, "docs": {}, "df": 0}, "docs": {"redlines.document.PlainTextFile.__init__": {"tf": 5.5677643628300215}, "redlines.processor.RedlinesProcessor.process": {"tf": 8.366600265340756}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 8.366600265340756}, "redlines.processor.Redline.__init__": {"tf": 10.488088481701515}, "redlines.processor.Stats.__init__": {"tf": 6.324555320336759}, "redlines.processor.DiffOperation.__init__": {"tf": 8.48528137423857}, "redlines.processor.Chunk.__init__": {"tf": 5.477225575051661}, "redlines.redlines.Redlines.__init__": {"tf": 9.1104335791443}, "redlines.redlines.Redlines.get_changes": {"tf": 6.6332495807108}, "redlines.redlines.Redlines.stats": {"tf": 4.47213595499958}, "redlines.redlines.Redlines.compare": {"tf": 11.445523142259598}}, "df": 11, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.document.PlainTextFile.__init__": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"redlines.document.PlainTextFile.__init__": {"tf": 1}}, "df": 1, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {"redlines.document.PlainTextFile.__init__": {"tf": 1}}, "df": 1}}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"redlines.processor.RedlinesProcessor.process": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}, "redlines.processor.DiffOperation.__init__": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.get_changes": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 1}}, "df": 5}}}}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.processor.Redline.__init__": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"redlines.document.PlainTextFile.__init__": {"tf": 1.4142135623730951}, "redlines.processor.RedlinesProcessor.process": {"tf": 1.4142135623730951}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1.4142135623730951}, "redlines.processor.Redline.__init__": {"tf": 1.4142135623730951}, "redlines.processor.DiffOperation.__init__": {"tf": 1}, "redlines.processor.Chunk.__init__": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.__init__": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.get_changes": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1.4142135623730951}}, "df": 9}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.stats": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "f": {"docs": {"redlines.processor.RedlinesProcessor.process": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 5}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.RedlinesProcessor.process": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}, "redlines.processor.Redline.__init__": {"tf": 1.4142135623730951}, "redlines.processor.DiffOperation.__init__": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 5}}}}}}, "b": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines.document.PlainTextFile.__init__": {"tf": 1}}, "df": 1}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {"redlines.document.PlainTextFile.__init__": {"tf": 1}}, "df": 1}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.processor.Redline.__init__": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1}}, "df": 2}}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.DiffOperation.__init__": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 2}}}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 1, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.compare": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.get_changes": {"tf": 1}}, "df": 1, "s": {"docs": {"redlines.processor.RedlinesProcessor.process": {"tf": 1.7320508075688772}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1.7320508075688772}, "redlines.processor.DiffOperation.__init__": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.__init__": {"tf": 2}, "redlines.redlines.Redlines.get_changes": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1.7320508075688772}}, "df": 7, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 2}}}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.Redline.__init__": {"tf": 1}}, "df": 1, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.Stats.__init__": {"tf": 1}}, "df": 1}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"redlines.redlines.Redlines.compare": {"tf": 1.4142135623730951}}, "df": 1}}}}, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"redlines.processor.RedlinesProcessor.process": {"tf": 2}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 2}, "redlines.redlines.Redlines.__init__": {"tf": 2}}, "df": 3}}}}}}}, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.processor.RedlinesProcessor.process": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}}, "df": 2}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.Redline.__init__": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.Stats.__init__": {"tf": 1}}, "df": 1}}}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"redlines.processor.RedlinesProcessor.process": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}, "redlines.processor.Redline.__init__": {"tf": 1.4142135623730951}, "redlines.processor.DiffOperation.__init__": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 6}}, "x": {"docs": {}, "df": 0, "t": {"docs": {"redlines.processor.Redline.__init__": {"tf": 1.4142135623730951}, "redlines.processor.Chunk.__init__": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1.4142135623730951}}, "df": 3}}}, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.Redline.__init__": {"tf": 1.4142135623730951}, "redlines.processor.DiffOperation.__init__": {"tf": 1}}, "df": 2}}}}, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"redlines.processor.Stats.__init__": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"redlines.processor.RedlinesProcessor.process": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}, "redlines.processor.Chunk.__init__": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1}}, "df": 4}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"redlines.processor.Redline.__init__": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 2}}}}}}, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.processor.Chunk.__init__": {"tf": 1}}, "df": 1}}}}}}}, "t": {"docs": {"redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"redlines.processor.Redline.__init__": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.Stats.__init__": {"tf": 1}}, "df": 1}}}}}}}}, "t": {"docs": {"redlines.processor.Redline.__init__": {"tf": 2}, "redlines.processor.Stats.__init__": {"tf": 2}, "redlines.processor.DiffOperation.__init__": {"tf": 2}}, "df": 3}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.Redline.__init__": {"tf": 2}, "redlines.processor.Chunk.__init__": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.get_changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.compare": {"tf": 1.4142135623730951}}, "df": 5}}}}, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.Stats.__init__": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "k": {"docs": {"redlines.processor.DiffOperation.__init__": {"tf": 2}, "redlines.processor.Chunk.__init__": {"tf": 1}}, "df": 2}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 2}}}}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 1}}}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "n": {"docs": {"redlines.redlines.Redlines.compare": {"tf": 1.7320508075688772}}, "df": 1}}}}}}}}, "g": {"docs": {}, "df": 0, "t": {"docs": {"redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 1}}}}, "bases": {"root": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "c": {"docs": {"redlines.document.Document": {"tf": 1.4142135623730951}, "redlines.processor.RedlinesProcessor": {"tf": 1.4142135623730951}}, "df": 2}}}, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"redlines.document.PlainTextFile": {"tf": 1}}, "df": 1}}}}}}}}, "b": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"redlines.enums.MarkdownStyle": {"tf": 1}, "redlines.enums.OutputType": {"tf": 1}}, "df": 2}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"redlines.enums.MarkdownStyle": {"tf": 1}, "redlines.enums.OutputType": {"tf": 1}}, "df": 2}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {"redlines.enums.MarkdownStyle": {"tf": 1.4142135623730951}, "redlines.enums.OutputType": {"tf": 1.4142135623730951}}, "df": 2}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"redlines.processor.WholeDocumentProcessor": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines.redlines.RedlinesOptions": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"redlines.redlines.RedlinesOptions": {"tf": 1}}, "df": 1}}}}}}}}}}}, "doc": {"root": {"0": {"docs": {"redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 2}, "1": {"6": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 1}, "docs": {"redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 2}, "2": {"docs": {"redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}}, "df": 1}, "3": {"9": {"docs": {"redlines.document.PlainTextFile": {"tf": 2}, "redlines.redlines.Redlines.__init__": {"tf": 2}, "redlines.redlines.Redlines.opcodes": {"tf": 3.1622776601683795}}, "df": 3}, "docs": {}, "df": 0}, "4": {"docs": {"redlines.redlines.Redlines.opcodes": {"tf": 2}}, "df": 1}, "5": {"docs": {"redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}}, "df": 1}, "6": {"docs": {"redlines.cli": {"tf": 1}, "redlines.redlines.Redlines.opcodes": {"tf": 2}}, "df": 2}, "9": {"docs": {"redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}}, "df": 1}, "docs": {"redlines": {"tf": 12.206555615733702}, "redlines.cli": {"tf": 13.674794331177344}, "redlines.document": {"tf": 1.7320508075688772}, "redlines.document.Document": {"tf": 5.830951894845301}, "redlines.document.Document.text": {"tf": 1.7320508075688772}, "redlines.document.PlainTextFile": {"tf": 10}, "redlines.document.PlainTextFile.__init__": {"tf": 3.7416573867739413}, "redlines.document.PlainTextFile.text": {"tf": 3}, "redlines.enums": {"tf": 1.7320508075688772}, "redlines.enums.MarkdownStyle": {"tf": 1.7320508075688772}, "redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1.7320508075688772}, "redlines.enums.MarkdownStyle.NONE": {"tf": 1.7320508075688772}, "redlines.enums.MarkdownStyle.RED": {"tf": 1.7320508075688772}, "redlines.enums.MarkdownStyle.GHFM": {"tf": 1.7320508075688772}, "redlines.enums.MarkdownStyle.BBCODE": {"tf": 1.7320508075688772}, "redlines.enums.MarkdownStyle.STREAMLIT": {"tf": 1.7320508075688772}, "redlines.enums.OutputType": {"tf": 1.7320508075688772}, "redlines.enums.OutputType.MARKDOWN": {"tf": 1.7320508075688772}, "redlines.enums.OutputType.RICH": {"tf": 1.7320508075688772}, "redlines.processor": {"tf": 1.7320508075688772}, "redlines.processor.RedlinesProcessor": {"tf": 2.23606797749979}, "redlines.processor.RedlinesProcessor.process": {"tf": 1.7320508075688772}, "redlines.processor.WholeDocumentProcessor": {"tf": 1.7320508075688772}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 5.477225575051661}, "redlines.processor.Redline": {"tf": 2.449489742783178}, "redlines.processor.Redline.__init__": {"tf": 1.7320508075688772}, "redlines.processor.Redline.operation": {"tf": 1.7320508075688772}, "redlines.processor.Redline.source_text": {"tf": 1.7320508075688772}, "redlines.processor.Redline.test_text": {"tf": 1.7320508075688772}, "redlines.processor.Redline.source_position": {"tf": 1.7320508075688772}, "redlines.processor.Redline.test_position": {"tf": 1.7320508075688772}, "redlines.processor.Stats": {"tf": 2.449489742783178}, "redlines.processor.Stats.__init__": {"tf": 1.7320508075688772}, "redlines.processor.Stats.total_changes": {"tf": 2.23606797749979}, "redlines.processor.Stats.deletions": {"tf": 1.4142135623730951}, "redlines.processor.Stats.insertions": {"tf": 1.4142135623730951}, "redlines.processor.Stats.replacements": {"tf": 1.4142135623730951}, "redlines.processor.DiffOperation": {"tf": 1.7320508075688772}, "redlines.processor.DiffOperation.__init__": {"tf": 1.7320508075688772}, "redlines.processor.DiffOperation.source_chunk": {"tf": 1.7320508075688772}, "redlines.processor.DiffOperation.test_chunk": {"tf": 1.4142135623730951}, "redlines.processor.DiffOperation.opcodes": {"tf": 1.4142135623730951}, "redlines.processor.Chunk": {"tf": 1.4142135623730951}, "redlines.processor.Chunk.__init__": {"tf": 1.7320508075688772}, "redlines.processor.Chunk.text": {"tf": 1.4142135623730951}, "redlines.processor.Chunk.chunk_location": {"tf": 1.4142135623730951}, "redlines.redlines": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.__init__": {"tf": 13.638181696985855}, "redlines.redlines.Redlines.source": {"tf": 3.4641016151377544}, "redlines.redlines.Redlines.test": {"tf": 3.4641016151377544}, "redlines.redlines.Redlines.redlines": {"tf": 4}, "redlines.redlines.Redlines.processor": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.options": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.opcodes": {"tf": 9.848857801796104}, "redlines.redlines.Redlines.changes": {"tf": 11.180339887498949}, "redlines.redlines.Redlines.get_changes": {"tf": 13}, "redlines.redlines.Redlines.stats": {"tf": 12.922847983320086}, "redlines.redlines.Redlines.output_markdown": {"tf": 16.881943016134134}, "redlines.redlines.Redlines.output_rich": {"tf": 3.4641016151377544}, "redlines.redlines.Redlines.compare": {"tf": 6.4031242374328485}, "redlines.redlines.RedlinesOptions": {"tf": 1.7320508075688772}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 2.23606797749979}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 2.6457513110645907}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 2.6457513110645907}}, "df": 65, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1}, "redlines.enums.MarkdownStyle.RED": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.449489742783178}}, "df": 3, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"redlines.cli": {"tf": 2}, "redlines.document.PlainTextFile": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.__init__": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.redlines": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.changes": {"tf": 2.449489742783178}, "redlines.redlines.Redlines.get_changes": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 9, "s": {"docs": {"redlines": {"tf": 2.8284271247461903}, "redlines.cli": {"tf": 3.1622776601683795}, "redlines.document.Document": {"tf": 1}, "redlines.document.Document.text": {"tf": 1.4142135623730951}, "redlines.document.PlainTextFile": {"tf": 1.7320508075688772}, "redlines.document.PlainTextFile.__init__": {"tf": 1}, "redlines.enums.MarkdownStyle": {"tf": 1}, "redlines.enums.OutputType": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 2}, "redlines.processor.WholeDocumentProcessor": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 2.6457513110645907}, "redlines.redlines.Redlines.opcodes": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.get_changes": {"tf": 2}, "redlines.redlines.Redlines.stats": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.449489742783178}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1}}, "df": 17}, "d": {"docs": {"redlines.cli": {"tf": 1}}, "df": 1}}}}}, "]": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}, "[": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1}}, "df": 2}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.processor.Redline": {"tf": 1}, "redlines.processor.DiffOperation": {"tf": 1}}, "df": 2}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines.redlines.Redlines.redlines": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}}, "df": 2}}}}}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.Redline.operation": {"tf": 1}, "redlines.processor.Redline.source_text": {"tf": 1}, "redlines.processor.Redline.test_text": {"tf": 1}, "redlines.redlines.Redlines.opcodes": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1.4142135623730951}}, "df": 6, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"redlines.processor.Stats.replacements": {"tf": 1}}, "df": 1, "s": {"docs": {"redlines.processor.Stats.total_changes": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.stats": {"tf": 1.4142135623730951}}, "df": 3}}}}}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"redlines": {"tf": 1}}, "df": 1}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 2}}}}}}}}}}, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines.processor.DiffOperation": {"tf": 1}}, "df": 1}}}}}}}, "g": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {"redlines": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines.cli": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {"redlines.document.Document.text": {"tf": 1}, "redlines.redlines.Redlines.redlines": {"tf": 1}, "redlines.redlines.Redlines.opcodes": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}}, "df": 4, "s": {"docs": {"redlines.document.PlainTextFile.text": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}, "redlines.redlines.Redlines.source": {"tf": 1}, "redlines.redlines.Redlines.test": {"tf": 1}, "redlines.redlines.Redlines.redlines": {"tf": 1}, "redlines.redlines.Redlines.opcodes": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.stats": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_rich": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 12}, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines.redlines.Redlines.redlines": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}}, "df": 2}}}}}}, "a": {"docs": {}, "df": 0, "d": {"docs": {"redlines.document.PlainTextFile": {"tf": 1}, "redlines.document.PlainTextFile.__init__": {"tf": 1}}, "df": 2, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 1}}}}}}, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines.document.PlainTextFile.text": {"tf": 1}}, "df": 1}}}}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"redlines": {"tf": 1}, "redlines.enums.OutputType.RICH": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 4}}}, "a": {"docs": {}, "df": 0, "w": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"redlines": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 2, "s": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.cli": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 3}, "d": {"docs": {"redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 1}}}}}}, "j": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"redlines.cli": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"redlines.document.Document.text": {"tf": 1}, "redlines.redlines.Redlines.redlines": {"tf": 1}}, "df": 2}}}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"redlines.processor.RedlinesProcessor": {"tf": 2}, "redlines.processor.WholeDocumentProcessor": {"tf": 1}}, "df": 2}}}}}}, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1, "s": {"docs": {"redlines.processor.Redline": {"tf": 1}, "redlines.processor.Stats": {"tf": 1}, "redlines.redlines.Redlines.redlines": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}}, "df": 4}, "d": {"docs": {"redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 1}}}}}, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"redlines.redlines.Redlines.changes": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"redlines.processor.Redline.source_text": {"tf": 1}, "redlines.processor.Redline.test_text": {"tf": 1}}, "df": 2}}}}, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "w": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"redlines.redlines.Redlines.changes": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 2}}, "df": 2}}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"redlines": {"tf": 2}, "redlines.cli": {"tf": 1.4142135623730951}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.opcodes": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.get_changes": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.6457513110645907}}, "df": 9}, "s": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"redlines": {"tf": 1}}, "df": 1}}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"redlines.document.PlainTextFile.__init__": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 5}}}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}}, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {"redlines.document.PlainTextFile.__init__": {"tf": 1.4142135623730951}}, "df": 1}}, "g": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.Chunk.chunk_location": {"tf": 1}}, "df": 1}}}, "y": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines": {"tf": 1}, "redlines.document.Document": {"tf": 1}}, "df": 2}}}}}, "i": {"docs": {}, "df": 0, "p": {"docs": {"redlines": {"tf": 1}}, "df": 1}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"redlines": {"tf": 1}, "redlines.document.Document": {"tf": 1}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.document.PlainTextFile.__init__": {"tf": 1}}, "df": 4, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.document.Document": {"tf": 1.4142135623730951}, "redlines.document.PlainTextFile": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.__init__": {"tf": 1.7320508075688772}}, "df": 3}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.processor.Redline": {"tf": 1}, "redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}}, "df": 4}}}}}}}, "d": {"docs": {}, "df": 0, "f": {"docs": {"redlines.processor.Chunk.chunk_location": {"tf": 1}}, "df": 1}}}, "a": {"docs": {"redlines": {"tf": 1.7320508075688772}, "redlines.cli": {"tf": 2.8284271247461903}, "redlines.document.Document": {"tf": 1.4142135623730951}, "redlines.processor.RedlinesProcessor": {"tf": 2.449489742783178}, "redlines.processor.WholeDocumentProcessor": {"tf": 1.4142135623730951}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1.4142135623730951}, "redlines.processor.Redline": {"tf": 1.7320508075688772}, "redlines.processor.Stats": {"tf": 1}, "redlines.processor.DiffOperation": {"tf": 1}, "redlines.processor.Chunk": {"tf": 1}, "redlines.processor.Chunk.chunk_location": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.source": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.changes": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.compare": {"tf": 1.4142135623730951}}, "df": 16, "r": {"docs": {}, "df": 0, "e": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1}, "redlines.redlines.Redlines.redlines": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_markdown": {"tf": 2}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 6}, "g": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}}, "n": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.document.Document": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 1.4142135623730951}, "redlines.processor.Chunk.chunk_location": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.redlines": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 7, "d": {"docs": {"redlines": {"tf": 2}, "redlines.cli": {"tf": 3.605551275463989}, "redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1.4142135623730951}, "redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.processor.Redline": {"tf": 1.4142135623730951}, "redlines.processor.Redline.source_text": {"tf": 1}, "redlines.processor.Redline.test_text": {"tf": 1}, "redlines.processor.Stats": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.redlines": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.stats": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.449489742783178}, "redlines.redlines.Redlines.compare": {"tf": 1.7320508075688772}}, "df": 14}, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 1}}}}}, "y": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1, "s": {"docs": {"redlines": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.cli": {"tf": 1}, "redlines.document.Document": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.processor.WholeDocumentProcessor": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}, "redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.source": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.7320508075688772}}, "df": 11, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"redlines.document.PlainTextFile": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 2}}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {"redlines.processor.Stats": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 3, "o": {"docs": {}, "df": 0, "w": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1, "s": {"docs": {"redlines.cli": {"tf": 1}}, "df": 1}}}}, "s": {"docs": {}, "df": 0, "o": {"docs": {"redlines.cli": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 3}}, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.redlines": {"tf": 1}}, "df": 1}}}}, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.cli": {"tf": 1}}, "df": 1}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"redlines.document.Document": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 1}}, "df": 2}}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"redlines.processor.Stats": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 1}}, "df": 2}}}}, "t": {"docs": {"redlines.document.Document": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 2}, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1}}, "df": 1}, "a": {"docs": {}, "df": 0, "l": {"docs": {"redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 2}}}}}}}}}, "c": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.Redline": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}}, "df": 2, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines.processor.Redline": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}}, "df": 2}}}}}}, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}}}}}, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"redlines.redlines.Redlines.redlines": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}}, "df": 2}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}, "t": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 1, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {"redlines": {"tf": 1.7320508075688772}, "redlines.cli": {"tf": 3.1622776601683795}, "redlines.document.Document": {"tf": 1.7320508075688772}, "redlines.document.Document.text": {"tf": 1.4142135623730951}, "redlines.document.PlainTextFile": {"tf": 1.4142135623730951}, "redlines.document.PlainTextFile.__init__": {"tf": 1.4142135623730951}, "redlines.document.PlainTextFile.text": {"tf": 1}, "redlines.processor.Redline": {"tf": 1.4142135623730951}, "redlines.processor.Redline.source_text": {"tf": 1}, "redlines.processor.Redline.test_text": {"tf": 1}, "redlines.processor.Stats": {"tf": 1}, "redlines.processor.DiffOperation.test_chunk": {"tf": 1}, "redlines.processor.Chunk": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 2}, "redlines.redlines.Redlines.source": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.test": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.changes": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.output_rich": {"tf": 1.4142135623730951}}, "df": 18, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"redlines.cli": {"tf": 1.4142135623730951}}, "df": 1}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.cli": {"tf": 2}, "redlines.document.PlainTextFile": {"tf": 1.4142135623730951}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1.4142135623730951}, "redlines.processor.Redline": {"tf": 1}, "redlines.processor.Redline.test_text": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}, "redlines.processor.Stats": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 2.449489742783178}, "redlines.redlines.Redlines.redlines": {"tf": 1}, "redlines.redlines.Redlines.opcodes": {"tf": 2.449489742783178}, "redlines.redlines.Redlines.changes": {"tf": 2}, "redlines.redlines.Redlines.get_changes": {"tf": 2.23606797749979}, "redlines.redlines.Redlines.stats": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.compare": {"tf": 2}}, "df": 16, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines": {"tf": 1}}, "df": 1}}, "s": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"redlines.document.PlainTextFile": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 2}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"redlines.document.PlainTextFile": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 2}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"redlines.cli": {"tf": 2}, "redlines.enums.OutputType.RICH": {"tf": 1}}, "df": 2}}}}}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {"redlines": {"tf": 4.898979485566356}, "redlines.cli": {"tf": 5.0990195135927845}, "redlines.document.Document": {"tf": 1.4142135623730951}, "redlines.document.Document.text": {"tf": 1.7320508075688772}, "redlines.document.PlainTextFile": {"tf": 1.4142135623730951}, "redlines.document.PlainTextFile.__init__": {"tf": 1}, "redlines.document.PlainTextFile.text": {"tf": 1.7320508075688772}, "redlines.enums.MarkdownStyle": {"tf": 1}, "redlines.enums.OutputType": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.processor.WholeDocumentProcessor": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 2}, "redlines.processor.Redline": {"tf": 1}, "redlines.processor.Redline.operation": {"tf": 1}, "redlines.processor.Redline.source_text": {"tf": 1.4142135623730951}, "redlines.processor.Redline.test_text": {"tf": 1.4142135623730951}, "redlines.processor.Stats": {"tf": 1}, "redlines.processor.DiffOperation.test_chunk": {"tf": 1}, "redlines.processor.DiffOperation.opcodes": {"tf": 1.7320508075688772}, "redlines.processor.Chunk": {"tf": 1}, "redlines.processor.Chunk.text": {"tf": 1.4142135623730951}, "redlines.processor.Chunk.chunk_location": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.__init__": {"tf": 3.3166247903554}, "redlines.redlines.Redlines.source": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.test": {"tf": 2}, "redlines.redlines.Redlines.redlines": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.opcodes": {"tf": 2}, "redlines.redlines.Redlines.changes": {"tf": 2.449489742783178}, "redlines.redlines.Redlines.get_changes": {"tf": 2.23606797749979}, "redlines.redlines.Redlines.stats": {"tf": 2.23606797749979}, "redlines.redlines.Redlines.output_markdown": {"tf": 6}, "redlines.redlines.Redlines.output_rich": {"tf": 2}, "redlines.redlines.Redlines.compare": {"tf": 2.23606797749979}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 36, "m": {"docs": {"redlines.processor.RedlinesProcessor": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "r": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {"redlines": {"tf": 1}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 4, "s": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1}}, "df": 2}}}}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {"redlines": {"tf": 2.23606797749979}, "redlines.cli": {"tf": 1.4142135623730951}, "redlines.document.Document.text": {"tf": 1.4142135623730951}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.document.PlainTextFile.__init__": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.processor.Redline": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.redlines": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.6457513110645907}}, "df": 11}}, "a": {"docs": {}, "df": 0, "t": {"docs": {"redlines.cli": {"tf": 1.7320508075688772}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.document.PlainTextFile.__init__": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 1.4142135623730951}, "redlines.processor.WholeDocumentProcessor": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}, "redlines.processor.DiffOperation.test_chunk": {"tf": 1}, "redlines.processor.DiffOperation.opcodes": {"tf": 1}, "redlines.processor.Chunk": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 10}, "n": {"docs": {"redlines.cli": {"tf": 1}, "redlines.document.Document": {"tf": 1}}, "df": 2}}}, "w": {"docs": {}, "df": 0, "o": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.cli": {"tf": 2}, "redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.processor.WholeDocumentProcessor": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 6}}, "o": {"docs": {"redlines": {"tf": 2.6457513110645907}, "redlines.cli": {"tf": 2.8284271247461903}, "redlines.document.Document": {"tf": 1}, "redlines.document.Document.text": {"tf": 2}, "redlines.document.PlainTextFile.__init__": {"tf": 1}, "redlines.document.PlainTextFile.text": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1.4142135623730951}, "redlines.processor.Redline": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 2}, "redlines.redlines.Redlines.source": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.test": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.opcodes": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.changes": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.449489742783178}, "redlines.redlines.Redlines.compare": {"tf": 1.4142135623730951}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1.7320508075688772}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1.7320508075688772}}, "df": 19, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}, "redlines.processor.Chunk.text": {"tf": 1}}, "df": 3}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"redlines.processor.Stats.total_changes": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 1.4142135623730951}}, "df": 2}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 3}}}, "y": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 1}, "u": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}, "x": {"docs": {}, "df": 0, "t": {"docs": {"redlines.document.PlainTextFile": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.__init__": {"tf": 1.4142135623730951}}, "df": 2}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.Redline.operation": {"tf": 1}, "redlines.processor.Stats": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1.4142135623730951}}, "df": 3, "s": {"docs": {"redlines.enums.OutputType": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.RedlinesProcessor": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "n": {"docs": {"redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}}, "df": 1}}}}, "s": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1}, "redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}}, "df": 3, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {"redlines.cli": {"tf": 1.4142135623730951}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.cli": {"tf": 1}}, "df": 2}}}, "s": {"docs": {"redlines.cli": {"tf": 1.4142135623730951}}, "df": 1}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {"redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 1, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.processor.Chunk.chunk_location": {"tf": 1}, "redlines.redlines.Redlines.opcodes": {"tf": 2}, "redlines.redlines.Redlines.compare": {"tf": 1.4142135623730951}}, "df": 4, "s": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 2.449489742783178}, "redlines.document.Document": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.4142135623730951}}, "df": 4, "/": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1}}, "df": 2}}}}}}}}, "k": {"docs": {}, "df": 0, "e": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1}}, "df": 2, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"redlines": {"tf": 1}, "redlines.enums.MarkdownStyle.STREAMLIT": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.6457513110645907}}, "df": 3}}}}}}, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines.processor.Redline": {"tf": 1}}, "df": 1}}}}}}}}, "y": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.document.PlainTextFile": {"tf": 1.4142135623730951}, "redlines.enums.MarkdownStyle.GHFM": {"tf": 1}, "redlines.enums.MarkdownStyle.BBCODE": {"tf": 1}, "redlines.enums.MarkdownStyle.STREAMLIT": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_markdown": {"tf": 3.1622776601683795}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 10, "s": {"docs": {"redlines.enums.MarkdownStyle": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 2}, "d": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.23606797749979}}, "df": 2}}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}}, "df": 2}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.Stats": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 1}}, "df": 2}}}}}}, "s": {"docs": {"redlines.redlines.Redlines.stats": {"tf": 2.6457513110645907}}, "df": 1}}, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}}, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1}, "redlines.redlines.Redlines.opcodes": {"tf": 1}}, "df": 3}}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.cli": {"tf": 1.7320508075688772}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.WholeDocumentProcessor": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}, "redlines.processor.Redline": {"tf": 1}}, "df": 3}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1}}, "df": 2}}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"redlines": {"tf": 1}, "redlines.redlines.Redlines.opcodes": {"tf": 1}}, "df": 2}}}}}}}}}}}}}, "e": {"docs": {"redlines.cli": {"tf": 1}, "redlines.document.Document": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.processor.DiffOperation.opcodes": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1}}, "df": 6}, "t": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 3, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"redlines": {"tf": 2}, "redlines.document.PlainTextFile": {"tf": 2}, "redlines.redlines.Redlines.__init__": {"tf": 2}}, "df": 3}}, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 1}, "d": {"docs": {"redlines.redlines.Redlines.compare": {"tf": 1.4142135623730951}}, "df": 1}}, "c": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}, "y": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}}}}, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"redlines": {"tf": 1}}, "df": 1}}, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines.document.Document": {"tf": 1}, "redlines.enums.MarkdownStyle": {"tf": 1}, "redlines.enums.OutputType": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 5}}}}}}}, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"redlines.processor.Stats": {"tf": 1}}, "df": 1}}}}}}, "y": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {"redlines.cli": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {"redlines.document.PlainTextFile": {"tf": 1}, "redlines.document.PlainTextFile.__init__": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 3, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"redlines.cli": {"tf": 2}, "redlines.document.PlainTextFile": {"tf": 1.4142135623730951}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1.4142135623730951}, "redlines.processor.Redline": {"tf": 1}, "redlines.processor.Redline.source_text": {"tf": 1}, "redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.Stats": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 2.23606797749979}, "redlines.redlines.Redlines.source": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.test": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.redlines": {"tf": 1}, "redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.stats": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 15}}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.Chunk": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 2}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.redlines": {"tf": 1}}, "df": 1}}}, "]": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "f": {"docs": {"redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.processor.Redline": {"tf": 1}, "redlines.processor.DiffOperation": {"tf": 1}}, "df": 3, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.cli": {"tf": 2}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}}, "df": 5}}}}}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.processor.WholeDocumentProcessor.process": {"tf": 1}}, "df": 1}}}}}}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {"redlines.processor.DiffOperation.opcodes": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"redlines": {"tf": 1}, "redlines.processor.Redline": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}}, "df": 3, "l": {"docs": {}, "df": 0, "y": {"docs": {"redlines.cli": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"redlines.cli": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 2}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "g": {"docs": {"redlines": {"tf": 2.449489742783178}, "redlines.cli": {"tf": 2}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.get_changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.stats": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.8284271247461903}}, "df": 9}, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"redlines.document.PlainTextFile.text": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1.4142135623730951}, "redlines.processor.Redline.source_text": {"tf": 1}, "redlines.processor.Redline.test_text": {"tf": 1}, "redlines.processor.Chunk": {"tf": 1}, "redlines.processor.Chunk.chunk_location": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 7, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines": {"tf": 1}, "redlines.processor.DiffOperation.opcodes": {"tf": 1}}, "df": 2}}}}}, "s": {"docs": {"redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.processor.WholeDocumentProcessor": {"tf": 1.4142135623730951}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1.4142135623730951}}, "df": 3}}}}}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "n": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, ":": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"redlines": {"tf": 1}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 3}}}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.cli": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 2}}}}}, "b": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.WholeDocumentProcessor.process": {"tf": 1}, "redlines.processor.DiffOperation.opcodes": {"tf": 1}}, "df": 2}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines.processor.Chunk.chunk_location": {"tf": 1}, "redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}}, "df": 2}}}}}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines.cli": {"tf": 1}}, "df": 1}}}}}}, "l": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.processor.Stats.deletions": {"tf": 1}}, "df": 1, "s": {"docs": {"redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1}, "redlines.processor.Stats.total_changes": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.stats": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 6}}}}, "e": {"docs": {"redlines.processor.Redline.operation": {"tf": 1}, "redlines.processor.Redline.source_text": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1.4142135623730951}}, "df": 4, "d": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 2}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_rich": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.compare": {"tf": 1.7320508075688772}}, "df": 3, "s": {"docs": {"redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 1}}}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.RedlinesProcessor": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 1, "s": {"docs": {"redlines.redlines.Redlines.compare": {"tf": 1}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 3}}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"redlines.document.Document": {"tf": 1}}, "df": 1}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 1}}}}}}, "b": {"docs": {}, "df": 0, "e": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.document.Document.text": {"tf": 1}, "redlines.processor.Chunk": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.source": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.test": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 7, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.cli": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}, "redlines.processor.Redline": {"tf": 1}, "redlines.processor.Stats": {"tf": 1}, "redlines.redlines.Redlines.redlines": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 1}}, "df": 8}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines.processor.DiffOperation.test_chunk": {"tf": 1}, "redlines.processor.Chunk": {"tf": 1}}, "df": 2}}}, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "n": {"docs": {"redlines": {"tf": 2.449489742783178}, "redlines.cli": {"tf": 2}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.get_changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.stats": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.8284271247461903}}, "df": 9}}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"redlines.document.Document": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 1}}, "df": 2}, "i": {"docs": {}, "df": 0, "c": {"docs": {"redlines.document.Document": {"tf": 1}}, "df": 1}, "s": {"docs": {"redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.source": {"tf": 1.4142135623730951}}, "df": 2}}}}, "y": {"docs": {"redlines.document.Document.text": {"tf": 1.4142135623730951}, "redlines.enums.MarkdownStyle": {"tf": 1}, "redlines.enums.OutputType": {"tf": 1}, "redlines.processor.Stats": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.compare": {"tf": 1.4142135623730951}}, "df": 8}, "b": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"redlines.enums.MarkdownStyle.BBCODE": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 2}}}}}}, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.Redline": {"tf": 1}, "redlines.processor.Redline.operation": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 4, "s": {"docs": {"redlines": {"tf": 1.7320508075688772}, "redlines.cli": {"tf": 1.7320508075688772}, "redlines.enums.MarkdownStyle.RED": {"tf": 1}, "redlines.processor.Stats": {"tf": 1.4142135623730951}, "redlines.processor.Stats.total_changes": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.redlines": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.changes": {"tf": 2}, "redlines.redlines.Redlines.get_changes": {"tf": 2.8284271247461903}, "redlines.redlines.Redlines.stats": {"tf": 1.7320508075688772}}, "df": 10}, "d": {"docs": {"redlines.processor.Redline": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}}, "df": 2}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1}}, "df": 2}}}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "k": {"docs": {"redlines.processor.WholeDocumentProcessor": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}, "redlines.processor.DiffOperation.test_chunk": {"tf": 1}, "redlines.processor.Chunk": {"tf": 1}, "redlines.processor.Chunk.text": {"tf": 1}, "redlines.processor.Chunk.chunk_location": {"tf": 1}}, "df": 6}}}}, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1}}, "df": 2}}, "r": {"docs": {}, "df": 0, "e": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 2}, "redlines.document.Document.text": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.__init__": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.compare": {"tf": 1.4142135623730951}}, "df": 7, "s": {"docs": {"redlines.cli": {"tf": 1.7320508075688772}, "redlines.processor.WholeDocumentProcessor": {"tf": 1.4142135623730951}}, "df": 2}, "d": {"docs": {"redlines.document.Document.text": {"tf": 1}, "redlines.processor.DiffOperation.test_chunk": {"tf": 1}, "redlines.processor.Chunk": {"tf": 1}, "redlines.redlines.Redlines.test": {"tf": 1.4142135623730951}}, "df": 4}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.redlines.Redlines.__init__": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.source": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 3}}}}}}}, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.document.Document": {"tf": 1}}, "df": 2}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"redlines.cli": {"tf": 2.449489742783178}}, "df": 1, "s": {"docs": {"redlines.cli": {"tf": 1}}, "df": 1}}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"redlines.enums.MarkdownStyle.RED": {"tf": 1}}, "df": 1, ":": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines": {"tf": 1}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 3}}}, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"redlines": {"tf": 1}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 3}}}}}}, "s": {"docs": {"redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1}, "redlines.enums.MarkdownStyle.NONE": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 3, "/": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.output_rich": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}, "]": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "]": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "]": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}}}}}}, "b": {"docs": {}, "df": 0, "]": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}}}}}, "a": {"docs": {}, "df": 0, "b": {"docs": {"redlines": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 2}}}, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"redlines": {"tf": 1}}, "df": 1}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"redlines.cli": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 2}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": null}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.output_rich": {"tf": 1.4142135623730951}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.Stats": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 1}}, "df": 2}}}}, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {"redlines": {"tf": 1}, "redlines.document.Document": {"tf": 1}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.document.PlainTextFile.__init__": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 6}, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.Chunk": {"tf": 1}}, "df": 1}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"redlines": {"tf": 1}, "redlines.document.Document": {"tf": 1.7320508075688772}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.document.PlainTextFile.__init__": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 2}, "redlines.processor.Redline": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.7320508075688772}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 10, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1.7320508075688772}}, "df": 1}}}}}, "i": {"docs": {"redlines": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"redlines": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 3, "d": {"docs": {"redlines.document.PlainTextFile.text": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 2}}}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.7320508075688772}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 4}}}}, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 1}}}}}}}}, "s": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 2.23606797749979}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1.4142135623730951}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1.4142135623730951}}, "df": 3}}}, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.cli": {"tf": 1}, "redlines.document.Document": {"tf": 1.4142135623730951}, "redlines.processor.Redline": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.test": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.changes": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 1}, "redlines.redlines.Redlines.output_rich": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 10}}}, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 4}}, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {"redlines.document.PlainTextFile.text": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 4}}, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.Chunk": {"tf": 1}}, "df": 1, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"redlines.processor.RedlinesProcessor": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 3, "s": {"docs": {"redlines": {"tf": 1}}, "df": 1}}, "k": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "s": {"docs": {"redlines": {"tf": 2}, "redlines.cli": {"tf": 1.4142135623730951}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.opcodes": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.get_changes": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.23606797749979}}, "df": 9}}}, "y": {"docs": {"redlines": {"tf": 1}}, "df": 1}, "n": {"docs": {}, "df": 0, "t": {"docs": {"redlines.cli": {"tf": 1.7320508075688772}, "redlines.processor.RedlinesProcessor": {"tf": 1}}, "df": 2}}, "s": {"docs": {"redlines.document.PlainTextFile.text": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 2}}, "e": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, ":": {"7": {"0": {"0": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.document.PlainTextFile": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.__init__": {"tf": 1.4142135623730951}}, "df": 3}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}}}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}, "e": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1}}, "df": 2}}}}}}}}, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1.4142135623730951}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.document.PlainTextFile.__init__": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 9, "s": {"docs": {"redlines": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 2}, "d": {"docs": {"redlines": {"tf": 1}, "redlines.document.Document": {"tf": 1}, "redlines.document.Document.text": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.source": {"tf": 1.4142135623730951}}, "df": 5}, "r": {"docs": {"redlines.processor.Redline": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}}, "df": 2, "s": {"docs": {"redlines": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 2}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines": {"tf": 2}, "redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 3}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"redlines.cli": {"tf": 1}}, "df": 1}}}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "k": {"docs": {"redlines.document.Document": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 2, "s": {"docs": {"redlines": {"tf": 1}}, "df": 1}}}, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1}}, "df": 2, "e": {"docs": {}, "df": 0, "r": {"docs": {"redlines.cli": {"tf": 1}}, "df": 1}}}}, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.processor.Chunk.chunk_location": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1}}, "df": 2}}}}}, "z": {"docs": {}, "df": 0, "y": {"docs": {"redlines": {"tf": 2.449489742783178}, "redlines.cli": {"tf": 2}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.get_changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.stats": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.8284271247461903}}, "df": 9}}, "y": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"redlines.cli": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"redlines": {"tf": 1.7320508075688772}, "redlines.cli": {"tf": 1.4142135623730951}, "redlines.document.Document.text": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 4}}}}}, "k": {"docs": {}, "df": 0, "e": {"docs": {"redlines": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 2}}, "n": {"docs": {}, "df": 0, "e": {"docs": {"redlines.cli": {"tf": 2}}, "df": 1, "s": {"docs": {"redlines.cli": {"tf": 1}}, "df": 1}}}, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"redlines.cli": {"tf": 1}}, "df": 1}}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"redlines.processor.WholeDocumentProcessor.process": {"tf": 1}, "redlines.redlines.Redlines.redlines": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.get_changes": {"tf": 1}}, "df": 5}}}, "t": {"docs": {"redlines": {"tf": 2}, "redlines.document.PlainTextFile": {"tf": 2}, "redlines.redlines.Redlines.__init__": {"tf": 2}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 4}}, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "t": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 3}}}}}}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1}, "redlines.document.Document.text": {"tf": 1}}, "df": 3}}}}, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"redlines.cli": {"tf": 1}}, "df": 1}}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.cli": {"tf": 1.7320508075688772}, "redlines.processor.DiffOperation.opcodes": {"tf": 1}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1}}, "df": 4}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"redlines": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "n": {"docs": {"redlines": {"tf": 1.7320508075688772}, "redlines.cli": {"tf": 1.4142135623730951}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.enums.MarkdownStyle": {"tf": 1}, "redlines.enums.MarkdownStyle.GHFM": {"tf": 1}, "redlines.enums.OutputType.MARKDOWN": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.output_markdown": {"tf": 4}, "redlines.redlines.Redlines.compare": {"tf": 1.4142135623730951}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1.4142135623730951}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 12}}}}}}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"redlines": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}, "y": {"docs": {"redlines.cli": {"tf": 1.4142135623730951}, "redlines.processor.Chunk": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 3}, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines.redlines.Redlines.get_changes": {"tf": 1}}, "df": 1}}}}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "f": {"docs": {"redlines": {"tf": 1.7320508075688772}, "redlines.cli": {"tf": 1.7320508075688772}, "redlines.document.PlainTextFile.text": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}, "redlines.processor.Redline": {"tf": 1}, "redlines.processor.Redline.operation": {"tf": 1}, "redlines.processor.Stats": {"tf": 1}, "redlines.processor.Stats.total_changes": {"tf": 1}, "redlines.processor.Stats.deletions": {"tf": 1}, "redlines.processor.Stats.insertions": {"tf": 1}, "redlines.processor.Stats.replacements": {"tf": 1}, "redlines.processor.DiffOperation": {"tf": 1}, "redlines.processor.DiffOperation.test_chunk": {"tf": 1}, "redlines.processor.Chunk": {"tf": 1}, "redlines.processor.Chunk.text": {"tf": 1}, "redlines.processor.Chunk.chunk_location": {"tf": 1}, "redlines.redlines.Redlines.redlines": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.get_changes": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.7320508075688772}}, "df": 22}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"redlines": {"tf": 1.7320508075688772}, "redlines.cli": {"tf": 1}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.enums.OutputType": {"tf": 1}, "redlines.enums.OutputType.RICH": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 2}, "redlines.redlines.Redlines.changes": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 2}, "redlines.redlines.Redlines.compare": {"tf": 2}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1.4142135623730951}}, "df": 10, "s": {"docs": {"redlines.cli": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "r": {"docs": {"redlines": {"tf": 1}, "redlines.processor.Redline.operation": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.8284271247461903}}, "df": 5, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1}}, "df": 2}}}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"redlines": {"tf": 2}, "redlines.cli": {"tf": 1.4142135623730951}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.opcodes": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.get_changes": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.6457513110645907}}, "df": 9}}}, "b": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"redlines": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 4, "s": {"docs": {"redlines.redlines.Redlines.redlines": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.get_changes": {"tf": 1}}, "df": 3}}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"redlines.document.Document.text": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"redlines": {"tf": 1}, "redlines.document.Document": {"tf": 1}}, "df": 2, "s": {"docs": {"redlines": {"tf": 1}}, "df": 1}}}}}, "n": {"docs": {"redlines": {"tf": 1}}, "df": 1, "l": {"docs": {}, "df": 0, "y": {"docs": {"redlines.enums.MarkdownStyle.RED": {"tf": 1}, "redlines.redlines.Redlines.redlines": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.get_changes": {"tf": 1}}, "df": 4}}}, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1.7320508075688772}}, "df": 1, "s": {"docs": {"redlines.cli": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.__init__": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1.4142135623730951}}, "df": 4}, "a": {"docs": {}, "df": 0, "l": {"docs": {"redlines.processor.Chunk.chunk_location": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 3, "l": {"docs": {}, "df": 0, "y": {"docs": {"redlines.redlines.Redlines.get_changes": {"tf": 1}}, "df": 1}}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.processor.Stats": {"tf": 1}, "redlines.processor.DiffOperation": {"tf": 1}, "redlines.processor.DiffOperation.opcodes": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 2.449489742783178}}, "df": 5, "s": {"docs": {"redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.processor.Redline.source_text": {"tf": 1}, "redlines.processor.Redline.test_text": {"tf": 1}, "redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}, "redlines.processor.Stats.deletions": {"tf": 1}, "redlines.processor.Stats.insertions": {"tf": 1}, "redlines.processor.Stats.replacements": {"tf": 1}, "redlines.processor.DiffOperation": {"tf": 1}, "redlines.redlines.Redlines.redlines": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}}, "df": 11}}}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.DiffOperation.opcodes": {"tf": 1}, "redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}}, "df": 2}}}}}}, "w": {"docs": {}, "df": 0, "n": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {"redlines": {"tf": 2}, "redlines.cli": {"tf": 2}, "redlines.document.Document.text": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.processor.DiffOperation.test_chunk": {"tf": 1}, "redlines.processor.Chunk": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.redlines": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.6457513110645907}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 11, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1, "s": {"docs": {"redlines": {"tf": 1.4142135623730951}}, "df": 1}}}}}, "n": {"docs": {"redlines": {"tf": 2}, "redlines.cli": {"tf": 2.449489742783178}, "redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}, "redlines.processor.Chunk": {"tf": 1}, "redlines.processor.Chunk.chunk_location": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.changes": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 3.4641016151377544}, "redlines.redlines.Redlines.output_rich": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.compare": {"tf": 1.4142135623730951}}, "df": 11, "s": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"redlines": {"tf": 1.7320508075688772}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"redlines.processor.Redline.operation": {"tf": 1}, "redlines.processor.Redline.test_text": {"tf": 1}, "redlines.processor.Redline.source_position": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1.4142135623730951}}, "df": 4, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.processor.Stats.insertions": {"tf": 1}}, "df": 1, "s": {"docs": {"redlines.processor.Stats.total_changes": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.stats": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}}, "df": 5}}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}}, "df": 2}}}}}}, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines": {"tf": 1}, "redlines.processor.Redline": {"tf": 1.4142135623730951}, "redlines.processor.DiffOperation.opcodes": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1}}, "df": 5}}}}}}}}}, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"redlines": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 2}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"redlines.cli": {"tf": 1.7320508075688772}, "redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.processor.Redline": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}}, "df": 4}}}}, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"redlines.document.Document": {"tf": 1}}, "df": 1}}}}}}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"redlines.processor.DiffOperation": {"tf": 1}}, "df": 1}}}}}, "o": {"docs": {"redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}}, "df": 1}}, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines.processor.Stats": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 2}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.DiffOperation": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.changes": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 7}}}, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"redlines.document.Document.text": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.document.Document": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "f": {"docs": {"redlines.cli": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.23606797749979}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 6}, "t": {"docs": {"redlines.processor.WholeDocumentProcessor": {"tf": 1}, "redlines.processor.Chunk": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 3}}, "f": {"docs": {"redlines.redlines.Redlines.changes": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 2}}, "df": 2, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1}}, "df": 2}}}}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1, "d": {"docs": {"redlines": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 2.23606797749979}, "redlines.document.Document": {"tf": 1}, "redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1}, "redlines.enums.MarkdownStyle.RED": {"tf": 1}, "redlines.enums.OutputType.RICH": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 1.4142135623730951}, "redlines.processor.Redline": {"tf": 1}, "redlines.processor.Redline.source_text": {"tf": 1}, "redlines.processor.Redline.test_text": {"tf": 1}, "redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}, "redlines.processor.DiffOperation": {"tf": 1}, "redlines.processor.DiffOperation.opcodes": {"tf": 1}, "redlines.processor.Chunk.chunk_location": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.source": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.redlines": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_rich": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.compare": {"tf": 1}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1.4142135623730951}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 25, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.enums.OutputType.MARKDOWN": {"tf": 1}, "redlines.enums.OutputType.RICH": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.compare": {"tf": 1.7320508075688772}}, "df": 6, "s": {"docs": {"redlines.document.Document": {"tf": 1.4142135623730951}}, "df": 1}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 3}}}}}}}}, "x": {"docs": {"redlines": {"tf": 2.449489742783178}, "redlines.cli": {"tf": 2}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.get_changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.stats": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.8284271247461903}}, "df": 9}, "n": {"docs": {}, "df": 0, "t": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.document.PlainTextFile": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.__init__": {"tf": 1.4142135623730951}}, "df": 3}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"redlines": {"tf": 1}}, "df": 1}}, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.document.Document": {"tf": 1}, "redlines.document.PlainTextFile.__init__": {"tf": 1.4142135623730951}, "redlines.document.PlainTextFile.text": {"tf": 1}}, "df": 3, "s": {"docs": {"redlines": {"tf": 1}, "redlines.document.Document": {"tf": 1.4142135623730951}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.document.PlainTextFile.__init__": {"tf": 1}}, "df": 4}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"redlines.redlines.Redlines.get_changes": {"tf": 1.4142135623730951}}, "df": 1, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines.redlines.Redlines.get_changes": {"tf": 1}}, "df": 1}}}}}}, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"redlines": {"tf": 1}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.processor.Redline.source_text": {"tf": 1}, "redlines.processor.Redline.test_text": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.changes": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 10}}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"redlines.processor.Redline": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}}, "df": 2}}}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines.enums.MarkdownStyle.GHFM": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 2}}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"redlines.redlines.Redlines.redlines": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "h": {"docs": {"redlines.cli": {"tf": 1}}, "df": 1, "t": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "l": {"docs": {"redlines": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 2}}, "df": 2}}}, "a": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"redlines": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 2}}, "s": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "p": {"docs": {"redlines.cli": {"tf": 1.4142135623730951}}, "df": 1}}, "r": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "w": {"docs": {"redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.processor.Chunk.chunk_location": {"tf": 1}}, "df": 3, "s": {"docs": {"redlines.cli": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {"redlines.cli": {"tf": 1}}, "df": 1}}, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines.redlines.Redlines.redlines": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}}, "df": 2}}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}}}}, "n": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"redlines": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 2, "s": {"docs": {"redlines": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.7320508075688772}}, "df": 2}}}}}}}}}}, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.WholeDocumentProcessor": {"tf": 1}}, "df": 1}}}}, "d": {"docs": {"redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}}, "df": 2}, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "c": {"docs": {"redlines": {"tf": 1}}, "df": 1}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"redlines.processor.DiffOperation": {"tf": 1}, "redlines.redlines.Redlines.redlines": {"tf": 1}, "redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}}, "df": 4}}}}}, "g": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"redlines": {"tf": 1}}, "df": 1}, "s": {"docs": {"redlines": {"tf": 1}}, "df": 1}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "b": {"docs": {"redlines.enums.MarkdownStyle.GHFM": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 2}}}}}, "t": {"docs": {"redlines": {"tf": 2}, "redlines.document.PlainTextFile": {"tf": 2}, "redlines.redlines.Redlines.__init__": {"tf": 2}, "redlines.redlines.Redlines.opcodes": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 6}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 2, "]": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}, "[": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.RedlinesProcessor": {"tf": 1}}, "df": 1}}}}}}}, "t": {"docs": {"redlines.redlines.Redlines.source": {"tf": 1}, "redlines.redlines.Redlines.test": {"tf": 1}, "redlines.redlines.Redlines.opcodes": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 3}, "redlines.redlines.Redlines.stats": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 6}}, "h": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "m": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1.7320508075688772}}, "df": 1}}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"redlines": {"tf": 2.449489742783178}, "redlines.cli": {"tf": 2}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.get_changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.stats": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.8284271247461903}}, "df": 9, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"redlines": {"tf": 1}}, "df": 1}}}}}}}}, "o": {"docs": {}, "df": 0, "t": {"docs": {"redlines": {"tf": 2}, "redlines.cli": {"tf": 2.8284271247461903}, "redlines.document.PlainTextFile": {"tf": 2.449489742783178}, "redlines.redlines.Redlines.__init__": {"tf": 3.1622776601683795}, "redlines.redlines.Redlines.changes": {"tf": 2.449489742783178}, "redlines.redlines.Redlines.get_changes": {"tf": 3.1622776601683795}, "redlines.redlines.Redlines.stats": {"tf": 3.4641016151377544}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.8284271247461903}}, "df": 8}}}}, "j": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {"redlines": {"tf": 2}, "redlines.cli": {"tf": 1.4142135623730951}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.opcodes": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.get_changes": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.23606797749979}}, "df": 9}}}, "p": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"redlines": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 2}}}}}}}, "y": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {"redlines.cli": {"tf": 2}, "redlines.document.Document": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 3}}, "df": 4, "r": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 2}}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {"redlines.enums.MarkdownStyle.NONE": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 3, "t": {"docs": {"redlines.cli": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 2, "e": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "k": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1, "s": {"docs": {"redlines": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 2}}}}}}}, "n": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.23606797749979}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 5}}, "w": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"redlines.cli": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 2}}}, "e": {"docs": {}, "df": 0, "w": {"docs": {"redlines.cli": {"tf": 1}}, "df": 1}, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"redlines.processor.Stats.total_changes": {"tf": 1}, "redlines.processor.Stats.deletions": {"tf": 1}, "redlines.processor.Stats.insertions": {"tf": 1}, "redlines.processor.Stats.replacements": {"tf": 1}, "redlines.processor.Chunk.chunk_location": {"tf": 1}}, "df": 5}}}}}}, "k": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}}, "pipeline": ["trimmer"], "_isPrebuiltIndex": true}; + + // mirrored in build-search-index.js (part 1) + // Also split on html tags. this is a cheap heuristic, but good enough. + elasticlunr.tokenizer.setSeperator(/[\s\-.;&_'"=,()]+|<[^>]*>/); + + let searchIndex; + if (docs._isPrebuiltIndex) { + console.info("using precompiled search index"); + searchIndex = elasticlunr.Index.load(docs); + } else { + console.time("building search index"); + // mirrored in build-search-index.js (part 2) + searchIndex = elasticlunr(function () { + this.pipeline.remove(elasticlunr.stemmer); + this.pipeline.remove(elasticlunr.stopWordFilter); + this.addField("qualname"); + this.addField("fullname"); + this.addField("annotation"); + this.addField("default_value"); + this.addField("signature"); + this.addField("bases"); + this.addField("doc"); + this.setRef("fullname"); + }); + for (let doc of docs) { + searchIndex.addDoc(doc); + } + console.timeEnd("building search index"); + } + + return (term) => searchIndex.search(term, { + fields: { + qualname: {boost: 4}, + fullname: {boost: 2}, + annotation: {boost: 2}, + default_value: {boost: 2}, + signature: {boost: 2}, + bases: {boost: 2}, + doc: {boost: 1}, + }, + expand: true + }); +})(); \ No newline at end of file diff --git a/docs/index.html b/docs/index.html new file mode 100644 index 0000000..d32360c --- /dev/null +++ b/docs/index.html @@ -0,0 +1,15 @@ + + + + + Documentation + + + +
+ Documentation for version v0.6.1 +
+

Documentation for version v0.6.1

+

Redirecting to documentation...

+ + From dd154dad32dcfbef933c08cf2fe61d425d6831dc Mon Sep 17 00:00:00 2001 From: Abbas Abro Date: Sun, 12 Oct 2025 21:49:16 +0500 Subject: [PATCH 6/8] Delete docs directory --- docs/generated-docs/index.html | 7 - docs/generated-docs/redlines.html | 390 --- docs/generated-docs/redlines/cli.html | 514 ---- docs/generated-docs/redlines/document.html | 530 ---- docs/generated-docs/redlines/enums.html | 493 ---- docs/generated-docs/redlines/processor.html | 1127 --------- docs/generated-docs/redlines/redlines.html | 2488 ------------------- docs/generated-docs/search.js | 46 - docs/index.html | 15 - 9 files changed, 5610 deletions(-) delete mode 100644 docs/generated-docs/index.html delete mode 100644 docs/generated-docs/redlines.html delete mode 100644 docs/generated-docs/redlines/cli.html delete mode 100644 docs/generated-docs/redlines/document.html delete mode 100644 docs/generated-docs/redlines/enums.html delete mode 100644 docs/generated-docs/redlines/processor.html delete mode 100644 docs/generated-docs/redlines/redlines.html delete mode 100644 docs/generated-docs/search.js delete mode 100644 docs/index.html diff --git a/docs/generated-docs/index.html b/docs/generated-docs/index.html deleted file mode 100644 index 16484a8..0000000 --- a/docs/generated-docs/index.html +++ /dev/null @@ -1,7 +0,0 @@ - - - - - - - diff --git a/docs/generated-docs/redlines.html b/docs/generated-docs/redlines.html deleted file mode 100644 index 4597aa1..0000000 --- a/docs/generated-docs/redlines.html +++ /dev/null @@ -1,390 +0,0 @@ - - - - - - - redlines API documentation - - - - - - - - - -
-
-

-redlines

- -

Redlines

- -

Redlines produces a text showing the differences between two strings/text. The changes are represented with -strike-throughs and underlines, which looks similar to Microsoft Word's track changes. This method of showing changes is -more familiar to lawyers and is more compact for long series of characters.

- -

Redlines uses SequenceMatcher -to find differences between words used. -The output can be in HTML, Markdown, or rich format.

- -

Example

- -

Given an original string:

- -
The quick brown fox jumps over the lazy dog.
-
- -

And the string to be tested with:

- -
The quick brown fox walks past the lazy dog.
-
- -

The library gives a result of:

- -
"The quick brown fox <span style='color:red;font-weight:700;text-decoration:line-through;'>jumps over </span><span style='color:green;font-weight:700;'>walks past </span>the lazy dog."
-
- -

Which is rendered like this:

- -

The quick brown fox jumps over walks past the lazy dog.

- -

Install

- -

Use your regular package manager to install the library in your python environment.

- -
pip install redlines
-
- -

Quickstart

- -

This is the most direct way to produce the example.

- -
-
# import the class
-from redlines import Redlines
-
-# Create a Redlines object using the two strings to compare
-test = Redlines(
-    "The quick brown fox jumps over the lazy dog.",
-    "The quick brown fox walks past the lazy dog.",
-)
-
-# This produces an output in markdown format
-test.output_markdown
-
-
- -

Common Issues

- -

The documentation contains other information on common issues users have faced while using this library:

- - -
- - - - - - 
 1"""
- 2# Redlines
- 3
- 4`Redlines` produces a text showing the differences between two strings/text. The changes are represented with
- 5strike-throughs and underlines, which looks similar to Microsoft Word's track changes. This method of showing changes is
- 6more familiar to lawyers and is more compact for long series of characters.
- 7
- 8Redlines uses [SequenceMatcher](https://docs.python.org/3/library/difflib.html#difflib.SequenceMatcher)
- 9to find differences between words used.
-10The output can be in HTML, Markdown, or `rich` format.
-11
-12## Example
-13
-14Given an original string:
-15
-16    The quick brown fox jumps over the lazy dog.
-17
-18And the string to be tested with:
-19
-20    The quick brown fox walks past the lazy dog.
-21
-22The library gives a result of:
-23
-24    "The quick brown fox <span style='color:red;font-weight:700;text-decoration:line-through;'>jumps over </span><span style='color:green;font-weight:700;'>walks past </span>the lazy dog."
-25
-26
-27Which is rendered like this:
-28
-29The quick brown fox <span style='color:red;font-weight:700;text-decoration:line-through;'>jumps over </span><span style='color:green;font-weight:700;'>walks past </span>the lazy dog.
-30
-31## Install
-32
-33Use your regular package manager to install the library in your python environment.
-34
-35```terminal
-36pip install redlines
-37```
-38
-39## Quickstart
-40
-41This is the most direct way to produce the example.
-42
-43```python
-44# import the class
-45from redlines import Redlines
-46
-47# Create a Redlines object using the two strings to compare
-48test = Redlines(
-49    "The quick brown fox jumps over the lazy dog.",
-50    "The quick brown fox walks past the lazy dog.",
-51)
-52
-53# This produces an output in markdown format
-54test.output_markdown
-55```
-56
-57## Common Issues
-58
-59The documentation contains other information on common issues users have faced while using this library:
-60
-61* [Styling](redlines/redlines.html#styling-markdown)
-62* [Ensuring styling appears in environments such as Jupyter Notebooks, Streamlit, CoLab etc](redlines/redlines.html#markdown-output-in-specific-environments)
-63* [Using plain text files and others as input](redlines/document.html)
-64* [Using the CLI](redlines/cli.html)
-65
-66"""
-67
-68from .document import *
-69from .enums import *
-70from .processor import *
-71from .redlines import *
-
- - -
-
- - \ No newline at end of file diff --git a/docs/generated-docs/redlines/cli.html b/docs/generated-docs/redlines/cli.html deleted file mode 100644 index 320bf55..0000000 --- a/docs/generated-docs/redlines/cli.html +++ /dev/null @@ -1,514 +0,0 @@ - - - - - - - redlines.cli API documentation - - - - - - - - - -
-
-

-redlines.cli

- -

Command line interface for redlines.

- -

A command line interface for the redlines library that allows you to compare two strings -and see the differences in the terminal.

- -

NAME

- -

redlines - A command line interface for the redlines library to compare text differences

- -

SYNOPSIS

- -
-
redlines [COMMAND] [OPTIONS] SOURCE TEST
-
-
- -

DESCRIPTION

- -

Redlines is a command line utility that shows the differences between two strings/text. -The changes are represented with strike-throughs and underlines, similar to Microsoft Word's track changes. -This method of showing changes is more familiar to lawyers and is more compact for long series of characters.

- -

COMMANDS

- -
-
text
-
-
- -

Compares the strings SOURCE and TEST and produces a redline in the terminal in a display that shows the original, new, and redlined text.

- -
-
simple_text
-
-
- -

Compares the strings SOURCE and TEST and outputs the redline in the terminal.

- -
-
markdown
-
-
- -

Compares the strings SOURCE and TEST and outputs the redline as a markdown.

- -

OPTIONS

- -
-
-h, --help
-
-
- -

Show this help message and exit.

- -

EXAMPLES

- -

Compare two strings and display the differences in a detailed layout:

- -
-
redlines text "The quick brown fox jumps over the lazy dog." "The quick brown fox walks past the lazy dog."
-
-
- -

Compare two strings and output the redline directly:

- -
-
redlines simple_text "The quick brown fox jumps over the lazy dog." "The quick brown fox walks past the lazy dog."
-
-
- -

LIMITATIONS

- -
    -
  • The text command is not able to show more than 6 lines of text. You may want to use simple_text for longer text.
    • -
- -

You may also want to consider a related textual project if you want to use redlines in the terminal, -redlines-textual.

-
- - - - - - 
  1"""
-  2# Command line interface for redlines.
-  3
-  4A command line interface for the redlines library that allows you to compare two strings
-  5and see the differences in the terminal.
-  6
-  7
-  8## NAME
-  9`redlines` - A command line interface for the redlines library to compare text differences
- 10
- 11## SYNOPSIS
- 12```sh
- 13redlines [COMMAND] [OPTIONS] SOURCE TEST
- 14```
- 15
- 16## DESCRIPTION
- 17`Redlines` is a command line utility that shows the differences between two strings/text.
- 18The changes are represented with strike-throughs and underlines, similar to Microsoft Word's track changes.
- 19This method of showing changes is more familiar to lawyers and is more compact for long series of characters.
- 20
- 21## COMMANDS
- 22```sh
- 23text
- 24```
- 25Compares the strings SOURCE and TEST and produces a redline in the terminal in a display that shows the original, new, and redlined text.
- 26
- 27```sh
- 28simple_text
- 29```
- 30Compares the strings SOURCE and TEST and outputs the redline in the terminal.
- 31
- 32```sh
- 33markdown
- 34```
- 35Compares the strings SOURCE and TEST and outputs the redline as a markdown.
- 36
- 37## OPTIONS
- 38```sh
- 39-h, --help
- 40```
- 41Show this help message and exit.
- 42
- 43## EXAMPLES
- 44
- 45Compare two strings and display the differences in a detailed layout:
- 46```sh
- 47redlines text "The quick brown fox jumps over the lazy dog." "The quick brown fox walks past the lazy dog."
- 48```
- 49
- 50Compare two strings and output the redline directly:
- 51```sh
- 52redlines simple_text "The quick brown fox jumps over the lazy dog." "The quick brown fox walks past the lazy dog."
- 53```
- 54
- 55## LIMITATIONS
- 56* The `text` command is not able to show more than 6 lines of text. You may want to use `simple_text` for longer text.
- 57
- 58You may also want to consider a related textual project if you want to use redlines in the terminal,
- 59[redlines-textual](https://github.com/houfu/redlines-textual).
- 60"""
- 61
- 62import sys
- 63import typing as t
- 64from importlib.metadata import version
- 65
- 66import rich_click as click
- 67from rich.console import Console, group
- 68from rich.layout import Layout
- 69from rich.panel import Panel
- 70from rich.text import Text
- 71
- 72from .enums import MarkdownStyle
- 73from .redlines import Redlines
- 74
- 75# Use Rich markup
- 76click.rich_click.USE_RICH_MARKUP = True
- 77click.rich_click.SHOW_ARGUMENTS = True
- 78
- 79
- 80if sys.version_info < (3, 10):
- 81    raise RuntimeError(
- 82        "redlines requires Python 3.10 or higher. Please upgrade your Python version."
- 83    )
- 84
- 85
- 86@group()
- 87def print_intro() -> t.Generator[Text, None, None]:
- 88    """@private"""
- 89    yield Text.from_markup(
- 90        f"\n[bold red]--__--[/] [b]Redlines CLI[/b] [magenta]v{version('redlines')}[/] [bold red]--__--[/]\n\n"
- 91        f"[dim]➡️ Showing differences in text in the terminal⬅️ \n "
- 92        f"[b]🏠 [link=https://github.com/houfu/redlines]Homepage[/][/]",
- 93        justify="center",
- 94    )
- 95
- 96
- 97@click.group()
- 98def cli() -> None:
- 99    """
-100    [red on black]Redlines[/] shows the differences between two strings/text.
-101
-102    The changes are represented with strike-throughs and underlines, which looks similar to Microsoft Word's
-103    track changes. This method of showing changes is more familiar to lawyers and is more compact for
-104    long series of characters.
-105
-106    [b][link=https://github.com/houfu/redlines]Homepage[/][/]
-107    \f
-108    @private
-109    """
-110    pass
-111
-112
-113@cli.command()
-114@click.argument("source", required=True)
-115@click.argument("test", required=True)
-116def text(source: str, test: str) -> None:
-117    """
-118    Compares the strings SOURCE and TEST and produce a redline in the terminal in a display that shows the original, new and redlined text.
-119
-120    \f
-121    @private
-122    """
-123
-124    redlines = Redlines(source, test)
-125
-126    console = Console()
-127    layout = Layout()
-128    layout.split_column(
-129        Layout(print_intro()),
-130        Layout(
-131            Panel(redlines.output_rich, title="redline", title_align="left"),
-132            name="redline",
-133        ),
-134        Layout(name="lower"),
-135    )
-136    layout["lower"].split_row(
-137        Layout(Panel(source, title="Source", title_align="left"), name="source"),
-138        Layout(Panel(test, title="Test", title_align="left"), name="test"),
-139    )
-140    console.print(layout)
-141
-142
-143@cli.command()
-144@click.argument("source", required=True)
-145@click.argument("test", required=True)
-146def simple_text(source: str, test: str) -> None:
-147    """
-148    Compares the strings SOURCE and TEST and outputs the redline in the terminal.
-149
-150    \f
-151    @private
-152    """
-153    from rich import print
-154
-155    redlines = Redlines(source, test)
-156    print(redlines.output_rich)
-157
-158
-159@cli.command()
-160@click.argument("source", required=True)
-161@click.argument("test", required=True)
-162@click.option(
-163    "markdown_style",
-164    "--markdown-style",
-165    "-m",
-166    type=click.Choice(list(MarkdownStyle), case_sensitive=False),
-167    default="red_green",
-168    help="The markdown style to use.",
-169)
-170def markdown(source: str, test: str, markdown_style: MarkdownStyle) -> None:
-171    """
-172    Compares the strings SOURCE and TEST and outputs the redline as a markdown.
-173
-174    \f
-175    @private
-176    """
-177    from rich import print
-178
-179    redlines = Redlines(source, test, markdown_style=markdown_style)
-180    print(redlines.output_markdown)
-
- - -
-
- - \ No newline at end of file diff --git a/docs/generated-docs/redlines/document.html b/docs/generated-docs/redlines/document.html deleted file mode 100644 index 1553eb6..0000000 --- a/docs/generated-docs/redlines/document.html +++ /dev/null @@ -1,530 +0,0 @@ - - - - - - - redlines.document API documentation - - - - - - - - - -
-
-

-redlines.document

- - - - - - - 
 1import os
- 2from abc import ABC, abstractmethod
- 3
- 4__all__: tuple[str, ...] = ("Document", "PlainTextFile")
- 5
- 6
- 7class Document(ABC):
- 8    """
- 9    An abstract base class used as a common data interchange with the redlines with formats other than python text strings.
-10    To see a basic implementation, you can look at the `PlainTextFile` class for text files
-11
-12    |Supported File Formats | Class |
-13    |---| --- |
-14    |Plain Text files | `PlainTextFile` |
-15    """
-16
-17    @property
-18    @abstractmethod
-19    def text(self) -> str:
-20        """
-21        This property is used by the redlines library to obtain the text to compare. Implement this method to return
-22        the text to be compared by redlines.
-23        """
-24        pass
-25
-26
-27class PlainTextFile(Document):
-28    """
-29    Use this class so that Redlines can read plain text files.
-30
-31    ```python
-32    from redlines import PlainTextFile
-33
-34    source = PlainTextFile("tests/documents/PlainTextFile/source.txt")
-35    test = PlainTextFile("tests/documents/PlainTextFile/test.txt")
-36
-37    redline = Redlines(source, test)
-38    assert (
-39        redline.output_markdown
-40        == "The quick brown fox <span style='color:red;font-weight:700;text-decoration:line-through;'>jumps over </span><span style='color:green;font-weight:700;'>walks past </span>the lazy dog."
-41    )
-42    ```
-43
-44    """
-45
-46    @property
-47    def text(self) -> str:
-48        """
-49        :return: The text of the file referred to when the Document was created.
-50        """
-51        return self._text
-52
-53    def __init__(self, file_path: str | bytes | os.PathLike[str]) -> None:
-54        """
-55        Use this class so that Redlines can read plain text files.
-56
-57        :param file_path: Path to the text file.
-58        :type file_path: str | bytes | os.PathLike[str]
-59        """
-60        with open(file_path) as f:
-61            self._text = f.read()
-
- - -
-
- -
- - class - Document(abc.ABC): - - - -
- - 
 8class Document(ABC):
- 9    """
-10    An abstract base class used as a common data interchange with the redlines with formats other than python text strings.
-11    To see a basic implementation, you can look at the `PlainTextFile` class for text files
-12
-13    |Supported File Formats | Class |
-14    |---| --- |
-15    |Plain Text files | `PlainTextFile` |
-16    """
-17
-18    @property
-19    @abstractmethod
-20    def text(self) -> str:
-21        """
-22        This property is used by the redlines library to obtain the text to compare. Implement this method to return
-23        the text to be compared by redlines.
-24        """
-25        pass
-
- - -

An abstract base class used as a common data interchange with the redlines with formats other than python text strings. -To see a basic implementation, you can look at the PlainTextFile class for text files

- - - - - - - - - - - - - - -
Supported File FormatsClass
Plain Text filesPlainTextFile
-
- - -
- -
- text: str - - - -
- - 
18    @property
-19    @abstractmethod
-20    def text(self) -> str:
-21        """
-22        This property is used by the redlines library to obtain the text to compare. Implement this method to return
-23        the text to be compared by redlines.
-24        """
-25        pass
-
- - -

This property is used by the redlines library to obtain the text to compare. Implement this method to return -the text to be compared by redlines.

-
- - -
-
-
- -
- - class - PlainTextFile(Document): - - - -
- - 
28class PlainTextFile(Document):
-29    """
-30    Use this class so that Redlines can read plain text files.
-31
-32    ```python
-33    from redlines import PlainTextFile
-34
-35    source = PlainTextFile("tests/documents/PlainTextFile/source.txt")
-36    test = PlainTextFile("tests/documents/PlainTextFile/test.txt")
-37
-38    redline = Redlines(source, test)
-39    assert (
-40        redline.output_markdown
-41        == "The quick brown fox <span style='color:red;font-weight:700;text-decoration:line-through;'>jumps over </span><span style='color:green;font-weight:700;'>walks past </span>the lazy dog."
-42    )
-43    ```
-44
-45    """
-46
-47    @property
-48    def text(self) -> str:
-49        """
-50        :return: The text of the file referred to when the Document was created.
-51        """
-52        return self._text
-53
-54    def __init__(self, file_path: str | bytes | os.PathLike[str]) -> None:
-55        """
-56        Use this class so that Redlines can read plain text files.
-57
-58        :param file_path: Path to the text file.
-59        :type file_path: str | bytes | os.PathLike[str]
-60        """
-61        with open(file_path) as f:
-62            self._text = f.read()
-
- - -

Use this class so that Redlines can read plain text files.

- -
-
from redlines import PlainTextFile
-
-source = PlainTextFile("tests/documents/PlainTextFile/source.txt")
-test = PlainTextFile("tests/documents/PlainTextFile/test.txt")
-
-redline = Redlines(source, test)
-assert (
-    redline.output_markdown
-    == "The quick brown fox <span style='color:red;font-weight:700;text-decoration:line-through;'>jumps over </span><span style='color:green;font-weight:700;'>walks past </span>the lazy dog."
-)
-
-
-
- - -
- -
- - PlainTextFile(file_path: str | bytes | os.PathLike[str]) - - - -
- - 
54    def __init__(self, file_path: str | bytes | os.PathLike[str]) -> None:
-55        """
-56        Use this class so that Redlines can read plain text files.
-57
-58        :param file_path: Path to the text file.
-59        :type file_path: str | bytes | os.PathLike[str]
-60        """
-61        with open(file_path) as f:
-62            self._text = f.read()
-
- - -

Use this class so that Redlines can read plain text files.

- -
Parameters
- -
    -
  • file_path: Path to the text file.
    • -
-
- - -
-
- -
- text: str - - - -
- - 
47    @property
-48    def text(self) -> str:
-49        """
-50        :return: The text of the file referred to when the Document was created.
-51        """
-52        return self._text
-
- - -
Returns
- -
-

The text of the file referred to when the Document was created.

-
-
- - -
-
-
- - \ No newline at end of file diff --git a/docs/generated-docs/redlines/enums.html b/docs/generated-docs/redlines/enums.html deleted file mode 100644 index 74622eb..0000000 --- a/docs/generated-docs/redlines/enums.html +++ /dev/null @@ -1,493 +0,0 @@ - - - - - - - redlines.enums API documentation - - - - - - - - - -
-
-

-redlines.enums

- - - - - - - 
 1import enum
- 2
- 3__all__: tuple[str, ...] = (
- 4    "MarkdownStyle",
- 5    "OutputType",
- 6)
- 7
- 8
- 9class MarkdownStyle(str, enum.Enum):
-10    """The markdown styles supported by redlines."""
-11
-12    RED_GREEN = "red_green"
-13    """Red and green colors for deletions and additions respectively."""
-14
-15    NONE = "none"
-16    """No colors."""
-17
-18    RED = "red"
-19    """Only red color for changes."""
-20
-21    GHFM = "ghfm"
-22    """GitHub Flavored Markdown style."""
-23
-24    BBCODE = "bbcode"
-25    """BBCode style."""
-26
-27    STREAMLIT = "streamlit"
-28    """Streamlit style."""
-29
-30
-31class OutputType(str, enum.Enum):
-32    """The output types supported by redlines."""
-33
-34    MARKDOWN = "markdown"
-35    """Markdown format."""
-36
-37    RICH = "rich"
-38    """Rich format for terminal output."""
-
- - -
-
- -
- - class - MarkdownStyle(builtins.str, enum.Enum): - - - -
- - 
10class MarkdownStyle(str, enum.Enum):
-11    """The markdown styles supported by redlines."""
-12
-13    RED_GREEN = "red_green"
-14    """Red and green colors for deletions and additions respectively."""
-15
-16    NONE = "none"
-17    """No colors."""
-18
-19    RED = "red"
-20    """Only red color for changes."""
-21
-22    GHFM = "ghfm"
-23    """GitHub Flavored Markdown style."""
-24
-25    BBCODE = "bbcode"
-26    """BBCode style."""
-27
-28    STREAMLIT = "streamlit"
-29    """Streamlit style."""
-
- - -

The markdown styles supported by redlines.

-
- - -
-
- RED_GREEN = -<MarkdownStyle.RED_GREEN: 'red_green'> - - -
- - -

Red and green colors for deletions and additions respectively.

-
- - -
-
-
- NONE = -<MarkdownStyle.NONE: 'none'> - - -
- - -

No colors.

-
- - -
-
-
- RED = -<MarkdownStyle.RED: 'red'> - - -
- - -

Only red color for changes.

-
- - -
-
-
- GHFM = -<MarkdownStyle.GHFM: 'ghfm'> - - -
- - -

GitHub Flavored Markdown style.

-
- - -
-
-
- BBCODE = -<MarkdownStyle.BBCODE: 'bbcode'> - - -
- - -

BBCode style.

-
- - -
-
-
- STREAMLIT = -<MarkdownStyle.STREAMLIT: 'streamlit'> - - -
- - -

Streamlit style.

-
- - -
-
-
- -
- - class - OutputType(builtins.str, enum.Enum): - - - -
- - 
32class OutputType(str, enum.Enum):
-33    """The output types supported by redlines."""
-34
-35    MARKDOWN = "markdown"
-36    """Markdown format."""
-37
-38    RICH = "rich"
-39    """Rich format for terminal output."""
-
- - -

The output types supported by redlines.

-
- - -
-
- MARKDOWN = -<OutputType.MARKDOWN: 'markdown'> - - -
- - -

Markdown format.

-
- - -
-
-
- RICH = -<OutputType.RICH: 'rich'> - - -
- - -

Rich format for terminal output.

-
- - -
-
-
- - \ No newline at end of file diff --git a/docs/generated-docs/redlines/processor.html b/docs/generated-docs/redlines/processor.html deleted file mode 100644 index 4b64a62..0000000 --- a/docs/generated-docs/redlines/processor.html +++ /dev/null @@ -1,1127 +0,0 @@ - - - - - - - redlines.processor API documentation - - - - - - - - - -
-
-

-redlines.processor

- - - - - - - 
  1from __future__ import annotations
-  2
-  3import re
-  4from abc import ABC, abstractmethod
-  5from dataclasses import dataclass
-  6from difflib import SequenceMatcher
-  7from typing import Literal
-  8
-  9from .document import Document
- 10
- 11__all__: tuple[str, ...] = (
- 12    "RedlinesProcessor",
- 13    "WholeDocumentProcessor",
- 14    "Redline",
- 15    "Stats",
- 16    "DiffOperation",
- 17    "Chunk",
- 18)
- 19
- 20tokenizer = re.compile(r"((?:[^()\s]+|[().?!-])\s*)")
- 21r"""
- 22This regular expression matches a group of characters that can include any character except for parentheses
- 23and whitespace characters (which include spaces, tabs, and line breaks) or any character
- 24that is a parenthesis or punctuation mark (.?!-).
- 25The group can also include any whitespace characters that follow these characters.
- 26
- 27Breaking it down further:
- 28
- 29* `(` and `)` indicate a capturing group
- 30* `(?: )` is a non-capturing group, meaning it matches the pattern but doesn't capture the matched text
- 31* `[^()\s]+` matches one or more characters that are not parentheses or whitespace characters
- 32* `|` indicates an alternative pattern
- 33* `[().?!-]` matches any character that is a parenthesis or punctuation mark `(.?!-)`
- 34* `\s*` matches zero or more whitespace characters (spaces, tabs, or line breaks) that follow the previous pattern.
- 35"""
- 36# This pattern matches one or more newline characters `\n`, and any spaces between them.
- 37
- 38paragraph_pattern = re.compile(r"((?:\n *)+)")
- 39r"""
- 40It is used to split the text into paragraphs.
- 41
- 42* `(?:\\n *)` is a non-capturing group that must start with a `\\n`   and be followed by zero or more spaces.
- 43* `((?:\\n *)+)` is the previous non-capturing group repeated one or more times.
- 44"""
- 45
- 46space_pattern = re.compile(r"(\s+)")
- 47"""It is used to detect space."""
- 48
- 49
- 50def tokenize_text(text: str) -> list[str]:
- 51    """
- 52    Tokenizes a string into a list of tokens. A token is defined as a group of characters that can include any character except for parentheses
- 53    and whitespace characters (which include spaces, tabs, and line breaks) or any character that is a parenthesis or punctuation mark (.?!-).
- 54    The group can also include any whitespace characters that follow these characters.
- 55    For example, if the text is "Hello, world! This is a test.", the result will be:
- 56    ['Hello, ', 'world! ', 'This ', 'is ', 'a ', 'test.']
- 57
- 58    :param text: The text to tokenize.
- 59    :type text: str
- 60    :return: a list of tokens.
- 61    :rtype: list[str]
- 62    """
- 63    # NOTE: Single capturing group hence findall returns list of strings
- 64    matches: list[str] = re.findall(tokenizer, text)
- 65    return matches
- 66
- 67
- 68def split_paragraphs(text: str) -> list[str]:
- 69    """
- 70    Splits a string into a list of paragraphs. One or more `\n` splits the paragraphs.
- 71    For example, if the text is "Hello\nWorld\nThis is a test", the result will be:
- 72    ['Hello', 'World', 'This is a test']
- 73
- 74    :param text: The text to split.
- 75    :type text: str
- 76    :return: a list of paragraphs.
- 77    :rtype: list[str]
- 78    """
- 79    # NOTE: Single capturing group hence split returns list of strings
- 80    split_text: list[str] = re.split(paragraph_pattern, text)
- 81    result: list[str] = []
- 82    for s in split_text:
- 83        if s and not re.fullmatch(space_pattern, s):
- 84            result.append(s.strip())
- 85
- 86    return result
- 87
- 88
- 89def concatenate_paragraphs_and_add_chr_182(text: str) -> str:
- 90    """
- 91    Split paragraphs and concatenate them. Then add a character '¶' between paragraphs.
- 92    For example, if the text is "Hello\nWorld\nThis is a test", the result will be:
- 93    "Hello¶World¶This is a test"
- 94
- 95    :param text: The text to split.
- 96    :type text: str
- 97    :return: a list of paragraphs.
- 98    :rtype: str
- 99    """
-100    paragraphs = split_paragraphs(text)
-101
-102    result: list[str] = []
-103    for p in paragraphs:
-104        result.append(p)
-105        result.append(" ¶ ")
-106        # Add a string ' ¶ ' between paragraphs.
-107    if len(paragraphs) > 0:
-108        result.pop()
-109
-110    return "".join(result)
-111
-112
-113@dataclass
-114class Chunk:
-115    """A chunk of text that is being compared. In some cases, it may be the whole document"""
-116
-117    text: list[str]
-118    """The tokens of the chunk"""
-119    chunk_location: str | None
-120    """An optional string describing the location of the chunk in the document. For example, a PDF page number"""
-121
-122
-123@dataclass
-124class DiffOperation:
-125    """Internal representation of a diff operation (includes 'equal' operations for rendering)"""
-126
-127    source_chunk: Chunk
-128    test_chunk: Chunk
-129    """The chunk of text that is being compared"""
-130    opcodes: tuple[str, int, int, int, int]
-131    """The opcodes that describe the operation. See the difflib documentation for more information"""
-132
-133
-134@dataclass
-135class Redline:
-136    """
-137    A structured representation of a single change between source and test text.
-138
-139    This class provides a user-friendly interface for accessing diff information,
-140    with direct access to the changed text and position information.
-141    """
-142
-143    operation: Literal["delete", "insert", "replace"]
-144    """The type of change: 'delete', 'insert', or 'replace'"""
-145
-146    source_text: str | None
-147    """The text from the source document. Present for 'delete' and 'replace' operations."""
-148
-149    test_text: str | None
-150    """The text from the test document. Present for 'insert' and 'replace' operations."""
-151
-152    source_position: tuple[int, int] | None
-153    """Position in source tokens as (start, end). None for 'insert' operations."""
-154
-155    test_position: tuple[int, int] | None
-156    """Position in test tokens as (start, end). None for 'delete' operations."""
-157
-158
-159@dataclass
-160class Stats:
-161    """
-162    Statistics about the changes between source and test text.
-163
-164    Provides a summary of all changes including counts by operation type.
-165    """
-166
-167    total_changes: int
-168    """Total number of changes (deletions + insertions + replacements)"""
-169
-170    deletions: int
-171    """Number of deletion operations"""
-172
-173    insertions: int
-174    """Number of insertion operations"""
-175
-176    replacements: int
-177    """Number of replacement operations"""
-178
-179
-180class RedlinesProcessor(ABC):
-181    """
-182    An abstract class that defines the interface for a redlines processor.
-183    A redlines processor is a class that takes two documents and generates diff operations from them.
-184    Use this class as a base class if you want to create a custom redlines processor.
-185    See `WholeDocumentProcessor` for an example of a redlines processor.
-186    """
-187
-188    @abstractmethod
-189    def process(self, source: Document | str, test: Document | str) -> list[DiffOperation]:
-190        pass
-191
-192
-193class WholeDocumentProcessor(RedlinesProcessor):
-194    """
-195    A redlines processor that compares two documents. It compares the entire documents as a single chunk.
-196    """
-197
-198    def process(self, source: Document | str, test: Document | str) -> list[DiffOperation]:
-199        """
-200        Compare two documents as a single chunk.
-201
-202        :param source: The source document to compare.
-203        :type source: Document | str
-204        :param test: The test document to compare.
-205        :type test: Document | str
-206        :return: A list of `DiffOperation` that describe the differences between the two documents.
-207        :rtype: list[DiffOperation]
-208        """
-209        # Extract text from documents if needed
-210        source_text = source.text if isinstance(source, Document) else source
-211        test_text = test.text if isinstance(test, Document) else test
-212
-213        # Tokenize the texts
-214        source_tokens = tokenize_text(
-215            concatenate_paragraphs_and_add_chr_182(source_text)
-216        )
-217        test_tokens = tokenize_text(concatenate_paragraphs_and_add_chr_182(test_text))
-218
-219        # Normalize tokens by stripping whitespace for comparison
-220        # This allows the matcher to focus on content differences rather than whitespace variations
-221        # while still preserving the original tokens (including whitespace) for display in the output
-222        seq_source_normalized = [token.strip() for token in source_tokens]
-223        seq_test_normalized = [token.strip() for token in test_tokens]
-224
-225        matcher = SequenceMatcher(None, seq_source_normalized, seq_test_normalized)
-226
-227        return [
-228            DiffOperation(
-229                source_chunk=Chunk(text=source_tokens, chunk_location=None),
-230                test_chunk=Chunk(text=test_tokens, chunk_location=None),
-231                opcodes=opcode,
-232            )
-233            for opcode in matcher.get_opcodes()
-234        ]
-
- - -
-
- -
- - class - RedlinesProcessor(abc.ABC): - - - -
- - 
181class RedlinesProcessor(ABC):
-182    """
-183    An abstract class that defines the interface for a redlines processor.
-184    A redlines processor is a class that takes two documents and generates diff operations from them.
-185    Use this class as a base class if you want to create a custom redlines processor.
-186    See `WholeDocumentProcessor` for an example of a redlines processor.
-187    """
-188
-189    @abstractmethod
-190    def process(self, source: Document | str, test: Document | str) -> list[DiffOperation]:
-191        pass
-
- - -

An abstract class that defines the interface for a redlines processor. -A redlines processor is a class that takes two documents and generates diff operations from them. -Use this class as a base class if you want to create a custom redlines processor. -See WholeDocumentProcessor for an example of a redlines processor.

-
- - -
- -
-
@abstractmethod
- - def - process( self, source: redlines.document.Document | str, test: redlines.document.Document | str) -> list[DiffOperation]: - - - -
- - 
189    @abstractmethod
-190    def process(self, source: Document | str, test: Document | str) -> list[DiffOperation]:
-191        pass
-
- - - - -
-
-
- -
- - class - WholeDocumentProcessor(RedlinesProcessor): - - - -
- - 
194class WholeDocumentProcessor(RedlinesProcessor):
-195    """
-196    A redlines processor that compares two documents. It compares the entire documents as a single chunk.
-197    """
-198
-199    def process(self, source: Document | str, test: Document | str) -> list[DiffOperation]:
-200        """
-201        Compare two documents as a single chunk.
-202
-203        :param source: The source document to compare.
-204        :type source: Document | str
-205        :param test: The test document to compare.
-206        :type test: Document | str
-207        :return: A list of `DiffOperation` that describe the differences between the two documents.
-208        :rtype: list[DiffOperation]
-209        """
-210        # Extract text from documents if needed
-211        source_text = source.text if isinstance(source, Document) else source
-212        test_text = test.text if isinstance(test, Document) else test
-213
-214        # Tokenize the texts
-215        source_tokens = tokenize_text(
-216            concatenate_paragraphs_and_add_chr_182(source_text)
-217        )
-218        test_tokens = tokenize_text(concatenate_paragraphs_and_add_chr_182(test_text))
-219
-220        # Normalize tokens by stripping whitespace for comparison
-221        # This allows the matcher to focus on content differences rather than whitespace variations
-222        # while still preserving the original tokens (including whitespace) for display in the output
-223        seq_source_normalized = [token.strip() for token in source_tokens]
-224        seq_test_normalized = [token.strip() for token in test_tokens]
-225
-226        matcher = SequenceMatcher(None, seq_source_normalized, seq_test_normalized)
-227
-228        return [
-229            DiffOperation(
-230                source_chunk=Chunk(text=source_tokens, chunk_location=None),
-231                test_chunk=Chunk(text=test_tokens, chunk_location=None),
-232                opcodes=opcode,
-233            )
-234            for opcode in matcher.get_opcodes()
-235        ]
-
- - -

A redlines processor that compares two documents. It compares the entire documents as a single chunk.

-
- - -
- -
- - def - process( self, source: redlines.document.Document | str, test: redlines.document.Document | str) -> list[DiffOperation]: - - - -
- - 
199    def process(self, source: Document | str, test: Document | str) -> list[DiffOperation]:
-200        """
-201        Compare two documents as a single chunk.
-202
-203        :param source: The source document to compare.
-204        :type source: Document | str
-205        :param test: The test document to compare.
-206        :type test: Document | str
-207        :return: A list of `DiffOperation` that describe the differences between the two documents.
-208        :rtype: list[DiffOperation]
-209        """
-210        # Extract text from documents if needed
-211        source_text = source.text if isinstance(source, Document) else source
-212        test_text = test.text if isinstance(test, Document) else test
-213
-214        # Tokenize the texts
-215        source_tokens = tokenize_text(
-216            concatenate_paragraphs_and_add_chr_182(source_text)
-217        )
-218        test_tokens = tokenize_text(concatenate_paragraphs_and_add_chr_182(test_text))
-219
-220        # Normalize tokens by stripping whitespace for comparison
-221        # This allows the matcher to focus on content differences rather than whitespace variations
-222        # while still preserving the original tokens (including whitespace) for display in the output
-223        seq_source_normalized = [token.strip() for token in source_tokens]
-224        seq_test_normalized = [token.strip() for token in test_tokens]
-225
-226        matcher = SequenceMatcher(None, seq_source_normalized, seq_test_normalized)
-227
-228        return [
-229            DiffOperation(
-230                source_chunk=Chunk(text=source_tokens, chunk_location=None),
-231                test_chunk=Chunk(text=test_tokens, chunk_location=None),
-232                opcodes=opcode,
-233            )
-234            for opcode in matcher.get_opcodes()
-235        ]
-
- - -

Compare two documents as a single chunk.

- -
Parameters
- -
    -
  • source: The source document to compare.
    • -
  • test: The test document to compare.
    • -
- -
Returns
- -
-

A list of DiffOperation that describe the differences between the two documents.

-
-
- - -
-
-
- -
-
@dataclass
- - class - Redline: - - - -
- - 
135@dataclass
-136class Redline:
-137    """
-138    A structured representation of a single change between source and test text.
-139
-140    This class provides a user-friendly interface for accessing diff information,
-141    with direct access to the changed text and position information.
-142    """
-143
-144    operation: Literal["delete", "insert", "replace"]
-145    """The type of change: 'delete', 'insert', or 'replace'"""
-146
-147    source_text: str | None
-148    """The text from the source document. Present for 'delete' and 'replace' operations."""
-149
-150    test_text: str | None
-151    """The text from the test document. Present for 'insert' and 'replace' operations."""
-152
-153    source_position: tuple[int, int] | None
-154    """Position in source tokens as (start, end). None for 'insert' operations."""
-155
-156    test_position: tuple[int, int] | None
-157    """Position in test tokens as (start, end). None for 'delete' operations."""
-
- - -

A structured representation of a single change between source and test text.

- -

This class provides a user-friendly interface for accessing diff information, -with direct access to the changed text and position information.

-
- - -
-
- - Redline( operation: Literal['delete', 'insert', 'replace'], source_text: str | None, test_text: str | None, source_position: tuple[int, int] | None, test_position: tuple[int, int] | None) - - -
- - - - -
-
-
- operation: Literal['delete', 'insert', 'replace'] - - -
- - -

The type of change: 'delete', 'insert', or 'replace'

-
- - -
-
-
- source_text: str | None - - -
- - -

The text from the source document. Present for 'delete' and 'replace' operations.

-
- - -
-
-
- test_text: str | None - - -
- - -

The text from the test document. Present for 'insert' and 'replace' operations.

-
- - -
-
-
- source_position: tuple[int, int] | None - - -
- - -

Position in source tokens as (start, end). None for 'insert' operations.

-
- - -
-
-
- test_position: tuple[int, int] | None - - -
- - -

Position in test tokens as (start, end). None for 'delete' operations.

-
- - -
-
-
- -
-
@dataclass
- - class - Stats: - - - -
- - 
160@dataclass
-161class Stats:
-162    """
-163    Statistics about the changes between source and test text.
-164
-165    Provides a summary of all changes including counts by operation type.
-166    """
-167
-168    total_changes: int
-169    """Total number of changes (deletions + insertions + replacements)"""
-170
-171    deletions: int
-172    """Number of deletion operations"""
-173
-174    insertions: int
-175    """Number of insertion operations"""
-176
-177    replacements: int
-178    """Number of replacement operations"""
-
- - -

Statistics about the changes between source and test text.

- -

Provides a summary of all changes including counts by operation type.

-
- - -
-
- - Stats( total_changes: int, deletions: int, insertions: int, replacements: int) - - -
- - - - -
-
-
- total_changes: int - - -
- - -

Total number of changes (deletions + insertions + replacements)

-
- - -
-
-
- deletions: int - - -
- - -

Number of deletion operations

-
- - -
-
-
- insertions: int - - -
- - -

Number of insertion operations

-
- - -
-
-
- replacements: int - - -
- - -

Number of replacement operations

-
- - -
-
-
- -
-
@dataclass
- - class - DiffOperation: - - - -
- - 
124@dataclass
-125class DiffOperation:
-126    """Internal representation of a diff operation (includes 'equal' operations for rendering)"""
-127
-128    source_chunk: Chunk
-129    test_chunk: Chunk
-130    """The chunk of text that is being compared"""
-131    opcodes: tuple[str, int, int, int, int]
-132    """The opcodes that describe the operation. See the difflib documentation for more information"""
-
- - -

Internal representation of a diff operation (includes 'equal' operations for rendering)

-
- - -
-
- - DiffOperation( source_chunk: Chunk, test_chunk: Chunk, opcodes: tuple[str, int, int, int, int]) - - -
- - - - -
-
-
- source_chunk: Chunk - - -
- - - - -
-
-
- test_chunk: Chunk - - -
- - -

The chunk of text that is being compared

-
- - -
-
-
- opcodes: tuple[str, int, int, int, int] - - -
- - -

The opcodes that describe the operation. See the difflib documentation for more information

-
- - -
-
-
- -
-
@dataclass
- - class - Chunk: - - - -
- - 
114@dataclass
-115class Chunk:
-116    """A chunk of text that is being compared. In some cases, it may be the whole document"""
-117
-118    text: list[str]
-119    """The tokens of the chunk"""
-120    chunk_location: str | None
-121    """An optional string describing the location of the chunk in the document. For example, a PDF page number"""
-
- - -

A chunk of text that is being compared. In some cases, it may be the whole document

-
- - -
-
- - Chunk(text: list[str], chunk_location: str | None) - - -
- - - - -
-
-
- text: list[str] - - -
- - -

The tokens of the chunk

-
- - -
-
-
- chunk_location: str | None - - -
- - -

An optional string describing the location of the chunk in the document. For example, a PDF page number

-
- - -
-
-
- - \ No newline at end of file diff --git a/docs/generated-docs/redlines/redlines.html b/docs/generated-docs/redlines/redlines.html deleted file mode 100644 index 58538fb..0000000 --- a/docs/generated-docs/redlines/redlines.html +++ /dev/null @@ -1,2488 +0,0 @@ - - - - - - - redlines.redlines API documentation - - - - - - - - - -
-
-

-redlines.redlines

- - - - - - - 
  1from __future__ import annotations
-  2
-  3import re
-  4import typing as t
-  5
-  6from rich.text import Text
-  7from typing_extensions import Unpack
-  8
-  9from .document import Document
- 10from .enums import MarkdownStyle, OutputType
- 11from .processor import DiffOperation, Redline, Stats, WholeDocumentProcessor
- 12
- 13__all__: tuple[str, ...] = (
- 14    "Redlines",
- 15    "RedlinesOptions",
- 16)
- 17
- 18# Workaround for enum + literal support in type hints
- 19# See: https://github.com/python/typing/issues/781
- 20OutputTypeLike = OutputType | t.Literal["markdown", "rich"]
- 21
- 22
- 23class RedlinesOptions(t.TypedDict, total=False):
- 24    markdown_style: str | MarkdownStyle | None
- 25    """The style to use for markdown output. See `Redlines.output_markdown` for more information."""
- 26    ins_class: str
- 27    """The CSS class to use for insertions when `markdown_style` is set to `custom_css`. Defaults to 'redline-inserted'."""
- 28    del_class: str
- 29    """The CSS class to use for deletions when `markdown_style` is set to `custom_css`. Defaults to 'redline-deleted'."""
- 30
- 31
- 32class Redlines:
- 33    _source: str | None = None
- 34    _test: str | None = None
- 35    _seq1: list[str] | None = None
- 36    _seq2: list[str] | None = None
- 37    _diff_operations: list[DiffOperation] | None = None
- 38
- 39    @property
- 40    def source(self) -> str:
- 41        """
- 42        Get the source text to be used as a basis for comparison.
- 43
- 44        :return: The source text to be used as a basis for comparison.
- 45        :rtype: str
- 46        """
- 47        if self._source is None:
- 48            raise ValueError("No source string was provided.")
- 49        return self._source
- 50
- 51    @source.setter
- 52    def source(self, value: str | Document) -> None:
- 53        self._source = value.text if isinstance(value, Document) else value
- 54
- 55        # If test is already set, process the new source against it
- 56        if self._test is not None:
- 57            self._diff_operations = self.processor.process(self._source, self._test)
- 58
- 59    @property
- 60    def test(self) -> str:
- 61        """
- 62        Get the text to be compared with the source.
- 63
- 64        :return: The text to be compared with the source.
- 65        :rtype: str
- 66        """
- 67        if self._test is None:
- 68            raise ValueError("No test string was provided.")
- 69        return self._test
- 70
- 71    @test.setter
- 72    def test(self, value: str | Document) -> None:
- 73        self._test = value.text if isinstance(value, Document) else value
- 74
- 75        # Process the text against the source
- 76        if self._source is not None:
- 77            self._diff_operations = self.processor.process(self._source, self._test)
- 78
- 79    @property
- 80    def _diff_ops(self) -> list[DiffOperation]:
- 81        """
- 82        Internal property: Return the list of DiffOperation objects (includes 'equal' operations).
- 83        For internal rendering code.
- 84
- 85        :return: List of DiffOperation objects
- 86        """
- 87        if self._diff_operations is None:
- 88            raise ValueError(
- 89                "No test string was provided when the function was called, or during initialisation."
- 90            )
- 91        return self._diff_operations
- 92
- 93    @property
- 94    def redlines(self) -> list[Redline]:
- 95        """
- 96        Return the list of Redline objects representing actual changes between source and test.
- 97
- 98        This is an alias for the `changes` property and provides the same functionality.
- 99        Only actual changes are returned (equal operations are excluded).
-100
-101        :return: List of Redline objects
-102        :rtype: list[Redline]
-103        """
-104        return self.changes
-105
-106    def __init__(
-107        self,
-108        source: str | Document,
-109        test: str | Document | None = None,
-110        **options: Unpack[RedlinesOptions],
-111    ):
-112        """
-113        Redline is a class used to compare text, and producing human-readable differences or deltas
-114        which look like track changes in Microsoft Word.
-115
-116        ```python
-117        # import the class
-118        from redlines import Redlines
-119
-120        # Create a Redlines object using the two strings to compare
-121        test = Redlines(
-122            "The quick brown fox jumps over the lazy dog.",
-123            "The quick brown fox walks past the lazy dog.",
-124        )
-125
-126        # This produces an output in Markdown format
-127        test.output_markdown
-128        ```
-129
-130        Besides strings, Redlines can also receive an input in another format if it is supported by the Document class
-131
-132        ```python
-133        from redlines import PlainTextFile
-134
-135        source = PlainTextFile("tests/documents/PlainTextFile/source.txt")
-136        test = PlainTextFile("tests/documents/PlainTextFile/test.txt")
-137
-138        redline = Redlines(source, test)
-139        assert (
-140            redline.output_markdown
-141            == "The quick brown fox <span style='color:red;font-weight:700;text-decoration:line-through;'>jumps over </span><span style='color:green;font-weight:700;'>walks past </span>the lazy dog."
-142        )
-143
-144        ```
-145
-146        :param source: The source text to be used as a basis for comparison.
-147        :type source: str | Document
-148        :param test: Optional test text to compare with the source.
-149        :type test: str | Document | None
-150        :param options: Additional options for comparison and output formatting.
-151        :type options: RedlinesOptions
-152        """
-153        self.processor = WholeDocumentProcessor()
-154        self.source = source.text if isinstance(source, Document) else source
-155        self.options = options
-156        self._diff_operations = None
-157        if test:
-158            self.test = test.text if isinstance(test, Document) else test
-159            # self.compare()
-160
-161    @property
-162    def opcodes(self) -> list[tuple[str, int, int, int, int]]:
-163        """
-164        Return list of 5-tuples describing how to turn `source` into `test`.
-165        Similar to [`SequenceMatcher.get_opcodes`](https://docs.python.org/3/library/difflib.html#difflib.SequenceMatcher.get_opcodes).
-166
-167        ```pycon
-168        >>> test_string_1 = 'The quick brown fox jumps over the lazy dog.'
-169        ... test_string_2 = 'The quick brown fox walks past the lazy dog.'
-170        ... s = Redlines(test_string_1, test_string_2)
-171        ... s.opcodes
-172        [('equal', 0, 4, 0, 4), ('replace', 4, 6, 4, 6), ('equal', 6, 9, 6, 9)]
-173        ```
-174
-175        :return: List of 5-tuples describing how to turn `source` into `test`.
-176        :rtype: list[tuple[str, int, int, int, int]]
-177        """
-178        return [diff_op.opcodes for diff_op in self._diff_ops]
-179
-180    @property
-181    def changes(self) -> list[Redline]:
-182        """
-183        Return list of Redline objects representing the differences between source and test.
-184
-185        This provides a user-friendly interface for programmatically accessing changes,
-186        with direct access to the changed text and position information. Only actual
-187        changes are returned (equal operations are excluded).
-188
-189        ```python
-190        from redlines import Redlines
-191
-192        test = Redlines(
-193            "The quick brown fox jumps over the lazy dog.",
-194            "The quick brown fox walks past the lazy dog."
-195        )
-196
-197        for redline in test.changes:
-198            print(f"{redline.operation}: {redline.source_text} -> {redline.test_text}")
-199        # Output: replace: jumps over  -> walks past
-200        ```
-201
-202        :return: List of Redline objects (only actual changes, no 'equal' operations)
-203        """
-204        result = []
-205        for diff_op in self._diff_ops:
-206            tag, i1, i2, j1, j2 = diff_op.opcodes
-207
-208            # Skip equal operations - only return actual changes
-209            if tag == "equal":
-210                continue
-211
-212            source_tokens = diff_op.source_chunk.text
-213            test_tokens = diff_op.test_chunk.text
-214
-215            # Extract text and positions based on operation type
-216            if tag == "delete":
-217                redline = Redline(
-218                    operation="delete",
-219                    source_text="".join(source_tokens[i1:i2]),
-220                    test_text=None,
-221                    source_position=(i1, i2),
-222                    test_position=None,
-223                )
-224            elif tag == "insert":
-225                redline = Redline(
-226                    operation="insert",
-227                    source_text=None,
-228                    test_text="".join(test_tokens[j1:j2]),
-229                    source_position=None,
-230                    test_position=(j1, j2),
-231                )
-232            elif tag == "replace":
-233                redline = Redline(
-234                    operation="replace",
-235                    source_text="".join(source_tokens[i1:i2]),
-236                    test_text="".join(test_tokens[j1:j2]),
-237                    source_position=(i1, i2),
-238                    test_position=(j1, j2),
-239                )
-240            else:
-241                continue
-242
-243            result.append(redline)
-244
-245        return result
-246
-247    def get_changes(
-248        self, operation: str | None = None
-249    ) -> list[Redline]:
-250        """
-251        Get changes (redlines), optionally filtered by operation type.
-252
-253        ```python
-254        from redlines import Redlines
-255
-256        test = Redlines(
-257            "The quick brown fox jumps over the lazy dog.",
-258            "The quick brown fox walks past the lazy dog."
-259        )
-260
-261        # Get all changes
-262        all_changes = test.get_changes()
-263
-264        # Get only replacements
-265        replacements = test.get_changes(operation="replace")
-266
-267        # Get deletions
-268        deletions = test.get_changes(operation="delete")
-269
-270        # Get insertions
-271        insertions = test.get_changes(operation="insert")
-272        ```
-273
-274        :param operation: Filter by operation type: "delete", "insert", or "replace". If None, returns all changes.
-275        :return: List of Redline objects matching the filter
-276        """
-277        changes = self.changes
-278
-279        if operation is None:
-280            return changes
-281
-282        if operation not in ("delete", "insert", "replace"):
-283            raise ValueError(
-284                f"Invalid operation '{operation}'. Must be 'delete', 'insert', or 'replace'."
-285            )
-286
-287        return [r for r in changes if r.operation == operation]
-288
-289    def stats(self) -> Stats:
-290        """
-291        Get statistics about the changes between source and test.
-292
-293        ```python
-294        from redlines import Redlines
-295
-296        test = Redlines(
-297            "The quick brown fox jumps over the lazy dog.",
-298            "The quick brown fox walks past the lazy dog."
-299        )
-300
-301        stats = test.stats()
-302        print(f"Total changes: {stats.total_changes}")
-303        print(f"Deletions: {stats.deletions}")
-304        print(f"Insertions: {stats.insertions}")
-305        print(f"Replacements: {stats.replacements}")
-306        ```
-307
-308        :return: Stats object with change counts
-309        """
-310        changes = self.changes
-311
-312        deletions = sum(1 for c in changes if c.operation == "delete")
-313        insertions = sum(1 for c in changes if c.operation == "insert")
-314        replacements = sum(1 for c in changes if c.operation == "replace")
-315
-316        return Stats(
-317            total_changes=len(changes),
-318            deletions=deletions,
-319            insertions=insertions,
-320            replacements=replacements,
-321        )
-322
-323    @property
-324    def output_markdown(self) -> str:
-325        """
-326        Returns the delta in Markdown format.
-327
-328        ## Styling Markdown
-329        To output markdown in a particular manner, you must pass a `markdown_style` option when the `Redlines` object
-330        is created or when `Redlines.compare` is called.
-331
-332        ```python
-333        from redlines import Redlines
-334
-335        test = Redlines(
-336            "The quick brown fox jumps over the lazy dog.",
-337            "The quick brown fox walks past the lazy dog.",
-338            markdown_style="red"  # This option specifies the style as red
-339        )
-340
-341        test.compare(markdown_style="none") # This option specifies the style as none
-342        ```
-343
-344        ### Available styles
-345
-346        | Style | Preview |
-347        |-------| -------|
-348        |red-green (**default**) | "The quick brown fox <span style='color:red;font-weight:700;text-decoration:line-through;'>jumps over </span><span style='color:green;font-weight:700;'>walks past </span>the lazy dog."|
-349        |none | 'The quick brown fox <del>jumps over </del><ins>walks past </ins>the lazy dog.'|
-350        |red | "The quick brown fox <span style='color:red;font-weight:700;text-decoration:line-through;'>jumps over </span><span style='color:red;font-weight:700;'>walks past </span>the lazy dog."|
-351        |ghfm (GitHub Flavored Markdown)| 'The quick brown fox ~~jumps over ~~**walks past **the lazy dog.' |
-352        |bbcode (BBCode) | 'The quick brown fox [s][color=red]jumps over [/color][/s][b][color=green]walks past [/color][/b]the lazy dog.' |
-353        |streamlit | 'The quick brown fox ~~:red[jumps over ]~~ **:green[walks past ]** the lazy dog.' |
-354
-355        ### Custom styling
-356
-357        You can also use css classes to provide custom styling by setting `markdown_style` as "custom_css".
-358        Insertions and deletions are now styled using the "redline-inserted" and "redline-deleted" CSS classes.
-359        You can also set your own CSS classes by specifying the name of the CSS class in the options `ins_class`
-360        and `del_class` respectively in the constructor or compare function.
-361
-362        ## Markdown output in specific environments
-363
-364        Users have reported that the output doesn't display correctly in their environments.
-365        This is because styling may not appear in markdown environments which disallow HTML.
-366        There is no consistent support for strikethroughs and colors in the markdown standard,
-367        and styling is largely accomplished through raw HTML. If you are using GitHub or Streamlit, you may not get
-368        the formatting you expect or see any change at all.
-369
-370        If you are facing this kind of difficulty, here are some recommendations. If your experience doesn't match
-371        the hints or description below, or you continue to face problems, please raise an issue.
-372
-373        ### Jupyter Notebooks
-374        This library was first written for the Jupyter notebook environment, so all the available styles, including
-375        the default (`red-green`), `red` and `none` work.
-376
-377        ### Streamlit
-378
-379        Try this:
-380
-381        * If streamlit version is >= 1.16.0, consider the markdown style "streamlit"
-382        * If streamlit version is < 1.16.0, consider the markdown style `ghfm`
-383        * Enable parsing of HTML. In Streamlit, you need to set the `unsafe_allow_html` argument in `st.write` or
-384        `st.markdown` to `True`.
-385
-386        ### Colab
-387
-388        Try this:
-389        * Use the markdown style `none` or `ghfm`
-390        * `Redlines.output_rich` has been reported to work in Colab
-391
-392        :return: The delta in Markdown format.
-393        :rtype: str
-394        """
-395        result: list[str] = []
-396
-397        # default_style = "red_green"
-398
-399        md_styles = {
-400            "ins": (
-401                f"<span style='color:green;font-weight:700;'>",
-402                "</span>",
-403            ),
-404            "del": (
-405                f"<span style='color:red;font-weight:700;text-decoration:line-through;'>",
-406                "</span>",
-407            ),
-408        }
-409
-410        if "markdown_style" in self.options:
-411            style = self.options["markdown_style"]
-412
-413            if style == "none" or style is None:
-414                md_styles = {"ins": ("<ins>", "</ins>"), "del": ("<del>", "</del>")}
-415            elif style == "red":
-416                md_styles = {
-417                    "ins": (
-418                        f"<span style='color:red;font-weight:700;'>",
-419                        "</span>",
-420                    ),
-421                    "del": (
-422                        f"<span style='color:red;font-weight:700;text-decoration:line-through;'>",
-423                        "</span>",
-424                    ),
-425                }
-426            elif style == "custom_css":
-427                ins_class = (
-428                    self.options["ins_class"]
-429                    if "ins_class" in self.options
-430                    else "redline-inserted"
-431                )
-432                del_class = (
-433                    self.options["del_class"]
-434                    if "del_class" in self.options
-435                    else "redline-deleted"
-436                )
-437
-438                elem_attributes = {
-439                    "ins": f"class='{ins_class}'",
-440                    "del": f"class='{del_class}'",
-441                }
-442
-443                md_styles = {
-444                    "ins": (
-445                        f"<span {elem_attributes['ins']}>",
-446                        "</span>",
-447                    ),
-448                    "del": (
-449                        f"<span {elem_attributes['del']}>",
-450                        "</span>",
-451                    ),
-452                }
-453            elif style == "ghfm":
-454                md_styles = {"ins": ("**", "**"), "del": ("~~", "~~")}
-455            elif style == "bbcode":
-456                md_styles = {
-457                    "ins": ("[b][color=green]", "[/color][/b]"),
-458                    "del": ("[s][color=red]", "[/color][/s]"),
-459                }
-460            elif style == "streamlit":
-461                md_styles = {"ins": ("**:green[", "]** "), "del": ("~~:red[", "]~~ ")}
-462
-463        for diff_op in self._diff_ops:
-464            tag, i1, i2, j1, j2 = diff_op.opcodes
-465            source_tokens = diff_op.source_chunk.text
-466            test_tokens = diff_op.test_chunk.text
-467
-468            if tag == "equal":
-469                temp_str = "".join(source_tokens[i1:i2])
-470                temp_str = re.sub("¶ ", "\n\n", temp_str)
-471                # here we use '¶ ' instead of ' ¶ ', because the leading space will be included in the previous token,
-472                # according to tokenizer = re.compile(r"((?:[^()\s]+|[().?!-])\s*)")
-473                result.append(temp_str)
-474            elif tag == "insert":
-475                temp_str = "".join(test_tokens[j1:j2])
-476                splits = re.split("¶ ", temp_str)
-477                for split in splits:
-478                    result.append(f"{md_styles['ins'][0]}{split}{md_styles['ins'][1]}")
-479                    result.append("\n\n")
-480                if len(splits) > 0:
-481                    result.pop()
-482            elif tag == "delete":
-483                result.append(
-484                    f"{md_styles['del'][0]}{''.join(source_tokens[i1:i2])}{md_styles['del'][1]}"
-485                )
-486                # for 'delete', we make no change, because otherwise there will be two times '\n\n' than the original
-487                # text.
-488            elif tag == "replace":
-489                result.append(
-490                    f"{md_styles['del'][0]}{''.join(source_tokens[i1:i2])}{md_styles['del'][1]}"
-491                )
-492                temp_str = "".join(test_tokens[j1:j2])
-493                splits = re.split("¶ ", temp_str)
-494                for split in splits:
-495                    result.append(f"{md_styles['ins'][0]}{split}{md_styles['ins'][1]}")
-496                    result.append("\n\n")
-497                if len(splits) > 0:
-498                    result.pop()
-499
-500        return "".join(result)
-501
-502    @property
-503    def output_rich(self) -> Text:
-504        """
-505        Returns the delta in text with colors/style for the console.
-506
-507        :return: The delta in text with colors/style for the console.
-508        :rtype: Text
-509        """
-510        console_text = Text()
-511
-512        for diff_op in self._diff_ops:
-513            tag, i1, i2, j1, j2 = diff_op.opcodes
-514            source_tokens = diff_op.source_chunk.text
-515            test_tokens = diff_op.test_chunk.text
-516
-517            if tag == "equal":
-518                temp_str = "".join(source_tokens[i1:i2])
-519                temp_str = re.sub("¶ ", "\n\n", temp_str)
-520                console_text.append(temp_str)
-521            elif tag == "insert":
-522                temp_str = "".join(test_tokens[j1:j2])
-523                splits = re.split("¶ ", temp_str)
-524                for split in splits:
-525                    console_text.append(split, "green")
-526            elif tag == "delete":
-527                console_text.append("".join(source_tokens[i1:i2]), "strike red")
-528            elif tag == "replace":
-529                console_text.append("".join(source_tokens[i1:i2]), "strike red")
-530                temp_str = "".join(test_tokens[j1:j2])
-531                splits = re.split("¶ ", temp_str)
-532                for split in splits:
-533                    console_text.append(split, "green")
-534
-535        return console_text
-536
-537    def compare(
-538        self,
-539        test: str | None = None,
-540        output: OutputTypeLike = OutputType.MARKDOWN,
-541        **options: Unpack[RedlinesOptions],
-542    ) -> Text | str:
-543        """
-544        Compare `test` with `source`, and produce a delta in a format specified by `output`.
-545
-546        :param test: Optional test string to compare. If None, uses the test string provided during initialisation.
-547        :type test: str | None
-548        :param output: The format which the delta should be produced. Currently, "markdown" and "rich" are supported. Defaults to "markdown".
-549        :type output: OutputTypeLike
-550        :param options: Additional options for comparison and output formatting.
-551        :type options: RedlinesOptions
-552        :return: The delta in the format specified by `output`.
-553        :rtype: Text | str
-554        """
-555        if options:
-556            self.options = options
-557
-558        if test:
-559            if self._test and test == self._test:
-560                # If we've already processed this test string, no need to reprocess
-561                pass
-562            else:
-563                self.test = test
-564        elif self._test is None:
-565            raise ValueError(
-566                "No test string was provided when the function was called, or during initialisation."
-567            )
-568
-569        if output == OutputType.MARKDOWN:
-570            return self.output_markdown
-571        elif output == OutputType.RICH:
-572            return self.output_rich
-573        return self.output_markdown
-
- - -
-
- -
- - class - Redlines: - - - -
- - 
 33class Redlines:
- 34    _source: str | None = None
- 35    _test: str | None = None
- 36    _seq1: list[str] | None = None
- 37    _seq2: list[str] | None = None
- 38    _diff_operations: list[DiffOperation] | None = None
- 39
- 40    @property
- 41    def source(self) -> str:
- 42        """
- 43        Get the source text to be used as a basis for comparison.
- 44
- 45        :return: The source text to be used as a basis for comparison.
- 46        :rtype: str
- 47        """
- 48        if self._source is None:
- 49            raise ValueError("No source string was provided.")
- 50        return self._source
- 51
- 52    @source.setter
- 53    def source(self, value: str | Document) -> None:
- 54        self._source = value.text if isinstance(value, Document) else value
- 55
- 56        # If test is already set, process the new source against it
- 57        if self._test is not None:
- 58            self._diff_operations = self.processor.process(self._source, self._test)
- 59
- 60    @property
- 61    def test(self) -> str:
- 62        """
- 63        Get the text to be compared with the source.
- 64
- 65        :return: The text to be compared with the source.
- 66        :rtype: str
- 67        """
- 68        if self._test is None:
- 69            raise ValueError("No test string was provided.")
- 70        return self._test
- 71
- 72    @test.setter
- 73    def test(self, value: str | Document) -> None:
- 74        self._test = value.text if isinstance(value, Document) else value
- 75
- 76        # Process the text against the source
- 77        if self._source is not None:
- 78            self._diff_operations = self.processor.process(self._source, self._test)
- 79
- 80    @property
- 81    def _diff_ops(self) -> list[DiffOperation]:
- 82        """
- 83        Internal property: Return the list of DiffOperation objects (includes 'equal' operations).
- 84        For internal rendering code.
- 85
- 86        :return: List of DiffOperation objects
- 87        """
- 88        if self._diff_operations is None:
- 89            raise ValueError(
- 90                "No test string was provided when the function was called, or during initialisation."
- 91            )
- 92        return self._diff_operations
- 93
- 94    @property
- 95    def redlines(self) -> list[Redline]:
- 96        """
- 97        Return the list of Redline objects representing actual changes between source and test.
- 98
- 99        This is an alias for the `changes` property and provides the same functionality.
-100        Only actual changes are returned (equal operations are excluded).
-101
-102        :return: List of Redline objects
-103        :rtype: list[Redline]
-104        """
-105        return self.changes
-106
-107    def __init__(
-108        self,
-109        source: str | Document,
-110        test: str | Document | None = None,
-111        **options: Unpack[RedlinesOptions],
-112    ):
-113        """
-114        Redline is a class used to compare text, and producing human-readable differences or deltas
-115        which look like track changes in Microsoft Word.
-116
-117        ```python
-118        # import the class
-119        from redlines import Redlines
-120
-121        # Create a Redlines object using the two strings to compare
-122        test = Redlines(
-123            "The quick brown fox jumps over the lazy dog.",
-124            "The quick brown fox walks past the lazy dog.",
-125        )
-126
-127        # This produces an output in Markdown format
-128        test.output_markdown
-129        ```
-130
-131        Besides strings, Redlines can also receive an input in another format if it is supported by the Document class
-132
-133        ```python
-134        from redlines import PlainTextFile
-135
-136        source = PlainTextFile("tests/documents/PlainTextFile/source.txt")
-137        test = PlainTextFile("tests/documents/PlainTextFile/test.txt")
-138
-139        redline = Redlines(source, test)
-140        assert (
-141            redline.output_markdown
-142            == "The quick brown fox <span style='color:red;font-weight:700;text-decoration:line-through;'>jumps over </span><span style='color:green;font-weight:700;'>walks past </span>the lazy dog."
-143        )
-144
-145        ```
-146
-147        :param source: The source text to be used as a basis for comparison.
-148        :type source: str | Document
-149        :param test: Optional test text to compare with the source.
-150        :type test: str | Document | None
-151        :param options: Additional options for comparison and output formatting.
-152        :type options: RedlinesOptions
-153        """
-154        self.processor = WholeDocumentProcessor()
-155        self.source = source.text if isinstance(source, Document) else source
-156        self.options = options
-157        self._diff_operations = None
-158        if test:
-159            self.test = test.text if isinstance(test, Document) else test
-160            # self.compare()
-161
-162    @property
-163    def opcodes(self) -> list[tuple[str, int, int, int, int]]:
-164        """
-165        Return list of 5-tuples describing how to turn `source` into `test`.
-166        Similar to [`SequenceMatcher.get_opcodes`](https://docs.python.org/3/library/difflib.html#difflib.SequenceMatcher.get_opcodes).
-167
-168        ```pycon
-169        >>> test_string_1 = 'The quick brown fox jumps over the lazy dog.'
-170        ... test_string_2 = 'The quick brown fox walks past the lazy dog.'
-171        ... s = Redlines(test_string_1, test_string_2)
-172        ... s.opcodes
-173        [('equal', 0, 4, 0, 4), ('replace', 4, 6, 4, 6), ('equal', 6, 9, 6, 9)]
-174        ```
-175
-176        :return: List of 5-tuples describing how to turn `source` into `test`.
-177        :rtype: list[tuple[str, int, int, int, int]]
-178        """
-179        return [diff_op.opcodes for diff_op in self._diff_ops]
-180
-181    @property
-182    def changes(self) -> list[Redline]:
-183        """
-184        Return list of Redline objects representing the differences between source and test.
-185
-186        This provides a user-friendly interface for programmatically accessing changes,
-187        with direct access to the changed text and position information. Only actual
-188        changes are returned (equal operations are excluded).
-189
-190        ```python
-191        from redlines import Redlines
-192
-193        test = Redlines(
-194            "The quick brown fox jumps over the lazy dog.",
-195            "The quick brown fox walks past the lazy dog."
-196        )
-197
-198        for redline in test.changes:
-199            print(f"{redline.operation}: {redline.source_text} -> {redline.test_text}")
-200        # Output: replace: jumps over  -> walks past
-201        ```
-202
-203        :return: List of Redline objects (only actual changes, no 'equal' operations)
-204        """
-205        result = []
-206        for diff_op in self._diff_ops:
-207            tag, i1, i2, j1, j2 = diff_op.opcodes
-208
-209            # Skip equal operations - only return actual changes
-210            if tag == "equal":
-211                continue
-212
-213            source_tokens = diff_op.source_chunk.text
-214            test_tokens = diff_op.test_chunk.text
-215
-216            # Extract text and positions based on operation type
-217            if tag == "delete":
-218                redline = Redline(
-219                    operation="delete",
-220                    source_text="".join(source_tokens[i1:i2]),
-221                    test_text=None,
-222                    source_position=(i1, i2),
-223                    test_position=None,
-224                )
-225            elif tag == "insert":
-226                redline = Redline(
-227                    operation="insert",
-228                    source_text=None,
-229                    test_text="".join(test_tokens[j1:j2]),
-230                    source_position=None,
-231                    test_position=(j1, j2),
-232                )
-233            elif tag == "replace":
-234                redline = Redline(
-235                    operation="replace",
-236                    source_text="".join(source_tokens[i1:i2]),
-237                    test_text="".join(test_tokens[j1:j2]),
-238                    source_position=(i1, i2),
-239                    test_position=(j1, j2),
-240                )
-241            else:
-242                continue
-243
-244            result.append(redline)
-245
-246        return result
-247
-248    def get_changes(
-249        self, operation: str | None = None
-250    ) -> list[Redline]:
-251        """
-252        Get changes (redlines), optionally filtered by operation type.
-253
-254        ```python
-255        from redlines import Redlines
-256
-257        test = Redlines(
-258            "The quick brown fox jumps over the lazy dog.",
-259            "The quick brown fox walks past the lazy dog."
-260        )
-261
-262        # Get all changes
-263        all_changes = test.get_changes()
-264
-265        # Get only replacements
-266        replacements = test.get_changes(operation="replace")
-267
-268        # Get deletions
-269        deletions = test.get_changes(operation="delete")
-270
-271        # Get insertions
-272        insertions = test.get_changes(operation="insert")
-273        ```
-274
-275        :param operation: Filter by operation type: "delete", "insert", or "replace". If None, returns all changes.
-276        :return: List of Redline objects matching the filter
-277        """
-278        changes = self.changes
-279
-280        if operation is None:
-281            return changes
-282
-283        if operation not in ("delete", "insert", "replace"):
-284            raise ValueError(
-285                f"Invalid operation '{operation}'. Must be 'delete', 'insert', or 'replace'."
-286            )
-287
-288        return [r for r in changes if r.operation == operation]
-289
-290    def stats(self) -> Stats:
-291        """
-292        Get statistics about the changes between source and test.
-293
-294        ```python
-295        from redlines import Redlines
-296
-297        test = Redlines(
-298            "The quick brown fox jumps over the lazy dog.",
-299            "The quick brown fox walks past the lazy dog."
-300        )
-301
-302        stats = test.stats()
-303        print(f"Total changes: {stats.total_changes}")
-304        print(f"Deletions: {stats.deletions}")
-305        print(f"Insertions: {stats.insertions}")
-306        print(f"Replacements: {stats.replacements}")
-307        ```
-308
-309        :return: Stats object with change counts
-310        """
-311        changes = self.changes
-312
-313        deletions = sum(1 for c in changes if c.operation == "delete")
-314        insertions = sum(1 for c in changes if c.operation == "insert")
-315        replacements = sum(1 for c in changes if c.operation == "replace")
-316
-317        return Stats(
-318            total_changes=len(changes),
-319            deletions=deletions,
-320            insertions=insertions,
-321            replacements=replacements,
-322        )
-323
-324    @property
-325    def output_markdown(self) -> str:
-326        """
-327        Returns the delta in Markdown format.
-328
-329        ## Styling Markdown
-330        To output markdown in a particular manner, you must pass a `markdown_style` option when the `Redlines` object
-331        is created or when `Redlines.compare` is called.
-332
-333        ```python
-334        from redlines import Redlines
-335
-336        test = Redlines(
-337            "The quick brown fox jumps over the lazy dog.",
-338            "The quick brown fox walks past the lazy dog.",
-339            markdown_style="red"  # This option specifies the style as red
-340        )
-341
-342        test.compare(markdown_style="none") # This option specifies the style as none
-343        ```
-344
-345        ### Available styles
-346
-347        | Style | Preview |
-348        |-------| -------|
-349        |red-green (**default**) | "The quick brown fox <span style='color:red;font-weight:700;text-decoration:line-through;'>jumps over </span><span style='color:green;font-weight:700;'>walks past </span>the lazy dog."|
-350        |none | 'The quick brown fox <del>jumps over </del><ins>walks past </ins>the lazy dog.'|
-351        |red | "The quick brown fox <span style='color:red;font-weight:700;text-decoration:line-through;'>jumps over </span><span style='color:red;font-weight:700;'>walks past </span>the lazy dog."|
-352        |ghfm (GitHub Flavored Markdown)| 'The quick brown fox ~~jumps over ~~**walks past **the lazy dog.' |
-353        |bbcode (BBCode) | 'The quick brown fox [s][color=red]jumps over [/color][/s][b][color=green]walks past [/color][/b]the lazy dog.' |
-354        |streamlit | 'The quick brown fox ~~:red[jumps over ]~~ **:green[walks past ]** the lazy dog.' |
-355
-356        ### Custom styling
-357
-358        You can also use css classes to provide custom styling by setting `markdown_style` as "custom_css".
-359        Insertions and deletions are now styled using the "redline-inserted" and "redline-deleted" CSS classes.
-360        You can also set your own CSS classes by specifying the name of the CSS class in the options `ins_class`
-361        and `del_class` respectively in the constructor or compare function.
-362
-363        ## Markdown output in specific environments
-364
-365        Users have reported that the output doesn't display correctly in their environments.
-366        This is because styling may not appear in markdown environments which disallow HTML.
-367        There is no consistent support for strikethroughs and colors in the markdown standard,
-368        and styling is largely accomplished through raw HTML. If you are using GitHub or Streamlit, you may not get
-369        the formatting you expect or see any change at all.
-370
-371        If you are facing this kind of difficulty, here are some recommendations. If your experience doesn't match
-372        the hints or description below, or you continue to face problems, please raise an issue.
-373
-374        ### Jupyter Notebooks
-375        This library was first written for the Jupyter notebook environment, so all the available styles, including
-376        the default (`red-green`), `red` and `none` work.
-377
-378        ### Streamlit
-379
-380        Try this:
-381
-382        * If streamlit version is >= 1.16.0, consider the markdown style "streamlit"
-383        * If streamlit version is < 1.16.0, consider the markdown style `ghfm`
-384        * Enable parsing of HTML. In Streamlit, you need to set the `unsafe_allow_html` argument in `st.write` or
-385        `st.markdown` to `True`.
-386
-387        ### Colab
-388
-389        Try this:
-390        * Use the markdown style `none` or `ghfm`
-391        * `Redlines.output_rich` has been reported to work in Colab
-392
-393        :return: The delta in Markdown format.
-394        :rtype: str
-395        """
-396        result: list[str] = []
-397
-398        # default_style = "red_green"
-399
-400        md_styles = {
-401            "ins": (
-402                f"<span style='color:green;font-weight:700;'>",
-403                "</span>",
-404            ),
-405            "del": (
-406                f"<span style='color:red;font-weight:700;text-decoration:line-through;'>",
-407                "</span>",
-408            ),
-409        }
-410
-411        if "markdown_style" in self.options:
-412            style = self.options["markdown_style"]
-413
-414            if style == "none" or style is None:
-415                md_styles = {"ins": ("<ins>", "</ins>"), "del": ("<del>", "</del>")}
-416            elif style == "red":
-417                md_styles = {
-418                    "ins": (
-419                        f"<span style='color:red;font-weight:700;'>",
-420                        "</span>",
-421                    ),
-422                    "del": (
-423                        f"<span style='color:red;font-weight:700;text-decoration:line-through;'>",
-424                        "</span>",
-425                    ),
-426                }
-427            elif style == "custom_css":
-428                ins_class = (
-429                    self.options["ins_class"]
-430                    if "ins_class" in self.options
-431                    else "redline-inserted"
-432                )
-433                del_class = (
-434                    self.options["del_class"]
-435                    if "del_class" in self.options
-436                    else "redline-deleted"
-437                )
-438
-439                elem_attributes = {
-440                    "ins": f"class='{ins_class}'",
-441                    "del": f"class='{del_class}'",
-442                }
-443
-444                md_styles = {
-445                    "ins": (
-446                        f"<span {elem_attributes['ins']}>",
-447                        "</span>",
-448                    ),
-449                    "del": (
-450                        f"<span {elem_attributes['del']}>",
-451                        "</span>",
-452                    ),
-453                }
-454            elif style == "ghfm":
-455                md_styles = {"ins": ("**", "**"), "del": ("~~", "~~")}
-456            elif style == "bbcode":
-457                md_styles = {
-458                    "ins": ("[b][color=green]", "[/color][/b]"),
-459                    "del": ("[s][color=red]", "[/color][/s]"),
-460                }
-461            elif style == "streamlit":
-462                md_styles = {"ins": ("**:green[", "]** "), "del": ("~~:red[", "]~~ ")}
-463
-464        for diff_op in self._diff_ops:
-465            tag, i1, i2, j1, j2 = diff_op.opcodes
-466            source_tokens = diff_op.source_chunk.text
-467            test_tokens = diff_op.test_chunk.text
-468
-469            if tag == "equal":
-470                temp_str = "".join(source_tokens[i1:i2])
-471                temp_str = re.sub("¶ ", "\n\n", temp_str)
-472                # here we use '¶ ' instead of ' ¶ ', because the leading space will be included in the previous token,
-473                # according to tokenizer = re.compile(r"((?:[^()\s]+|[().?!-])\s*)")
-474                result.append(temp_str)
-475            elif tag == "insert":
-476                temp_str = "".join(test_tokens[j1:j2])
-477                splits = re.split("¶ ", temp_str)
-478                for split in splits:
-479                    result.append(f"{md_styles['ins'][0]}{split}{md_styles['ins'][1]}")
-480                    result.append("\n\n")
-481                if len(splits) > 0:
-482                    result.pop()
-483            elif tag == "delete":
-484                result.append(
-485                    f"{md_styles['del'][0]}{''.join(source_tokens[i1:i2])}{md_styles['del'][1]}"
-486                )
-487                # for 'delete', we make no change, because otherwise there will be two times '\n\n' than the original
-488                # text.
-489            elif tag == "replace":
-490                result.append(
-491                    f"{md_styles['del'][0]}{''.join(source_tokens[i1:i2])}{md_styles['del'][1]}"
-492                )
-493                temp_str = "".join(test_tokens[j1:j2])
-494                splits = re.split("¶ ", temp_str)
-495                for split in splits:
-496                    result.append(f"{md_styles['ins'][0]}{split}{md_styles['ins'][1]}")
-497                    result.append("\n\n")
-498                if len(splits) > 0:
-499                    result.pop()
-500
-501        return "".join(result)
-502
-503    @property
-504    def output_rich(self) -> Text:
-505        """
-506        Returns the delta in text with colors/style for the console.
-507
-508        :return: The delta in text with colors/style for the console.
-509        :rtype: Text
-510        """
-511        console_text = Text()
-512
-513        for diff_op in self._diff_ops:
-514            tag, i1, i2, j1, j2 = diff_op.opcodes
-515            source_tokens = diff_op.source_chunk.text
-516            test_tokens = diff_op.test_chunk.text
-517
-518            if tag == "equal":
-519                temp_str = "".join(source_tokens[i1:i2])
-520                temp_str = re.sub("¶ ", "\n\n", temp_str)
-521                console_text.append(temp_str)
-522            elif tag == "insert":
-523                temp_str = "".join(test_tokens[j1:j2])
-524                splits = re.split("¶ ", temp_str)
-525                for split in splits:
-526                    console_text.append(split, "green")
-527            elif tag == "delete":
-528                console_text.append("".join(source_tokens[i1:i2]), "strike red")
-529            elif tag == "replace":
-530                console_text.append("".join(source_tokens[i1:i2]), "strike red")
-531                temp_str = "".join(test_tokens[j1:j2])
-532                splits = re.split("¶ ", temp_str)
-533                for split in splits:
-534                    console_text.append(split, "green")
-535
-536        return console_text
-537
-538    def compare(
-539        self,
-540        test: str | None = None,
-541        output: OutputTypeLike = OutputType.MARKDOWN,
-542        **options: Unpack[RedlinesOptions],
-543    ) -> Text | str:
-544        """
-545        Compare `test` with `source`, and produce a delta in a format specified by `output`.
-546
-547        :param test: Optional test string to compare. If None, uses the test string provided during initialisation.
-548        :type test: str | None
-549        :param output: The format which the delta should be produced. Currently, "markdown" and "rich" are supported. Defaults to "markdown".
-550        :type output: OutputTypeLike
-551        :param options: Additional options for comparison and output formatting.
-552        :type options: RedlinesOptions
-553        :return: The delta in the format specified by `output`.
-554        :rtype: Text | str
-555        """
-556        if options:
-557            self.options = options
-558
-559        if test:
-560            if self._test and test == self._test:
-561                # If we've already processed this test string, no need to reprocess
-562                pass
-563            else:
-564                self.test = test
-565        elif self._test is None:
-566            raise ValueError(
-567                "No test string was provided when the function was called, or during initialisation."
-568            )
-569
-570        if output == OutputType.MARKDOWN:
-571            return self.output_markdown
-572        elif output == OutputType.RICH:
-573            return self.output_rich
-574        return self.output_markdown
-
- - - - -
- -
- - Redlines( source: str | redlines.document.Document, test: str | redlines.document.Document | None = None, **options: Unpack[RedlinesOptions]) - - - -
- - 
107    def __init__(
-108        self,
-109        source: str | Document,
-110        test: str | Document | None = None,
-111        **options: Unpack[RedlinesOptions],
-112    ):
-113        """
-114        Redline is a class used to compare text, and producing human-readable differences or deltas
-115        which look like track changes in Microsoft Word.
-116
-117        ```python
-118        # import the class
-119        from redlines import Redlines
-120
-121        # Create a Redlines object using the two strings to compare
-122        test = Redlines(
-123            "The quick brown fox jumps over the lazy dog.",
-124            "The quick brown fox walks past the lazy dog.",
-125        )
-126
-127        # This produces an output in Markdown format
-128        test.output_markdown
-129        ```
-130
-131        Besides strings, Redlines can also receive an input in another format if it is supported by the Document class
-132
-133        ```python
-134        from redlines import PlainTextFile
-135
-136        source = PlainTextFile("tests/documents/PlainTextFile/source.txt")
-137        test = PlainTextFile("tests/documents/PlainTextFile/test.txt")
-138
-139        redline = Redlines(source, test)
-140        assert (
-141            redline.output_markdown
-142            == "The quick brown fox <span style='color:red;font-weight:700;text-decoration:line-through;'>jumps over </span><span style='color:green;font-weight:700;'>walks past </span>the lazy dog."
-143        )
-144
-145        ```
-146
-147        :param source: The source text to be used as a basis for comparison.
-148        :type source: str | Document
-149        :param test: Optional test text to compare with the source.
-150        :type test: str | Document | None
-151        :param options: Additional options for comparison and output formatting.
-152        :type options: RedlinesOptions
-153        """
-154        self.processor = WholeDocumentProcessor()
-155        self.source = source.text if isinstance(source, Document) else source
-156        self.options = options
-157        self._diff_operations = None
-158        if test:
-159            self.test = test.text if isinstance(test, Document) else test
-160            # self.compare()
-
- - -

Redline is a class used to compare text, and producing human-readable differences or deltas -which look like track changes in Microsoft Word.

- -
-
# import the class
-from redlines import Redlines
-
-# Create a Redlines object using the two strings to compare
-test = Redlines(
-    "The quick brown fox jumps over the lazy dog.",
-    "The quick brown fox walks past the lazy dog.",
-)
-
-# This produces an output in Markdown format
-test.output_markdown
-
-
- -

Besides strings, Redlines can also receive an input in another format if it is supported by the Document class

- -
-
from redlines import PlainTextFile
-
-source = PlainTextFile("tests/documents/PlainTextFile/source.txt")
-test = PlainTextFile("tests/documents/PlainTextFile/test.txt")
-
-redline = Redlines(source, test)
-assert (
-    redline.output_markdown
-    == "The quick brown fox <span style='color:red;font-weight:700;text-decoration:line-through;'>jumps over </span><span style='color:green;font-weight:700;'>walks past </span>the lazy dog."
-)
-
-
- -
Parameters
- -
    -
  • source: The source text to be used as a basis for comparison.
    • -
  • test: Optional test text to compare with the source.
    • -
  • options: Additional options for comparison and output formatting.
    • -
-
- - -
-
- -
- source: str - - - -
- - 
40    @property
-41    def source(self) -> str:
-42        """
-43        Get the source text to be used as a basis for comparison.
-44
-45        :return: The source text to be used as a basis for comparison.
-46        :rtype: str
-47        """
-48        if self._source is None:
-49            raise ValueError("No source string was provided.")
-50        return self._source
-
- - -

Get the source text to be used as a basis for comparison.

- -
Returns
- -
-

The source text to be used as a basis for comparison.

-
-
- - -
-
- -
- test: str - - - -
- - 
60    @property
-61    def test(self) -> str:
-62        """
-63        Get the text to be compared with the source.
-64
-65        :return: The text to be compared with the source.
-66        :rtype: str
-67        """
-68        if self._test is None:
-69            raise ValueError("No test string was provided.")
-70        return self._test
-
- - -

Get the text to be compared with the source.

- -
Returns
- -
-

The text to be compared with the source.

-
-
- - -
-
- -
- redlines: list[redlines.processor.Redline] - - - -
- - 
 94    @property
- 95    def redlines(self) -> list[Redline]:
- 96        """
- 97        Return the list of Redline objects representing actual changes between source and test.
- 98
- 99        This is an alias for the `changes` property and provides the same functionality.
-100        Only actual changes are returned (equal operations are excluded).
-101
-102        :return: List of Redline objects
-103        :rtype: list[Redline]
-104        """
-105        return self.changes
-
- - -

Return the list of Redline objects representing actual changes between source and test.

- -

This is an alias for the changes property and provides the same functionality. -Only actual changes are returned (equal operations are excluded).

- -
Returns
- -
-

List of Redline objects

-
-
- - -
-
-
- processor - - -
- - - - -
-
-
- options - - -
- - - - -
-
- -
- opcodes: list[tuple[str, int, int, int, int]] - - - -
- - 
162    @property
-163    def opcodes(self) -> list[tuple[str, int, int, int, int]]:
-164        """
-165        Return list of 5-tuples describing how to turn `source` into `test`.
-166        Similar to [`SequenceMatcher.get_opcodes`](https://docs.python.org/3/library/difflib.html#difflib.SequenceMatcher.get_opcodes).
-167
-168        ```pycon
-169        >>> test_string_1 = 'The quick brown fox jumps over the lazy dog.'
-170        ... test_string_2 = 'The quick brown fox walks past the lazy dog.'
-171        ... s = Redlines(test_string_1, test_string_2)
-172        ... s.opcodes
-173        [('equal', 0, 4, 0, 4), ('replace', 4, 6, 4, 6), ('equal', 6, 9, 6, 9)]
-174        ```
-175
-176        :return: List of 5-tuples describing how to turn `source` into `test`.
-177        :rtype: list[tuple[str, int, int, int, int]]
-178        """
-179        return [diff_op.opcodes for diff_op in self._diff_ops]
-
- - -

Return list of 5-tuples describing how to turn source into test. -Similar to SequenceMatcher.get_opcodes.

- -
-
>>> test_string_1 = 'The quick brown fox jumps over the lazy dog.'
-... test_string_2 = 'The quick brown fox walks past the lazy dog.'
-... s = Redlines(test_string_1, test_string_2)
-... s.opcodes
-[('equal', 0, 4, 0, 4), ('replace', 4, 6, 4, 6), ('equal', 6, 9, 6, 9)]
-
-
- -
Returns
- -
-

List of 5-tuples describing how to turn source into test.

-
-
- - -
-
- -
- changes: list[redlines.processor.Redline] - - - -
- - 
181    @property
-182    def changes(self) -> list[Redline]:
-183        """
-184        Return list of Redline objects representing the differences between source and test.
-185
-186        This provides a user-friendly interface for programmatically accessing changes,
-187        with direct access to the changed text and position information. Only actual
-188        changes are returned (equal operations are excluded).
-189
-190        ```python
-191        from redlines import Redlines
-192
-193        test = Redlines(
-194            "The quick brown fox jumps over the lazy dog.",
-195            "The quick brown fox walks past the lazy dog."
-196        )
-197
-198        for redline in test.changes:
-199            print(f"{redline.operation}: {redline.source_text} -> {redline.test_text}")
-200        # Output: replace: jumps over  -> walks past
-201        ```
-202
-203        :return: List of Redline objects (only actual changes, no 'equal' operations)
-204        """
-205        result = []
-206        for diff_op in self._diff_ops:
-207            tag, i1, i2, j1, j2 = diff_op.opcodes
-208
-209            # Skip equal operations - only return actual changes
-210            if tag == "equal":
-211                continue
-212
-213            source_tokens = diff_op.source_chunk.text
-214            test_tokens = diff_op.test_chunk.text
-215
-216            # Extract text and positions based on operation type
-217            if tag == "delete":
-218                redline = Redline(
-219                    operation="delete",
-220                    source_text="".join(source_tokens[i1:i2]),
-221                    test_text=None,
-222                    source_position=(i1, i2),
-223                    test_position=None,
-224                )
-225            elif tag == "insert":
-226                redline = Redline(
-227                    operation="insert",
-228                    source_text=None,
-229                    test_text="".join(test_tokens[j1:j2]),
-230                    source_position=None,
-231                    test_position=(j1, j2),
-232                )
-233            elif tag == "replace":
-234                redline = Redline(
-235                    operation="replace",
-236                    source_text="".join(source_tokens[i1:i2]),
-237                    test_text="".join(test_tokens[j1:j2]),
-238                    source_position=(i1, i2),
-239                    test_position=(j1, j2),
-240                )
-241            else:
-242                continue
-243
-244            result.append(redline)
-245
-246        return result
-
- - -

Return list of Redline objects representing the differences between source and test.

- -

This provides a user-friendly interface for programmatically accessing changes, -with direct access to the changed text and position information. Only actual -changes are returned (equal operations are excluded).

- -
-
from redlines import Redlines
-
-test = Redlines(
-    "The quick brown fox jumps over the lazy dog.",
-    "The quick brown fox walks past the lazy dog."
-)
-
-for redline in test.changes:
-    print(f"{redline.operation}: {redline.source_text} -> {redline.test_text}")
-# Output: replace: jumps over  -> walks past
-
-
- -
Returns
- -
-

List of Redline objects (only actual changes, no 'equal' operations)

-
-
- - -
-
- -
- - def - get_changes(self, operation: str | None = None) -> list[redlines.processor.Redline]: - - - -
- - 
248    def get_changes(
-249        self, operation: str | None = None
-250    ) -> list[Redline]:
-251        """
-252        Get changes (redlines), optionally filtered by operation type.
-253
-254        ```python
-255        from redlines import Redlines
-256
-257        test = Redlines(
-258            "The quick brown fox jumps over the lazy dog.",
-259            "The quick brown fox walks past the lazy dog."
-260        )
-261
-262        # Get all changes
-263        all_changes = test.get_changes()
-264
-265        # Get only replacements
-266        replacements = test.get_changes(operation="replace")
-267
-268        # Get deletions
-269        deletions = test.get_changes(operation="delete")
-270
-271        # Get insertions
-272        insertions = test.get_changes(operation="insert")
-273        ```
-274
-275        :param operation: Filter by operation type: "delete", "insert", or "replace". If None, returns all changes.
-276        :return: List of Redline objects matching the filter
-277        """
-278        changes = self.changes
-279
-280        if operation is None:
-281            return changes
-282
-283        if operation not in ("delete", "insert", "replace"):
-284            raise ValueError(
-285                f"Invalid operation '{operation}'. Must be 'delete', 'insert', or 'replace'."
-286            )
-287
-288        return [r for r in changes if r.operation == operation]
-
- - -

Get changes (redlines), optionally filtered by operation type.

- -
-
from redlines import Redlines
-
-test = Redlines(
-    "The quick brown fox jumps over the lazy dog.",
-    "The quick brown fox walks past the lazy dog."
-)
-
-# Get all changes
-all_changes = test.get_changes()
-
-# Get only replacements
-replacements = test.get_changes(operation="replace")
-
-# Get deletions
-deletions = test.get_changes(operation="delete")
-
-# Get insertions
-insertions = test.get_changes(operation="insert")
-
-
- -
Parameters
- -
    -
  • operation: Filter by operation type: "delete", "insert", or "replace". If None, returns all changes.
    • -
- -
Returns
- -
-

List of Redline objects matching the filter

-
-
- - -
-
- -
- - def - stats(self) -> redlines.processor.Stats: - - - -
- - 
290    def stats(self) -> Stats:
-291        """
-292        Get statistics about the changes between source and test.
-293
-294        ```python
-295        from redlines import Redlines
-296
-297        test = Redlines(
-298            "The quick brown fox jumps over the lazy dog.",
-299            "The quick brown fox walks past the lazy dog."
-300        )
-301
-302        stats = test.stats()
-303        print(f"Total changes: {stats.total_changes}")
-304        print(f"Deletions: {stats.deletions}")
-305        print(f"Insertions: {stats.insertions}")
-306        print(f"Replacements: {stats.replacements}")
-307        ```
-308
-309        :return: Stats object with change counts
-310        """
-311        changes = self.changes
-312
-313        deletions = sum(1 for c in changes if c.operation == "delete")
-314        insertions = sum(1 for c in changes if c.operation == "insert")
-315        replacements = sum(1 for c in changes if c.operation == "replace")
-316
-317        return Stats(
-318            total_changes=len(changes),
-319            deletions=deletions,
-320            insertions=insertions,
-321            replacements=replacements,
-322        )
-
- - -

Get statistics about the changes between source and test.

- -
-
from redlines import Redlines
-
-test = Redlines(
-    "The quick brown fox jumps over the lazy dog.",
-    "The quick brown fox walks past the lazy dog."
-)
-
-stats = test.stats()
-print(f"Total changes: {stats.total_changes}")
-print(f"Deletions: {stats.deletions}")
-print(f"Insertions: {stats.insertions}")
-print(f"Replacements: {stats.replacements}")
-
-
- -
Returns
- -
-

Stats object with change counts

-
-
- - -
-
- -
- output_markdown: str - - - -
- - 
324    @property
-325    def output_markdown(self) -> str:
-326        """
-327        Returns the delta in Markdown format.
-328
-329        ## Styling Markdown
-330        To output markdown in a particular manner, you must pass a `markdown_style` option when the `Redlines` object
-331        is created or when `Redlines.compare` is called.
-332
-333        ```python
-334        from redlines import Redlines
-335
-336        test = Redlines(
-337            "The quick brown fox jumps over the lazy dog.",
-338            "The quick brown fox walks past the lazy dog.",
-339            markdown_style="red"  # This option specifies the style as red
-340        )
-341
-342        test.compare(markdown_style="none") # This option specifies the style as none
-343        ```
-344
-345        ### Available styles
-346
-347        | Style | Preview |
-348        |-------| -------|
-349        |red-green (**default**) | "The quick brown fox <span style='color:red;font-weight:700;text-decoration:line-through;'>jumps over </span><span style='color:green;font-weight:700;'>walks past </span>the lazy dog."|
-350        |none | 'The quick brown fox <del>jumps over </del><ins>walks past </ins>the lazy dog.'|
-351        |red | "The quick brown fox <span style='color:red;font-weight:700;text-decoration:line-through;'>jumps over </span><span style='color:red;font-weight:700;'>walks past </span>the lazy dog."|
-352        |ghfm (GitHub Flavored Markdown)| 'The quick brown fox ~~jumps over ~~**walks past **the lazy dog.' |
-353        |bbcode (BBCode) | 'The quick brown fox [s][color=red]jumps over [/color][/s][b][color=green]walks past [/color][/b]the lazy dog.' |
-354        |streamlit | 'The quick brown fox ~~:red[jumps over ]~~ **:green[walks past ]** the lazy dog.' |
-355
-356        ### Custom styling
-357
-358        You can also use css classes to provide custom styling by setting `markdown_style` as "custom_css".
-359        Insertions and deletions are now styled using the "redline-inserted" and "redline-deleted" CSS classes.
-360        You can also set your own CSS classes by specifying the name of the CSS class in the options `ins_class`
-361        and `del_class` respectively in the constructor or compare function.
-362
-363        ## Markdown output in specific environments
-364
-365        Users have reported that the output doesn't display correctly in their environments.
-366        This is because styling may not appear in markdown environments which disallow HTML.
-367        There is no consistent support for strikethroughs and colors in the markdown standard,
-368        and styling is largely accomplished through raw HTML. If you are using GitHub or Streamlit, you may not get
-369        the formatting you expect or see any change at all.
-370
-371        If you are facing this kind of difficulty, here are some recommendations. If your experience doesn't match
-372        the hints or description below, or you continue to face problems, please raise an issue.
-373
-374        ### Jupyter Notebooks
-375        This library was first written for the Jupyter notebook environment, so all the available styles, including
-376        the default (`red-green`), `red` and `none` work.
-377
-378        ### Streamlit
-379
-380        Try this:
-381
-382        * If streamlit version is >= 1.16.0, consider the markdown style "streamlit"
-383        * If streamlit version is < 1.16.0, consider the markdown style `ghfm`
-384        * Enable parsing of HTML. In Streamlit, you need to set the `unsafe_allow_html` argument in `st.write` or
-385        `st.markdown` to `True`.
-386
-387        ### Colab
-388
-389        Try this:
-390        * Use the markdown style `none` or `ghfm`
-391        * `Redlines.output_rich` has been reported to work in Colab
-392
-393        :return: The delta in Markdown format.
-394        :rtype: str
-395        """
-396        result: list[str] = []
-397
-398        # default_style = "red_green"
-399
-400        md_styles = {
-401            "ins": (
-402                f"<span style='color:green;font-weight:700;'>",
-403                "</span>",
-404            ),
-405            "del": (
-406                f"<span style='color:red;font-weight:700;text-decoration:line-through;'>",
-407                "</span>",
-408            ),
-409        }
-410
-411        if "markdown_style" in self.options:
-412            style = self.options["markdown_style"]
-413
-414            if style == "none" or style is None:
-415                md_styles = {"ins": ("<ins>", "</ins>"), "del": ("<del>", "</del>")}
-416            elif style == "red":
-417                md_styles = {
-418                    "ins": (
-419                        f"<span style='color:red;font-weight:700;'>",
-420                        "</span>",
-421                    ),
-422                    "del": (
-423                        f"<span style='color:red;font-weight:700;text-decoration:line-through;'>",
-424                        "</span>",
-425                    ),
-426                }
-427            elif style == "custom_css":
-428                ins_class = (
-429                    self.options["ins_class"]
-430                    if "ins_class" in self.options
-431                    else "redline-inserted"
-432                )
-433                del_class = (
-434                    self.options["del_class"]
-435                    if "del_class" in self.options
-436                    else "redline-deleted"
-437                )
-438
-439                elem_attributes = {
-440                    "ins": f"class='{ins_class}'",
-441                    "del": f"class='{del_class}'",
-442                }
-443
-444                md_styles = {
-445                    "ins": (
-446                        f"<span {elem_attributes['ins']}>",
-447                        "</span>",
-448                    ),
-449                    "del": (
-450                        f"<span {elem_attributes['del']}>",
-451                        "</span>",
-452                    ),
-453                }
-454            elif style == "ghfm":
-455                md_styles = {"ins": ("**", "**"), "del": ("~~", "~~")}
-456            elif style == "bbcode":
-457                md_styles = {
-458                    "ins": ("[b][color=green]", "[/color][/b]"),
-459                    "del": ("[s][color=red]", "[/color][/s]"),
-460                }
-461            elif style == "streamlit":
-462                md_styles = {"ins": ("**:green[", "]** "), "del": ("~~:red[", "]~~ ")}
-463
-464        for diff_op in self._diff_ops:
-465            tag, i1, i2, j1, j2 = diff_op.opcodes
-466            source_tokens = diff_op.source_chunk.text
-467            test_tokens = diff_op.test_chunk.text
-468
-469            if tag == "equal":
-470                temp_str = "".join(source_tokens[i1:i2])
-471                temp_str = re.sub("¶ ", "\n\n", temp_str)
-472                # here we use '¶ ' instead of ' ¶ ', because the leading space will be included in the previous token,
-473                # according to tokenizer = re.compile(r"((?:[^()\s]+|[().?!-])\s*)")
-474                result.append(temp_str)
-475            elif tag == "insert":
-476                temp_str = "".join(test_tokens[j1:j2])
-477                splits = re.split("¶ ", temp_str)
-478                for split in splits:
-479                    result.append(f"{md_styles['ins'][0]}{split}{md_styles['ins'][1]}")
-480                    result.append("\n\n")
-481                if len(splits) > 0:
-482                    result.pop()
-483            elif tag == "delete":
-484                result.append(
-485                    f"{md_styles['del'][0]}{''.join(source_tokens[i1:i2])}{md_styles['del'][1]}"
-486                )
-487                # for 'delete', we make no change, because otherwise there will be two times '\n\n' than the original
-488                # text.
-489            elif tag == "replace":
-490                result.append(
-491                    f"{md_styles['del'][0]}{''.join(source_tokens[i1:i2])}{md_styles['del'][1]}"
-492                )
-493                temp_str = "".join(test_tokens[j1:j2])
-494                splits = re.split("¶ ", temp_str)
-495                for split in splits:
-496                    result.append(f"{md_styles['ins'][0]}{split}{md_styles['ins'][1]}")
-497                    result.append("\n\n")
-498                if len(splits) > 0:
-499                    result.pop()
-500
-501        return "".join(result)
-
- - -

Returns the delta in Markdown format.

- -

Styling Markdown

- -

To output markdown in a particular manner, you must pass a markdown_style option when the Redlines object -is created or when Redlines.compare is called.

- -
-
from redlines import Redlines
-
-test = Redlines(
-    "The quick brown fox jumps over the lazy dog.",
-    "The quick brown fox walks past the lazy dog.",
-    markdown_style="red"  # This option specifies the style as red
-)
-
-test.compare(markdown_style="none") # This option specifies the style as none
-
-
- -

Available styles

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
StylePreview
red-green (default)"The quick brown fox jumps over walks past the lazy dog."
none'The quick brown fox jumps over walks past the lazy dog.'
red"The quick brown fox jumps over walks past the lazy dog."
ghfm (GitHub Flavored Markdown)'The quick brown fox ~~jumps over ~~*walks past *the lazy dog.'
bbcode (BBCode)'The quick brown fox [s][color=red]jumps over [/color][/s][b][color=green]walks past [/color][/b]the lazy dog.'
streamlit'The quick brown fox :red[jumps over ] :green[walks past ] the lazy dog.'
- -

Custom styling

- -

You can also use css classes to provide custom styling by setting markdown_style as "custom_css". -Insertions and deletions are now styled using the "redline-inserted" and "redline-deleted" CSS classes. -You can also set your own CSS classes by specifying the name of the CSS class in the options ins_class -and del_class respectively in the constructor or compare function.

- -

Markdown output in specific environments

- -

Users have reported that the output doesn't display correctly in their environments. -This is because styling may not appear in markdown environments which disallow HTML. -There is no consistent support for strikethroughs and colors in the markdown standard, -and styling is largely accomplished through raw HTML. If you are using GitHub or Streamlit, you may not get -the formatting you expect or see any change at all.

- -

If you are facing this kind of difficulty, here are some recommendations. If your experience doesn't match -the hints or description below, or you continue to face problems, please raise an issue.

- -

Jupyter Notebooks

- -

This library was first written for the Jupyter notebook environment, so all the available styles, including -the default (red-green), red and none work.

- -

Streamlit

- -

Try this:

- -
    -
  • If streamlit version is >= 1.16.0, consider the markdown style "streamlit"
    • -
  • If streamlit version is < 1.16.0, consider the markdown style ghfm
    • -
  • Enable parsing of HTML. In Streamlit, you need to set the unsafe_allow_html argument in st.write or -st.markdown to True.
    • -
- -

Colab

- -

Try this:

- - - -
Returns
- -
-

The delta in Markdown format.

-
-
- - -
-
- -
- output_rich: rich.text.Text - - - -
- - 
503    @property
-504    def output_rich(self) -> Text:
-505        """
-506        Returns the delta in text with colors/style for the console.
-507
-508        :return: The delta in text with colors/style for the console.
-509        :rtype: Text
-510        """
-511        console_text = Text()
-512
-513        for diff_op in self._diff_ops:
-514            tag, i1, i2, j1, j2 = diff_op.opcodes
-515            source_tokens = diff_op.source_chunk.text
-516            test_tokens = diff_op.test_chunk.text
-517
-518            if tag == "equal":
-519                temp_str = "".join(source_tokens[i1:i2])
-520                temp_str = re.sub("¶ ", "\n\n", temp_str)
-521                console_text.append(temp_str)
-522            elif tag == "insert":
-523                temp_str = "".join(test_tokens[j1:j2])
-524                splits = re.split("¶ ", temp_str)
-525                for split in splits:
-526                    console_text.append(split, "green")
-527            elif tag == "delete":
-528                console_text.append("".join(source_tokens[i1:i2]), "strike red")
-529            elif tag == "replace":
-530                console_text.append("".join(source_tokens[i1:i2]), "strike red")
-531                temp_str = "".join(test_tokens[j1:j2])
-532                splits = re.split("¶ ", temp_str)
-533                for split in splits:
-534                    console_text.append(split, "green")
-535
-536        return console_text
-
- - -

Returns the delta in text with colors/style for the console.

- -
Returns
- -
-

The delta in text with colors/style for the console.

-
-
- - -
-
- -
- - def - compare( self, test: str | None = None, output: Union[redlines.enums.OutputType, Literal['markdown', 'rich']] = <OutputType.MARKDOWN: 'markdown'>, **options: Unpack[RedlinesOptions]) -> rich.text.Text | str: - - - -
- - 
538    def compare(
-539        self,
-540        test: str | None = None,
-541        output: OutputTypeLike = OutputType.MARKDOWN,
-542        **options: Unpack[RedlinesOptions],
-543    ) -> Text | str:
-544        """
-545        Compare `test` with `source`, and produce a delta in a format specified by `output`.
-546
-547        :param test: Optional test string to compare. If None, uses the test string provided during initialisation.
-548        :type test: str | None
-549        :param output: The format which the delta should be produced. Currently, "markdown" and "rich" are supported. Defaults to "markdown".
-550        :type output: OutputTypeLike
-551        :param options: Additional options for comparison and output formatting.
-552        :type options: RedlinesOptions
-553        :return: The delta in the format specified by `output`.
-554        :rtype: Text | str
-555        """
-556        if options:
-557            self.options = options
-558
-559        if test:
-560            if self._test and test == self._test:
-561                # If we've already processed this test string, no need to reprocess
-562                pass
-563            else:
-564                self.test = test
-565        elif self._test is None:
-566            raise ValueError(
-567                "No test string was provided when the function was called, or during initialisation."
-568            )
-569
-570        if output == OutputType.MARKDOWN:
-571            return self.output_markdown
-572        elif output == OutputType.RICH:
-573            return self.output_rich
-574        return self.output_markdown
-
- - -

Compare test with source, and produce a delta in a format specified by output.

- -
Parameters
- -
    -
  • test: Optional test string to compare. If None, uses the test string provided during initialisation.
    • -
  • output: The format which the delta should be produced. Currently, "markdown" and "rich" are supported. Defaults to "markdown".
    • -
  • options: Additional options for comparison and output formatting.
    • -
- -
Returns
- -
-

The delta in the format specified by output.

-
-
- - -
-
-
- -
- - class - RedlinesOptions(typing.TypedDict): - - - -
- - 
24class RedlinesOptions(t.TypedDict, total=False):
-25    markdown_style: str | MarkdownStyle | None
-26    """The style to use for markdown output. See `Redlines.output_markdown` for more information."""
-27    ins_class: str
-28    """The CSS class to use for insertions when `markdown_style` is set to `custom_css`. Defaults to 'redline-inserted'."""
-29    del_class: str
-30    """The CSS class to use for deletions when `markdown_style` is set to `custom_css`. Defaults to 'redline-deleted'."""
-
- - - - -
-
- markdown_style: str | redlines.enums.MarkdownStyle | None - - -
- - -

The style to use for markdown output. See Redlines.output_markdown for more information.

-
- - -
-
-
- ins_class: str - - -
- - -

The CSS class to use for insertions when markdown_style is set to custom_css. Defaults to 'redline-inserted'.

-
- - -
-
-
- del_class: str - - -
- - -

The CSS class to use for deletions when markdown_style is set to custom_css. Defaults to 'redline-deleted'.

-
- - -
-
-
- - \ No newline at end of file diff --git a/docs/generated-docs/search.js b/docs/generated-docs/search.js deleted file mode 100644 index 20ea74a..0000000 --- a/docs/generated-docs/search.js +++ /dev/null @@ -1,46 +0,0 @@ -window.pdocSearch = (function(){ -/** elasticlunr - http://weixsong.github.io * Copyright (C) 2017 Oliver Nightingale * Copyright (C) 2017 Wei Song * MIT Licensed */!function(){function e(e){if(null===e||"object"!=typeof e)return e;var t=e.constructor();for(var n in e)e.hasOwnProperty(n)&&(t[n]=e[n]);return t}var t=function(e){var n=new t.Index;return n.pipeline.add(t.trimmer,t.stopWordFilter,t.stemmer),e&&e.call(n,n),n};t.version="0.9.5",lunr=t,t.utils={},t.utils.warn=function(e){return function(t){e.console&&console.warn&&console.warn(t)}}(this),t.utils.toString=function(e){return void 0===e||null===e?"":e.toString()},t.EventEmitter=function(){this.events={}},t.EventEmitter.prototype.addListener=function(){var e=Array.prototype.slice.call(arguments),t=e.pop(),n=e;if("function"!=typeof t)throw new TypeError("last argument must be a function");n.forEach(function(e){this.hasHandler(e)||(this.events[e]=[]),this.events[e].push(t)},this)},t.EventEmitter.prototype.removeListener=function(e,t){if(this.hasHandler(e)){var n=this.events[e].indexOf(t);-1!==n&&(this.events[e].splice(n,1),0==this.events[e].length&&delete this.events[e])}},t.EventEmitter.prototype.emit=function(e){if(this.hasHandler(e)){var t=Array.prototype.slice.call(arguments,1);this.events[e].forEach(function(e){e.apply(void 0,t)},this)}},t.EventEmitter.prototype.hasHandler=function(e){return e in this.events},t.tokenizer=function(e){if(!arguments.length||null===e||void 0===e)return[];if(Array.isArray(e)){var n=e.filter(function(e){return null===e||void 0===e?!1:!0});n=n.map(function(e){return t.utils.toString(e).toLowerCase()});var i=[];return n.forEach(function(e){var n=e.split(t.tokenizer.seperator);i=i.concat(n)},this),i}return e.toString().trim().toLowerCase().split(t.tokenizer.seperator)},t.tokenizer.defaultSeperator=/[\s\-]+/,t.tokenizer.seperator=t.tokenizer.defaultSeperator,t.tokenizer.setSeperator=function(e){null!==e&&void 0!==e&&"object"==typeof e&&(t.tokenizer.seperator=e)},t.tokenizer.resetSeperator=function(){t.tokenizer.seperator=t.tokenizer.defaultSeperator},t.tokenizer.getSeperator=function(){return t.tokenizer.seperator},t.Pipeline=function(){this._queue=[]},t.Pipeline.registeredFunctions={},t.Pipeline.registerFunction=function(e,n){n in t.Pipeline.registeredFunctions&&t.utils.warn("Overwriting existing registered function: "+n),e.label=n,t.Pipeline.registeredFunctions[n]=e},t.Pipeline.getRegisteredFunction=function(e){return e in t.Pipeline.registeredFunctions!=!0?null:t.Pipeline.registeredFunctions[e]},t.Pipeline.warnIfFunctionNotRegistered=function(e){var n=e.label&&e.label in this.registeredFunctions;n||t.utils.warn("Function is not registered with pipeline. This may cause problems when serialising the index.\n",e)},t.Pipeline.load=function(e){var n=new t.Pipeline;return e.forEach(function(e){var i=t.Pipeline.getRegisteredFunction(e);if(!i)throw new Error("Cannot load un-registered function: "+e);n.add(i)}),n},t.Pipeline.prototype.add=function(){var e=Array.prototype.slice.call(arguments);e.forEach(function(e){t.Pipeline.warnIfFunctionNotRegistered(e),this._queue.push(e)},this)},t.Pipeline.prototype.after=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var i=this._queue.indexOf(e);if(-1===i)throw new Error("Cannot find existingFn");this._queue.splice(i+1,0,n)},t.Pipeline.prototype.before=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var i=this._queue.indexOf(e);if(-1===i)throw new Error("Cannot find existingFn");this._queue.splice(i,0,n)},t.Pipeline.prototype.remove=function(e){var t=this._queue.indexOf(e);-1!==t&&this._queue.splice(t,1)},t.Pipeline.prototype.run=function(e){for(var t=[],n=e.length,i=this._queue.length,o=0;n>o;o++){for(var r=e[o],s=0;i>s&&(r=this._queue[s](r,o,e),void 0!==r&&null!==r);s++);void 0!==r&&null!==r&&t.push(r)}return t},t.Pipeline.prototype.reset=function(){this._queue=[]},t.Pipeline.prototype.get=function(){return this._queue},t.Pipeline.prototype.toJSON=function(){return this._queue.map(function(e){return t.Pipeline.warnIfFunctionNotRegistered(e),e.label})},t.Index=function(){this._fields=[],this._ref="id",this.pipeline=new t.Pipeline,this.documentStore=new t.DocumentStore,this.index={},this.eventEmitter=new t.EventEmitter,this._idfCache={},this.on("add","remove","update",function(){this._idfCache={}}.bind(this))},t.Index.prototype.on=function(){var e=Array.prototype.slice.call(arguments);return this.eventEmitter.addListener.apply(this.eventEmitter,e)},t.Index.prototype.off=function(e,t){return this.eventEmitter.removeListener(e,t)},t.Index.load=function(e){e.version!==t.version&&t.utils.warn("version mismatch: current "+t.version+" importing "+e.version);var n=new this;n._fields=e.fields,n._ref=e.ref,n.documentStore=t.DocumentStore.load(e.documentStore),n.pipeline=t.Pipeline.load(e.pipeline),n.index={};for(var i in e.index)n.index[i]=t.InvertedIndex.load(e.index[i]);return n},t.Index.prototype.addField=function(e){return this._fields.push(e),this.index[e]=new t.InvertedIndex,this},t.Index.prototype.setRef=function(e){return this._ref=e,this},t.Index.prototype.saveDocument=function(e){return this.documentStore=new t.DocumentStore(e),this},t.Index.prototype.addDoc=function(e,n){if(e){var n=void 0===n?!0:n,i=e[this._ref];this.documentStore.addDoc(i,e),this._fields.forEach(function(n){var o=this.pipeline.run(t.tokenizer(e[n]));this.documentStore.addFieldLength(i,n,o.length);var r={};o.forEach(function(e){e in r?r[e]+=1:r[e]=1},this);for(var s in r){var u=r[s];u=Math.sqrt(u),this.index[n].addToken(s,{ref:i,tf:u})}},this),n&&this.eventEmitter.emit("add",e,this)}},t.Index.prototype.removeDocByRef=function(e){if(e&&this.documentStore.isDocStored()!==!1&&this.documentStore.hasDoc(e)){var t=this.documentStore.getDoc(e);this.removeDoc(t,!1)}},t.Index.prototype.removeDoc=function(e,n){if(e){var n=void 0===n?!0:n,i=e[this._ref];this.documentStore.hasDoc(i)&&(this.documentStore.removeDoc(i),this._fields.forEach(function(n){var o=this.pipeline.run(t.tokenizer(e[n]));o.forEach(function(e){this.index[n].removeToken(e,i)},this)},this),n&&this.eventEmitter.emit("remove",e,this))}},t.Index.prototype.updateDoc=function(e,t){var t=void 0===t?!0:t;this.removeDocByRef(e[this._ref],!1),this.addDoc(e,!1),t&&this.eventEmitter.emit("update",e,this)},t.Index.prototype.idf=function(e,t){var n="@"+t+"/"+e;if(Object.prototype.hasOwnProperty.call(this._idfCache,n))return this._idfCache[n];var i=this.index[t].getDocFreq(e),o=1+Math.log(this.documentStore.length/(i+1));return this._idfCache[n]=o,o},t.Index.prototype.getFields=function(){return this._fields.slice()},t.Index.prototype.search=function(e,n){if(!e)return[];e="string"==typeof e?{any:e}:JSON.parse(JSON.stringify(e));var i=null;null!=n&&(i=JSON.stringify(n));for(var o=new t.Configuration(i,this.getFields()).get(),r={},s=Object.keys(e),u=0;u0&&t.push(e);for(var i in n)"docs"!==i&&"df"!==i&&this.expandToken(e+i,t,n[i]);return t},t.InvertedIndex.prototype.toJSON=function(){return{root:this.root}},t.Configuration=function(e,n){var e=e||"";if(void 0==n||null==n)throw new Error("fields should not be null");this.config={};var i;try{i=JSON.parse(e),this.buildUserConfig(i,n)}catch(o){t.utils.warn("user configuration parse failed, will use default configuration"),this.buildDefaultConfig(n)}},t.Configuration.prototype.buildDefaultConfig=function(e){this.reset(),e.forEach(function(e){this.config[e]={boost:1,bool:"OR",expand:!1}},this)},t.Configuration.prototype.buildUserConfig=function(e,n){var i="OR",o=!1;if(this.reset(),"bool"in e&&(i=e.bool||i),"expand"in e&&(o=e.expand||o),"fields"in e)for(var r in e.fields)if(n.indexOf(r)>-1){var s=e.fields[r],u=o;void 0!=s.expand&&(u=s.expand),this.config[r]={boost:s.boost||0===s.boost?s.boost:1,bool:s.bool||i,expand:u}}else t.utils.warn("field name in user configuration not found in index instance fields");else this.addAllFields2UserConfig(i,o,n)},t.Configuration.prototype.addAllFields2UserConfig=function(e,t,n){n.forEach(function(n){this.config[n]={boost:1,bool:e,expand:t}},this)},t.Configuration.prototype.get=function(){return this.config},t.Configuration.prototype.reset=function(){this.config={}},lunr.SortedSet=function(){this.length=0,this.elements=[]},lunr.SortedSet.load=function(e){var t=new this;return t.elements=e,t.length=e.length,t},lunr.SortedSet.prototype.add=function(){var e,t;for(e=0;e1;){if(r===e)return o;e>r&&(t=o),r>e&&(n=o),i=n-t,o=t+Math.floor(i/2),r=this.elements[o]}return r===e?o:-1},lunr.SortedSet.prototype.locationFor=function(e){for(var t=0,n=this.elements.length,i=n-t,o=t+Math.floor(i/2),r=this.elements[o];i>1;)e>r&&(t=o),r>e&&(n=o),i=n-t,o=t+Math.floor(i/2),r=this.elements[o];return r>e?o:e>r?o+1:void 0},lunr.SortedSet.prototype.intersect=function(e){for(var t=new lunr.SortedSet,n=0,i=0,o=this.length,r=e.length,s=this.elements,u=e.elements;;){if(n>o-1||i>r-1)break;s[n]!==u[i]?s[n]u[i]&&i++:(t.add(s[n]),n++,i++)}return t},lunr.SortedSet.prototype.clone=function(){var e=new lunr.SortedSet;return e.elements=this.toArray(),e.length=e.elements.length,e},lunr.SortedSet.prototype.union=function(e){var t,n,i;this.length>=e.length?(t=this,n=e):(t=e,n=this),i=t.clone();for(var o=0,r=n.toArray();oRedlines\n\n

Redlines produces a text showing the differences between two strings/text. The changes are represented with\nstrike-throughs and underlines, which looks similar to Microsoft Word's track changes. This method of showing changes is\nmore familiar to lawyers and is more compact for long series of characters.

\n\n

Redlines uses SequenceMatcher\nto find differences between words used.\nThe output can be in HTML, Markdown, or rich format.

\n\n

Example

\n\n

Given an original string:

\n\n
The quick brown fox jumps over the lazy dog.\n
\n\n

And the string to be tested with:

\n\n
The quick brown fox walks past the lazy dog.\n
\n\n

The library gives a result of:

\n\n
\"The quick brown fox <span style='color:red;font-weight:700;text-decoration:line-through;'>jumps over </span><span style='color:green;font-weight:700;'>walks past </span>the lazy dog.\"\n
\n\n

Which is rendered like this:

\n\n

The quick brown fox jumps over walks past the lazy dog.

\n\n

Install

\n\n

Use your regular package manager to install the library in your python environment.

\n\n
pip install redlines\n
\n\n

Quickstart

\n\n

This is the most direct way to produce the example.

\n\n
\n
# import the class\nfrom redlines import Redlines\n\n# Create a Redlines object using the two strings to compare\ntest = Redlines(\n    "The quick brown fox jumps over the lazy dog.",\n    "The quick brown fox walks past the lazy dog.",\n)\n\n# This produces an output in markdown format\ntest.output_markdown\n
\n
\n\n

Common Issues

\n\n

The documentation contains other information on common issues users have faced while using this library:

\n\n\n"}, "redlines.cli": {"fullname": "redlines.cli", "modulename": "redlines.cli", "kind": "module", "doc": "

Command line interface for redlines.

\n\n

A command line interface for the redlines library that allows you to compare two strings\nand see the differences in the terminal.

\n\n

NAME

\n\n

redlines - A command line interface for the redlines library to compare text differences

\n\n

SYNOPSIS

\n\n
\n
redlines [COMMAND] [OPTIONS] SOURCE TEST\n
\n
\n\n

DESCRIPTION

\n\n

Redlines is a command line utility that shows the differences between two strings/text.\nThe changes are represented with strike-throughs and underlines, similar to Microsoft Word's track changes.\nThis method of showing changes is more familiar to lawyers and is more compact for long series of characters.

\n\n

COMMANDS

\n\n
\n
text\n
\n
\n\n

Compares the strings SOURCE and TEST and produces a redline in the terminal in a display that shows the original, new, and redlined text.

\n\n
\n
simple_text\n
\n
\n\n

Compares the strings SOURCE and TEST and outputs the redline in the terminal.

\n\n
\n
markdown\n
\n
\n\n

Compares the strings SOURCE and TEST and outputs the redline as a markdown.

\n\n

OPTIONS

\n\n
\n
-h, --help\n
\n
\n\n

Show this help message and exit.

\n\n

EXAMPLES

\n\n

Compare two strings and display the differences in a detailed layout:

\n\n
\n
redlines text "The quick brown fox jumps over the lazy dog." "The quick brown fox walks past the lazy dog."\n
\n
\n\n

Compare two strings and output the redline directly:

\n\n
\n
redlines simple_text "The quick brown fox jumps over the lazy dog." "The quick brown fox walks past the lazy dog."\n
\n
\n\n

LIMITATIONS

\n\n
    \n
  • The text command is not able to show more than 6 lines of text. You may want to use simple_text for longer text.
    • \n
\n\n

You may also want to consider a related textual project if you want to use redlines in the terminal,\nredlines-textual.

\n"}, "redlines.document": {"fullname": "redlines.document", "modulename": "redlines.document", "kind": "module", "doc": "

\n"}, "redlines.document.Document": {"fullname": "redlines.document.Document", "modulename": "redlines.document", "qualname": "Document", "kind": "class", "doc": "

An abstract base class used as a common data interchange with the redlines with formats other than python text strings.\nTo see a basic implementation, you can look at the PlainTextFile class for text files

\n\n\n\n\n \n \n\n\n\n\n \n \n\n\n
Supported File FormatsClass
Plain Text filesPlainTextFile
\n", "bases": "abc.ABC"}, "redlines.document.Document.text": {"fullname": "redlines.document.Document.text", "modulename": "redlines.document", "qualname": "Document.text", "kind": "variable", "doc": "

This property is used by the redlines library to obtain the text to compare. Implement this method to return\nthe text to be compared by redlines.

\n", "annotation": ": str"}, "redlines.document.PlainTextFile": {"fullname": "redlines.document.PlainTextFile", "modulename": "redlines.document", "qualname": "PlainTextFile", "kind": "class", "doc": "

Use this class so that Redlines can read plain text files.

\n\n
\n
from redlines import PlainTextFile\n\nsource = PlainTextFile("tests/documents/PlainTextFile/source.txt")\ntest = PlainTextFile("tests/documents/PlainTextFile/test.txt")\n\nredline = Redlines(source, test)\nassert (\n    redline.output_markdown\n    == "The quick brown fox <span style='color:red;font-weight:700;text-decoration:line-through;'>jumps over </span><span style='color:green;font-weight:700;'>walks past </span>the lazy dog."\n)\n
\n
\n", "bases": "Document"}, "redlines.document.PlainTextFile.__init__": {"fullname": "redlines.document.PlainTextFile.__init__", "modulename": "redlines.document", "qualname": "PlainTextFile.__init__", "kind": "function", "doc": "

Use this class so that Redlines can read plain text files.

\n\n
Parameters
\n\n
    \n
  • file_path: Path to the text file.
    • \n
\n", "signature": "(file_path: str | bytes | os.PathLike[str])"}, "redlines.document.PlainTextFile.text": {"fullname": "redlines.document.PlainTextFile.text", "modulename": "redlines.document", "qualname": "PlainTextFile.text", "kind": "variable", "doc": "
Returns
\n\n
\n

The text of the file referred to when the Document was created.

\n
\n", "annotation": ": str"}, "redlines.enums": {"fullname": "redlines.enums", "modulename": "redlines.enums", "kind": "module", "doc": "

\n"}, "redlines.enums.MarkdownStyle": {"fullname": "redlines.enums.MarkdownStyle", "modulename": "redlines.enums", "qualname": "MarkdownStyle", "kind": "class", "doc": "

The markdown styles supported by redlines.

\n", "bases": "builtins.str, enum.Enum"}, "redlines.enums.MarkdownStyle.RED_GREEN": {"fullname": "redlines.enums.MarkdownStyle.RED_GREEN", "modulename": "redlines.enums", "qualname": "MarkdownStyle.RED_GREEN", "kind": "variable", "doc": "

Red and green colors for deletions and additions respectively.

\n", "default_value": "<MarkdownStyle.RED_GREEN: 'red_green'>"}, "redlines.enums.MarkdownStyle.NONE": {"fullname": "redlines.enums.MarkdownStyle.NONE", "modulename": "redlines.enums", "qualname": "MarkdownStyle.NONE", "kind": "variable", "doc": "

No colors.

\n", "default_value": "<MarkdownStyle.NONE: 'none'>"}, "redlines.enums.MarkdownStyle.RED": {"fullname": "redlines.enums.MarkdownStyle.RED", "modulename": "redlines.enums", "qualname": "MarkdownStyle.RED", "kind": "variable", "doc": "

Only red color for changes.

\n", "default_value": "<MarkdownStyle.RED: 'red'>"}, "redlines.enums.MarkdownStyle.GHFM": {"fullname": "redlines.enums.MarkdownStyle.GHFM", "modulename": "redlines.enums", "qualname": "MarkdownStyle.GHFM", "kind": "variable", "doc": "

GitHub Flavored Markdown style.

\n", "default_value": "<MarkdownStyle.GHFM: 'ghfm'>"}, "redlines.enums.MarkdownStyle.BBCODE": {"fullname": "redlines.enums.MarkdownStyle.BBCODE", "modulename": "redlines.enums", "qualname": "MarkdownStyle.BBCODE", "kind": "variable", "doc": "

BBCode style.

\n", "default_value": "<MarkdownStyle.BBCODE: 'bbcode'>"}, "redlines.enums.MarkdownStyle.STREAMLIT": {"fullname": "redlines.enums.MarkdownStyle.STREAMLIT", "modulename": "redlines.enums", "qualname": "MarkdownStyle.STREAMLIT", "kind": "variable", "doc": "

Streamlit style.

\n", "default_value": "<MarkdownStyle.STREAMLIT: 'streamlit'>"}, "redlines.enums.OutputType": {"fullname": "redlines.enums.OutputType", "modulename": "redlines.enums", "qualname": "OutputType", "kind": "class", "doc": "

The output types supported by redlines.

\n", "bases": "builtins.str, enum.Enum"}, "redlines.enums.OutputType.MARKDOWN": {"fullname": "redlines.enums.OutputType.MARKDOWN", "modulename": "redlines.enums", "qualname": "OutputType.MARKDOWN", "kind": "variable", "doc": "

Markdown format.

\n", "default_value": "<OutputType.MARKDOWN: 'markdown'>"}, "redlines.enums.OutputType.RICH": {"fullname": "redlines.enums.OutputType.RICH", "modulename": "redlines.enums", "qualname": "OutputType.RICH", "kind": "variable", "doc": "

Rich format for terminal output.

\n", "default_value": "<OutputType.RICH: 'rich'>"}, "redlines.processor": {"fullname": "redlines.processor", "modulename": "redlines.processor", "kind": "module", "doc": "

\n"}, "redlines.processor.RedlinesProcessor": {"fullname": "redlines.processor.RedlinesProcessor", "modulename": "redlines.processor", "qualname": "RedlinesProcessor", "kind": "class", "doc": "

An abstract class that defines the interface for a redlines processor.\nA redlines processor is a class that takes two documents and generates diff operations from them.\nUse this class as a base class if you want to create a custom redlines processor.\nSee WholeDocumentProcessor for an example of a redlines processor.

\n", "bases": "abc.ABC"}, "redlines.processor.RedlinesProcessor.process": {"fullname": "redlines.processor.RedlinesProcessor.process", "modulename": "redlines.processor", "qualname": "RedlinesProcessor.process", "kind": "function", "doc": "

\n", "signature": "(\tself,\tsource: redlines.document.Document | str,\ttest: redlines.document.Document | str) -> list[redlines.processor.DiffOperation]:", "funcdef": "def"}, "redlines.processor.WholeDocumentProcessor": {"fullname": "redlines.processor.WholeDocumentProcessor", "modulename": "redlines.processor", "qualname": "WholeDocumentProcessor", "kind": "class", "doc": "

A redlines processor that compares two documents. It compares the entire documents as a single chunk.

\n", "bases": "RedlinesProcessor"}, "redlines.processor.WholeDocumentProcessor.process": {"fullname": "redlines.processor.WholeDocumentProcessor.process", "modulename": "redlines.processor", "qualname": "WholeDocumentProcessor.process", "kind": "function", "doc": "

Compare two documents as a single chunk.

\n\n
Parameters
\n\n
    \n
  • source: The source document to compare.
    • \n
  • test: The test document to compare.
    • \n
\n\n
Returns
\n\n
\n

A list of DiffOperation that describe the differences between the two documents.

\n
\n", "signature": "(\tself,\tsource: redlines.document.Document | str,\ttest: redlines.document.Document | str) -> list[redlines.processor.DiffOperation]:", "funcdef": "def"}, "redlines.processor.Redline": {"fullname": "redlines.processor.Redline", "modulename": "redlines.processor", "qualname": "Redline", "kind": "class", "doc": "

A structured representation of a single change between source and test text.

\n\n

This class provides a user-friendly interface for accessing diff information,\nwith direct access to the changed text and position information.

\n"}, "redlines.processor.Redline.__init__": {"fullname": "redlines.processor.Redline.__init__", "modulename": "redlines.processor", "qualname": "Redline.__init__", "kind": "function", "doc": "

\n", "signature": "(\toperation: Literal['delete', 'insert', 'replace'],\tsource_text: str | None,\ttest_text: str | None,\tsource_position: tuple[int, int] | None,\ttest_position: tuple[int, int] | None)"}, "redlines.processor.Redline.operation": {"fullname": "redlines.processor.Redline.operation", "modulename": "redlines.processor", "qualname": "Redline.operation", "kind": "variable", "doc": "

The type of change: 'delete', 'insert', or 'replace'

\n", "annotation": ": Literal['delete', 'insert', 'replace']"}, "redlines.processor.Redline.source_text": {"fullname": "redlines.processor.Redline.source_text", "modulename": "redlines.processor", "qualname": "Redline.source_text", "kind": "variable", "doc": "

The text from the source document. Present for 'delete' and 'replace' operations.

\n", "annotation": ": str | None"}, "redlines.processor.Redline.test_text": {"fullname": "redlines.processor.Redline.test_text", "modulename": "redlines.processor", "qualname": "Redline.test_text", "kind": "variable", "doc": "

The text from the test document. Present for 'insert' and 'replace' operations.

\n", "annotation": ": str | None"}, "redlines.processor.Redline.source_position": {"fullname": "redlines.processor.Redline.source_position", "modulename": "redlines.processor", "qualname": "Redline.source_position", "kind": "variable", "doc": "

Position in source tokens as (start, end). None for 'insert' operations.

\n", "annotation": ": tuple[int, int] | None"}, "redlines.processor.Redline.test_position": {"fullname": "redlines.processor.Redline.test_position", "modulename": "redlines.processor", "qualname": "Redline.test_position", "kind": "variable", "doc": "

Position in test tokens as (start, end). None for 'delete' operations.

\n", "annotation": ": tuple[int, int] | None"}, "redlines.processor.Stats": {"fullname": "redlines.processor.Stats", "modulename": "redlines.processor", "qualname": "Stats", "kind": "class", "doc": "

Statistics about the changes between source and test text.

\n\n

Provides a summary of all changes including counts by operation type.

\n"}, "redlines.processor.Stats.__init__": {"fullname": "redlines.processor.Stats.__init__", "modulename": "redlines.processor", "qualname": "Stats.__init__", "kind": "function", "doc": "

\n", "signature": "(\ttotal_changes: int,\tdeletions: int,\tinsertions: int,\treplacements: int)"}, "redlines.processor.Stats.total_changes": {"fullname": "redlines.processor.Stats.total_changes", "modulename": "redlines.processor", "qualname": "Stats.total_changes", "kind": "variable", "doc": "

Total number of changes (deletions + insertions + replacements)

\n", "annotation": ": int"}, "redlines.processor.Stats.deletions": {"fullname": "redlines.processor.Stats.deletions", "modulename": "redlines.processor", "qualname": "Stats.deletions", "kind": "variable", "doc": "

Number of deletion operations

\n", "annotation": ": int"}, "redlines.processor.Stats.insertions": {"fullname": "redlines.processor.Stats.insertions", "modulename": "redlines.processor", "qualname": "Stats.insertions", "kind": "variable", "doc": "

Number of insertion operations

\n", "annotation": ": int"}, "redlines.processor.Stats.replacements": {"fullname": "redlines.processor.Stats.replacements", "modulename": "redlines.processor", "qualname": "Stats.replacements", "kind": "variable", "doc": "

Number of replacement operations

\n", "annotation": ": int"}, "redlines.processor.DiffOperation": {"fullname": "redlines.processor.DiffOperation", "modulename": "redlines.processor", "qualname": "DiffOperation", "kind": "class", "doc": "

Internal representation of a diff operation (includes 'equal' operations for rendering)

\n"}, "redlines.processor.DiffOperation.__init__": {"fullname": "redlines.processor.DiffOperation.__init__", "modulename": "redlines.processor", "qualname": "DiffOperation.__init__", "kind": "function", "doc": "

\n", "signature": "(\tsource_chunk: redlines.processor.Chunk,\ttest_chunk: redlines.processor.Chunk,\topcodes: tuple[str, int, int, int, int])"}, "redlines.processor.DiffOperation.source_chunk": {"fullname": "redlines.processor.DiffOperation.source_chunk", "modulename": "redlines.processor", "qualname": "DiffOperation.source_chunk", "kind": "variable", "doc": "

\n", "annotation": ": redlines.processor.Chunk"}, "redlines.processor.DiffOperation.test_chunk": {"fullname": "redlines.processor.DiffOperation.test_chunk", "modulename": "redlines.processor", "qualname": "DiffOperation.test_chunk", "kind": "variable", "doc": "

The chunk of text that is being compared

\n", "annotation": ": redlines.processor.Chunk"}, "redlines.processor.DiffOperation.opcodes": {"fullname": "redlines.processor.DiffOperation.opcodes", "modulename": "redlines.processor", "qualname": "DiffOperation.opcodes", "kind": "variable", "doc": "

The opcodes that describe the operation. See the difflib documentation for more information

\n", "annotation": ": tuple[str, int, int, int, int]"}, "redlines.processor.Chunk": {"fullname": "redlines.processor.Chunk", "modulename": "redlines.processor", "qualname": "Chunk", "kind": "class", "doc": "

A chunk of text that is being compared. In some cases, it may be the whole document

\n"}, "redlines.processor.Chunk.__init__": {"fullname": "redlines.processor.Chunk.__init__", "modulename": "redlines.processor", "qualname": "Chunk.__init__", "kind": "function", "doc": "

\n", "signature": "(text: list[str], chunk_location: str | None)"}, "redlines.processor.Chunk.text": {"fullname": "redlines.processor.Chunk.text", "modulename": "redlines.processor", "qualname": "Chunk.text", "kind": "variable", "doc": "

The tokens of the chunk

\n", "annotation": ": list[str]"}, "redlines.processor.Chunk.chunk_location": {"fullname": "redlines.processor.Chunk.chunk_location", "modulename": "redlines.processor", "qualname": "Chunk.chunk_location", "kind": "variable", "doc": "

An optional string describing the location of the chunk in the document. For example, a PDF page number

\n", "annotation": ": str | None"}, "redlines.redlines": {"fullname": "redlines.redlines", "modulename": "redlines.redlines", "kind": "module", "doc": "

\n"}, "redlines.redlines.Redlines": {"fullname": "redlines.redlines.Redlines", "modulename": "redlines.redlines", "qualname": "Redlines", "kind": "class", "doc": "

\n"}, "redlines.redlines.Redlines.__init__": {"fullname": "redlines.redlines.Redlines.__init__", "modulename": "redlines.redlines", "qualname": "Redlines.__init__", "kind": "function", "doc": "

Redline is a class used to compare text, and producing human-readable differences or deltas\nwhich look like track changes in Microsoft Word.

\n\n
\n
# import the class\nfrom redlines import Redlines\n\n# Create a Redlines object using the two strings to compare\ntest = Redlines(\n    "The quick brown fox jumps over the lazy dog.",\n    "The quick brown fox walks past the lazy dog.",\n)\n\n# This produces an output in Markdown format\ntest.output_markdown\n
\n
\n\n

Besides strings, Redlines can also receive an input in another format if it is supported by the Document class

\n\n
\n
from redlines import PlainTextFile\n\nsource = PlainTextFile("tests/documents/PlainTextFile/source.txt")\ntest = PlainTextFile("tests/documents/PlainTextFile/test.txt")\n\nredline = Redlines(source, test)\nassert (\n    redline.output_markdown\n    == "The quick brown fox <span style='color:red;font-weight:700;text-decoration:line-through;'>jumps over </span><span style='color:green;font-weight:700;'>walks past </span>the lazy dog."\n)\n
\n
\n\n
Parameters
\n\n
    \n
  • source: The source text to be used as a basis for comparison.
    • \n
  • test: Optional test text to compare with the source.
    • \n
  • options: Additional options for comparison and output formatting.
    • \n
\n", "signature": "(\tsource: str | redlines.document.Document,\ttest: str | redlines.document.Document | None = None,\t**options: Unpack[redlines.redlines.RedlinesOptions])"}, "redlines.redlines.Redlines.source": {"fullname": "redlines.redlines.Redlines.source", "modulename": "redlines.redlines", "qualname": "Redlines.source", "kind": "variable", "doc": "

Get the source text to be used as a basis for comparison.

\n\n
Returns
\n\n
\n

The source text to be used as a basis for comparison.

\n
\n", "annotation": ": str"}, "redlines.redlines.Redlines.test": {"fullname": "redlines.redlines.Redlines.test", "modulename": "redlines.redlines", "qualname": "Redlines.test", "kind": "variable", "doc": "

Get the text to be compared with the source.

\n\n
Returns
\n\n
\n

The text to be compared with the source.

\n
\n", "annotation": ": str"}, "redlines.redlines.Redlines.redlines": {"fullname": "redlines.redlines.Redlines.redlines", "modulename": "redlines.redlines", "qualname": "Redlines.redlines", "kind": "variable", "doc": "

Return the list of Redline objects representing actual changes between source and test.

\n\n

This is an alias for the changes property and provides the same functionality.\nOnly actual changes are returned (equal operations are excluded).

\n\n
Returns
\n\n
\n

List of Redline objects

\n
\n", "annotation": ": list[redlines.processor.Redline]"}, "redlines.redlines.Redlines.processor": {"fullname": "redlines.redlines.Redlines.processor", "modulename": "redlines.redlines", "qualname": "Redlines.processor", "kind": "variable", "doc": "

\n"}, "redlines.redlines.Redlines.options": {"fullname": "redlines.redlines.Redlines.options", "modulename": "redlines.redlines", "qualname": "Redlines.options", "kind": "variable", "doc": "

\n"}, "redlines.redlines.Redlines.opcodes": {"fullname": "redlines.redlines.Redlines.opcodes", "modulename": "redlines.redlines", "qualname": "Redlines.opcodes", "kind": "variable", "doc": "

Return list of 5-tuples describing how to turn source into test.\nSimilar to SequenceMatcher.get_opcodes.

\n\n
\n
>>> test_string_1 = 'The quick brown fox jumps over the lazy dog.'\n... test_string_2 = 'The quick brown fox walks past the lazy dog.'\n... s = Redlines(test_string_1, test_string_2)\n... s.opcodes\n[('equal', 0, 4, 0, 4), ('replace', 4, 6, 4, 6), ('equal', 6, 9, 6, 9)]\n
\n
\n\n
Returns
\n\n
\n

List of 5-tuples describing how to turn source into test.

\n
\n", "annotation": ": list[tuple[str, int, int, int, int]]"}, "redlines.redlines.Redlines.changes": {"fullname": "redlines.redlines.Redlines.changes", "modulename": "redlines.redlines", "qualname": "Redlines.changes", "kind": "variable", "doc": "

Return list of Redline objects representing the differences between source and test.

\n\n

This provides a user-friendly interface for programmatically accessing changes,\nwith direct access to the changed text and position information. Only actual\nchanges are returned (equal operations are excluded).

\n\n
\n
from redlines import Redlines\n\ntest = Redlines(\n    "The quick brown fox jumps over the lazy dog.",\n    "The quick brown fox walks past the lazy dog."\n)\n\nfor redline in test.changes:\n    print(f"{redline.operation}: {redline.source_text} -> {redline.test_text}")\n# Output: replace: jumps over  -> walks past\n
\n
\n\n
Returns
\n\n
\n

List of Redline objects (only actual changes, no 'equal' operations)

\n
\n", "annotation": ": list[redlines.processor.Redline]"}, "redlines.redlines.Redlines.get_changes": {"fullname": "redlines.redlines.Redlines.get_changes", "modulename": "redlines.redlines", "qualname": "Redlines.get_changes", "kind": "function", "doc": "

Get changes (redlines), optionally filtered by operation type.

\n\n
\n
from redlines import Redlines\n\ntest = Redlines(\n    "The quick brown fox jumps over the lazy dog.",\n    "The quick brown fox walks past the lazy dog."\n)\n\n# Get all changes\nall_changes = test.get_changes()\n\n# Get only replacements\nreplacements = test.get_changes(operation="replace")\n\n# Get deletions\ndeletions = test.get_changes(operation="delete")\n\n# Get insertions\ninsertions = test.get_changes(operation="insert")\n
\n
\n\n
Parameters
\n\n
    \n
  • operation: Filter by operation type: \"delete\", \"insert\", or \"replace\". If None, returns all changes.
    • \n
\n\n
Returns
\n\n
\n

List of Redline objects matching the filter

\n
\n", "signature": "(self, operation: str | None = None) -> list[redlines.processor.Redline]:", "funcdef": "def"}, "redlines.redlines.Redlines.stats": {"fullname": "redlines.redlines.Redlines.stats", "modulename": "redlines.redlines", "qualname": "Redlines.stats", "kind": "function", "doc": "

Get statistics about the changes between source and test.

\n\n
\n
from redlines import Redlines\n\ntest = Redlines(\n    "The quick brown fox jumps over the lazy dog.",\n    "The quick brown fox walks past the lazy dog."\n)\n\nstats = test.stats()\nprint(f"Total changes: {stats.total_changes}")\nprint(f"Deletions: {stats.deletions}")\nprint(f"Insertions: {stats.insertions}")\nprint(f"Replacements: {stats.replacements}")\n
\n
\n\n
Returns
\n\n
\n

Stats object with change counts

\n
\n", "signature": "(self) -> redlines.processor.Stats:", "funcdef": "def"}, "redlines.redlines.Redlines.output_markdown": {"fullname": "redlines.redlines.Redlines.output_markdown", "modulename": "redlines.redlines", "qualname": "Redlines.output_markdown", "kind": "variable", "doc": "

Returns the delta in Markdown format.

\n\n

Styling Markdown

\n\n

To output markdown in a particular manner, you must pass a markdown_style option when the Redlines object\nis created or when Redlines.compare is called.

\n\n
\n
from redlines import Redlines\n\ntest = Redlines(\n    "The quick brown fox jumps over the lazy dog.",\n    "The quick brown fox walks past the lazy dog.",\n    markdown_style="red"  # This option specifies the style as red\n)\n\ntest.compare(markdown_style="none") # This option specifies the style as none\n
\n
\n\n

Available styles

\n\n\n\n\n \n \n\n\n\n\n \n \n\n\n \n \n\n\n \n \n\n\n \n \n\n\n \n \n\n\n \n \n\n\n
StylePreview
red-green (default)\"The quick brown fox jumps over walks past the lazy dog.\"
none'The quick brown fox jumps over walks past the lazy dog.'
red\"The quick brown fox jumps over walks past the lazy dog.\"
ghfm (GitHub Flavored Markdown)'The quick brown fox ~~jumps over ~~*walks past *the lazy dog.'
bbcode (BBCode)'The quick brown fox [s][color=red]jumps over [/color][/s][b][color=green]walks past [/color][/b]the lazy dog.'
streamlit'The quick brown fox :red[jumps over ] :green[walks past ] the lazy dog.'
\n\n

Custom styling

\n\n

You can also use css classes to provide custom styling by setting markdown_style as \"custom_css\".\nInsertions and deletions are now styled using the \"redline-inserted\" and \"redline-deleted\" CSS classes.\nYou can also set your own CSS classes by specifying the name of the CSS class in the options ins_class\nand del_class respectively in the constructor or compare function.

\n\n

Markdown output in specific environments

\n\n

Users have reported that the output doesn't display correctly in their environments.\nThis is because styling may not appear in markdown environments which disallow HTML.\nThere is no consistent support for strikethroughs and colors in the markdown standard,\nand styling is largely accomplished through raw HTML. If you are using GitHub or Streamlit, you may not get\nthe formatting you expect or see any change at all.

\n\n

If you are facing this kind of difficulty, here are some recommendations. If your experience doesn't match\nthe hints or description below, or you continue to face problems, please raise an issue.

\n\n

Jupyter Notebooks

\n\n

This library was first written for the Jupyter notebook environment, so all the available styles, including\nthe default (red-green), red and none work.

\n\n

Streamlit

\n\n

Try this:

\n\n
    \n
  • If streamlit version is >= 1.16.0, consider the markdown style \"streamlit\"
    • \n
  • If streamlit version is < 1.16.0, consider the markdown style ghfm
    • \n
  • Enable parsing of HTML. In Streamlit, you need to set the unsafe_allow_html argument in st.write or\nst.markdown to True.
    • \n
\n\n

Colab

\n\n

Try this:

\n\n
    \n
  • Use the markdown style none or ghfm
    • \n
  • Redlines.output_rich has been reported to work in Colab
    • \n
\n\n
Returns
\n\n
\n

The delta in Markdown format.

\n
\n", "annotation": ": str"}, "redlines.redlines.Redlines.output_rich": {"fullname": "redlines.redlines.Redlines.output_rich", "modulename": "redlines.redlines", "qualname": "Redlines.output_rich", "kind": "variable", "doc": "

Returns the delta in text with colors/style for the console.

\n\n
Returns
\n\n
\n

The delta in text with colors/style for the console.

\n
\n", "annotation": ": rich.text.Text"}, "redlines.redlines.Redlines.compare": {"fullname": "redlines.redlines.Redlines.compare", "modulename": "redlines.redlines", "qualname": "Redlines.compare", "kind": "function", "doc": "

Compare test with source, and produce a delta in a format specified by output.

\n\n
Parameters
\n\n
    \n
  • test: Optional test string to compare. If None, uses the test string provided during initialisation.
    • \n
  • output: The format which the delta should be produced. Currently, \"markdown\" and \"rich\" are supported. Defaults to \"markdown\".
    • \n
  • options: Additional options for comparison and output formatting.
    • \n
\n\n
Returns
\n\n
\n

The delta in the format specified by output.

\n
\n", "signature": "(\tself,\ttest: str | None = None,\toutput: Union[redlines.enums.OutputType, Literal['markdown', 'rich']] = <OutputType.MARKDOWN: 'markdown'>,\t**options: Unpack[redlines.redlines.RedlinesOptions]) -> rich.text.Text | str:", "funcdef": "def"}, "redlines.redlines.RedlinesOptions": {"fullname": "redlines.redlines.RedlinesOptions", "modulename": "redlines.redlines", "qualname": "RedlinesOptions", "kind": "class", "doc": "

\n", "bases": "typing.TypedDict"}, "redlines.redlines.RedlinesOptions.markdown_style": {"fullname": "redlines.redlines.RedlinesOptions.markdown_style", "modulename": "redlines.redlines", "qualname": "RedlinesOptions.markdown_style", "kind": "variable", "doc": "

The style to use for markdown output. See Redlines.output_markdown for more information.

\n", "annotation": ": str | redlines.enums.MarkdownStyle | None"}, "redlines.redlines.RedlinesOptions.ins_class": {"fullname": "redlines.redlines.RedlinesOptions.ins_class", "modulename": "redlines.redlines", "qualname": "RedlinesOptions.ins_class", "kind": "variable", "doc": "

The CSS class to use for insertions when markdown_style is set to custom_css. Defaults to 'redline-inserted'.

\n", "annotation": ": str"}, "redlines.redlines.RedlinesOptions.del_class": {"fullname": "redlines.redlines.RedlinesOptions.del_class", "modulename": "redlines.redlines", "qualname": "RedlinesOptions.del_class", "kind": "variable", "doc": "

The CSS class to use for deletions when markdown_style is set to custom_css. Defaults to 'redline-deleted'.

\n", "annotation": ": str"}}, "docInfo": {"redlines": {"qualname": 0, "fullname": 1, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 422}, "redlines.cli": {"qualname": 0, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 462}, "redlines.document": {"qualname": 0, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "redlines.document.Document": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 77}, "redlines.document.Document.text": {"qualname": 2, "fullname": 4, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 29}, "redlines.document.PlainTextFile": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 175}, "redlines.document.PlainTextFile.__init__": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 33}, "redlines.document.PlainTextFile.text": {"qualname": 2, "fullname": 4, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 22}, "redlines.enums": {"qualname": 0, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "redlines.enums.MarkdownStyle": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 4, "doc": 9}, "redlines.enums.MarkdownStyle.RED_GREEN": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 11, "signature": 0, "bases": 0, "doc": 12}, "redlines.enums.MarkdownStyle.NONE": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 5}, "redlines.enums.MarkdownStyle.RED": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 8}, "redlines.enums.MarkdownStyle.GHFM": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 7}, "redlines.enums.MarkdownStyle.BBCODE": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 5}, "redlines.enums.MarkdownStyle.STREAMLIT": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 5}, "redlines.enums.OutputType": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 4, "doc": 9}, "redlines.enums.OutputType.MARKDOWN": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 5}, "redlines.enums.OutputType.RICH": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 8}, "redlines.processor": {"qualname": 0, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "redlines.processor.RedlinesProcessor": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 57}, "redlines.processor.RedlinesProcessor.process": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 85, "bases": 0, "doc": 3}, "redlines.processor.WholeDocumentProcessor": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 19}, "redlines.processor.WholeDocumentProcessor.process": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 85, "bases": 0, "doc": 63}, "redlines.processor.Redline": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 39}, "redlines.processor.Redline.__init__": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 141, "bases": 0, "doc": 3}, "redlines.processor.Redline.operation": {"qualname": 2, "fullname": 4, "annotation": 12, "default_value": 0, "signature": 0, "bases": 0, "doc": 11}, "redlines.processor.Redline.source_text": {"qualname": 3, "fullname": 5, "annotation": 4, "default_value": 0, "signature": 0, "bases": 0, "doc": 15}, "redlines.processor.Redline.test_text": {"qualname": 3, "fullname": 5, "annotation": 4, "default_value": 0, "signature": 0, "bases": 0, "doc": 15}, "redlines.processor.Redline.source_position": {"qualname": 3, "fullname": 5, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 14}, "redlines.processor.Redline.test_position": {"qualname": 3, "fullname": 5, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 14}, "redlines.processor.Stats": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 26}, "redlines.processor.Stats.__init__": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 49, "bases": 0, "doc": 3}, "redlines.processor.Stats.total_changes": {"qualname": 3, "fullname": 5, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 12}, "redlines.processor.Stats.deletions": {"qualname": 2, "fullname": 4, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 6}, "redlines.processor.Stats.insertions": {"qualname": 2, "fullname": 4, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 6}, "redlines.processor.Stats.replacements": {"qualname": 2, "fullname": 4, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 6}, "redlines.processor.DiffOperation": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 14}, "redlines.processor.DiffOperation.__init__": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 89, "bases": 0, "doc": 3}, "redlines.processor.DiffOperation.source_chunk": {"qualname": 3, "fullname": 5, "annotation": 4, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "redlines.processor.DiffOperation.test_chunk": {"qualname": 3, "fullname": 5, "annotation": 4, "default_value": 0, "signature": 0, "bases": 0, "doc": 10}, "redlines.processor.DiffOperation.opcodes": {"qualname": 2, "fullname": 4, "annotation": 6, "default_value": 0, "signature": 0, "bases": 0, "doc": 15}, "redlines.processor.Chunk": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 19}, "redlines.processor.Chunk.__init__": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 37, "bases": 0, "doc": 3}, "redlines.processor.Chunk.text": {"qualname": 2, "fullname": 4, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 7}, "redlines.processor.Chunk.chunk_location": {"qualname": 3, "fullname": 5, "annotation": 4, "default_value": 0, "signature": 0, "bases": 0, "doc": 20}, "redlines.redlines": {"qualname": 0, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "redlines.redlines.Redlines": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "redlines.redlines.Redlines.__init__": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 100, "bases": 0, "doc": 373}, "redlines.redlines.Redlines.source": {"qualname": 2, "fullname": 4, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 36}, "redlines.redlines.Redlines.test": {"qualname": 2, "fullname": 4, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 30}, "redlines.redlines.Redlines.redlines": {"qualname": 2, "fullname": 4, "annotation": 4, "default_value": 0, "signature": 0, "bases": 0, "doc": 56}, "redlines.redlines.Redlines.processor": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "redlines.redlines.Redlines.options": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "redlines.redlines.Redlines.opcodes": {"qualname": 2, "fullname": 4, "annotation": 6, "default_value": 0, "signature": 0, "bases": 0, "doc": 188}, "redlines.redlines.Redlines.changes": {"qualname": 2, "fullname": 4, "annotation": 4, "default_value": 0, "signature": 0, "bases": 0, "doc": 230}, "redlines.redlines.Redlines.get_changes": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 53, "bases": 0, "doc": 267}, "redlines.redlines.Redlines.stats": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 24, "bases": 0, "doc": 243}, "redlines.redlines.Redlines.output_markdown": {"qualname": 3, "fullname": 5, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 732}, "redlines.redlines.Redlines.output_rich": {"qualname": 3, "fullname": 5, "annotation": 4, "default_value": 0, "signature": 0, "bases": 0, "doc": 32}, "redlines.redlines.Redlines.compare": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 164, "bases": 0, "doc": 106}, "redlines.redlines.RedlinesOptions": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 3}, "redlines.redlines.RedlinesOptions.markdown_style": {"qualname": 3, "fullname": 5, "annotation": 8, "default_value": 0, "signature": 0, "bases": 0, "doc": 19}, "redlines.redlines.RedlinesOptions.ins_class": {"qualname": 3, "fullname": 5, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 26}, "redlines.redlines.RedlinesOptions.del_class": {"qualname": 3, "fullname": 5, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 26}}, "length": 65, "save": true}, "index": {"qualname": {"root": {"docs": {"redlines.document.PlainTextFile.__init__": {"tf": 1}, "redlines.processor.Redline.__init__": {"tf": 1}, "redlines.processor.Stats.__init__": {"tf": 1}, "redlines.processor.DiffOperation.__init__": {"tf": 1}, "redlines.processor.Chunk.__init__": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 6, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"redlines.document.Document": {"tf": 1}, "redlines.document.Document.text": {"tf": 1}}, "df": 2}}}}}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {"redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.Stats.deletions": {"tf": 1}}, "df": 1}}}}}}}}, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.processor.DiffOperation": {"tf": 1}, "redlines.processor.DiffOperation.__init__": {"tf": 1}, "redlines.processor.DiffOperation.source_chunk": {"tf": 1}, "redlines.processor.DiffOperation.test_chunk": {"tf": 1}, "redlines.processor.DiffOperation.opcodes": {"tf": 1}}, "df": 5}}}}}}}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {"redlines.document.Document.text": {"tf": 1}, "redlines.document.PlainTextFile.text": {"tf": 1}, "redlines.processor.Redline.source_text": {"tf": 1}, "redlines.processor.Redline.test_text": {"tf": 1}, "redlines.processor.Chunk.text": {"tf": 1}}, "df": 5}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"redlines.processor.Redline.test_text": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}, "redlines.processor.DiffOperation.test_chunk": {"tf": 1}, "redlines.redlines.Redlines.test": {"tf": 1}}, "df": 4}}}, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"redlines.processor.Stats.total_changes": {"tf": 1}}, "df": 1}}}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.document.PlainTextFile": {"tf": 1}, "redlines.document.PlainTextFile.__init__": {"tf": 1}, "redlines.document.PlainTextFile.text": {"tf": 1}}, "df": 3}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.RedlinesProcessor.process": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}}, "df": 2, "o": {"docs": {}, "df": 0, "r": {"docs": {"redlines.redlines.Redlines.processor": {"tf": 1}}, "df": 1}}}}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}}, "df": 2}}}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"redlines.document.PlainTextFile.__init__": {"tf": 1}, "redlines.processor.Redline.__init__": {"tf": 1}, "redlines.processor.Stats.__init__": {"tf": 1}, "redlines.processor.DiffOperation.__init__": {"tf": 1}, "redlines.processor.Chunk.__init__": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 6}}, "s": {"docs": {"redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.Stats.insertions": {"tf": 1}}, "df": 1}}}}}}}}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "n": {"docs": {"redlines.enums.OutputType.MARKDOWN": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1}}, "df": 3, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.enums.MarkdownStyle": {"tf": 1}, "redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1}, "redlines.enums.MarkdownStyle.NONE": {"tf": 1}, "redlines.enums.MarkdownStyle.RED": {"tf": 1}, "redlines.enums.MarkdownStyle.GHFM": {"tf": 1}, "redlines.enums.MarkdownStyle.BBCODE": {"tf": 1}, "redlines.enums.MarkdownStyle.STREAMLIT": {"tf": 1}}, "df": 7}}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1}, "redlines.enums.MarkdownStyle.RED": {"tf": 1}}, "df": 2, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.Redline": {"tf": 1}, "redlines.processor.Redline.__init__": {"tf": 1}, "redlines.processor.Redline.operation": {"tf": 1}, "redlines.processor.Redline.source_text": {"tf": 1}, "redlines.processor.Redline.test_text": {"tf": 1}, "redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}}, "df": 7, "s": {"docs": {"redlines.redlines.Redlines": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.source": {"tf": 1}, "redlines.redlines.Redlines.test": {"tf": 1}, "redlines.redlines.Redlines.redlines": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.processor": {"tf": 1}, "redlines.redlines.Redlines.options": {"tf": 1}, "redlines.redlines.Redlines.opcodes": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}, "redlines.redlines.Redlines.output_rich": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 14, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.processor.RedlinesProcessor.process": {"tf": 1}}, "df": 2}}}}}}}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.RedlinesOptions": {"tf": 1}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 4}}}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.Stats.replacements": {"tf": 1}}, "df": 1}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"redlines.enums.OutputType.RICH": {"tf": 1}, "redlines.redlines.Redlines.output_rich": {"tf": 1}}, "df": 2}}}}, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1}}, "df": 1}}}}, "h": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "m": {"docs": {"redlines.enums.MarkdownStyle.GHFM": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {"redlines.redlines.Redlines.get_changes": {"tf": 1}}, "df": 1}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"redlines.enums.MarkdownStyle.NONE": {"tf": 1}}, "df": 1}}}}, "b": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"redlines.enums.MarkdownStyle.BBCODE": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"redlines.enums.MarkdownStyle.STREAMLIT": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.Stats": {"tf": 1}, "redlines.processor.Stats.__init__": {"tf": 1}, "redlines.processor.Stats.total_changes": {"tf": 1}, "redlines.processor.Stats.deletions": {"tf": 1}, "redlines.processor.Stats.insertions": {"tf": 1}, "redlines.processor.Stats.replacements": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 1}}, "df": 7}}}, "y": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.Redline.source_text": {"tf": 1}, "redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.DiffOperation.source_chunk": {"tf": 1}, "redlines.redlines.Redlines.source": {"tf": 1}}, "df": 4}}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}, "redlines.redlines.Redlines.output_rich": {"tf": 1}}, "df": 2, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"redlines.enums.OutputType": {"tf": 1}, "redlines.enums.OutputType.MARKDOWN": {"tf": 1}, "redlines.enums.OutputType.RICH": {"tf": 1}}, "df": 3}}}}}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.processor.Redline.operation": {"tf": 1}}, "df": 1}}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.DiffOperation.opcodes": {"tf": 1}, "redlines.redlines.Redlines.opcodes": {"tf": 1}}, "df": 2}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.options": {"tf": 1}}, "df": 1}}}}}}}, "w": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"redlines.processor.WholeDocumentProcessor": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}}, "df": 2}}}}}}}}}}}}}}}}}}}}}}, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.Stats.total_changes": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1}}, "df": 3}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "k": {"docs": {"redlines.processor.DiffOperation.source_chunk": {"tf": 1}, "redlines.processor.DiffOperation.test_chunk": {"tf": 1}, "redlines.processor.Chunk": {"tf": 1}, "redlines.processor.Chunk.__init__": {"tf": 1}, "redlines.processor.Chunk.text": {"tf": 1}, "redlines.processor.Chunk.chunk_location": {"tf": 1.4142135623730951}}, "df": 6}}}}, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 1}}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 2}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.processor.Chunk.chunk_location": {"tf": 1}}, "df": 1}}}}}}}}}}, "fullname": {"root": {"docs": {"redlines.document.PlainTextFile.__init__": {"tf": 1}, "redlines.processor.Redline.__init__": {"tf": 1}, "redlines.processor.Stats.__init__": {"tf": 1}, "redlines.processor.DiffOperation.__init__": {"tf": 1}, "redlines.processor.Chunk.__init__": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 6, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1}, "redlines.enums.MarkdownStyle.RED": {"tf": 1}}, "df": 2, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.Redline": {"tf": 1}, "redlines.processor.Redline.__init__": {"tf": 1}, "redlines.processor.Redline.operation": {"tf": 1}, "redlines.processor.Redline.source_text": {"tf": 1}, "redlines.processor.Redline.test_text": {"tf": 1}, "redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}}, "df": 7, "s": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1}, "redlines.document": {"tf": 1}, "redlines.document.Document": {"tf": 1}, "redlines.document.Document.text": {"tf": 1}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.document.PlainTextFile.__init__": {"tf": 1}, "redlines.document.PlainTextFile.text": {"tf": 1}, "redlines.enums": {"tf": 1}, "redlines.enums.MarkdownStyle": {"tf": 1}, "redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1}, "redlines.enums.MarkdownStyle.NONE": {"tf": 1}, "redlines.enums.MarkdownStyle.RED": {"tf": 1}, "redlines.enums.MarkdownStyle.GHFM": {"tf": 1}, "redlines.enums.MarkdownStyle.BBCODE": {"tf": 1}, "redlines.enums.MarkdownStyle.STREAMLIT": {"tf": 1}, "redlines.enums.OutputType": {"tf": 1}, "redlines.enums.OutputType.MARKDOWN": {"tf": 1}, "redlines.enums.OutputType.RICH": {"tf": 1}, "redlines.processor": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.processor.RedlinesProcessor.process": {"tf": 1}, "redlines.processor.WholeDocumentProcessor": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}, "redlines.processor.Redline": {"tf": 1}, "redlines.processor.Redline.__init__": {"tf": 1}, "redlines.processor.Redline.operation": {"tf": 1}, "redlines.processor.Redline.source_text": {"tf": 1}, "redlines.processor.Redline.test_text": {"tf": 1}, "redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}, "redlines.processor.Stats": {"tf": 1}, "redlines.processor.Stats.__init__": {"tf": 1}, "redlines.processor.Stats.total_changes": {"tf": 1}, "redlines.processor.Stats.deletions": {"tf": 1}, "redlines.processor.Stats.insertions": {"tf": 1}, "redlines.processor.Stats.replacements": {"tf": 1}, "redlines.processor.DiffOperation": {"tf": 1}, "redlines.processor.DiffOperation.__init__": {"tf": 1}, "redlines.processor.DiffOperation.source_chunk": {"tf": 1}, "redlines.processor.DiffOperation.test_chunk": {"tf": 1}, "redlines.processor.DiffOperation.opcodes": {"tf": 1}, "redlines.processor.Chunk": {"tf": 1}, "redlines.processor.Chunk.__init__": {"tf": 1}, "redlines.processor.Chunk.text": {"tf": 1}, "redlines.processor.Chunk.chunk_location": {"tf": 1}, "redlines.redlines": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.__init__": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.source": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.test": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.redlines": {"tf": 2}, "redlines.redlines.Redlines.processor": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.options": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.opcodes": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.changes": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.get_changes": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.stats": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.output_rich": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.compare": {"tf": 1.7320508075688772}, "redlines.redlines.RedlinesOptions": {"tf": 1.4142135623730951}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1.4142135623730951}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1.4142135623730951}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1.4142135623730951}}, "df": 65, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.processor.RedlinesProcessor.process": {"tf": 1}}, "df": 2}}}}}}}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.RedlinesOptions": {"tf": 1}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 4}}}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.Stats.replacements": {"tf": 1}}, "df": 1}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"redlines.enums.OutputType.RICH": {"tf": 1}, "redlines.redlines.Redlines.output_rich": {"tf": 1}}, "df": 2}}}}, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {"redlines.cli": {"tf": 1}}, "df": 1}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 2}}}}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.Stats.total_changes": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1}}, "df": 3}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "k": {"docs": {"redlines.processor.DiffOperation.source_chunk": {"tf": 1}, "redlines.processor.DiffOperation.test_chunk": {"tf": 1}, "redlines.processor.Chunk": {"tf": 1}, "redlines.processor.Chunk.__init__": {"tf": 1}, "redlines.processor.Chunk.text": {"tf": 1}, "redlines.processor.Chunk.chunk_location": {"tf": 1.4142135623730951}}, "df": 6}}}}, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 1}}}}}}}, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"redlines.document": {"tf": 1}, "redlines.document.Document": {"tf": 1.4142135623730951}, "redlines.document.Document.text": {"tf": 1.4142135623730951}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.document.PlainTextFile.__init__": {"tf": 1}, "redlines.document.PlainTextFile.text": {"tf": 1}}, "df": 6}}}}}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {"redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.Stats.deletions": {"tf": 1}}, "df": 1}}}}}}}}, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.processor.DiffOperation": {"tf": 1}, "redlines.processor.DiffOperation.__init__": {"tf": 1}, "redlines.processor.DiffOperation.source_chunk": {"tf": 1}, "redlines.processor.DiffOperation.test_chunk": {"tf": 1}, "redlines.processor.DiffOperation.opcodes": {"tf": 1}}, "df": 5}}}}}}}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {"redlines.document.Document.text": {"tf": 1}, "redlines.document.PlainTextFile.text": {"tf": 1}, "redlines.processor.Redline.source_text": {"tf": 1}, "redlines.processor.Redline.test_text": {"tf": 1}, "redlines.processor.Chunk.text": {"tf": 1}}, "df": 5}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"redlines.processor.Redline.test_text": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}, "redlines.processor.DiffOperation.test_chunk": {"tf": 1}, "redlines.redlines.Redlines.test": {"tf": 1}}, "df": 4}}}, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"redlines.processor.Stats.total_changes": {"tf": 1}}, "df": 1}}}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.document.PlainTextFile": {"tf": 1}, "redlines.document.PlainTextFile.__init__": {"tf": 1}, "redlines.document.PlainTextFile.text": {"tf": 1}}, "df": 3}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.RedlinesProcessor.process": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}}, "df": 2, "o": {"docs": {}, "df": 0, "r": {"docs": {"redlines.processor": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.processor.RedlinesProcessor.process": {"tf": 1}, "redlines.processor.WholeDocumentProcessor": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}, "redlines.processor.Redline": {"tf": 1}, "redlines.processor.Redline.__init__": {"tf": 1}, "redlines.processor.Redline.operation": {"tf": 1}, "redlines.processor.Redline.source_text": {"tf": 1}, "redlines.processor.Redline.test_text": {"tf": 1}, "redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}, "redlines.processor.Stats": {"tf": 1}, "redlines.processor.Stats.__init__": {"tf": 1}, "redlines.processor.Stats.total_changes": {"tf": 1}, "redlines.processor.Stats.deletions": {"tf": 1}, "redlines.processor.Stats.insertions": {"tf": 1}, "redlines.processor.Stats.replacements": {"tf": 1}, "redlines.processor.DiffOperation": {"tf": 1}, "redlines.processor.DiffOperation.__init__": {"tf": 1}, "redlines.processor.DiffOperation.source_chunk": {"tf": 1}, "redlines.processor.DiffOperation.test_chunk": {"tf": 1}, "redlines.processor.DiffOperation.opcodes": {"tf": 1}, "redlines.processor.Chunk": {"tf": 1}, "redlines.processor.Chunk.__init__": {"tf": 1}, "redlines.processor.Chunk.text": {"tf": 1}, "redlines.processor.Chunk.chunk_location": {"tf": 1}, "redlines.redlines.Redlines.processor": {"tf": 1}}, "df": 28}}}}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}}, "df": 2}}}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"redlines.document.PlainTextFile.__init__": {"tf": 1}, "redlines.processor.Redline.__init__": {"tf": 1}, "redlines.processor.Stats.__init__": {"tf": 1}, "redlines.processor.DiffOperation.__init__": {"tf": 1}, "redlines.processor.Chunk.__init__": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 6}}, "s": {"docs": {"redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.Stats.insertions": {"tf": 1}}, "df": 1}}}}}}}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"redlines.enums": {"tf": 1}, "redlines.enums.MarkdownStyle": {"tf": 1}, "redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1}, "redlines.enums.MarkdownStyle.NONE": {"tf": 1}, "redlines.enums.MarkdownStyle.RED": {"tf": 1}, "redlines.enums.MarkdownStyle.GHFM": {"tf": 1}, "redlines.enums.MarkdownStyle.BBCODE": {"tf": 1}, "redlines.enums.MarkdownStyle.STREAMLIT": {"tf": 1}, "redlines.enums.OutputType": {"tf": 1}, "redlines.enums.OutputType.MARKDOWN": {"tf": 1}, "redlines.enums.OutputType.RICH": {"tf": 1}}, "df": 11}}}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "n": {"docs": {"redlines.enums.OutputType.MARKDOWN": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1}}, "df": 3, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.enums.MarkdownStyle": {"tf": 1}, "redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1}, "redlines.enums.MarkdownStyle.NONE": {"tf": 1}, "redlines.enums.MarkdownStyle.RED": {"tf": 1}, "redlines.enums.MarkdownStyle.GHFM": {"tf": 1}, "redlines.enums.MarkdownStyle.BBCODE": {"tf": 1}, "redlines.enums.MarkdownStyle.STREAMLIT": {"tf": 1}}, "df": 7}}}}}}}}}}}}}, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1}}, "df": 1}}}}, "h": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "m": {"docs": {"redlines.enums.MarkdownStyle.GHFM": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {"redlines.redlines.Redlines.get_changes": {"tf": 1}}, "df": 1}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"redlines.enums.MarkdownStyle.NONE": {"tf": 1}}, "df": 1}}}}, "b": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"redlines.enums.MarkdownStyle.BBCODE": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"redlines.enums.MarkdownStyle.STREAMLIT": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.Stats": {"tf": 1}, "redlines.processor.Stats.__init__": {"tf": 1}, "redlines.processor.Stats.total_changes": {"tf": 1}, "redlines.processor.Stats.deletions": {"tf": 1}, "redlines.processor.Stats.insertions": {"tf": 1}, "redlines.processor.Stats.replacements": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 1}}, "df": 7}}}, "y": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.Redline.source_text": {"tf": 1}, "redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.DiffOperation.source_chunk": {"tf": 1}, "redlines.redlines.Redlines.source": {"tf": 1}}, "df": 4}}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}, "redlines.redlines.Redlines.output_rich": {"tf": 1}}, "df": 2, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"redlines.enums.OutputType": {"tf": 1}, "redlines.enums.OutputType.MARKDOWN": {"tf": 1}, "redlines.enums.OutputType.RICH": {"tf": 1}}, "df": 3}}}}}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.processor.Redline.operation": {"tf": 1}}, "df": 1}}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.DiffOperation.opcodes": {"tf": 1}, "redlines.redlines.Redlines.opcodes": {"tf": 1}}, "df": 2}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.options": {"tf": 1}}, "df": 1}}}}}}}, "w": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"redlines.processor.WholeDocumentProcessor": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}}, "df": 2}}}}}}}}}}}}}}}}}}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.processor.Chunk.chunk_location": {"tf": 1}}, "df": 1}}}}}}}}}}, "annotation": {"root": {"docs": {"redlines.document.Document.text": {"tf": 1}, "redlines.document.PlainTextFile.text": {"tf": 1}, "redlines.processor.Redline.operation": {"tf": 1.4142135623730951}, "redlines.processor.Redline.source_text": {"tf": 1.4142135623730951}, "redlines.processor.Redline.test_text": {"tf": 1.4142135623730951}, "redlines.processor.Redline.source_position": {"tf": 1.4142135623730951}, "redlines.processor.Redline.test_position": {"tf": 1.4142135623730951}, "redlines.processor.Stats.total_changes": {"tf": 1}, "redlines.processor.Stats.deletions": {"tf": 1}, "redlines.processor.Stats.insertions": {"tf": 1}, "redlines.processor.Stats.replacements": {"tf": 1}, "redlines.processor.DiffOperation.source_chunk": {"tf": 1}, "redlines.processor.DiffOperation.test_chunk": {"tf": 1}, "redlines.processor.DiffOperation.opcodes": {"tf": 1}, "redlines.processor.Chunk.text": {"tf": 1}, "redlines.processor.Chunk.chunk_location": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.source": {"tf": 1}, "redlines.redlines.Redlines.test": {"tf": 1}, "redlines.redlines.Redlines.redlines": {"tf": 1}, "redlines.redlines.Redlines.opcodes": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}, "redlines.redlines.Redlines.output_rich": {"tf": 1}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1.7320508075688772}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 26, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"redlines.document.Document.text": {"tf": 1}, "redlines.document.PlainTextFile.text": {"tf": 1}, "redlines.processor.Redline.source_text": {"tf": 1}, "redlines.processor.Redline.test_text": {"tf": 1}, "redlines.processor.Chunk.chunk_location": {"tf": 1}, "redlines.redlines.Redlines.source": {"tf": 1}, "redlines.redlines.Redlines.test": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 11}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"redlines.processor.Redline.operation": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"redlines.processor.Chunk.text": {"tf": 1}}, "df": 1}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.redlines": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}}, "df": 2}}}}}}}}, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"redlines.redlines.Redlines.opcodes": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "x": {"2": {"7": {"docs": {"redlines.processor.Redline.operation": {"tf": 2.449489742783178}}, "df": 1}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.Redline.operation": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"redlines.processor.Redline.operation": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {"redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}, "redlines.processor.Stats.total_changes": {"tf": 1}, "redlines.processor.Stats.deletions": {"tf": 1}, "redlines.processor.Stats.insertions": {"tf": 1}, "redlines.processor.Stats.replacements": {"tf": 1}, "redlines.processor.DiffOperation.opcodes": {"tf": 2}, "redlines.redlines.Redlines.opcodes": {"tf": 2}}, "df": 8}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.Redline.operation": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.redlines": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}}, "df": 2, "s": {"docs": {"redlines.processor.DiffOperation.source_chunk": {"tf": 1}, "redlines.processor.DiffOperation.test_chunk": {"tf": 1}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1}}, "df": 3}}}}}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"redlines.redlines.Redlines.output_rich": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.Redline.source_text": {"tf": 1}, "redlines.processor.Redline.test_text": {"tf": 1}, "redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}, "redlines.processor.Chunk.chunk_location": {"tf": 1}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1}}, "df": 6}}}}, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}}, "df": 2}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"redlines.processor.DiffOperation.opcodes": {"tf": 1}}, "df": 1}}}}}}}}, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {"redlines.redlines.Redlines.output_rich": {"tf": 1.4142135623730951}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"redlines.processor.DiffOperation.source_chunk": {"tf": 1}, "redlines.processor.DiffOperation.test_chunk": {"tf": 1}, "redlines.redlines.Redlines.redlines": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}}, "df": 4}}}}}}}}}, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "k": {"docs": {"redlines.processor.DiffOperation.source_chunk": {"tf": 1}, "redlines.processor.DiffOperation.test_chunk": {"tf": 1}}, "df": 2}}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1}}, "df": 1}}}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}, "default_value": {"root": {"docs": {"redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1.4142135623730951}, "redlines.enums.MarkdownStyle.NONE": {"tf": 1.4142135623730951}, "redlines.enums.MarkdownStyle.RED": {"tf": 1.4142135623730951}, "redlines.enums.MarkdownStyle.GHFM": {"tf": 1.4142135623730951}, "redlines.enums.MarkdownStyle.BBCODE": {"tf": 1.4142135623730951}, "redlines.enums.MarkdownStyle.STREAMLIT": {"tf": 1.4142135623730951}, "redlines.enums.OutputType.MARKDOWN": {"tf": 1.4142135623730951}, "redlines.enums.OutputType.RICH": {"tf": 1.4142135623730951}}, "df": 8, "l": {"docs": {}, "df": 0, "t": {"docs": {"redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1}, "redlines.enums.MarkdownStyle.NONE": {"tf": 1}, "redlines.enums.MarkdownStyle.RED": {"tf": 1}, "redlines.enums.MarkdownStyle.GHFM": {"tf": 1}, "redlines.enums.MarkdownStyle.BBCODE": {"tf": 1}, "redlines.enums.MarkdownStyle.STREAMLIT": {"tf": 1}, "redlines.enums.OutputType.MARKDOWN": {"tf": 1}, "redlines.enums.OutputType.RICH": {"tf": 1}}, "df": 8}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "n": {"docs": {"redlines.enums.OutputType.MARKDOWN": {"tf": 1.4142135623730951}}, "df": 1, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1}, "redlines.enums.MarkdownStyle.NONE": {"tf": 1}, "redlines.enums.MarkdownStyle.RED": {"tf": 1}, "redlines.enums.MarkdownStyle.GHFM": {"tf": 1}, "redlines.enums.MarkdownStyle.BBCODE": {"tf": 1}, "redlines.enums.MarkdownStyle.STREAMLIT": {"tf": 1}}, "df": 6}}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1.4142135623730951}, "redlines.enums.MarkdownStyle.RED": {"tf": 1.4142135623730951}}, "df": 2}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"redlines.enums.OutputType.RICH": {"tf": 1.4142135623730951}}, "df": 1}}}}, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1.4142135623730951}}, "df": 1}}}}, "t": {"docs": {"redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1}, "redlines.enums.MarkdownStyle.NONE": {"tf": 1}, "redlines.enums.MarkdownStyle.RED": {"tf": 1}, "redlines.enums.MarkdownStyle.GHFM": {"tf": 1}, "redlines.enums.MarkdownStyle.BBCODE": {"tf": 1}, "redlines.enums.MarkdownStyle.STREAMLIT": {"tf": 1}, "redlines.enums.OutputType.MARKDOWN": {"tf": 1}, "redlines.enums.OutputType.RICH": {"tf": 1}}, "df": 8}, "h": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "m": {"docs": {"redlines.enums.MarkdownStyle.GHFM": {"tf": 1.4142135623730951}}, "df": 1}}}}, "x": {"2": {"7": {"docs": {"redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1.4142135623730951}, "redlines.enums.MarkdownStyle.NONE": {"tf": 1.4142135623730951}, "redlines.enums.MarkdownStyle.RED": {"tf": 1.4142135623730951}, "redlines.enums.MarkdownStyle.GHFM": {"tf": 1.4142135623730951}, "redlines.enums.MarkdownStyle.BBCODE": {"tf": 1.4142135623730951}, "redlines.enums.MarkdownStyle.STREAMLIT": {"tf": 1.4142135623730951}, "redlines.enums.OutputType.MARKDOWN": {"tf": 1.4142135623730951}, "redlines.enums.OutputType.RICH": {"tf": 1.4142135623730951}}, "df": 8}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"redlines.enums.MarkdownStyle.NONE": {"tf": 1.4142135623730951}}, "df": 1}}}}, "b": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"redlines.enums.MarkdownStyle.BBCODE": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"redlines.enums.MarkdownStyle.STREAMLIT": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"redlines.enums.OutputType.MARKDOWN": {"tf": 1}, "redlines.enums.OutputType.RICH": {"tf": 1}}, "df": 2}}}}}}}}}}}}, "signature": {"root": {"3": {"9": {"docs": {"redlines.processor.Redline.__init__": {"tf": 2.449489742783178}, "redlines.redlines.Redlines.compare": {"tf": 2.449489742783178}}, "df": 2}, "docs": {}, "df": 0}, "docs": {"redlines.document.PlainTextFile.__init__": {"tf": 5.5677643628300215}, "redlines.processor.RedlinesProcessor.process": {"tf": 8.366600265340756}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 8.366600265340756}, "redlines.processor.Redline.__init__": {"tf": 10.488088481701515}, "redlines.processor.Stats.__init__": {"tf": 6.324555320336759}, "redlines.processor.DiffOperation.__init__": {"tf": 8.48528137423857}, "redlines.processor.Chunk.__init__": {"tf": 5.477225575051661}, "redlines.redlines.Redlines.__init__": {"tf": 9.1104335791443}, "redlines.redlines.Redlines.get_changes": {"tf": 6.6332495807108}, "redlines.redlines.Redlines.stats": {"tf": 4.47213595499958}, "redlines.redlines.Redlines.compare": {"tf": 11.445523142259598}}, "df": 11, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.document.PlainTextFile.__init__": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"redlines.document.PlainTextFile.__init__": {"tf": 1}}, "df": 1, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {"redlines.document.PlainTextFile.__init__": {"tf": 1}}, "df": 1}}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"redlines.processor.RedlinesProcessor.process": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}, "redlines.processor.DiffOperation.__init__": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.get_changes": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 1}}, "df": 5}}}}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.processor.Redline.__init__": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"redlines.document.PlainTextFile.__init__": {"tf": 1.4142135623730951}, "redlines.processor.RedlinesProcessor.process": {"tf": 1.4142135623730951}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1.4142135623730951}, "redlines.processor.Redline.__init__": {"tf": 1.4142135623730951}, "redlines.processor.DiffOperation.__init__": {"tf": 1}, "redlines.processor.Chunk.__init__": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.__init__": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.get_changes": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1.4142135623730951}}, "df": 9}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.stats": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "f": {"docs": {"redlines.processor.RedlinesProcessor.process": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 5}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.RedlinesProcessor.process": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}, "redlines.processor.Redline.__init__": {"tf": 1.4142135623730951}, "redlines.processor.DiffOperation.__init__": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 5}}}}}}, "b": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines.document.PlainTextFile.__init__": {"tf": 1}}, "df": 1}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {"redlines.document.PlainTextFile.__init__": {"tf": 1}}, "df": 1}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.processor.Redline.__init__": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1}}, "df": 2}}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.DiffOperation.__init__": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 2}}}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 1, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.compare": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.get_changes": {"tf": 1}}, "df": 1, "s": {"docs": {"redlines.processor.RedlinesProcessor.process": {"tf": 1.7320508075688772}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1.7320508075688772}, "redlines.processor.DiffOperation.__init__": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.__init__": {"tf": 2}, "redlines.redlines.Redlines.get_changes": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1.7320508075688772}}, "df": 7, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 2}}}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.Redline.__init__": {"tf": 1}}, "df": 1, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.Stats.__init__": {"tf": 1}}, "df": 1}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"redlines.redlines.Redlines.compare": {"tf": 1.4142135623730951}}, "df": 1}}}}, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"redlines.processor.RedlinesProcessor.process": {"tf": 2}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 2}, "redlines.redlines.Redlines.__init__": {"tf": 2}}, "df": 3}}}}}}}, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.processor.RedlinesProcessor.process": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}}, "df": 2}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.Redline.__init__": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.Stats.__init__": {"tf": 1}}, "df": 1}}}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"redlines.processor.RedlinesProcessor.process": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}, "redlines.processor.Redline.__init__": {"tf": 1.4142135623730951}, "redlines.processor.DiffOperation.__init__": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 6}}, "x": {"docs": {}, "df": 0, "t": {"docs": {"redlines.processor.Redline.__init__": {"tf": 1.4142135623730951}, "redlines.processor.Chunk.__init__": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1.4142135623730951}}, "df": 3}}}, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.Redline.__init__": {"tf": 1.4142135623730951}, "redlines.processor.DiffOperation.__init__": {"tf": 1}}, "df": 2}}}}, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"redlines.processor.Stats.__init__": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"redlines.processor.RedlinesProcessor.process": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}, "redlines.processor.Chunk.__init__": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1}}, "df": 4}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"redlines.processor.Redline.__init__": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 2}}}}}}, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.processor.Chunk.__init__": {"tf": 1}}, "df": 1}}}}}}}, "t": {"docs": {"redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"redlines.processor.Redline.__init__": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.Stats.__init__": {"tf": 1}}, "df": 1}}}}}}}}, "t": {"docs": {"redlines.processor.Redline.__init__": {"tf": 2}, "redlines.processor.Stats.__init__": {"tf": 2}, "redlines.processor.DiffOperation.__init__": {"tf": 2}}, "df": 3}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.Redline.__init__": {"tf": 2}, "redlines.processor.Chunk.__init__": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.get_changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.compare": {"tf": 1.4142135623730951}}, "df": 5}}}}, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.Stats.__init__": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "k": {"docs": {"redlines.processor.DiffOperation.__init__": {"tf": 2}, "redlines.processor.Chunk.__init__": {"tf": 1}}, "df": 2}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 2}}}}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 1}}}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "n": {"docs": {"redlines.redlines.Redlines.compare": {"tf": 1.7320508075688772}}, "df": 1}}}}}}}}, "g": {"docs": {}, "df": 0, "t": {"docs": {"redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 1}}}}, "bases": {"root": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "c": {"docs": {"redlines.document.Document": {"tf": 1.4142135623730951}, "redlines.processor.RedlinesProcessor": {"tf": 1.4142135623730951}}, "df": 2}}}, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"redlines.document.PlainTextFile": {"tf": 1}}, "df": 1}}}}}}}}, "b": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"redlines.enums.MarkdownStyle": {"tf": 1}, "redlines.enums.OutputType": {"tf": 1}}, "df": 2}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"redlines.enums.MarkdownStyle": {"tf": 1}, "redlines.enums.OutputType": {"tf": 1}}, "df": 2}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {"redlines.enums.MarkdownStyle": {"tf": 1.4142135623730951}, "redlines.enums.OutputType": {"tf": 1.4142135623730951}}, "df": 2}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"redlines.processor.WholeDocumentProcessor": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines.redlines.RedlinesOptions": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"redlines.redlines.RedlinesOptions": {"tf": 1}}, "df": 1}}}}}}}}}}}, "doc": {"root": {"0": {"docs": {"redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 2}, "1": {"6": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 1}, "docs": {"redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 2}, "2": {"docs": {"redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}}, "df": 1}, "3": {"9": {"docs": {"redlines.document.PlainTextFile": {"tf": 2}, "redlines.redlines.Redlines.__init__": {"tf": 2}, "redlines.redlines.Redlines.opcodes": {"tf": 3.1622776601683795}}, "df": 3}, "docs": {}, "df": 0}, "4": {"docs": {"redlines.redlines.Redlines.opcodes": {"tf": 2}}, "df": 1}, "5": {"docs": {"redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}}, "df": 1}, "6": {"docs": {"redlines.cli": {"tf": 1}, "redlines.redlines.Redlines.opcodes": {"tf": 2}}, "df": 2}, "9": {"docs": {"redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}}, "df": 1}, "docs": {"redlines": {"tf": 12.206555615733702}, "redlines.cli": {"tf": 13.674794331177344}, "redlines.document": {"tf": 1.7320508075688772}, "redlines.document.Document": {"tf": 5.830951894845301}, "redlines.document.Document.text": {"tf": 1.7320508075688772}, "redlines.document.PlainTextFile": {"tf": 10}, "redlines.document.PlainTextFile.__init__": {"tf": 3.7416573867739413}, "redlines.document.PlainTextFile.text": {"tf": 3}, "redlines.enums": {"tf": 1.7320508075688772}, "redlines.enums.MarkdownStyle": {"tf": 1.7320508075688772}, "redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1.7320508075688772}, "redlines.enums.MarkdownStyle.NONE": {"tf": 1.7320508075688772}, "redlines.enums.MarkdownStyle.RED": {"tf": 1.7320508075688772}, "redlines.enums.MarkdownStyle.GHFM": {"tf": 1.7320508075688772}, "redlines.enums.MarkdownStyle.BBCODE": {"tf": 1.7320508075688772}, "redlines.enums.MarkdownStyle.STREAMLIT": {"tf": 1.7320508075688772}, "redlines.enums.OutputType": {"tf": 1.7320508075688772}, "redlines.enums.OutputType.MARKDOWN": {"tf": 1.7320508075688772}, "redlines.enums.OutputType.RICH": {"tf": 1.7320508075688772}, "redlines.processor": {"tf": 1.7320508075688772}, "redlines.processor.RedlinesProcessor": {"tf": 2.23606797749979}, "redlines.processor.RedlinesProcessor.process": {"tf": 1.7320508075688772}, "redlines.processor.WholeDocumentProcessor": {"tf": 1.7320508075688772}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 5.477225575051661}, "redlines.processor.Redline": {"tf": 2.449489742783178}, "redlines.processor.Redline.__init__": {"tf": 1.7320508075688772}, "redlines.processor.Redline.operation": {"tf": 1.7320508075688772}, "redlines.processor.Redline.source_text": {"tf": 1.7320508075688772}, "redlines.processor.Redline.test_text": {"tf": 1.7320508075688772}, "redlines.processor.Redline.source_position": {"tf": 1.7320508075688772}, "redlines.processor.Redline.test_position": {"tf": 1.7320508075688772}, "redlines.processor.Stats": {"tf": 2.449489742783178}, "redlines.processor.Stats.__init__": {"tf": 1.7320508075688772}, "redlines.processor.Stats.total_changes": {"tf": 2.23606797749979}, "redlines.processor.Stats.deletions": {"tf": 1.4142135623730951}, "redlines.processor.Stats.insertions": {"tf": 1.4142135623730951}, "redlines.processor.Stats.replacements": {"tf": 1.4142135623730951}, "redlines.processor.DiffOperation": {"tf": 1.7320508075688772}, "redlines.processor.DiffOperation.__init__": {"tf": 1.7320508075688772}, "redlines.processor.DiffOperation.source_chunk": {"tf": 1.7320508075688772}, "redlines.processor.DiffOperation.test_chunk": {"tf": 1.4142135623730951}, "redlines.processor.DiffOperation.opcodes": {"tf": 1.4142135623730951}, "redlines.processor.Chunk": {"tf": 1.4142135623730951}, "redlines.processor.Chunk.__init__": {"tf": 1.7320508075688772}, "redlines.processor.Chunk.text": {"tf": 1.4142135623730951}, "redlines.processor.Chunk.chunk_location": {"tf": 1.4142135623730951}, "redlines.redlines": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.__init__": {"tf": 13.638181696985855}, "redlines.redlines.Redlines.source": {"tf": 3.4641016151377544}, "redlines.redlines.Redlines.test": {"tf": 3.4641016151377544}, "redlines.redlines.Redlines.redlines": {"tf": 4}, "redlines.redlines.Redlines.processor": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.options": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.opcodes": {"tf": 9.848857801796104}, "redlines.redlines.Redlines.changes": {"tf": 11.180339887498949}, "redlines.redlines.Redlines.get_changes": {"tf": 13}, "redlines.redlines.Redlines.stats": {"tf": 12.922847983320086}, "redlines.redlines.Redlines.output_markdown": {"tf": 16.881943016134134}, "redlines.redlines.Redlines.output_rich": {"tf": 3.4641016151377544}, "redlines.redlines.Redlines.compare": {"tf": 6.4031242374328485}, "redlines.redlines.RedlinesOptions": {"tf": 1.7320508075688772}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 2.23606797749979}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 2.6457513110645907}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 2.6457513110645907}}, "df": 65, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1}, "redlines.enums.MarkdownStyle.RED": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.449489742783178}}, "df": 3, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"redlines.cli": {"tf": 2}, "redlines.document.PlainTextFile": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.__init__": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.redlines": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.changes": {"tf": 2.449489742783178}, "redlines.redlines.Redlines.get_changes": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 9, "s": {"docs": {"redlines": {"tf": 2.8284271247461903}, "redlines.cli": {"tf": 3.1622776601683795}, "redlines.document.Document": {"tf": 1}, "redlines.document.Document.text": {"tf": 1.4142135623730951}, "redlines.document.PlainTextFile": {"tf": 1.7320508075688772}, "redlines.document.PlainTextFile.__init__": {"tf": 1}, "redlines.enums.MarkdownStyle": {"tf": 1}, "redlines.enums.OutputType": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 2}, "redlines.processor.WholeDocumentProcessor": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 2.6457513110645907}, "redlines.redlines.Redlines.opcodes": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.get_changes": {"tf": 2}, "redlines.redlines.Redlines.stats": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.449489742783178}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1}}, "df": 17}, "d": {"docs": {"redlines.cli": {"tf": 1}}, "df": 1}}}}}, "]": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}, "[": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1}}, "df": 2}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.processor.Redline": {"tf": 1}, "redlines.processor.DiffOperation": {"tf": 1}}, "df": 2}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines.redlines.Redlines.redlines": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}}, "df": 2}}}}}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.Redline.operation": {"tf": 1}, "redlines.processor.Redline.source_text": {"tf": 1}, "redlines.processor.Redline.test_text": {"tf": 1}, "redlines.redlines.Redlines.opcodes": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1.4142135623730951}}, "df": 6, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"redlines.processor.Stats.replacements": {"tf": 1}}, "df": 1, "s": {"docs": {"redlines.processor.Stats.total_changes": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.stats": {"tf": 1.4142135623730951}}, "df": 3}}}}}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"redlines": {"tf": 1}}, "df": 1}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 2}}}}}}}}}}, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines.processor.DiffOperation": {"tf": 1}}, "df": 1}}}}}}}, "g": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {"redlines": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines.cli": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {"redlines.document.Document.text": {"tf": 1}, "redlines.redlines.Redlines.redlines": {"tf": 1}, "redlines.redlines.Redlines.opcodes": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}}, "df": 4, "s": {"docs": {"redlines.document.PlainTextFile.text": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}, "redlines.redlines.Redlines.source": {"tf": 1}, "redlines.redlines.Redlines.test": {"tf": 1}, "redlines.redlines.Redlines.redlines": {"tf": 1}, "redlines.redlines.Redlines.opcodes": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.stats": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_rich": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 12}, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines.redlines.Redlines.redlines": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}}, "df": 2}}}}}}, "a": {"docs": {}, "df": 0, "d": {"docs": {"redlines.document.PlainTextFile": {"tf": 1}, "redlines.document.PlainTextFile.__init__": {"tf": 1}}, "df": 2, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 1}}}}}}, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines.document.PlainTextFile.text": {"tf": 1}}, "df": 1}}}}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"redlines": {"tf": 1}, "redlines.enums.OutputType.RICH": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 4}}}, "a": {"docs": {}, "df": 0, "w": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"redlines": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 2, "s": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.cli": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 3}, "d": {"docs": {"redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 1}}}}}}, "j": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"redlines.cli": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"redlines.document.Document.text": {"tf": 1}, "redlines.redlines.Redlines.redlines": {"tf": 1}}, "df": 2}}}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"redlines.processor.RedlinesProcessor": {"tf": 2}, "redlines.processor.WholeDocumentProcessor": {"tf": 1}}, "df": 2}}}}}}, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1, "s": {"docs": {"redlines.processor.Redline": {"tf": 1}, "redlines.processor.Stats": {"tf": 1}, "redlines.redlines.Redlines.redlines": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}}, "df": 4}, "d": {"docs": {"redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 1}}}}}, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"redlines.redlines.Redlines.changes": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"redlines.processor.Redline.source_text": {"tf": 1}, "redlines.processor.Redline.test_text": {"tf": 1}}, "df": 2}}}}, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "w": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"redlines.redlines.Redlines.changes": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 2}}, "df": 2}}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"redlines": {"tf": 2}, "redlines.cli": {"tf": 1.4142135623730951}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.opcodes": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.get_changes": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.6457513110645907}}, "df": 9}, "s": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"redlines": {"tf": 1}}, "df": 1}}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"redlines.document.PlainTextFile.__init__": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 5}}}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}}, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {"redlines.document.PlainTextFile.__init__": {"tf": 1.4142135623730951}}, "df": 1}}, "g": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.Chunk.chunk_location": {"tf": 1}}, "df": 1}}}, "y": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines": {"tf": 1}, "redlines.document.Document": {"tf": 1}}, "df": 2}}}}}, "i": {"docs": {}, "df": 0, "p": {"docs": {"redlines": {"tf": 1}}, "df": 1}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"redlines": {"tf": 1}, "redlines.document.Document": {"tf": 1}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.document.PlainTextFile.__init__": {"tf": 1}}, "df": 4, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.document.Document": {"tf": 1.4142135623730951}, "redlines.document.PlainTextFile": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.__init__": {"tf": 1.7320508075688772}}, "df": 3}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.processor.Redline": {"tf": 1}, "redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}}, "df": 4}}}}}}}, "d": {"docs": {}, "df": 0, "f": {"docs": {"redlines.processor.Chunk.chunk_location": {"tf": 1}}, "df": 1}}}, "a": {"docs": {"redlines": {"tf": 1.7320508075688772}, "redlines.cli": {"tf": 2.8284271247461903}, "redlines.document.Document": {"tf": 1.4142135623730951}, "redlines.processor.RedlinesProcessor": {"tf": 2.449489742783178}, "redlines.processor.WholeDocumentProcessor": {"tf": 1.4142135623730951}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1.4142135623730951}, "redlines.processor.Redline": {"tf": 1.7320508075688772}, "redlines.processor.Stats": {"tf": 1}, "redlines.processor.DiffOperation": {"tf": 1}, "redlines.processor.Chunk": {"tf": 1}, "redlines.processor.Chunk.chunk_location": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.source": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.changes": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.compare": {"tf": 1.4142135623730951}}, "df": 16, "r": {"docs": {}, "df": 0, "e": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1}, "redlines.redlines.Redlines.redlines": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_markdown": {"tf": 2}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 6}, "g": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}}, "n": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.document.Document": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 1.4142135623730951}, "redlines.processor.Chunk.chunk_location": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.redlines": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 7, "d": {"docs": {"redlines": {"tf": 2}, "redlines.cli": {"tf": 3.605551275463989}, "redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1.4142135623730951}, "redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.processor.Redline": {"tf": 1.4142135623730951}, "redlines.processor.Redline.source_text": {"tf": 1}, "redlines.processor.Redline.test_text": {"tf": 1}, "redlines.processor.Stats": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.redlines": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.stats": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.449489742783178}, "redlines.redlines.Redlines.compare": {"tf": 1.7320508075688772}}, "df": 14}, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 1}}}}}, "y": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1, "s": {"docs": {"redlines": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.cli": {"tf": 1}, "redlines.document.Document": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.processor.WholeDocumentProcessor": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}, "redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.source": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.7320508075688772}}, "df": 11, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"redlines.document.PlainTextFile": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 2}}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {"redlines.processor.Stats": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 3, "o": {"docs": {}, "df": 0, "w": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1, "s": {"docs": {"redlines.cli": {"tf": 1}}, "df": 1}}}}, "s": {"docs": {}, "df": 0, "o": {"docs": {"redlines.cli": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 3}}, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.redlines": {"tf": 1}}, "df": 1}}}}, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.cli": {"tf": 1}}, "df": 1}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"redlines.document.Document": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 1}}, "df": 2}}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"redlines.processor.Stats": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 1}}, "df": 2}}}}, "t": {"docs": {"redlines.document.Document": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 2}, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1}}, "df": 1}, "a": {"docs": {}, "df": 0, "l": {"docs": {"redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 2}}}}}}}}}, "c": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.Redline": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}}, "df": 2, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines.processor.Redline": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}}, "df": 2}}}}}}, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}}}}}, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"redlines.redlines.Redlines.redlines": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}}, "df": 2}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}, "t": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 1, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {"redlines": {"tf": 1.7320508075688772}, "redlines.cli": {"tf": 3.1622776601683795}, "redlines.document.Document": {"tf": 1.7320508075688772}, "redlines.document.Document.text": {"tf": 1.4142135623730951}, "redlines.document.PlainTextFile": {"tf": 1.4142135623730951}, "redlines.document.PlainTextFile.__init__": {"tf": 1.4142135623730951}, "redlines.document.PlainTextFile.text": {"tf": 1}, "redlines.processor.Redline": {"tf": 1.4142135623730951}, "redlines.processor.Redline.source_text": {"tf": 1}, "redlines.processor.Redline.test_text": {"tf": 1}, "redlines.processor.Stats": {"tf": 1}, "redlines.processor.DiffOperation.test_chunk": {"tf": 1}, "redlines.processor.Chunk": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 2}, "redlines.redlines.Redlines.source": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.test": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.changes": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.output_rich": {"tf": 1.4142135623730951}}, "df": 18, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"redlines.cli": {"tf": 1.4142135623730951}}, "df": 1}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.cli": {"tf": 2}, "redlines.document.PlainTextFile": {"tf": 1.4142135623730951}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1.4142135623730951}, "redlines.processor.Redline": {"tf": 1}, "redlines.processor.Redline.test_text": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}, "redlines.processor.Stats": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 2.449489742783178}, "redlines.redlines.Redlines.redlines": {"tf": 1}, "redlines.redlines.Redlines.opcodes": {"tf": 2.449489742783178}, "redlines.redlines.Redlines.changes": {"tf": 2}, "redlines.redlines.Redlines.get_changes": {"tf": 2.23606797749979}, "redlines.redlines.Redlines.stats": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.compare": {"tf": 2}}, "df": 16, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines": {"tf": 1}}, "df": 1}}, "s": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"redlines.document.PlainTextFile": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 2}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"redlines.document.PlainTextFile": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 2}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"redlines.cli": {"tf": 2}, "redlines.enums.OutputType.RICH": {"tf": 1}}, "df": 2}}}}}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {"redlines": {"tf": 4.898979485566356}, "redlines.cli": {"tf": 5.0990195135927845}, "redlines.document.Document": {"tf": 1.4142135623730951}, "redlines.document.Document.text": {"tf": 1.7320508075688772}, "redlines.document.PlainTextFile": {"tf": 1.4142135623730951}, "redlines.document.PlainTextFile.__init__": {"tf": 1}, "redlines.document.PlainTextFile.text": {"tf": 1.7320508075688772}, "redlines.enums.MarkdownStyle": {"tf": 1}, "redlines.enums.OutputType": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.processor.WholeDocumentProcessor": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 2}, "redlines.processor.Redline": {"tf": 1}, "redlines.processor.Redline.operation": {"tf": 1}, "redlines.processor.Redline.source_text": {"tf": 1.4142135623730951}, "redlines.processor.Redline.test_text": {"tf": 1.4142135623730951}, "redlines.processor.Stats": {"tf": 1}, "redlines.processor.DiffOperation.test_chunk": {"tf": 1}, "redlines.processor.DiffOperation.opcodes": {"tf": 1.7320508075688772}, "redlines.processor.Chunk": {"tf": 1}, "redlines.processor.Chunk.text": {"tf": 1.4142135623730951}, "redlines.processor.Chunk.chunk_location": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.__init__": {"tf": 3.3166247903554}, "redlines.redlines.Redlines.source": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.test": {"tf": 2}, "redlines.redlines.Redlines.redlines": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.opcodes": {"tf": 2}, "redlines.redlines.Redlines.changes": {"tf": 2.449489742783178}, "redlines.redlines.Redlines.get_changes": {"tf": 2.23606797749979}, "redlines.redlines.Redlines.stats": {"tf": 2.23606797749979}, "redlines.redlines.Redlines.output_markdown": {"tf": 6}, "redlines.redlines.Redlines.output_rich": {"tf": 2}, "redlines.redlines.Redlines.compare": {"tf": 2.23606797749979}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 36, "m": {"docs": {"redlines.processor.RedlinesProcessor": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "r": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {"redlines": {"tf": 1}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 4, "s": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1}}, "df": 2}}}}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {"redlines": {"tf": 2.23606797749979}, "redlines.cli": {"tf": 1.4142135623730951}, "redlines.document.Document.text": {"tf": 1.4142135623730951}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.document.PlainTextFile.__init__": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.processor.Redline": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.redlines": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.6457513110645907}}, "df": 11}}, "a": {"docs": {}, "df": 0, "t": {"docs": {"redlines.cli": {"tf": 1.7320508075688772}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.document.PlainTextFile.__init__": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 1.4142135623730951}, "redlines.processor.WholeDocumentProcessor": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}, "redlines.processor.DiffOperation.test_chunk": {"tf": 1}, "redlines.processor.DiffOperation.opcodes": {"tf": 1}, "redlines.processor.Chunk": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 10}, "n": {"docs": {"redlines.cli": {"tf": 1}, "redlines.document.Document": {"tf": 1}}, "df": 2}}}, "w": {"docs": {}, "df": 0, "o": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.cli": {"tf": 2}, "redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.processor.WholeDocumentProcessor": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 6}}, "o": {"docs": {"redlines": {"tf": 2.6457513110645907}, "redlines.cli": {"tf": 2.8284271247461903}, "redlines.document.Document": {"tf": 1}, "redlines.document.Document.text": {"tf": 2}, "redlines.document.PlainTextFile.__init__": {"tf": 1}, "redlines.document.PlainTextFile.text": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1.4142135623730951}, "redlines.processor.Redline": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 2}, "redlines.redlines.Redlines.source": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.test": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.opcodes": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.changes": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.449489742783178}, "redlines.redlines.Redlines.compare": {"tf": 1.4142135623730951}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1.7320508075688772}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1.7320508075688772}}, "df": 19, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}, "redlines.processor.Chunk.text": {"tf": 1}}, "df": 3}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"redlines.processor.Stats.total_changes": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 1.4142135623730951}}, "df": 2}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 3}}}, "y": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 1}, "u": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}, "x": {"docs": {}, "df": 0, "t": {"docs": {"redlines.document.PlainTextFile": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.__init__": {"tf": 1.4142135623730951}}, "df": 2}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.Redline.operation": {"tf": 1}, "redlines.processor.Stats": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1.4142135623730951}}, "df": 3, "s": {"docs": {"redlines.enums.OutputType": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.RedlinesProcessor": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "n": {"docs": {"redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}}, "df": 1}}}}, "s": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1}, "redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}}, "df": 3, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {"redlines.cli": {"tf": 1.4142135623730951}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.cli": {"tf": 1}}, "df": 2}}}, "s": {"docs": {"redlines.cli": {"tf": 1.4142135623730951}}, "df": 1}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {"redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 1, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.processor.Chunk.chunk_location": {"tf": 1}, "redlines.redlines.Redlines.opcodes": {"tf": 2}, "redlines.redlines.Redlines.compare": {"tf": 1.4142135623730951}}, "df": 4, "s": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 2.449489742783178}, "redlines.document.Document": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.4142135623730951}}, "df": 4, "/": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1}}, "df": 2}}}}}}}}, "k": {"docs": {}, "df": 0, "e": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1}}, "df": 2, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"redlines": {"tf": 1}, "redlines.enums.MarkdownStyle.STREAMLIT": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.6457513110645907}}, "df": 3}}}}}}, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines.processor.Redline": {"tf": 1}}, "df": 1}}}}}}}}, "y": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.document.PlainTextFile": {"tf": 1.4142135623730951}, "redlines.enums.MarkdownStyle.GHFM": {"tf": 1}, "redlines.enums.MarkdownStyle.BBCODE": {"tf": 1}, "redlines.enums.MarkdownStyle.STREAMLIT": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_markdown": {"tf": 3.1622776601683795}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 10, "s": {"docs": {"redlines.enums.MarkdownStyle": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 2}, "d": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.23606797749979}}, "df": 2}}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}}, "df": 2}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.Stats": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 1}}, "df": 2}}}}}}, "s": {"docs": {"redlines.redlines.Redlines.stats": {"tf": 2.6457513110645907}}, "df": 1}}, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}}, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1}, "redlines.redlines.Redlines.opcodes": {"tf": 1}}, "df": 3}}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.cli": {"tf": 1.7320508075688772}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.WholeDocumentProcessor": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}, "redlines.processor.Redline": {"tf": 1}}, "df": 3}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1}}, "df": 2}}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"redlines": {"tf": 1}, "redlines.redlines.Redlines.opcodes": {"tf": 1}}, "df": 2}}}}}}}}}}}}}, "e": {"docs": {"redlines.cli": {"tf": 1}, "redlines.document.Document": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.processor.DiffOperation.opcodes": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1}}, "df": 6}, "t": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 3, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"redlines": {"tf": 2}, "redlines.document.PlainTextFile": {"tf": 2}, "redlines.redlines.Redlines.__init__": {"tf": 2}}, "df": 3}}, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 1}, "d": {"docs": {"redlines.redlines.Redlines.compare": {"tf": 1.4142135623730951}}, "df": 1}}, "c": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}, "y": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}}}}, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"redlines": {"tf": 1}}, "df": 1}}, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines.document.Document": {"tf": 1}, "redlines.enums.MarkdownStyle": {"tf": 1}, "redlines.enums.OutputType": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 5}}}}}}}, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"redlines.processor.Stats": {"tf": 1}}, "df": 1}}}}}}, "y": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {"redlines.cli": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {"redlines.document.PlainTextFile": {"tf": 1}, "redlines.document.PlainTextFile.__init__": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 3, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"redlines.cli": {"tf": 2}, "redlines.document.PlainTextFile": {"tf": 1.4142135623730951}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1.4142135623730951}, "redlines.processor.Redline": {"tf": 1}, "redlines.processor.Redline.source_text": {"tf": 1}, "redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.Stats": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 2.23606797749979}, "redlines.redlines.Redlines.source": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.test": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.redlines": {"tf": 1}, "redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.stats": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 15}}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.Chunk": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 2}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.redlines": {"tf": 1}}, "df": 1}}}, "]": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "f": {"docs": {"redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.processor.Redline": {"tf": 1}, "redlines.processor.DiffOperation": {"tf": 1}}, "df": 3, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.cli": {"tf": 2}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}}, "df": 5}}}}}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.processor.WholeDocumentProcessor.process": {"tf": 1}}, "df": 1}}}}}}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {"redlines.processor.DiffOperation.opcodes": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"redlines": {"tf": 1}, "redlines.processor.Redline": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}}, "df": 3, "l": {"docs": {}, "df": 0, "y": {"docs": {"redlines.cli": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"redlines.cli": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 2}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "g": {"docs": {"redlines": {"tf": 2.449489742783178}, "redlines.cli": {"tf": 2}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.get_changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.stats": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.8284271247461903}}, "df": 9}, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"redlines.document.PlainTextFile.text": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1.4142135623730951}, "redlines.processor.Redline.source_text": {"tf": 1}, "redlines.processor.Redline.test_text": {"tf": 1}, "redlines.processor.Chunk": {"tf": 1}, "redlines.processor.Chunk.chunk_location": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 7, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines": {"tf": 1}, "redlines.processor.DiffOperation.opcodes": {"tf": 1}}, "df": 2}}}}}, "s": {"docs": {"redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.processor.WholeDocumentProcessor": {"tf": 1.4142135623730951}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1.4142135623730951}}, "df": 3}}}}}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "n": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, ":": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"redlines": {"tf": 1}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 3}}}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.cli": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 2}}}}}, "b": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.WholeDocumentProcessor.process": {"tf": 1}, "redlines.processor.DiffOperation.opcodes": {"tf": 1}}, "df": 2}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines.processor.Chunk.chunk_location": {"tf": 1}, "redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}}, "df": 2}}}}}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines.cli": {"tf": 1}}, "df": 1}}}}}}, "l": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.processor.Stats.deletions": {"tf": 1}}, "df": 1, "s": {"docs": {"redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1}, "redlines.processor.Stats.total_changes": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.stats": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 6}}}}, "e": {"docs": {"redlines.processor.Redline.operation": {"tf": 1}, "redlines.processor.Redline.source_text": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1.4142135623730951}}, "df": 4, "d": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 2}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_rich": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.compare": {"tf": 1.7320508075688772}}, "df": 3, "s": {"docs": {"redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 1}}}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.RedlinesProcessor": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 1, "s": {"docs": {"redlines.redlines.Redlines.compare": {"tf": 1}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 3}}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"redlines.document.Document": {"tf": 1}}, "df": 1}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 1}}}}}}, "b": {"docs": {}, "df": 0, "e": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.document.Document.text": {"tf": 1}, "redlines.processor.Chunk": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.source": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.test": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 7, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.cli": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}, "redlines.processor.Redline": {"tf": 1}, "redlines.processor.Stats": {"tf": 1}, "redlines.redlines.Redlines.redlines": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 1}}, "df": 8}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines.processor.DiffOperation.test_chunk": {"tf": 1}, "redlines.processor.Chunk": {"tf": 1}}, "df": 2}}}, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "n": {"docs": {"redlines": {"tf": 2.449489742783178}, "redlines.cli": {"tf": 2}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.get_changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.stats": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.8284271247461903}}, "df": 9}}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"redlines.document.Document": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 1}}, "df": 2}, "i": {"docs": {}, "df": 0, "c": {"docs": {"redlines.document.Document": {"tf": 1}}, "df": 1}, "s": {"docs": {"redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.source": {"tf": 1.4142135623730951}}, "df": 2}}}}, "y": {"docs": {"redlines.document.Document.text": {"tf": 1.4142135623730951}, "redlines.enums.MarkdownStyle": {"tf": 1}, "redlines.enums.OutputType": {"tf": 1}, "redlines.processor.Stats": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.compare": {"tf": 1.4142135623730951}}, "df": 8}, "b": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"redlines.enums.MarkdownStyle.BBCODE": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 2}}}}}}, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.Redline": {"tf": 1}, "redlines.processor.Redline.operation": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 4, "s": {"docs": {"redlines": {"tf": 1.7320508075688772}, "redlines.cli": {"tf": 1.7320508075688772}, "redlines.enums.MarkdownStyle.RED": {"tf": 1}, "redlines.processor.Stats": {"tf": 1.4142135623730951}, "redlines.processor.Stats.total_changes": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.redlines": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.changes": {"tf": 2}, "redlines.redlines.Redlines.get_changes": {"tf": 2.8284271247461903}, "redlines.redlines.Redlines.stats": {"tf": 1.7320508075688772}}, "df": 10}, "d": {"docs": {"redlines.processor.Redline": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}}, "df": 2}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1}}, "df": 2}}}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "k": {"docs": {"redlines.processor.WholeDocumentProcessor": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}, "redlines.processor.DiffOperation.test_chunk": {"tf": 1}, "redlines.processor.Chunk": {"tf": 1}, "redlines.processor.Chunk.text": {"tf": 1}, "redlines.processor.Chunk.chunk_location": {"tf": 1}}, "df": 6}}}}, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1}}, "df": 2}}, "r": {"docs": {}, "df": 0, "e": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 2}, "redlines.document.Document.text": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.__init__": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.compare": {"tf": 1.4142135623730951}}, "df": 7, "s": {"docs": {"redlines.cli": {"tf": 1.7320508075688772}, "redlines.processor.WholeDocumentProcessor": {"tf": 1.4142135623730951}}, "df": 2}, "d": {"docs": {"redlines.document.Document.text": {"tf": 1}, "redlines.processor.DiffOperation.test_chunk": {"tf": 1}, "redlines.processor.Chunk": {"tf": 1}, "redlines.redlines.Redlines.test": {"tf": 1.4142135623730951}}, "df": 4}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.redlines.Redlines.__init__": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.source": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 3}}}}}}}, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.document.Document": {"tf": 1}}, "df": 2}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"redlines.cli": {"tf": 2.449489742783178}}, "df": 1, "s": {"docs": {"redlines.cli": {"tf": 1}}, "df": 1}}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"redlines.enums.MarkdownStyle.RED": {"tf": 1}}, "df": 1, ":": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines": {"tf": 1}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 3}}}, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"redlines": {"tf": 1}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 3}}}}}}, "s": {"docs": {"redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1}, "redlines.enums.MarkdownStyle.NONE": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 3, "/": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.output_rich": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}, "]": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "]": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "]": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}}}}}}, "b": {"docs": {}, "df": 0, "]": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}}}}}, "a": {"docs": {}, "df": 0, "b": {"docs": {"redlines": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 2}}}, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"redlines": {"tf": 1}}, "df": 1}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"redlines.cli": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 2}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": null}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.output_rich": {"tf": 1.4142135623730951}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.Stats": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 1}}, "df": 2}}}}, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {"redlines": {"tf": 1}, "redlines.document.Document": {"tf": 1}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.document.PlainTextFile.__init__": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 6}, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.Chunk": {"tf": 1}}, "df": 1}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"redlines": {"tf": 1}, "redlines.document.Document": {"tf": 1.7320508075688772}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.document.PlainTextFile.__init__": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 2}, "redlines.processor.Redline": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.7320508075688772}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 10, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1.7320508075688772}}, "df": 1}}}}}, "i": {"docs": {"redlines": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"redlines": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 3, "d": {"docs": {"redlines.document.PlainTextFile.text": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 2}}}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.7320508075688772}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 4}}}}, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 1}}}}}}}}, "s": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 2.23606797749979}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1.4142135623730951}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1.4142135623730951}}, "df": 3}}}, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.cli": {"tf": 1}, "redlines.document.Document": {"tf": 1.4142135623730951}, "redlines.processor.Redline": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.test": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.changes": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 1}, "redlines.redlines.Redlines.output_rich": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 10}}}, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 4}}, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {"redlines.document.PlainTextFile.text": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 4}}, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.Chunk": {"tf": 1}}, "df": 1, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"redlines.processor.RedlinesProcessor": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 3, "s": {"docs": {"redlines": {"tf": 1}}, "df": 1}}, "k": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "s": {"docs": {"redlines": {"tf": 2}, "redlines.cli": {"tf": 1.4142135623730951}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.opcodes": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.get_changes": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.23606797749979}}, "df": 9}}}, "y": {"docs": {"redlines": {"tf": 1}}, "df": 1}, "n": {"docs": {}, "df": 0, "t": {"docs": {"redlines.cli": {"tf": 1.7320508075688772}, "redlines.processor.RedlinesProcessor": {"tf": 1}}, "df": 2}}, "s": {"docs": {"redlines.document.PlainTextFile.text": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 2}}, "e": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, ":": {"7": {"0": {"0": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.document.PlainTextFile": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.__init__": {"tf": 1.4142135623730951}}, "df": 3}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}}}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}, "e": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1}}, "df": 2}}}}}}}}, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1.4142135623730951}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.document.PlainTextFile.__init__": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 9, "s": {"docs": {"redlines": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 2}, "d": {"docs": {"redlines": {"tf": 1}, "redlines.document.Document": {"tf": 1}, "redlines.document.Document.text": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.source": {"tf": 1.4142135623730951}}, "df": 5}, "r": {"docs": {"redlines.processor.Redline": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}}, "df": 2, "s": {"docs": {"redlines": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 2}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines": {"tf": 2}, "redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 3}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"redlines.cli": {"tf": 1}}, "df": 1}}}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "k": {"docs": {"redlines.document.Document": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 2, "s": {"docs": {"redlines": {"tf": 1}}, "df": 1}}}, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1}}, "df": 2, "e": {"docs": {}, "df": 0, "r": {"docs": {"redlines.cli": {"tf": 1}}, "df": 1}}}}, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.processor.Chunk.chunk_location": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1}}, "df": 2}}}}}, "z": {"docs": {}, "df": 0, "y": {"docs": {"redlines": {"tf": 2.449489742783178}, "redlines.cli": {"tf": 2}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.get_changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.stats": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.8284271247461903}}, "df": 9}}, "y": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"redlines.cli": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"redlines": {"tf": 1.7320508075688772}, "redlines.cli": {"tf": 1.4142135623730951}, "redlines.document.Document.text": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 4}}}}}, "k": {"docs": {}, "df": 0, "e": {"docs": {"redlines": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 2}}, "n": {"docs": {}, "df": 0, "e": {"docs": {"redlines.cli": {"tf": 2}}, "df": 1, "s": {"docs": {"redlines.cli": {"tf": 1}}, "df": 1}}}, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"redlines.cli": {"tf": 1}}, "df": 1}}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"redlines.processor.WholeDocumentProcessor.process": {"tf": 1}, "redlines.redlines.Redlines.redlines": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.get_changes": {"tf": 1}}, "df": 5}}}, "t": {"docs": {"redlines": {"tf": 2}, "redlines.document.PlainTextFile": {"tf": 2}, "redlines.redlines.Redlines.__init__": {"tf": 2}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 4}}, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "t": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 3}}}}}}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1}, "redlines.document.Document.text": {"tf": 1}}, "df": 3}}}}, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"redlines.cli": {"tf": 1}}, "df": 1}}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.cli": {"tf": 1.7320508075688772}, "redlines.processor.DiffOperation.opcodes": {"tf": 1}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1}}, "df": 4}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"redlines": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "n": {"docs": {"redlines": {"tf": 1.7320508075688772}, "redlines.cli": {"tf": 1.4142135623730951}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.enums.MarkdownStyle": {"tf": 1}, "redlines.enums.MarkdownStyle.GHFM": {"tf": 1}, "redlines.enums.OutputType.MARKDOWN": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.output_markdown": {"tf": 4}, "redlines.redlines.Redlines.compare": {"tf": 1.4142135623730951}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1.4142135623730951}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 12}}}}}}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"redlines": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}, "y": {"docs": {"redlines.cli": {"tf": 1.4142135623730951}, "redlines.processor.Chunk": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 3}, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines.redlines.Redlines.get_changes": {"tf": 1}}, "df": 1}}}}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "f": {"docs": {"redlines": {"tf": 1.7320508075688772}, "redlines.cli": {"tf": 1.7320508075688772}, "redlines.document.PlainTextFile.text": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.processor.WholeDocumentProcessor.process": {"tf": 1}, "redlines.processor.Redline": {"tf": 1}, "redlines.processor.Redline.operation": {"tf": 1}, "redlines.processor.Stats": {"tf": 1}, "redlines.processor.Stats.total_changes": {"tf": 1}, "redlines.processor.Stats.deletions": {"tf": 1}, "redlines.processor.Stats.insertions": {"tf": 1}, "redlines.processor.Stats.replacements": {"tf": 1}, "redlines.processor.DiffOperation": {"tf": 1}, "redlines.processor.DiffOperation.test_chunk": {"tf": 1}, "redlines.processor.Chunk": {"tf": 1}, "redlines.processor.Chunk.text": {"tf": 1}, "redlines.processor.Chunk.chunk_location": {"tf": 1}, "redlines.redlines.Redlines.redlines": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.get_changes": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.7320508075688772}}, "df": 22}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"redlines": {"tf": 1.7320508075688772}, "redlines.cli": {"tf": 1}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.enums.OutputType": {"tf": 1}, "redlines.enums.OutputType.RICH": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 2}, "redlines.redlines.Redlines.changes": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 2}, "redlines.redlines.Redlines.compare": {"tf": 2}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1.4142135623730951}}, "df": 10, "s": {"docs": {"redlines.cli": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "r": {"docs": {"redlines": {"tf": 1}, "redlines.processor.Redline.operation": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.8284271247461903}}, "df": 5, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1}}, "df": 2}}}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"redlines": {"tf": 2}, "redlines.cli": {"tf": 1.4142135623730951}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.opcodes": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.get_changes": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.6457513110645907}}, "df": 9}}}, "b": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"redlines": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 4, "s": {"docs": {"redlines.redlines.Redlines.redlines": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.get_changes": {"tf": 1}}, "df": 3}}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"redlines.document.Document.text": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"redlines": {"tf": 1}, "redlines.document.Document": {"tf": 1}}, "df": 2, "s": {"docs": {"redlines": {"tf": 1}}, "df": 1}}}}}, "n": {"docs": {"redlines": {"tf": 1}}, "df": 1, "l": {"docs": {}, "df": 0, "y": {"docs": {"redlines.enums.MarkdownStyle.RED": {"tf": 1}, "redlines.redlines.Redlines.redlines": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.get_changes": {"tf": 1}}, "df": 4}}}, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1.7320508075688772}}, "df": 1, "s": {"docs": {"redlines.cli": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.__init__": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1.4142135623730951}}, "df": 4}, "a": {"docs": {}, "df": 0, "l": {"docs": {"redlines.processor.Chunk.chunk_location": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 3, "l": {"docs": {}, "df": 0, "y": {"docs": {"redlines.redlines.Redlines.get_changes": {"tf": 1}}, "df": 1}}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.processor.Stats": {"tf": 1}, "redlines.processor.DiffOperation": {"tf": 1}, "redlines.processor.DiffOperation.opcodes": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 2.449489742783178}}, "df": 5, "s": {"docs": {"redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.processor.Redline.source_text": {"tf": 1}, "redlines.processor.Redline.test_text": {"tf": 1}, "redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}, "redlines.processor.Stats.deletions": {"tf": 1}, "redlines.processor.Stats.insertions": {"tf": 1}, "redlines.processor.Stats.replacements": {"tf": 1}, "redlines.processor.DiffOperation": {"tf": 1}, "redlines.redlines.Redlines.redlines": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}}, "df": 11}}}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.DiffOperation.opcodes": {"tf": 1}, "redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}}, "df": 2}}}}}}, "w": {"docs": {}, "df": 0, "n": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {"redlines": {"tf": 2}, "redlines.cli": {"tf": 2}, "redlines.document.Document.text": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.processor.DiffOperation.test_chunk": {"tf": 1}, "redlines.processor.Chunk": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.redlines": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.6457513110645907}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 11, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1, "s": {"docs": {"redlines": {"tf": 1.4142135623730951}}, "df": 1}}}}}, "n": {"docs": {"redlines": {"tf": 2}, "redlines.cli": {"tf": 2.449489742783178}, "redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}, "redlines.processor.Chunk": {"tf": 1}, "redlines.processor.Chunk.chunk_location": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.changes": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 3.4641016151377544}, "redlines.redlines.Redlines.output_rich": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.compare": {"tf": 1.4142135623730951}}, "df": 11, "s": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"redlines": {"tf": 1.7320508075688772}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"redlines.processor.Redline.operation": {"tf": 1}, "redlines.processor.Redline.test_text": {"tf": 1}, "redlines.processor.Redline.source_position": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1.4142135623730951}}, "df": 4, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.processor.Stats.insertions": {"tf": 1}}, "df": 1, "s": {"docs": {"redlines.processor.Stats.total_changes": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.stats": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}}, "df": 5}}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}}, "df": 2}}}}}}, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines": {"tf": 1}, "redlines.processor.Redline": {"tf": 1.4142135623730951}, "redlines.processor.DiffOperation.opcodes": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1}}, "df": 5}}}}}}}}}, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"redlines": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 2}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"redlines.cli": {"tf": 1.7320508075688772}, "redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.processor.Redline": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}}, "df": 4}}}}, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"redlines.document.Document": {"tf": 1}}, "df": 1}}}}}}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"redlines.processor.DiffOperation": {"tf": 1}}, "df": 1}}}}}, "o": {"docs": {"redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}}, "df": 1}}, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines.processor.Stats": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 2}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.DiffOperation": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.changes": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 7}}}, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"redlines.document.Document.text": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.document.Document": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "f": {"docs": {"redlines.cli": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.23606797749979}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 6}, "t": {"docs": {"redlines.processor.WholeDocumentProcessor": {"tf": 1}, "redlines.processor.Chunk": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 3}}, "f": {"docs": {"redlines.redlines.Redlines.changes": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 2}}, "df": 2, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 1}}, "df": 2}}}}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1, "d": {"docs": {"redlines": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {"redlines": {"tf": 1}, "redlines.cli": {"tf": 2.23606797749979}, "redlines.document.Document": {"tf": 1}, "redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1}, "redlines.enums.MarkdownStyle.RED": {"tf": 1}, "redlines.enums.OutputType.RICH": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 1.4142135623730951}, "redlines.processor.Redline": {"tf": 1}, "redlines.processor.Redline.source_text": {"tf": 1}, "redlines.processor.Redline.test_text": {"tf": 1}, "redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}, "redlines.processor.DiffOperation": {"tf": 1}, "redlines.processor.DiffOperation.opcodes": {"tf": 1}, "redlines.processor.Chunk.chunk_location": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.source": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.redlines": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_rich": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.compare": {"tf": 1}, "redlines.redlines.RedlinesOptions.markdown_style": {"tf": 1.4142135623730951}, "redlines.redlines.RedlinesOptions.ins_class": {"tf": 1}, "redlines.redlines.RedlinesOptions.del_class": {"tf": 1}}, "df": 25, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.enums.OutputType.MARKDOWN": {"tf": 1}, "redlines.enums.OutputType.RICH": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.compare": {"tf": 1.7320508075688772}}, "df": 6, "s": {"docs": {"redlines.document.Document": {"tf": 1.4142135623730951}}, "df": 1}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines.redlines.Redlines.__init__": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 3}}}}}}}}, "x": {"docs": {"redlines": {"tf": 2.449489742783178}, "redlines.cli": {"tf": 2}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.get_changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.stats": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.8284271247461903}}, "df": 9}, "n": {"docs": {}, "df": 0, "t": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.document.PlainTextFile": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.__init__": {"tf": 1.4142135623730951}}, "df": 3}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"redlines": {"tf": 1}}, "df": 1}}, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.document.Document": {"tf": 1}, "redlines.document.PlainTextFile.__init__": {"tf": 1.4142135623730951}, "redlines.document.PlainTextFile.text": {"tf": 1}}, "df": 3, "s": {"docs": {"redlines": {"tf": 1}, "redlines.document.Document": {"tf": 1.4142135623730951}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.document.PlainTextFile.__init__": {"tf": 1}}, "df": 4}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"redlines.redlines.Redlines.get_changes": {"tf": 1.4142135623730951}}, "df": 1, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines.redlines.Redlines.get_changes": {"tf": 1}}, "df": 1}}}}}}, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"redlines": {"tf": 1}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.processor.Redline.source_text": {"tf": 1}, "redlines.processor.Redline.test_text": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.changes": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 10}}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"redlines.processor.Redline": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}}, "df": 2}}}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines.enums.MarkdownStyle.GHFM": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 2}}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"redlines.redlines.Redlines.redlines": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "h": {"docs": {"redlines.cli": {"tf": 1}}, "df": 1, "t": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "l": {"docs": {"redlines": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 2}}, "df": 2}}}, "a": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"redlines": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 2}}, "s": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "p": {"docs": {"redlines.cli": {"tf": 1.4142135623730951}}, "df": 1}}, "r": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"redlines.redlines.Redlines.__init__": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "w": {"docs": {"redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.processor.Chunk.chunk_location": {"tf": 1}}, "df": 3, "s": {"docs": {"redlines.cli": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {"redlines.cli": {"tf": 1}}, "df": 1}}, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines.redlines.Redlines.redlines": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}}, "df": 2}}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}}}}, "n": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"redlines": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 2, "s": {"docs": {"redlines": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.7320508075688772}}, "df": 2}}}}}}}}}}, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"redlines": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.WholeDocumentProcessor": {"tf": 1}}, "df": 1}}}}, "d": {"docs": {"redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}}, "df": 2}, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "c": {"docs": {"redlines": {"tf": 1}}, "df": 1}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"redlines.processor.DiffOperation": {"tf": 1}, "redlines.redlines.Redlines.redlines": {"tf": 1}, "redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}}, "df": 4}}}}}, "g": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"redlines": {"tf": 1}}, "df": 1}, "s": {"docs": {"redlines": {"tf": 1}}, "df": 1}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "b": {"docs": {"redlines.enums.MarkdownStyle.GHFM": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 2}}}}}, "t": {"docs": {"redlines": {"tf": 2}, "redlines.document.PlainTextFile": {"tf": 2}, "redlines.redlines.Redlines.__init__": {"tf": 2}, "redlines.redlines.Redlines.opcodes": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 6}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"redlines.enums.MarkdownStyle.RED_GREEN": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 2, "]": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}, "[": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "s": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}}}}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"redlines.processor.RedlinesProcessor": {"tf": 1}}, "df": 1}}}}}}}, "t": {"docs": {"redlines.redlines.Redlines.source": {"tf": 1}, "redlines.redlines.Redlines.test": {"tf": 1}, "redlines.redlines.Redlines.opcodes": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 3}, "redlines.redlines.Redlines.stats": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 6}}, "h": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "m": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1.7320508075688772}}, "df": 1}}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"redlines": {"tf": 2.449489742783178}, "redlines.cli": {"tf": 2}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.7320508075688772}, "redlines.redlines.Redlines.opcodes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.get_changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.stats": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.8284271247461903}}, "df": 9, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"redlines": {"tf": 1}}, "df": 1}}}}}}}}, "o": {"docs": {}, "df": 0, "t": {"docs": {"redlines": {"tf": 2}, "redlines.cli": {"tf": 2.8284271247461903}, "redlines.document.PlainTextFile": {"tf": 2.449489742783178}, "redlines.redlines.Redlines.__init__": {"tf": 3.1622776601683795}, "redlines.redlines.Redlines.changes": {"tf": 2.449489742783178}, "redlines.redlines.Redlines.get_changes": {"tf": 3.1622776601683795}, "redlines.redlines.Redlines.stats": {"tf": 3.4641016151377544}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.8284271247461903}}, "df": 8}}}}, "j": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {"redlines": {"tf": 2}, "redlines.cli": {"tf": 1.4142135623730951}, "redlines.document.PlainTextFile": {"tf": 1}, "redlines.redlines.Redlines.__init__": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.opcodes": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.get_changes": {"tf": 1}, "redlines.redlines.Redlines.stats": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.23606797749979}}, "df": 9}}}, "p": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"redlines": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 2}}}}}}}, "y": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {"redlines.cli": {"tf": 2}, "redlines.document.Document": {"tf": 1}, "redlines.processor.RedlinesProcessor": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 3}}, "df": 4, "r": {"docs": {"redlines": {"tf": 1.4142135623730951}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 2}}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {"redlines.enums.MarkdownStyle.NONE": {"tf": 1}, "redlines.redlines.Redlines.changes": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 3, "t": {"docs": {"redlines.cli": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 2, "e": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "k": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1, "s": {"docs": {"redlines": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 2}}}}}}}, "n": {"docs": {}, "df": 0, "e": {"docs": {"redlines.processor.Redline.source_position": {"tf": 1}, "redlines.processor.Redline.test_position": {"tf": 1}, "redlines.redlines.Redlines.get_changes": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 2.23606797749979}, "redlines.redlines.Redlines.compare": {"tf": 1}}, "df": 5}}, "w": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"redlines.cli": {"tf": 1}, "redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 2}}}, "e": {"docs": {}, "df": 0, "w": {"docs": {"redlines.cli": {"tf": 1}}, "df": 1}, "e": {"docs": {}, "df": 0, "d": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"redlines.processor.Stats.total_changes": {"tf": 1}, "redlines.processor.Stats.deletions": {"tf": 1}, "redlines.processor.Stats.insertions": {"tf": 1}, "redlines.processor.Stats.replacements": {"tf": 1}, "redlines.processor.Chunk.chunk_location": {"tf": 1}}, "df": 5}}}}}}, "k": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1}}, "df": 1}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"redlines.redlines.Redlines.output_markdown": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}}, "pipeline": ["trimmer"], "_isPrebuiltIndex": true}; - - // mirrored in build-search-index.js (part 1) - // Also split on html tags. this is a cheap heuristic, but good enough. - elasticlunr.tokenizer.setSeperator(/[\s\-.;&_'"=,()]+|<[^>]*>/); - - let searchIndex; - if (docs._isPrebuiltIndex) { - console.info("using precompiled search index"); - searchIndex = elasticlunr.Index.load(docs); - } else { - console.time("building search index"); - // mirrored in build-search-index.js (part 2) - searchIndex = elasticlunr(function () { - this.pipeline.remove(elasticlunr.stemmer); - this.pipeline.remove(elasticlunr.stopWordFilter); - this.addField("qualname"); - this.addField("fullname"); - this.addField("annotation"); - this.addField("default_value"); - this.addField("signature"); - this.addField("bases"); - this.addField("doc"); - this.setRef("fullname"); - }); - for (let doc of docs) { - searchIndex.addDoc(doc); - } - console.timeEnd("building search index"); - } - - return (term) => searchIndex.search(term, { - fields: { - qualname: {boost: 4}, - fullname: {boost: 2}, - annotation: {boost: 2}, - default_value: {boost: 2}, - signature: {boost: 2}, - bases: {boost: 2}, - doc: {boost: 1}, - }, - expand: true - }); -})(); \ No newline at end of file diff --git a/docs/index.html b/docs/index.html deleted file mode 100644 index d32360c..0000000 --- a/docs/index.html +++ /dev/null @@ -1,15 +0,0 @@ - - - - - Documentation - - - -
- Documentation for version v0.6.1 -
-

Documentation for version v0.6.1

-

Redirecting to documentation...

- - From 76b586b3e3f1e185fbb82be63962da46f29b947a Mon Sep 17 00:00:00 2001 From: Houfu Ang Date: Tue, 14 Oct 2025 23:21:43 +0800 Subject: [PATCH 7/8] Apply suggestions from code review --- .github/workflows/docs.yml | 2 +- CONTRIBUTING.md | 2 -- 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml index b6b05a9..97cc657 100644 --- a/.github/workflows/docs.yml +++ b/.github/workflows/docs.yml @@ -3,7 +3,7 @@ name: website # build the documentation whenever there are new commits on main on: release: - - published + types: [published] # Alternative: only build for tags. # tags: # - '*' diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 0a02a9d..128291f 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -173,7 +173,6 @@ To build docs locally before releasing: ```bash # install pdoc locally pip install pdoc -``` # generate HTML into docs/ pdoc --html --output-dir docs/ your_package_name @@ -182,7 +181,6 @@ pdoc --html --output-dir docs/ your_package_name cd docs python -m http.server 8000 # then open http://localhost:8000 in your browser - ## Styleguides For code, we use the [Black formatter](https://black.readthedocs.io/en/stable/index.html). Please be encouraged to use From 2f352db85ebd5ee7f1fcca88bc2b218dbc1efaa2 Mon Sep 17 00:00:00 2001 From: Houfu Ang Date: Tue, 14 Oct 2025 23:22:21 +0800 Subject: [PATCH 8/8] Update CONTRIBUTING.md --- CONTRIBUTING.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 128291f..14ea30c 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -181,6 +181,8 @@ pdoc --html --output-dir docs/ your_package_name cd docs python -m http.server 8000 # then open http://localhost:8000 in your browser +``` + ## Styleguides For code, we use the [Black formatter](https://black.readthedocs.io/en/stable/index.html). Please be encouraged to use