Split up problem_statement/ into statement/, solution/, and problem_slide/ (#434)

* use new paths

* update latex template files

* update skel

* ran bt upgrade

* remove stem call

* implemented suggestions

* export more stuff

* Rewrite problem_statement to statement/solution/problem_slide in documentation

* [export] Move files in solution/ or problem_slide/ to problem_statement/, not statement/

* use pdfType everywhere

* dont create empty keys

* return empty list on error

* update glob patterns

---------

Co-authored-by: Maarten Sijm <[email protected]>

Author: mzuenni

bin/constraints.py

@@ -1,6 +1,7 @@
 import re
 from collections import defaultdict
 
+import latex
 import validate
 from colorama import Fore, Style
 
@@ -45,7 +46,7 @@ def f(cs):
 
 
 def check_statement(problem, language):
-    statement_file = problem.path / f"problem_statement/problem.{language}.tex"
+    statement_file = problem.path / latex.PdfType.PROBLEM.path(language)
     statement = statement_file.read_text()
 
     statement_values = set()
@@ -170,7 +171,7 @@ def parse_command():
     # 3) if a section starts parse that (and ensure that no environment is active)
     # 4) if an environment begins parse that (and ensure that no other environment is active)
     # 5) if a new define starts parse that
-    # 6) if inline math starts in an input/ouput part parse it as constraint
+    # 6) if inline math starts in an input/output part parse it as constraint
     while pos < len(statement):
         if statement[pos] == "%":
             next = statement.find("\n", pos)

bin/export.py

@@ -97,7 +97,7 @@ def build_problem_zip(problem: Problem, output: Path):
 
     files = [
         ("problem.yaml", True),
-        ("problem_statement/*", True),
+        ("statement/*", True),
         ("submissions/accepted/**/*", True),
         ("submissions/*/**/*", False),
         ("attachments/**/*", problem.interactive or problem.multi_pass),
@@ -206,7 +206,7 @@ def add_file(path, source):
     # Replace \problemname{...} by the value of `name:` in problems.yaml in all .tex files.
     # This is needed because Kattis is currently still running the legacy version of the problem spec,
     # rather than 2023-07-draft.
-    for f in (export_dir / "problem_statement").iterdir():
+    for f in (export_dir / "statement").iterdir():
         if f.is_file() and f.suffix == ".tex" and len(f.suffixes) >= 2:
             lang = f.suffixes[-2][1:]
             t = f.read_text()
@@ -226,7 +226,7 @@ def add_file(path, source):
             "data/**/testdata.yaml",
             "output_validators/**/*",
             "input_validators/**/*",
-            # "problem_statement/*", uses \constants
+            # "statement/*", uses \constants
             # "submissions/*/**/*", removed support?
         ]
         for pattern in constants_supported:
@@ -242,6 +242,23 @@ def add_file(path, source):
                     f.unlink()
                     f.write_text(text)
 
+    # TODO: Remove this if we know others import the statement folder
+    if (export_dir / "statement").exists():
+        (export_dir / "statement").rename(export_dir / "problem_statement")
+    for d in ["solution", "problem_slide"]:
+        for f in list(util.glob(problem.path, f"{d}/*")):
+            if f.is_file():
+                out = Path("problem_statement") / f.relative_to(problem.path / d)
+                if out.exists():
+                    message(
+                        f"Can not export {f.relative_to(problem.path)} as {out}",
+                        "Zip",
+                        output,
+                        color_type=MessageType.WARN,
+                    )
+                else:
+                    add_file(out, f)
+
     # Build .ZIP file.
     message("writing zip file", "Zip", output, color_type=MessageType.LOG)
     try:

bin/latex.py

@@ -6,13 +6,12 @@
 import sys
 from enum import Enum
 from pathlib import Path
-from typing import Optional
+from typing import Optional, TYPE_CHECKING
 
 from colorama import Fore, Style
 
 import config
 from contest import contest_yaml, problems_yaml
-import problem
 from util import (
     copy_and_substitute,
     ensure_symlink,
@@ -26,20 +25,27 @@
     warn,
 )
 
+if TYPE_CHECKING:  # Prevent circular import: https://stackoverflow.com/a/39757388
+    from problem import Problem
 
-class PdfType(str, Enum):
-    PROBLEM = "problem"
-    PROBLEM_SLIDE = "problem-slide"
-    SOLUTION = "solution"
 
+class PdfType(Enum):
+    PROBLEM = Path("statement") / "problem"
+    PROBLEM_SLIDE = Path("problem_slide") / "problem-slide"
+    SOLUTION = Path("solution") / "solution"
 
-def latex_builddir(problem: "problem.Problem", language: str) -> Path:
+    def path(self, lang: Optional[str] = None, ext: str = ".tex") -> Path:
+        lang = f".{lang}" if lang is not None else ""
+        return self.value.with_name(f"{self.value.name}{lang}{ext}")
+
+
+def latex_builddir(problem: "Problem", language: str) -> Path:
     builddir = problem.tmpdir / "latex" / language
     builddir.mkdir(parents=True, exist_ok=True)
     return builddir
 
 
-def create_samples_file(problem: "problem.Problem", language: str) -> None:
+def create_samples_file(problem: "Problem", language: str) -> None:
     builddir = latex_builddir(problem, language)
 
     # create the samples.tex file
@@ -164,7 +170,7 @@ def flush():
     samples_file_path.write_text("".join(samples_data))
 
 
-def create_constants_file(problem: "problem.Problem", language: str) -> None:
+def create_constants_file(problem: "Problem", language: str) -> None:
     constant_data: list[str] = []
     for key, item in problem.settings.constants.items():
         constant_data.append(f"\\expandafter\\def\\csname constants_{key}\\endcsname{{{item}}}\n")
@@ -175,12 +181,12 @@ def create_constants_file(problem: "problem.Problem", language: str) -> None:
 
 
 # Steps needed for both problem and contest compilation.
-def prepare_problem(problem: "problem.Problem", language: str):
+def prepare_problem(problem: "Problem", language: str):
     create_samples_file(problem, language)
     create_constants_file(problem, language)
 
 
-def get_tl(problem: "problem.Problem"):
+def get_tl(problem: "Problem"):
     tl = problem.limits.time_limit
     tl = int(tl) if abs(tl - int(tl)) < 0.0001 else tl
 
@@ -194,7 +200,7 @@ def get_tl(problem: "problem.Problem"):
     return tl if print_tl else ""
 
 
-def problem_data(problem: "problem.Problem", language: str):
+def problem_data(problem: "Problem", language: str):
     background = next(
         (
             p["rgb"][1:]
@@ -363,17 +369,14 @@ def run_latexmk(stdout, stderr):
 #    substituting variables.
 # 2. Create tmpdir/<problem>/latex/<language>/{samples,constants}.tex.
 # 3. Run latexmk and link the resulting <build_type>.<language>.pdf into the problem directory.
-def build_problem_pdf(
-    problem: "problem.Problem", language: str, build_type=PdfType.PROBLEM, web=False
-):
+def build_problem_pdf(problem: "Problem", language: str, build_type=PdfType.PROBLEM, web=False):
     """
     Arguments:
     -- language: str, the two-letter language code appearing the file name, such as problem.en.tex
     """
-    main_file = build_type.value
-    main_file += "-web.tex" if web else ".tex"
+    main_file = build_type.path(ext="-web.tex" if web else ".tex").name
 
-    bar = PrintBar(f"{main_file[:-3]}{language}.pdf")
+    bar = PrintBar(f"{main_file[:-4]}.{language}.pdf")
     bar.log(f"Building PDF for language {language}")
 
     prepare_problem(problem, language)
@@ -391,7 +394,7 @@ def build_problem_pdf(
     return build_latex_pdf(builddir, builddir / main_file, language, bar, problem.path)
 
 
-def build_problem_pdfs(problem: "problem.Problem", build_type=PdfType.PROBLEM, web=False):
+def build_problem_pdfs(problem: "Problem", build_type=PdfType.PROBLEM, web=False):
     """Build PDFs for various languages. If list of languages is specified,
     (either via config files or --language arguments), build those. Otherwise
     build all languages for which there is a statement latex source.
@@ -411,11 +414,11 @@ def build_problem_pdfs(problem: "problem.Problem", build_type=PdfType.PROBLEM, w
         if build_type != PdfType.PROBLEM:
             filtered_languages = []
             for lang in languages:
-                if (problem.path / "problem_statement" / f"{build_type.value}.{lang}.tex").exists():
+                if (problem.path / build_type.path(lang)).exists():
                     filtered_languages.append(lang)
                 else:
                     message(
-                        f"{build_type.value}.{lang}.tex not found",
+                        f"{build_type.path(lang)} not found",
                         problem.name,
                         color_type=MessageType.WARN,
                     )
@@ -436,7 +439,7 @@ def find_logo() -> Path:
 
 def build_contest_pdf(
     contest: str,
-    problems: list["problem.Problem"],
+    problems: list["Problem"],
     tmpdir: Path,
     language: str,
     build_type=PdfType.PROBLEM,
@@ -491,31 +494,31 @@ def build_contest_pdf(
         elif headertex.exists():
             problems_data += f"\\input{{{headertex}}}\n"
 
-    local_per_problem_data = Path(f"contest-{build_type.value}.tex")
+    local_per_problem_data = Path(f"contest-{build_type.path().name}")
     per_problem_data_tex = (
         local_per_problem_data
         if local_per_problem_data.is_file()
-        else config.TOOLS_ROOT / "latex" / f"contest-{build_type.value}.tex"
+        else config.TOOLS_ROOT / "latex" / local_per_problem_data.name
     ).read_text()
 
     for prob in problems:
         if build_type == PdfType.PROBLEM:
             prepare_problem(prob, language)
         else:  # i.e. for SOLUTION and PROBLEM_SLIDE
             create_constants_file(prob, language)
-            tex_no_lang = prob.path / "problem_statement" / f"{build_type.value}.tex"
-            tex_with_lang = prob.path / "problem_statement" / f"{build_type.value}.{language}.tex"
+            tex_no_lang = prob.path / build_type.path()
+            tex_with_lang = prob.path / build_type.path(language)
             if tex_with_lang.is_file():
                 # All is good
                 pass
             elif tex_no_lang.is_file():
                 bar.warn(
-                    f"Rename {build_type.value}.tex to {build_type.value}.{language}.tex",
+                    f"Rename {tex_no_lang.name} to {tex_with_lang.name}",
                     prob.name,
                 )
                 continue
             else:
-                bar.warn(f"{build_type.value}.{language}.tex not found", prob.name)
+                bar.warn(f"{tex_with_lang.name} not found", prob.name)
                 continue
 
         problems_data += substitute(
@@ -533,7 +536,7 @@ def build_contest_pdf(
         elif footertex.exists():
             problems_data += f"\\input{{{footertex}}}\n"
 
-    (builddir / f"contest-{build_type.value}s.tex").write_text(problems_data)
+    (builddir / f"contest-{build_type.path(ext='s.tex').name}").write_text(problems_data)
 
     return build_latex_pdf(builddir, Path(main_file), language, bar)
 

bin/problem.py

@@ -334,30 +334,31 @@ def _determine_statement_languages(self):
         """
         yamllangs = set(self.settings.name)
         texlangs = set(
-            path.suffixes[0][1:] for path in glob(self.path, "problem_statement/problem.*.tex")
+            path.suffixes[0][1:] for path in glob(self.path, str(latex.PdfType.PROBLEM.path("*")))
         )
         for lang in texlangs - yamllangs:
             error(
-                f"{self.name}: Found problem.{lang}.tex, but no corresponding name in problem.yaml."
+                f"{self.name}: Found {latex.PdfType.PROBLEM.path(lang).name}, but no corresponding name in problem.yaml."
             )
         for lang in yamllangs - texlangs:
             error(
-                f"{self.name}: Found name for language {lang} in problem.yaml, but not problem_statement/problem.{lang}.tex."
+                f"{self.name}: Found name for language {lang} in problem.yaml, but not {latex.PdfType.PROBLEM.path(lang)}."
             )
         # Check that names in problem.yaml and \problemname{} in problem.*.tex agree:
         for lang in texlangs & yamllangs:
             unnormalised_yamlname = self.settings.name[lang]
             yamlname = " ".join(unnormalised_yamlname.split())
-            with open(self.path / "problem_statement" / f"problem.{lang}.tex") as texfile:
+            texpath = self.path / latex.PdfType.PROBLEM.path(lang)
+            with open(texpath) as texfile:
                 match texname := latex.get_argument_for_command(texfile, "problemname"):
                     case None:
-                        error(rf"No \problemname found in problem.{lang}.tex")
+                        error(rf"No \problemname found in {texpath.name}")
                         continue
                     case "":
                         continue
                     case r"\problemyamlname":
                         warn(
-                            rf"Prefer using \problemname{{}} instead of \problemname{{\problemyamlname}} in problem.{lang}.tex"
+                            rf"Prefer using \problemname{{}} instead of \problemname{{\problemyamlname}} in {texpath.name}"
                         )
                         continue
                     case s if "\\" in s or "_" in s or "^" in s:
@@ -366,7 +367,7 @@ def _determine_statement_languages(self):
                         continue
                     case s if s != yamlname:
                         warn(
-                            f"Problem titles in problem.{lang}.tex ({texname})"
+                            f"Problem titles in {texpath.name} ({texname})"
                             + f" and problem.yaml ({yamlname}) differ;"
                             + r" consider using \problemname{}."
                         )
@@ -514,12 +515,14 @@ def get_testdata_yaml(
             if key in flags:
                 if key == "output_validator_args":
                     if not isinstance(flags[key], str):
-                        bar.error("ouput_validator_args must be string")
+                        bar.error("output_validator_args must be string")
+                        return []
                     return flags[key].split()
 
                 if key == "input_validator_args":
                     if not isinstance(flags[key], (str, dict)):
                         bar.error("input_validator_args must be string or map")
+                        return []
                     if isinstance(flags[key], str):
                         return flags[key].split()
                     elif name in flags[key]:

bin/skel.py

@@ -4,6 +4,7 @@
 
 # Local imports
 import config
+import latex
 from export import force_single_language
 from problem import Problem
 from util import *
@@ -254,10 +255,11 @@ def new_problem():
 
     # Warn about missing problem statement skeletons for non-en languages
     for lang in statement_languages:
-        filename = f"problem.{lang}.tex"
-        statement_path = target_dir / dirname / "problem_statement" / filename
+        statement_path = target_dir / dirname / latex.PdfType.PROBLEM.path(lang)
         if not statement_path.is_file():
-            warn(f"No skeleton for {filename} found. Create it manually or update skel/problem.")
+            warn(
+                f"No skeleton for {statement_path.name} found. Create it manually or update skel/problem."
+            )
 
 
 def rename_problem(problem):
@@ -344,8 +346,9 @@ def problem_source_dir(problem: Problem):
     contest_yml = (config.TOOLS_ROOT / "skel/gitlab_ci/contest.yaml").read_text()
     contest_path = Path(".").resolve().relative_to(git_root_path)
     changes = "".join(
-        "      - " + str(problem_source_dir(problem)) + "/problem_statement/**/*\n"
+        f"      - {problem_source_dir(problem)}/{pdf_type.path().parent}/**/*\n"
         for problem in problems
+        for pdf_type in latex.PdfType
     )
     print(
         substitute(

bin/stats.py

@@ -11,6 +11,7 @@
 
 import config
 import generate
+import latex
 import program
 from util import error, exec_command, glob, warn
 
@@ -48,8 +49,8 @@ def problem_stats(problems):
         # Roughly in order of importance
         ("  time", lambda p: p.limits.time_limit, 0),
         ("yaml", "problem.yaml"),
-        ("tex", "problem_statement/problem*.tex", 1),
-        ("sol", "problem_statement/solution*.tex", 1),
+        ("tex", str(latex.PdfType.PROBLEM.path("*")), 1),
+        ("sol", str(latex.PdfType.SOLUTION.path("*")), 1),
         ("  val: I", ["input_validators/*", "input_format_validators/*"]),
         ("A", ["answer_validators/*"]),
         ("O", ["output_validators/*"]),

bin/tools.py

@@ -1216,10 +1216,8 @@ def run_parsed_arguments(args):
                         web=True,
                     )
                 # Only build the problem slides if at least one problem has the TeX for it
-                if any(
-                    glob(problem.path / "problem_statement", "problem-slide.*.tex")
-                    for problem in problems
-                ):
+                slideglob = latex.PdfType.PROBLEM_SLIDE.path("*")
+                if any(problem.path.glob(str(slideglob)) for problem in problems):
                     success &= latex.build_contest_pdf(
                         contest,
                         problems,
@@ -1228,7 +1226,7 @@ def run_parsed_arguments(args):
                         build_type=latex.PdfType.PROBLEM_SLIDE,
                     )
                 else:
-                    log("No problem has problem-slide.*.tex, skipping problem slides")
+                    log(f"No problem has {slideglob.name}, skipping problem slides")
 
             outfile = contest + ".zip"
             if config.args.kattis: