invoice2data 0.4.7__tar.gz → 0.5.0__tar.gz

{invoice2data-0.4.7/src/invoice2data.egg-info → invoice2data-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: invoice2data
-Version: 0.4.7
+Version: 0.5.0
 Summary: Python parser to extract data from pdf invoice
 Author: Manuel Riel
 License: MIT
@@ -12,7 +12,6 @@ Keywords: python,data-mining,accounting,invoice,pdf,parcing
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
@@ -26,7 +25,7 @@ Classifier: Topic :: Office/Business :: Financial :: Accounting
 Classifier: Topic :: Office/Business :: Financial
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Development Status :: 5 - Production/Stable
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
 Requires-Dist: click>=8.0.1
@@ -178,7 +177,7 @@ Using in-house templates
 See `invoice2data/extract/templates` for existing templates. Just extend
 the list to add your own. If deployed by a bigger organisation, there
 should be an interface to edit templates for new suppliers. 80-20 rule.
-For a short tutorial on how to add new templates, see [tutorial.md](./docs/tutorial.md).
+For a short tutorial on how to add new templates, see the [template creation tutorial][tutorial].
 
 Templates are based on Yaml or JSON. They define one or more keywords to find
 the right template, one or more exclude_keywords to further narrow it down
@@ -237,7 +236,7 @@ It can be installed on most distributions by:
 ## Development
 
 If you are interested in improving this project, have a look at our
-[developer guide](./CONTRIBUTING.md) to get you started quickly.
+[contributor guide] to get you started quickly.
 
 ## Roadmap and open tasks
 
@@ -287,3 +286,4 @@ To learn more, see the [Contributor Guide].
 [license]: https://invoice2data.readthedocs.io/latest/license.html
 [contributor guide]: https://invoice2data.readthedocs.io/latest/contributing.html
 [command-line reference]: https://invoice2data.readthedocs.io/latest/usage.html
+[tutorial]: https://invoice2data.readthedocs.io/latest/tutorial.html

{invoice2data-0.4.7 → invoice2data-0.5.0}/README.md

@@ -125,7 +125,7 @@ Using in-house templates
 See `invoice2data/extract/templates` for existing templates. Just extend
 the list to add your own. If deployed by a bigger organisation, there
 should be an interface to edit templates for new suppliers. 80-20 rule.
-For a short tutorial on how to add new templates, see [tutorial.md](./docs/tutorial.md).
+For a short tutorial on how to add new templates, see the [template creation tutorial][tutorial].
 
 Templates are based on Yaml or JSON. They define one or more keywords to find
 the right template, one or more exclude_keywords to further narrow it down
@@ -184,7 +184,7 @@ It can be installed on most distributions by:
 ## Development
 
 If you are interested in improving this project, have a look at our
-[developer guide](./CONTRIBUTING.md) to get you started quickly.
+[contributor guide] to get you started quickly.
 
 ## Roadmap and open tasks
 
@@ -234,3 +234,4 @@ To learn more, see the [Contributor Guide].
 [license]: https://invoice2data.readthedocs.io/latest/license.html
 [contributor guide]: https://invoice2data.readthedocs.io/latest/contributing.html
 [command-line reference]: https://invoice2data.readthedocs.io/latest/usage.html
+[tutorial]: https://invoice2data.readthedocs.io/latest/tutorial.html

{invoice2data-0.4.7 → invoice2data-0.5.0}/pyproject.toml

@@ -6,16 +6,15 @@ build-backend = "setuptools.build_meta"
 name = "invoice2data"
 authors = [{ name = "Manuel Riel" }]
 description = "Python parser to extract data from pdf invoice"
-version = "0.4.7"
+version = "0.5.0"
 keywords = ["python", "data-mining", "accounting", "invoice", "pdf", "parcing"]
 license = { text = "MIT" }
 readme = "README.md"
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 classifiers = [
     "Programming Language :: Python :: 3",
     "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",
-    "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
@@ -64,6 +63,7 @@ docs = [
     "sphinx-autobuild >=2021.3.14",
     "sphinx-click >=3.0.2",
     "sphinx-mermaid >=0.0.7",
+    "sphinxcontrib-svg2pdfconverter >=2.1.0",
 ]
 mypy = ["mypy >=0.930"]
 typeguard = ["typeguard >=2.13.3"]
@@ -161,8 +161,6 @@ extend-ignore = [
     "S101",   # use of assert Activate later
     "S603",
     "UP031",  # Use fstring instead of % identifier
-    "UP006",  # PEP 585 (list vs List): defer typing modernization to its own PR
-    "UP035",  # deprecated typing imports: defer typing modernization to its own PR
     "E501",   # fix this when updating docstrings
     # "DOC106",
     # "DOC107",

{invoice2data-0.4.7 → invoice2data-0.5.0}/src/invoice2data/__init__.py

@@ -1,3 +1,4 @@
 """Invoice2Data."""
 
+from .__main__ import Invoice2Data  # noqa: F401
 from .__main__ import extract_data  # noqa: F401

{invoice2data-0.4.7 → invoice2data-0.5.0}/src/invoice2data/__main__.py

@@ -9,10 +9,6 @@ from copy import deepcopy
 from os.path import join
 from typing import Any
 from typing import ClassVar
-from typing import Dict
-from typing import List
-from typing import Optional
-from typing import Tuple
 
 import click
 
@@ -110,9 +106,9 @@ if not logger.handlers:
 
 def extract_data(
     invoicefile: str,
-    templates: Optional[List[InvoiceTemplate]] = None,
+    templates: list[InvoiceTemplate] | None = None,
     input_module: Any = None,
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     """Extracts structured data from PDF/image invoices.
 
     This function uses the text extracted from a PDF file or image and
@@ -123,14 +119,14 @@ def extract_data(
 
     Args:
         invoicefile (str): Path of electronic invoice file in PDF, JPEG, PNG
-        templates (Optional[List[InvoiceTemplate]]): List of instances of class `InvoiceTemplate`.
+        templates (list[InvoiceTemplate] | None): List of instances of class `InvoiceTemplate`.
                                             Templates are loaded using `read_template` function in `loader.py`.
         input_module (Any, optional): Library to be used to extract text
                                         from the given `invoicefile`.
                                         Choices: {'pdftotext', 'pdfminer', 'tesseract', 'text'}.
 
     Returns:
-        Dict[str, Any]: Extracted and matched fields, or False if no template matches.
+        dict[str, Any]: Extracted and matched fields, or False if no template matches.
 
     Notes:
         Import the required `input_module` when using invoice2data as a library.
@@ -152,7 +148,15 @@ def extract_data(
     elif input_module is None:
         input_module = text if invoicefile.lower().endswith(".txt") else pdftotext
 
-    extracted_str = input_module.to_text(invoicefile)
+    try:
+        extracted_str = input_module.to_text(invoicefile)
+    except Exception:
+        logger.exception(
+            "Failed to extract text from %s using %s",
+            invoicefile,
+            input_module.__name__,
+        )
+        return {}
     if not isinstance(extracted_str, str) or not extracted_str.strip():
         logger.error(
             "Failed to extract text from %s using %s",
@@ -192,14 +196,14 @@ def extract_data(
 
 def extract_data_fallback_ocrmypdf(
     invoicefile: str,
-    templates: List[InvoiceTemplate],
+    templates: list[InvoiceTemplate],
     input_module: Any,
-) -> Tuple[str, str, List[InvoiceTemplate]]:
+) -> tuple[str, str, list[InvoiceTemplate]]:
     logger.debug("Trying OCR extraction with ocrmypdf")
     extracted_str = ocrmypdf.to_text(invoicefile)
 
     # Convert the filter object to a list
-    templates_matched: List[InvoiceTemplate] = list(
+    templates_matched: list[InvoiceTemplate] = list(
         filter(lambda t: t.matches_input(extracted_str), templates)
     )
     templates_matched.sort(key=lambda k: k["priority"], reverse=True)
@@ -211,6 +215,44 @@ def extract_data_fallback_ocrmypdf(
         return extracted_str, invoicefile, []
 
 
+class Invoice2Data:
+    """Object-oriented interface around :func:`extract_data`.
+
+    Holds a reusable set of templates so several invoices can be processed
+    without reloading templates each time.
+
+    Args:
+        load_built_in_templates (bool): Load the bundled templates on init.
+            Defaults to True.
+    """
+
+    def __init__(self, load_built_in_templates: bool = True) -> None:
+        self.templates: list[InvoiceTemplate] = []
+        if load_built_in_templates:
+            self.templates += read_templates()
+
+    def read_templates(self, path: str) -> None:
+        """Add templates from a user folder to this instance.
+
+        Args:
+            path (str): Folder containing .yml/.json templates to load.
+        """
+        self.templates += read_templates(os.path.abspath(path))
+
+    def extract_data(self, path: str, input_module: Any = None) -> dict[str, Any]:
+        """Extract data from an invoice using this instance's templates.
+
+        Args:
+            path (str): Path to the invoice file.
+            input_module (Any): Text-extraction module to use. Defaults to None
+                (auto-detect between text and pdftotext).
+
+        Returns:
+            dict[str, Any]: Extracted fields, or an empty dict if none matched.
+        """
+        return extract_data(path, self.templates, input_module)
+
+
 @click.command()
 @click.option(
     "--input-reader",
@@ -268,17 +310,17 @@ def extract_data_fallback_ocrmypdf(
 )
 @click.version_option()
 def main(
-    input_reader: Optional[str],
+    input_reader: str | None,
     output_format: str,
     output_date_format: str,
     output_name: str,
     debug: bool,
-    copy: Optional[str],
-    move: Optional[str],
+    copy: str | None,
+    move: str | None,
     filename_format: str,
-    template_folder: Optional[str],
+    template_folder: str | None,
     exclude_built_in_templates: bool,
-    input_files: Tuple[Any, ...],
+    input_files: tuple[Any, ...],
 ) -> None:
     """Extract data from PDF files and output it in a structured format."""
     if debug:
@@ -315,8 +357,8 @@ def main(
 
 
 def _load_templates(
-    template_folder: Optional[str], exclude_built_in_templates: bool
-) -> List[Any]:
+    template_folder: str | None, exclude_built_in_templates: bool
+) -> list[Any]:
     """Load templates from the specified folder."""
     templates = []
     if template_folder:
@@ -328,9 +370,9 @@ def _load_templates(
 
 def _process_and_move_copy(
     filename: str,
-    res: Dict[str, Any],
-    copy: Optional[str],
-    move: Optional[str],
+    res: dict[str, Any],
+    copy: str | None,
+    move: str | None,
     filename_format: str,
 ) -> None:
     """Process the extracted data and copy/move the file."""

{invoice2data-0.4.7 → invoice2data-0.5.0}/src/invoice2data/extract/invoice_template.py

@@ -5,11 +5,10 @@ Templates are initially read from .yml files and then kept as class.
 
 import re
 import unicodedata
+from collections import OrderedDict as OrderedDictType
 from logging import getLogger
 from pprint import pformat
 from typing import Any
-from typing import Dict
-from typing import OrderedDict as OrderedDictType
 
 import dateparser  # type: ignore[import-untyped]
 
@@ -68,7 +67,7 @@ class InvoiceTemplate(OrderedDictType[str, Any]):
         super().__init__(*args, **kwargs)
 
         # Merge template-specific options with defaults
-        self.options: Dict[str, Any] = OPTIONS_DEFAULT.copy()
+        self.options: dict[str, Any] = OPTIONS_DEFAULT.copy()
 
         if "options" in self:
             self.options.update(self["options"])
@@ -234,7 +233,7 @@ class InvoiceTemplate(OrderedDictType[str, Any]):
 
     def extract(
         self, optimized_str: str, invoice_file: str, input_module: Any
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """Extracts data from the optimized string using the template.
 
         Args:
@@ -243,7 +242,7 @@ class InvoiceTemplate(OrderedDictType[str, Any]):
             input_module (Any): The input module used.
 
         Returns:
-            Dict[str, Any]: The extracted data.
+            dict[str, Any]: The extracted data.
 
         """
         output = _initialize_output_and_log(self, optimized_str)
@@ -274,7 +273,7 @@ class InvoiceTemplate(OrderedDictType[str, Any]):
 
 def _initialize_output_and_log(
     self: InvoiceTemplate, optimized_str: str
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     """Initialize the output dictionary and log debug information."""
     logger.debug("START optimized_str ========================\n" + optimized_str)
     logger.debug("END optimized_str ==========================")
@@ -296,7 +295,7 @@ def _initialize_output_and_log(
 
 def _handle_area(
     self: InvoiceTemplate,
-    v: Dict[str, Any],
+    v: dict[str, Any],
     input_module: Any,
     invoice_file: str,
     optimized_str: str,
@@ -317,9 +316,9 @@ def _handle_area(
 def _handle_parser(
     self: InvoiceTemplate,
     k: str,
-    v: Dict[str, Any],
+    v: dict[str, Any],
     optimized_str_for_parser: str,
-    output: Dict[str, Any],
+    output: dict[str, Any],
 ) -> None:
     """Handle parsing using different parsers."""
     if v["parser"] in PARSERS_MAPPING:
@@ -334,7 +333,7 @@ def _handle_parser(
 
 
 def _handle_legacy_syntax(
-    self: InvoiceTemplate, k: str, v: Any, optimized_str: str, output: Dict[str, Any]
+    self: InvoiceTemplate, k: str, v: Any, optimized_str: str, output: dict[str, Any]
 ) -> None:
     """Handle legacy syntax for backward compatibility."""
     result = None
@@ -361,8 +360,8 @@ def _handle_legacy_syntax(
 
 
 def _check_required_fields(
-    self: InvoiceTemplate, output: Dict[str, Any]
-) -> Dict[str, Any]:
+    self: InvoiceTemplate, output: dict[str, Any]
+) -> dict[str, Any]:
     """Check if all required fields are present in the output."""
     if "required_fields" not in self.keys():
         required_fields = ["date", "amount", "invoice_number", "issuer"]

{invoice2data-0.4.7 → invoice2data-0.5.0}/src/invoice2data/extract/loader.py

@@ -6,12 +6,9 @@ Templates are initially read from .yml or .json files and then kept as class.
 import codecs
 import json
 import os
+from collections.abc import Callable
 from logging import getLogger
 from typing import Any
-from typing import Callable
-from typing import Dict
-from typing import List
-from typing import Optional
 from typing import cast
 
 
@@ -32,7 +29,7 @@ logger = getLogger(__name__)
 
 def ordered_load(
     stream: str, loader: Callable[[str], Any] = json.loads
-) -> List[InvoiceTemplate]:
+) -> list[InvoiceTemplate]:
     """Loads a stream of JSON data.
 
     Args:
@@ -40,7 +37,7 @@ def ordered_load(
         loader (Callable[[str], Any], optional): JSON loader function. Defaults to json.loads.
 
     Returns:
-        List[InvoiceTemplate]: List of InvoiceTemplate objects.
+        list[InvoiceTemplate]: List of InvoiceTemplate objects.
     """
     output = []
 
@@ -54,22 +51,22 @@ def ordered_load(
     for tpl in tpl_stream:
         tpl = prepare_template(tpl)
         if tpl:
-            output.append(InvoiceTemplate(cast(Dict[str, Any], tpl)))
+            output.append(InvoiceTemplate(cast(dict[str, Any], tpl)))
 
     return output
 
 
-def read_templates(folder: Optional[str] = None) -> List[InvoiceTemplate]:
+def read_templates(folder: str | None = None) -> list[InvoiceTemplate]:
     """Load YAML templates from template folder. Return list of dicts.
 
     Use built-in templates if no folder is set.
 
     Args:
-        folder (Optional[str]): User-defined folder where templates are stored.
+        folder (str | None): User-defined folder where templates are stored.
                                 If None, uses built-in templates.
 
     Returns:
-        List[InvoiceTemplate]: List of InvoiceTemplate objects.
+        list[InvoiceTemplate]: List of InvoiceTemplate objects.
 
     Examples:
         >>> templates = read_templates("./src/invoice2data/extract/templates/au")
@@ -109,20 +106,20 @@ def read_templates(folder: Optional[str] = None) -> List[InvoiceTemplate]:
             tpl = prepare_template(tpl)
 
             if tpl:
-                output.append(InvoiceTemplate(cast(Dict[str, Any], tpl)))
+                output.append(InvoiceTemplate(cast(dict[str, Any], tpl)))
 
     logger.info("Loaded %d templates from %s", len(output), folder)
     return output
 
 
-def prepare_template(tpl: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+def prepare_template(tpl: dict[str, Any]) -> dict[str, Any] | None:
     """Prepare a template for use.
 
     Args:
-        tpl (Dict[str, Any]): Template dictionary.
+        tpl (dict[str, Any]): Template dictionary.
 
     Returns:
-        Optional[Dict[str, Any]]: Processed template dictionary.
+        dict[str, Any] | None: Processed template dictionary.
     """
     # Test if all required fields are in template
     if "keywords" not in tpl:

{invoice2data-0.4.7 → invoice2data-0.5.0}/src/invoice2data/extract/parsers/lines.py

@@ -5,12 +5,8 @@ Initial work and maintenance by Holger Brunn @hbrunn
 
 import re
 from logging import getLogger
+from re import Match
 from typing import Any
-from typing import Dict
-from typing import List
-from typing import Match
-from typing import Optional
-from typing import Union
 
 
 # from ..invoice_template import InvoiceTemplate  # type: ignore[unused-ignore]
@@ -20,7 +16,7 @@ logger = getLogger(__name__)
 DEFAULT_OPTIONS = {"line_separator": r"\n"}
 
 
-def parse_line(patterns: Union[str, List[str]], line: str) -> Optional[Match[str]]:
+def parse_line(patterns: str | list[str], line: str) -> Match[str] | None:
     """Parse a line using a given pattern or list of patterns.
 
     This function searches for a match in the given line using the provided
@@ -28,11 +24,11 @@ def parse_line(patterns: Union[str, List[str]], line: str) -> Optional[Match[str
     object; otherwise, it returns None.
 
     Args:
-        patterns (Union[str, List[str]]): The pattern(s) to search for.
+        patterns (str | list[str]): The pattern(s) to search for.
         line (str): The line to parse.
 
     Returns:
-        Optional[Match[str]]: A match object if a match is found, otherwise None.
+        Match[str] | None: A match object if a match is found, otherwise None.
     """
     patterns = patterns if isinstance(patterns, list) else [patterns]
     for pattern in patterns:
@@ -43,11 +39,11 @@ def parse_line(patterns: Union[str, List[str]], line: str) -> Optional[Match[str
 
 
 def parse_block(  # noqa: RUF100 C901
-    template: Dict[str, Any],
+    template: dict[str, Any],
     field: str,
-    settings: Dict[str, Any],
+    settings: dict[str, Any],
     content: str,
-) -> List[Dict[str, Any]]:
+) -> list[dict[str, Any]]:
     """Parse a block of lines to extract data.
 
     This function parses a block of lines from an invoice to extract data
@@ -56,13 +52,13 @@ def parse_block(  # noqa: RUF100 C901
     based on the configuration.
 
     Args:
-        template (Dict[str, Any]): The template containing extraction rules.
+        template (dict[str, Any]): The template containing extraction rules.
         field (str): The name of the field to extract.
-        settings (Dict[str, Any]): The settings for the extraction rule.
+        settings (dict[str, Any]): The settings for the extraction rule.
         content (str): The text content to parse.
 
     Returns:
-        List[Dict[str, Any]]: A list of dictionaries, where each dictionary
+        list[dict[str, Any]]: A list of dictionaries, where each dictionary
                                 represents an extracted row with field-value pairs.
     """
     # Validate settings
@@ -72,8 +68,8 @@ def parse_block(  # noqa: RUF100 C901
 
     logger.debug("START lines block content ========================\n%s", content)
     logger.debug("END lines block content ==========================")
-    lines: List[Dict[str, Any]] = []
-    current_row: Dict[str, Any] = {}
+    lines: list[dict[str, Any]] = []
+    current_row: dict[str, Any] = {}
 
     # We assume that structured line fields may either be individual lines or
     # they may be main line items with descriptions or details following beneath.
@@ -167,21 +163,21 @@ def parse_block(  # noqa: RUF100 C901
 
 
 def parse_by_rule(
-    template: Dict[str, Any],
+    template: dict[str, Any],
     field: str,
-    rule: Dict[str, Any],
+    rule: dict[str, Any],
     content: str,
-) -> List[Dict[str, Any]]:
+) -> list[dict[str, Any]]:
     """Parse lines from a block of text based on a rule.
 
     Args:
-        template (Dict[str, Any]): The template dictionary.
+        template (dict[str, Any]): The template dictionary.
         field (str): The field name.
-        rule (Dict[str, Any]): The rule dictionary.
+        rule (dict[str, Any]): The rule dictionary.
         content (str): The text content to parse.
 
     Returns:
-        List[Dict[str, Any]]: The parsed lines.
+        list[dict[str, Any]]: The parsed lines.
     """
     # First apply default options.
     settings = DEFAULT_OPTIONS.copy()
@@ -227,21 +223,21 @@ def parse_by_rule(
 
 
 def parse(
-    template: Dict[str, Any],
+    template: dict[str, Any],
     field: str,
-    settings: Dict[str, Any],
+    settings: dict[str, Any],
     content: str,
-) -> List[Dict[str, Any]]:
+) -> list[dict[str, Any]]:
     """Parse lines from the content based on the given settings.
 
     Args:
-        template (Dict[str, Any]): The template dictionary.
+        template (dict[str, Any]): The template dictionary.
         field (str): The field name.
-        settings (Dict[str, Any]): The settings dictionary.
+        settings (dict[str, Any]): The settings dictionary.
         content (str): The text content to parse.
 
     Returns:
-        List[Dict[str, Any]]: The parsed lines.
+        list[dict[str, Any]]: The parsed lines.
     """
     if "rules" in settings:
         # One field can have multiple sets of line-parsing rules
@@ -262,16 +258,16 @@ def parse(
 
 
 def parse_current_row(
-    match: Optional[Match[str]], current_row: Dict[str, Any]
-) -> Dict[str, Any]:
+    match: Match[str] | None, current_row: dict[str, Any]
+) -> dict[str, Any]:
     """Parse the current row data.
 
     Args:
-        match (Optional[Match[str]]): The match object.
-        current_row (Dict[str, Any]): The current row dictionary.
+        match (Match[str] | None): The match object.
+        current_row (dict[str, Any]): The current row dictionary.
 
     Returns:
-        Dict[str, Any]: The updated current row dictionary.
+        dict[str, Any]: The updated current row dictionary.
     """
     if match:
         for field, value in match.groupdict().items():

{invoice2data-0.4.7 → invoice2data-0.5.0}/src/invoice2data/extract/parsers/regex.py

@@ -15,9 +15,6 @@ import logging
 import re
 from collections import OrderedDict
 from typing import Any
-from typing import Dict
-from typing import List
-from typing import Optional
 
 from ..utils import _apply_grouping
 
@@ -28,7 +25,7 @@ logger = logging.getLogger(__name__)
 def parse(
     template: Any,
     field: str,
-    settings: Dict[str, Any],
+    settings: dict[str, Any],
     content: str,
     legacy: bool = False,
 ) -> Any:
@@ -37,7 +34,7 @@ def parse(
     Args:
         template (Any): The template object.
         field (str): The name of the field to extract.
-        settings (Dict[str, Any]): The settings for the field extraction.
+        settings (dict[str, Any]): The settings for the field extraction.
         content (str): The text content to parse.
         legacy (bool, optional): Whether to use legacy parsing. Defaults to False.
 
@@ -64,7 +61,7 @@ def parse(
     return result
 
 
-def _extract_matches(settings: Dict[str, Any], content: str) -> Optional[List[Any]]:
+def _extract_matches(settings: dict[str, Any], content: str) -> list[Any] | None:
     """Extract matches from the content using the given regexes."""
     if isinstance(settings["regex"], list):
         regexes = settings["regex"]
@@ -100,8 +97,8 @@ def _extract_matches(settings: Dict[str, Any], content: str) -> Optional[List[An
 
 
 def _apply_type_coercion(
-    template: Any, settings: Dict[str, Any], result: List[Any]
-) -> List[Any]:
+    template: Any, settings: dict[str, Any], result: list[Any]
+) -> list[Any]:
     """Apply type coercion to the extracted values."""
     if "type" in settings:
         for k, v in enumerate(result):
@@ -109,7 +106,7 @@ def _apply_type_coercion(
     return result
 
 
-def _remove_duplicates(legacy: bool, result: Optional[Any]) -> Optional[Any]:
+def _remove_duplicates(legacy: bool, result: Any | None) -> Any | None:
     """Remove duplicate values from the result."""
     if isinstance(result, list):
         if legacy: