password-finder 2.1.1__tar.gz

password_finder-2.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 District5
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

password_finder-2.1.1/MANIFEST.in

@@ -0,0 +1,17 @@
+# Keep the source distribution in step with the wheel: ship the package, the
+# license, the readme, and the security policy -- but not tests, fixtures, CI
+# config, or build artefacts. (Tests are dev-only and the email fixtures contain
+# password-shaped test data that has no place in a distributed artefact.)
+
+include LICENSE
+include README.md
+include SECURITY.md
+include pyproject.toml
+
+prune tests
+prune .github
+prune dist
+prune build
+
+global-exclude *.py[cod]
+global-exclude __pycache__

password_finder-2.1.1/PKG-INFO

@@ -0,0 +1,208 @@
+Metadata-Version: 2.4
+Name: password-finder
+Version: 2.1.1
+Summary: Extract passwords from free-form text such as email bodies (e.g. a password for an encrypted attachment sent in a separate message).
+Author: District5
+License: MIT
+Keywords: password,extract,parse,email,text,regex
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Text Processing
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: license-file
+
+# Password Finder
+
+A small Python library that extracts a password out of free-form text.
+
+The motivating case: an encrypted attachment arrives in one email, and the
+password to open it arrives in another (or in the body of the same message)
+phrased in plain English — *"the password for the attached document is
+Q3Report2026z"*. This library pulls that password back out.
+
+## Installation
+
+```bash
+pip install password-finder
+```
+
+Requires Python 3.9+. It has no runtime dependencies (standard library only).
+
+## Usage
+
+The finder **always returns a list of candidates**, ranked by confidence — it
+never returns a single string, because there is often more than one plausible
+password and the caller is best placed to decide (try each in turn, apply a
+threshold, ask a human). The list is empty when nothing plausible was found.
+
+Everything works on a **string** — read a file (or take an email body) and pass
+its contents straight in:
+
+```python
+from password_finder import PasswordFinder
+
+finder = PasswordFinder()
+
+email_body = open("message.html", encoding="utf-8").read()
+
+# Full candidate objects, ranked by confidence (highest first), de-duplicated
+for c in finder.find_all(email_body):
+    print(c.password)     # "Q3Report2026z"
+    print(c.confidence)   # 0.96
+    print(c.keyword)      # "password"
+    print(c.context)      # "…the password to open the document is: Q3Report2026z…"
+
+# Just the strings, same ranking
+passwords = finder.find_passwords(email_body)   # ["Q3Report2026z", ...]
+
+# The most likely one (guard for the empty case yourself)
+candidates = finder.find_all(email_body)
+best = candidates[0].password if candidates else None
+```
+
+If you don't need to hold on to a configured finder, call the module-level
+helpers — string in, passwords out:
+
+```python
+import password_finder
+
+password_finder.find_passwords(open("message.html").read())   # ["Q3Report2026z", ...]
+password_finder.find_all("The password is Hunter2!")            # [Candidate(...)]
+```
+
+**HTML is detected automatically.** You never tell the library whether a string
+is HTML or plain text — it decides per input. When a string looks like HTML
+(tags or entities present), `<script>`/`<style>` blocks and comments are
+dropped, tags are stripped and entities decoded before matching, so
+`<b>Rb9TZ4W</b>` and `&amp;` come out correctly; plain text is left untouched.
+You can ask the library directly with `PasswordFinder.looks_like_html(text)`,
+or force plain-text handling with `PasswordFinder(decode_html=False)`.
+
+## How it works
+
+The finder scans for password-related keywords — `password`, `passphrase`,
+`passcode`, `access code`, `unlock code`, `one-time code`, `authentication
+code`, `login credentials`, `pwd`, `pin`, `code`, `secret`, localised spellings
+(`kennwort`, `mot de passe`, `contraseña`, …) and more — optionally followed by
+filler words (*"for opening the protected mail content"*) and a connector (`:`,
+`=`, or `is`), then captures the token that follows. It matches four layouts:
+
+1. **strict** — keyword + curated filler + connector,
+2. **loose** — keyword + free text up to a `:`/`=`,
+3. **wrapped** — keyword immediately followed by a quoted/bracketed value,
+4. **nextline** — keyword alone on a line with the value on the next line
+   (this also recovers label/value pairs in adjacent HTML table cells).
+
+Values wrapped in quotes, `*markdown*`, `` `backticks` `` or `(brackets)` are
+unwrapped automatically. The matching `pattern` and character `span` are exposed
+on each `Candidate` for debugging.
+
+Each hit is scored heuristically. Signals that raise confidence:
+
+- an explicit `:` or `=` connector,
+- a specific keyword (`password` beats `pin`),
+- a value that is close to the keyword (short distance),
+- high **Shannon entropy** and **character-class diversity** (looks generated),
+- a sensible length (6–40 characters),
+- a value the sender deliberately **quoted/bracketed**.
+
+Signals that lower it, or reject the match outright:
+
+- lots of filler words / large distance between the keyword and the value,
+- the "password" being a plain word like `attached`, `below`, `reset`, or `is`,
+- a long pure-digit run (looks like a reference/policy number),
+- shapes that are **never** passwords: URLs, email addresses, phone numbers,
+  dates, times, and currency amounts — these are rejected outright.
+
+This means when a message contains several candidates, the most plausible one
+sorts to the top. Because it is heuristic, always sanity-check
+`.confidence` for your use case rather than trusting the top hit blindly.
+
+## Configuration
+
+Basic knobs, shown with their defaults:
+
+```python
+finder = PasswordFinder(
+    min_length=3,                        # ignore very short tokens
+    max_length=128,                      # ignore very long tokens (URLs etc.)
+    extra_keywords=None,                 # add your own trigger words
+    decode_html=True,                    # strip HTML before matching
+)
+```
+
+Raising `min_length` and lowering `max_length` is the quickest way to trade
+recall for precision — e.g. `PasswordFinder(min_length=6, max_length=64)` if you
+know the passwords you care about are never shorter than six characters.
+
+Everything the finder uses — keywords and their base scores, the filler/reject
+word lists, and every scoring weight — lives in `FinderConfig` and can be
+overridden without touching the engine:
+
+```python
+from password_finder import PasswordFinder, FinderConfig, Weights
+
+config = FinderConfig(
+    keywords={"password": 0.75, "kennwort": 0.72, "magicword": 0.9},
+    weights=Weights(colon_bonus=0.20, entropy_scale=0.03),
+)
+finder = PasswordFinder(config=config)
+```
+
+`extra_keywords` still works alongside a custom `config` (it merges on top).
+
+## Command-line testing
+
+Two helpers are installed with the package for trying the library against real
+messages. They print every candidate, best first:
+
+```bash
+find-password email.txt        # from a file
+pbpaste | find-password        # pipe from the clipboard (macOS)
+cat message.eml | find-password
+
+scan-emails                    # run over every file in tests/emails/
+scan-emails path/to/dir        # ...or a directory of your choosing
+```
+
+You can also invoke them without installing:
+
+```bash
+python -m password_finder.cli email.txt
+```
+
+## Tests
+
+```bash
+python -m venv .venv && . .venv/bin/activate
+pip install -e ".[dev]"
+pytest
+```
+
+Test emails live in `tests/emails/`, named after the password(s) they contain
+using `-OR-` as the separator (e.g. `{pw1}-OR-{pw2}.html`). `test_email_fixtures.py`
+runs the finder over each one and asserts those passwords are the top-ranked
+candidates, so dropping a new email in there and naming it after its password(s)
+is enough to add a regression test.
+
+`tests/emails-special-characters/` holds passwords made of punctuation and
+symbols — including characters a file name cannot contain — so it uses a
+different convention: **the first line of the file is the expected password**,
+and `test_special_character_fixtures.py` strips that line before matching. This
+is where trimming, HTML entity decoding, and the rejection rules get exercised.
+
+`tests/emails_negative/` holds the **negative corpus** — realistic emails that
+must *not* yield a convincing password (marketing, statements, and keywords
+sitting next to URLs / dates / phone numbers). `test_negative_corpus.py` asserts
+nothing crosses a confidence threshold, guarding against precision regressions.
+
+Each fixture directory has a `README.md` explaining its convention and how to
+anonymise a real message before adding it.
+
+## License
+
+MIT — Copyright (c) 2026 District5. See [LICENSE](LICENSE) for the full text.

