Add comprehensive TypedDicts to minimize Any usage in public APIs

Co-authored-by: seanthegeek <44679+seanthegeek@users.noreply.github.com>
Fix Python 3.9 compatibility: replace pipe union syntax with Union/Optional
2026-02-21 00:36:25 +00:00 · 2025-12-17 22:28:19 +00:00 · 2025-12-17 22:18:57 +00:00 · 2025-12-17 21:45:21 +00:00 · 2025-12-17 21:42:25 +00:00 · 2025-12-17 21:36:57 +00:00
40 changed files with 1275 additions and 2313 deletions
--- a/.github/workflows/python-tests.yml
+++ b/.github/workflows/python-tests.yml
@@ -30,7 +30,7 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13", "3.14"]
+        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13"]

    steps:
    - uses: actions/checkout@v5
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -13,154 +13,148 @@
        "MD024": false
    },
    "cSpell.words": [
-      "adkim",
-      "akamaiedge",
-      "amsmath",
-      "andrewmcgilvray",
-      "arcname",
-      "aspf",
-      "autoclass",
-      "automodule",
-      "backported",
-      "bellsouth",
-      "boto",
-      "brakhane",
-      "Brightmail",
-      "CEST",
-      "CHACHA",
-      "checkdmarc",
-      "Codecov",
-      "confnew",
-      "dateparser",
-      "dateutil",
-      "Davmail",
-      "DBIP",
-      "dearmor",
-      "deflist",
-      "devel",
-      "DMARC",
-      "Dmarcian",
-      "dnspython",
-      "dollarmath",
-      "dpkg",
-      "exampleuser",
-      "expiringdict",
-      "fieldlist",
-      "GELF",
-      "genindex",
-      "geoip",
-      "geoipupdate",
-      "Geolite",
-      "geolocation",
-      "githubpages",
-      "Grafana",
-      "hostnames",
-      "htpasswd",
-      "httpasswd",
-      "httplib",
-      "ifhost",
-      "IMAP",
-      "imapclient",
-      "infile",
-      "Interaktive",
-      "IPDB",
-      "journalctl",
-      "kafkaclient",
-      "keepalive",
-      "keyout",
-      "keyrings",
-      "Leeman",
-      "libemail",
-      "linkify",
-      "LISTSERV",
-      "loganalytics",
-      "lxml",
-      "mailparser",
-      "mailrelay",
-      "mailsuite",
-      "maxdepth",
-      "MAXHEADERS",
-      "maxmind",
-      "mbox",
-      "mfrom",
-      "mhdw",
-      "michaeldavie",
-      "mikesiegel",
-      "Mimecast",
-      "mitigations",
-      "MMDB",
-      "modindex",
-      "msgconvert",
-      "msgraph",
-      "MSSP",
-      "multiprocess",
-      "Munge",
-      "ndjson",
-      "newkey",
-      "Nhcm",
-      "nojekyll",
-      "nondigest",
-      "nosecureimap",
-      "nosniff",
-      "nwettbewerb",
-      "opensearch",
-      "opensearchpy",
-      "parsedmarc",
-      "passsword",
-      "pbar",
-      "Postorius",
-      "premade",
-      "privatesuffix",
-      "procs",
-      "publicsuffix",
-      "publicsuffixlist",
-      "publixsuffix",
-      "pygelf",
-      "pypy",
-      "pytest",
-      "quickstart",
-      "Reindex",
-      "replyto",
-      "reversename",
-      "Rollup",
-      "Rpdm",
-      "SAMEORIGIN",
-      "sdist",
-      "Servernameone",
-      "setuptools",
-      "smartquotes",
-      "SMTPTLS",
-      "sortlists",
-      "sortmaps",
-      "sourcetype",
-      "STARTTLS",
-      "tasklist",
-      "timespan",
-      "tlsa",
-      "tlsrpt",
-      "toctree",
-      "TQDDM",
-      "tqdm",
-      "truststore",
-      "Übersicht",
-      "uids",
-      "Uncategorized",
-      "unparasable",
-      "uper",
-      "urllib",
-      "Valimail",
-      "venv",
-      "Vhcw",
-      "viewcode",
-      "virtualenv",
-      "WBITS",
-      "webmail",
-      "Wettbewerber",
-      "Whalen",
-      "whitespaces",
-      "xennn",
-      "xmltodict",
-      "xpack",
-      "zscholl"
+        "adkim",
+        "akamaiedge",
+        "amsmath",
+        "andrewmcgilvray",
+        "arcname",
+        "aspf",
+        "autoclass",
+        "automodule",
+        "backported",
+        "bellsouth",
+        "boto",
+        "brakhane",
+        "Brightmail",
+        "CEST",
+        "CHACHA",
+        "checkdmarc",
+        "Codecov",
+        "confnew",
+        "dateparser",
+        "dateutil",
+        "Davmail",
+        "DBIP",
+        "dearmor",
+        "deflist",
+        "devel",
+        "DMARC",
+        "Dmarcian",
+        "dnspython",
+        "dollarmath",
+        "dpkg",
+        "exampleuser",
+        "expiringdict",
+        "fieldlist",
+        "GELF",
+        "genindex",
+        "geoip",
+        "geoipupdate",
+        "Geolite",
+        "geolocation",
+        "githubpages",
+        "Grafana",
+        "hostnames",
+        "htpasswd",
+        "httpasswd",
+        "httplib",
+        "IMAP",
+        "imapclient",
+        "infile",
+        "Interaktive",
+        "IPDB",
+        "journalctl",
+        "keepalive",
+        "keyout",
+        "keyrings",
+        "Leeman",
+        "libemail",
+        "linkify",
+        "LISTSERV",
+        "lxml",
+        "mailparser",
+        "mailrelay",
+        "mailsuite",
+        "maxdepth",
+        "MAXHEADERS",
+        "maxmind",
+        "mbox",
+        "mfrom",
+        "michaeldavie",
+        "mikesiegel",
+        "Mimecast",
+        "mitigations",
+        "MMDB",
+        "modindex",
+        "msgconvert",
+        "msgraph",
+        "MSSP",
+        "multiprocess",
+        "Munge",
+        "ndjson",
+        "newkey",
+        "Nhcm",
+        "nojekyll",
+        "nondigest",
+        "nosecureimap",
+        "nosniff",
+        "nwettbewerb",
+        "opensearch",
+        "opensearchpy",
+        "parsedmarc",
+        "passsword",
+        "Postorius",
+        "premade",
+        "procs",
+        "publicsuffix",
+        "publicsuffixlist",
+        "publixsuffix",
+        "pygelf",
+        "pypy",
+        "pytest",
+        "quickstart",
+        "Reindex",
+        "replyto",
+        "reversename",
+        "Rollup",
+        "Rpdm",
+        "SAMEORIGIN",
+        "sdist",
+        "Servernameone",
+        "setuptools",
+        "smartquotes",
+        "SMTPTLS",
+        "sortlists",
+        "sortmaps",
+        "sourcetype",
+        "STARTTLS",
+        "tasklist",
+        "timespan",
+        "tlsa",
+        "tlsrpt",
+        "toctree",
+        "TQDDM",
+        "tqdm",
+        "truststore",
+        "Übersicht",
+        "uids",
+        "Uncategorized",
+        "unparasable",
+        "uper",
+        "urllib",
+        "Valimail",
+        "venv",
+        "Vhcw",
+        "viewcode",
+        "virtualenv",
+        "WBITS",
+        "webmail",
+        "Wettbewerber",
+        "Whalen",
+        "whitespaces",
+        "xennn",
+        "xmltodict",
+        "xpack",
+        "zscholl"
    ],
 }
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,54 +1,5 @@
 # Changelog

