PyPI - psdi-data-conversion - Versions diffs - 0.0.23__py3-none-any.whl - Mend

psdi-data-conversion 0.0.23__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (81) hide show

psdi_data_conversion/__init__.py +11 -0
psdi_data_conversion/app.py +242 -0
psdi_data_conversion/bin/linux/atomsk +0 -0
psdi_data_conversion/bin/linux/c2x +0 -0
psdi_data_conversion/bin/mac/atomsk +0 -0
psdi_data_conversion/bin/mac/c2x +0 -0
psdi_data_conversion/constants.py +185 -0
psdi_data_conversion/converter.py +459 -0
psdi_data_conversion/converters/__init__.py +6 -0
psdi_data_conversion/converters/atomsk.py +32 -0
psdi_data_conversion/converters/base.py +702 -0
psdi_data_conversion/converters/c2x.py +32 -0
psdi_data_conversion/converters/openbabel.py +239 -0
psdi_data_conversion/database.py +1064 -0
psdi_data_conversion/dist.py +87 -0
psdi_data_conversion/file_io.py +216 -0
psdi_data_conversion/log_utility.py +241 -0
psdi_data_conversion/main.py +776 -0
psdi_data_conversion/scripts/atomsk.sh +32 -0
psdi_data_conversion/scripts/c2x.sh +26 -0
psdi_data_conversion/security.py +38 -0
psdi_data_conversion/static/content/accessibility.htm +254 -0
psdi_data_conversion/static/content/convert.htm +121 -0
psdi_data_conversion/static/content/convertato.htm +65 -0
psdi_data_conversion/static/content/convertc2x.htm +65 -0
psdi_data_conversion/static/content/documentation.htm +94 -0
psdi_data_conversion/static/content/feedback.htm +53 -0
psdi_data_conversion/static/content/header-links.html +8 -0
psdi_data_conversion/static/content/index-versions/header-links.html +8 -0
psdi_data_conversion/static/content/index-versions/psdi-common-footer.html +99 -0
psdi_data_conversion/static/content/index-versions/psdi-common-header.html +28 -0
psdi_data_conversion/static/content/psdi-common-footer.html +99 -0
psdi_data_conversion/static/content/psdi-common-header.html +28 -0
psdi_data_conversion/static/content/report.htm +103 -0
psdi_data_conversion/static/data/data.json +143940 -0
psdi_data_conversion/static/img/colormode-toggle-dm.svg +3 -0
psdi_data_conversion/static/img/colormode-toggle-lm.svg +3 -0
psdi_data_conversion/static/img/psdi-icon-dark.svg +136 -0
psdi_data_conversion/static/img/psdi-icon-light.svg +208 -0
psdi_data_conversion/static/img/psdi-logo-darktext.png +0 -0
psdi_data_conversion/static/img/psdi-logo-lighttext.png +0 -0
psdi_data_conversion/static/img/social-logo-bluesky-black.svg +4 -0
psdi_data_conversion/static/img/social-logo-bluesky-white.svg +4 -0
psdi_data_conversion/static/img/social-logo-instagram-black.svg +1 -0
psdi_data_conversion/static/img/social-logo-instagram-white.svg +1 -0
psdi_data_conversion/static/img/social-logo-linkedin-black.png +0 -0
psdi_data_conversion/static/img/social-logo-linkedin-white.png +0 -0
psdi_data_conversion/static/img/social-logo-mastodon-black.svg +4 -0
psdi_data_conversion/static/img/social-logo-mastodon-white.svg +4 -0
psdi_data_conversion/static/img/social-logo-x-black.svg +3 -0
psdi_data_conversion/static/img/social-logo-x-white.svg +3 -0
psdi_data_conversion/static/img/social-logo-youtube-black.png +0 -0
psdi_data_conversion/static/img/social-logo-youtube-white.png +0 -0
psdi_data_conversion/static/img/ukri-epsr-logo-darktext.png +0 -0
psdi_data_conversion/static/img/ukri-epsr-logo-lighttext.png +0 -0
psdi_data_conversion/static/img/ukri-logo-darktext.png +0 -0
psdi_data_conversion/static/img/ukri-logo-lighttext.png +0 -0
psdi_data_conversion/static/javascript/accessibility.js +196 -0
psdi_data_conversion/static/javascript/common.js +42 -0
psdi_data_conversion/static/javascript/convert.js +296 -0
psdi_data_conversion/static/javascript/convert_common.js +252 -0
psdi_data_conversion/static/javascript/convertato.js +107 -0
psdi_data_conversion/static/javascript/convertc2x.js +107 -0
psdi_data_conversion/static/javascript/data.js +176 -0
psdi_data_conversion/static/javascript/format.js +611 -0
psdi_data_conversion/static/javascript/load_accessibility.js +89 -0
psdi_data_conversion/static/javascript/psdi-common.js +177 -0
psdi_data_conversion/static/javascript/report.js +381 -0
psdi_data_conversion/static/styles/format.css +147 -0
psdi_data_conversion/static/styles/psdi-common.css +705 -0
psdi_data_conversion/templates/index.htm +114 -0
psdi_data_conversion/testing/__init__.py +5 -0
psdi_data_conversion/testing/constants.py +12 -0
psdi_data_conversion/testing/conversion_callbacks.py +394 -0
psdi_data_conversion/testing/conversion_test_specs.py +208 -0
psdi_data_conversion/testing/utils.py +522 -0
psdi_data_conversion-0.0.23.dist-info/METADATA +663 -0
psdi_data_conversion-0.0.23.dist-info/RECORD +81 -0
psdi_data_conversion-0.0.23.dist-info/WHEEL +4 -0
psdi_data_conversion-0.0.23.dist-info/entry_points.txt +2 -0
psdi_data_conversion-0.0.23.dist-info/licenses/LICENSE +201 -0

psdi_data_conversion/templates/index.htm ADDED Viewed

@@ -0,0 +1,114 @@
+<!--
+  index.htm
+  Version 1.0, 27th November 2024
+-->
+<!DOCTYPE html>
+<html>
+<head>
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>PSDI Data Conversion Service</title>
+  <link rel="icon" type="image/x-icon" href="./static/img/psdi-icon-dark.svg">
+  <link href="https://fonts.googleapis.com/css?family=Lato:400" rel="stylesheet" type="text/css">
+  <link href="https://fonts.googleapis.com/css?family=Open+Sans+Condensed:700" rel="stylesheet" type="text/css">
+  <link href="https://fonts.googleapis.com/css?family=Open+Sans:400" rel="stylesheet" type="text/css">
+  <link href="https://fonts.googleapis.com/css?family=Lexend:400" rel="stylesheet" type="text/css">
+  <link rel="stylesheet" href="{{url_for('static', filename='styles/format.css')}}">
+  <script src="static/javascript/load_accessibility.js"></script>
+</head>
+<body marginwidth="0">
+  <!-- Cover to hide element loading and make page transitions seem smoother -->
+  <div id="cover"></div>
+  <header class="header" id="psdi-header"></header>
+  <script type="module">
+    import { setHeaderLinksSource, setHeaderSource, setFooterSource } from "./static/javascript/psdi-common.js";
+    // Due to the index being a template which will exist in a different directory once rendered, we need to set
+    // a non-default location of the header links file
+    setHeaderSource("{{url_for('static', filename='content/index-versions/psdi-common-header.html')}}");
+    setFooterSource("{{url_for('static', filename='content/index-versions/psdi-common-footer.html')}}");
+    setHeaderLinksSource("{{url_for('static', filename='content/index-versions/header-links.html')}}");
+  </script>
+  <div class="hero">
+    <div class="max-width-box">
+      <h1 class="hero__title marginless_header">Format and Converter Selection</h1>
+    </div>
+  </div>
+  <form name="gui">
+    <div class="max-width-box">
+      <p>Select 'from' and 'to' file formats in the 'Convert from/to' boxes, in either order. Typing where indicated
+        filters the options (case insensitive); for example, typing 'can' or 'NON' reduces the number of options to one:
+        'can: Canonical SMILES.' If you change your mind about a conversion, it is advisable to click on the 'Reset'
+        button. When both formats have been selected, converters able to carry out this conversion appear in the
+        'Conversion options' box along with an indication of conversion quality (many conversions have not yet been
+        tested) and whether or not the converter is supported on this site.</p>
+      <p>
+        <label for="searchFrom" id="fromLabel">Convert from:</label><br>
+        <input type="text" placeholder="-- type here to filter options --" size="12" id="searchFrom"
+          class="large-width"><br>
+        <select size="4" id="fromList" class="large-width"></select>
+      </p>
+      <div class="smallGap"></div>
+      <p>
+        <label for="searchTo" id="toLabel">Convert to:</label><br>
+        <input type="text" placeholder="-- type here to filter options --" size="12" id="searchTo"
+          class="large-width"><br>
+        <select size="4" id="toList" class="large-width"></select>
+      </p>
+      <input type="button" class="button" value=" Reset " name="resetButton" id="resetButton">
+      <br><br>
+      <p>Selecting a converter displays information
+        about it, along with a link to a relevant website. Selecting a supported converter affords the opportunity to
+        carry out a conversion on this site. Clicking on the 'Yes' button takes us to the 'Conversion' page. If a
+        file format has not been found, or if there are no converters capable of carrying out a required conversion
+        please click on 'Report Missing Format/Conversion' in the navigation bar.</p>
+      <p>
+        <label for="success">Select from available conversion
+          options:</label><br>
+        <select size="4" id="success" class="large-width"></select>
+      </p>
+      <span class="normalText">Show how the conversion quality was determined for the selected converter.</span>
+      <input type="button" class="button" value=" Show " name="showButton" id="showButton">
+      <br>
+      <h6>Converter details:</h6>
+      <p id="converter" , class="init-hidden">
+        <span id="name"></span>
+        <br><span id="description"></span>
+        <br><span id="url"></span>
+        <br><span id="info"></span>
+        <a id="visit" target="_blank">this website.</a>
+      <div id="formatWarning" class="init-hidden"></div>
+      <div id="offer" class="init-hidden">
+        <span id="question"></span>
+        <input type="button" class="button" value=" Yes " name="yesButton" id="yesButton">
+      </div>
+      </p>
+      <div class="medGap"></div>
+    </div>
+  </form>
+  <script src="https://code.jquery.com/jquery-3.7.1.js" integrity="sha256-eKhayi8LEQwp4NKxN+CfCh+3qOVUtJn3QNZ0TciWLP4="
+    crossorigin="anonymous"></script>
+  {% for item in data %}
+  <script>
+    const token = "{{item.token}}";
+    const max_file_size = "{{item.max_file_size}}";
+    const service_mode = "{{item.service_mode}}";
+    const production_mode = "{{item.production_mode}}";
+  </script>
+  <div class="secondary prod-only">
+    <div class="max-width-box">SHA: {{item.sha}}</div>
+  </div>
+  {% endfor %}
+  <script src="{{url_for('static', filename='/javascript/format.js')}}" type="module" language="JavaScript"></script>
+  <footer class="footer" id="psdi-footer"></footer>
+</body>
+</html>

psdi_data_conversion/testing/__init__.py ADDED Viewed

@@ -0,0 +1,5 @@
+"""
+# Testing package
+This package contains functions, classes, and information used solely for the purpose of running unit tests.
+"""

psdi_data_conversion/testing/constants.py ADDED Viewed

@@ -0,0 +1,12 @@
+"""
+# constants.py
+Constants related to unit testing
+"""
+import os
+TEST_DATA_LOC = os.path.abspath("./test_data")
+INPUT_TEST_DATA_LOC = TEST_DATA_LOC
+OUTPUT_TEST_DATA_LOC = os.path.join(TEST_DATA_LOC, "output")

psdi_data_conversion/testing/conversion_callbacks.py ADDED Viewed

@@ -0,0 +1,394 @@
+"""
+# conversion_callbacks.py
+This module provides functions and callable classes which can be used as callbacks for to check the results of a
+conversion test, run with the functions and classes defined in the `utils.py` module.
+"""
+import abc
+from collections.abc import Callable, Iterable
+from dataclasses import dataclass, field
+import os
+import re
+from tempfile import TemporaryDirectory
+from psdi_data_conversion.constants import DATETIME_RE_RAW
+from psdi_data_conversion.file_io import unpack_zip_or_tar
+from psdi_data_conversion.log_utility import string_with_placeholders_matches
+from psdi_data_conversion.testing.constants import OUTPUT_TEST_DATA_LOC
+from psdi_data_conversion.testing.utils import ConversionTestInfo, LibraryConversionTestInfo, check_file_match
+class MultiCallback:
+    """Callable class which stores a list of other callbacks to call on the input, and runs them all in sequence. All
+    callbacks will be run, even if some fail, and the results will be joined to an output string.
+    """
+    def __init__(self, *l_callbacks: Callable[[ConversionTestInfo], str]):
+        self.l_callbacks: Iterable[Callable[[ConversionTestInfo], str]] = l_callbacks
+        """A list of callbacks to be called in turn"""
+    def __call__(self, test_info: ConversionTestInfo) -> str:
+        """When called and passed test info, run each stored callback on the test info in turn and join the results
+        """
+        l_results = [callback(test_info) for callback in self.l_callbacks]
+        # Only join non-empty results so we don't end up with excess newlines
+        res = "\n".join([x for x in l_results if x]).strip()
+        return res
+@dataclass
+class CheckFileStatus:
+    """Callable class which checks the presence or absence of standard input and output files for a conversion"""
+    expect_input_exists: bool | None = True
+    """Whether to expect that the input file of the conversion exists (with non-zero size) or not. If None, will
+    not check either way."""
+    expect_output_exists: bool | None = True
+    """Whether to expect that the output file of the conversion exists (with non-zero size) or not. If None, will
+    not check either way."""
+    expect_log_exists: bool | None = True
+    """Whether to expect that the log exists (with non-zero size) or not. If None, will not check either way."""
+    expect_global_log_exists: bool | None = None
+    """Whether to expect that the global log exists (zero-size allowed) or not. If None, will not check either way."""
+    def __call__(self, test_info: ConversionTestInfo) -> str:
+        """Perform the check on output file and log status"""
+        l_errors: list[str] = []
+        # Check the status of the input file
+        qualified_in_filename = test_info.qualified_in_filename
+        if self.expect_input_exists:
+            if not os.path.isfile(qualified_in_filename):
+                l_errors.append(f"ERROR: Expected input file for conversion '{qualified_in_filename}' does not "
+                                "exist")
+            elif os.path.getsize(qualified_in_filename) == 0:
+                l_errors.append(f"ERROR: Expected input file for conversion '{qualified_in_filename}' exists but "
+                                "is unexpectedly empty")
+        elif self.expect_output_exists is False and os.path.isfile(qualified_in_filename):
+            l_errors.append(f"ERROR: Input file from conversion '{qualified_in_filename}' exists, but was expected "
+                            "to not exist")
+        # Check the status of the output file
+        qualified_out_filename = test_info.qualified_out_filename
+        if self.expect_output_exists:
+            if not os.path.isfile(qualified_out_filename):
+                l_errors.append(f"ERROR: Expected output file from conversion '{qualified_out_filename}' does not "
+                                "exist")
+            elif os.path.getsize(qualified_out_filename) == 0:
+                l_errors.append(f"ERROR: Expected output file from conversion '{qualified_out_filename}' exists but "
+                                "is unexpectedly empty")
+        elif self.expect_output_exists is False and os.path.isfile(qualified_out_filename):
+            l_errors.append(f"ERROR: Output file from conversion '{qualified_out_filename}' exists, but was expected "
+                            "to not exist")
+        qualified_log_filename = test_info.qualified_log_filename
+        if self.expect_log_exists:
+            if not os.path.isfile(qualified_log_filename):
+                l_errors.append(f"ERROR: Expected log file from conversion '{qualified_log_filename}' does not "
+                                "exist")
+            elif os.path.getsize(qualified_log_filename) == 0:
+                l_errors.append(f"ERROR: Expected log file from conversion '{qualified_log_filename}' exists but "
+                                "is unexpectedly empty")
+        elif self.expect_log_exists is False and os.path.isfile(qualified_log_filename):
+            l_errors.append(f"ERROR: Log file from conversion '{qualified_log_filename}' exists, but was expected "
+                            "to not exist")
+        qualified_global_log_filename = test_info.qualified_global_log_filename
+        if self.expect_global_log_exists:
+            if not os.path.isfile(qualified_global_log_filename):
+                l_errors.append(f"ERROR: Expected global log file from conversion '{qualified_global_log_filename}' "
+                                "does not exist")
+        elif self.expect_global_log_exists is False and os.path.isfile(qualified_global_log_filename):
+            l_errors.append(f"ERROR: Global log file from conversion '{qualified_global_log_filename}' exists, but was "
+                            "expected to not exist")
+        # Join any errors for output
+        res = "\n".join(l_errors)
+        return res
+@dataclass
+class CheckArchiveContents:
+    """Callable class which checks that an archive file created as the result of a conversion contains files with the
+    expected names and all of the expected type"""
+    l_filename_bases: Iterable[str]
+    """List of unqualified filenames without extensions, representing the files that should be found in the archive"""
+    to_format: str
+    """Format (extension) that all files in the archive should have"""
+    def __call__(self, test_info: ConversionTestInfo):
+        """Run the check on archive contents"""
+        # First, check that the archive file exists
+        qualified_out_filename = test_info.qualified_out_filename
+        if not os.path.isfile(qualified_out_filename):
+            raise FileNotFoundError(f"ERROR: Expected output file from conversion '{qualified_out_filename}' does not "
+                                    "exist")
+        l_errors = []
+        # Use a temporary directory to unpack the archive, then check for each file in it
+        with TemporaryDirectory() as extract_dir:
+            unpack_zip_or_tar(qualified_out_filename, extract_dir=extract_dir)
+            for filename_base in self.l_filename_bases:
+                filename = f"{filename_base}.{self.to_format}"
+                if not os.path.isfile(os.path.join(extract_dir, filename)):
+                    l_errors.append(f"ERROR: Expected file '{filename}' was not found in archive "
+                                    f"{qualified_out_filename}")
+        return "\n".join(l_errors)
+@dataclass
+class CheckTextContents(abc.ABC):
+    """Callable class which checks the contents of some text (e.g. stdout or a log file) from a conversion"""
+    l_strings_to_find: str | Iterable[str] = field(default_factory=list)
+    """One or more strings which must be found in the text. These may optionally include formatting placeholders,
+    e.g. "The filename is: {file}", in which case any text in the place of the placeholder will be considered valid for
+    a match.
+    """
+    l_strings_to_exclude: str | Iterable[str] = field(default_factory=list)
+    """One or more strings which must NOT be found in the text. These may optionally include formatting
+    placeholders, e.g. "The filename is: {file}", in which case any text in the place of the placeholder will be
+    considered valid for a match.
+    """
+    l_regex_to_find: str | Iterable[str] = field(default_factory=list)
+    """One or more uncompiled regular expressions which must be matched somewhere in the text"""
+    l_regex_to_exclude: str | Iterable[str] = field(default_factory=list)
+    """One or more uncompiled regular expressions which must NOT be matched anywhere in the text"""
+    def __post_init__(self):
+        """If any input was provided as just a single string, coerce it to a list"""
+        if isinstance(self.l_strings_to_find, str):
+            self.l_strings_to_find = [self.l_strings_to_find]
+        if isinstance(self.l_strings_to_exclude, str):
+            self.l_strings_to_exclude = [self.l_strings_to_exclude]
+        if isinstance(self.l_regex_to_find, str):
+            self.l_regex_to_find = [self.l_regex_to_find]
+        if isinstance(self.l_regex_to_exclude, str):
+            self.l_regex_to_exclude = [self.l_regex_to_exclude]
+    def get_default_strings_to_find(self, test_info: ConversionTestInfo) -> list[str]:
+        """Get a default list of strings to find in the text; can be overridden by child classes to implement
+        defaults"""
+        return []
+    def get_default_strings_to_exclude(self, test_info: ConversionTestInfo) -> list[str]:
+        """Get a default list of strings to NOT find in the text; can be overridden by child classes to implement
+        defaults"""
+        return []
+    def get_default_regex_to_find(self, test_info: ConversionTestInfo) -> list[str]:
+        """Get a default list of uncompiled regular expressions to match in the text; can be overridden by child
+        classes to implement defaults"""
+        return []
+    def get_default_regex_to_exclude(self, test_info: ConversionTestInfo) -> list[str]:
+        """Get a default list of uncompiled regular expressions to NOT match in the text; can be overridden by
+        child classes to implement defaults"""
+        return []
+    @abc.abstractmethod
+    def _get_text(self, test_info: ConversionTestInfo) -> str:
+        """Abstract method which must be overridden to get the text to be checked"""
+        pass
+    @abc.abstractmethod
+    def _get_text_source_label(self, test_info: ConversionTestInfo) -> str:
+        """Abstract method which must be overridden to label the source of the text to be checked"""
+        pass
+    def __call__(self, test_info: ConversionTestInfo) -> str:
+        """Perform the check on text contents"""
+        test_text = self._get_text(test_info)
+        l_errors: list[str] = []
+        # Add the default checks to the lists of strings/regexes to check
+        l_strings_to_find: list[str] = list(self.l_strings_to_find) + self.get_default_strings_to_find(test_info)
+        l_strings_to_exclude: list[str] = (list(self.l_strings_to_exclude) +
+                                           self.get_default_strings_to_exclude(test_info))
+        l_regex_to_find: list[str] = list(self.l_regex_to_find) + self.get_default_regex_to_find(test_info)
+        l_regex_to_exclude: list[str] = list(self.l_regex_to_exclude) + self.get_default_regex_to_exclude(test_info)
+        # Check that all expected strings are present
+        for string_to_find in l_strings_to_find:
+            if not string_with_placeholders_matches(string_to_find, test_text):
+                l_errors.append(f"ERROR: String \"{string_to_find}\" was expected in "
+                                f"{self._get_text_source_label(test_info)} but was not found. Text:\n {test_text}")
+        # Check that all excluded strings are not present
+        for l_strings_to_exclude in l_strings_to_exclude:
+            if string_with_placeholders_matches(l_strings_to_exclude, test_text):
+                l_errors.append(f"ERROR: String \"{l_strings_to_exclude}\" was not expected in "
+                                f"{self._get_text_source_label(test_info)} but was found. Text:\n {test_text}")
+        # Check that all expected regexes are present
+        for regex_to_find in l_regex_to_find:
+            compiled_regex = re.compile(regex_to_find)
+            if not compiled_regex.search(test_text):
+                l_errors.append(f"ERROR: Regex /{regex_to_find}/ was expected in "
+                                f"{self._get_text_source_label(test_info)} but was not found. Text:\n {test_text}")
+        # Check that all excluded regexes are not present
+        for regex_to_exclude in l_regex_to_exclude:
+            compiled_regex = re.compile(regex_to_exclude)
+            if compiled_regex.search(test_text):
+                l_errors.append(f"ERROR: Regex /{regex_to_exclude}/ was not expected in "
+                                f"{self._get_text_source_label(test_info)} but was found. Text:\n {test_text}")
+        # Join any errors for output
+        res = "\n".join(l_errors)
+        return res
+@dataclass
+class CheckLogContents(CheckTextContents):
+    """Implementation of `CheckTextContents` which checks the contents of the output log file of a conversion"""
+    def _get_text(self, test_info: ConversionTestInfo) -> str:
+        """Get the text from the output log file"""
+        # First, check that the log exists
+        qualified_log_filename = test_info.qualified_log_filename
+        if not os.path.isfile(qualified_log_filename):
+            raise FileNotFoundError(f"ERROR: Expected log file from conversion '{qualified_log_filename}' does not "
+                                    "exist")
+        return open(qualified_log_filename, "r").read()
+    def _get_text_source_label(self, test_info: ConversionTestInfo) -> str:
+        """Label as coming from the appropriate log file"""
+        return f"log file '{test_info.qualified_log_filename}'"
+@dataclass
+class CheckLogContentsSuccess(CheckLogContents):
+    """Specialized callback to check log contents for a successful conversion"""
+    def get_default_strings_to_exclude(self, test_info: ConversionTestInfo) -> Iterable[str]:
+        """Exclude strings which indicate something likely went wrong"""
+        return ["ERROR", "exception", "Exception"]
+    def get_default_regex_to_find(self, test_info: ConversionTestInfo) -> Iterable[str]:
+        """Check for the filename and date and time in the log"""
+        return [r"File name:\s*"+os.path.splitext(test_info.test_spec.filename)[0],
+                DATETIME_RE_RAW]
+@dataclass
+class CheckStdoutContents(CheckTextContents):
+    """Implementation of `CheckTextContents` which checks the output to stdout"""
+    def _get_text(self, test_info: ConversionTestInfo) -> str:
+        """Get the text from the captured stdout"""
+        return test_info.captured_stdout
+    def _get_text_source_label(self, test_info: ConversionTestInfo) -> str:
+        """Label as coming from stdout"""
+        return "stdout"
+@dataclass
+class CheckStderrContents(CheckTextContents):
+    """Implementation of `CheckTextContents` which checks the output to stderr"""
+    def _get_text(self, test_info: ConversionTestInfo) -> str:
+        """Get the text from the captured stderr"""
+        return test_info.captured_stderr
+    def _get_text_source_label(self, test_info: ConversionTestInfo) -> str:
+        """Label as coming from stderr"""
+        return "stderr"
+@dataclass
+class CheckException:
+    """Callable class which checks an exception raised for its type, status code, and message. Tests will only be
+    run on tests with the python library, as that's the only route that provides exceptions."""
+    ex_type: type[Exception]
+    """The expected type of the raised exception (subclasses of it will also be allowed)"""
+    ex_message: str | None = None
+    """A string pattern (with placeholders allowed) which must be found in the exceptions message"""
+    ex_status_code: int | None = None
+    """The required status code of the exception - will not pass if this is provided and the exception doesn't come
+    with a status code"""
+    def __call__(self, test_info: ConversionTestInfo) -> str:
+        """Perform the check on the exception"""
+        if not isinstance(test_info, LibraryConversionTestInfo):
+            return ""
+        # Confirm that an exception was indeed raised
+        exc_info = test_info.exc_info
+        if not exc_info:
+            return f"ERROR: No exception was raised - expected an exception of type {self.ex_type}"
+        l_errors: list[str] = []
+        # Check the exception type
+        if not issubclass(exc_info.type, self.ex_type):
+            l_errors.append(f"ERROR: Raised exception is of type '{exc_info.type}', but expected '{self.ex_type}'")
+        exc = exc_info.value
+        # Check the exception message, if applicable
+        if self.ex_message:
+            if len(exc.args) == 0:
+                l_errors.append(f"ERROR: Expected string \"{self.ex_message}\" in exception of type '{type(exc)}''s "
+                                "message, but exception does not have any message")
+            elif not string_with_placeholders_matches(self.ex_message, str(exc.args[0])):
+                l_errors.append(f"ERROR: Expected string \"{self.ex_message}\" not found in exception message: "
+                                f"\"{exc.args[0]}\"")
+        # Check the exception status code, if applicable
+        if self.ex_status_code:
+            if not hasattr(exc, "status_code"):
+                l_errors.append(f"ERROR: Expected status code {self.ex_status_code} for exception of type {type(exc)}, "
+                                "but this exception type does not have a status code attribute")
+            elif self.ex_status_code != exc.status_code:
+                l_errors.append(f"ERROR: Expected status code {self.ex_status_code} does not match that of {exc}: "
+                                f"{exc.status_code}")
+        # Join any errors for output
+        res = "\n".join(l_errors)
+        return res
+@dataclass
+class MatchOutputFile:
+    """Callable class which checks that the output file of a conversion numerically matches an expected output file"""
+    ex_output_filename: str
+    """The name of the file which the output of the conversion should match, relative to the test_data/output directory
+    """
+    def __call__(self, test_info: ConversionTestInfo):
+        """Run the check comparing the two files"""
+        qualified_ex_output_filename = os.path.join(OUTPUT_TEST_DATA_LOC, self.ex_output_filename)
+        return check_file_match(test_info.qualified_out_filename, qualified_ex_output_filename)