password_finder-2.1.1/README.md

@@ -0,0 +1,191 @@
+# Password Finder
+
+A small Python library that extracts a password out of free-form text.
+
+The motivating case: an encrypted attachment arrives in one email, and the
+password to open it arrives in another (or in the body of the same message)
+phrased in plain English — *"the password for the attached document is
+Q3Report2026z"*. This library pulls that password back out.
+
+## Installation
+
+```bash
+pip install password-finder
+```
+
+Requires Python 3.9+. It has no runtime dependencies (standard library only).
+
+## Usage
+
+The finder **always returns a list of candidates**, ranked by confidence — it
+never returns a single string, because there is often more than one plausible
+password and the caller is best placed to decide (try each in turn, apply a
+threshold, ask a human). The list is empty when nothing plausible was found.
+
+Everything works on a **string** — read a file (or take an email body) and pass
+its contents straight in:
+
+```python
+from password_finder import PasswordFinder
+
+finder = PasswordFinder()
+
+email_body = open("message.html", encoding="utf-8").read()
+
+# Full candidate objects, ranked by confidence (highest first), de-duplicated
+for c in finder.find_all(email_body):
+    print(c.password)     # "Q3Report2026z"
+    print(c.confidence)   # 0.96
+    print(c.keyword)      # "password"
+    print(c.context)      # "…the password to open the document is: Q3Report2026z…"
+
+# Just the strings, same ranking
+passwords = finder.find_passwords(email_body)   # ["Q3Report2026z", ...]
+
+# The most likely one (guard for the empty case yourself)
+candidates = finder.find_all(email_body)
+best = candidates[0].password if candidates else None
+```
+
+If you don't need to hold on to a configured finder, call the module-level
+helpers — string in, passwords out:
+
+```python
+import password_finder
+
+password_finder.find_passwords(open("message.html").read())   # ["Q3Report2026z", ...]
+password_finder.find_all("The password is Hunter2!")            # [Candidate(...)]
+```
+
+**HTML is detected automatically.** You never tell the library whether a string
+is HTML or plain text — it decides per input. When a string looks like HTML
+(tags or entities present), `<script>`/`<style>` blocks and comments are
+dropped, tags are stripped and entities decoded before matching, so
+`<b>Rb9TZ4W</b>` and `&amp;` come out correctly; plain text is left untouched.
+You can ask the library directly with `PasswordFinder.looks_like_html(text)`,
+or force plain-text handling with `PasswordFinder(decode_html=False)`.
+
+## How it works
+
+The finder scans for password-related keywords — `password`, `passphrase`,
+`passcode`, `access code`, `unlock code`, `one-time code`, `authentication
+code`, `login credentials`, `pwd`, `pin`, `code`, `secret`, localised spellings
+(`kennwort`, `mot de passe`, `contraseña`, …) and more — optionally followed by
+filler words (*"for opening the protected mail content"*) and a connector (`:`,
+`=`, or `is`), then captures the token that follows. It matches four layouts:
+
+1. **strict** — keyword + curated filler + connector,
+2. **loose** — keyword + free text up to a `:`/`=`,
+3. **wrapped** — keyword immediately followed by a quoted/bracketed value,
+4. **nextline** — keyword alone on a line with the value on the next line
+   (this also recovers label/value pairs in adjacent HTML table cells).
+
+Values wrapped in quotes, `*markdown*`, `` `backticks` `` or `(brackets)` are
+unwrapped automatically. The matching `pattern` and character `span` are exposed
+on each `Candidate` for debugging.
+
+Each hit is scored heuristically. Signals that raise confidence:
+
+- an explicit `:` or `=` connector,
+- a specific keyword (`password` beats `pin`),
+- a value that is close to the keyword (short distance),
+- high **Shannon entropy** and **character-class diversity** (looks generated),
+- a sensible length (6–40 characters),
+- a value the sender deliberately **quoted/bracketed**.
+
+Signals that lower it, or reject the match outright:
+
+- lots of filler words / large distance between the keyword and the value,
+- the "password" being a plain word like `attached`, `below`, `reset`, or `is`,
+- a long pure-digit run (looks like a reference/policy number),
+- shapes that are **never** passwords: URLs, email addresses, phone numbers,
+  dates, times, and currency amounts — these are rejected outright.
+
+This means when a message contains several candidates, the most plausible one
+sorts to the top. Because it is heuristic, always sanity-check
+`.confidence` for your use case rather than trusting the top hit blindly.
+
+## Configuration
+
+Basic knobs, shown with their defaults:
+
+```python
+finder = PasswordFinder(
+    min_length=3,                        # ignore very short tokens
+    max_length=128,                      # ignore very long tokens (URLs etc.)
+    extra_keywords=None,                 # add your own trigger words
+    decode_html=True,                    # strip HTML before matching
+)
+```
+
+Raising `min_length` and lowering `max_length` is the quickest way to trade
+recall for precision — e.g. `PasswordFinder(min_length=6, max_length=64)` if you
+know the passwords you care about are never shorter than six characters.
+
+Everything the finder uses — keywords and their base scores, the filler/reject
+word lists, and every scoring weight — lives in `FinderConfig` and can be
+overridden without touching the engine:
+
+```python
+from password_finder import PasswordFinder, FinderConfig, Weights
+
+config = FinderConfig(
+    keywords={"password": 0.75, "kennwort": 0.72, "magicword": 0.9},
+    weights=Weights(colon_bonus=0.20, entropy_scale=0.03),
+)
+finder = PasswordFinder(config=config)
+```
+
+`extra_keywords` still works alongside a custom `config` (it merges on top).
+
+## Command-line testing
+
+Two helpers are installed with the package for trying the library against real
+messages. They print every candidate, best first:
+
+```bash
+find-password email.txt        # from a file
+pbpaste | find-password        # pipe from the clipboard (macOS)
+cat message.eml | find-password
+
+scan-emails                    # run over every file in tests/emails/
+scan-emails path/to/dir        # ...or a directory of your choosing
+```
+
+You can also invoke them without installing:
+
+```bash
+python -m password_finder.cli email.txt
+```
+
+## Tests
+
+```bash
+python -m venv .venv && . .venv/bin/activate
+pip install -e ".[dev]"
+pytest
+```
+
+Test emails live in `tests/emails/`, named after the password(s) they contain
+using `-OR-` as the separator (e.g. `{pw1}-OR-{pw2}.html`). `test_email_fixtures.py`
+runs the finder over each one and asserts those passwords are the top-ranked
+candidates, so dropping a new email in there and naming it after its password(s)
+is enough to add a regression test.
+
+`tests/emails-special-characters/` holds passwords made of punctuation and
+symbols — including characters a file name cannot contain — so it uses a
+different convention: **the first line of the file is the expected password**,
+and `test_special_character_fixtures.py` strips that line before matching. This
+is where trimming, HTML entity decoding, and the rejection rules get exercised.
+
+`tests/emails_negative/` holds the **negative corpus** — realistic emails that
+must *not* yield a convincing password (marketing, statements, and keywords
+sitting next to URLs / dates / phone numbers). `test_negative_corpus.py` asserts
+nothing crosses a confidence threshold, guarding against precision regressions.
+
+Each fixture directory has a `README.md` explaining its convention and how to
+anonymise a real message before adding it.
+
+## License
+
+MIT — Copyright (c) 2026 District5. See [LICENSE](LICENSE) for the full text.

