problemtools 1.20231016__tar.gz

problemtools-1.20231016/LICENSE

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

problemtools-1.20231016/MANIFEST.in

@@ -0,0 +1,4 @@
+recursive-include problemtools/config *
+recursive-include problemtools/templates *
+recursive-include problemtools/tests *
+recursive-include support *

problemtools-1.20231016/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: problemtools
+Version: 1.20231016
+Summary: Kattis Problem Tools
+Home-page: https://github.com/Kattis/problemtools
+Maintainer: Kattis AB
+Maintainer-email: contact@kattis.com
+License: MIT
+License-File: LICENSE
+Requires-Dist: PyYAML
+Requires-Dist: plasTeX>=3.0; python_version >= "3"
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: maintainer
+Dynamic: maintainer-email
+Dynamic: requires-dist
+Dynamic: summary

problemtools-1.20231016/README.md

@@ -0,0 +1,227 @@
+# Kattis Problem Tools
+
+master:
+[![Master Build Status](https://travis-ci.org/Kattis/problemtools.svg?branch=master)](https://travis-ci.org/Kattis/problemtools).
+develop:
+[![Develop Build Status](https://travis-ci.org/Kattis/problemtools.svg?branch=develop)](https://travis-ci.org/Kattis/problemtools)
+
+These are tools to manage problem packages using the Kattis problem package
+format.
+
+
+## Programs Provided
+
+The problem tools provide the following three programs:
+
+ - `verifyproblem`: run a complete check on a problem
+ - `problem2pdf`: convert a problem statement to pdf
+ - `problem2html`: convert a problem statement to html
+
+Running any of them with command-line option `-h` gives
+documentation on what arguments they accept.
+
+
+## Example Problems
+
+A few examples of problem packages can be found in [examples](examples).
+
+
+## Installing problemtools
+
+There are four supported ways of installing and running problemtools.
+(For non-Linux users, "Method 2" below, to use Docker, is probably the least painful.)
+
+### Method 1: Install the Python package
+
+Run
+```
+pip3 install git+https://github.com/kattis/problemtools
+```
+
+Or if you don't want a system-wide installation,
+```
+pip3 install --user git+https://github.com/kattis/problemtools
+```
+With this second option, in order to get the command line scripts, you need
+to make sure that the local user bin path used (e.g., on Linux,
+`$HOME/.local/bin`) is in your `$PATH`.
+
+In order for problemtools to build and run properly, you also need to have LaTeX
+and various LaTeX packages installed.  See [Requirements and
+compatbility](#requirements-and-compatibility) below for details on
+which packages are needed.
+
+
+### Method 2: Use Docker
+
+This method allows you to run the Kattis problemtools inside a Docker container. This method is supported on any system for which Docker exists, including **macOS** and **Windows 10**.
+
+We maintain three official problemtools Docker images on Docker Hub:
+
+- [`problemtools/full`](https://hub.docker.com/r/problemtools/full/): this image contains problemtools along with compilers/interpreters for all supported programming languages.
+
+- [`problemtools/icpc`](https://hub.docker.com/r/problemtools/icpc/): this image contains problemtools along with compilers/interpreters for the programming languages allowed in the International Collegiate Programming Contest (ICPC): C, C++, Java, Python 2+3, and Kotlin.
+
+- [`problemtools/minimal`](https://hub.docker.com/r/problemtools/minimal/): this image only contains problemtools, no additional programming languages.  As such as it is not particularly useful on its own, but if you are organizing a contest and want to set up a problemtools environment containing exactly the right set of compilers/interpreters for your contest, this is the recommended starting point.
+
+For example, suppose you want to use the `problemtools/icpc` image.  To get started, install the [Docker CLI](https://docs.docker.com/install), and then pull the image:
+
+    docker pull problemtools/icpc
+
+Once the image has finished downloading, you can check that it exists on your system using `docker images`. To launch an interactive container and play around with *verifyproblem*, *problem2pdf*, and *problem2html* run:
+
+    docker run --rm -it problemtools/icpc
+
+By default, docker containers do _NOT_ persist storage between runs, so any files you create or modify will be lost when the container stops running.  Two common ways of dealing with this are:
+
+1) Use a [bind mount](https://docs.docker.com/storage/bind-mounts/) to mount a directory on your machine into the docker container.  This can be done as follows (see Docker documentation for further details):
+    ```
+    docker run --rm -it -v ${FULL_PATH_TO_MOUNT}:/kattis_work_dir problemtools/icpc
+    ```
+2) Persist any changes you want to keep to a remote file system/source control (e.g. a remote Git repository, note however that you would first need to install Git in the image).
+
+#### Building your own images
+
+If you want a more complete environment in the Docker images (e.g. if
+you want to install git or your favorite editor), feel free to extend
+them in whichever way you like.
+
+The `problemtools/{minimal,icpc,full}` images point to the latest
+release versions of problemtools.  If for some reason you want an
+image containing the latest development version, you have to build it
+yourself from scratch (while there are
+`problemtools/{minimal,icpc,full}:develop` Docker images on Docker
+Hub, these are only updated sporadically for testing purposes and not
+kept up to date).
+
+
+### Method 3: Run directly from the repository.
+
+If you intend to help develop problemtools, or if you just want a
+bare-bones way of running them, this is your option.
+
+For this method, you need to clone the repository (just downloading a
+zip archive of it does not work, because the project has submodules
+that are not included in that zip archive).
+
+In order for the tools to work, you first have to compile the various
+support programs, which can be done by running `make` in the root
+directory of problemtools.
+
+When this is done, you can run the three programs
+`bin/verifyproblem.sh`, `bin/problem2pdf.sh`, and
+`bin/problem2html.sh` directly from the repository.
+
+See [Requirements and compatibility](#requirements-and-compatibility)
+below for what other software needs to be installed on your machine in
+order for problemtools to work correctly.
+
+
+### Method 4: Build and install the Debian package
+
+This applies if you are running on Debian or a Debian derivative such
+as Ubuntu.
+
+As with method 3, you need to clone the repository (just downloading a
+zip archive of it does not work, because the project has submodules
+that are not included in that zip archive).
+
+Run `make builddeb` in the root of the problemtools repository to
+build the package.  It will be found as kattis-problemtools_X.Y.deb in
+the directory containing problemtools (i.e., one level up from the
+root of the repository).
+
+Apart from the build dependencies listed [below](#ubuntu), building
+the Debian package requires that the following tools are installed:
+
+    debhelper dh-python dpkg-dev
+
+The package can then be installed using (replace `<version>` as appropriate):
+
+    sudo gdebi kattis-problemtools_<version>.deb
+
+This installs the three provided programs in your path and they should
+now be ready to use.
+
+
+## Configuration
+
+System-wide problemtools configuration files are placed in
+`/etc/kattis/problemtools/`, and user-specific configuration files are placed
+in `$HOME/.config/problemtools/` (or in `$XDG_CONFIG_HOME` if this is defined).  The following files can be used to change
+problemtools' configuration:
+
+1. `languages.yaml`.  Use it to override problemtools' default
+   programming language configuration.  For instance, while the
+   problemtools default is to use the CPython `/usr/bin/python3`
+   interpreter for Python 3, many contests, as well as the Kattis
+   online judge, use Pypy as the interpreter for Python 3.  To change
+   this on your machine, you can simply place a file
+   `/etc/kattis/problemtools/languages.yaml` (or
+   `~/.config/problemtools/languages.yaml` if you only want to make the
+   change for your user) containing the following:
+
+   ```yaml
+   python3:
+      name: 'Python 3 w/Pypy'
+      run: '/usr/bin/pypy3 "{mainfile}"'
+   ```
+   Here, overriding the name of the language is not strictly
+   necessary, but it is often helpful to clearly indicate that Pypy is
+   being used.
+
+   For more details on the format of the language specifications and
+   what the default settings are, see the [default version of
+   languages.yaml](problemtools/config/languages.yaml)
+
+2. `problem.yaml`.  For most users, this should not be edited.  If you
+   are not sure whether you should use it, then you probably shouldn't.
+   This file can be used to specify the system defaults for those
+   problem limits which are not given a fixed default value in the
+   [problem format specification](http://www.problemarchive.org/wiki/index.php/Problem_Format#limits).
+   The system defaults assumed by problemtools can be found in
+   (problemtools/config/problem.yaml).  For instance, if you are
+   primarily working against a system with a default memory limit of 2 GiB,
+   you can place a file `~/.config/problemtools/problem.yaml` containing:
+
+   ```yaml
+   limits:
+       memory: 2048 # (unit is MiB)
+   ```
+
+   (In principle it is possible to override the defaults of other values than the
+   system-dependent defaults in the problem.yaml metadata files this way, but such
+   usage is very strongly discouraged.)
+
+
+## Requirements and compatibility
+
+To build and run the tools, you need Python 3 with the YAML and PlasTeX libraries,
+and a LaTeX installation.
+
+### Ubuntu
+
+The dependencies needed to *build/install* problemtools can be installed with:
+
+    sudo apt install automake g++ make libboost-regex-dev libgmp-dev libgmp10 libgmpxx4ldbl python3 python3-pytest python3-setuptools python3-yaml python3-plastex
+
+And the dependencies needed to *run* problemtools can be installed with:
+
+    sudo apt install ghostscript libgmpxx4ldbl python3-minimal python-pkg-resources python3-plastex python3-yaml texlive-fonts-recommended texlive-lang-cyrillic texlive-latex-extra texlive-plain-generic tidy
+
+### Fedora
+
+On Fedora, these dependencies can be installed with:
+
+    sudo dnf install boost-regex gcc gmp-devel gmp-c++ python3 python3-pyyaml texlive-latex texlive-collection-fontsrecommended texlive-fancyhdr texlive-subfigure texlive-wrapfig texlive-import texlive-ulem texlive-xifthen texlive-overpic texlive-pbox tidy ghostscript
+
+Followed by:
+
+    pip3 install --user plastex
+
+### Other platforms
+
+The problem tools have not been tested on other platforms.  If you do
+test on another platform, we would be happy to hear what worked and what
+did not work, so that we can write proper instructions (and try to
+figure out how to make the non-working stuff work).

problemtools-1.20231016/problemtools/ProblemPlasTeX/ProblemsetMacros.py

@@ -0,0 +1,179 @@
+import sys
+import os
+import os.path
+import io
+from plasTeX.DOM import Node
+from plasTeX.Base import Command
+from plasTeX.Base import DimenCommand
+from plasTeX.Logging import getLogger
+import plasTeX.Packages.graphics as graphics
+
+log = getLogger()
+status = getLogger('status')
+
+# Ugly hack: assume textwidth is 600pt.  True for Kattis but not in
+# general.
+class textwidth(DimenCommand):
+    value = DimenCommand.new('600pt')
+
+
+# Convert an expression of the form "X\textwidth" to 100*x%
+# (Used in ugly hack to handle illustrations)
+def clean_width(width):
+    if not isinstance(width, Node):
+        return width
+    nodes = width.childNodes
+    if len(nodes) != 2 or nodes[1].nodeName != 'textwidth':
+        return width
+    return '%.2f%%' % (100*float(nodes[0]))
+
+
+# \problemheader
+class problemheader(Command):
+    args = 'title id:str'
+
+    def invoke(self, tex):
+        res = Command.invoke(self, tex)
+        timelimfile = os.path.join(os.path.dirname(tex.filename),
+                                   '..', '.timelimit')
+        if os.path.isfile(timelimfile):
+            self.attributes['timelim'] = open(timelimfile, 'r').read()
+
+
+# \sampletable
+class sampletable(Command):
+    args = 'header1 file1:str header2 file2:str'
+
+    def read_sample_file(self, filename):
+        return io.open(filename, 'r', encoding='utf-8').read()
+
+    def invoke(self, tex):
+        res = Command.invoke(self, tex)
+        dir = os.path.dirname(tex.filename)
+        file1 = os.path.join(dir, self.attributes['file1'])
+        file2 = os.path.join(dir, self.attributes['file2'])
+        try:
+            status.info(' ( verbatim %s ' % file1)
+            self.attributes['data1'] = self.read_sample_file(file1)
+            status.info(') ( verbatim %s ' % file2)
+            self.attributes['data2'] = self.read_sample_file(file2)
+            status.info(') ')
+        except (OSError, IOError):
+            log.warning('\nProblem opening files "%s" and "%s"', file1, file2)
+
+
+# \sampletableinteractive
+class sampletableinteractive(Command):
+    args = 'header read write file:str'
+
+    def read_sample_interaction(self, filename):
+        data = io.open(filename, 'r', encoding='utf-8').read()
+        messages = []
+        cur_msg = []
+        cur_mode = None
+        for line in data.split('\n'):
+            if not line: continue
+            if line[0] == '<': mode = 'read'
+            elif line[0] == '>': mode = 'write'
+            else: continue
+            line = line[1:]
+            if mode != cur_mode:
+                if cur_mode: messages.append({'mode': cur_mode,
+                                              'data': '\n'.join(cur_msg)})
+                cur_msg = []
+            cur_msg.append(line)
+            cur_mode = mode
+        if cur_mode: messages.append({'mode': cur_mode,
+                                      'data': '\n'.join(cur_msg)})
+        return messages
+
+    def invoke(self, tex):
+        res = Command.invoke(self, tex)
+        dir = os.path.dirname(tex.filename)
+        file = os.path.join(dir, self.attributes['file'])
+        try:
+            status.info(' ( sampletableinteractive %s ' % file)
+            self.attributes['messages'] = self.read_sample_interaction(file)
+            status.info(') ')
+        except (OSError, IOError):
+            log.warning('\nProblem opening file "%s"', file)
+
+
+# Any command including a picture, such as \illustration and our
+# re-implementation of \includegraphics.  (Based on plasTeX's
+# \includegraphics implementation)
+class _graphics_command(Command):
+    def invoke(self, tex):
+        res = Command.invoke(self, tex)
+
+        # Overcome plasTeX bug by looking for love in the right place
+        basetex = self.ownerDocument.userdata['base_tex_instance']
+        f = self.attributes['file']
+        ext = self.ownerDocument.userdata.getPath(
+                      'packages/graphicx/extensions',
+                      ['.png', '.jpg', '.jpeg', '.gif', '.pdf'])
+        paths = self.ownerDocument.userdata.getPath(
+                        'packages/graphicx/paths', [os.path.dirname(basetex.filename)])
+        img = None
+        # Check for file using graphicspath
+        for p in paths:
+            for e in ['']+ext:
+                fname = os.path.join(p, f+e)
+                if os.path.isfile(fname):
+                    img = os.path.abspath(fname)
+                    break
+            if img is not None:
+                break
+
+        # Check for file using kpsewhich
+        if img is None:
+            for e in ['']+ext:
+                try:
+                    img = os.path.abspath(basetex.kpsewhich(f+e))
+                    break
+                except (OSError, IOError):
+                    pass
+
+        if not os.path.isfile(img):
+            log.warning('Could not identify image "%s"' % f)
+
+        self.imageoverride = img
+        return res
+
+
+# \illustration
+class illustration(_graphics_command):
+    args = 'width:double file:str description'
+
+    def invoke(self, tex):
+        res = _graphics_command.invoke(self, tex)
+        self.style['width'] = '%.2f%%' % (100*self.attributes['width'])
+        return res
+
+# Dummy for \fontencoding to suppress warnings
+class fontencoding(Command):
+    args = 'charset:str'
+
+# Dummy for \selectfont to suppress warnings.
+class selectfont(Command):
+    pass
+
+# Dummy for \ExecuteOptions to suppress warnings.
+class ExecuteOptions(Command):
+    pass
+
+
+def init(tex):
+    # Dirty hack #25783 to get plasTeX to work properly:
+    # any subprocess of the tex instance won't remember things like,
+    # say, the name of the .tex file being processed, which is needed
+    # for kpsewhich to work.  So we'll keep a pointer to the original
+    # tex instance in the document's userdata.
+    tex.ownerDocument.userdata['base_tex_instance'] = tex
+
+    # Import the macros
+    tex.ownerDocument.context.importMacros(vars(sys.modules[__name__]))
+
+    # So apparently this is how to communicate to Plastex where to
+    # search for modules... Eugch.
+    sys.path = [os.path.dirname(__file__)] + sys.path

problemtools-1.20231016/problemtools/ProblemPlasTeX/__init__.py

@@ -0,0 +1,125 @@
+import re
+import os
+import shutil
+import subprocess
+import plasTeX.Renderers
+from plasTeX.Renderers.PageTemplate import Renderer
+from plasTeX.Filenames import Filenames
+from plasTeX.Imagers import Image
+from plasTeX.Logging import getLogger
+
+log = getLogger()
+
+# Adapted from plasTeX.Imagers.Imager class
+class ImageConverter(object):
+    fileExtension = '.png'
+    imageAttrs = ''
+    imageUnits = ''
+
+    imageTypes = ['.png', '.jpg', '.jpeg', '.gif'] #, '.svg']
+    imageConversion = {'.pdf': ['.png',
+                                ['gs', '-dUseCropBox', '-sDEVICE=pngalpha', '-r300', '-o']]}
+
+    def __init__(self, document):
+        self.config = document.config
+        self.ownerDocument = document
+
+        # Cache of already seen images
+        self.staticimages = {}
+
+        # Filename generator
+        self.newFilename = Filenames(self.config['images'].get('filenames'),
+                                     None,
+                                     variables={'jobname': document.userdata.get('jobname', '')},
+                                     extension=self.fileExtension, invalid={})
+
+    def close(self):
+        return
+
+    def getImage(self, node):
+        name = getattr(node, 'imageoverride', None)
+        if name is None:
+            log.error('Image handler called for non-image node "%s"' % node.source)
+            return None
+
+        if name in self.staticimages:
+            return self.staticimages[name]
+
+        oldext = os.path.splitext(name)[1]
+        path = self.newFilename()
+
+        try:
+            directory = os.path.dirname(path)
+            if directory and not os.path.isdir(directory):
+                os.makedirs(directory)
+            if oldext in self.imageConversion:
+                # Need to convert image
+                newext = self.imageConversion[oldext][0]
+                path = os.path.splitext(path)[0]+newext
+                cmd = self.imageConversion[oldext][1] + [path, name]
+                status = subprocess.call(cmd)
+                if status:
+                    log.warning('Failed to convert %s image "%s to %s', oldext, name, newext)
+            else:
+                # Just copy it
+                path = os.path.splitext(path)[0]+oldext
+                shutil.copyfile(name, path)
+            img = Image(path, self.ownerDocument.config['images'])
+            self.staticimages[name] = img
+            return img
+
+        except Exception as msg:
+            log.warning('%s in image "%s".' % (msg, name))
+            pass
+        return None
+
+
+
+
+class ProblemRenderer(Renderer):
+    """ Renderer for ProblemHTML documents """
+
+    fileExtension = '.html'
+    imageTypes = ['.png', '.jpg', '.jpeg', '.gif']
+    vectorImageTypes = ['.svg']
+
+    def render(self, document):
+        templatepaths = [os.path.join(os.path.dirname(__file__), '../templates/html'),
+                         os.path.join(os.path.dirname(__file__), '../../templates/html'),
+                         '/usr/lib/problemtools/templates/html']
+        templatepath = None
+        for p in templatepaths:
+            if os.path.isdir(p):
+                templatepath = p
+                break
+        if templatepath == None:
+            raise Exception('Could not find templates needed for conversion to HTML')
+
+        # Ugly but unfortunately PlasTeX is quite inflexible when it comes to
+        # configuring where to search for template files
+        os.environ['ProblemRendererTEMPLATES'] = templatepath
+
+        # Gigantic ugliness to cope with PlasTeX problem that prevents
+        # plastex from resetting list of invalid filenames when doing multiple renderings.
+        f = Filenames('blah.html', {}, {}, 'html')
+        f.invalid.clear()
+
+        # Setup our own mini-imager which just does copying and converts pdfs to png
+        self.imager = ImageConverter(document)
+
+        Renderer.render(self, document)
+
+    def processFileContent(self, document, s):
+        s = Renderer.processFileContent(self, document, s)
+
+        # Force XHTML syntax on empty tags
+        s = re.compile(r'(<(?:hr|br|img|link|meta)\b.*?)\s*/?\s*(>)',
+                       re.I|re.S).sub(r'\1 /\2', s)
+
+        # Remove empty paragraphs
+        s = re.compile(r'<p>\s*</p>', re.I).sub(r'', s)
+
+        # Add a non-breaking space to empty table cells
+        s = re.compile(r'(<(td|th)\b[^>]*>)\s*(</\2>)', re.I).sub(r'\1&nbsp;\3', s)
+
+        return s

problemtools-1.20231016/problemtools/ProblemPlasTeX/graphicx.py

@@ -0,0 +1,28 @@
+import plasTeX.Packages.graphics as graphics
+from ProblemsetMacros import _graphics_command, clean_width
+
+# Reimplementation of graphicx package because plasTeX is broken and
+# annoying.
+
+class includegraphics(_graphics_command):
+    args = '* [ options:dict ] file:str'
+    packageName = 'graphicx'
+    captionable = True
+
+    def invoke(self, tex):
+        res = _graphics_command.invoke(self, tex)
+        options = self.attributes['options']
+        if options is not None:
+            height = options.get('height')
+            if height is not None:
+                self.style['height'] = height
+            width = options.get('width')
+            if width is not None:
+                self.style['width'] = clean_width(width)
+        return res
+
+class DeclareGraphicsExtensions(graphics.DeclareGraphicsExtensions):
+    packageName = 'graphicx'
+
+class graphicspath(graphics.graphicspath):
+    packageName = 'graphicx'

problemtools-1.20231016/problemtools/ProblemPlasTeX/import.py

@@ -0,0 +1,27 @@
+import codecs
+import os
+from plasTeX.Base import Command
+from plasTeX.Logging import getLogger
+
+log = getLogger()
+status = getLogger('status')
+
+# (Partial) implementation of import.sty because plasTeX does not ship
+# with an implementation.  Only implement \import command which is the
+# only one we'll use.
+class import_sty(Command):
+    macroName = 'import'
+    args = 'dir:str file:str'
+
+    def invoke(self, tex):
+        a = self.parse(tex)
+        path = os.path.join(a['dir'], a['file'])
+        fullpath = tex.kpsewhich(path)
+        status.info(' ( %s ' % fullpath)
+        try:
+            encoding = self.config['files']['input-encoding']
+            tex.input(codecs.open(fullpath, 'r', encoding, 'replace'))
+        except (OSError, IOError):
+            log.warning('\nProblem opening file "%s"', fullpath)
+        status.info(' ) ')
+        return []

problemtools-1.20231016/problemtools/ProblemPlasTeX/listingsutf8.py

@@ -0,0 +1,37 @@
+from plasTeX.Base import Command
+from plasTeX.Logging import getLogger
+
+import os
+import io
+
+import ProblemsetMacros
+
+log = getLogger()
+
+# Implementation of (parts) of listingsutf8 package since PlasTeX does
+# not have one
+
+class lstinputlisting(Command):
+    args = '* [ options:dict ] file:str'
+
+    def read_file(self, filename):
+        data = io.open(filename, 'r', encoding='utf-8').read()
+        data = ProblemsetMacros.plastex_escape(data)
+        return data
+
+    def invoke(self, tex):
+        res = Command.invoke(self, tex)
+        basetex = self.ownerDocument.userdata['base_tex_instance']
+        f = self.attributes['file']
+        # Maybe more paths to look in?
+        paths = [os.path.dirname(basetex.filename)]
+        # Locate file
+        for p in paths:
+            fname = os.path.join(p, f)
+            if os.path.isfile(fname):
+                self.attributes['data'] = self.read_file(fname)
+                break
+        if 'data' not in self.attributes:
+            log.warning('Problem opening file "%s"', f)
+
+        # TODO: handle language param in options

problemtools-1.20231016/problemtools/ProblemPlasTeX/ulem.py

@@ -0,0 +1,11 @@
+from plasTeX.Base.LaTeX.FontSelection import TextCommand
+
+class uline(TextCommand): pass
+class uuline(TextCommand): pass
+class uwave(TextCommand): pass
+class sout(TextCommand): pass
+class xout(TextCommand): pass
+class dashuline(TextCommand): pass
+class dotuline(TextCommand): pass
+
+