Update docs

Normalize timespans for aggregate reports in Elasticsearch and Opensearch
Update launch configuration and metadata key for timespan in aggregate report
2026-02-19 16:06:22 +00:00 · 2025-12-01 17:04:37 -05:00 · 2025-12-01 16:34:40 -05:00 · 2025-12-01 16:10:41 -05:00 · 2025-11-30 19:43:14 -05:00 · 2025-11-30 16:17:07 -05:00
34 changed files with 894 additions and 993 deletions
--- a/.github/workflows/docker.yml
+++ b/.github/workflows/docker.yml
@@ -24,11 +24,11 @@ jobs:

    steps:
      - name: Checkout repository
-        uses: actions/checkout@v5
+        uses: actions/checkout@v3

      - name: Docker meta
        id: meta
-        uses: docker/metadata-action@v5
+        uses: docker/metadata-action@v3
        with:
          images: |
            ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
@@ -40,14 +40,16 @@ jobs:
            type=semver,pattern={{major}}.{{minor}}

      - name: Log in to the Container registry
-        uses: docker/login-action@v3
+        # https://github.com/docker/login-action/releases/tag/v2.0.0
+        uses: docker/login-action@49ed152c8eca782a232dede0303416e8f356c37b
        with:
          registry: ${{ env.REGISTRY }}
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}

      - name: Build and push Docker image
-        uses: docker/build-push-action@v6
+        # https://github.com/docker/build-push-action/releases/tag/v3.0.0
+        uses: docker/build-push-action@e551b19e49efd4e98792db7592c17c09b89db8d8
        with:
          context: .
          push: ${{ github.event_name == 'release' }}
--- a/.github/workflows/python-tests.yml
+++ b/.github/workflows/python-tests.yml
@@ -15,7 +15,7 @@ jobs:

    services:
      elasticsearch:
-        image: elasticsearch:8.19.7
+        image: elasticsearch:8.18.2
        env:
          discovery.type: single-node
          cluster.name: parsedmarc-cluster
@@ -33,15 +33,15 @@ jobs:
        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13"]

    steps:
-    - uses: actions/checkout@v5
+    - uses: actions/checkout@v4
    - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v6
+      uses: actions/setup-python@v5
      with:
        python-version: ${{ matrix.python-version }}
    - name: Install system dependencies
      run: |
-        sudo apt-get -q update
-        sudo apt-get -qy install libemail-outlook-message-perl
+        sudo apt-get update
+        sudo apt-get install -y libemail-outlook-message-perl
    - name: Install Python dependencies
      run: |
        python -m pip install --upgrade pip
@@ -65,6 +65,6 @@ jobs:
      run: |
        hatch build
    - name: Upload coverage to Codecov
-      uses: codecov/codecov-action@v5
+      uses: codecov/codecov-action@v4
      with:
          token: ${{ secrets.CODECOV_TOKEN }}
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -36,7 +36,6 @@
        "exampleuser",
        "expiringdict",
        "fieldlist",
-        "GELF",
        "genindex",
        "geoip",
        "geoipupdate",
@@ -66,20 +65,17 @@
        "mailrelay",
        "mailsuite",
        "maxdepth",
-        "MAXHEADERS",
        "maxmind",
        "mbox",
        "mfrom",
        "michaeldavie",
        "mikesiegel",
-        "Mimecast",
        "mitigations",
        "MMDB",
        "modindex",
        "msgconvert",
        "msgraph",
        "MSSP",
-        "multiprocess",
        "Munge",
        "ndjson",
        "newkey",
@@ -90,7 +86,6 @@
        "nosniff",
        "nwettbewerb",
        "opensearch",
-        "opensearchpy",
        "parsedmarc",
        "passsword",
        "Postorius",
@@ -128,7 +123,6 @@
        "truststore",
        "Übersicht",
        "uids",
-        "Uncategorized",
        "unparasable",
        "uper",
        "urllib",
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
--- a/README.md
+++ b/README.md
@@ -23,10 +23,11 @@ ProofPoint Email Fraud Defense, and Valimail.

 ## Help Wanted