password_finder-2.1.1/SECURITY.md

@@ -0,0 +1,102 @@
+# Security Policy
+
+## Reporting a vulnerability
+
+**Please do not open a public issue for a security problem.**
+
+Use GitHub's private vulnerability reporting instead: go to the
+[Security tab](https://github.com/district-5/password-finder/security)
+and choose **Report a vulnerability**. That channel is private to you and the
+maintainers.
+
+If you cannot use it, open a normal issue containing **only** the sentence
+"I have a security report" — no details, no sample data — and a maintainer will
+arrange a private channel. Do not describe the problem in the public issue.
+
+We aim to acknowledge a report within 5 working days, and to agree a disclosure
+timeline with you once we have confirmed it. Please give us a reasonable chance
+to ship a fix before publishing.
+
+<!-- Maintainers: if you set up a dedicated security mailbox, add it here as a
+     second channel. Do not list an address that nobody monitors. -->
+
+## Never send us a real password
+
+This library exists to extract passwords, so reports naturally come with sample
+messages attached. **Sanitise them before sending, even privately.**
+
+Replace the real password with an invented one of the **same shape** — same
+length, same mix of upper case, lower case, digits and symbols, same separators
+— and strip names, email addresses, phone numbers, account and reference
+numbers, real domains, and mail headers. `tests/emails/README.md` has worked
+examples with measured confidence scores.
+
+If a real password has already been committed, pasted into an issue, or emailed
+anywhere: **rotate it first**, then tell us. Treat it as disclosed. Git objects
+stay reachable in forks, caches, and existing clones long after a force-push,
+so rewriting history is not a remedy on its own.
+
+## Scope
+
+The library takes untrusted text and runs regular expressions over it. It has no
+runtime dependencies, opens no network connections, reads no files (the
+`find-password` and `scan-emails` CLI entry points do), and never evaluates or
+deserialises input. So the interesting attack surface is narrow, and it is
+mostly about what a hostile *input string* can do to a process that parses it.
+
+In scope:
+
+- **Catastrophic backtracking / denial of service.** An input that makes
+  matching take pathological time or memory. The matcher compiles patterns from
+  a configurable keyword list and applies bounded-repetition groups to arbitrary
+  text; an input that defeats those bounds is a valid report. Please include the
+  input (sanitised), the wall-clock time, and your `min_length`/`max_length` and
+  `FinderConfig` settings.
+- **Unbounded memory growth** on large or adversarial bodies, including in HTML
+  normalisation.
+- **Crashes** that a caller cannot defend against — an uncaught exception on
+  input that is merely unusual rather than invalid.
+- **Leaks of extracted values** into places a caller did not choose: an
+  exception message, a warning, `repr()` output, or a temporary file.
+- **Supply-chain problems**: a compromised or typo-squatted `password-finder`
+  release, or a tampered artefact.
+
+Out of scope — real reports, but not security ones, so please use the
+[issue templates](https://github.com/district-5/password-finder/issues/new/choose):
+
+- The finder **missing** a password, ranking the wrong candidate first, or
+  returning a false positive. These are detection bugs. The library is
+  explicitly heuristic and returns ranked candidates rather than one answer.
+- A confidence score you disagree with.
+- The library finding a password in a message you consider private — it only
+  ever sees the string you pass it.
+
+## Handling extracted passwords safely
+
+Some hazards live in the calling code rather than in this library, and they are
+easy to trip over. If you integrate it, note:
+
+- **`str(candidate)` returns the bare password.** `Candidate.__str__` is the
+  password itself, so `print(f"found {c}")`, `logging.info("%s", c)`, and any
+  f-string interpolation write a real secret to your logs.
+- **`candidate.context` contains the password plus roughly 40 characters either
+  side.** It exists for debugging and review. Logging it leaks both the secret
+  and the surrounding message text.
+- **`candidate.to_dict()` serialises `password` and `context` in full.** Do not
+  hand it to a JSON logger, an error tracker, or an analytics pipeline.
+- **The CLI prints candidates to stdout.** Convenient for testing, but that
+  means terminal scrollback, shell history, CI logs, and any redirect target.
+  Do not run `scan-emails` over real mail in CI.
+- Keep extracted passwords in memory only as long as you need them, and prefer
+  passing them straight to the consumer (e.g. the archive being opened) over
+  storing them.
+
+## Supported versions
+
+| Version | Supported |
+| --- | --- |
+| 2.1.x | Yes |
+| < 2.1 | No — please upgrade |
+
+Fixes land on `master` and go out in a new release; there are no long-term
+support branches.

password_finder-2.1.1/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "password-finder"
+version = "2.1.1"
+description = "Extract passwords from free-form text such as email bodies (e.g. a password for an encrypted attachment sent in a separate message)."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+keywords = ["password", "extract", "parse", "email", "text", "regex"]
+authors = [{ name = "District5" }]
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Text Processing",
+]
+dependencies = []
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0"]
+
+[project.scripts]
+find-password = "password_finder.cli:find_password"
+scan-emails = "password_finder.cli:scan_emails"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

password_finder-2.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

password_finder-2.1.1/src/password_finder/__init__.py

@@ -0,0 +1,22 @@
+"""Extract passwords from free-form text such as email bodies.
+
+The motivating case: an encrypted attachment arrives in one email, and the
+password to open it arrives in another (or in the body of the same message)
+phrased in plain English -- *"the password for the attached document is
+Q3Report2026z"*. This library pulls that password back out.
+"""
+
+from .candidate import Candidate
+from .config import DEFAULT_KEYWORDS, FinderConfig, Weights
+from .finder import PasswordFinder, find_all, find_passwords
+
+__all__ = [
+    "Candidate",
+    "PasswordFinder",
+    "FinderConfig",
+    "Weights",
+    "DEFAULT_KEYWORDS",
+    "find_passwords",
+    "find_all",
+]
+__version__ = "2.1.0"

password_finder-2.1.1/src/password_finder/candidate.py

@@ -0,0 +1,47 @@
+"""Value object representing a single extracted password candidate."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class Candidate:
+    """A single password candidate extracted from a body of text.
+
+    Immutable value object. :attr:`confidence` is a heuristic score in the
+    range ``0.0`` - ``1.0`` describing how likely this string is to be the
+    intended password. It is used to rank candidates when a text contains more
+    than one.
+
+    :param password:   The extracted password.
+    :param confidence: Heuristic score, ``0.0`` (unlikely) - ``1.0`` (very likely).
+    :param keyword:    The keyword that triggered the match (e.g. ``"password"``).
+    :param context:    A short snippet of surrounding text for debugging/review.
+    :param offset:     Character offset of the password within the normalised text.
+    :param pattern:    Which match strategy fired: ``strict``/``loose``/``wrapped``/``nextline``.
+    :param span:       ``(start, end)`` character span of the password in the normalised text.
+    """
+
+    password: str
+    confidence: float
+    keyword: str
+    context: str
+    offset: int
+    pattern: str = ""
+    span: tuple[int, int] = (-1, -1)
+
+    def __str__(self) -> str:
+        return self.password
+
+    def to_dict(self) -> dict:
+        """Return the candidate as a plain dictionary."""
+        return {
+            "password": self.password,
+            "confidence": self.confidence,
+            "keyword": self.keyword,
+            "context": self.context,
+            "offset": self.offset,
+            "pattern": self.pattern,
+            "span": self.span,
+        }