inspect-ai 0.3.102__py3-none-any.whl → 0.3.104__py3-none-any.whl

inspect_ai/_view/www/node_modules/katex/src/fonts/generate_fonts.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+
+import sys
+import os
+import json
+
+from fontTools.ttLib import TTFont, sfnt
+from fontTools.misc.timeTools import timestampNow
+sfnt.USE_ZOPFLI = True
+
+if len(sys.argv) < 2:
+    print("Usage: %s <font file>" % sys.argv[0])
+    sys.exit(1)
+
+font_file = sys.argv[1]
+font_name = os.path.splitext(os.path.basename(font_file))[0]
+
+
+font = TTFont(font_file, recalcBBoxes=False, recalcTimestamp=False)
+
+# fix timestamp to the epoch
+font['head'].created = 0
+font['head'].modified = 0
+
+# remove fontforge timestamps
+if 'FFTM' in font:
+    del font['FFTM']
+
+# remove redundant GDEF table
+if 'GDEF' in font:
+    del font['GDEF']
+
+# remove Macintosh table
+# https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6cmap.html
+font['name'].names = [record for record in font['name'].names if record.platformID != 1]
+font['cmap'].tables = [table for table in font['cmap'].tables if table.platformID != 1]
+
+# fix OS/2 and hhea metrics
+glyf = font['glyf']
+ascent = int(max(glyf[c].yMax for c in font.getGlyphOrder() if hasattr(glyf[c], "yMax")))
+descent = -int(min(glyf[c].yMin for c in font.getGlyphOrder() if hasattr(glyf[c], "yMin")))
+
+font['OS/2'].usWinAscent = ascent
+font['OS/2'].usWinDescent = descent
+
+font['hhea'].ascent = ascent
+font['hhea'].descent = -descent
+
+# save TTF
+font.save(font_file, reorderTables=None)
+
+# save WOFF
+font.flavor = 'woff'
+font.save(os.path.join('woff', font_name + '.woff'), reorderTables=None)
+
+# save WOFF2
+font.flavor = 'woff2'
+font.save(os.path.join('woff2', font_name + '.woff2'), reorderTables=None)

inspect_ai/_view/www/node_modules/katex/src/metrics/extract_tfms.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+
+import collections
+import json
+import parse_tfm
+import subprocess
+import sys
+
+
+def find_font_path(font_name):
+    try:
+        font_path = subprocess.check_output(['kpsewhich', font_name])
+    except OSError:
+        raise RuntimeError("Couldn't find kpsewhich program, make sure you" +
+                           " have TeX installed")
+    except subprocess.CalledProcessError:
+        raise RuntimeError("Couldn't find font metrics: '%s'" % font_name)
+    return font_path.strip()
+
+
+def main():
+    mapping = json.load(sys.stdin)
+
+    fonts = [
+        'cmbsy10.tfm',
+        'cmbx10.tfm',
+        'cmbxti10.tfm',
+        'cmex10.tfm',
+        'cmmi10.tfm',
+        'cmmib10.tfm',
+        'cmr10.tfm',
+        'cmsy10.tfm',
+        'cmti10.tfm',
+        'msam10.tfm',
+        'msbm10.tfm',
+        'eufm10.tfm',
+        'cmtt10.tfm',
+        'rsfs10.tfm',
+        'cmss10.tfm',
+        'cmssbx10.tfm',
+        'cmssi10.tfm',
+    ]
+
+    # Extracted by running `\font\a=<font>` and then `\showthe\skewchar\a` in
+    # TeX, where `<font>` is the name of the font listed here. The skewchar
+    # will be printed out in the output. If it outputs `-1`, that means there
+    # is no skewchar, so we use `None` here.
+    font_skewchar = {
+        'cmbsy10': None,
+        'cmbx10': None,
+        'cmbxti10': None,
+        'cmex10': None,
+        'cmmi10': 127,
+        'cmmib10': None,
+        'cmr10': None,
+        'cmsy10': 48,
+        'cmti10': None,
+        'msam10': None,
+        'msbm10': None,
+        'eufm10': None,
+        'cmtt10': None,
+        'rsfs10': None,
+        'cmss10': None,
+        'cmssbx10': None,
+        'cmssi10': None,
+    }
+
+    font_name_to_tfm = {}
+
+    for font_name in fonts:
+        font_basename = font_name.split('.')[0]
+        font_path = find_font_path(font_name)
+        font_name_to_tfm[font_basename] = parse_tfm.read_tfm_file(font_path)
+
+    families = collections.defaultdict(dict)
+
+    for family, chars in mapping.items():
+        for char, char_data in chars.items():
+            char_num = int(char)
+
+            font = char_data['font']
+            tex_char_num = int(char_data['char'])
+            yshift = float(char_data['yshift'])
+
+            if family == "Script-Regular":
+                tfm_char = font_name_to_tfm[font].get_char_metrics(tex_char_num,
+                                                                   fix_rsfs=True)
+            else:
+                tfm_char = font_name_to_tfm[font].get_char_metrics(tex_char_num)
+
+            height = round(tfm_char.height + yshift / 1000.0, 5)
+            depth = round(tfm_char.depth - yshift / 1000.0, 5)
+            italic = round(tfm_char.italic_correction, 5)
+            width = round(tfm_char.width, 5)
+
+            skewkern = 0.0
+            if (font_skewchar[font] and
+                    font_skewchar[font] in tfm_char.kern_table):
+                skewkern = round(
+                    tfm_char.kern_table[font_skewchar[font]], 5)
+
+            families[family][char_num] = {
+                'height': height,
+                'depth': depth,
+                'italic': italic,
+                'skew': skewkern,
+                'width': width
+            }
+
+    sys.stdout.write(
+        json.dumps(families, separators=(',', ':'), sort_keys=True))
+
+if __name__ == '__main__':
+    main()