-This project is maintained by one developer. Please consider reviewing the open
-[issues](https://github.com/domainaware/parsedmarc/issues) to see how you can
-contribute code, documentation, or user support. Assistance on the pinned
-issues would be particularly helpful.
+This project is maintained by one developer. Please consider
+reviewing the open
+[issues](https://github.com/domainaware/parsedmarc/issues) to see how
+you can contribute code, documentation, or user support. Assistance on
+the pinned issues would be particularly helpful.

 Thanks to all
 [contributors](https://github.com/domainaware/parsedmarc/graphs/contributors)!
@@ -41,24 +42,6 @@ Thanks to all
 - Consistent data structures
 - Simple JSON and/or CSV output
 - Optionally email the results
- Optionally send the results to Elasticsearch, Opensearch, and/or Splunk, for
-  use with premade dashboards
+- Optionally send the results to Elasticsearch, Opensearch, and/or Splunk, for use
+    with premade dashboards
 - Optionally send reports to Apache Kafka
-
-## Python Compatibility
-
-This project supports the following Python versions, which are either actively maintained or are the default versions
-for RHEL or Debian.
-
-| Version | Supported | Reason                                                     |
-|---------|-----------|------------------------------------------------------------|
-| < 3.6   | ❌         | End of Life (EOL)                                          |
-| 3.6     | ❌         | Used in RHEL 8, but not supported by project dependencies |
-| 3.7     | ❌         | End of Life (EOL)                                          |
-| 3.8     | ❌         | End of Life (EOL)                                          |
-| 3.9     | ✅         | Supported until August 2026 (Debian 11); May 2032 (RHEL 9) |
-| 3.10    | ✅         | Actively maintained                                        |
-| 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    | ❌         | Not currently supported due to [this Python bug](https://github.com/python/cpython/issues/142307)|
--- a/build.sh
+++ b/build.sh
@@ -14,7 +14,7 @@ cd docs
 make clean 
 make html
 touch build/html/.nojekyll
-if [  -d "../../parsedmarc-docs" ]; then
+if [  -d "./../parsedmarc-docs" ]; then
  cp -rf build/html/* ../../parsedmarc-docs/
 fi
 cd ..
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -1,6 +1,8 @@
+version: '3.7'
+
 services:
  elasticsearch:
-    image: docker.elastic.co/elasticsearch/elasticsearch:8.19.7
+    image: docker.elastic.co/elasticsearch/elasticsearch:8.3.1
    environment:
      - network.host=127.0.0.1
      - http.host=0.0.0.0
@@ -12,7 +14,7 @@ services:
      - xpack.security.enabled=false
      - xpack.license.self_generated.type=basic
    ports:
-      - "127.0.0.1:9200:9200"
+      - 127.0.0.1:9200:9200
    ulimits:
      memlock:
        soft: -1
@@ -28,7 +30,7 @@ services:
      retries: 24

  opensearch:
-    image: opensearchproject/opensearch:2
+    image: opensearchproject/opensearch:2.18.0
    environment:
      - network.host=127.0.0.1
      - http.host=0.0.0.0
@@ -39,7 +41,7 @@ services:
      - bootstrap.memory_lock=true
      - OPENSEARCH_INITIAL_ADMIN_PASSWORD=${OPENSEARCH_INITIAL_ADMIN_PASSWORD}
    ports:
-      - "127.0.0.1:9201:9200"
+      - 127.0.0.1:9201:9200
    ulimits:
      memlock:
        soft: -1
--- a/docs/source/conf.py
+++ b/docs/source/conf.py
@@ -20,7 +20,7 @@ from parsedmarc import __version__
 # -- Project information -----------------------------------------------------

 project = "parsedmarc"
-copyright = "2018 - 2025, Sean Whalen and contributors"
+copyright = "2018 - 2023, Sean Whalen and contributors"
 author = "Sean Whalen and contributors"

 # The version info for the project you're documenting, acts as replacement for
--- a/docs/source/index.md
+++ b/docs/source/index.md
@@ -45,24 +45,6 @@ and Valimail.
    with premade dashboards
 - Optionally send reports to Apache Kafka

-## Python Compatibility
-
-This project supports the following Python versions, which are either actively maintained or are the default versions
-for RHEL or Debian.
-
-| Version | Supported | Reason                                                     |
-|---------|-----------|------------------------------------------------------------|
-| < 3.6   | ❌         | End of Life (EOL)                                          |
-| 3.6     | ❌         | Used in RHEL 8, but not supported by project dependencies |
-| 3.7     | ❌         | End of Life (EOL)                                          |
-| 3.8     | ❌         | End of Life (EOL)                                          |
-| 3.9     | ✅         | Supported until August 2026 (Debian 11); May 2032 (RHEL 9) |
-| 3.10    | ✅         | Actively maintained                                        |
-| 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    | ❌         | Not currently supported due to [this Python bug](https://github.com/python/cpython/issues/142307)|
-
 ```{toctree}
 :caption: 'Contents'
 :maxdepth: 2
--- a/docs/source/installation.md
+++ b/docs/source/installation.md
@@ -199,7 +199,7 @@ sudo apt-get install libemail-outlook-message-perl
 [geoipupdate releases page on github]: https://github.com/maxmind/geoipupdate/releases
 [ip to country lite database]: https://db-ip.com/db/download/ip-to-country-lite
 [license keys]: https://www.maxmind.com/en/accounts/current/license-key
-[maxmind geoipupdate page]: https://dev.maxmind.com/geoip/updating-databases/
+[maxmind geoipupdate page]: https://dev.maxmind.com/geoip/geoipupdate/
 [maxmind geolite2 country database]: https://dev.maxmind.com/geoip/geolite2-free-geolocation-data
 [registering for a free geolite2 account]: https://www.maxmind.com/en/geolite2/signup
 [to comply with various privacy regulations]: https://blog.maxmind.com/2019/12/18/significant-changes-to-accessing-and-using-geolite2-databases/
--- a/docs/source/usage.md
+++ b/docs/source/usage.md
@@ -172,7 +172,7 @@ The full set of configuration options are:
      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"}. 
+      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
@@ -257,7 +257,7 @@ The full set of configuration options are:
    :::
  - `user` - str: Basic auth username
  - `password` - str: Basic auth password
-  - `api_key` - str: API key
+  - `apiKey` - str: API key
  - `ssl` - bool: Use an encrypted SSL/TLS connection
    (Default: `True`)
  - `timeout` - float: Timeout in seconds (Default: 60)
@@ -280,7 +280,7 @@ The full set of configuration options are:
    :::
  - `user` - str: Basic auth username
  - `password` - str: Basic auth password
-  - `api_key` - str: API key
+  - `apiKey` - str: API key
  - `ssl` - bool: Use an encrypted SSL/TLS connection
    (Default: `True`)
  - `timeout` - float: Timeout in seconds (Default: 60)
--- a/kibana/export.ndjson
+++ b/kibana/export.ndjson
--- a/parsedmarc/init.py
+++ b/parsedmarc/init.py
@@ -4,7 +4,7 @@

 from __future__ import annotations

-from typing import Dict, List, Any, Union, Optional, IO, Callable
+from typing import Dict, List, Any, Union, IO, Callable

 import binascii
 import email
@@ -220,8 +220,8 @@ def _bucket_interval_by_day(


 def _append_parsed_record(
-    parsed_record: OrderedDict[str, Any],
-    records: OrderedDict[str, Any],
+    parsed_record: Dict[str, Any],
+    records: List[Dict[str, Any]],
    begin_dt: datetime,
    end_dt: datetime,
    normalize: bool,
@@ -264,16 +264,15 @@ def _append_parsed_record(


 def _parse_report_record(
-    record: OrderedDict,
-    *,
-    ip_db_path: Optional[str] = None,
+    record: dict,
+    ip_db_path: str = None,
    always_use_local_files: bool = False,
-    reverse_dns_map_path: Optional[str] = None,
-    reverse_dns_map_url: Optional[str] = None,
+    reverse_dns_map_path: str = None,
+    reverse_dns_map_url: str = None,
    offline: bool = False,
-    nameservers: Optional[list[str]] = None,
-    dns_timeout: Optional[float] = 2.0,
-) -> OrderedDict[str, Any]:
+    nameservers: list[str] = None,
+    dns_timeout: float = 2.0,
+):
    """
    Converts a record from a DMARC aggregate report into a more consistent
    format
@@ -427,7 +426,7 @@ def _parse_report_record(
    return new_record


-def _parse_smtp_tls_failure_details(failure_details: dict[str, Any]):
+def _parse_smtp_tls_failure_details(failure_details: dict):
    try:
        new_failure_details = OrderedDict(
            result_type=failure_details["result-type"],
@@ -463,7 +462,7 @@ def _parse_smtp_tls_failure_details(failure_details: dict[str, Any]):
        raise InvalidSMTPTLSReport(str(e))


-def _parse_smtp_tls_report_policy(policy: dict[str, Any]):
+def _parse_smtp_tls_report_policy(policy: dict):
    policy_types = ["tlsa", "sts", "no-policy-found"]
    try:
        policy_domain = policy["policy"]["policy-domain"]
@@ -500,7 +499,7 @@ def _parse_smtp_tls_report_policy(policy: dict[str, Any]):
        raise InvalidSMTPTLSReport(str(e))


-def parse_smtp_tls_report_json(report: dict[str, Any]):
+def parse_smtp_tls_report_json(report: dict):
    """Parses and validates an SMTP TLS report"""
    required_fields = [
        "organization-name",
@@ -539,7 +538,7 @@ def parse_smtp_tls_report_json(report: dict[str, Any]):
        raise InvalidSMTPTLSReport(str(e))


-def parsed_smtp_tls_reports_to_csv_rows(reports: OrderedDict[str, Any]):
+def parsed_smtp_tls_reports_to_csv_rows(reports: dict):
    """Converts one oor more parsed SMTP TLS reports into a list of single
    layer OrderedDict objects suitable for use in a CSV"""
    if type(reports) is OrderedDict:
@@ -574,7 +573,7 @@ def parsed_smtp_tls_reports_to_csv_rows(reports: OrderedDict[str, Any]):
    return rows


-def parsed_smtp_tls_reports_to_csv(reports: OrderedDict[str, Any]) -> str:
+def parsed_smtp_tls_reports_to_csv(reports: dict):
    """
    Converts one or more parsed SMTP TLS reports to flat CSV format, including
    headers
@@ -621,17 +620,16 @@ def parsed_smtp_tls_reports_to_csv(reports: OrderedDict[str, Any]) -> str:

 def parse_aggregate_report_xml(
    xml: str,
-    *,
-    ip_db_path: Optional[bool] = None,
-    always_use_local_files: Optional[bool] = False,
-    reverse_dns_map_path: Optional[bool] = None,
-    reverse_dns_map_url: Optional[bool] = None,
-    offline: Optional[bool] = False,
-    nameservers: Optional[list[str]] = None,
-    timeout: Optional[float] = 2.0,
-    keep_alive: Optional[callable] = None,
-    normalize_timespan_threshold_hours: Optional[float] = 24.0,
-) -> OrderedDict[str, Any]:
+    ip_db_path: bool = None,
+    always_use_local_files: bool = False,
+    reverse_dns_map_path: bool = None,
+    reverse_dns_map_url: bool = None,
+    offline: bool = False,
+    nameservers: bool = None,
+    timeout: float = 2.0,
+    keep_alive: callable = None,
+    normalize_timespan_threshold_hours: float = 24.0,
+):
    """Parses a DMARC XML report string and returns a consistent OrderedDict

    Args:
@@ -834,7 +832,7 @@ def parse_aggregate_report_xml(
        raise InvalidAggregateReport("Unexpected error: {0}".format(error.__str__()))


-def extract_report(content: Union[bytes, str, IO[Any]]) -> str:
+def extract_report(content: Union[bytes, str, IO[Any]]):
    """
    Extracts text from a zip or gzip file, as a base64-encoded string,
    file-like object, or bytes.
@@ -853,7 +851,9 @@ def extract_report(content: Union[bytes, str, IO[Any]]) -> str:
            try:
                file_object = BytesIO(b64decode(content))
            except binascii.Error:
-                return content
+                pass
+            if file_object is None:
+                file_object = open(content, "rb")
        elif type(content) is bytes:
            file_object = BytesIO(content)
        else:
@@ -877,18 +877,16 @@ def extract_report(content: Union[bytes, str, IO[Any]]) -> str:
        file_object.close()

    except UnicodeDecodeError:
-        if file_object:
-            file_object.close()
+        file_object.close()
        raise ParserError("File objects must be opened in binary (rb) mode")
    except Exception as error:
-        if file_object:
-            file_object.close()
+        file_object.close()
        raise ParserError("Invalid archive file: {0}".format(error.__str__()))

    return report


-def extract_report_from_file_path(file_path: str):
+def extract_report_from_file_path(file_path):
    """Extracts report from a file at the given file_path"""
    try:
        with open(file_path, "rb") as report_file:
@@ -899,22 +897,21 @@ def extract_report_from_file_path(file_path: str):

 def parse_aggregate_report_file(
    _input: Union[str, bytes, IO[Any]],
-    *,
-    offline: Optional[bool] = False,
-    always_use_local_files: Optional[bool] = None,
-    reverse_dns_map_path: Optional[str] = None,
-    reverse_dns_map_url: Optional[str] = None,
-    ip_db_path: Optional[str] = None,
-    nameservers: Optional[list[str]] = None,
-    dns_timeout: Optional[float] = 2.0,
-    keep_alive: Optional[Callable] = None,
-    normalize_timespan_threshold_hours: Optional[float] = 24.0,
-) -> OrderedDict[str, any]:
+    offline: bool = False,
+    always_use_local_files: bool = None,
+    reverse_dns_map_path: str = None,
+    reverse_dns_map_url: str = None,
+    ip_db_path: str = None,
+    nameservers: list[str] = None,
+    dns_timeout: float = 2.0,
+    keep_alive: Callable = None,
+    normalize_timespan_threshold_hours: float = 24.0,
+):
    """Parses a file at the given path, a file-like object. or bytes as an
    aggregate DMARC report

    Args:
-        _input (str | bytes | IO): A path to a file, a file like object, or bytes
+        _input: A path to a file, a file like object, or bytes
        offline (bool): Do not query online for geolocation or DNS
        always_use_local_files (bool): Do not download files
        reverse_dns_map_path (str): Path to a reverse DNS map file
@@ -949,9 +946,7 @@ def parse_aggregate_report_file(
    )


-def parsed_aggregate_reports_to_csv_rows(
-    reports: list[OrderedDict[str, Any]],
-) -> list[dict[str, Any]]:
+def parsed_aggregate_reports_to_csv_rows(reports: list[dict]):
    """
    Converts one or more parsed aggregate reports to list of dicts in flat CSV
    format
@@ -1075,7 +1070,7 @@ def parsed_aggregate_reports_to_csv_rows(
    return rows


-def parsed_aggregate_reports_to_csv(reports: list[OrderedDict[str, Any]]) -> str:
+def parsed_aggregate_reports_to_csv(reports: list[OrderedDict]):
    """
    Converts one or more parsed aggregate reports to flat CSV format, including
    headers
@@ -1145,16 +1140,15 @@ def parse_forensic_report(
    feedback_report: str,
    sample: str,
    msg_date: datetime,
-    *,
-    always_use_local_files: Optional[bool] = False,
-    reverse_dns_map_path: Optional[str] = None,
+    always_use_local_files: bool = False,
+    reverse_dns_map_path: str = None,
    reverse_dns_map_url: str = None,
-    offline: Optional[bool] = False,
-    ip_db_path: Optional[str] = None,
-    nameservers: Optional[list[str]] = None,
-    dns_timeout: Optional[float] = 2.0,
-    strip_attachment_payloads: Optional[bool] = False,
-) -> OrderedDict[str, Any]:
+    offline: bool = False,
+    ip_db_path: str = None,
+    nameservers: list[str] = None,
+    dns_timeout: float = 2.0,
+    strip_attachment_payloads: bool = False,
+):
    """
    Converts a DMARC forensic report and sample to a ``OrderedDict``

@@ -1282,7 +1276,7 @@ def parse_forensic_report(
        raise InvalidForensicReport("Unexpected error: {0}".format(error.__str__()))


-def parsed_forensic_reports_to_csv_rows(reports: list[OrderedDict[str, Any]]):
+def parsed_forensic_reports_to_csv_rows(reports: list[OrderedDict]):
    """
    Converts one or more parsed forensic reports to a list of dicts in flat CSV
    format
@@ -1318,7 +1312,7 @@ def parsed_forensic_reports_to_csv_rows(reports: list[OrderedDict[str, Any]]):
    return rows


-def parsed_forensic_reports_to_csv(reports: list[dict[str, Any]]) -> str:
+def parsed_forensic_reports_to_csv(reports: list[dict]):
    """
    Converts one or more parsed forensic reports to flat CSV format, including
    headers
@@ -1372,18 +1366,17 @@ def parsed_forensic_reports_to_csv(reports: list[dict[str, Any]]) -> str:

 def parse_report_email(
    input_: Union[bytes, str],
-    *,
-    offline: Optional[bool] = False,
-    ip_db_path: Optional[str] = None,
-    always_use_local_files: Optional[bool] = False,
-    reverse_dns_map_path: Optional[str] = None,
-    reverse_dns_map_url: Optional[str] = None,
+    offline: bool = False,
+    ip_db_path: str = None,
+    always_use_local_files: bool = False,
+    reverse_dns_map_path: str = None,
+    reverse_dns_map_url: str = None,
    nameservers: list[str] = None,
-    dns_timeout: Optional[float] = 2.0,
-    strip_attachment_payloads: Optional[bool] = False,
-    keep_alive: Optional[callable] = None,
-    normalize_timespan_threshold_hours: Optional[float] = 24.0,
-) -> OrderedDict[str, Any]:
+    dns_timeout: float = 2.0,
+    strip_attachment_payloads: bool = False,
+    keep_alive: callable = None,
+    normalize_timespan_threshold_hours: float = 24.0,
+):
    """
    Parses a DMARC report from an email

@@ -1570,23 +1563,22 @@ def parse_report_email(

 def parse_report_file(
    input_: Union[bytes, str, IO[Any]],
-    *,
-    nameservers: Optional[list[str]] = None,
-    dns_timeout: Optional[float] = 2.0,
-    strip_attachment_payloads: Optional[bool] = False,
-    ip_db_path: Optional[str] = None,
-    always_use_local_files: Optional[bool] = False,
-    reverse_dns_map_path: Optional[str] = None,
-    reverse_dns_map_url: Optional[str] = None,
-    offline: Optional[bool] = False,
-    keep_alive: Optional[Callable] = None,
-    normalize_timespan_threshold_hours: Optional[float] = 24,
-) -> OrderedDict[str, Any]:
+    nameservers: list[str] = None,
+    dns_timeout: float = 2.0,
+    strip_attachment_payloads: bool = False,
+    ip_db_path: str = None,
+    always_use_local_files: bool = False,
+    reverse_dns_map_path: str = None,
+    reverse_dns_map_url: str = None,
+    offline: bool = False,
+    keep_alive: Callable = None,
+    normalize_timespan_threshold_hours: float = 24,
+):
    """Parses a DMARC aggregate or forensic file at the given path, a
    file-like object. or bytes

    Args:
-        input_ (str | bytes | IO): A path to a file, a file like object, or bytes
+        input_: A path to a file, a file like object, or bytes
        nameservers (list): A list of one or more nameservers to use
            (Cloudflare's public DNS resolvers by default)
        dns_timeout (float): Sets the DNS timeout in seconds
@@ -1612,8 +1604,6 @@ def parse_report_file(

    content = file_object.read()
    file_object.close()
-    if content.startswith(MAGIC_ZIP) or content.startswith(MAGIC_GZIP):
-        content = extract_report(content)
    try:
        report = parse_aggregate_report_file(
            content,
@@ -1655,22 +1645,21 @@ def parse_report_file(

 def get_dmarc_reports_from_mbox(
    input_: str,
-    *,
-    nameservers: Optional[list[str]] = None,
-    dns_timeout: Optional[float] = 2.0,
-    strip_attachment_payloads: Optional[bool] = False,
-    ip_db_path: Optional[str] = None,
-    always_use_local_files: Optional[bool] = False,
-    reverse_dns_map_path: Optional[str] = None,
-    reverse_dns_map_url: Optional[str] = None,
-    offline: Optional[bool] = False,
-    normalize_timespan_threshold_hours: Optional[float] = 24.0,
-) -> OrderedDict[str, OrderedDict[str, Any]]:
+    nameservers: list[str] = None,
+    dns_timeout: float = 2.0,
+    strip_attachment_payloads: bool = False,
+    ip_db_path: str = None,
+    always_use_local_files: bool = False,
+    reverse_dns_map_path: str = None,
+    reverse_dns_map_url: str = None,
+    offline: bool = False,
+    normalize_timespan_threshold_hours: float = 24.0,
+):
    """Parses a mailbox in mbox format containing e-mails with attached
    DMARC reports

    Args:
-        input_ (str): A path to a mbox file
+        input_: A path to a mbox file
        nameservers (list): A list of one or more nameservers to use
            (Cloudflare's public DNS resolvers by default)
        dns_timeout (float): Sets the DNS timeout in seconds
@@ -1684,7 +1673,7 @@ def get_dmarc_reports_from_mbox(
        normalize_timespan_threshold_hours (float): Normalize timespans beyond this

    Returns:
-        OrderedDict: Lists of ``aggregate_reports``, ``forensic_reports``, and ``smtp_tls_reports``
+        OrderedDict: Lists of ``aggregate_reports`` and ``forensic_reports``

    """
    aggregate_reports = []
@@ -1744,32 +1733,31 @@ def get_dmarc_reports_from_mbox(

 def get_dmarc_reports_from_mailbox(
    connection: MailboxConnection,
-    *,
-    reports_folder: Optional[str] = "INBOX",
-    archive_folder: Optional[str] = "Archive",
-    delete: Optional[bool] = False,
-    test: Optional[bool] = False,
-    ip_db_path: Optional[str] = None,
-    always_use_local_files: Optional[str] = False,
-    reverse_dns_map_path: Optional[str] = None,
-    reverse_dns_map_url: Optional[str] = None,
-    offline: Optional[bool] = False,
-    nameservers: Optional[list[str]] = None,
-    dns_timeout: Optional[float] = 6.0,
-    strip_attachment_payloads: Optional[bool] = False,
-    results: Optional[OrderedDict[str, any]] = None,
-    batch_size: Optional[int] = 10,
-    since: Optional[datetime] = None,
-    create_folders: Optional[bool] = True,
-    normalize_timespan_threshold_hours: Optional[float] = 24,
-) -> OrderedDict[str, OrderedDict[str, Any]]:
+    reports_folder: str = "INBOX",
+    archive_folder: str = "Archive",
+    delete: bool = False,
+    test: bool = False,
+    ip_db_path: str = None,
+    always_use_local_files: str = False,
+    reverse_dns_map_path: str = None,
+    reverse_dns_map_url: str = None,
+    offline: bool = False,
+    nameservers: list[str] = None,
+    dns_timeout: float = 6.0,
+    strip_attachment_payloads: bool = False,
+    results: dict = None,
+    batch_size: int = 10,
+    since: datetime = None,
+    create_folders: bool = True,
+    normalize_timespan_threshold_hours: float = 24,
+):
    """
    Fetches and parses DMARC reports from a mailbox

    Args:
        connection: A Mailbox connection object
-        reports_folder (str): The folder where reports can be found
-        archive_folder (str): The folder to move processed mail to
+        reports_folder: The folder where reports can be found
+        archive_folder: The folder to move processed mail to
        delete (bool): Delete  messages after processing them
        test (bool): Do not move or delete messages after processing them
        ip_db_path (str): Path to a MMDB file from MaxMind or DBIP
@@ -1791,7 +1779,7 @@ def get_dmarc_reports_from_mailbox(
        normalize_timespan_threshold_hours (float): Normalize timespans beyond this

    Returns:
-        OrderedDict: Lists of ``aggregate_reports``, ``forensic_reports``, and ``smtp_tls_reports``
+        OrderedDict: Lists of ``aggregate_reports`` and ``forensic_reports``
    """
    if delete and test:
        raise ValueError("delete and test options are mutually exclusive")
@@ -1849,7 +1837,7 @@ def get_dmarc_reports_from_mailbox(
        if isinstance(connection, IMAPConnection):
            logger.debug(
                "Only days and weeks values in 'since' option are \
-                         considered for IMAP connections. Examples: 2d or 1w"
+                         considered for IMAP conections. Examples: 2d or 1w"
            )
            since = (datetime.now(timezone.utc) - timedelta(minutes=_since)).date()
            current_time = datetime.now(timezone.utc).date()
@@ -2067,22 +2055,21 @@ def get_dmarc_reports_from_mailbox(
 def watch_inbox(
    mailbox_connection: MailboxConnection,
    callback: Callable,
-    *,
-    reports_folder: Optional[str] = "INBOX",
-    archive_folder: Optional[str] = "Archive",
-    delete: Optional[bool] = False,
-    test: Optional[bool] = False,
-    check_timeout: Optional[int] = 30,
-    ip_db_path: Optional[str] = None,
-    always_use_local_files: Optional[bool] = False,
-    reverse_dns_map_path: Optional[str] = None,
-    reverse_dns_map_url: Optional[str] = None,
-    offline: Optional[bool] = False,
-    nameservers: Optional[list[str]] = None,
-    dns_timeout: Optional[float] = 6.0,
-    strip_attachment_payloads: Optional[bool] = False,
-    batch_size: Optional[int] = None,
-    normalize_timespan_threshold_hours: Optional[float] = 24,
+    reports_folder: str = "INBOX",
+    archive_folder: str = "Archive",
+    delete: bool = False,
+    test: bool = False,
+    check_timeout: int = 30,
+    ip_db_path: str = None,
+    always_use_local_files: bool = False,
+    reverse_dns_map_path: str = None,
+    reverse_dns_map_url: str = None,
+    offline: bool = False,
+    nameservers: list[str] = None,
+    dns_timeout: float = 6.0,
+    strip_attachment_payloads: bool = False,
+    batch_size: int = None,
+    normalize_timespan_threshold_hours: float = 24,
 ):
    """
    Watches the mailbox for new messages and
@@ -2091,8 +2078,8 @@ def watch_inbox(
    Args:
        mailbox_connection: The mailbox connection object
        callback: The callback function to receive the parsing results
-        reports_folder (str): The IMAP folder where reports can be found
-        archive_folder (str): The folder to move processed mail to
+        reports_folder: The IMAP folder where reports can be found
+        archive_folder: The folder to move processed mail to
        delete (bool): Delete  messages after processing them
        test (bool): Do not move or delete messages after processing them
        check_timeout (int): Number of seconds to wait for a IMAP IDLE response
@@ -2172,15 +2159,14 @@ def append_csv(filename, csv):


 def save_output(
-    results: OrderedDict[str, Any],
-    *,
-    output_directory: Optional[str] = "output",
-    aggregate_json_filename: Optional[str] = "aggregate.json",
-    forensic_json_filename: Optional[str] = "forensic.json",
-    smtp_tls_json_filename: Optional[str] = "smtp_tls.json",
-    aggregate_csv_filename: Optional[str] = "aggregate.csv",
-    forensic_csv_filename: Optional[str] = "forensic.csv",
-    smtp_tls_csv_filename: Optional[str] = "smtp_tls.csv",
+    results: OrderedDict,
+    output_directory: str = "output",
+    aggregate_json_filename: str = "aggregate.json",
+    forensic_json_filename: str = "forensic.json",
+    smtp_tls_json_filename: str = "smtp_tls.json",
+    aggregate_csv_filename: str = "aggregate.csv",
+    forensic_csv_filename: str = "forensic.csv",
+    smtp_tls_csv_filename: str = "smtp_tls.csv",
 ):
    """
    Save report data in the given directory
@@ -2258,7 +2244,7 @@ def save_output(
            sample_file.write(sample)


-def get_report_zip(results: OrderedDict[str, Any]) -> bytes:
+def get_report_zip(results: OrderedDict):
    """
    Creates a zip file of parsed report output

@@ -2304,28 +2290,27 @@ def get_report_zip(results: OrderedDict[str, Any]) -> bytes:


 def email_results(
-    results: OrderedDict,
-    *,
-    host: str,
-    mail_from: str,
-    mail_to: str,
-    mail_cc: list = None,
-    mail_bcc: list = None,
-    port: int = 0,
-    require_encryption: bool = False,
-    verify: bool = True,
-    username: str = None,
-    password: str = None,
-    subject: str = None,
-    attachment_filename: str = None,
-    message: str = None,
+    results,
+    host,
+    mail_from,
+    mail_to,
+    mail_cc=None,
+    mail_bcc=None,
+    port=0,
+    require_encryption=False,
+    verify=True,
+    username=None,
+    password=None,
+    subject=None,
+    attachment_filename=None,
+    message=None,
 ):
    """
    Emails parsing results as a zip file

    Args:
        results (OrderedDict): Parsing results
-        host (str): Mail server hostname or IP address
+        host: Mail server hostname or IP address
        mail_from: The value of the message from header
        mail_to (list): A list of addresses to mail to
        mail_cc (list): A list of addresses to CC
--- a/parsedmarc/cli.py
+++ b/parsedmarc/cli.py
@@ -593,7 +593,7 @@ def _main():
        elasticsearch_monthly_indexes=False,
        elasticsearch_username=None,
        elasticsearch_password=None,
-        elasticsearch_api_key=None,
+        elasticsearch_apiKey=None,
        opensearch_hosts=None,
        opensearch_timeout=60,
        opensearch_number_of_shards=1,
@@ -605,7 +605,7 @@ def _main():
        opensearch_monthly_indexes=False,
        opensearch_username=None,
        opensearch_password=None,
-        opensearch_api_key=None,
+        opensearch_apiKey=None,
        kafka_hosts=None,
        kafka_username=None,
        kafka_password=None,
@@ -729,11 +729,11 @@ def _main():
                    )
                    exit(-1)
            if "save_aggregate" in general_config:
-                opts.save_aggregate = general_config.getboolean("save_aggregate")
+                opts.save_aggregate = general_config["save_aggregate"]
            if "save_forensic" in general_config:
-                opts.save_forensic = general_config.getboolean("save_forensic")
+                opts.save_forensic = general_config["save_forensic"]
            if "save_smtp_tls" in general_config:
-                opts.save_smtp_tls = general_config.getboolean("save_smtp_tls")
+                opts.save_smtp_tls = general_config["save_smtp_tls"]
            if "debug" in general_config:
                opts.debug = general_config.getboolean("debug")
            if "verbose" in general_config:
@@ -804,9 +804,8 @@ def _main():
            if "ssl" in imap_config:
                opts.imap_ssl = imap_config.getboolean("ssl")
            if "skip_certificate_verification" in imap_config:
-                opts.imap_skip_certificate_verification = imap_config.getboolean(
-                    "skip_certificate_verification"
-                )
+                imap_verify = imap_config.getboolean("skip_certificate_verification")
+                opts.imap_skip_certificate_verification = imap_verify
            if "user" in imap_config:
                opts.imap_user = imap_config["user"]
            else:
@@ -982,12 +981,8 @@ def _main():
                opts.elasticsearch_username = elasticsearch_config["user"]
            if "password" in elasticsearch_config:
                opts.elasticsearch_password = elasticsearch_config["password"]
-            # Until 8.20
            if "apiKey" in elasticsearch_config:
                opts.elasticsearch_apiKey = elasticsearch_config["apiKey"]
-            # Since 8.20
-            if "api_key" in elasticsearch_config:
-                opts.elasticsearch_apiKey = elasticsearch_config["api_key"]

        if "opensearch" in config:
            opensearch_config = config["opensearch"]
@@ -1022,12 +1017,8 @@ def _main():
                opts.opensearch_username = opensearch_config["user"]
            if "password" in opensearch_config:
                opts.opensearch_password = opensearch_config["password"]
-            # Until 8.20
            if "apiKey" in opensearch_config:
                opts.opensearch_apiKey = opensearch_config["apiKey"]
-            # Since 8.20
-            if "api_key" in opensearch_config:
-                opts.opensearch_apiKey = opensearch_config["api_key"]

        if "splunk_hec" in config.sections():
            hec_config = config["splunk_hec"]
@@ -1184,9 +1175,7 @@ def _main():
            )
            opts.gmail_api_scopes = _str_to_list(opts.gmail_api_scopes)
            if "oauth2_port" in gmail_api_config:
-                opts.gmail_api_oauth2_port = gmail_api_config.getint(
-                    "oauth2_port", 8080
-                )
+                opts.gmail_api_oauth2_port = gmail_api_config.get("oauth2_port", 8080)

        if "maildir" in config.sections():
            maildir_api_config = config["maildir"]
@@ -1288,11 +1277,11 @@ def _main():
                    es_smtp_tls_index = "{0}{1}".format(prefix, es_smtp_tls_index)
                elastic.set_hosts(
                    opts.elasticsearch_hosts,
-                    use_ssl=opts.elasticsearch_ssl,
-                    ssl_cert_path=opts.elasticsearch_ssl_cert_path,
-                    username=opts.elasticsearch_username,
-                    password=opts.elasticsearch_password,
-                    api_key=opts.elasticsearch_api_key,
+                    opts.elasticsearch_ssl,
+                    opts.elasticsearch_ssl_cert_path,
+                    opts.elasticsearch_username,
+                    opts.elasticsearch_password,
+                    opts.elasticsearch_apiKey,
                    timeout=opts.elasticsearch_timeout,
                )
                elastic.migrate_indexes(
@@ -1320,11 +1309,11 @@ def _main():
                    os_smtp_tls_index = "{0}{1}".format(prefix, os_smtp_tls_index)
                opensearch.set_hosts(
                    opts.opensearch_hosts,
-                    use_ssl=opts.opensearch_ssl,
-                    ssl_cert_path=opts.opensearch_ssl_cert_path,
-                    username=opts.opensearch_username,
-                    password=opts.opensearch_password,
-                    api_key=opts.opensearch_api_key,
+                    opts.opensearch_ssl,
+                    opts.opensearch_ssl_cert_path,
+                    opts.opensearch_username,
+                    opts.opensearch_password,
+                    opts.opensearch_apiKey,
                    timeout=opts.opensearch_timeout,
                )
                opensearch.migrate_indexes(
@@ -1532,7 +1521,7 @@ def _main():
            if opts.imap_skip_certificate_verification:
                logger.debug("Skipping IMAP certificate verification")
                verify = False
-            if not opts.imap_ssl:
+            if opts.imap_ssl is False:
                ssl = False

            mailbox_connection = IMAPConnection(
--- a/parsedmarc/constants.py
+++ b/parsedmarc/constants.py
@@ -1,2 +1,2 @@
-__version__ = "9.0.3"
+__version__ = "9.0.0"
 USER_AGENT = f"parsedmarc/{__version__}"
--- a/parsedmarc/elastic.py
+++ b/parsedmarc/elastic.py
@@ -1,9 +1,5 @@
 # -*- coding: utf-8 -*-

-from __future__ import annotations
-
-from typing import Optional, Union, Any
-
 from collections import OrderedDict

 from elasticsearch_dsl.search import Q
@@ -93,15 +89,15 @@ class _AggregateReportDoc(Document):
    dkim_results = Nested(_DKIMResult)
    spf_results = Nested(_SPFResult)

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

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

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

    def save(self, **kwargs):
@@ -137,21 +133,21 @@ class _ForensicSampleDoc(InnerDoc):
    body = Text()
    attachments = Nested(_EmailAttachmentDoc)

-    def add_to(self, display_name: str, address: str):
+    def add_to(self, display_name, address):
        self.to.append(_EmailAddressDoc(display_name=display_name, address=address))

-    def add_reply_to(self, display_name: str, address: str):
+    def add_reply_to(self, display_name, address):
        self.reply_to.append(
            _EmailAddressDoc(display_name=display_name, address=address)
        )

-    def add_cc(self, display_name: str, address: str):
+    def add_cc(self, display_name, address):
        self.cc.append(_EmailAddressDoc(display_name=display_name, address=address))

-    def add_bcc(self, display_name: str, address: str):
+    def add_bcc(self, display_name, address):
        self.bcc.append(_EmailAddressDoc(display_name=display_name, address=address))

-    def add_attachment(self, filename: str, content_type: str, sha256: str):
+    def add_attachment(self, filename, content_type, sha256):
        self.attachments.append(
            _EmailAttachmentDoc(
                filename=filename, content_type=content_type, sha256=sha256
@@ -203,15 +199,15 @@ class _SMTPTLSPolicyDoc(InnerDoc):

    def add_failure_details(
        self,
-        result_type: str,
-        ip_address: str,
-        receiving_ip: str,
-        receiving_mx_helo: str,
-        failed_session_count: int,
-        sending_mta_ip: Optional[str] = None,
-        receiving_mx_hostname: Optional[str] = None,
-        additional_information_uri: Optional[str] = None,
-        failure_reason_code: Union[str, int, None] = None,
+        result_type,
+        ip_address,
+        receiving_ip,
+        receiving_mx_helo,
+        failed_session_count,
+        sending_mta_ip=None,
+        receiving_mx_hostname=None,
+        additional_information_uri=None,
+        failure_reason_code=None,
    ):
        _details = _SMTPTLSFailureDetailsDoc(
            result_type=result_type,
@@ -241,14 +237,13 @@ class _SMTPTLSReportDoc(Document):

    def add_policy(
        self,
-        policy_type: str,
-        policy_domain: str,
-        successful_session_count: int,
-        failed_session_count: int,
-        *,
-        policy_string: Optional[str] = None,
-        mx_host_patterns: Optional[list[str]] = None,
-        failure_details: Optional[str] = None,
+        policy_type,
+        policy_domain,
+        successful_session_count,
+        failed_session_count,
+        policy_string=None,
+        mx_host_patterns=None,
+        failure_details=None,
    ):
        self.policies.append(
            policy_type=policy_type,
@@ -266,25 +261,24 @@ class AlreadySaved(ValueError):


 def set_hosts(
-    hosts: Union[str, list[str]],
-    *,
-    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: Optional[float] = 60.0,
+    hosts,
+    use_ssl=False,
+    ssl_cert_path=None,
+    username=None,
+    password=None,
+    apiKey=None,
+    timeout=60.0,
 ):
    """
    Sets the Elasticsearch hosts to use

    Args:
-        hosts (str | list[str]): A single hostname or URL, or list of hostnames or URLs
-        use_ssl (bool): Use an HTTPS connection to the server
+        hosts (str): A single hostname or URL, or list of hostnames or URLs
+        use_ssl (bool): Use a HTTPS connection to the server
        ssl_cert_path (str): Path to the certificate chain
        username (str): The username to use for authentication
        password (str): The password to use for authentication
-        api_key (str): The Base64 encoded API key to use for authentication
+        apiKey (str): The Base64 encoded API key to use for authentication
        timeout (float): Timeout in seconds
    """
    if not isinstance(hosts, list):
@@ -299,12 +293,12 @@ def set_hosts(
            conn_params["verify_certs"] = False
    if username:
        conn_params["http_auth"] = username + ":" + password
-    if api_key:
-        conn_params["api_key"] = api_key
+    if apiKey:
+        conn_params["api_key"] = apiKey
    connections.create_connection(**conn_params)


-def create_indexes(names: list[str], settings: Optional[dict[str, Any]] = None):
+def create_indexes(names, settings=None):
    """
    Create Elasticsearch indexes

@@ -327,10 +321,7 @@ def create_indexes(names: list[str], settings: Optional[dict[str, Any]] = None):
            raise ElasticsearchError("Elasticsearch error: {0}".format(e.__str__()))


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

@@ -377,12 +368,12 @@ def migrate_indexes(


 def save_aggregate_report_to_elasticsearch(
-    aggregate_report: OrderedDict[str, Any],
-    index_suffix: Optional[str] = None,
-    index_prefix: Optional[str] = None,
-    monthly_indexes: Optional[bool] = False,
-    number_of_shards: Optional[int] = 1,
-    number_of_replicas: Optional[int] = 0,
+    aggregate_report,
+    index_suffix=None,
+    index_prefix=None,
+    monthly_indexes=False,
+    number_of_shards=1,
+    number_of_replicas=0,
 ):
    """
    Saves a parsed DMARC aggregate report to Elasticsearch
@@ -404,51 +395,7 @@ def save_aggregate_report_to_elasticsearch(
    org_name = metadata["org_name"]
    report_id = metadata["report_id"]
    domain = aggregate_report["policy_published"]["domain"]
-    begin_date = human_timestamp_to_datetime(metadata["begin_date"], to_utc=True)
-    end_date = human_timestamp_to_datetime(metadata["end_date"], to_utc=True)
-
-    if monthly_indexes:
-        index_date = begin_date.strftime("%Y-%m")
-    else:
-        index_date = begin_date.strftime("%Y-%m-%d")
-
-    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)
-    else:
-        search_index = "dmarc_aggregate*"
-    if index_prefix is not None:
-        search_index = "{0}{1}".format(index_prefix, search_index)
-    search = Search(index=search_index)
-    query = org_name_query & report_id_query & domain_query
-    query = query & begin_date_query & end_date_query
-    search.query = query
-
-    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__())
-        )
-
-    if len(existing) > 0:
-        raise AlreadySaved(
-            "An aggregate report ID {0} from {1} about {2} "
-            "with a date range of {3} UTC to {4} UTC already "
-            "exists in "
-            "Elasticsearch".format(
-                report_id, org_name, domain, begin_date_human, end_date_human
-            )
-        )
+    
    published_policy = _PublishedPolicy(
        domain=aggregate_report["policy_published"]["domain"],
        adkim=aggregate_report["policy_published"]["adkim"],
@@ -462,8 +409,8 @@ def save_aggregate_report_to_elasticsearch(
    for record in aggregate_report["records"]:
        begin_date = human_timestamp_to_datetime(record["interval_begin"], to_utc=True)
        end_date = human_timestamp_to_datetime(record["interval_end"], to_utc=True)
-        normalized_timespan = record["normalized_timespan"]
-
+        begin_date_human = begin_date.strftime("%Y-%m-%d %H:%M:%SZ")
+        end_date_human = end_date.strftime("%Y-%m-%d %H:%M:%SZ")
        if monthly_indexes:
            index_date = begin_date.strftime("%Y-%m")
        else:
@@ -471,6 +418,41 @@ def save_aggregate_report_to_elasticsearch(
        aggregate_report["begin_date"] = begin_date
        aggregate_report["end_date"] = end_date
        date_range = [aggregate_report["begin_date"], aggregate_report["end_date"]]
+
+        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)
+        else:
+            search_index = "dmarc_aggregate*"
+        if index_prefix is not None:
+            search_index = "{0}{1}".format(index_prefix, search_index)
+        search = Search(index=search_index)
+        query = org_name_query & report_id_query & domain_query
+        query = query & begin_date_query & end_date_query
+        search.query = query
+
+        try:
+            existing = search.execute()
+        except Exception as error_:
+            raise ElasticsearchError(
+                "Elasticsearch's search for existing report \
+                error: {}".format(error_.__str__())
+            )
+
+        if len(existing) > 0:
+            raise AlreadySaved(
+                "An aggregate report ID {0} from {1} about {2} "
+                "with a date range of {3} UTC to {4} UTC already "
+                "exists in "
+                "Elasticsearch".format(
+                    report_id, org_name, domain, begin_date_human, end_date_human
+                )
+            )
        agg_doc = _AggregateReportDoc(
            xml_schema=aggregate_report["xml_schema"],
            org_name=metadata["org_name"],
@@ -478,9 +460,9 @@ def save_aggregate_report_to_elasticsearch(
            org_extra_contact_info=metadata["org_extra_contact_info"],
            report_id=metadata["report_id"],
            date_range=date_range,
-            date_begin=begin_date,
-            date_end=end_date,
-            normalized_timespan=normalized_timespan,
+            date_begin=aggregate_report["begin_date"],
+            date_end=aggregate_report["end_date"],
+            normalized_timespan=record["normalized_timespan"],
            errors=metadata["errors"],
            published_policy=published_policy,
            source_ip_address=record["source"]["ip_address"],
@@ -539,12 +521,12 @@ def save_aggregate_report_to_elasticsearch(


 def save_forensic_report_to_elasticsearch(
-    forensic_report: OrderedDict[str, Any],
-    index_suffix: Optional[any] = None,
-    index_prefix: Optional[str] = None,
-    monthly_indexes: Optional[bool] = False,
-    number_of_shards: int = 1,
-    number_of_replicas: int = 0,
+    forensic_report,
+    index_suffix=None,
+    index_prefix=None,
+    monthly_indexes=False,
+    number_of_shards=1,
+    number_of_replicas=0,
 ):
    """
    Saves a parsed DMARC forensic report to Elasticsearch
@@ -706,12 +688,12 @@ def save_forensic_report_to_elasticsearch(


 def save_smtp_tls_report_to_elasticsearch(
-    report: OrderedDict[str, Any],
-    index_suffix: str = None,
-    index_prefix: str = None,
-    monthly_indexes: Optional[bool] = False,
-    number_of_shards: Optional[int] = 1,
-    number_of_replicas: Optional[int] = 0,
+    report,
+    index_suffix=None,
+    index_prefix=None,
+    monthly_indexes=False,
+    number_of_shards=1,
+    number_of_replicas=0,
 ):
    """
    Saves a parsed SMTP TLS report to Elasticsearch
@@ -803,7 +785,7 @@ def save_smtp_tls_report_to_elasticsearch(
        policy_doc = _SMTPTLSPolicyDoc(
            policy_domain=policy["policy_domain"],
            policy_type=policy["policy_type"],
-            successful_session_count=policy["successful_session_count"],
+            succesful_session_count=policy["successful_session_count"],
            failed_session_count=policy["failed_session_count"],
            policy_string=policy_strings,
            mx_host_patterns=mx_host_patterns,
--- a/parsedmarc/gelf.py
+++ b/parsedmarc/gelf.py
@@ -1,14 +1,9 @@
 # -*- coding: utf-8 -*-

-from __future__ import annotations
-
-from typing import Any
-
 import logging
 import logging.handlers
 import json
 import threading
-from collections import OrderedDict

 from parsedmarc import (
    parsed_aggregate_reports_to_csv_rows,
@@ -53,7 +48,7 @@ class GelfClient(object):
        )
        self.logger.addHandler(self.handler)

-    def save_aggregate_report_to_gelf(self, aggregate_reports: OrderedDict[str, Any]):
+    def save_aggregate_report_to_gelf(self, aggregate_reports):
        rows = parsed_aggregate_reports_to_csv_rows(aggregate_reports)
        for row in rows:
            log_context_data.parsedmarc = row
@@ -61,12 +56,12 @@ class GelfClient(object):

        log_context_data.parsedmarc = None

-    def save_forensic_report_to_gelf(self, forensic_reports: OrderedDict[str, Any]):
+    def save_forensic_report_to_gelf(self, forensic_reports):
        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_gelf(self, smtp_tls_reports: OrderedDict[str, Any]):
+    def save_smtp_tls_report_to_gelf(self, smtp_tls_reports):
        rows = parsed_smtp_tls_reports_to_csv_rows(smtp_tls_reports)
        for row in rows:
            self.logger.info(json.dumps(row))
--- a/parsedmarc/kafkaclient.py
+++ b/parsedmarc/kafkaclient.py
@@ -1,10 +1,5 @@
 # -*- coding: utf-8 -*-

-from __future__ import annotations
-
-from typing import Any, Optional
-from ssl import SSLContext
-
 import json
 from ssl import create_default_context

@@ -23,13 +18,7 @@ class KafkaError(RuntimeError):

 class KafkaClient(object):
    def __init__(
-        self,
-        kafka_hosts: list[str],
-        *,
-        ssl: Optional[bool] = False,
-        username: Optional[str] = None,
-        password: Optional[str] = None,
-        ssl_context: Optional[SSLContext] = None,
+        self, kafka_hosts, ssl=False, username=None, password=None, ssl_context=None
    ):
        """
        Initializes the Kafka client
@@ -39,7 +28,7 @@ class KafkaClient(object):
            ssl (bool): Use a SSL/TLS connection
            username (str): An optional username
            password (str):  An optional password
-            ssl_context (SSLContext): SSL context options
+            ssl_context: SSL context options

        Notes:
            ``use_ssl=True`` is implied when a username or password are
@@ -66,7 +55,7 @@ class KafkaClient(object):
            raise KafkaError("No Kafka brokers available")

    @staticmethod
-    def strip_metadata(report: OrderedDict[str, Any]):
+    def strip_metadata(report):
        """
        Duplicates org_name, org_email and report_id into JSON root
        and removes report_metadata key to bring it more inline
@@ -80,7 +69,7 @@ class KafkaClient(object):
        return report

    @staticmethod
-    def generate_date_range(report: OrderedDict[str, Any]):
+    def generate_daterange(report):
        """
        Creates a date_range timestamp with format YYYY-MM-DD-T-HH:MM:SS
        based on begin and end dates for easier parsing in Kibana.
@@ -97,9 +86,7 @@ class KafkaClient(object):
        logger.debug("date_range is {}".format(date_range))
        return date_range

-    def save_aggregate_reports_to_kafka(
-        self, aggregate_reports: list[OrderedDict][str, Any], aggregate_topic: str
-    ):
+    def save_aggregate_reports_to_kafka(self, aggregate_reports, aggregate_topic):
        """
        Saves aggregate DMARC reports to Kafka

@@ -118,7 +105,7 @@ class KafkaClient(object):
            return

        for report in aggregate_reports:
-            report["date_range"] = self.generate_date_range(report)
+            report["date_range"] = self.generate_daterange(report)
            report = self.strip_metadata(report)

            for slice in report["records"]:
@@ -142,9 +129,7 @@ class KafkaClient(object):
                except Exception as e:
                    raise KafkaError("Kafka error: {0}".format(e.__str__()))

-    def save_forensic_reports_to_kafka(
-        self, forensic_reports: OrderedDict[str, Any], forensic_topic: str
-    ):
+    def save_forensic_reports_to_kafka(self, forensic_reports, forensic_topic):
        """
        Saves forensic DMARC reports to Kafka, sends individual
        records (slices) since Kafka requires messages to be <= 1MB
@@ -174,9 +159,7 @@ class KafkaClient(object):
        except Exception as e:
            raise KafkaError("Kafka error: {0}".format(e.__str__()))

-    def save_smtp_tls_reports_to_kafka(
-        self, smtp_tls_reports: list[OrderedDict[str, Any]], smtp_tls_topic: str
-    ):
+    def save_smtp_tls_reports_to_kafka(self, smtp_tls_reports, smtp_tls_topic):
        """
        Saves SMTP TLS reports to Kafka, sends individual
        records (slices) since Kafka requires messages to be <= 1MB
--- a/parsedmarc/loganalytics.py
+++ b/parsedmarc/loganalytics.py
@@ -1,10 +1,4 @@
 # -*- coding: utf-8 -*-
-
-from __future__ import annotations
-
-from typing import Any
-from collections import OrderedDict
-
 from parsedmarc.log import logger
 from azure.core.exceptions import HttpResponseError
 from azure.identity import ClientSecretCredential
@@ -108,12 +102,7 @@ class LogAnalyticsClient(object):
                "Invalid configuration. " + "One or more required settings are missing."
            )

-    def publish_json(
-        self,
-        results: OrderedDict[str, OrderedDict[str, Any]],
-        logs_client: LogsIngestionClient,
-        dcr_stream: str,
-    ):
+    def publish_json(self, results, logs_client: LogsIngestionClient, dcr_stream: str):
        """
        Background function to publish given
        DMARC report to specific Data Collection Rule.
@@ -132,11 +121,7 @@ class LogAnalyticsClient(object):
            raise LogAnalyticsException("Upload failed: {error}".format(error=e))

    def publish_results(
-        self,
-        results: OrderedDict[str, OrderedDict[str, Any]],
-        save_aggregate: bool,
-        save_forensic: bool,
-        save_smtp_tls: bool,
+        self, results, save_aggregate: bool, save_forensic: bool, save_smtp_tls: bool
    ):
        """
        Function to publish DMARC and/or SMTP TLS reports to Log Analytics
--- a/parsedmarc/mail/gmail.py
+++ b/parsedmarc/mail/gmail.py
@@ -1,7 +1,3 @@
-# -*- coding: utf-8 -*-
-
-from __future__ import annotations
-
 from base64 import urlsafe_b64decode
 from functools import lru_cache
 from pathlib import Path
@@ -156,4 +152,3 @@ class GmailConnection(MailboxConnection):
        for label in labels:
            if label_name == label["id"] or label_name == label["name"]:
                return label["id"]
-        return ""
--- a/parsedmarc/mail/graph.py
+++ b/parsedmarc/mail/graph.py
@@ -1,7 +1,3 @@
-# -*- coding: utf-8 -*-
-
-from __future__ import annotations
-
 from enum import Enum
 from functools import lru_cache
 from pathlib import Path
--- a/parsedmarc/mail/imap.py
+++ b/parsedmarc/mail/imap.py
@@ -1,9 +1,3 @@
-# -*- coding: utf-8 -*-
-
-from __future__ import annotations
-
-from typing import Optional
-
 from time import sleep

 from imapclient.exceptions import IMAPClientError
@@ -17,15 +11,14 @@ from parsedmarc.mail.mailbox_connection import MailboxConnection
 class IMAPConnection(MailboxConnection):
    def __init__(
        self,
-        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,
+        host=None,
+        user=None,
+        password=None,
+        port=None,
+        ssl=True,
+        verify=True,
+        timeout=30,
+        max_retries=4,
    ):
        self._username = user
        self._password = password
@@ -52,13 +45,13 @@ class IMAPConnection(MailboxConnection):
        else:
            return self._client.search()

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

-    def delete_message(self, message_id: int):
+    def delete_message(self, message_id: str):
        self._client.delete_messages([message_id])

-    def move_message(self, message_id: int, folder_name: str):
+    def move_message(self, message_id: str, folder_name: str):
        self._client.move_messages([message_id], folder_name)

    def keepalive(self):
--- a/parsedmarc/mail/mailbox_connection.py
+++ b/parsedmarc/mail/mailbox_connection.py
@@ -1,8 +1,5 @@
-# -*- coding: utf-8 -*-
-
-from __future__ import annotations
-
 from abc import ABC
+from typing import List


 class MailboxConnection(ABC):
@@ -13,7 +10,7 @@ class MailboxConnection(ABC):
    def create_folder(self, folder_name: str):
        raise NotImplementedError

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

    def fetch_message(self, message_id) -> str:
--- a/parsedmarc/mail/maildir.py
+++ b/parsedmarc/mail/maildir.py
@@ -1,9 +1,3 @@
-# -*- coding: utf-8 -*-
-
-from __future__ import annotations
-
-from typing import Optional
-
 from time import sleep

 from parsedmarc.log import logger
@@ -15,8 +9,8 @@ import os
 class MaildirConnection(MailboxConnection):
    def __init__(
        self,
-        maildir_path: Optional[bool] = None,
-        maildir_create: Optional[bool] = False,
+        maildir_path=None,
+        maildir_create=False,
    ):
        self._maildir_path = maildir_path
        self._maildir_create = maildir_create
@@ -42,7 +36,7 @@ class MaildirConnection(MailboxConnection):
    def fetch_messages(self, reports_folder: str, **kwargs):
        return self._client.keys()

-    def fetch_message(self, message_id: str):
+    def fetch_message(self, message_id):
        return self._client.get(message_id).as_string()

    def delete_message(self, message_id: str):
--- a/parsedmarc/opensearch.py
+++ b/parsedmarc/opensearch.py
@@ -1,9 +1,5 @@
 # -*- coding: utf-8 -*-

-from __future__ import annotations
-
-from typing import Optional, Union, Any
-
 from collections import OrderedDict

 from opensearchpy import (
@@ -93,15 +89,15 @@ class _AggregateReportDoc(Document):
    dkim_results = Nested(_DKIMResult)
    spf_results = Nested(_SPFResult)

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

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

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

    def save(self, **kwargs):
@@ -137,21 +133,21 @@ class _ForensicSampleDoc(InnerDoc):
    body = Text()
    attachments = Nested(_EmailAttachmentDoc)

-    def add_to(self, display_name: str, address: str):
+    def add_to(self, display_name, address):
        self.to.append(_EmailAddressDoc(display_name=display_name, address=address))

-    def add_reply_to(self, display_name: str, address: str):
+    def add_reply_to(self, display_name, address):
        self.reply_to.append(
            _EmailAddressDoc(display_name=display_name, address=address)
        )

-    def add_cc(self, display_name: str, address: str):
+    def add_cc(self, display_name, address):
        self.cc.append(_EmailAddressDoc(display_name=display_name, address=address))

-    def add_bcc(self, display_name: str, address: str):
+    def add_bcc(self, display_name, address):
        self.bcc.append(_EmailAddressDoc(display_name=display_name, address=address))

-    def add_attachment(self, filename: str, content_type: str, sha256: str):
+    def add_attachment(self, filename, content_type, sha256):
        self.attachments.append(
            _EmailAttachmentDoc(
                filename=filename, content_type=content_type, sha256=sha256
@@ -203,15 +199,15 @@ class _SMTPTLSPolicyDoc(InnerDoc):

    def add_failure_details(
        self,
-        result_type: str,
-        ip_address: str,
-        receiving_ip: str,
-        receiving_mx_helo: str,
-        failed_session_count: int,
-        sending_mta_ip: Optional[str] = None,
-        receiving_mx_hostname: Optional[str] = None,
-        additional_information_uri: Optional[str] = None,
-        failure_reason_code: Union[str, int, None] = None,
+        result_type,
+        ip_address,
+        receiving_ip,
+        receiving_mx_helo,
+        failed_session_count,
+        sending_mta_ip=None,
+        receiving_mx_hostname=None,
+        additional_information_uri=None,
+        failure_reason_code=None,
    ):
        _details = _SMTPTLSFailureDetailsDoc(
            result_type=result_type,
@@ -241,14 +237,13 @@ class _SMTPTLSReportDoc(Document):

    def add_policy(
        self,
-        policy_type: str,
-        policy_domain: str,
-        successful_session_count: int,
-        failed_session_count: int,
-        *,
-        policy_string: Optional[str] = None,
-        mx_host_patterns: Optional[list[str]] = None,
-        failure_details: Optional[str] = None,
+        policy_type,
+        policy_domain,
+        successful_session_count,
+        failed_session_count,
+        policy_string=None,
+        mx_host_patterns=None,
+        failure_details=None,
    ):
        self.policies.append(
            policy_type=policy_type,
@@ -266,25 +261,24 @@ class AlreadySaved(ValueError):


 def set_hosts(
-    hosts: Union[str, list[str]],
-    *,
-    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: Optional[float] = 60.0,
+    hosts,
+    use_ssl=False,
+    ssl_cert_path=None,
+    username=None,
+    password=None,
+    apiKey=None,
+    timeout=60.0,
 ):
    """
    Sets the OpenSearch hosts to use

    Args:
-        hosts (str|list[str]): A single hostname or URL, or list of hostnames or URLs
+        hosts (str|list): A 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
        password (str): The password to use for authentication
-        api_key (str): The Base64 encoded API key to use for authentication
+        apiKey (str): The Base64 encoded API key to use for authentication
        timeout (float): Timeout in seconds
    """
    if not isinstance(hosts, list):
@@ -299,12 +293,12 @@ def set_hosts(
            conn_params["verify_certs"] = False
    if username:
        conn_params["http_auth"] = username + ":" + password
-    if api_key:
-        conn_params["api_key"] = api_key
+    if apiKey:
+        conn_params["api_key"] = apiKey
    connections.create_connection(**conn_params)


-def create_indexes(names: list[str], settings: Optional[dict[str, Any]] = None):
+def create_indexes(names, settings=None):
    """
    Create OpenSearch indexes

@@ -327,10 +321,7 @@ def create_indexes(names: list[str], settings: Optional[dict[str, Any]] = None):
            raise OpenSearchError("OpenSearch error: {0}".format(e.__str__()))


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

@@ -376,13 +367,13 @@ def migrate_indexes(
        pass


-def save_aggregate_report_to_elasticsearch(
-    aggregate_report: OrderedDict[str, Any],
-    index_suffix: Optional[str] = None,
-    index_prefix: Optional[str] = None,
-    monthly_indexes: Optional[bool] = False,
-    number_of_shards: Optional[int] = 1,
-    number_of_replicas: Optional[int] = 0,
+def save_aggregate_report_to_opensearch(
+    aggregate_report,
+    index_suffix=None,
+    index_prefix=None,
+    monthly_indexes=False,
+    number_of_shards=1,
+    number_of_replicas=0,
 ):
    """
    Saves a parsed DMARC aggregate report to OpenSearch
@@ -404,51 +395,7 @@ def save_aggregate_report_to_elasticsearch(
    org_name = metadata["org_name"]
    report_id = metadata["report_id"]
    domain = aggregate_report["policy_published"]["domain"]
-    begin_date = human_timestamp_to_datetime(metadata["begin_date"], to_utc=True)
-    end_date = human_timestamp_to_datetime(metadata["end_date"], to_utc=True)
-
-    if monthly_indexes:
-        index_date = begin_date.strftime("%Y-%m")
-    else:
-        index_date = begin_date.strftime("%Y-%m-%d")
-
-    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)
-    else:
-        search_index = "dmarc_aggregate*"
-    if index_prefix is not None:
-        search_index = "{0}{1}".format(index_prefix, search_index)
-    search = Search(index=search_index)
-    query = org_name_query & report_id_query & domain_query
-    query = query & begin_date_query & end_date_query
-    search.query = query
-
-    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__())
-        )
-
-    if len(existing) > 0:
-        raise AlreadySaved(
-            "An aggregate report ID {0} from {1} about {2} "
-            "with a date range of {3} UTC to {4} UTC already "
-            "exists in "
-            "OpenSearch".format(
-                report_id, org_name, domain, begin_date_human, end_date_human
-            )
-        )
+    
    published_policy = _PublishedPolicy(
        domain=aggregate_report["policy_published"]["domain"],
        adkim=aggregate_report["policy_published"]["adkim"],
@@ -462,8 +409,8 @@ def save_aggregate_report_to_elasticsearch(
    for record in aggregate_report["records"]:
        begin_date = human_timestamp_to_datetime(record["interval_begin"], to_utc=True)
        end_date = human_timestamp_to_datetime(record["interval_end"], to_utc=True)
-        normalized_timespan = record["normalized_timespan"]
-
+        begin_date_human = begin_date.strftime("%Y-%m-%d %H:%M:%SZ")
+        end_date_human = end_date.strftime("%Y-%m-%d %H:%M:%SZ")
        if monthly_indexes:
            index_date = begin_date.strftime("%Y-%m")
        else:
@@ -471,6 +418,41 @@ def save_aggregate_report_to_elasticsearch(
        aggregate_report["begin_date"] = begin_date
        aggregate_report["end_date"] = end_date
        date_range = [aggregate_report["begin_date"], aggregate_report["end_date"]]
+
+        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)
+        else:
+            search_index = "dmarc_aggregate*"
+        if index_prefix is not None:
+            search_index = "{0}{1}".format(index_prefix, search_index)
+        search = Search(index=search_index)
+        query = org_name_query & report_id_query & domain_query
+        query = query & begin_date_query & end_date_query
+        search.query = query
+
+        try:
+            existing = search.execute()
+        except Exception as error_:
+            raise OpenSearchError(
+                "OpenSearch's search for existing report \
+                error: {}".format(error_.__str__())
+            )
+
+        if len(existing) > 0:
+            raise AlreadySaved(
+                "An aggregate report ID {0} from {1} about {2} "
+                "with a date range of {3} UTC to {4} UTC already "
+                "exists in "
+                "OpenSearch".format(
+                    report_id, org_name, domain, begin_date_human, end_date_human
+                )
+            )
        agg_doc = _AggregateReportDoc(
            xml_schema=aggregate_report["xml_schema"],
            org_name=metadata["org_name"],
@@ -478,9 +460,8 @@ def save_aggregate_report_to_elasticsearch(
            org_extra_contact_info=metadata["org_extra_contact_info"],
            report_id=metadata["report_id"],
            date_range=date_range,
-            date_begin=begin_date,
-            date_end=end_date,
-            normalized_timespan=normalized_timespan,
+            date_begin=aggregate_report["begin_date"],
+            date_end=aggregate_report["end_date"],
            errors=metadata["errors"],
            published_policy=published_policy,
            source_ip_address=record["source"]["ip_address"],
@@ -538,13 +519,13 @@ def save_aggregate_report_to_elasticsearch(
            raise OpenSearchError("OpenSearch error: {0}".format(e.__str__()))


-def save_forensic_report_to_elasticsearch(
-    forensic_report: OrderedDict[str, Any],
-    index_suffix: Optional[any] = None,
-    index_prefix: Optional[str] = None,
-    monthly_indexes: Optional[bool] = False,
-    number_of_shards: int = 1,
-    number_of_replicas: int = 0,
+def save_forensic_report_to_opensearch(
+    forensic_report,
+    index_suffix=None,
+    index_prefix=None,
+    monthly_indexes=False,
+    number_of_shards=1,
+    number_of_replicas=0,
 ):
    """
    Saves a parsed DMARC forensic report to OpenSearch
@@ -705,13 +686,13 @@ def save_forensic_report_to_elasticsearch(
        )


-def save_smtp_tls_report_to_elasticsearch(
-    report: OrderedDict[str, Any],
-    index_suffix: str = None,
-    index_prefix: str = None,
-    monthly_indexes: Optional[bool] = False,
-    number_of_shards: Optional[int] = 1,
-    number_of_replicas: Optional[int] = 0,
+def save_smtp_tls_report_to_opensearch(
+    report,
+    index_suffix=None,
+    index_prefix=None,
+    monthly_indexes=False,
+    number_of_shards=1,
+    number_of_replicas=0,
 ):
    """
    Saves a parsed SMTP TLS report to OpenSearch
@@ -727,7 +708,7 @@ def save_smtp_tls_report_to_elasticsearch(
    Raises:
            AlreadySaved
    """
-    logger.info("Saving SMTP TLS report to OpenSearch")
+    logger.info("Saving aggregate report to OpenSearch")
    org_name = report["organization_name"]
    report_id = report["report_id"]
    begin_date = human_timestamp_to_datetime(report["begin_date"], to_utc=True)
@@ -803,7 +784,7 @@ def save_smtp_tls_report_to_elasticsearch(
        policy_doc = _SMTPTLSPolicyDoc(
            policy_domain=policy["policy_domain"],
            policy_type=policy["policy_type"],
-            successful_session_count=policy["successful_session_count"],
+            succesful_session_count=policy["successful_session_count"],
            failed_session_count=policy["failed_session_count"],
            policy_string=policy_strings,
            mx_host_patterns=mx_host_patterns,
--- a/parsedmarc/resources/maps/base_reverse_dns_map.csv
+++ b/parsedmarc/resources/maps/base_reverse_dns_map.csv
@@ -132,7 +132,6 @@ asu-vei.ru,ASU-VEI,Industrial
 atextelecom.com.br,ATEX Telecom,ISP
 atmailcloud.com,atmail,Email Provider
 ats.ca,ATS Healthcare,Healthcare
-att.net,AT&T,ISP
 atw.ne.jp,ATW,Web Host
 au-net.ne.jp,KDDI,ISP
 au.com,au,ISP
@@ -243,7 +242,6 @@ carandainet.com.br,CN Internet,ISP
 cardhealth.com,Cardinal Health,Healthcare
 cardinal.com,Cardinal Health,Healthcare
 cardinalhealth.com,Cardinal Health,Healthcare
-cardinalscriptnet.com,Cardinal Health,Healthcare
 carecentrix.com,CareCentrix,Healthcare
 carleton.edu,Carlton College,Education
 carrierzone.com,carrierzone,Email Security
@@ -699,7 +697,6 @@ hdsupply-email.com,HD Supply,Retail
 healthall.com,UC Health,Healthcare
 healthcaresupplypros.com,Healthcare Supply Pros,Healthcare
 healthproductsforyou.com,Health Products For You,Healthcare
-healthtouch.com,Cardinal Health,Healthcare
 helloserver6.com,1st Source Web,Marketing
 helpforcb.com,InterServer,Web Host
 helpscout.net,Help Scout,SaaS
@@ -756,8 +753,6 @@ hostwindsdns.com,Hostwinds,Web Host
 hotnet.net.il,Hot Net Internet Services,ISP
 hp.com,HP,Technology
 hringdu.is,Hringdu,ISP
-hslda.net,Home School Legal Defense Association (HSLDA),Education
-hslda.org,Home School Legal Defense Association (HSLDA),Education
 hspherefilter.com,"DynamicNet, Inc. (DNI)",Web Host
 htc.net,HTC,ISP
 htmlservices.it,HTMLServices.it,MSP
@@ -768,7 +763,6 @@ hughston.com,Hughston Clinic,Healthcare
 hvvc.us,Hivelocity,Web Host
 i2ts.ne.jp,i2ts,Web Host
 i4i.com,i4i,Technology
-ibindley.com,Cardinal Health,Healthcare
 ice.co.cr,Grupo ICE,Industrial
 icehosting.nl,IceHosting,Web Host
 icewarpcloud.in,IceWrap,Email Provider
@@ -838,7 +832,6 @@ ip-5-196-151.eu,OVH,Web Host
 ip-51-161-36.net,OVH,Web Host
 ip-51-195-53.eu,OVH,Web Host
 ip-51-254-53.eu,OVH,Web Host
-ip-51-38-67.eu,OVH,Web Host
 ip-51-77-42.eu,OVH,Web Host
 ip-51-83-140.eu,OVH,Web Host
 ip-51-89-240.eu,OVH,Web Host
@@ -1224,7 +1217,6 @@ nettoday.co.th,Net Today,Web Host
 netventure.pl,Netventure,MSP
 netvigator.com,HKT,ISP
 netvision.net.il,013 Netvision,ISP
-network-tech.com,Network Technologies International (NTI),SaaS
 network.kz,network.kz,ISP
 network80.com,Network80,Web Host
 neubox.net,Neubox,Web Host
--- a/parsedmarc/resources/maps/find_unknown_base_reverse_dns.py
+++ b/parsedmarc/resources/maps/find_unknown_base_reverse_dns.py
@@ -13,6 +13,8 @@ def _main():

    csv_headers = ["source_name", "message_count"]

+    output_rows = []
+
    known_unknown_domains = []
    psl_overrides = []
    known_domains = []
--- a/parsedmarc/s3.py
+++ b/parsedmarc/s3.py
@@ -1,29 +1,23 @@
 # -*- coding: utf-8 -*-

-from __future__ import annotations
-
-from typing import Any
-
 import json
 import boto3

-from collections import OrderedDict
-
 from parsedmarc.log import logger
 from parsedmarc.utils import human_timestamp_to_datetime


 class S3Client(object):
-    """A client for interacting with Amazon S3"""
+    """A client for a Amazon S3"""

    def __init__(
        self,
-        bucket_name: str,
-        bucket_path: str,
-        region_name: str,
-        endpoint_url: str,
-        access_key_id: str,
-        secret_access_key: str,
+        bucket_name,
+        bucket_path,
+        region_name,
+        endpoint_url,
+        access_key_id,
+        secret_access_key,
    ):
        """
        Initializes the S3Client
@@ -55,16 +49,16 @@ class S3Client(object):
        )
        self.bucket = self.s3.Bucket(self.bucket_name)

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

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

-    def save_smtp_tls_report_to_s3(self, report: OrderedDict[str, Any]):
+    def save_smtp_tls_report_to_s3(self, report):
        self.save_report_to_s3(report, "smtp_tls")

-    def save_report_to_s3(self, report: OrderedDict[str, Any], report_type: str):
+    def save_report_to_s3(self, report, report_type):
        if report_type == "smtp_tls":
            report_date = report["begin_date"]
            report_id = report["report_id"]
--- a/parsedmarc/splunk.py
+++ b/parsedmarc/splunk.py
@@ -1,11 +1,3 @@
-# -*- coding: utf-8 -*-
-
-from __future__ import annotations
-
-from typing import Any
-
-from collections import OrderedDict
-
 from urllib.parse import urlparse
 import socket
 import json
@@ -31,13 +23,7 @@ class HECClient(object):
    # http://docs.splunk.com/Documentation/Splunk/latest/RESTREF/RESTinput#services.2Fcollector

    def __init__(
-        self,
-        url: str,
-        access_token: str,
-        index: str,
-        source: bool = "parsedmarc",
-        verify=True,
-        timeout=60,
+        self, url, access_token, index, source="parsedmarc", verify=True, timeout=60
    ):
        """
        Initializes the HECClient
@@ -69,9 +55,7 @@ class HECClient(object):
            "Authorization": "Splunk {0}".format(self.access_token),
        }

-    def save_aggregate_reports_to_splunk(
-        self, aggregate_reports: list[OrderedDict[str, Any]]
-    ):
+    def save_aggregate_reports_to_splunk(self, aggregate_reports):
        """
        Saves aggregate DMARC reports to Splunk

@@ -134,9 +118,7 @@ class HECClient(object):
        if response["code"] != 0:
            raise SplunkError(response["text"])

-    def save_forensic_reports_to_splunk(
-        self, forensic_reports: list[OrderedDict[str, Any]]
-    ):
+    def save_forensic_reports_to_splunk(self, forensic_reports):
        """
        Saves forensic DMARC reports to Splunk

@@ -170,7 +152,7 @@ class HECClient(object):
        if response["code"] != 0:
            raise SplunkError(response["text"])

-    def save_smtp_tls_reports_to_splunk(self, reports: OrderedDict[str, Any]):
+    def save_smtp_tls_reports_to_splunk(self, reports):
        """
        Saves aggregate DMARC reports to Splunk

--- a/parsedmarc/syslog.py
+++ b/parsedmarc/syslog.py
@@ -1,15 +1,7 @@
 # -*- coding: utf-8 -*-

-
-from __future__ import annotations
-
 import logging
 import logging.handlers
-
-from typing import Any
-
-from collections import OrderedDict
-
 import json

 from parsedmarc import (
@@ -22,7 +14,7 @@ from parsedmarc import (
 class SyslogClient(object):
    """A client for Syslog"""

-    def __init__(self, server_name: str, server_port: int):
+    def __init__(self, server_name, server_port):
        """
        Initializes the SyslogClient
        Args:
@@ -36,23 +28,17 @@ class SyslogClient(object):
        log_handler = logging.handlers.SysLogHandler(address=(server_name, server_port))
        self.logger.addHandler(log_handler)

-    def save_aggregate_report_to_syslog(
-        self, aggregate_reports: list[OrderedDict[str, Any]]
-    ):
+    def save_aggregate_report_to_syslog(self, aggregate_reports):
        rows = parsed_aggregate_reports_to_csv_rows(aggregate_reports)
        for row in rows:
            self.logger.info(json.dumps(row))

-    def save_forensic_report_to_syslog(
-        self, forensic_reports: list[OrderedDict[str, Any]]
-    ):
+    def save_forensic_report_to_syslog(self, forensic_reports):
        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[OrderedDict[str, Any]]
-    ):
+    def save_smtp_tls_report_to_syslog(self, smtp_tls_reports):
        rows = parsed_smtp_tls_reports_to_csv_rows(smtp_tls_reports)
        for row in rows:
            self.logger.info(json.dumps(row))
--- a/parsedmarc/utils.py
+++ b/parsedmarc/utils.py
@@ -1,18 +1,11 @@
-# -*- coding: utf-8 -*-
-
 """Utility functions that might be useful for other projects"""

-from __future__ import annotations
-
-from typing import Optional, Union
-
 import logging
 import os
 from datetime import datetime
 from datetime import timezone
 from datetime import timedelta
 from collections import OrderedDict
-from expiringdict import ExpiringDict
 import tempfile
 import subprocess
 import shutil
@@ -67,12 +60,12 @@ class DownloadError(RuntimeError):
    """Raised when an error occurs when downloading a file"""


-def decode_base64(data: str) -> bytes:
+def decode_base64(data):
    """
    Decodes a base64 string, with padding being optional

    Args:
-        data (str): A base64 encoded string
+        data: A base64 encoded string

    Returns:
        bytes: The decoded bytes
@@ -85,7 +78,7 @@ def decode_base64(data: str) -> bytes:
    return base64.b64decode(data)


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

@@ -109,14 +102,7 @@ def get_base_domain(domain: str) -> str:
    return publicsuffix


-def query_dns(
-    domain: str,
-    record_type: str,
-    *,
-    cache: Optional[ExpiringDict] = None,
-    nameservers: list[str] = None,
-    timeout: int = 2.0,
-) -> list[str]:
+def query_dns(domain, record_type, cache=None, nameservers=None, timeout=2.0):
    """
    Queries DNS

@@ -177,13 +163,7 @@ def query_dns(
    return records


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

@@ -211,7 +191,7 @@ def get_reverse_dns(
    return hostname


-def timestamp_to_datetime(timestamp: int) -> datetime:
+def timestamp_to_datetime(timestamp):
    """
    Converts a UNIX/DMARC timestamp to a Python ``datetime`` object

@@ -224,7 +204,7 @@ def timestamp_to_datetime(timestamp: int) -> datetime:
    return datetime.fromtimestamp(int(timestamp))


-def timestamp_to_human(timestamp: int) -> str:
+def timestamp_to_human(timestamp):
    """
    Converts a UNIX/DMARC timestamp to a human-readable string

@@ -237,9 +217,7 @@ def timestamp_to_human(timestamp: int) -> str:
    return timestamp_to_datetime(timestamp).strftime("%Y-%m-%d %H:%M:%S")


-def human_timestamp_to_datetime(
-    human_timestamp: str, *, to_utc: Optional[bool] = False
-) -> datetime:
+def human_timestamp_to_datetime(human_timestamp, to_utc=False):
    """
    Converts a human-readable timestamp into a Python ``datetime`` object

@@ -258,7 +236,7 @@ def human_timestamp_to_datetime(
    return dt.astimezone(timezone.utc) if to_utc else dt


-def human_timestamp_to_unix_timestamp(human_timestamp: str) -> int:
+def human_timestamp_to_unix_timestamp(human_timestamp):
    """
    Converts a human-readable timestamp into a UNIX timestamp

@@ -272,7 +250,7 @@ def human_timestamp_to_unix_timestamp(human_timestamp: str) -> int:
    return human_timestamp_to_datetime(human_timestamp).timestamp()


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

    if db_path is not None:
-        if not os.path.isfile(db_path):
+        if os.path.isfile(db_path) is False:
            db_path = None
            logger.warning(
                f"No file exists at {db_path}. Falling back to an "
@@ -336,13 +314,12 @@ def get_ip_address_country(ip_address: str, *, db_path: Optional[str] = None) ->

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

@@ -412,17 +389,16 @@ def get_service_from_reverse_dns_base_domain(

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

@@ -440,7 +416,7 @@ def get_ip_address_info(
        timeout (float): Sets the DNS timeout in seconds

    Returns:
-        OrderedDict: ``ip_address``, ``reverse_dns``, ``country``
+        OrderedDict: ``ip_address``, ``reverse_dns``

    """
    ip_address = ip_address.lower()
@@ -487,7 +463,7 @@ def get_ip_address_info(
    return info


-def parse_email_address(original_address: str) -> OrderedDict[str, str]:
+def parse_email_address(original_address):
    if original_address[0] == "":
        display_name = None
    else:
@@ -510,7 +486,7 @@ def parse_email_address(original_address: str) -> OrderedDict[str, str]:
    )


-def get_filename_safe_string(string: str) -> str:
+def get_filename_safe_string(string):
    """
    Converts a string to a string that is safe for a filename

@@ -532,7 +508,7 @@ def get_filename_safe_string(string: str) -> str:
    return string


-def is_mbox(path: str) -> bool:
+def is_mbox(path):
    """
    Checks if the given content is an MBOX mailbox file

@@ -553,7 +529,7 @@ def is_mbox(path: str) -> bool:
    return _is_mbox


-def is_outlook_msg(content) -> bool:
+def is_outlook_msg(content):
    """
    Checks if the given content is an Outlook msg OLE/MSG file

@@ -568,7 +544,7 @@ def is_outlook_msg(content) -> bool:
    )


-def convert_outlook_msg(msg_bytes: bytes) -> str:
+def convert_outlook_msg(msg_bytes):
    """
    Uses the ``msgconvert`` Perl utility to convert an Outlook MS file to
    standard RFC 822 format
@@ -604,9 +580,7 @@ def convert_outlook_msg(msg_bytes: bytes) -> str:
    return rfc822


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

--- a/parsedmarc/webhook.py
+++ b/parsedmarc/webhook.py
@@ -1,11 +1,3 @@
-# -*- coding: utf-8 -*-
-
-from __future__ import annotations
-
-from typing import Any, Optional, Union
-
-from collections import OrderedDict
-
 import requests

 from parsedmarc import logger
@@ -15,13 +7,7 @@ from parsedmarc.constants import USER_AGENT
 class WebhookClient(object):
    """A client for webhooks"""

-    def __init__(
-        self,
-        aggregate_url: str,
-        forensic_url: str,
-        smtp_tls_url: str,
-        timeout: Optional[int] = 60,
-    ):
+    def __init__(self, aggregate_url, forensic_url, smtp_tls_url, timeout=60):
        """
        Initializes the WebhookClient
        Args:
@@ -40,27 +26,25 @@ class WebhookClient(object):
            "Content-Type": "application/json",
        }

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

-    def save_smtp_tls_report_to_webhook(self, report: OrderedDict[str, Any]):
+    def save_smtp_tls_report_to_webhook(self, report):
        try:
            self._send_to_webhook(self.smtp_tls_url, report)
        except Exception as error_:
            logger.error("Webhook Error: {0}".format(error_.__str__()))

-    def save_aggregate_report_to_webhook(self, report: OrderedDict[str, Any]):
+    def save_aggregate_report_to_webhook(self, report):
        try:
            self._send_to_webhook(self.aggregate_url, report)
        except Exception as error_:
            logger.error("Webhook Error: {0}".format(error_.__str__()))

-    def _send_to_webhook(
-        self, webhook_url: str, payload: Union[bytes, str, dict[str, Any]]
-    ):
+    def _send_to_webhook(self, webhook_url, payload):
        try:
            self.session.post(webhook_url, data=payload, timeout=self.timeout)
        except Exception as error_:
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -28,7 +28,6 @@ classifiers = [
    "Operating System :: OS Independent",
    "Programming Language :: Python :: 3"
 ]
-requires-python = ">=3.9, <3.14"
 dependencies = [
    "azure-identity>=1.8.0",
    "azure-monitor-ingestion>=1.0.0",
@@ -87,11 +86,11 @@ include = [

 [tool.hatch.build]
 exclude = [
-    "base_reverse_dns.csv",
-    "find_bad_utf8.py",
-    "find_unknown_base_reverse_dns.py",
-    "unknown_base_reverse_dns.csv",
-    "sortmaps.py",
-    "README.md",
-    "*.bak"
+"base_reverse_dns.csv",
+"find_bad_utf8.py",
+"find_unknown_base_reverse_dns.py",
+"unknown_base_reverse_dns.csv",
+"sortmaps.py",
+"README.md",
+"*.bak"
 ]
--- a/tests.py
+++ b/tests.py
@@ -1,6 +1,3 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
 from __future__ import absolute_import, print_function, unicode_literals

 import os
@@ -77,7 +74,7 @@ class Test(unittest.TestCase):
        print()
        file = "samples/extract_report/nice-input.xml"
        print("Testing {0}: ".format(file), end="")
-        xmlout = parsedmarc.extract_report_from_file_path(file)
+        xmlout = parsedmarc.extract_report(file)
        xmlin_file = open("samples/extract_report/nice-input.xml")
        xmlin = xmlin_file.read()
        xmlin_file.close()
Author	SHA1	Message	Date
Sean Whalen	110c6e507d	Update docs	2025-12-01 17:04:37 -05:00
Sean Whalen	c8cdd90a1e	Normalize timespans for aggregate reports in Elasticsearch and Opensearch	2025-12-01 16:34:40 -05:00
Sean Whalen	46a62cc10a	Update launch configuration and metadata key for timespan in aggregate report	2025-12-01 16:10:41 -05:00
Sean Whalen	67fe009145	Add sources my name table to the Kibana DMARC Summary dashboard This matches the table in the Splunk DMARC Aggregate reports dashboard	2025-11-30 19:43:14 -05:00
Sean Whalen	e405e8fa53	Update changelog to correct timespan threshold for DMARC report normalization	2025-11-30 16:17:07 -05:00
Sean Whalen	a72d08ceb7	Refactor configuration loading for normalize_timespan_threshold_hours	2025-11-30 16:16:32 -05:00
Sean Whalen	2785e3df34	More fixes for normalize_timespan_threshold_hours:	2025-11-30 13:56:50 -05:00
Sean Whalen	f4470a7dd2	Fix normalize_timespan_threshold_hours	2025-11-30 13:46:21 -05:00
Sean Whalen	18b9894a1f	Code formatting	2025-11-30 12:40:09 -05:00
Sean Whalen	d1791a97d3	Make timespan normalization hours configurable, with a 24.0 default	2025-11-30 12:23:38 -05:00
Sean Whalen	47ca6561c1	Fix changelog version	2025-11-30 10:46:48 -05:00
Sean Whalen	a0e18206ce	Bump version to 9.0.0	2025-11-29 23:01:04 -05:00
Sean Whalen	9e4ffdd54c	Add interval_begin, interval_end, and normalized_timespan to the Splunk report	2025-11-29 21:32:33 -05:00
Sean Whalen	434bd49eb3	Fix normalized_timespan in CSV output for aggregate reports	2025-11-29 21:23:39 -05:00
Sean Whalen	589038d2c9	Add normalized_timespan to CSV output for aggregate reports	2025-11-29 21:17:27 -05:00
Sean Whalen	c558224671	Rename normalized_timespan to timespan_requires_normalization and include interval_begin and interval_end in CSV output	2025-11-29 21:16:30 -05:00
Sean Whalen	044aa9e9a0	Include interval_begin in splunk output for accurate timestamping	2025-11-29 20:50:13 -05:00
Sean Whalen	6270468d30	Remove unneeded fields	2025-11-29 17:13:24 -05:00
Sean Whalen	832be7cfa3	Clean up imports	2025-11-29 16:56:12 -05:00
Sean Whalen	04dd11cf54	Fix formatting	2025-11-29 16:51:57 -05:00
Sean Whalen	0b41942916	Always include interval_begin and interval_end in records	2025-11-29 16:46:03 -05:00
Sean Whalen	f14a34202f	Add morse type hints	2025-11-29 16:33:40 -05:00
Sean Whalen	daa6653c29	Bump version to 8.20.0 and update changelog for new report volume normalization	2025-11-29 15:26:25 -05:00
Sean Whalen	45d1093a99	Normalize report volumes when a report timespan exceed 24 hours	2025-11-29 14:52:57 -05:00
Sean Whalen	c1a757ca29	Remove outdated launch config	2025-11-29 14:45:21 -05:00
Sean Whalen	69b9d25a99	Revert code formatting	2025-11-29 14:14:54 -05:00
Sean Whalen	94d65f979d	Code formatting	2025-11-29 14:04:20 -05:00