-## 9.1.0
-
-## Enhancements
-
- Add TCP and TLS support for syslog output. (#656)
- Skip DNS lookups in GitHub Actions to prevent DNS timeouts during tests timeouts. (#657)
- Remove microseconds from DMARC aggregate report time ranges before parsing them.
-
-## 9.0.10
-
- Support Python 3.14+
-
-## 9.0.9
-
-### Fixes
-
- Validate that a string is base64-encoded before trying to base64 decode it. (PRs #648 and #649)
-
-## 9.0.8
-
-### Fixes
-
- Fix logging configuration not propagating to child parser processes (#646).
- Update `mailsuite` dependency to `?=1.11.1` to solve issues with iCloud IMAP (#493).
-
-## 9.0.7
-
-## Fixes
-
- Fix IMAP `since` option (#PR 645 closes issues #581 and #643).
-
-## 9.0.6
-
-### Fixes
-
- Fix #638.
- Fix/clarify report extraction and parsing behavior for multiple input types (bytes, base64 strings, and file-like objects).
- Fix type mismatches that could cause runtime issues in SMTP emailing and CLI option handling.
-
-### Improvements
-
- Improve type hints across the library (Pylance/Pyright friendliness) and reduce false-positive linter errors.
- Emails in Microsoft 365 are now marked read as they are read. This provides constancy with other mailbox types, and gives you a indication of when emails are being read as they are processed in batches. (Close #625)
-
-### Compatibility / Dependencies
-
- Set Python requirement to `>=3.9,<3.14`.
- Bump `mailsuite` requirement to `>=1.11.0`.
-
 ## 9.0.5

 ## Fixes
--- a/README.md
+++ b/README.md
@@ -61,4 +61,4 @@ for RHEL or Debian.
 | 3.11    | ✅         | Actively maintained; supported until June 2028 (Debian 12) |
 | 3.12    | ✅         | Actively maintained; supported until May 2035 (RHEL 10)    |
 | 3.13    | ✅         | Actively maintained; supported until June 2030 (Debian 13) |
-| 3.14    | ✅         | Actively maintained                                        |
+| 3.14    | ❌         | Not currently supported due to Not currently supported due to [this imapclient bug](https://github.com/mjs/imapclient/issues/618)|
--- a/ci.ini
+++ b/ci.ini
@@ -3,7 +3,6 @@ save_aggregate = True
 save_forensic = True
 save_smtp_tls = True
 debug = True
-offline = True

 [elasticsearch]
 hosts = http://localhost:9200
--- a/docs/source/api.md
+++ b/docs/source/api.md
@@ -28,13 +28,6 @@
   :members:
 ```

-## parsedmarc.types
-
-```{eval-rst}
-.. automodule:: parsedmarc.types
-   :members:
-```
-
 ## parsedmarc.utils

 ```{eval-rst}
--- a/docs/source/elasticsearch.md
+++ b/docs/source/elasticsearch.md
@@ -214,7 +214,7 @@ Kibana index patterns with versions that match the upgraded indexes:

 1. Login in to Kibana, and click on Management
 2. Under Kibana, click on Saved Objects
-3. Check the checkboxes for the `dmarc_aggregate` and `dmarc_failure`
+3. Check the checkboxes for the `dmarc_aggregate` and `dmarc_forensic`
   index patterns
 4. Click Delete
 5. Click Delete on the conformation message
--- a/docs/source/example.ini
+++ b/docs/source/example.ini
@@ -2,7 +2,7 @@

 [general]
 save_aggregate = True
-save_failure = True
+save_forensic = True

 [imap]
 host = imap.example.com
--- a/docs/source/index.md
+++ b/docs/source/index.md
@@ -34,7 +34,7 @@ and Valimail.
 ## Features

 - Parses draft and 1.0 standard aggregate/rua DMARC reports
- Parses failure/ruf DMARC reports
+- Parses forensic/failure/ruf DMARC reports
 - Parses reports from SMTP TLS Reporting
 - Can parse reports from an inbox over IMAP, Microsoft Graph, or Gmail API
 - Transparently handles gzip or zip compressed reports
@@ -61,7 +61,7 @@ for RHEL or Debian.
 | 3.11    | ✅         | Actively maintained; supported until June 2028 (Debian 12) |
 | 3.12    | ✅         | Actively maintained; supported until May 2035 (RHEL 10)    |
 | 3.13    | ✅         | Actively maintained; supported until June 2030 (Debian 13) |
-| 3.14    | ✅         | Actively maintained                                        |
+| 3.14    | ❌         | Not currently supported due to [this imapclient bug](https://github.com/mjs/imapclient/issues/618)|

 ```{toctree}
 :caption: 'Contents'
--- a/docs/source/kibana.md
+++ b/docs/source/kibana.md
@@ -74,14 +74,14 @@ the DMARC Summary dashboard. To view failures only, use the pie chart.
 Any other filters work the same way. You can also add your own custom temporary
 filters by clicking on Add Filter at the upper right of the page.

-## DMARC Failure Samples
+## DMARC Forensic Samples

-The DMARC Failure Samples dashboard contains information on DMARC failure
-reports (also known as ruf reports). These reports contain
+The DMARC Forensic Samples dashboard contains information on DMARC forensic
+reports (also known as failure reports or ruf reports). These reports contain
 samples of emails that have failed to pass DMARC.

 :::{note}
-Most recipients do not send failure/ruf reports at all to avoid
+Most recipients do not send forensic/failure/ruf reports at all to avoid
 privacy leaks. Some recipients (notably Chinese webmail services) will only
 supply the headers of sample emails. Very few provide the entire email.
 :::
--- a/docs/source/output.md
+++ b/docs/source/output.md
@@ -96,12 +96,12 @@ draft,acme.com,noreply-dmarc-support@acme.com,http://acme.com/dmarc/support,9391

 ```

-## Sample failure report output
+## Sample forensic report output

 Thanks to GitHub user [xennn](https://github.com/xennn) for the anonymized
-[failure report email sample](<https://github.com/domainaware/parsedmarc/raw/master/samples/forensic/DMARC%20Failure%20Report%20for%20domain.de%20(mail-from%3Dsharepoint%40domain.de%2C%20ip%3D10.10.10.10).eml>).
+[forensic report email sample](<https://github.com/domainaware/parsedmarc/raw/master/samples/forensic/DMARC%20Failure%20Report%20for%20domain.de%20(mail-from%3Dsharepoint%40domain.de%2C%20ip%3D10.10.10.10).eml>).

-### JSON failure report
+### JSON forensic report

 ```json
 {
@@ -190,7 +190,7 @@ Thanks to GitHub user [xennn](https://github.com/xennn) for the anonymized
   }
 ```

-### CSV failure report
+### CSV forensic report

 ```text
 feedback_type,user_agent,version,original_envelope_id,original_mail_from,original_rcpt_to,arrival_date,arrival_date_utc,subject,message_id,authentication_results,dkim_domain,source_ip_address,source_country,source_reverse_dns,source_base_domain,delivery_result,auth_failure,reported_domain,authentication_mechanisms,sample_headers_only
--- a/docs/source/splunk.md
+++ b/docs/source/splunk.md
@@ -1,10 +1,10 @@
 # Splunk

 Starting in version 4.3.0 `parsedmarc` supports sending aggregate and/or
-failure DMARC data to a Splunk [HTTP Event collector (HEC)].
+forensic DMARC data to a Splunk [HTTP Event collector (HEC)].

 The project repository contains [XML files] for premade Splunk
-dashboards for aggregate and failure DMARC reports.
+dashboards for aggregate and forensic DMARC reports.

 Copy and paste the contents of each file into a separate Splunk
 dashboard XML editor.
--- a/docs/source/usage.md
+++ b/docs/source/usage.md
@@ -4,9 +4,9 @@

 ```text
 usage: parsedmarc [-h] [-c CONFIG_FILE] [--strip-attachment-payloads] [-o OUTPUT]
-                  [--aggregate-json-filename AGGREGATE_JSON_FILENAME] [--failure-json-filename FAILURE_JSON_FILENAME]
+                  [--aggregate-json-filename AGGREGATE_JSON_FILENAME] [--forensic-json-filename FORENSIC_JSON_FILENAME]
                  [--smtp-tls-json-filename SMTP_TLS_JSON_FILENAME] [--aggregate-csv-filename AGGREGATE_CSV_FILENAME]
-                  [--failure-csv-filename FAILURE_CSV_FILENAME] [--smtp-tls-csv-filename SMTP_TLS_CSV_FILENAME]
+                  [--forensic-csv-filename FORENSIC_CSV_FILENAME] [--smtp-tls-csv-filename SMTP_TLS_CSV_FILENAME]
                  [-n NAMESERVERS [NAMESERVERS ...]] [-t DNS_TIMEOUT] [--offline] [-s] [-w] [--verbose] [--debug]
                  [--log-file LOG_FILE] [--no-prettify-json] [-v]
                  [file_path ...]
@@ -14,26 +14,26 @@ usage: parsedmarc [-h] [-c CONFIG_FILE] [--strip-attachment-payloads] [-o OUTPUT
 Parses DMARC reports

 positional arguments:
-  file_path             one or more paths to aggregate or failure report files, emails, or mbox files'
+  file_path             one or more paths to aggregate or forensic report files, emails, or mbox files'

 options:
  -h, --help            show this help message and exit
  -c CONFIG_FILE, --config-file CONFIG_FILE
                        a path to a configuration file (--silent implied)
  --strip-attachment-payloads
-                        remove attachment payloads from failure report output
+                        remove attachment payloads from forensic report output
  -o OUTPUT, --output OUTPUT
                        write output files to the given directory
  --aggregate-json-filename AGGREGATE_JSON_FILENAME
                        filename for the aggregate JSON output file
-  --failure-json-filename FAILURE_JSON_FILENAME
-                        filename for the failure JSON output file
+  --forensic-json-filename FORENSIC_JSON_FILENAME
+                        filename for the forensic JSON output file
  --smtp-tls-json-filename SMTP_TLS_JSON_FILENAME
                        filename for the SMTP TLS JSON output file
  --aggregate-csv-filename AGGREGATE_CSV_FILENAME
                        filename for the aggregate CSV output file
-  --failure-csv-filename FAILURE_CSV_FILENAME
-                        filename for the failure CSV output file
+  --forensic-csv-filename FORENSIC_CSV_FILENAME
+                        filename for the forensic CSV output file
  --smtp-tls-csv-filename SMTP_TLS_CSV_FILENAME
                        filename for the SMTP TLS CSV output file
  -n NAMESERVERS [NAMESERVERS ...], --nameservers NAMESERVERS [NAMESERVERS ...]
@@ -70,7 +70,7 @@ For example

 [general]
 save_aggregate = True
-save_failure = True
+save_forensic = True

 [imap]
 host = imap.example.com
@@ -109,7 +109,7 @@ mode = tcp

 [webhook]
 aggregate_url = https://aggregate_url.example.com
-failure_url = https://failure_url.example.com
+forensic_url = https://forensic_url.example.com
 smtp_tls_url = https://smtp_tls_url.example.com
 timeout = 60
 ```
@@ -119,7 +119,7 @@ The full set of configuration options are:
 - `general`
  - `save_aggregate` - bool: Save aggregate report data to
      Elasticsearch, Splunk and/or S3
-  - `save_failure` - bool: Save failure report data to
+  - `save_forensic` - bool: Save forensic report data to
      Elasticsearch, Splunk and/or S3
  - `save_smtp_tls` - bool: Save SMTP-STS report data to
      Elasticsearch, Splunk and/or S3
@@ -130,7 +130,7 @@ The full set of configuration options are:
  - `output` - str: Directory to place JSON and CSV files in.  This is required if you set either of the JSON output file options.
  - `aggregate_json_filename` - str: filename for the aggregate
      JSON output file
-  - `failure_json_filename` - str: filename for the failure
+  - `forensic_json_filename` - str: filename for the forensic
      JSON output file
  - `ip_db_path` - str: An optional custom path to a MMDB file
      from MaxMind or DBIP
@@ -171,8 +171,8 @@ The full set of configuration options are:
  - `check_timeout` - int: Number of seconds to wait for a IMAP
      IDLE response or the number of seconds until the next
      mail check (Default: `30`)
-  - `since` - str: Search for messages since certain time. (Examples: `5m|3h|2d|1w`)
-      Acceptable units - {"m":"minutes", "h":"hours", "d":"days", "w":"weeks"}.
+  - `since` - str: Search for messages since certain time. (Examples: `5m|3h|2d|1w`) 
+      Acceptable units - {"m":"minutes", "h":"hours", "d":"days", "w":"weeks"}. 
      Defaults to `1d` if incorrect value is provided.
 - `imap`
  - `host` - str: The IMAP server hostname or IP address
@@ -240,7 +240,7 @@ The full set of configuration options are:
    group and use that as the group id.

    ```powershell
-    New-ApplicationAccessPolicy -AccessRight RestrictAccess
+    New-ApplicationAccessPolicy -AccessRight RestrictAccess 
    -AppId "<CLIENT_ID>" -PolicyScopeGroupId "<MAILBOX>"
    -Description "Restrict access to dmarc reports mailbox."
    ```
@@ -306,7 +306,7 @@ The full set of configuration options are:
  - `skip_certificate_verification` - bool: Skip certificate
    verification (not recommended)
  - `aggregate_topic` - str: The Kafka topic for aggregate reports
-  - `failure_topic` - str: The Kafka topic for failure reports
+  - `forensic_topic` - str: The Kafka topic for forensic reports
 - `smtp`
  - `host` - str: The SMTP hostname
  - `port` - int: The SMTP port (Default: `25`)
@@ -336,65 +336,13 @@ The full set of configuration options are:
  - `secret_access_key` - str: The secret access key (Optional)
 - `syslog`
  - `server` - str: The Syslog server name or IP address
-  - `port` - int: The port to use (Default: `514`)
-  - `protocol` - str: The protocol to use: `udp`, `tcp`, or `tls` (Default: `udp`)
-  - `cafile_path` - str: Path to CA certificate file for TLS server verification (Optional)
-  - `certfile_path` - str: Path to client certificate file for TLS authentication (Optional)
-  - `keyfile_path` - str: Path to client private key file for TLS authentication (Optional)
-  - `timeout` - float: Connection timeout in seconds for TCP/TLS (Default: `5.0`)
-  - `retry_attempts` - int: Number of retry attempts for failed connections (Default: `3`)
-  - `retry_delay` - int: Delay in seconds between retry attempts (Default: `5`)
-
-  **Example UDP configuration (default):**
-
-  ```ini
-  [syslog]
-  server = syslog.example.com
-  port = 514
-  ```
-
-  **Example TCP configuration:**
-
-  ```ini
-  [syslog]
-  server = syslog.example.com
-  port = 6514
-  protocol = tcp
-  timeout = 10.0
-  retry_attempts = 5
-  ```
-
-  **Example TLS configuration with server verification:**
-
-  ```ini
-  [syslog]
-  server = syslog.example.com
-  port = 6514
-  protocol = tls
-  cafile_path = /path/to/ca-cert.pem
-  timeout = 10.0
-  ```
-
-  **Example TLS configuration with mutual authentication:**
-
-  ```ini
-  [syslog]
-  server = syslog.example.com
-  port = 6514
-  protocol = tls
-  cafile_path = /path/to/ca-cert.pem
-  certfile_path = /path/to/client-cert.pem
-  keyfile_path = /path/to/client-key.pem
-  timeout = 10.0
-  retry_attempts = 3
-  retry_delay = 5
-  ```
+  - `port` - int: The UDP port to use (Default: `514`)
 - `gmail_api`
  - `credentials_file` - str: Path to file containing the
      credentials, None to disable (Default: `None`)
  - `token_file` - str: Path to save the token file
      (Default: `.token`)
-
+      
    :::{note}
    credentials_file and token_file can be got with [quickstart](https://developers.google.com/gmail/api/quickstart/python).Please change the scope to `https://www.googleapis.com/auth/gmail.modify`.
    :::
@@ -414,7 +362,7 @@ The full set of configuration options are:
  - `dce` - str: The Data Collection Endpoint (DCE). Example: `https://{DCE-NAME}.{REGION}.ingest.monitor.azure.com`.
  - `dcr_immutable_id` - str: The immutable ID of the Data Collection Rule (DCR)
  - `dcr_aggregate_stream` - str: The stream name for aggregate reports in the DCR
-  - `dcr_failure_stream` - str: The stream name for the failure reports in the DCR
+  - `dcr_forensic_stream` - str: The stream name for the forensic reports in the DCR
  - `dcr_smtp_tls_stream` - str: The stream name for the SMTP TLS reports in the DCR

  :::{note}
@@ -431,7 +379,7 @@ The full set of configuration options are:

 - `webhook` - Post the individual reports to a webhook url with the report as the JSON body
  - `aggregate_url` - str: URL of the webhook which should receive the aggregate reports
-  - `failure_url` - str: URL of the webhook which should receive the failure reports
+  - `forensic_url` - str: URL of the webhook which should receive the forensic reports
  - `smtp_tls_url` - str: URL of the webhook which should receive the smtp_tls reports
  - `timeout` - int: Interval in which the webhook call should timeout

@@ -446,26 +394,26 @@ blocks DNS requests to outside resolvers.
 :::

 :::{note}
-`save_aggregate` and `save_failure` are separate options
-because you may not want to save failure reports
-(formerly known as forensic reports) to your Elasticsearch instance,
+`save_aggregate` and `save_forensic` are separate options
+because you may not want to save forensic reports
+(also known as failure reports) to your Elasticsearch instance,
 particularly if you are in a highly-regulated industry that
 handles sensitive data, such as healthcare or finance. If your
 legitimate outgoing email fails DMARC, it is possible
-that email may appear later in a failure report.
+that email may appear later in a forensic report.

-Failure reports contain the original headers of an email that
+Forensic reports contain the original headers of an email that
 failed a DMARC check, and sometimes may also include the
 full message body, depending on the policy of the reporting
 organization.

-Most reporting organizations do not send failure reports of any
+Most reporting organizations do not send forensic reports of any
 kind for privacy reasons. While aggregate DMARC reports are sent
-at least daily, it is normal to receive very few failure reports.
+at least daily, it is normal to receive very few forensic reports.

-An alternative approach is to still collect failure/ruf
+An alternative approach is to still collect forensic/failure/ruf
 reports in your DMARC inbox, but run `parsedmarc` with
-```save_failure = True``` manually on a separate IMAP folder (using
+```save_forensic = True``` manually on a separate IMAP folder (using
 the ```reports_folder``` option), after you have manually moved
 known samples you want to save to that folder
 (e.g. malicious samples and non-sensitive legitimate samples).
@@ -494,7 +442,7 @@ Update the limit to 2k per example:
 PUT _cluster/settings
 {
  "persistent" : {
-    "cluster.max_shards_per_node" : 2000
+    "cluster.max_shards_per_node" : 2000 
  }
 }
 ```
--- a/grafana/Grafana-DMARC_Reports.json
+++ b/grafana/Grafana-DMARC_Reports.json
@@ -83,7 +83,7 @@
      "id": 28,
      "panels": [
        {
-          "content": "# DMARC Summary\r\nAs the name suggests, this dashboard is the best place to start reviewing your aggregate DMARC data.\r\n\r\nAcross the top of the dashboard, three pie charts display the percentage of alignment pass/fail for SPF, DKIM, and DMARC. Clicking on any chart segment will filter for that value.\r\n\r\n***Note***\r\nMessages should not be considered malicious just because they failed to pass DMARC; especially if you have just started collecting data. It may be a legitimate service that needs SPF and DKIM configured correctly.\r\n\r\nStart by filtering the results to only show failed DKIM alignment. While DMARC passes if a message passes SPF or DKIM alignment, only DKIM alignment remains valid when a message is forwarded without changing the from address, which is often caused by a mailbox forwarding rule. This is because DKIM signatures are part of the message headers, whereas SPF relies on SMTP session headers.\r\n\r\nUnderneath the pie charts. you can see graphs of DMARC passage and message disposition over time.\r\n\r\nUnder the graphs you will find the most useful data tables on the dashboard. On the left, there is a list of organizations that are sending you DMARC reports. In the center, there is a list of sending servers grouped by the base domain in their reverse DNS. On the right, there is a list of email from domains, sorted by message volume.\r\n\r\nBy hovering your mouse over a data table value and using the magnifying glass icons, you can filter on or filter out different values. Start by looking at the Message Sources by Reverse DNS table. Find a sender that you recognize, such as an email marketing service, hover over it, and click on the plus (+) magnifying glass icon, to add a filter that only shows results for that sender. Now, look at the Message From Header table to the right. That shows you the domains that a sender is sending as, which might tell you which brand/business is using a particular service. With that information, you can contact them and have them set up DKIM.\r\n\r\n***Note***\r\nIf you have a lot of B2C customers, you may see a high volume of emails as your domains coming from consumer email services, such as Google/Gmail and Yahoo! This occurs when customers have mailbox rules in place that forward emails from an old account to a new account, which is why DKIM authentication is so important, as mentioned earlier. Similar patterns may be observed with businesses who send from reverse DNS addressees of parent, subsidiary, and outdated brands.\r\n\r\n***Note***\r\nYou can add your own custom temporary filters by clicking on Add Filter at the upper right of the page.\r\n\r\n# DMARC Failure Samples\r\nThe DMARC Failure Samples section contains information on DMARC failure reports (also known as ruf reports). These reports contain samples of emails that have failed to pass DMARC.\r\n\r\n***Note***\r\nMost recipients do not send failure/ruf reports at all to avoid privacy leaks. Some recipients (notably Chinese webmail services) will only supply the headers of sample emails. Very few provide the entire email.\r\n\r\n# DMARC Alignment Guide\r\nDMARC ensures that SPF and DKIM authentication mechanisms actually authenticate against the same domain that the end user sees.\r\n\r\nA message passes a DMARC check by passing DKIM or SPF, **as long as the related indicators are also in alignment.**\r\n\r\n|           \t| DKIM                                                                                                                                             \t| SPF                                                                                                            \t|\r\n|-----------\t|--------------------------------------------------------------------------------------------------------------------------------------------------\t|----------------------------------------------------------------------------------------------------------------\t|\r\n| **Passing**   \t| The signature in the DKIM header is validated using a public key that is published as a DNS record of the domain name specified in the signature \t| The mail server's IP address is listed in the SPF record of the domain in the SMTP envelope's mail from header \t|\r\n| **Alignment** \t| The signing domain aligns with the domain in the message's from header                                                                           \t| The domain in the SMTP envelope's mail from header aligns with the domain in the message's from header         \t|\r\n\r\n\r\n# Further Reading\r\n[Demystifying DMARC: A guide to preventing email spoofing](https://seanthegeek.net/459/demystifying-dmarc/amp/)\r\n\r\n[DMARC Manual](https://menainfosec.com/wp-content/uploads/2017/12/DMARC_Service_Manual.pdf)\r\n\r\n[What is “External Destination Verification”?](https://dmarcian.com/what-is-external-destination-verification/)",
+          "content": "# DMARC Summary\r\nAs the name suggests, this dashboard is the best place to start reviewing your aggregate DMARC data.\r\n\r\nAcross the top of the dashboard, three pie charts display the percentage of alignment pass/fail for SPF, DKIM, and DMARC. Clicking on any chart segment will filter for that value.\r\n\r\n***Note***\r\nMessages should not be considered malicious just because they failed to pass DMARC; especially if you have just started collecting data. It may be a legitimate service that needs SPF and DKIM configured correctly.\r\n\r\nStart by filtering the results to only show failed DKIM alignment. While DMARC passes if a message passes SPF or DKIM alignment, only DKIM alignment remains valid when a message is forwarded without changing the from address, which is often caused by a mailbox forwarding rule. This is because DKIM signatures are part of the message headers, whereas SPF relies on SMTP session headers.\r\n\r\nUnderneath the pie charts. you can see graphs of DMARC passage and message disposition over time.\r\n\r\nUnder the graphs you will find the most useful data tables on the dashboard. On the left, there is a list of organizations that are sending you DMARC reports. In the center, there is a list of sending servers grouped by the base domain in their reverse DNS. On the right, there is a list of email from domains, sorted by message volume.\r\n\r\nBy hovering your mouse over a data table value and using the magnifying glass icons, you can filter on or filter out different values. Start by looking at the Message Sources by Reverse DNS table. Find a sender that you recognize, such as an email marketing service, hover over it, and click on the plus (+) magnifying glass icon, to add a filter that only shows results for that sender. Now, look at the Message From Header table to the right. That shows you the domains that a sender is sending as, which might tell you which brand/business is using a particular service. With that information, you can contact them and have them set up DKIM.\r\n\r\n***Note***\r\nIf you have a lot of B2C customers, you may see a high volume of emails as your domains coming from consumer email services, such as Google/Gmail and Yahoo! This occurs when customers have mailbox rules in place that forward emails from an old account to a new account, which is why DKIM authentication is so important, as mentioned earlier. Similar patterns may be observed with businesses who send from reverse DNS addressees of parent, subsidiary, and outdated brands.\r\n\r\n***Note***\r\nYou can add your own custom temporary filters by clicking on Add Filter at the upper right of the page.\r\n\r\n# DMARC Forensic Samples\r\nThe DMARC Forensic Samples section contains information on DMARC forensic reports (also known as failure reports or ruf reports). These reports contain samples of emails that have failed to pass DMARC.\r\n\r\n***Note***\r\nMost recipients do not send forensic/failure/ruf reports at all to avoid privacy leaks. Some recipients (notably Chinese webmail services) will only supply the headers of sample emails. Very few provide the entire email.\r\n\r\n# DMARC Alignment Guide\r\nDMARC ensures that SPF and DKIM authentication mechanisms actually authenticate against the same domain that the end user sees.\r\n\r\nA message passes a DMARC check by passing DKIM or SPF, **as long as the related indicators are also in alignment.**\r\n\r\n|           \t| DKIM                                                                                                                                             \t| SPF                                                                                                            \t|\r\n|-----------\t|--------------------------------------------------------------------------------------------------------------------------------------------------\t|----------------------------------------------------------------------------------------------------------------\t|\r\n| **Passing**   \t| The signature in the DKIM header is validated using a public key that is published as a DNS record of the domain name specified in the signature \t| The mail server's IP address is listed in the SPF record of the domain in the SMTP envelope's mail from header \t|\r\n| **Alignment** \t| The signing domain aligns with the domain in the message's from header                                                                           \t| The domain in the SMTP envelope's mail from header aligns with the domain in the message's from header         \t|\r\n\r\n\r\n# Further Reading\r\n[Demystifying DMARC: A guide to preventing email spoofing](https://seanthegeek.net/459/demystifying-dmarc/amp/)\r\n\r\n[DMARC Manual](https://menainfosec.com/wp-content/uploads/2017/12/DMARC_Service_Manual.pdf)\r\n\r\n[What is “External Destination Verification”?](https://dmarcian.com/what-is-external-destination-verification/)",
          "datasource": null,
          "fieldConfig": {
            "defaults": {
@@ -101,7 +101,7 @@
          "links": [],
          "mode": "markdown",
          "options": {
-            "content": "# DMARC Summary\r\nAs the name suggests, this dashboard is the best place to start reviewing your aggregate DMARC data.\r\n\r\nAcross the top of the dashboard, three pie charts display the percentage of alignment pass/fail for SPF, DKIM, and DMARC. Clicking on any chart segment will filter for that value.\r\n\r\n***Note***\r\nMessages should not be considered malicious just because they failed to pass DMARC; especially if you have just started collecting data. It may be a legitimate service that needs SPF and DKIM configured correctly.\r\n\r\nStart by filtering the results to only show failed DKIM alignment. While DMARC passes if a message passes SPF or DKIM alignment, only DKIM alignment remains valid when a message is forwarded without changing the from address, which is often caused by a mailbox forwarding rule. This is because DKIM signatures are part of the message headers, whereas SPF relies on SMTP session headers.\r\n\r\nUnderneath the pie charts. you can see graphs of DMARC passage and message disposition over time.\r\n\r\nUnder the graphs you will find the most useful data tables on the dashboard. On the left, there is a list of organizations that are sending you DMARC reports. In the center, there is a list of sending servers grouped by the base domain in their reverse DNS. On the right, there is a list of email from domains, sorted by message volume.\r\n\r\nBy hovering your mouse over a data table value and using the magnifying glass icons, you can filter on or filter out different values. Start by looking at the Message Sources by Reverse DNS table. Find a sender that you recognize, such as an email marketing service, hover over it, and click on the plus (+) magnifying glass icon, to add a filter that only shows results for that sender. Now, look at the Message From Header table to the right. That shows you the domains that a sender is sending as, which might tell you which brand/business is using a particular service. With that information, you can contact them and have them set up DKIM.\r\n\r\n***Note***\r\nIf you have a lot of B2C customers, you may see a high volume of emails as your domains coming from consumer email services, such as Google/Gmail and Yahoo! This occurs when customers have mailbox rules in place that forward emails from an old account to a new account, which is why DKIM authentication is so important, as mentioned earlier. Similar patterns may be observed with businesses who send from reverse DNS addressees of parent, subsidiary, and outdated brands.\r\n\r\n***Note***\r\nYou can add your own custom temporary filters by clicking on Add Filter at the upper right of the page.\r\n\r\n# DMARC Failure Samples\r\nThe DMARC Failure Samples section contains information on DMARC failure reports (also known as ruf reports). These reports contain samples of emails that have failed to pass DMARC.\r\n\r\n***Note***\r\nMost recipients do not send failure/ruf reports at all to avoid privacy leaks. Some recipients (notably Chinese webmail services) will only supply the headers of sample emails. Very few provide the entire email.\r\n\r\n# DMARC Alignment Guide\r\nDMARC ensures that SPF and DKIM authentication mechanisms actually authenticate against the same domain that the end user sees.\r\n\r\nA message passes a DMARC check by passing DKIM or SPF, **as long as the related indicators are also in alignment.**\r\n\r\n|           \t| DKIM                                                                                                                                             \t| SPF                                                                                                            \t|\r\n|-----------\t|--------------------------------------------------------------------------------------------------------------------------------------------------\t|----------------------------------------------------------------------------------------------------------------\t|\r\n| **Passing**   \t| The signature in the DKIM header is validated using a public key that is published as a DNS record of the domain name specified in the signature \t| The mail server's IP address is listed in the SPF record of the domain in the SMTP envelope's mail from header \t|\r\n| **Alignment** \t| The signing domain aligns with the domain in the message's from header                                                                           \t| The domain in the SMTP envelope's mail from header aligns with the domain in the message's from header         \t|\r\n\r\n\r\n# Further Reading\r\n[Demystifying DMARC: A guide to preventing email spoofing](https://seanthegeek.net/459/demystifying-dmarc/amp/)\r\n\r\n[DMARC Manual](https://menainfosec.com/wp-content/uploads/2017/12/DMARC_Service_Manual.pdf)\r\n\r\n[What is “External Destination Verification”?](https://dmarcian.com/what-is-external-destination-verification/)",
+            "content": "# DMARC Summary\r\nAs the name suggests, this dashboard is the best place to start reviewing your aggregate DMARC data.\r\n\r\nAcross the top of the dashboard, three pie charts display the percentage of alignment pass/fail for SPF, DKIM, and DMARC. Clicking on any chart segment will filter for that value.\r\n\r\n***Note***\r\nMessages should not be considered malicious just because they failed to pass DMARC; especially if you have just started collecting data. It may be a legitimate service that needs SPF and DKIM configured correctly.\r\n\r\nStart by filtering the results to only show failed DKIM alignment. While DMARC passes if a message passes SPF or DKIM alignment, only DKIM alignment remains valid when a message is forwarded without changing the from address, which is often caused by a mailbox forwarding rule. This is because DKIM signatures are part of the message headers, whereas SPF relies on SMTP session headers.\r\n\r\nUnderneath the pie charts. you can see graphs of DMARC passage and message disposition over time.\r\n\r\nUnder the graphs you will find the most useful data tables on the dashboard. On the left, there is a list of organizations that are sending you DMARC reports. In the center, there is a list of sending servers grouped by the base domain in their reverse DNS. On the right, there is a list of email from domains, sorted by message volume.\r\n\r\nBy hovering your mouse over a data table value and using the magnifying glass icons, you can filter on or filter out different values. Start by looking at the Message Sources by Reverse DNS table. Find a sender that you recognize, such as an email marketing service, hover over it, and click on the plus (+) magnifying glass icon, to add a filter that only shows results for that sender. Now, look at the Message From Header table to the right. That shows you the domains that a sender is sending as, which might tell you which brand/business is using a particular service. With that information, you can contact them and have them set up DKIM.\r\n\r\n***Note***\r\nIf you have a lot of B2C customers, you may see a high volume of emails as your domains coming from consumer email services, such as Google/Gmail and Yahoo! This occurs when customers have mailbox rules in place that forward emails from an old account to a new account, which is why DKIM authentication is so important, as mentioned earlier. Similar patterns may be observed with businesses who send from reverse DNS addressees of parent, subsidiary, and outdated brands.\r\n\r\n***Note***\r\nYou can add your own custom temporary filters by clicking on Add Filter at the upper right of the page.\r\n\r\n# DMARC Forensic Samples\r\nThe DMARC Forensic Samples section contains information on DMARC forensic reports (also known as failure reports or ruf reports). These reports contain samples of emails that have failed to pass DMARC.\r\n\r\n***Note***\r\nMost recipients do not send forensic/failure/ruf reports at all to avoid privacy leaks. Some recipients (notably Chinese webmail services) will only supply the headers of sample emails. Very few provide the entire email.\r\n\r\n# DMARC Alignment Guide\r\nDMARC ensures that SPF and DKIM authentication mechanisms actually authenticate against the same domain that the end user sees.\r\n\r\nA message passes a DMARC check by passing DKIM or SPF, **as long as the related indicators are also in alignment.**\r\n\r\n|           \t| DKIM                                                                                                                                             \t| SPF                                                                                                            \t|\r\n|-----------\t|--------------------------------------------------------------------------------------------------------------------------------------------------\t|----------------------------------------------------------------------------------------------------------------\t|\r\n| **Passing**   \t| The signature in the DKIM header is validated using a public key that is published as a DNS record of the domain name specified in the signature \t| The mail server's IP address is listed in the SPF record of the domain in the SMTP envelope's mail from header \t|\r\n| **Alignment** \t| The signing domain aligns with the domain in the message's from header                                                                           \t| The domain in the SMTP envelope's mail from header aligns with the domain in the message's from header         \t|\r\n\r\n\r\n# Further Reading\r\n[Demystifying DMARC: A guide to preventing email spoofing](https://seanthegeek.net/459/demystifying-dmarc/amp/)\r\n\r\n[DMARC Manual](https://menainfosec.com/wp-content/uploads/2017/12/DMARC_Service_Manual.pdf)\r\n\r\n[What is “External Destination Verification”?](https://dmarcian.com/what-is-external-destination-verification/)",
            "mode": "markdown"
          },
          "pluginVersion": "7.1.0",
--- a/kibana/export.ndjson
+++ b/kibana/export.ndjson
--- a/parsedmarc/init.py
+++ b/parsedmarc/init.py
--- a/parsedmarc/cli.py
+++ b/parsedmarc/cli.py
--- a/parsedmarc/constants.py
+++ b/parsedmarc/constants.py
@@ -1,3 +1,3 @@
-__version__ = "9.1.0"
+__version__ = "9.0.5"

 USER_AGENT = f"parsedmarc/{__version__}"
--- a/parsedmarc/elastic.py
+++ b/parsedmarc/elastic.py
@@ -2,29 +2,29 @@

 from __future__ import annotations

-from typing import Any, Optional, Union
+from typing import Optional, Union, Any

-from elasticsearch.helpers import reindex
+
+from elasticsearch_dsl.search import Q
 from elasticsearch_dsl import (
-    Boolean,
-    Date,
+    connections,
+    Object,
    Document,
    Index,
+    Nested,
    InnerDoc,
    Integer,
-    Ip,
-    Keyword,
-    Nested,
-    Object,
-    Search,
    Text,
-    connections,
+    Boolean,
+    Ip,
+    Date,
+    Search,
 )
-from elasticsearch_dsl.search import Q
+from elasticsearch.helpers import reindex

-from parsedmarc import InvalidFailureReport
 from parsedmarc.log import logger
 from parsedmarc.utils import human_timestamp_to_datetime
+from parsedmarc import InvalidForensicReport


 class ElasticsearchError(Exception):
@@ -44,23 +44,18 @@ class _PublishedPolicy(InnerDoc):
    sp = Text()
    pct = Integer()
    fo = Text()
-    np = Keyword()
-    testing = Keyword()
-    discovery_method = Keyword()


 class _DKIMResult(InnerDoc):
    domain = Text()
    selector = Text()
    result = Text()
-    human_result = Text()


 class _SPFResult(InnerDoc):
    domain = Text()
    scope = Text()
    results = Text()
-    human_result = Text()


 class _AggregateReportDoc(Document):
@@ -96,37 +91,19 @@ class _AggregateReportDoc(Document):
    envelope_to = Text()
    dkim_results = Nested(_DKIMResult)
    spf_results = Nested(_SPFResult)
-    np = Keyword()
-    testing = Keyword()
-    discovery_method = Keyword()
-    generator = Text()

    def add_policy_override(self, type_: str, comment: str):
-        self.policy_overrides.append(_PolicyOverride(type=type_, comment=comment))  # pyright: ignore[reportCallIssue]
+        self.policy_overrides.append(_PolicyOverride(type=type_, comment=comment))

-    def add_dkim_result(
-        self, domain: str, selector: str, result: _DKIMResult,
-        human_result: str = None,
-    ):
+    def add_dkim_result(self, domain: str, selector: str, result: _DKIMResult):
        self.dkim_results.append(
-            _DKIMResult(
-                domain=domain, selector=selector, result=result,
-                human_result=human_result,
-            )
-        )  # pyright: ignore[reportCallIssue]
+            _DKIMResult(domain=domain, selector=selector, result=result)
+        )

-    def add_spf_result(
-        self, domain: str, scope: str, result: _SPFResult,
-        human_result: str = None,
-    ):
-        self.spf_results.append(
-            _SPFResult(
-                domain=domain, scope=scope, result=result,
-                human_result=human_result,
-            )
-        )  # pyright: ignore[reportCallIssue]
+    def add_spf_result(self, domain: str, scope: str, result: _SPFResult):
+        self.spf_results.append(_SPFResult(domain=domain, scope=scope, result=result))

-    def save(self, **kwargs):  # pyright: ignore[reportIncompatibleMethodOverride]
+    def save(self, **kwargs):
        self.passed_dmarc = False
        self.passed_dmarc = self.spf_aligned or self.dkim_aligned

@@ -144,7 +121,7 @@ class _EmailAttachmentDoc(Document):
    sha256 = Text()


-class _FailureSampleDoc(InnerDoc):
+class _ForensicSampleDoc(InnerDoc):
    raw = Text()
    headers = Object()
    headers_only = Boolean()
@@ -160,30 +137,30 @@ class _FailureSampleDoc(InnerDoc):
    attachments = Nested(_EmailAttachmentDoc)

    def add_to(self, display_name: str, address: str):
-        self.to.append(_EmailAddressDoc(display_name=display_name, address=address))  # pyright: ignore[reportCallIssue]
+        self.to.append(_EmailAddressDoc(display_name=display_name, address=address))

    def add_reply_to(self, display_name: str, address: str):
        self.reply_to.append(
            _EmailAddressDoc(display_name=display_name, address=address)
-        )  # pyright: ignore[reportCallIssue]
+        )

    def add_cc(self, display_name: str, address: str):
-        self.cc.append(_EmailAddressDoc(display_name=display_name, address=address))  # pyright: ignore[reportCallIssue]
+        self.cc.append(_EmailAddressDoc(display_name=display_name, address=address))

    def add_bcc(self, display_name: str, address: str):
-        self.bcc.append(_EmailAddressDoc(display_name=display_name, address=address))  # pyright: ignore[reportCallIssue]
+        self.bcc.append(_EmailAddressDoc(display_name=display_name, address=address))

    def add_attachment(self, filename: str, content_type: str, sha256: str):
        self.attachments.append(
            _EmailAttachmentDoc(
                filename=filename, content_type=content_type, sha256=sha256
            )
-        )  # pyright: ignore[reportCallIssue]
+        )


-class _FailureReportDoc(Document):
+class _ForensicReportDoc(Document):
    class Index:
-        name = "dmarc_failure"
+        name = "dmarc_forensic"

    feedback_type = Text()
    user_agent = Text()
@@ -201,7 +178,7 @@ class _FailureReportDoc(Document):
    source_auth_failures = Text()
    dkim_domain = Text()
    original_rcpt_to = Text()
-    sample = Object(_FailureSampleDoc)
+    sample = Object(_ForensicSampleDoc)


 class _SMTPTLSFailureDetailsDoc(InnerDoc):
@@ -246,7 +223,7 @@ class _SMTPTLSPolicyDoc(InnerDoc):
            additional_information=additional_information_uri,
            failure_reason_code=failure_reason_code,
        )
-        self.failure_details.append(_details)  # pyright: ignore[reportCallIssue]
+        self.failure_details.append(_details)


 class _SMTPTLSReportDoc(Document):
@@ -280,7 +257,7 @@ class _SMTPTLSReportDoc(Document):
            policy_string=policy_string,
            mx_host_patterns=mx_host_patterns,
            failure_details=failure_details,
-        )  # pyright: ignore[reportCallIssue]
+        )


 class AlreadySaved(ValueError):
@@ -290,18 +267,18 @@ class AlreadySaved(ValueError):
 def set_hosts(
    hosts: Union[str, list[str]],
    *,
-    use_ssl: bool = False,
+    use_ssl: Optional[bool] = False,
    ssl_cert_path: Optional[str] = None,
    username: Optional[str] = None,
    password: Optional[str] = None,
    api_key: Optional[str] = None,
-    timeout: float = 60.0,
+    timeout: Optional[float] = 60.0,
 ):
    """
    Sets the Elasticsearch hosts to use

    Args:
-        hosts (str | list[str]): A single hostname or URL, or list of hostnames or URLs
+        hosts (Union[str, list[str]]): A single hostname or URL, or list of hostnames or URLs
        use_ssl (bool): Use an HTTPS connection to the server
        ssl_cert_path (str): Path to the certificate chain
        username (str): The username to use for authentication
@@ -351,20 +328,20 @@ def create_indexes(names: list[str], settings: Optional[dict[str, Any]] = None):

 def migrate_indexes(
    aggregate_indexes: Optional[list[str]] = None,
-    failure_indexes: Optional[list[str]] = None,
+    forensic_indexes: Optional[list[str]] = None,
 ):
    """
    Updates index mappings

    Args:
        aggregate_indexes (list): A list of aggregate index names
-        failure_indexes (list): A list of failure index names
+        forensic_indexes (list): A list of forensic index names
    """
    version = 2
    if aggregate_indexes is None:
        aggregate_indexes = []
-    if failure_indexes is None:
-        failure_indexes = []
+    if forensic_indexes is None:
+        forensic_indexes = []
    for aggregate_index_name in aggregate_indexes:
        if not Index(aggregate_index_name).exists():
            continue
@@ -391,10 +368,10 @@ def migrate_indexes(
            }
            Index(new_index_name).create()
            Index(new_index_name).put_mapping(doc_type=doc, body=body)
-            reindex(connections.get_connection(), aggregate_index_name, new_index_name)  # pyright: ignore[reportArgumentType]
+            reindex(connections.get_connection(), aggregate_index_name, new_index_name)
            Index(aggregate_index_name).delete()

-    for failure_index in failure_indexes:
+    for forensic_index in forensic_indexes:
        pass


@@ -403,14 +380,14 @@ def save_aggregate_report_to_elasticsearch(
    index_suffix: Optional[str] = None,
    index_prefix: Optional[str] = None,
    monthly_indexes: Optional[bool] = False,
-    number_of_shards: int = 1,
-    number_of_replicas: int = 0,
+    number_of_shards: Optional[int] = 1,
+    number_of_replicas: Optional[int] = 0,
 ):
    """
    Saves a parsed DMARC aggregate report to Elasticsearch

    Args:
-        aggregate_report (dict): A parsed aggregate report
+        aggregate_report (dict): A parsed forensic report
        index_suffix (str): The suffix of the name of the index to save to
        index_prefix (str): The prefix of the name of the index to save to
        monthly_indexes (bool): Use monthly indexes instead of daily indexes
@@ -434,11 +411,11 @@ def save_aggregate_report_to_elasticsearch(
    else:
        index_date = begin_date.strftime("%Y-%m-%d")

-    org_name_query = Q(dict(match_phrase=dict(org_name=org_name)))  # type: ignore
-    report_id_query = Q(dict(match_phrase=dict(report_id=report_id)))  # pyright: ignore[reportArgumentType]
-    domain_query = Q(dict(match_phrase={"published_policy.domain": domain}))  # pyright: ignore[reportArgumentType]
-    begin_date_query = Q(dict(match=dict(date_begin=begin_date)))  # pyright: ignore[reportArgumentType]
-    end_date_query = Q(dict(match=dict(date_end=end_date)))  # pyright: ignore[reportArgumentType]
+    org_name_query = Q(dict(match_phrase=dict(org_name=org_name)))
+    report_id_query = Q(dict(match_phrase=dict(report_id=report_id)))
+    domain_query = Q(dict(match_phrase={"published_policy.domain": domain}))
+    begin_date_query = Q(dict(match=dict(date_begin=begin_date)))
+    end_date_query = Q(dict(match=dict(date_end=end_date)))

    if index_suffix is not None:
        search_index = "dmarc_aggregate_{0}*".format(index_suffix)
@@ -450,12 +427,13 @@ def save_aggregate_report_to_elasticsearch(
    query = org_name_query & report_id_query & domain_query
    query = query & begin_date_query & end_date_query
    search.query = query
-    begin_date_human = begin_date.strftime("%Y-%m-%d %H:%M:%SZ")
-    end_date_human = end_date.strftime("%Y-%m-%d %H:%M:%SZ")

    try:
        existing = search.execute()
    except Exception as error_:
+        begin_date_human = begin_date.strftime("%Y-%m-%d %H:%M:%SZ")
+        end_date_human = end_date.strftime("%Y-%m-%d %H:%M:%SZ")
+
        raise ElasticsearchError(
            "Elasticsearch's search for existing report \
            error: {}".format(error_.__str__())
@@ -478,11 +456,6 @@ def save_aggregate_report_to_elasticsearch(
        sp=aggregate_report["policy_published"]["sp"],
        pct=aggregate_report["policy_published"]["pct"],
        fo=aggregate_report["policy_published"]["fo"],
-        np=aggregate_report["policy_published"].get("np"),
-        testing=aggregate_report["policy_published"].get("testing"),
-        discovery_method=aggregate_report["policy_published"].get(
-            "discovery_method"
-        ),
    )

    for record in aggregate_report["records"]:
@@ -524,12 +497,6 @@ def save_aggregate_report_to_elasticsearch(
            header_from=record["identifiers"]["header_from"],
            envelope_from=record["identifiers"]["envelope_from"],
            envelope_to=record["identifiers"]["envelope_to"],
-            np=aggregate_report["policy_published"].get("np"),
-            testing=aggregate_report["policy_published"].get("testing"),
-            discovery_method=aggregate_report["policy_published"].get(
-                "discovery_method"
-            ),
-            generator=metadata.get("generator"),
        )

        for override in record["policy_evaluated"]["policy_override_reasons"]:
@@ -542,7 +509,6 @@ def save_aggregate_report_to_elasticsearch(
                domain=dkim_result["domain"],
                selector=dkim_result["selector"],
                result=dkim_result["result"],
-                human_result=dkim_result.get("human_result"),
            )

        for spf_result in record["auth_results"]["spf"]:
@@ -550,7 +516,6 @@ def save_aggregate_report_to_elasticsearch(
                domain=spf_result["domain"],
                scope=spf_result["scope"],
                result=spf_result["result"],
-                human_result=spf_result.get("human_result"),
            )

        index = "dmarc_aggregate"
@@ -564,7 +529,7 @@ def save_aggregate_report_to_elasticsearch(
            number_of_shards=number_of_shards, number_of_replicas=number_of_replicas
        )
        create_indexes([index], index_settings)
-        agg_doc.meta.index = index  # pyright: ignore[reportOptionalMemberAccess, reportAttributeAccessIssue]
+        agg_doc.meta.index = index

        try:
            agg_doc.save()
@@ -572,8 +537,8 @@ def save_aggregate_report_to_elasticsearch(
            raise ElasticsearchError("Elasticsearch error: {0}".format(e.__str__()))


-def save_failure_report_to_elasticsearch(
-    failure_report: dict[str, Any],
+def save_forensic_report_to_elasticsearch(
+    forensic_report: dict[str, Any],
    index_suffix: Optional[Any] = None,
    index_prefix: Optional[str] = None,
    monthly_indexes: Optional[bool] = False,
@@ -581,10 +546,10 @@ def save_failure_report_to_elasticsearch(
    number_of_replicas: int = 0,
 ):
    """
-    Saves a parsed DMARC failure report to Elasticsearch
+    Saves a parsed DMARC forensic report to Elasticsearch

    Args:
-        failure_report (dict): A parsed failure report
+        forensic_report (dict): A parsed forensic report
        index_suffix (str): The suffix of the name of the index to save to
        index_prefix (str): The prefix of the name of the index to save to
        monthly_indexes (bool): Use monthly indexes instead of daily
@@ -597,33 +562,28 @@ def save_failure_report_to_elasticsearch(
        AlreadySaved

    """
-    logger.info("Saving failure report to Elasticsearch")
-    failure_report = failure_report.copy()
+    logger.info("Saving forensic report to Elasticsearch")
+    forensic_report = forensic_report.copy()
    sample_date = None
-    if failure_report["parsed_sample"]["date"] is not None:
-        sample_date = failure_report["parsed_sample"]["date"]
+    if forensic_report["parsed_sample"]["date"] is not None:
+        sample_date = forensic_report["parsed_sample"]["date"]
        sample_date = human_timestamp_to_datetime(sample_date)
-    original_headers = failure_report["parsed_sample"]["headers"]
-    headers: dict[str, Any] = {}
+    original_headers = forensic_report["parsed_sample"]["headers"]
+    headers = dict()
    for original_header in original_headers:
        headers[original_header.lower()] = original_headers[original_header]

-    arrival_date = human_timestamp_to_datetime(failure_report["arrival_date_utc"])
+    arrival_date = human_timestamp_to_datetime(forensic_report["arrival_date_utc"])
    arrival_date_epoch_milliseconds = int(arrival_date.timestamp() * 1000)

    if index_suffix is not None:
-        search_index = "dmarc_failure_{0}*,dmarc_forensic_{0}*".format(
-            index_suffix
-        )
+        search_index = "dmarc_forensic_{0}*".format(index_suffix)
    else:
-        search_index = "dmarc_failure*,dmarc_forensic*"
+        search_index = "dmarc_forensic*"
    if index_prefix is not None:
-        search_index = ",".join(
-            "{0}{1}".format(index_prefix, part)
-            for part in search_index.split(",")
-        )
+        search_index = "{0}{1}".format(index_prefix, search_index)
    search = Search(index=search_index)
-    q = Q(dict(match=dict(arrival_date=arrival_date_epoch_milliseconds)))  # pyright: ignore[reportArgumentType]
+    q = Q(dict(match=dict(arrival_date=arrival_date_epoch_milliseconds)))

    from_ = None
    to_ = None
@@ -638,7 +598,7 @@ def save_failure_report_to_elasticsearch(

        from_ = dict()
        from_["sample.headers.from"] = headers["from"]
-        from_query = Q(dict(match_phrase=from_))  # pyright: ignore[reportArgumentType]
+        from_query = Q(dict(match_phrase=from_))
        q = q & from_query
    if "to" in headers:
        # We convert the TO header from a string list to a flat string.
@@ -650,76 +610,76 @@ def save_failure_report_to_elasticsearch(

        to_ = dict()
        to_["sample.headers.to"] = headers["to"]
-        to_query = Q(dict(match_phrase=to_))  # pyright: ignore[reportArgumentType]
+        to_query = Q(dict(match_phrase=to_))
        q = q & to_query
    if "subject" in headers:
        subject = headers["subject"]
        subject_query = {"match_phrase": {"sample.headers.subject": subject}}
-        q = q & Q(subject_query)  # pyright: ignore[reportArgumentType]
+        q = q & Q(subject_query)

    search.query = q
    existing = search.execute()

    if len(existing) > 0:
        raise AlreadySaved(
-            "A failure sample to {0} from {1} "
+            "A forensic sample to {0} from {1} "
            "with a subject of {2} and arrival date of {3} "
            "already exists in "
            "Elasticsearch".format(
-                to_, from_, subject, failure_report["arrival_date_utc"]
+                to_, from_, subject, forensic_report["arrival_date_utc"]
            )
        )

-    parsed_sample = failure_report["parsed_sample"]
-    sample = _FailureSampleDoc(
-        raw=failure_report["sample"],
+    parsed_sample = forensic_report["parsed_sample"]
+    sample = _ForensicSampleDoc(
+        raw=forensic_report["sample"],
        headers=headers,
-        headers_only=failure_report["sample_headers_only"],
+        headers_only=forensic_report["sample_headers_only"],
        date=sample_date,
-        subject=failure_report["parsed_sample"]["subject"],
+        subject=forensic_report["parsed_sample"]["subject"],
        filename_safe_subject=parsed_sample["filename_safe_subject"],
-        body=failure_report["parsed_sample"]["body"],
+        body=forensic_report["parsed_sample"]["body"],
    )

-    for address in failure_report["parsed_sample"]["to"]:
+    for address in forensic_report["parsed_sample"]["to"]:
        sample.add_to(display_name=address["display_name"], address=address["address"])
-    for address in failure_report["parsed_sample"]["reply_to"]:
+    for address in forensic_report["parsed_sample"]["reply_to"]:
        sample.add_reply_to(
            display_name=address["display_name"], address=address["address"]
        )
-    for address in failure_report["parsed_sample"]["cc"]:
+    for address in forensic_report["parsed_sample"]["cc"]:
        sample.add_cc(display_name=address["display_name"], address=address["address"])
-    for address in failure_report["parsed_sample"]["bcc"]:
+    for address in forensic_report["parsed_sample"]["bcc"]:
        sample.add_bcc(display_name=address["display_name"], address=address["address"])
-    for attachment in failure_report["parsed_sample"]["attachments"]:
+    for attachment in forensic_report["parsed_sample"]["attachments"]:
        sample.add_attachment(
            filename=attachment["filename"],
            content_type=attachment["mail_content_type"],
            sha256=attachment["sha256"],
        )
    try:
-        failure_doc = _FailureReportDoc(
-            feedback_type=failure_report["feedback_type"],
-            user_agent=failure_report["user_agent"],
-            version=failure_report["version"],
-            original_mail_from=failure_report["original_mail_from"],
+        forensic_doc = _ForensicReportDoc(
+            feedback_type=forensic_report["feedback_type"],
+            user_agent=forensic_report["user_agent"],
+            version=forensic_report["version"],
+            original_mail_from=forensic_report["original_mail_from"],
            arrival_date=arrival_date_epoch_milliseconds,
-            domain=failure_report["reported_domain"],
-            original_envelope_id=failure_report["original_envelope_id"],
-            authentication_results=failure_report["authentication_results"],
-            delivery_results=failure_report["delivery_result"],
-            source_ip_address=failure_report["source"]["ip_address"],
-            source_country=failure_report["source"]["country"],
-            source_reverse_dns=failure_report["source"]["reverse_dns"],
-            source_base_domain=failure_report["source"]["base_domain"],
-            authentication_mechanisms=failure_report["authentication_mechanisms"],
-            auth_failure=failure_report["auth_failure"],
-            dkim_domain=failure_report["dkim_domain"],
-            original_rcpt_to=failure_report["original_rcpt_to"],
+            domain=forensic_report["reported_domain"],
+            original_envelope_id=forensic_report["original_envelope_id"],
+            authentication_results=forensic_report["authentication_results"],
+            delivery_results=forensic_report["delivery_result"],
+            source_ip_address=forensic_report["source"]["ip_address"],
+            source_country=forensic_report["source"]["country"],
+            source_reverse_dns=forensic_report["source"]["reverse_dns"],
+            source_base_domain=forensic_report["source"]["base_domain"],
+            authentication_mechanisms=forensic_report["authentication_mechanisms"],
+            auth_failure=forensic_report["auth_failure"],
+            dkim_domain=forensic_report["dkim_domain"],
+            original_rcpt_to=forensic_report["original_rcpt_to"],
            sample=sample,
        )

-        index = "dmarc_failure"
+        index = "dmarc_forensic"
        if index_suffix:
            index = "{0}_{1}".format(index, index_suffix)
        if index_prefix:
@@ -733,14 +693,14 @@ def save_failure_report_to_elasticsearch(
            number_of_shards=number_of_shards, number_of_replicas=number_of_replicas
        )
        create_indexes([index], index_settings)
-        failure_doc.meta.index = index  # pyright: ignore[reportAttributeAccessIssue, reportOptionalMemberAccess]
+        forensic_doc.meta.index = index
        try:
-            failure_doc.save()
+            forensic_doc.save()
        except Exception as e:
            raise ElasticsearchError("Elasticsearch error: {0}".format(e.__str__()))
    except KeyError as e:
-        raise InvalidFailureReport(
-            "Failure report missing required field: {0}".format(e.__str__())
+        raise InvalidForensicReport(
+            "Forensic report missing required field: {0}".format(e.__str__())
        )


@@ -748,9 +708,9 @@ def save_smtp_tls_report_to_elasticsearch(
    report: dict[str, Any],
    index_suffix: Optional[str] = None,
    index_prefix: Optional[str] = None,
-    monthly_indexes: bool = False,
-    number_of_shards: int = 1,
-    number_of_replicas: int = 0,
+    monthly_indexes: Optional[bool] = False,
+    number_of_shards: Optional[int] = 1,
+    number_of_replicas: Optional[int] = 0,
 ):
    """
    Saves a parsed SMTP TLS report to Elasticsearch
@@ -780,10 +740,10 @@ def save_smtp_tls_report_to_elasticsearch(
    report["begin_date"] = begin_date
    report["end_date"] = end_date

-    org_name_query = Q(dict(match_phrase=dict(org_name=org_name)))  # pyright: ignore[reportArgumentType]
-    report_id_query = Q(dict(match_phrase=dict(report_id=report_id)))  # pyright: ignore[reportArgumentType]
-    begin_date_query = Q(dict(match=dict(date_begin=begin_date)))  # pyright: ignore[reportArgumentType]
-    end_date_query = Q(dict(match=dict(date_end=end_date)))  # pyright: ignore[reportArgumentType]
+    org_name_query = Q(dict(match_phrase=dict(org_name=org_name)))
+    report_id_query = Q(dict(match_phrase=dict(report_id=report_id)))
+    begin_date_query = Q(dict(match=dict(date_begin=begin_date)))
+    end_date_query = Q(dict(match=dict(date_end=end_date)))

    if index_suffix is not None:
        search_index = "smtp_tls_{0}*".format(index_suffix)
@@ -884,18 +844,12 @@ def save_smtp_tls_report_to_elasticsearch(
                    additional_information_uri=additional_information_uri,
                    failure_reason_code=failure_reason_code,
                )
-        smtp_tls_doc.policies.append(policy_doc)  # pyright: ignore[reportCallIssue]
+        smtp_tls_doc.policies.append(policy_doc)

    create_indexes([index], index_settings)
-    smtp_tls_doc.meta.index = index  # pyright: ignore[reportOptionalMemberAccess, reportAttributeAccessIssue]
+    smtp_tls_doc.meta.index = index

    try:
        smtp_tls_doc.save()
    except Exception as e:
        raise ElasticsearchError("Elasticsearch error: {0}".format(e.__str__()))
-
-
-# Backward-compatible aliases
-_ForensicSampleDoc = _FailureSampleDoc
-_ForensicReportDoc = _FailureReportDoc
-save_forensic_report_to_elasticsearch = save_failure_report_to_elasticsearch
--- a/parsedmarc/gelf.py
+++ b/parsedmarc/gelf.py
@@ -2,18 +2,20 @@

 from __future__ import annotations

-import logging
-import logging.handlers
-import threading
 from typing import Any

-from pygelf import GelfTcpHandler, GelfTlsHandler, GelfUdpHandler
+import logging
+import logging.handlers
+import json
+import threading

 from parsedmarc import (
    parsed_aggregate_reports_to_csv_rows,
-    parsed_failure_reports_to_csv_rows,
+    parsed_forensic_reports_to_csv_rows,
    parsed_smtp_tls_reports_to_csv_rows,
 )
+from pygelf import GelfTcpHandler, GelfUdpHandler, GelfTlsHandler
+

 log_context_data = threading.local()

@@ -50,7 +52,9 @@ class GelfClient(object):
        )
        self.logger.addHandler(self.handler)

-    def save_aggregate_report_to_gelf(self, aggregate_reports: list[dict[str, Any]]):
+    def save_aggregate_report_to_gelf(
+        self, aggregate_reports: list[dict[str, Any]]
+    ):
        rows = parsed_aggregate_reports_to_csv_rows(aggregate_reports)
        for row in rows:
            log_context_data.parsedmarc = row
@@ -58,18 +62,14 @@ class GelfClient(object):

        log_context_data.parsedmarc = None

-    def save_failure_report_to_gelf(self, failure_reports: list[dict[str, Any]]):
-        rows = parsed_failure_reports_to_csv_rows(failure_reports)
+    def save_forensic_report_to_gelf(
+        self, forensic_reports: list[dict[str, Any]]
+    ):
+        rows = parsed_forensic_reports_to_csv_rows(forensic_reports)
        for row in rows:
-            log_context_data.parsedmarc = row
-            self.logger.info("parsedmarc failure report")
+            self.logger.info(json.dumps(row))

    def save_smtp_tls_report_to_gelf(self, smtp_tls_reports: dict[str, Any]):
        rows = parsed_smtp_tls_reports_to_csv_rows(smtp_tls_reports)
        for row in rows:
-            log_context_data.parsedmarc = row
-            self.logger.info("parsedmarc smtptls report")
-
-
-# Backward-compatible aliases
-GelfClient.save_forensic_report_to_gelf = GelfClient.save_failure_report_to_gelf
+            self.logger.info(json.dumps(row))
--- a/parsedmarc/kafkaclient.py
+++ b/parsedmarc/kafkaclient.py
@@ -2,16 +2,18 @@

 from __future__ import annotations

-import json
-from ssl import SSLContext, create_default_context
 from typing import Any, Optional, Union
+from ssl import SSLContext
+
+import json
+from ssl import create_default_context

 from kafka import KafkaProducer
 from kafka.errors import NoBrokersAvailable, UnknownTopicOrPartitionError
+from parsedmarc.utils import human_timestamp_to_datetime

 from parsedmarc import __version__
 from parsedmarc.log import logger
-from parsedmarc.utils import human_timestamp_to_datetime


 class KafkaError(RuntimeError):
@@ -46,7 +48,7 @@ class KafkaClient(object):
            ``$ConnectionString``, and the password is the
            Azure Event Hub connection string.
        """
-        config: dict[str, Any] = dict(
+        config = dict(
            value_serializer=lambda v: json.dumps(v).encode("utf-8"),
            bootstrap_servers=kafka_hosts,
            client_id="parsedmarc-{0}".format(__version__),
@@ -139,31 +141,31 @@ class KafkaClient(object):
                except Exception as e:
                    raise KafkaError("Kafka error: {0}".format(e.__str__()))

-    def save_failure_reports_to_kafka(
+    def save_forensic_reports_to_kafka(
        self,
-        failure_reports: Union[dict[str, Any], list[dict[str, Any]]],
-        failure_topic: str,
+        forensic_reports: Union[dict[str, Any], list[dict[str, Any]]],
+        forensic_topic: str,
    ):
        """
-        Saves failure DMARC reports to Kafka, sends individual
+        Saves forensic DMARC reports to Kafka, sends individual
        records (slices) since Kafka requires messages to be <= 1MB
        by default.

        Args:
-            failure_reports (list):  A list of failure report dicts
+            forensic_reports (list):  A list of forensic report dicts
            to save to Kafka
-            failure_topic (str): The name of the Kafka topic
+            forensic_topic (str): The name of the Kafka topic

        """
-        if isinstance(failure_reports, dict):
-            failure_reports = [failure_reports]
+        if isinstance(forensic_reports, dict):
+            forensic_reports = [forensic_reports]

-        if len(failure_reports) < 1:
+        if len(forensic_reports) < 1:
            return

        try:
-            logger.debug("Saving failure reports to Kafka")
-            self.producer.send(failure_topic, failure_reports)
+            logger.debug("Saving forensic reports to Kafka")
+            self.producer.send(forensic_topic, forensic_reports)
        except UnknownTopicOrPartitionError:
            raise KafkaError("Kafka error: Unknown topic or partition on broker")
        except Exception as e:
@@ -184,7 +186,7 @@ class KafkaClient(object):
        by default.

        Args:
-            smtp_tls_reports (list):  A list of SMTP TLS report dicts
+            smtp_tls_reports (list):  A list of forensic report dicts
            to save to Kafka
            smtp_tls_topic (str): The name of the Kafka topic

@@ -196,7 +198,7 @@ class KafkaClient(object):
            return

        try:
-            logger.debug("Saving SMTP TLS reports to Kafka")
+            logger.debug("Saving forensic reports to Kafka")
            self.producer.send(smtp_tls_topic, smtp_tls_reports)
        except UnknownTopicOrPartitionError:
            raise KafkaError("Kafka error: Unknown topic or partition on broker")
@@ -206,7 +208,3 @@ class KafkaClient(object):
            self.producer.flush()
        except Exception as e:
            raise KafkaError("Kafka error: {0}".format(e.__str__()))
-
-
-# Backward-compatible aliases
-KafkaClient.save_forensic_reports_to_kafka = KafkaClient.save_failure_reports_to_kafka
--- a/parsedmarc/loganalytics.py
+++ b/parsedmarc/loganalytics.py
@@ -4,12 +4,11 @@ from __future__ import annotations

 from typing import Any

+from parsedmarc.log import logger
 from azure.core.exceptions import HttpResponseError
 from azure.identity import ClientSecretCredential
 from azure.monitor.ingestion import LogsIngestionClient

-from parsedmarc.log import logger
-

 class LogAnalyticsException(Exception):
    """Raised when an Elasticsearch error occurs"""
@@ -38,9 +37,9 @@ class LogAnalyticsConfig:
            The Stream name where
            the Aggregate DMARC reports
            need to be pushed.
-        dcr_failure_stream (str):
+        dcr_forensic_stream (str):
            The Stream name where
-            the Failure DMARC reports
+            the Forensic DMARC reports
            need to be pushed.
        dcr_smtp_tls_stream (str):
            The Stream name where
@@ -56,7 +55,7 @@ class LogAnalyticsConfig:
        dce: str,
        dcr_immutable_id: str,
        dcr_aggregate_stream: str,
-        dcr_failure_stream: str,
+        dcr_forensic_stream: str,
        dcr_smtp_tls_stream: str,
    ):
        self.client_id = client_id
@@ -65,7 +64,7 @@ class LogAnalyticsConfig:
        self.dce = dce
        self.dcr_immutable_id = dcr_immutable_id
        self.dcr_aggregate_stream = dcr_aggregate_stream
-        self.dcr_failure_stream = dcr_failure_stream
+        self.dcr_forensic_stream = dcr_forensic_stream
        self.dcr_smtp_tls_stream = dcr_smtp_tls_stream


@@ -84,7 +83,7 @@ class LogAnalyticsClient(object):
        dce: str,
        dcr_immutable_id: str,
        dcr_aggregate_stream: str,
-        dcr_failure_stream: str,
+        dcr_forensic_stream: str,
        dcr_smtp_tls_stream: str,
    ):
        self.conf = LogAnalyticsConfig(
@@ -94,7 +93,7 @@ class LogAnalyticsClient(object):
            dce=dce,
            dcr_immutable_id=dcr_immutable_id,
            dcr_aggregate_stream=dcr_aggregate_stream,
-            dcr_failure_stream=dcr_failure_stream,
+            dcr_forensic_stream=dcr_forensic_stream,
            dcr_smtp_tls_stream=dcr_smtp_tls_stream,
        )
        if (
@@ -133,9 +132,9 @@ class LogAnalyticsClient(object):

    def publish_results(
        self,
-        results: dict[str, Any],
+        results: dict[str, dict[str, Any]],
        save_aggregate: bool,
-        save_failure: bool,
+        save_forensic: bool,
        save_smtp_tls: bool,
    ):
        """
@@ -146,13 +145,13 @@ class LogAnalyticsClient(object):

        Args:
            results (list):
-                The DMARC reports (Aggregate & Failure)
+                The DMARC reports (Aggregate & Forensic)
            save_aggregate (bool):
                Whether Aggregate reports can be saved into Log Analytics
-            save_failure (bool):
-                Whether Failure reports can be saved into Log Analytics
+            save_forensic (bool):
+                Whether Forensic reports can be saved into Log Analytics
            save_smtp_tls (bool):
-                Whether Failure reports can be saved into Log Analytics
+                Whether Forensic reports can be saved into Log Analytics
        """
        conf = self.conf
        credential = ClientSecretCredential(
@@ -173,16 +172,16 @@ class LogAnalyticsClient(object):
            )
            logger.info("Successfully pushed aggregate reports.")
        if (
-            results["failure_reports"]
-            and conf.dcr_failure_stream
-            and len(results["failure_reports"]) > 0
-            and save_failure
+            results["forensic_reports"]
+            and conf.dcr_forensic_stream
+            and len(results["forensic_reports"]) > 0
+            and save_forensic
        ):
-            logger.info("Publishing failure reports.")
+            logger.info("Publishing forensic reports.")
            self.publish_json(
-                results["failure_reports"], logs_client, conf.dcr_failure_stream
+                results["forensic_reports"], logs_client, conf.dcr_forensic_stream
            )
-            logger.info("Successfully pushed failure reports.")
+            logger.info("Successfully pushed forensic reports.")
        if (
            results["smtp_tls_reports"]
            and conf.dcr_smtp_tls_stream
--- a/parsedmarc/mail/gmail.py
+++ b/parsedmarc/mail/gmail.py
@@ -116,14 +116,14 @@ class GmailConnection(MailboxConnection):
        else:
            return [id for id in self._fetch_all_message_ids(reports_label_id)]

-    def fetch_message(self, message_id) -> str:
+    def fetch_message(self, message_id):
        msg = (
            self.service.users()
            .messages()
            .get(userId="me", id=message_id, format="raw")
            .execute()
        )
-        return urlsafe_b64decode(msg["raw"]).decode(errors="replace")
+        return urlsafe_b64decode(msg["raw"])

    def delete_message(self, message_id: str):
        self.service.users().messages().delete(userId="me", id=message_id)
--- a/parsedmarc/mail/graph.py
+++ b/parsedmarc/mail/graph.py
@@ -6,7 +6,7 @@ from enum import Enum
 from functools import lru_cache
 from pathlib import Path
 from time import sleep
-from typing import Any, List, Optional, Union
+from typing import List, Optional

 from azure.identity import (
    UsernamePasswordCredential,
@@ -28,7 +28,7 @@ class AuthMethod(Enum):


 def _get_cache_args(token_path: Path, allow_unencrypted_storage):
-    cache_args: dict[str, Any] = {
+    cache_args = {
        "cache_persistence_options": TokenCachePersistenceOptions(
            name="parsedmarc", allow_unencrypted_storage=allow_unencrypted_storage
        )
@@ -151,9 +151,9 @@ class MSGraphConnection(MailboxConnection):
        else:
            logger.warning(f"Unknown response {resp.status_code} {resp.json()}")

-    def fetch_messages(self, reports_folder: str, **kwargs) -> List[str]:
+    def fetch_messages(self, folder_name: str, **kwargs) -> List[str]:
        """Returns a list of message UIDs in the specified folder"""
-        folder_id = self._find_folder_id_from_folder_path(reports_folder)
+        folder_id = self._find_folder_id_from_folder_path(folder_name)
        url = f"/users/{self.mailbox_name}/mailFolders/{folder_id}/messages"
        since = kwargs.get("since")
        if not since:
@@ -166,7 +166,7 @@ class MSGraphConnection(MailboxConnection):

    def _get_all_messages(self, url, batch_size, since):
        messages: list
-        params: dict[str, Union[str, int]] = {"$select": "id"}
+        params = {"$select": "id"}
        if since:
            params["$filter"] = f"receivedDateTime ge {since}"
        if batch_size and batch_size > 0:
--- a/parsedmarc/mail/imap.py
+++ b/parsedmarc/mail/imap.py
@@ -2,7 +2,7 @@

 from __future__ import annotations

-from typing import cast
+from typing import Optional

 from time import sleep

@@ -17,14 +17,15 @@ from parsedmarc.mail.mailbox_connection import MailboxConnection
 class IMAPConnection(MailboxConnection):
    def __init__(
        self,
-        host: str,
-        user: str,
-        password: str,
-        port: int = 993,
-        ssl: bool = True,
-        verify: bool = True,
-        timeout: int = 30,
-        max_retries: int = 4,
+        host: Optional[str] = None,
+        *,
+        user: Optional[str] = None,
+        password: Optional[str] = None,
+        port: Optional[str] = None,
+        ssl: Optional[bool] = True,
+        verify: Optional[bool] = True,
+        timeout: Optional[int] = 30,
+        max_retries: Optional[int] = 4,
    ):
        self._username = user
        self._password = password
@@ -46,13 +47,13 @@ class IMAPConnection(MailboxConnection):
    def fetch_messages(self, reports_folder: str, **kwargs):
        self._client.select_folder(reports_folder)
        since = kwargs.get("since")
-        if since is not None:
-            return self._client.search(f"SINCE {since}")
+        if since:
+            return self._client.search(["SINCE", since])
        else:
            return self._client.search()

    def fetch_message(self, message_id: int):
-        return cast(str, self._client.fetch_message(message_id, parse=False))
+        return self._client.fetch_message(message_id, parse=False)

    def delete_message(self, message_id: int):
        self._client.delete_messages([message_id])
--- a/parsedmarc/mail/mailbox_connection.py
+++ b/parsedmarc/mail/mailbox_connection.py
@@ -13,16 +13,16 @@ class MailboxConnection(ABC):
    def create_folder(self, folder_name: str):
        raise NotImplementedError

-    def fetch_messages(self, reports_folder: str, **kwargs):
+    def fetch_messages(self, reports_folder: str, **kwargs) -> list[str]:
        raise NotImplementedError

    def fetch_message(self, message_id) -> str:
        raise NotImplementedError

-    def delete_message(self, message_id):
+    def delete_message(self, message_id: str):
        raise NotImplementedError

-    def move_message(self, message_id, folder_name: str):
+    def move_message(self, message_id: str, folder_name: str):
        raise NotImplementedError

    def keepalive(self):
--- a/parsedmarc/mail/maildir.py
+++ b/parsedmarc/mail/maildir.py
@@ -2,20 +2,21 @@

 from __future__ import annotations

-import mailbox
-import os
+from typing import Optional
+
 from time import sleep
-from typing import Dict

 from parsedmarc.log import logger
 from parsedmarc.mail.mailbox_connection import MailboxConnection
+import mailbox
+import os


 class MaildirConnection(MailboxConnection):
    def __init__(
        self,
-        maildir_path: str,
-        maildir_create: bool = False,
+        maildir_path: Optional[bool] = None,
+        maildir_create: Optional[bool] = False,
    ):
        self._maildir_path = maildir_path
        self._maildir_create = maildir_create
@@ -32,31 +33,27 @@ class MaildirConnection(MailboxConnection):
                )
                raise Exception(ex)
        self._client = mailbox.Maildir(maildir_path, create=maildir_create)
-        self._subfolder_client: Dict[str, mailbox.Maildir] = {}
+        self._subfolder_client = {}

    def create_folder(self, folder_name: str):
        self._subfolder_client[folder_name] = self._client.add_folder(folder_name)
+        self._client.add_folder(folder_name)

    def fetch_messages(self, reports_folder: str, **kwargs):
        return self._client.keys()

-    def fetch_message(self, message_id: str) -> str:
-        msg = self._client.get(message_id)
-        if msg is not None:
-            msg = msg.as_string()
-            if msg is not None:
-                return msg
-        return ""
+    def fetch_message(self, message_id: str):
+        return self._client.get(message_id).as_string()

    def delete_message(self, message_id: str):
        self._client.remove(message_id)

    def move_message(self, message_id: str, folder_name: str):
        message_data = self._client.get(message_id)
-        if message_data is None:
-            return
-        if folder_name not in self._subfolder_client:
-            self._subfolder_client[folder_name] = self._client.add_folder(folder_name)
+        if folder_name not in self._subfolder_client.keys():
+            self._subfolder_client = mailbox.Maildir(
+                os.join(self.maildir_path, folder_name), create=self.maildir_create
+            )
        self._subfolder_client[folder_name].add(message_data)
        self._client.remove(message_id)

--- a/parsedmarc/opensearch.py
+++ b/parsedmarc/opensearch.py
@@ -2,29 +2,29 @@

 from __future__ import annotations

-from typing import Any, Optional, Union
+from typing import Optional, Union, Any
+

 from opensearchpy import (
-    Boolean,
-    Date,
+    Q,
+    connections,
+    Object,
    Document,
    Index,
+    Nested,
    InnerDoc,
    Integer,
-    Ip,
-    Keyword,
-    Nested,
-    Object,
-    Q,
-    Search,
    Text,
-    connections,
+    Boolean,
+    Ip,
+    Date,
+    Search,
 )
 from opensearchpy.helpers import reindex

-from parsedmarc import InvalidFailureReport
 from parsedmarc.log import logger
 from parsedmarc.utils import human_timestamp_to_datetime
+from parsedmarc import InvalidForensicReport


 class OpenSearchError(Exception):
@@ -44,23 +44,18 @@ class _PublishedPolicy(InnerDoc):
    sp = Text()
    pct = Integer()
    fo = Text()
-    np = Keyword()
-    testing = Keyword()
-    discovery_method = Keyword()


 class _DKIMResult(InnerDoc):
    domain = Text()
    selector = Text()
    result = Text()
-    human_result = Text()


 class _SPFResult(InnerDoc):
    domain = Text()
    scope = Text()
    results = Text()
-    human_result = Text()


 class _AggregateReportDoc(Document):
@@ -96,37 +91,19 @@ class _AggregateReportDoc(Document):
    envelope_to = Text()
    dkim_results = Nested(_DKIMResult)
    spf_results = Nested(_SPFResult)
-    np = Keyword()
-    testing = Keyword()
-    discovery_method = Keyword()
-    generator = Text()

    def add_policy_override(self, type_: str, comment: str):
        self.policy_overrides.append(_PolicyOverride(type=type_, comment=comment))

-    def add_dkim_result(
-        self, domain: str, selector: str, result: _DKIMResult,
-        human_result: str = None,
-    ):
+    def add_dkim_result(self, domain: str, selector: str, result: _DKIMResult):
        self.dkim_results.append(
-            _DKIMResult(
-                domain=domain, selector=selector, result=result,
-                human_result=human_result,
-            )
+            _DKIMResult(domain=domain, selector=selector, result=result)
        )

-    def add_spf_result(
-        self, domain: str, scope: str, result: _SPFResult,
-        human_result: str = None,
-    ):
-        self.spf_results.append(
-            _SPFResult(
-                domain=domain, scope=scope, result=result,
-                human_result=human_result,
-            )
-        )
+    def add_spf_result(self, domain: str, scope: str, result: _SPFResult):
+        self.spf_results.append(_SPFResult(domain=domain, scope=scope, result=result))

-    def save(self, **kwargs):  # pyright: ignore[reportIncompatibleMethodOverride]
+    def save(self, **kwargs):
        self.passed_dmarc = False
        self.passed_dmarc = self.spf_aligned or self.dkim_aligned

@@ -144,7 +121,7 @@ class _EmailAttachmentDoc(Document):
    sha256 = Text()


-class _FailureSampleDoc(InnerDoc):
+class _ForensicSampleDoc(InnerDoc):
    raw = Text()
    headers = Object()
    headers_only = Boolean()
@@ -181,9 +158,9 @@ class _FailureSampleDoc(InnerDoc):
        )


-class _FailureReportDoc(Document):
+class _ForensicReportDoc(Document):
    class Index:
-        name = "dmarc_failure"
+        name = "dmarc_forensic"

    feedback_type = Text()
    user_agent = Text()
@@ -201,7 +178,7 @@ class _FailureReportDoc(Document):
    source_auth_failures = Text()
    dkim_domain = Text()
    original_rcpt_to = Text()
-    sample = Object(_FailureSampleDoc)
+    sample = Object(_ForensicSampleDoc)


 class _SMTPTLSFailureDetailsDoc(InnerDoc):
@@ -351,20 +328,20 @@ def create_indexes(names: list[str], settings: Optional[dict[str, Any]] = None):

 def migrate_indexes(
    aggregate_indexes: Optional[list[str]] = None,
-    failure_indexes: Optional[list[str]] = None,
+    forensic_indexes: Optional[list[str]] = None,
 ):
    """
    Updates index mappings

    Args:
        aggregate_indexes (list): A list of aggregate index names
-        failure_indexes (list): A list of failure index names
+        forensic_indexes (list): A list of forensic index names
    """
    version = 2
    if aggregate_indexes is None:
        aggregate_indexes = []
-    if failure_indexes is None:
-        failure_indexes = []
+    if forensic_indexes is None:
+        forensic_indexes = []
    for aggregate_index_name in aggregate_indexes:
        if not Index(aggregate_index_name).exists():
            continue
@@ -394,7 +371,7 @@ def migrate_indexes(
            reindex(connections.get_connection(), aggregate_index_name, new_index_name)
            Index(aggregate_index_name).delete()

-    for failure_index in failure_indexes:
+    for forensic_index in forensic_indexes:
        pass


@@ -402,15 +379,15 @@ def save_aggregate_report_to_opensearch(
    aggregate_report: dict[str, Any],
    index_suffix: Optional[str] = None,
    index_prefix: Optional[str] = None,
-    monthly_indexes: bool = False,
-    number_of_shards: int = 1,
-    number_of_replicas: int = 0,
+    monthly_indexes: Optional[bool] = False,
+    number_of_shards: Optional[int] = 1,
+    number_of_replicas: Optional[int] = 0,
 ):
    """
    Saves a parsed DMARC aggregate report to OpenSearch

    Args:
-        aggregate_report (dict): A parsed aggregate report
+        aggregate_report (dict): A parsed forensic report
        index_suffix (str): The suffix of the name of the index to save to
        index_prefix (str): The prefix of the name of the index to save to
        monthly_indexes (bool): Use monthly indexes instead of daily indexes
@@ -450,12 +427,13 @@ def save_aggregate_report_to_opensearch(
    query = org_name_query & report_id_query & domain_query
    query = query & begin_date_query & end_date_query
    search.query = query
-    begin_date_human = begin_date.strftime("%Y-%m-%d %H:%M:%SZ")
-    end_date_human = end_date.strftime("%Y-%m-%d %H:%M:%SZ")

    try:
        existing = search.execute()
    except Exception as error_:
+        begin_date_human = begin_date.strftime("%Y-%m-%d %H:%M:%SZ")
+        end_date_human = end_date.strftime("%Y-%m-%d %H:%M:%SZ")
+
        raise OpenSearchError(
            "OpenSearch's search for existing report \
            error: {}".format(error_.__str__())
@@ -478,11 +456,6 @@ def save_aggregate_report_to_opensearch(
        sp=aggregate_report["policy_published"]["sp"],
        pct=aggregate_report["policy_published"]["pct"],
        fo=aggregate_report["policy_published"]["fo"],
-        np=aggregate_report["policy_published"].get("np"),
-        testing=aggregate_report["policy_published"].get("testing"),
-        discovery_method=aggregate_report["policy_published"].get(
-            "discovery_method"
-        ),
    )

    for record in aggregate_report["records"]:
@@ -524,12 +497,6 @@ def save_aggregate_report_to_opensearch(
            header_from=record["identifiers"]["header_from"],
            envelope_from=record["identifiers"]["envelope_from"],
            envelope_to=record["identifiers"]["envelope_to"],
-            np=aggregate_report["policy_published"].get("np"),
-            testing=aggregate_report["policy_published"].get("testing"),
-            discovery_method=aggregate_report["policy_published"].get(
-                "discovery_method"
-            ),
-            generator=metadata.get("generator"),
        )

        for override in record["policy_evaluated"]["policy_override_reasons"]:
@@ -542,7 +509,6 @@ def save_aggregate_report_to_opensearch(
                domain=dkim_result["domain"],
                selector=dkim_result["selector"],
                result=dkim_result["result"],
-                human_result=dkim_result.get("human_result"),
            )

        for spf_result in record["auth_results"]["spf"]:
@@ -550,7 +516,6 @@ def save_aggregate_report_to_opensearch(
                domain=spf_result["domain"],
                scope=spf_result["scope"],
                result=spf_result["result"],
-                human_result=spf_result.get("human_result"),
            )

        index = "dmarc_aggregate"
@@ -572,19 +537,19 @@ def save_aggregate_report_to_opensearch(
            raise OpenSearchError("OpenSearch error: {0}".format(e.__str__()))


-def save_failure_report_to_opensearch(
-    failure_report: dict[str, Any],
+def save_forensic_report_to_opensearch(
+    forensic_report: dict[str, Any],
    index_suffix: Optional[str] = None,
    index_prefix: Optional[str] = None,
-    monthly_indexes: bool = False,
+    monthly_indexes: Optional[bool] = False,
    number_of_shards: int = 1,
    number_of_replicas: int = 0,
 ):
    """
-    Saves a parsed DMARC failure report to OpenSearch
+    Saves a parsed DMARC forensic report to OpenSearch

    Args:
-        failure_report (dict): A parsed failure report
+        forensic_report (dict): A parsed forensic report
        index_suffix (str): The suffix of the name of the index to save to
        index_prefix (str): The prefix of the name of the index to save to
        monthly_indexes (bool): Use monthly indexes instead of daily
@@ -597,31 +562,26 @@ def save_failure_report_to_opensearch(
        AlreadySaved

    """
-    logger.info("Saving failure report to OpenSearch")
-    failure_report = failure_report.copy()
+    logger.info("Saving forensic report to OpenSearch")
+    forensic_report = forensic_report.copy()
    sample_date = None
-    if failure_report["parsed_sample"]["date"] is not None:
-        sample_date = failure_report["parsed_sample"]["date"]
+    if forensic_report["parsed_sample"]["date"] is not None:
+        sample_date = forensic_report["parsed_sample"]["date"]
        sample_date = human_timestamp_to_datetime(sample_date)
-    original_headers = failure_report["parsed_sample"]["headers"]
-    headers: dict[str, Any] = {}
+    original_headers = forensic_report["parsed_sample"]["headers"]
+    headers = dict()
    for original_header in original_headers:
        headers[original_header.lower()] = original_headers[original_header]

-    arrival_date = human_timestamp_to_datetime(failure_report["arrival_date_utc"])
+    arrival_date = human_timestamp_to_datetime(forensic_report["arrival_date_utc"])
    arrival_date_epoch_milliseconds = int(arrival_date.timestamp() * 1000)

    if index_suffix is not None:
-        search_index = "dmarc_failure_{0}*,dmarc_forensic_{0}*".format(
-            index_suffix
-        )
+        search_index = "dmarc_forensic_{0}*".format(index_suffix)
    else:
-        search_index = "dmarc_failure*,dmarc_forensic*"
+        search_index = "dmarc_forensic*"
    if index_prefix is not None:
-        search_index = ",".join(
-            "{0}{1}".format(index_prefix, part)
-            for part in search_index.split(",")
-        )
+        search_index = "{0}{1}".format(index_prefix, search_index)
    search = Search(index=search_index)
    q = Q(dict(match=dict(arrival_date=arrival_date_epoch_milliseconds)))

@@ -662,64 +622,64 @@ def save_failure_report_to_opensearch(

    if len(existing) > 0:
        raise AlreadySaved(
-            "A failure sample to {0} from {1} "
+            "A forensic sample to {0} from {1} "
            "with a subject of {2} and arrival date of {3} "
            "already exists in "
            "OpenSearch".format(
-                to_, from_, subject, failure_report["arrival_date_utc"]
+                to_, from_, subject, forensic_report["arrival_date_utc"]
            )
        )

-    parsed_sample = failure_report["parsed_sample"]
-    sample = _FailureSampleDoc(
-        raw=failure_report["sample"],
+    parsed_sample = forensic_report["parsed_sample"]
+    sample = _ForensicSampleDoc(
+        raw=forensic_report["sample"],
        headers=headers,
-        headers_only=failure_report["sample_headers_only"],
+        headers_only=forensic_report["sample_headers_only"],
        date=sample_date,
-        subject=failure_report["parsed_sample"]["subject"],
+        subject=forensic_report["parsed_sample"]["subject"],
        filename_safe_subject=parsed_sample["filename_safe_subject"],
-        body=failure_report["parsed_sample"]["body"],
+        body=forensic_report["parsed_sample"]["body"],
    )

-    for address in failure_report["parsed_sample"]["to"]:
+    for address in forensic_report["parsed_sample"]["to"]:
        sample.add_to(display_name=address["display_name"], address=address["address"])
-    for address in failure_report["parsed_sample"]["reply_to"]:
+    for address in forensic_report["parsed_sample"]["reply_to"]:
        sample.add_reply_to(
            display_name=address["display_name"], address=address["address"]
        )
-    for address in failure_report["parsed_sample"]["cc"]:
+    for address in forensic_report["parsed_sample"]["cc"]:
        sample.add_cc(display_name=address["display_name"], address=address["address"])
-    for address in failure_report["parsed_sample"]["bcc"]:
+    for address in forensic_report["parsed_sample"]["bcc"]:
        sample.add_bcc(display_name=address["display_name"], address=address["address"])
-    for attachment in failure_report["parsed_sample"]["attachments"]:
+    for attachment in forensic_report["parsed_sample"]["attachments"]:
        sample.add_attachment(
            filename=attachment["filename"],
            content_type=attachment["mail_content_type"],
            sha256=attachment["sha256"],
        )
    try:
-        failure_doc = _FailureReportDoc(
-            feedback_type=failure_report["feedback_type"],
-            user_agent=failure_report["user_agent"],
-            version=failure_report["version"],
-            original_mail_from=failure_report["original_mail_from"],
+        forensic_doc = _ForensicReportDoc(
+            feedback_type=forensic_report["feedback_type"],
+            user_agent=forensic_report["user_agent"],
+            version=forensic_report["version"],
+            original_mail_from=forensic_report["original_mail_from"],
            arrival_date=arrival_date_epoch_milliseconds,
-            domain=failure_report["reported_domain"],
-            original_envelope_id=failure_report["original_envelope_id"],
-            authentication_results=failure_report["authentication_results"],
-            delivery_results=failure_report["delivery_result"],
-            source_ip_address=failure_report["source"]["ip_address"],
-            source_country=failure_report["source"]["country"],
-            source_reverse_dns=failure_report["source"]["reverse_dns"],
-            source_base_domain=failure_report["source"]["base_domain"],
-            authentication_mechanisms=failure_report["authentication_mechanisms"],
-            auth_failure=failure_report["auth_failure"],
-            dkim_domain=failure_report["dkim_domain"],
-            original_rcpt_to=failure_report["original_rcpt_to"],
+            domain=forensic_report["reported_domain"],
+            original_envelope_id=forensic_report["original_envelope_id"],
+            authentication_results=forensic_report["authentication_results"],
+            delivery_results=forensic_report["delivery_result"],
+            source_ip_address=forensic_report["source"]["ip_address"],
+            source_country=forensic_report["source"]["country"],
+            source_reverse_dns=forensic_report["source"]["reverse_dns"],
+            source_base_domain=forensic_report["source"]["base_domain"],
+            authentication_mechanisms=forensic_report["authentication_mechanisms"],
+            auth_failure=forensic_report["auth_failure"],
+            dkim_domain=forensic_report["dkim_domain"],
+            original_rcpt_to=forensic_report["original_rcpt_to"],
            sample=sample,
        )

-        index = "dmarc_failure"
+        index = "dmarc_forensic"
        if index_suffix:
            index = "{0}_{1}".format(index, index_suffix)
        if index_prefix:
@@ -733,14 +693,14 @@ def save_failure_report_to_opensearch(
            number_of_shards=number_of_shards, number_of_replicas=number_of_replicas
        )
        create_indexes([index], index_settings)
-        failure_doc.meta.index = index
+        forensic_doc.meta.index = index
        try:
-            failure_doc.save()
+            forensic_doc.save()
        except Exception as e:
            raise OpenSearchError("OpenSearch error: {0}".format(e.__str__()))
    except KeyError as e:
-        raise InvalidFailureReport(
-            "Failure report missing required field: {0}".format(e.__str__())
+        raise InvalidForensicReport(
+            "Forensic report missing required field: {0}".format(e.__str__())
        )


@@ -748,9 +708,9 @@ def save_smtp_tls_report_to_opensearch(
    report: dict[str, Any],
    index_suffix: Optional[str] = None,
    index_prefix: Optional[str] = None,
-    monthly_indexes: bool = False,
-    number_of_shards: int = 1,
-    number_of_replicas: int = 0,
+    monthly_indexes: Optional[bool] = False,
+    number_of_shards: Optional[int] = 1,
+    number_of_replicas: Optional[int] = 0,
 ):
    """
    Saves a parsed SMTP TLS report to OpenSearch
@@ -893,9 +853,3 @@ def save_smtp_tls_report_to_opensearch(
        smtp_tls_doc.save()
    except Exception as e:
        raise OpenSearchError("OpenSearch error: {0}".format(e.__str__()))
-
-
-# Backward-compatible aliases
-_ForensicSampleDoc = _FailureSampleDoc
-_ForensicReportDoc = _FailureReportDoc
-save_forensic_report_to_opensearch = save_failure_report_to_opensearch
--- a/parsedmarc/s3.py
+++ b/parsedmarc/s3.py
@@ -2,9 +2,9 @@

 from __future__ import annotations

-import json
 from typing import Any

+import json
 import boto3

 from parsedmarc.log import logger
@@ -51,13 +51,13 @@ class S3Client(object):
            aws_access_key_id=access_key_id,
            aws_secret_access_key=secret_access_key,
        )
-        self.bucket = self.s3.Bucket(self.bucket_name)  # type: ignore
+        self.bucket: Any = self.s3.Bucket(self.bucket_name)

    def save_aggregate_report_to_s3(self, report: dict[str, Any]):
        self.save_report_to_s3(report, "aggregate")

-    def save_failure_report_to_s3(self, report: dict[str, Any]):
-        self.save_report_to_s3(report, "failure")
+    def save_forensic_report_to_s3(self, report: dict[str, Any]):
+        self.save_report_to_s3(report, "forensic")

    def save_smtp_tls_report_to_s3(self, report: dict[str, Any]):
        self.save_report_to_s3(report, "smtp_tls")
@@ -93,7 +93,3 @@ class S3Client(object):
        self.bucket.put_object(
            Body=json.dumps(report), Key=object_path, Metadata=object_metadata
        )
-
-
-# Backward-compatible aliases
-S3Client.save_forensic_report_to_s3 = S3Client.save_failure_report_to_s3
--- a/parsedmarc/splunk.py
+++ b/parsedmarc/splunk.py
@@ -2,13 +2,15 @@

 from __future__ import annotations

-import json
-import socket
 from typing import Any, Union
-from urllib.parse import urlparse

-import requests
+
+from urllib.parse import urlparse
+import socket
+import json
+
 import urllib3
+import requests

 from parsedmarc.constants import USER_AGENT
 from parsedmarc.log import logger
@@ -134,28 +136,28 @@ class HECClient(object):
        if response["code"] != 0:
            raise SplunkError(response["text"])

-    def save_failure_reports_to_splunk(
+    def save_forensic_reports_to_splunk(
        self,
-        failure_reports: Union[list[dict[str, Any]], dict[str, Any]],
+        forensic_reports: Union[list[dict[str, Any]], dict[str, Any]],
    ):
        """
-        Saves failure DMARC reports to Splunk
+        Saves forensic DMARC reports to Splunk

        Args:
-            failure_reports (list): A list of failure report dictionaries
+            forensic_reports (list): A list of forensic report dictionaries
                to save in Splunk
        """
-        logger.debug("Saving failure reports to Splunk")
-        if isinstance(failure_reports, dict):
-            failure_reports = [failure_reports]
+        logger.debug("Saving forensic reports to Splunk")
+        if isinstance(forensic_reports, dict):
+            forensic_reports = [forensic_reports]

-        if len(failure_reports) < 1:
+        if len(forensic_reports) < 1:
            return

        json_str = ""
-        for report in failure_reports:
+        for report in forensic_reports:
            data = self._common_data.copy()
-            data["sourcetype"] = "dmarc:failure"
+            data["sourcetype"] = "dmarc:forensic"
            timestamp = human_timestamp_to_unix_timestamp(report["arrival_date_utc"])
            data["time"] = timestamp
            data["event"] = report.copy()
@@ -207,7 +209,3 @@ class HECClient(object):
            raise SplunkError(e.__str__())
        if response["code"] != 0:
            raise SplunkError(response["text"])
-
-
-# Backward-compatible aliases
-HECClient.save_forensic_reports_to_splunk = HECClient.save_failure_reports_to_splunk
--- a/parsedmarc/syslog.py
+++ b/parsedmarc/syslog.py
@@ -3,17 +3,17 @@

 from __future__ import annotations

-import json
 import logging
 import logging.handlers
-import socket
-import ssl
-import time
-from typing import Any, Optional
+
+from typing import Any
+
+
+import json

 from parsedmarc import (
    parsed_aggregate_reports_to_csv_rows,
-    parsed_failure_reports_to_csv_rows,
+    parsed_forensic_reports_to_csv_rows,
    parsed_smtp_tls_reports_to_csv_rows,
 )

@@ -21,165 +21,37 @@ from parsedmarc import (
 class SyslogClient(object):
    """A client for Syslog"""

-    def __init__(
-        self,
-        server_name: str,
-        server_port: int,
-        protocol: str = "udp",
-        cafile_path: Optional[str] = None,
-        certfile_path: Optional[str] = None,
-        keyfile_path: Optional[str] = None,
-        timeout: float = 5.0,
-        retry_attempts: int = 3,
-        retry_delay: int = 5,
-    ):
+    def __init__(self, server_name: str, server_port: int):
        """
        Initializes the SyslogClient
        Args:
            server_name (str): The Syslog server
-            server_port (int): The Syslog port
-            protocol (str): The protocol to use: "udp", "tcp", or "tls" (Default: "udp")
-            cafile_path (str): Path to CA certificate file for TLS server verification (Optional)
-            certfile_path (str): Path to client certificate file for TLS authentication (Optional)
-            keyfile_path (str): Path to client private key file for TLS authentication (Optional)
-            timeout (float): Connection timeout in seconds for TCP/TLS (Default: 5.0)
-            retry_attempts (int): Number of retry attempts for failed connections (Default: 3)
-            retry_delay (int): Delay in seconds between retry attempts (Default: 5)
+            server_port (int): The Syslog UDP port
        """
        self.server_name = server_name
        self.server_port = server_port
-        self.protocol = protocol.lower()
-        self.timeout = timeout
-        self.retry_attempts = retry_attempts
-        self.retry_delay = retry_delay
-
        self.logger = logging.getLogger("parsedmarc_syslog")
        self.logger.setLevel(logging.INFO)
-
-        # Create the appropriate syslog handler based on protocol
-        log_handler = self._create_syslog_handler(
-            server_name,
-            server_port,
-            self.protocol,
-            cafile_path,
-            certfile_path,
-            keyfile_path,
-            timeout,
-            retry_attempts,
-            retry_delay,
-        )
-
+        log_handler = logging.handlers.SysLogHandler(address=(server_name, server_port))
        self.logger.addHandler(log_handler)

-    def _create_syslog_handler(
-        self,
-        server_name: str,
-        server_port: int,
-        protocol: str,
-        cafile_path: Optional[str],
-        certfile_path: Optional[str],
-        keyfile_path: Optional[str],
-        timeout: float,
-        retry_attempts: int,
-        retry_delay: int,
-    ) -> logging.handlers.SysLogHandler:
-        """
-        Creates a SysLogHandler with the specified protocol and TLS settings
-        """
-        if protocol == "udp":
-            # UDP protocol (default, backward compatible)
-            return logging.handlers.SysLogHandler(
-                address=(server_name, server_port),
-                socktype=socket.SOCK_DGRAM,
-            )
-        elif protocol in ["tcp", "tls"]:
-            # TCP or TLS protocol with retry logic
-            for attempt in range(1, retry_attempts + 1):
-                try:
-                    if protocol == "tcp":
-                        # TCP without TLS
-                        handler = logging.handlers.SysLogHandler(
-                            address=(server_name, server_port),
-                            socktype=socket.SOCK_STREAM,
-                        )
-                        # Set timeout on the socket
-                        if hasattr(handler, "socket") and handler.socket:
-                            handler.socket.settimeout(timeout)
-                        return handler
-                    else:
-                        # TLS protocol
-                        # Create SSL context with secure defaults
-                        ssl_context = ssl.create_default_context()
-
-                        # Explicitly set minimum TLS version to 1.2 for security
-                        ssl_context.minimum_version = ssl.TLSVersion.TLSv1_2
-
-                        # Configure server certificate verification
-                        if cafile_path:
-                            ssl_context.load_verify_locations(cafile=cafile_path)
-
-                        # Configure client certificate authentication
-                        if certfile_path and keyfile_path:
-                            ssl_context.load_cert_chain(
-                                certfile=certfile_path,
-                                keyfile=keyfile_path,
-                            )
-                        elif certfile_path or keyfile_path:
-                            # Warn if only one of the two required parameters is provided
-                            self.logger.warning(
-                                "Both certfile_path and keyfile_path are required for "
-                                "client certificate authentication. Client authentication "
-                                "will not be used."
-                            )
-
-                        # Create TCP handler first
-                        handler = logging.handlers.SysLogHandler(
-                            address=(server_name, server_port),
-                            socktype=socket.SOCK_STREAM,
-                        )
-
-                        # Wrap socket with TLS
-                        if hasattr(handler, "socket") and handler.socket:
-                            handler.socket = ssl_context.wrap_socket(
-                                handler.socket,
-                                server_hostname=server_name,
-                            )
-                            handler.socket.settimeout(timeout)
-
-                        return handler
-
-                except Exception as e:
-                    if attempt < retry_attempts:
-                        self.logger.warning(
-                            f"Syslog connection attempt {attempt}/{retry_attempts} failed: {e}. "
-                            f"Retrying in {retry_delay} seconds..."
-                        )
-                        time.sleep(retry_delay)
-                    else:
-                        self.logger.error(
-                            f"Syslog connection failed after {retry_attempts} attempts: {e}"
-                        )
-                        raise
-        else:
-            raise ValueError(
-                f"Invalid protocol '{protocol}'. Must be 'udp', 'tcp', or 'tls'."
-            )
-
-    def save_aggregate_report_to_syslog(self, aggregate_reports: list[dict[str, Any]]):
+    def save_aggregate_report_to_syslog(
+        self, aggregate_reports: list[dict[str, Any]]
+    ):
        rows = parsed_aggregate_reports_to_csv_rows(aggregate_reports)
        for row in rows:
            self.logger.info(json.dumps(row))

-    def save_failure_report_to_syslog(self, failure_reports: list[dict[str, Any]]):
-        rows = parsed_failure_reports_to_csv_rows(failure_reports)
+    def save_forensic_report_to_syslog(
+        self, forensic_reports: list[dict[str, Any]]
+    ):
+        rows = parsed_forensic_reports_to_csv_rows(forensic_reports)
        for row in rows:
            self.logger.info(json.dumps(row))

-    def save_smtp_tls_report_to_syslog(self, smtp_tls_reports: list[dict[str, Any]]):
+    def save_smtp_tls_report_to_syslog(
+        self, smtp_tls_reports: list[dict[str, Any]]
+    ):
        rows = parsed_smtp_tls_reports_to_csv_rows(smtp_tls_reports)
        for row in rows:
            self.logger.info(json.dumps(row))
-
-
-# Backward-compatible aliases
-SyslogClient.save_forensic_report_to_syslog = SyslogClient.save_failure_report_to_syslog
--- a/parsedmarc/types.py
+++ b/parsedmarc/types.py
@@ -1,234 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, Dict, List, Literal, Optional, TypedDict, Union
-
-# NOTE: This module is intentionally Python 3.9 compatible.
-# - No PEP 604 unions (A | B)
-# - No typing.NotRequired / Required (3.11+) to avoid an extra dependency.
-#   For optional keys, use total=False TypedDicts.
-
-
-ReportType = Literal["aggregate", "failure", "smtp_tls"]
-
-
-class AggregateReportMetadata(TypedDict):
-    org_name: str
-    org_email: str
-    org_extra_contact_info: Optional[str]
-    report_id: str
-    begin_date: str
-    end_date: str
-    timespan_requires_normalization: bool
-    original_timespan_seconds: int
-    errors: List[str]
-    generator: Optional[str]
-
-
-class AggregatePolicyPublished(TypedDict):
-    domain: str
-    adkim: str
-    aspf: str
-    p: str
-    sp: str
-    pct: str
-    fo: str
-    np: Optional[str]
-    testing: Optional[str]
-    discovery_method: Optional[str]
-
-
-class IPSourceInfo(TypedDict):
-    ip_address: str
-    country: Optional[str]
-    reverse_dns: Optional[str]
-    base_domain: Optional[str]
-    name: Optional[str]
-    type: Optional[str]
-
-
-class AggregateAlignment(TypedDict):
-    spf: bool
-    dkim: bool
-    dmarc: bool
-
-
-class AggregateIdentifiers(TypedDict):
-    header_from: str
-    envelope_from: Optional[str]
-    envelope_to: Optional[str]
-
-
-class AggregatePolicyOverrideReason(TypedDict):
-    type: Optional[str]
-    comment: Optional[str]
-
-
-class AggregateAuthResultDKIM(TypedDict):
-    domain: str
-    result: str
-    selector: str
-    human_result: Optional[str]
-
-
-class AggregateAuthResultSPF(TypedDict):
-    domain: str
-    result: str
-    scope: str
-    human_result: Optional[str]
-
-
-class AggregateAuthResults(TypedDict):
-    dkim: List[AggregateAuthResultDKIM]
-    spf: List[AggregateAuthResultSPF]
-
-
-class AggregatePolicyEvaluated(TypedDict):
-    disposition: str
-    dkim: str
-    spf: str
-    policy_override_reasons: List[AggregatePolicyOverrideReason]
-
-
-class AggregateRecord(TypedDict):
-    interval_begin: str
-    interval_end: str
-    source: IPSourceInfo
-    count: int
-    alignment: AggregateAlignment
-    policy_evaluated: AggregatePolicyEvaluated
-    disposition: str
-    identifiers: AggregateIdentifiers
-    auth_results: AggregateAuthResults
-
-
-class AggregateReport(TypedDict):
-    xml_schema: str
-    report_metadata: AggregateReportMetadata
-    policy_published: AggregatePolicyPublished
-    records: List[AggregateRecord]
-
-
-class EmailAddress(TypedDict):
-    display_name: Optional[str]
-    address: str
-    local: Optional[str]
-    domain: Optional[str]
-
-
-class EmailAttachment(TypedDict, total=False):
-    filename: Optional[str]
-    mail_content_type: Optional[str]
-    sha256: Optional[str]
-
-
-ParsedEmail = TypedDict(
-    "ParsedEmail",
-    {
-        # This is a lightly-specified version of mailsuite/mailparser JSON.
-        # It focuses on the fields parsedmarc uses in failure report handling.
-        "headers": Dict[str, Any],
-        "subject": Optional[str],
-        "filename_safe_subject": Optional[str],
-        "date": Optional[str],
-        "from": EmailAddress,
-        "to": List[EmailAddress],
-        "cc": List[EmailAddress],
-        "bcc": List[EmailAddress],
-        "attachments": List[EmailAttachment],
-        "body": Optional[str],
-        "has_defects": bool,
-        "defects": Any,
-        "defects_categories": Any,
-    },
-    total=False,
-)
-
-
-class FailureReport(TypedDict):
-    feedback_type: Optional[str]
-    user_agent: Optional[str]
-    version: Optional[str]
-    original_envelope_id: Optional[str]
-    original_mail_from: Optional[str]
-    original_rcpt_to: Optional[str]
-    arrival_date: str
-    arrival_date_utc: str
-    authentication_results: Optional[str]
-    delivery_result: Optional[str]
-    auth_failure: List[str]
-    authentication_mechanisms: List[str]
-    dkim_domain: Optional[str]
-    reported_domain: str
-    sample_headers_only: bool
-    source: IPSourceInfo
-    sample: str
-    parsed_sample: ParsedEmail
-
-
-# Backward-compatible alias
-ForensicReport = FailureReport
-
-
-class SMTPTLSFailureDetails(TypedDict):
-    result_type: str
-    failed_session_count: int
-
-
-class SMTPTLSFailureDetailsOptional(SMTPTLSFailureDetails, total=False):
-    sending_mta_ip: str
-    receiving_ip: str
-    receiving_mx_hostname: str
-    receiving_mx_helo: str
-    additional_info_uri: str
-    failure_reason_code: str
-    ip_address: str
-
-
-class SMTPTLSPolicySummary(TypedDict):
-    policy_domain: str
-    policy_type: str
-    successful_session_count: int
-    failed_session_count: int
-
-
-class SMTPTLSPolicy(SMTPTLSPolicySummary, total=False):
-    policy_strings: List[str]
-    mx_host_patterns: List[str]
-    failure_details: List[SMTPTLSFailureDetailsOptional]
-
-
-class SMTPTLSReport(TypedDict):
-    organization_name: str
-    begin_date: str
-    end_date: str
-    contact_info: Union[str, List[str]]
-    report_id: str
-    policies: List[SMTPTLSPolicy]
-
-
-class AggregateParsedReport(TypedDict):
-    report_type: Literal["aggregate"]
-    report: AggregateReport
-
-
-class FailureParsedReport(TypedDict):
-    report_type: Literal["failure"]
-    report: FailureReport
-
-
-# Backward-compatible alias
-ForensicParsedReport = FailureParsedReport
-
-
-class SMTPTLSParsedReport(TypedDict):
-    report_type: Literal["smtp_tls"]
-    report: SMTPTLSReport
-
-
-ParsedReport = Union[AggregateParsedReport, FailureParsedReport, SMTPTLSParsedReport]
-
-
-class ParsingResults(TypedDict):
-    aggregate_reports: List[AggregateReport]
-    failure_reports: List[FailureReport]
-    smtp_tls_reports: List[SMTPTLSReport]
--- a/parsedmarc/utils.py
+++ b/parsedmarc/utils.py
@@ -4,23 +4,25 @@

 from __future__ import annotations

-import base64
-import csv
-import hashlib
-import io
-import json
-import logging
-import mailbox
-import os
-import re
-import shutil
-import subprocess
-import tempfile
-from datetime import datetime, timedelta, timezone
-from typing import Optional, TypedDict, Union, cast
+from typing import Optional, Union, TypedDict, Any

-import mailparser
+import logging
+import os
+from datetime import datetime
+from datetime import timezone
+from datetime import timedelta
 from expiringdict import ExpiringDict
+import tempfile
+import subprocess
+import shutil
+import mailparser
+import json
+import hashlib
+import base64
+import mailbox
+import re
+import csv
+import io

 try:
    from importlib.resources import files
@@ -29,19 +31,19 @@ except ImportError:
    from importlib.resources import files


-import dns.exception
-import dns.resolver
+from dateutil.parser import parse as parse_date
 import dns.reversename
+import dns.resolver
+import dns.exception
 import geoip2.database
 import geoip2.errors
 import publicsuffixlist
 import requests
-from dateutil.parser import parse as parse_date

+from parsedmarc.log import logger
 import parsedmarc.resources.dbip
 import parsedmarc.resources.maps
 from parsedmarc.constants import USER_AGENT
-from parsedmarc.log import logger

 parenthesis_regex = re.compile(r"\s*\(.*\)\s*")

@@ -64,21 +66,12 @@ class DownloadError(RuntimeError):
    """Raised when an error occurs when downloading a file"""


-class ReverseDNSService(TypedDict):
-    name: str
-    type: Optional[str]
-
-
-ReverseDNSMap = dict[str, ReverseDNSService]
-
-
-class IPAddressInfo(TypedDict):
-    ip_address: str
-    reverse_dns: Optional[str]
-    country: Optional[str]
-    base_domain: Optional[str]
-    name: Optional[str]
-    type: Optional[str]
+class EmailAddress(TypedDict):
+    """Parsed email address information"""
+    display_name: Optional[str]
+    address: str
+    local: Optional[str]
+    domain: Optional[str]


 def decode_base64(data: str) -> bytes:
@@ -92,14 +85,14 @@ def decode_base64(data: str) -> bytes:
        bytes: The decoded bytes

    """
-    data_bytes = bytes(data, encoding="ascii")
-    missing_padding = len(data_bytes) % 4
+    data = bytes(data, encoding="ascii")
+    missing_padding = len(data) % 4
    if missing_padding != 0:
-        data_bytes += b"=" * (4 - missing_padding)
-    return base64.b64decode(data_bytes)
+        data += b"=" * (4 - missing_padding)
+    return base64.b64decode(data)


-def get_base_domain(domain: str) -> Optional[str]:
+def get_base_domain(domain: str) -> str:
    """
    Gets the base domain name for the given domain

@@ -128,8 +121,8 @@ def query_dns(
    record_type: str,
    *,
    cache: Optional[ExpiringDict] = None,
-    nameservers: Optional[list[str]] = None,
-    timeout: float = 2.0,
+    nameservers: list[str] = None,
+    timeout: int = 2.0,
 ) -> list[str]:
    """
    Queries DNS
@@ -149,9 +142,9 @@ def query_dns(
    record_type = record_type.upper()
    cache_key = "{0}_{1}".format(domain, record_type)
    if cache:
-        cached_records = cache.get(cache_key, None)
-        if isinstance(cached_records, list):
-            return cast(list[str], cached_records)
+        records = cache.get(cache_key, None)
+        if records:
+            return records

    resolver = dns.resolver.Resolver()
    timeout = float(timeout)
@@ -165,12 +158,26 @@ def query_dns(
    resolver.nameservers = nameservers
    resolver.timeout = timeout
    resolver.lifetime = timeout
-    records = list(
-        map(
-            lambda r: r.to_text().replace('"', "").rstrip("."),
-            resolver.resolve(domain, record_type, lifetime=timeout),
+    if record_type == "TXT":
+        resource_records = list(
+            map(
+                lambda r: r.strings,
+                resolver.resolve(domain, record_type, lifetime=timeout),
+            )
+        )
+        _resource_record = [
+            resource_record[0][:0].join(resource_record)
+            for resource_record in resource_records
+            if resource_record
+        ]
+        records = [r.decode() for r in _resource_record]
+    else:
+        records = list(
+            map(
+                lambda r: r.to_text().replace('"', "").rstrip("."),
+                resolver.resolve(domain, record_type, lifetime=timeout),
+            )
        )
-    )
    if cache:
        cache[cache_key] = records

@@ -181,9 +188,9 @@ def get_reverse_dns(
    ip_address,
    *,
    cache: Optional[ExpiringDict] = None,
-    nameservers: Optional[list[str]] = None,
-    timeout: float = 2.0,
-) -> Optional[str]:
+    nameservers: list[str] = None,
+    timeout: int = 2.0,
+) -> str:
    """
    Resolves an IP address to a hostname using a reverse DNS query

@@ -201,7 +208,7 @@ def get_reverse_dns(
    try:
        address = dns.reversename.from_address(ip_address)
        hostname = query_dns(
-            str(address), "PTR", cache=cache, nameservers=nameservers, timeout=timeout
+            address, "PTR", cache=cache, nameservers=nameservers, timeout=timeout
        )[0]

    except dns.exception.DNSException as e:
@@ -238,7 +245,7 @@ def timestamp_to_human(timestamp: int) -> str:


 def human_timestamp_to_datetime(
-    human_timestamp: str, *, to_utc: bool = False
+    human_timestamp: str, *, to_utc: Optional[bool] = False
 ) -> datetime:
    """
    Converts a human-readable timestamp into a Python ``datetime`` object
@@ -269,12 +276,10 @@ def human_timestamp_to_unix_timestamp(human_timestamp: str) -> int:
        float: The converted timestamp
    """
    human_timestamp = human_timestamp.replace("T", " ")
-    return int(human_timestamp_to_datetime(human_timestamp).timestamp())
+    return human_timestamp_to_datetime(human_timestamp).timestamp()


-def get_ip_address_country(
-    ip_address: str, *, db_path: Optional[str] = None
-) -> Optional[str]:
+def get_ip_address_country(ip_address: str, *, db_path: Optional[str] = None) -> str:
    """
    Returns the ISO code for the country associated
    with the given IPv4 or IPv6 address
@@ -337,14 +342,14 @@ def get_ip_address_country(


 def get_service_from_reverse_dns_base_domain(
-    base_domain,
+    base_domain: str,
    *,
-    always_use_local_file: bool = False,
+    always_use_local_file: Optional[bool] = False,
    local_file_path: Optional[str] = None,
    url: Optional[str] = None,
-    offline: bool = False,
-    reverse_dns_map: Optional[ReverseDNSMap] = None,
-) -> ReverseDNSService:
+    offline: Optional[bool] = False,
+    reverse_dns_map: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
    """
    Returns the service name of a given base domain name from reverse DNS.

@@ -361,6 +366,12 @@ def get_service_from_reverse_dns_base_domain(
        the supplied reverse_dns_base_domain and the type will be None
    """

+    def load_csv(_csv_file):
+        reader = csv.DictReader(_csv_file)
+        for row in reader:
+            key = row["base_reverse_dns"].lower().strip()
+            reverse_dns_map[key] = dict(name=row["name"], type=row["type"])
+
    base_domain = base_domain.lower().strip()
    if url is None:
        url = (
@@ -368,24 +379,11 @@ def get_service_from_reverse_dns_base_domain(
            "/parsedmarc/master/parsedmarc/"
            "resources/maps/base_reverse_dns_map.csv"
        )
-    reverse_dns_map_value: ReverseDNSMap
    if reverse_dns_map is None:
-        reverse_dns_map_value = {}
-    else:
-        reverse_dns_map_value = reverse_dns_map
-
-    def load_csv(_csv_file):
-        reader = csv.DictReader(_csv_file)
-        for row in reader:
-            key = row["base_reverse_dns"].lower().strip()
-            reverse_dns_map_value[key] = {
-                "name": row["name"],
-                "type": row["type"],
-            }
-
+        reverse_dns_map = dict()
    csv_file = io.StringIO()

-    if not (offline or always_use_local_file) and len(reverse_dns_map_value) == 0:
+    if not (offline or always_use_local_file) and len(reverse_dns_map) == 0:
        try:
            logger.debug(f"Trying to fetch reverse DNS map from {url}...")
            headers = {"User-Agent": USER_AGENT}
@@ -402,7 +400,7 @@ def get_service_from_reverse_dns_base_domain(
            logging.debug("Response body:")
            logger.debug(csv_file.read())

-    if len(reverse_dns_map_value) == 0:
+    if len(reverse_dns_map) == 0:
        logger.info("Loading included reverse DNS map...")
        path = str(
            files(parsedmarc.resources.maps).joinpath("base_reverse_dns_map.csv")
@@ -411,28 +409,27 @@ def get_service_from_reverse_dns_base_domain(
            path = local_file_path
        with open(path) as csv_file:
            load_csv(csv_file)
-    service: ReverseDNSService
    try:
-        service = reverse_dns_map_value[base_domain]
+        service = reverse_dns_map[base_domain]
    except KeyError:
-        service = {"name": base_domain, "type": None}
+        service = dict(name=base_domain, type=None)

    return service


 def get_ip_address_info(
-    ip_address,
+    ip_address: str,
    *,
    ip_db_path: Optional[str] = None,
    reverse_dns_map_path: Optional[str] = None,
-    always_use_local_files: bool = False,
+    always_use_local_files: Optional[bool] = False,
    reverse_dns_map_url: Optional[str] = None,
    cache: Optional[ExpiringDict] = None,
-    reverse_dns_map: Optional[ReverseDNSMap] = None,
-    offline: bool = False,
+    reverse_dns_map: Optional[dict[str, Any]] = None,
+    offline: Optional[bool] = False,
    nameservers: Optional[list[str]] = None,
-    timeout: float = 2.0,
-) -> IPAddressInfo:
+    timeout: Optional[float] = 2.0,
+) -> dict[str, Any]:
    """
    Returns reverse DNS and country information for the given IP address

@@ -455,22 +452,12 @@ def get_ip_address_info(
    """
    ip_address = ip_address.lower()
    if cache is not None:
-        cached_info = cache.get(ip_address, None)
-        if (
-            cached_info
-            and isinstance(cached_info, dict)
-            and "ip_address" in cached_info
-        ):
+        info = cache.get(ip_address, None)
+        if info:
            logger.debug(f"IP address {ip_address} was found in cache")
-            return cast(IPAddressInfo, cached_info)
-    info: IPAddressInfo = {
-        "ip_address": ip_address,
-        "reverse_dns": None,
-        "country": None,
-        "base_domain": None,
-        "name": None,
-        "type": None,
-    }
+            return info
+    info = dict()
+    info["ip_address"] = ip_address
    if offline:
        reverse_dns = None
    else:
@@ -480,6 +467,9 @@ def get_ip_address_info(
    country = get_ip_address_country(ip_address, db_path=ip_db_path)
    info["country"] = country
    info["reverse_dns"] = reverse_dns
+    info["base_domain"] = None
+    info["name"] = None
+    info["type"] = None
    if reverse_dns is not None:
        base_domain = get_base_domain(reverse_dns)
        if base_domain is not None:
@@ -504,7 +494,7 @@ def get_ip_address_info(
    return info


-def parse_email_address(original_address: str) -> dict[str, Optional[str]]:
+def parse_email_address(original_address: str) -> EmailAddress:
    if original_address[0] == "":
        display_name = None
    else:
@@ -568,7 +558,7 @@ def is_mbox(path: str) -> bool:
    return _is_mbox


-def is_outlook_msg(content) -> bool:
+def is_outlook_msg(content: Union[bytes, Any]) -> bool:
    """
    Checks if the given content is an Outlook msg OLE/MSG file

@@ -583,7 +573,7 @@ def is_outlook_msg(content) -> bool:
    )


-def convert_outlook_msg(msg_bytes: bytes) -> bytes:
+def convert_outlook_msg(msg_bytes: bytes) -> str:
    """
    Uses the ``msgconvert`` Perl utility to convert an Outlook MS file to
    standard RFC 822 format
@@ -592,7 +582,7 @@ def convert_outlook_msg(msg_bytes: bytes) -> bytes:
        msg_bytes (bytes): the content of the .msg file

    Returns:
-        A RFC 822 bytes payload
+        A RFC 822 string
    """
    if not is_outlook_msg(msg_bytes):
        raise ValueError("The supplied bytes are not an Outlook MSG file")
@@ -601,13 +591,14 @@ def convert_outlook_msg(msg_bytes: bytes) -> bytes:
    os.chdir(tmp_dir)
    with open("sample.msg", "wb") as msg_file:
        msg_file.write(msg_bytes)
+    rfc822_bytes: bytes
    try:
        subprocess.check_call(
            ["msgconvert", "sample.msg"], stdout=null_file, stderr=null_file
        )
        eml_path = "sample.eml"
        with open(eml_path, "rb") as eml_file:
-            rfc822 = eml_file.read()
+            rfc822_bytes = eml_file.read()
    except FileNotFoundError:
        raise EmailParserError(
            "Failed to convert Outlook MSG: msgconvert utility not found"
@@ -616,12 +607,12 @@ def convert_outlook_msg(msg_bytes: bytes) -> bytes:
        os.chdir(orig_dir)
        shutil.rmtree(tmp_dir)

-    return rfc822
+    return rfc822_bytes.decode("utf-8", errors="replace")


 def parse_email(
-    data: Union[bytes, str], *, strip_attachment_payloads: bool = False
-) -> dict:
+    data: Union[bytes, str], *, strip_attachment_payloads: Optional[bool] = False
+) -> dict[str, Any]:
    """
    A simplified email parser

@@ -636,7 +627,8 @@ def parse_email(
    if isinstance(data, bytes):
        if is_outlook_msg(data):
            data = convert_outlook_msg(data)
-        data = data.decode("utf-8", errors="replace")
+        else:
+            data = data.decode("utf-8", errors="replace")
    parsed_email = mailparser.parse_from_string(data)
    headers = json.loads(parsed_email.headers_json).copy()
    parsed_email = json.loads(parsed_email.mail_json).copy()
--- a/parsedmarc/webhook.py
+++ b/parsedmarc/webhook.py
@@ -16,7 +16,7 @@ class WebhookClient(object):
    def __init__(
        self,
        aggregate_url: str,
-        failure_url: str,
+        forensic_url: str,
        smtp_tls_url: str,
        timeout: Optional[int] = 60,
    ):
@@ -24,12 +24,12 @@ class WebhookClient(object):
        Initializes the WebhookClient
        Args:
            aggregate_url (str): The aggregate report webhook url
-            failure_url (str): The failure report webhook url
+            forensic_url (str): The forensic report webhook url
            smtp_tls_url (str): The smtp_tls report webhook url
            timeout (int): The timeout to use when calling the webhooks
        """
        self.aggregate_url = aggregate_url
-        self.failure_url = failure_url
+        self.forensic_url = forensic_url
        self.smtp_tls_url = smtp_tls_url
        self.timeout = timeout
        self.session = requests.Session()
@@ -38,9 +38,9 @@ class WebhookClient(object):
            "Content-Type": "application/json",
        }

-    def save_failure_report_to_webhook(self, report: str):
+    def save_forensic_report_to_webhook(self, report: str):
        try:
-            self._send_to_webhook(self.failure_url, report)
+            self._send_to_webhook(self.forensic_url, report)
        except Exception as error_:
            logger.error("Webhook Error: {0}".format(error_.__str__()))

@@ -63,7 +63,3 @@ class WebhookClient(object):
            self.session.post(webhook_url, data=payload, timeout=self.timeout)
        except Exception as error_:
            logger.error("Webhook Error: {0}".format(error_.__str__()))
-
-
-# Backward-compatible aliases
-WebhookClient.save_forensic_report_to_webhook = WebhookClient.save_failure_report_to_webhook
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -29,7 +29,7 @@ classifiers = [
    "Operating System :: OS Independent",
    "Programming Language :: Python :: 3"
 ]
-requires-python = ">=3.9"
+requires-python = ">=3.9, <3.14"
 dependencies = [
    "azure-identity>=1.8.0",
    "azure-monitor-ingestion>=1.0.0",
@@ -48,7 +48,7 @@ dependencies = [
    "imapclient>=2.1.0",
    "kafka-python-ng>=2.2.2",
    "lxml>=4.4.0",
-    "mailsuite>=1.11.2",
+    "mailsuite>=1.9.18",
    "msgraph-core==0.2.2",
    "opensearch-py>=2.4.2,<=3.0.0",
    "publicsuffixlist>=0.10.0",
--- a/samples/aggregate/dmarcbis-draft-sample.xml
+++ b/samples/aggregate/dmarcbis-draft-sample.xml
@@ -1,48 +0,0 @@
-<feedback xmlns="urn:ietf:params:xml:ns:dmarc-2.0">
-  <version>1.0</version>
-  <report_metadata>
-    <org_name>Sample Reporter</org_name>
-    <email>report_sender@example-reporter.com</email>
-    <extra_contact_info>...</extra_contact_info>
-    <report_id>3v98abbp8ya9n3va8yr8oa3ya</report_id>
-    <date_range>
-      <begin>302832000</begin>
-      <end>302918399</end>
-    </date_range>
-    <generator>Example DMARC Aggregate Reporter v1.2</generator>
-  </report_metadata>
-  <policy_published>
-    <domain>example.com</domain>
-    <p>quarantine</p>
-    <sp>none</sp>
-    <np>none</np>
-    <testing>n</testing>
-    <discovery_method>treewalk</discovery_method>
-  </policy_published>
-  <record>
-    <row>
-      <source_ip>192.0.2.123</source_ip>
-      <count>123</count>
-      <policy_evaluated>
-        <disposition>pass</disposition>
-        <dkim>pass</dkim>
-        <spf>fail</spf>
-      </policy_evaluated>
-    </row>
-    <identifiers>
-      <envelope_from>example.com</envelope_from>
-      <header_from>example.com</header_from>
-    </identifiers>
-    <auth_results>
-      <dkim>
-        <domain>example.com</domain>
-        <result>pass</result>
-        <selector>abc123</selector>
-      </dkim>
-      <spf>
-        <domain>example.com</domain>
-        <result>fail</result>
-      </spf>
-    </auth_results>
-  </record>
-</feedback>
--- a/samples/aggregate/dmarcbis-example.net!example.com!1700000000!1700086399.xml
+++ b/samples/aggregate/dmarcbis-example.net!example.com!1700000000!1700086399.xml
@@ -1,77 +0,0 @@
-<?xml version="1.0"?>
-<feedback>
-  <version>2.0</version>
-  <report_metadata>
-    <org_name>example.net</org_name>
-    <email>postmaster@example.net</email>
-    <report_id>dmarcbis-test-report-001</report_id>
-    <date_range>
-      <begin>1700000000</begin>
-      <end>1700086399</end>
-    </date_range>
-  </report_metadata>
-  <policy_published>
-    <domain>example.com</domain>
-    <adkim>s</adkim>
-    <aspf>s</aspf>
-    <p>reject</p>
-    <sp>quarantine</sp>
-    <np>reject</np>
-    <testing>y</testing>
-    <discovery_method>treewalk</discovery_method>
-    <fo>1</fo>
-  </policy_published>
-  <record>
-    <row>
-      <source_ip>198.51.100.1</source_ip>
-      <count>5</count>
-      <policy_evaluated>
-        <disposition>none</disposition>
-        <dkim>pass</dkim>
-        <spf>pass</spf>
-      </policy_evaluated>
-    </row>
-    <identifiers>
-      <envelope_from>example.com</envelope_from>
-      <header_from>example.com</header_from>
-    </identifiers>
-    <auth_results>
-      <dkim>
-        <domain>example.com</domain>
-        <selector>selector1</selector>
-        <result>pass</result>
-      </dkim>
-      <spf>
-        <domain>example.com</domain>
-        <scope>mfrom</scope>
-        <result>pass</result>
-      </spf>
-    </auth_results>
-  </record>
-  <record>
-    <row>
-      <source_ip>203.0.113.10</source_ip>
-      <count>2</count>
-      <policy_evaluated>
-        <disposition>reject</disposition>
-        <dkim>fail</dkim>
-        <spf>fail</spf>
-        <reason>
-          <type>other</type>
-          <comment>sender not authorized</comment>
-        </reason>
-      </policy_evaluated>
-    </row>
-    <identifiers>
-      <envelope_from>spoofed.example.com</envelope_from>
-      <header_from>example.com</header_from>
-    </identifiers>
-    <auth_results>
-      <spf>
-        <domain>spoofed.example.com</domain>
-        <scope>mfrom</scope>
-        <result>fail</result>
-      </spf>
-    </auth_results>
-  </record>
-</feedback>
--- a/splunk/README.rst
+++ b/splunk/README.rst
@@ -60,10 +60,10 @@ Create Dashboards
 9. Click Save
 10. Click Dashboards
 11. Click Create New Dashboard
-12. Use a descriptive title, such as "Failure DMARC Data"
+12. Use a descriptive title, such as "Forensic DMARC Data"
 13. Click Create Dashboard
 14. Click on the Source button
-15. Paste the content of ''dmarc_failure_dashboard.xml`` into the source editor
+15. Paste the content of ''dmarc_forensic_dashboard.xml`` into the source editor
 16. If the index storing the DMARC data is not named email, replace index="email" accordingly
 17. Click Save

--- a/splunk/dmarc_forensic_dashboard.xml
+++ b/splunk/dmarc_forensic_dashboard.xml
@@ -1,8 +1,8 @@
 <form theme="dark" version="1.1">
-  <label>Failure DMARC Data</label>
+  <label>Forensic DMARC Data</label>
  <search id="base_search">
    <query>
-      index="email" (sourcetype="dmarc:failure" OR sourcetype="dmarc:forensic") parsed_sample.headers.From=$header_from$ parsed_sample.headers.To=$header_to$ parsed_sample.headers.Subject=$header_subject$ source.ip_address=$source_ip_address$ source.reverse_dns=$source_reverse_dns$ source.country=$source_country$
+      index="email" sourcetype="dmarc:forensic" parsed_sample.headers.From=$header_from$ parsed_sample.headers.To=$header_to$ parsed_sample.headers.Subject=$header_subject$ source.ip_address=$source_ip_address$ source.reverse_dns=$source_reverse_dns$ source.country=$source_country$
      | table *
    </query>
    <earliest>$time_range.earliest$</earliest>
@@ -43,7 +43,7 @@
  </fieldset>
  <row>
    <panel>
-      <title>Failure samples</title>
+      <title>Forensic samples</title>
      <table>
        <search base="base_search">
          <query>| table arrival_date_utc authentication_results parsed_sample.headers.From,parsed_sample.headers.To,parsed_sample.headers.Subject | sort -arrival_date_utc</query>
@@ -59,7 +59,7 @@
  </row>
  <row>
    <panel>
-      <title>Failure samples by country</title>
+      <title>Forensic samples by country</title>
      <map>
        <search base="base_search">
          <query>| iplocation source.ip_address| stats count by Country | geom geo_countries featureIdField="Country"</query>
@@ -72,7 +72,7 @@
  </row>
  <row>
    <panel>
-      <title>Failure samples by IP address</title>
+      <title>Forensic samples by IP address</title>
      <table>
        <search base="base_search">
          <query>| iplocation source.ip_address | stats count by source.ip_address,source.reverse_dns | sort -count</query>
@@ -85,7 +85,7 @@
      </table>
    </panel>
    <panel>
-      <title>Failure samples by country ISO code</title>
+      <title>Forensic samples by country ISO code</title>
      <table>
        <search base="base_search">
          <query>| stats count by source.country | sort - count</query>
--- a/tests.py
+++ b/tests.py
@@ -12,9 +12,6 @@ from lxml import etree
 import parsedmarc
 import parsedmarc.utils

-# Detect if running in GitHub Actions to skip DNS lookups
-OFFLINE_MODE = os.environ.get("GITHUB_ACTIONS", "false").lower() == "true"
-

 def minify_xml(xml_string):
    parser = etree.XMLParser(remove_blank_text=True)
@@ -124,7 +121,7 @@ class Test(unittest.TestCase):
                continue
            print("Testing {0}: ".format(sample_path), end="")
            parsed_report = parsedmarc.parse_report_file(
-                sample_path, always_use_local_files=True, offline=OFFLINE_MODE
+                sample_path, always_use_local_files=True
            )["report"]
            parsedmarc.parsed_aggregate_reports_to_csv(parsed_report)
            print("Passed!")
@@ -132,173 +129,21 @@ class Test(unittest.TestCase):
    def testEmptySample(self):
        """Test empty/unparasable report"""
        with self.assertRaises(parsedmarc.ParserError):
-            parsedmarc.parse_report_file("samples/empty.xml", offline=OFFLINE_MODE)
+            parsedmarc.parse_report_file("samples/empty.xml")

    def testForensicSamples(self):
-        """Test sample failure/ruf DMARC reports"""
+        """Test sample forensic/ruf/failure DMARC reports"""
        print()
        sample_paths = glob("samples/forensic/*.eml")
        for sample_path in sample_paths:
            print("Testing {0}: ".format(sample_path), end="")
            with open(sample_path) as sample_file:
                sample_content = sample_file.read()
-                parsed_report = parsedmarc.parse_report_email(
-                    sample_content, offline=OFFLINE_MODE
-                )["report"]
-            parsed_report = parsedmarc.parse_report_file(
-                sample_path, offline=OFFLINE_MODE
-            )["report"]
-            parsedmarc.parsed_failure_reports_to_csv(parsed_report)
+                parsed_report = parsedmarc.parse_report_email(sample_content)["report"]
+            parsed_report = parsedmarc.parse_report_file(sample_path)["report"]
+            parsedmarc.parsed_forensic_reports_to_csv(parsed_report)
            print("Passed!")

-    def testFailureReportBackwardCompat(self):
-        """Test that old forensic function aliases still work"""
-        self.assertIs(
-            parsedmarc.parse_forensic_report,
-            parsedmarc.parse_failure_report,
-        )
-        self.assertIs(
-            parsedmarc.parsed_forensic_reports_to_csv,
-            parsedmarc.parsed_failure_reports_to_csv,
-        )
-        self.assertIs(
-            parsedmarc.parsed_forensic_reports_to_csv_rows,
-            parsedmarc.parsed_failure_reports_to_csv_rows,
-        )
-        self.assertIs(
-            parsedmarc.InvalidForensicReport,
-            parsedmarc.InvalidFailureReport,
-        )
-
-    def testDMARCbisDraftSample(self):
-        """Test parsing the sample report from the DMARCbis aggregate draft"""
-        print()
-        sample_path = (
-            "samples/aggregate/dmarcbis-draft-sample.xml"
-        )
-        print("Testing {0}: ".format(sample_path), end="")
-        result = parsedmarc.parse_report_file(
-            sample_path, always_use_local_files=True, offline=True
-        )
-        report = result["report"]
-
-        # Verify report_type
-        self.assertEqual(result["report_type"], "aggregate")
-
-        # Verify xml_schema
-        self.assertEqual(report["xml_schema"], "1.0")
-
-        # Verify report_metadata
-        metadata = report["report_metadata"]
-        self.assertEqual(metadata["org_name"], "Sample Reporter")
-        self.assertEqual(
-            metadata["org_email"], "report_sender@example-reporter.com"
-        )
-        self.assertEqual(
-            metadata["org_extra_contact_info"], "..."
-        )
-        self.assertEqual(
-            metadata["report_id"], "3v98abbp8ya9n3va8yr8oa3ya"
-        )
-        self.assertEqual(
-            metadata["generator"],
-            "Example DMARC Aggregate Reporter v1.2",
-        )
-
-        # Verify DMARCbis policy_published fields
-        pp = report["policy_published"]
-        self.assertEqual(pp["domain"], "example.com")
-        self.assertEqual(pp["p"], "quarantine")
-        self.assertEqual(pp["sp"], "none")
-        self.assertEqual(pp["np"], "none")
-        self.assertEqual(pp["testing"], "n")
-        self.assertEqual(pp["discovery_method"], "treewalk")
-        # adkim/aspf/pct/fo default when not in XML
-        self.assertEqual(pp["adkim"], "r")
-        self.assertEqual(pp["aspf"], "r")
-        self.assertEqual(pp["pct"], "100")
-        self.assertEqual(pp["fo"], "0")
-
-        # Verify record
-        self.assertEqual(len(report["records"]), 1)
-        rec = report["records"][0]
-        self.assertEqual(rec["source"]["ip_address"], "192.0.2.123")
-        self.assertEqual(rec["count"], 123)
-        self.assertEqual(
-            rec["policy_evaluated"]["disposition"], "pass"
-        )
-        self.assertEqual(rec["policy_evaluated"]["dkim"], "pass")
-        self.assertEqual(rec["policy_evaluated"]["spf"], "fail")
-
-        # Verify DKIM auth result with human_result
-        self.assertEqual(len(rec["auth_results"]["dkim"]), 1)
-        dkim = rec["auth_results"]["dkim"][0]
-        self.assertEqual(dkim["domain"], "example.com")
-        self.assertEqual(dkim["selector"], "abc123")
-        self.assertEqual(dkim["result"], "pass")
-        self.assertIsNone(dkim["human_result"])
-
-        # Verify SPF auth result with human_result
-        self.assertEqual(len(rec["auth_results"]["spf"]), 1)
-        spf = rec["auth_results"]["spf"][0]
-        self.assertEqual(spf["domain"], "example.com")
-        self.assertEqual(spf["result"], "fail")
-        self.assertIsNone(spf["human_result"])
-
-        # Verify CSV output includes new fields
-        csv = parsedmarc.parsed_aggregate_reports_to_csv(report)
-        header = csv.split("\n")[0]
-        self.assertIn("np", header.split(","))
-        self.assertIn("testing", header.split(","))
-        self.assertIn("discovery_method", header.split(","))
-        print("Passed!")
-
-    def testDMARCbisFieldsWithRFC7489(self):
-        """Test that RFC 7489 reports have None for DMARCbis-only fields"""
-        print()
-        sample_path = (
-            "samples/aggregate/"
-            "example.net!example.com!1529366400!1529452799.xml"
-        )
-        print("Testing {0}: ".format(sample_path), end="")
-        result = parsedmarc.parse_report_file(
-            sample_path, always_use_local_files=True, offline=True
-        )
-        report = result["report"]
-        pp = report["policy_published"]
-
-        # RFC 7489 fields present
-        self.assertEqual(pp["pct"], "100")
-        self.assertEqual(pp["fo"], "0")
-
-        # DMARCbis fields absent (None)
-        self.assertIsNone(pp["np"])
-        self.assertIsNone(pp["testing"])
-        self.assertIsNone(pp["discovery_method"])
-
-        # generator absent (None)
-        self.assertIsNone(report["report_metadata"]["generator"])
-        print("Passed!")
-
-    def testDMARCbisWithExplicitFields(self):
-        """Test DMARCbis report with explicit testing and discovery_method"""
-        print()
-        sample_path = (
-            "samples/aggregate/"
-            "dmarcbis-example.net!example.com!1700000000!1700086399.xml"
-        )
-        print("Testing {0}: ".format(sample_path), end="")
-        result = parsedmarc.parse_report_file(
-            sample_path, always_use_local_files=True, offline=True
-        )
-        report = result["report"]
-        pp = report["policy_published"]
-
-        self.assertEqual(pp["np"], "reject")
-        self.assertEqual(pp["testing"], "y")
-        self.assertEqual(pp["discovery_method"], "treewalk")
-        print("Passed!")
-
    def testSmtpTlsSamples(self):
        """Test sample SMTP TLS reports"""
        print()
@@ -307,9 +152,7 @@ class Test(unittest.TestCase):
            if os.path.isdir(sample_path):
                continue
            print("Testing {0}: ".format(sample_path), end="")
-            parsed_report = parsedmarc.parse_report_file(
-                sample_path, offline=OFFLINE_MODE
-            )["report"]
+            parsed_report = parsedmarc.parse_report_file(sample_path)["report"]
            parsedmarc.parsed_smtp_tls_reports_to_csv(parsed_report)
            print("Passed!")
Author	SHA1	Message	Date
copilot-swe-agent[bot]	2174f23eb5	Add comprehensive TypedDicts to minimize Any usage in public APIs Co-authored-by: seanthegeek <44679+seanthegeek@users.noreply.github.com>	2025-12-17 22:28:19 +00:00
copilot-swe-agent[bot]	febbb107c4	Fix Python 3.9 compatibility: replace pipe union syntax with Union/Optional Co-authored-by: seanthegeek <44679+seanthegeek@users.noreply.github.com>	2025-12-17 22:18:57 +00:00
copilot-swe-agent[bot]	9a64b494e7	Fix code review issues: incomplete isinstance and variable name mismatch Co-authored-by: seanthegeek <44679+seanthegeek@users.noreply.github.com>	2025-12-17 21:45:21 +00:00
copilot-swe-agent[bot]	e93209c766	Fix function signatures and improve type annotations Co-authored-by: seanthegeek <44679+seanthegeek@users.noreply.github.com>	2025-12-17 21:42:25 +00:00
copilot-swe-agent[bot]	d1c22466be	Replace OrderedDict with dict and add TypedDict definitions Co-authored-by: seanthegeek <44679+seanthegeek@users.noreply.github.com>	2025-12-17 21:36:57 +00:00
copilot-swe-agent[bot]	3d1b2522d3	Initial plan	2025-12-17 21:19:30 +00:00