inspect_ai/_view/www/node_modules/katex/src/metrics/extract_ttfs.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+
+from fontTools.ttLib import TTFont
+import sys
+import json
+
+# map of characters to extract
+metrics_to_extract = {
+    # Font name
+    "AMS-Regular": {
+        u"\u21e2": None,  # \dashrightarrow
+        u"\u21e0": None,  # \dashleftarrow
+    },
+    "Main-Regular": {
+        # Skew and italic metrics can't be easily parsed from the TTF. Instead,
+        # we map each character to a "base character", which is a character
+        # from the same font with correct italic and skew metrics. A character
+        # maps to None if it doesn't have a base.
+
+        #u"\u2209": None,  # \notin
+        #u"\u2260": None,  # \neq
+        u"\u2245": None,  # \cong
+        u"\u2026": None,  # \ldots
+        u"\u22ef": None,  # \cdots
+        u"\u22f1": None,  # \ddots
+        u"\u22ee": None,  # \vdots
+        u"\u22ee": None,  # \vdots
+        u"\u22a8": None,  # \models
+        u"\u22c8": None,  # \bowtie
+        u"\u2250": None,  # \doteq
+        u"\u23b0": None,  # \lmoustache
+        u"\u23b1": None,  # \rmoustache
+        u"\u27ee": None,  # \lgroup
+        u"\u27ef": None,  # \rgroup
+        u"\u27f5": None,  # \longleftarrow
+        u"\u27f8": None,  # \Longleftarrow
+        u"\u27f6": None,  # \longrightarrow
+        u"\u27f9": None,  # \Longrightarrow
+        u"\u27f7": None,  # \longleftrightarrow
+        u"\u27fa": None,  # \Longleftrightarrow
+        u"\u21a6": None,  # \mapsto
+        u"\u27fc": None,  # \longmapsto
+        u"\u21a9": None,  # \hookleftarrow
+        u"\u21aa": None,  # \hookrightarrow
+        u"\u21cc": None,  # \rightleftharpoons
+    },
+    "Main-Bold": {
+        u"\u2245": None,  # \cong
+    },
+    "Size1-Regular": {
+        u"\u222c": u"\u222b",  # \iint, based on \int
+        u"\u222d": u"\u222b",  # \iiint, based on \int
+    },
+    "Size2-Regular": {
+        u"\u222c": u"\u222b",  # \iint, based on \int
+        u"\u222d": u"\u222b",  # \iiint, based on \int
+    },
+}
+
+
+def main():
+    start_json = json.load(sys.stdin)
+
+    for font in start_json:
+        fontInfo = TTFont("../../fonts/KaTeX_" + font + ".ttf")
+        glyf = fontInfo["glyf"]
+        widths = fontInfo.getGlyphSet()
+        unitsPerEm = float(fontInfo["head"].unitsPerEm)
+
+        # We keep ALL Unicode cmaps, not just fontInfo["cmap"].getcmap(3, 1).
+        # This is playing it extra safe, since it reports inconsistencies.
+        # Platform 0 is Unicode, platform 3 is Windows. For platform 3,
+        # encoding 1 is UCS-2 and encoding 10 is UCS-4.
+        cmap = [t.cmap for t in fontInfo["cmap"].tables
+                if (t.platformID == 0)
+                or (t.platformID == 3 and t.platEncID in (1, 10))]
+
+        chars = metrics_to_extract.get(font, {})
+        chars[u"\u0020"] = None  # space
+        chars[u"\u00a0"] = None  # nbsp
+
+        for char, base_char in chars.items():
+            code = ord(char)
+            names = set(t.get(code) for t in cmap)
+            if not names:
+                sys.stderr.write(
+                    "Codepoint {} of font {} maps to no name\n"
+                    .format(code, font))
+                continue
+            if len(names) != 1:
+                sys.stderr.write(
+                    "Codepoint {} of font {} maps to multiple names: {}\n"
+                    .format(code, font, ", ".join(sorted(names))))
+                continue
+            name = names.pop()
+
+            height = depth = italic = skew = width = 0
+            glyph = glyf[name]
+            if glyph.numberOfContours:
+                height = glyph.yMax / unitsPerEm
+                depth = -glyph.yMin / unitsPerEm
+            width = widths[name].width / unitsPerEm
+            if base_char:
+                base_char_str = str(ord(base_char))
+                base_metrics = start_json[font][base_char_str]
+                italic = base_metrics["italic"]
+                skew = base_metrics["skew"]
+                width = base_metrics["width"]
+
+            start_json[font][str(code)] = {
+                "height": height,
+                "depth": depth,
+                "italic": italic,
+                "skew": skew,
+                "width": width
+            }
+
+    sys.stdout.write(
+        json.dumps(start_json, separators=(',', ':'), sort_keys=True))
+
+if __name__ == "__main__":
+    main()

inspect_ai/_view/www/node_modules/katex/src/metrics/format_json.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+
+import sys
+import json
+
+props = ['depth', 'height', 'italic', 'skew']
+
+if len(sys.argv) > 1:
+    if sys.argv[1] == '--width':
+        props.append('width')
+
+data = json.load(sys.stdin)
+sys.stdout.write(
+  "// This file is GENERATED by buildMetrics.sh. DO NOT MODIFY.\n")
+sep = "export default {\n    "
+for font in sorted(data):
+    sys.stdout.write(sep + json.dumps(font))
+    sep = ": {\n        "
+    for glyph in sorted(data[font], key=int):
+        sys.stdout.write(sep + json.dumps(glyph) + ": ")
+
+        values = [value if value != 0.0 else 0 for value in
+                  [data[font][glyph][key] for key in props]]
+
+        sys.stdout.write(json.dumps(values))
+        sep = ",\n        "
+    sep = ",\n    },\n    "
+sys.stdout.write(",\n    },\n};\n")

inspect_ai/_view/www/node_modules/katex/src/metrics/parse_tfm.py

@@ -0,0 +1,211 @@
+class CharInfoWord(object):
+    def __init__(self, word):
+        b1, b2, b3, b4 = (word >> 24,
+                          (word & 0xff0000) >> 16,
+                          (word & 0xff00) >> 8,
+                          word & 0xff)
+
+        self.width_index = b1
+        self.height_index = b2 >> 4
+        self.depth_index = b2 & 0x0f
+        self.italic_index = (b3 & 0b11111100) >> 2
+        self.tag = b3 & 0b11
+        self.remainder = b4
+
+    def has_ligkern(self):
+        return self.tag == 1
+
+    def ligkern_start(self):
+        return self.remainder
+
+
+class LigKernProgram(object):
+    def __init__(self, program):
+        self.program = program
+
+    def execute(self, start, next_char):
+        curr_instruction = start
+        while True:
+            instruction = self.program[curr_instruction]
+            (skip, inst_next_char, op, remainder) = instruction
+
+            if inst_next_char == next_char:
+                if op < 128:
+                    # Don't worry about ligatures for now, we only need kerns
+                    return None
+                else:
+                    return 256 * (op - 128) + remainder
+            elif skip >= 128:
+                return None
+            else:
+                curr_instruction += 1 + skip
+
+
+class TfmCharMetrics(object):
+    def __init__(self, width, height, depth, italic, kern_table):
+        self.width = width
+        self.height = height
+        self.depth = depth
+        self.italic_correction = italic
+        self.kern_table = kern_table
+
+
+class TfmFile(object):
+    def __init__(self, start_char, end_char, char_info, width_table,
+                 height_table, depth_table, italic_table, ligkern_table,
+                 kern_table):
+        self.start_char = start_char
+        self.end_char = end_char
+        self.char_info = char_info
+        self.width_table = width_table
+        self.height_table = height_table
+        self.depth_table = depth_table
+        self.italic_table = italic_table
+        self.ligkern_program = LigKernProgram(ligkern_table)
+        self.kern_table = kern_table
+
+    def get_char_metrics(self, char_num, fix_rsfs=False):
+        """Return glyph metrics for a unicode code point.
+
+        Arguments:
+            char_num: a unicode code point
+            fix_rsfs: adjust for rsfs10.tfm's different indexing system
+        """
+        if char_num < self.start_char or char_num > self.end_char:
+            raise RuntimeError("Invalid character number")
+
+        if fix_rsfs:
+            # all of the char_nums contained start from zero in rsfs10.tfm
+            info = self.char_info[char_num - self.start_char]
+        else:
+            info = self.char_info[char_num + self.start_char]
+
+        char_kern_table = {}
+        if info.has_ligkern():
+            for char in range(self.start_char, self.end_char + 1):
+                kern = self.ligkern_program.execute(info.ligkern_start(), char)
+                if kern:
+                    char_kern_table[char] = self.kern_table[kern]
+
+        return TfmCharMetrics(
+            self.width_table[info.width_index],
+            self.height_table[info.height_index],
+            self.depth_table[info.depth_index],
+            self.italic_table[info.italic_index],
+            char_kern_table)
+
+
+class TfmReader(object):
+    def __init__(self, f):
+        self.f = f
+
+    def read_byte(self):
+        return ord(self.f.read(1))
+
+    def read_halfword(self):
+        b1 = self.read_byte()
+        b2 = self.read_byte()
+        return (b1 << 8) | b2
+
+    def read_word(self):
+        b1 = self.read_byte()
+        b2 = self.read_byte()
+        b3 = self.read_byte()
+        b4 = self.read_byte()
+        return (b1 << 24) | (b2 << 16) | (b3 << 8) | b4
+
+    def read_fixword(self):
+        word = self.read_word()
+
+        neg = False
+        if word & 0x80000000:
+            neg = True
+            word = (-word & 0xffffffff)
+
+        return (-1 if neg else 1) * word / float(1 << 20)
+
+    def read_bcpl(self, length):
+        str_length = self.read_byte()
+        data = self.f.read(length - 1)
+        return data[:str_length]
+
+
+def read_tfm_file(file_name):
+    with open(file_name, 'rb') as f:
+        reader = TfmReader(f)
+
+        # file_size
+        reader.read_halfword()
+        header_size = reader.read_halfword()
+
+        start_char = reader.read_halfword()
+        end_char = reader.read_halfword()
+
+        width_table_size = reader.read_halfword()
+        height_table_size = reader.read_halfword()
+        depth_table_size = reader.read_halfword()
+        italic_table_size = reader.read_halfword()
+
+        ligkern_table_size = reader.read_halfword()
+        kern_table_size = reader.read_halfword()
+
+        # extensible_table_size
+        reader.read_halfword()
+        # parameter_table_size
+        reader.read_halfword()
+
+        # checksum
+        reader.read_word()
+        # design_size
+        reader.read_fixword()
+
+        if header_size > 2:
+            # coding_scheme
+            reader.read_bcpl(40)
+
+        if header_size > 12:
+            # font_family
+            reader.read_bcpl(20)
+
+        for i in range(header_size - 17):
+            reader.read_word()
+
+        char_info = []
+        for i in range(start_char, end_char + 1):
+            char_info.append(CharInfoWord(reader.read_word()))
+
+        width_table = []
+        for i in range(width_table_size):
+            width_table.append(reader.read_fixword())
+
+        height_table = []
+        for i in range(height_table_size):
+            height_table.append(reader.read_fixword())
+
+        depth_table = []
+        for i in range(depth_table_size):
+            depth_table.append(reader.read_fixword())
+
+        italic_table = []
+        for i in range(italic_table_size):
+            italic_table.append(reader.read_fixword())
+
+        ligkern_table = []
+        for i in range(ligkern_table_size):
+            skip = reader.read_byte()
+            next_char = reader.read_byte()
+            op = reader.read_byte()
+            remainder = reader.read_byte()
+
+            ligkern_table.append((skip, next_char, op, remainder))
+
+        kern_table = []
+        for i in range(kern_table_size):
+            kern_table.append(reader.read_fixword())
+
+        # There is more information, like the ligkern, kern, extensible, and
+        # param table, but we don't need these for now
+
+        return TfmFile(start_char, end_char, char_info, width_table,
+                       height_table, depth_table, italic_table,
+                       ligkern_table, kern_table)

inspect_ai/_view/www/package.json

@@ -91,7 +91,7 @@
     "react-popper": "^2.3.0",
     "react-router-dom": "^7.6.0",
     "react-virtuoso": "^4.12.7",
-    "zustand": "^5.0.5",
-    "use-resize-observer": "^9.1.0"
+    "use-resize-observer": "^9.1.0",
+    "zustand": "^5.0.5"
   }
 }