pygacity 0.4.0__py3-none-any.whl

pygacity/cli.py

@@ -0,0 +1,132 @@
+# Author: Cameron F. Abrams, <cfa22@drexel.edu>
+
+
+import logging
+import os
+import shutil
+
+import argparse as ap
+
+from .generate.build import build, answerset_subcommand
+from .util.pdfutils import combine_pdfs
+from .util.stringthings import oxford, banner
+
+logger = logging.getLogger(__name__)
+
+def setup_logging(args):    
+    loglevel_numeric = getattr(logging, args.logging_level.upper())
+    if args.log:
+        if os.path.exists(args.log):
+            shutil.copyfile(args.log, args.log+'.bak')
+        logging.basicConfig(filename=args.log,
+                            filemode='w',
+                            format='%(asctime)s %(name)s %(message)s',
+                            level=loglevel_numeric
+        )
+    console = logging.StreamHandler()
+    console.setLevel(logging.INFO)
+    formatter = logging.Formatter('%(levelname)s> %(message)s')
+    console.setFormatter(formatter)
+    logging.getLogger('').addHandler(console)
+
+def cli():
+    subcommands = {
+        'build': dict(
+            func = build,
+            help = 'build document',
+            ),
+        'answerset' : dict(
+            func = answerset_subcommand,
+            help = 'remake answer set document from a previous build',
+        ),
+        'combine': dict(
+            func = combine_pdfs,
+            help = 'combine PDFs',
+        )
+    }
+    parser = ap.ArgumentParser(
+        prog='pygacity',
+    )
+    parser.add_argument(
+        '-b',
+        '--banner',
+        default=True,
+        action=ap.BooleanOptionalAction,
+        help='toggle banner message'
+    )
+    parser.add_argument(
+        '--logging-level',
+        type=str,
+        default='debug',
+        choices=[None, 'info', 'debug', 'warning'],
+        help='Logging level for messages written to diagnostic log'
+    )
+    parser.add_argument(
+        '-l',
+        '--log',
+        type=str,
+        default='pygacity-diagnostics.log',
+        help='File to which diagnostic log messages are written'
+    )
+    subparsers = parser.add_subparsers(
+        title="subcommands",
+        dest="command",
+        metavar="<command>",
+        required=True,
+    )
+    command_parsers={}
+    for k, specs in subcommands.items():
+        command_parsers[k] = subparsers.add_parser(
+            k,
+            help=specs['help'],
+            formatter_class=ap.RawDescriptionHelpFormatter
+        )
+        command_parsers[k].set_defaults(func=specs['func'])
+
+    command_parsers['build'].add_argument(
+        '-o',
+        '--overwrite',
+        type=bool,
+        default=False,
+        action=ap.BooleanOptionalAction,
+        help='completely remove old save dir and build new exams')
+    command_parsers['build'].add_argument(
+        '-s',
+        '--solutions',
+        type=bool,
+        default=True,
+        action=ap.BooleanOptionalAction,
+        help='build solutions document(s)')
+    command_parsers['build'].add_argument(
+        'f',
+        help='mandatory YAML input file')
+    command_parsers['answerset'].add_argument(
+        'f',
+        help='mandatory YAML input file used in a previous build to generate the answer set')
+    command_parsers['combine'].add_argument(
+        '-i',
+        '--input-pdfs',
+        type=str,
+        default=[],
+        nargs='+',  
+        help='space-separated list of PDF file names to combine'
+    )
+    command_parsers['combine'].add_argument(
+        '-o',
+        '--pdf-out',
+        type=str,
+        default='out.pdf',
+        help='name of new output PDF to be created')
+    
+    args = parser.parse_args()
+
+    setup_logging(args)
+
+    if args.banner:
+        banner(print)    
+    if hasattr(args, 'func'):
+        args.func(args)
+    else:
+        my_list = oxford(list(subcommands.keys()))
+        print(f'No subcommand found. Expected one of {my_list}')
+    logger.info('Thanks for using pygacity!')

pygacity/generate/answerset.py

@@ -0,0 +1,194 @@
+# Author: Cameron F. Abrams, <cfa22@drexel.edu>
+import yaml
+import os
+from collections import UserList
+import pandas as pd
+import logging
+
+logger = logging.getLogger(__name__)
+
+class AnswerSet:
+    _keys = ['label', 'value', 'units', 'formatter']
+    def __init__(self, serial: int = 0):
+        self.serial = serial
+        self.dumpname = f'answers-{serial:08d}.yaml'
+        self.D = {}
+        self.first_index = None
+
+    @classmethod
+    def from_yaml(cls, filename, delete=False):
+        """
+        Create an AnswerSet instance by loading from a YAML file of the same format as that 
+        generated by the to_yaml() method.
+        """
+        root, ext = os.path.splitext(filename)
+        assert ext in ['.yaml', '.yml'], f'{filename} does not end in .yaml or .yml'
+        tokens = root.split('-')
+        assert len(tokens) == 2, f'{filename} should be of the format "answers-<serial#>.yaml"'
+        serial = int(tokens[1])
+        R = cls(serial)
+        with open(filename, 'r') as f:
+            R.D = yaml.safe_load(f)
+        if delete:
+            os.remove(filename)
+        return R
+    
+    def register(self, index, label=None, value=None, units=None, formatter=None, group=None):
+        """
+        Register an answer entry for a particular question index.
+        """
+        if not self.first_index:
+            self.first_index = index
+        if not index in self.D:
+            self.D[index] = []
+        # if value is a numpy data type, convert to native python type
+        if hasattr(value, 'item'):
+            value = value.item()
+        self.D[index].append(dict(  label=label,
+                                    value=value,
+                                    units=units,
+                                    formatter=formatter,
+                                    group=group))
+        logger.debug(f'AnswerSet.register index={index} label={label} value={value} units={units} formatter={formatter} group={group}')
+    
+    def display(self, index, element=0):
+        D = None
+        if element < len(self.D[index]):
+            D = self.D[index][element]
+        if D:
+            fmt = D.get('formatter',None)
+            val = D.get('value',None)
+            label = D.get('label',None)
+            units = D.get('units',None)
+            vstr = ''
+            if val:
+                if fmt:
+                    vstr = fmt.format(val)
+                else:
+                    vstr = str(val)
+                if units:
+                    vstr += f' {units}'
+            if label:
+                if vstr:
+                    return f'{label} = {vstr}'
+                else:
+                    return label
+        return ''
+
+    # def to_yaml(self):
+    #     # check all indices for common bytes at the start, and remove them
+    #     raw_indices = list(self.D.keys())
+    #     common_prefix = os.path.commonprefix([str(x) for x in raw_indices])
+    #     logger.debug(f'AnswerSet.to_yaml common prefix: "{common_prefix}"')
+    #     if common_prefix:
+    #         new_D = {}
+    #         for index, AL in self.D.items():
+    #             new_index = str(index)[len(common_prefix):]
+    #             new_D[new_index] = AL
+    #         self.D = new_D
+    #     with open(self.dumpname, 'w') as f:
+    #         yaml.safe_dump(self.D, f)
+
+class AnswerSuperSet(UserList):
+
+    def __init__(self, initial: list[AnswerSet] = None):
+        self.data: list[AnswerSet] = initial if initial is not None else []
+        super().__init__(self.data)
+        if not self._check_congruency():
+            print(f'Error: There is a lack of congruency among answer sets')
+        self._make_dfs()
+
+    @classmethod
+    def from_dumpfiles(cls, files=[], delete=False):
+        data=[]
+        for f in files:
+            data.append(AnswerSet.from_yaml(f, delete=delete))
+        return cls(initial=data)
+
+    def to_latex(self):
+        result = ''
+        for group_name, group_data in self.groups.items():
+            df = group_data['df']
+            formatters = group_data.get('formatters', None)
+            logger.debug(f'AnswerSuperSet.to_latex group "{group_name}" with formatters: {formatters}')
+            result += df.to_latex(formatters=formatters, index=False, longtable=True)#,header=self.headings)
+        return result
+    
+    def _check_congruency(self):
+        if len(self)>0:
+            indices=list(self.data[0].D.keys())
+            for l in self.data[1:]:
+                test_indices=list(l.D.keys())
+                check=all([x==y for x,y in zip(indices,test_indices)])
+                if not check:
+                    return False
+            for i in indices:
+                ilen=len(self.data[0].D[i])
+                for l in self.data[1:]:
+                    test_ilen=len(l.D[i])
+                    check=ilen==test_ilen
+                    if not check:
+                        return False
+        return True
+    
+    def _make_dfs(self):
+        # to do: groupify
+        serials = [x.serial for x in self.data]
+        # logger.debug(serials)
+        # self.headings = ['serials']
+        # keys = ['serials']
+        values = {'serials': serials}
+        pattern = self.data[0]  # keys in first AnswerSet form the pattern all sets follow
+        self.formatters = {}
+        self.groups = {}
+        # keys in D may be prepended with a common prefix; remove it
+        common_prefix = os.path.commonprefix([str(x) for x in pattern.D.keys()])
+        logger.debug(f'Overall common prefix: "{common_prefix}"')
+        for dataset in self.data:
+            new_dataset_D = {}
+            for index in dataset.D.keys():
+                new_index = str(index)[len(common_prefix):]
+                new_dataset_D[new_index] = dataset.D[index]
+            dataset.D = new_dataset_D
+        for index, AL in pattern.D.items():
+            for a in AL:
+                key = f'{index}-{a["label"]}'
+                if 'units' in a and a['units']:
+                    key += f' ({a["units"]})'
+                group = a.get('group', None)
+                if group:
+                    if group not in self.groups:
+                        self.groups[group] = dict(formatters={}, df=None, values={'serials': serials})
+                    self.groups[group]['values'][key] = []
+                    if 'formatter' in a:
+                        self.groups[group]['formatters'][key] = a['formatter']
+                else:
+                    values[key] = []
+                    if 'formatter' in a:
+                        self.formatters[key] = a['formatter']
+        # logger.debug(values)
+        for inst in self.data:
+            for index, AL in inst.D.items():
+                for a in AL:
+                    key = f'{index}-{a["label"]}'
+                    if 'units' in a and a['units']:
+                        key += f' ({a["units"]})'
+                    group = a.get('group', None)
+                    if group:
+                        self.groups[group]['values'][key].append(a['value'])
+                    else:
+                        values[key].append(a['value'])
+        # logger.debug(values)
+        if not self.groups:
+            DF = pd.DataFrame(values)
+            DF.sort_values(by='serials', inplace=True)
+            self.groups['base'] = dict(formatters=self.formatters, df=DF)
+        else:
+            for gname, gdata in self.groups.items():
+                logger.debug(f'Building DataFrame for group {gname} with values: {gdata["values"]}')
+                DF = pd.DataFrame(gdata['values'])
+                DF.sort_values(by='serials', inplace=True)
+                self.groups[gname]['df'] = DF
+        # print(self.DF)
+
+

pygacity/generate/block.py

@@ -0,0 +1,166 @@
+# Author: Cameron F. Abrams, <cfa22@drexel.edu>
+from __future__ import annotations
+import logging
+import os
+import re
+
+from copy import deepcopy
+from importlib.resources import files
+from pathlib import Path
+from shutil import copy2
+
+logger = logging.getLogger(__name__)
+
+def path_resolver(filename: str, search_paths: list[Path] = [], ext: str ='') -> Path:
+    local_filename = filename if filename.endswith(ext) else filename + ext
+    # check local directory first
+    local_path = Path(local_filename)
+    if local_path.exists():
+        return local_path
+    # check search path next
+    else:
+        for search_path in search_paths:
+            template_path = search_path / local_filename
+            if template_path.exists():
+                return template_path
+        spm = ':'.join([str(sp) for sp in search_paths])
+        raise FileNotFoundError((f'Could not locate source file {local_filename} in cwd ({os.getcwd()}) '
+                                 f'or search path {spm}.'))
+
+class LatexCompoundBlock:
+    resources_root: Path = files('pygacity') / 'resources'
+    templates_dir: Path = resources_root / 'templates'
+    pythontex_dir = resources_root / 'pythontex'
+    substitution_delimiters: tuple = (r'<<<', r'>>>')
+
+    def __init__(self, block_specs: dict, parent_idx: str = '', idx: int = 0):
+        self.block_specs = block_specs
+        self.idx = parent_idx + (f'.{idx}' if parent_idx != '' else f'{idx}')
+        self.textcontents: str = block_specs.get('text', '')
+
+        self.sourcename: str = block_specs.get('source', None)
+        self.substitution_map: dict = block_specs.get('substitutions', {})
+
+        self.points: int = block_specs.get('points', 0)
+        self.config_filename: str = block_specs.get('config', None)
+        self.group: int = block_specs.get('group', 0)
+
+        self.pythontex: list[str] = block_specs.get('pythontex', [])
+
+        self.enumerate = [LatexCompoundBlock(block_specs=child, parent_idx=self.idx, idx=i+1) for i, child in enumerate(block_specs.get('enumerate', []))]
+        self.itemize = [LatexCompoundBlock(block_specs=child, parent_idx=self.idx, idx=i+1) for i, child in enumerate(block_specs.get('itemize', []))]
+        self.children = self.enumerate + self.itemize
+
+        self.sourcepath = None
+        self.config_path = Path(self.config_filename) if self.config_filename else None
+        self.processedcontents: str = ''
+        self.has_pycode: bool = False
+        self.embedded_graphics: list[str | Path] = []
+
+        self._check_schema()
+
+        logger.debug(f'LatexCompoundBlock.__init__ substitution_map: {self.substitution_map}')
+
+    def _check_schema(self):
+        # cannot specify both text content and a source file
+        if self.textcontents != '' and self.sourcename is not None:
+            raise ValueError('Block cannot specify both "text" content and a "source" file.')
+        # cannot specify both enumerate and itemize
+        if len(self.enumerate) > 0 and len(self.itemize) > 0:
+            raise ValueError('Block cannot specify both "enumerate" and "itemize" children.')
+        # if list of pythontext files is non-empty, cannot specify text or source
+        if len(self.pythontex) > 0:
+            if self.textcontents != '' or self.sourcename is not None:
+                raise ValueError('Block cannot specify "pythontex" files along with "text" content or a "source" file.')
+
+    def load(self) -> LatexCompoundBlock:
+        if self.sourcename:
+            self.sourcepath = path_resolver(self.sourcename, search_paths=[self.templates_dir])
+            with open(self.sourcepath, 'r') as f:
+                self.textcontents = f.read()
+        elif len(self.pythontex) > 0:
+            self.textcontents = r'\begin{pycode}' + '\n'
+            for ptfile in self.pythontex:
+                ptpath = path_resolver(ptfile, search_paths=[LatexCompoundBlock.pythontex_dir], ext='.pycode')
+                with open(ptpath, 'r') as f:
+                    self.textcontents += f.read() + '\n\n'
+            self.textcontents += r'\end{pycode}' + '\n'
+        self.has_pycode = r'\begin{pycode}' in self.textcontents or self.has_pycode
+        # check contents for substitution keys and embedded graphics files
+        KEY_RE = re.compile(rf'{self.substitution_delimiters[0]}\s*([A-Za-z0-9_-]+)\s*{self.substitution_delimiters[1]}')
+        for line in self.textcontents.split('\n'):
+            keys = set(KEY_RE.findall(line))
+            for key in keys:
+                if not key in self.substitution_map:
+                    self.substitution_map[key] = None
+            # check for embedded graphics
+            GRAPHICS_RE = re.compile(r'\\includegraphics(?:\[[^\]]*\])?\{([^\}]+)\}')
+            graphics_files = GRAPHICS_RE.findall(line)
+            for gf in graphics_files:
+                if gf not in self.embedded_graphics:
+                    self.embedded_graphics.append(gf)
+        self.processedcontents = self.textcontents[:]
+        if self.config_path:
+            if not self.config_path.exists():
+                raise FileNotFoundError(f'Configuration file {self.config_path.as_posix()} does not exist.')
+            self.substitution_map['config'] = self.config_path.as_posix()
+        if self.points:
+            self.substitution_map['points'] = self.points
+        if self.group:
+            self.substitution_map['group'] = self.group
+        self.substitution_map['idx'] = self.idx
+
+        for child in self.children:
+            child.load()
+            self.has_pycode = child.has_pycode or self.has_pycode
+            self.embedded_graphics.extend(child.embedded_graphics)
+
+        logger.debug(f'LatexCompoundBlock.load completed for idx={self.idx} with substitutions: {self.substitution_map}')
+        return self
+
+    def substitute(self, super_substitutions: dict = {}, match_all: bool = True):
+        self.processedcontents = self.textcontents[:]
+        substitutions = deepcopy(super_substitutions)
+        logger.debug(f'block at idx {self.idx} incoming substitutions: {substitutions}')
+        logger.debug(f'block at idx {self.idx} own substitution_map: {self.substitution_map}')
+        substitutions.update({k: v for k, v in self.substitution_map.items() if v is not None})
+        logger.debug(f'block at idx {self.idx} substitutions: {substitutions}')
+        # apply substitutions to the contents
+        for key, value in substitutions.items():
+            if value is not None:
+                self.processedcontents = self.processedcontents.replace(f'{self.substitution_delimiters[0]}{key}{self.substitution_delimiters[1]}', str(value))
+            elif match_all:
+                raise KeyError(f'Substitution key {key} has no associated value for text {self.textcontents[:30]}...')
+        # apply substitutions to children
+        for child in self.children:
+            child.substitute(super_substitutions=substitutions, match_all=match_all)
+
+    def copy_referenced_configs(self, output_dir: str):
+        config_paths = []
+        if self.config_path and self.config_path.exists():
+            dest_path = Path(output_dir) / self.config_path.name
+            if not dest_path.exists():
+                copy2(self.config_path, dest_path)
+                logger.debug(f'Copied config file {self.config_path} to {dest_path}')
+            config_paths.append(str(dest_path))
+        for child in self.children:
+            child_paths = child.copy_referenced_configs(output_dir)
+            if child_paths:
+                config_paths.extend(child_paths)
+        return config_paths
+
+    def __str__(self):
+        contents = self.processedcontents
+        if self.enumerate:
+            enum_str = r'\begin{enumerate}' + '\n'
+            for item in self.enumerate:
+                enum_str += r'\item ' + str(item) + '\n'
+            enum_str += r'\end{enumerate}' + '\n'
+            contents += '\n' + enum_str
+        if self.itemize:
+            item_str = r'\begin{itemize}' + '\n'
+            for item in self.itemize:
+                item_str += r'\item ' + str(item) + '\n'
+            item_str += r'\end{itemize}' + '\n'
+            contents += '\n' + item_str
+        return contents

pygacity/generate/build.py

@@ -0,0 +1,188 @@
+# Author: Cameron F. Abrams, <cfa22@drexel.edu>
+from copy import deepcopy
+import logging
+import os
+import pickle
+import stat
+import random
+from shutil import rmtree
+from pathlib import Path
+from .answerset import AnswerSet, AnswerSuperSet
+from .config import Config
+from .document import Document
+from ..util.stringthings import chmod_recursive
+from ..util.collectors import FileCollector
+from ..util.texutils import LatexBuilder
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+logging.getLogger("ycleptic").setLevel(logging.WARNING)
+logging.getLogger("matplotlib").setLevel(logging.WARNING)
+
+def build(args):
+    logger.info(f'Building document(s) as specified in {args.f}...')
+    FC = FileCollector()
+    config = Config(args.f)
+    seed = config.build_specs.get('seed', None)
+    if seed is not None:
+        random.seed(seed)
+        logger.info(f'Setting random seed to {seed}.')
+
+    build_path: Path = Path(config.build_specs['paths']['build-dir'])
+    pickle_cache = build_path / '.cache'
+    if not build_path.exists():
+        build_path.mkdir(parents=True, exist_ok=True)
+    else:
+        if args.overwrite:
+            permissions = stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR
+            chmod_recursive(build_path, permissions)
+            rmtree(build_path)
+            build_path.mkdir(parents=True, exist_ok=True)
+        else:
+            raise Exception(f'Build directory "{build_path.as_posix()}" already exists and "--overwrite" was not specified.')
+
+    if not pickle_cache.exists():
+        pickle_cache.mkdir(parents=True, exist_ok=True)
+
+    base_builder = LatexBuilder(config.build_specs, 
+                                 searchdirs = [config.autoprob_package_dir])
+    base_doc = Document(config.document_specs)
+    logger.debug(f'base_doc has {len(base_doc.blocks)} blocks')
+    if args.solutions:
+        solution_build_specs = deepcopy(config.build_specs)
+        # solution_build_specs['output-name'] = config.build_specs.get('output-name', 'document') + '_soln'
+        solution_build_specs['job-name'] = config.build_specs.get('job-name', 'document') + '_soln'
+        soln_builder = LatexBuilder(solution_build_specs,
+                                    searchdirs = [config.autoprob_package_dir])
+        
+        solution_document_specs = deepcopy(config.document_specs)
+        solution_document_specs['class']['options'].append('solutions')
+        solution_doc = Document(solution_document_specs)
+        logger.debug(f'solution_doc has {len(solution_doc.blocks)} blocks')
+
+    if build_path != Path.cwd():
+        # find any configs referenced in document blocks and copy them to output_dir
+        for block in base_doc.blocks:
+            file_or_files_or_none = block.copy_referenced_configs(build_path)
+            if file_or_files_or_none:
+                if isinstance(file_or_files_or_none, list):
+                    for f in file_or_files_or_none:
+                        FC.append(f)
+                else:
+                    FC.append(file_or_files_or_none)
+
+    if config.build_specs.get('copies', 1) > 1:
+        if config.build_specs.get('serials', None):
+            # check for explict serials
+            serials = [int(x) for x in config.build_specs['serials']]
+        elif config.build_specs.get('serial-range', None):
+            # check for a serial range
+            serials = list(range(config.build_specs['serial-range'][0],
+                                 config.build_specs['serial-range'][1] + 1))
+        elif config.build_specs.get('serial-file', None):
+            # check for a file containing serials, one integer per line
+            with open(config.build_specs['serial-file'], 'r') as f:
+                serials = [int(line.strip()) for line in f if line.strip()]
+        else:
+            serial_digits = config.build_specs.get('serial-digits', len(str(config.build_specs['copies'])))
+            # generate 'copies' random serial numbers
+            serials = set()
+            while len(serials) < config.build_specs['copies']:
+                serial = random.randint(10**(serial_digits-1), 10**serial_digits - 1)
+                serials.add(serial)
+            serials = list(serials)
+            serials.sort()
+    else:
+        if config.build_specs.get('serials', None):
+            # check for explict serials
+            serials = [int(x) for x in config.build_specs['serials']]
+        else:
+            serials = [0]
+
+    for i, serial in enumerate(serials):
+        outer_substitutions = dict(serial=serial)
+        base_doc.make_substitutions(outer_substitutions)
+        base_builder.build_document(base_doc)
+        FC.append(f'{base_builder.working_job_name}.tex')
+        logger.info(f'serial # {serial} ({i+1}/{len(serials)}) => {build_path.absolute().relative_to(Path.cwd()).as_posix()}/{base_builder.working_job_name}.pdf')
+        if args.solutions:
+            solution_doc.make_substitutions(outer_substitutions)
+            soln_builder.build_document(solution_doc)
+            FC.append(f'{soln_builder.working_job_name}.tex')
+            logger.info(f'serial # {serial} ({i+1}/{len(serials)}) => {build_path.absolute().relative_to(Path.cwd()).as_posix()}/{soln_builder.working_job_name}.pdf')
+
+    AnswerSets = []
+    if pickle_cache.exists():
+        # there may be a pickle file for each serial that holds a FileCollector instance
+        commonFC = FileCollector()
+        for pfile in pickle_cache.glob('*.pkl'):
+            with pfile.open('rb') as f:
+                obj = pickle.load(f)
+            if isinstance(obj, FileCollector):
+                for item in obj.data:
+                    commonFC.append(build_path / item)
+            elif isinstance(obj, AnswerSet):
+                # serial is second token in filename split by '-'
+                tokens = pfile.stem.split('-')
+                serial = int(tokens[1])
+                AnswerSets.append(obj)
+            else:
+                logger.debug(f'Unrecognized object type {type(obj)} in pickle file {pfile.as_posix()}')
+            logger.debug(f'Removing pickle cache file {pfile.as_posix()}')
+            pfile.unlink()
+        
+        archive_path = build_path / 'common_files_from_pickle_cache'
+        common_archive = commonFC.archive(archive_path, delete=True)
+        logger.info(f'Archived common files from pickle cache to {common_archive.absolute().relative_to(Path.cwd()).as_posix()}')
+        rmtree(pickle_cache)
+        logger.debug(f'Removed pickle cache at {pickle_cache.as_posix()}')
+    if len(AnswerSets) > 0:
+        logger.info(f'Collected {len(AnswerSets)} answer sets from pickle cache.')
+        FC.append(answerset(config, AnswerSets=AnswerSets))
+    for f in FC.data:
+        logger.debug(f'Generated file: {f.absolute().relative_to(Path.cwd()).as_posix()}')
+    tex_archive = FC.archive(build_path / 'tex_artifacts', delete=True)
+    logger.info(f'Archived TeX artifacts to {tex_archive.absolute().relative_to(Path.cwd()).as_posix()}')
+    buildfiles_archive = base_builder.FC.archive(build_path / 'buildfiles', delete=True)
+    solnbuildfiles_archive = soln_builder.FC.archive(build_path / 'solnbuildfiles', delete=True)
+    logger.info(f'Archived build files to {buildfiles_archive.absolute().relative_to(Path.cwd()).as_posix()}')
+    logger.info(f'Archived solution build files to {solnbuildfiles_archive.absolute().relative_to(Path.cwd()).as_posix()}')
+
+def answerset(config: Config = None, AnswerSets: dict[str | int, AnswerSet] = None) -> str:
+    build_path: Path = Path(config.build_specs['paths']['build-dir'])
+    if len(AnswerSets) == 0:
+        apparent_answer_files = list(build_path.glob('answers-*.yaml'))
+        if not apparent_answer_files:
+            raise FileNotFoundError(f'No answer files found in {build_path} matching pattern "answers-*.yaml"')
+        filenames = [str(x) for x in apparent_answer_files]
+        filenames.sort()
+        logger.debug(f'Found answer set files: {filenames}')
+        AS = AnswerSuperSet.from_dumpfiles(filenames, delete=True)
+    else:
+        AS = AnswerSuperSet(initial=AnswerSets)
+
+    answer_buildspecs = {'job-name': config.build_specs.get('answer-name', 'answerset'),
+                         'paths': config.build_specs['paths']}
+    AnswerSetBuilder = LatexBuilder(answer_buildspecs,
+                                    searchdirs = [config.autoprob_package_dir])
+    
+    answer_docspecs = deepcopy(config.document_specs) 
+    answer_docspecs['structure'] = [] 
+    answer_docspecs['structure'].append(deepcopy(config.document_specs['structure'][0]))
+    answer_docspecs['structure'].append({'text': AS.to_latex()})
+    answer_docspecs['structure'].append(deepcopy(config.document_specs['structure'][-1]))
+    AnswerSetDoc = Document(answer_docspecs)
+    AnswerSetDoc.make_substitutions(dict(serial='Answer Set'))
+    AnswerSetBuilder.build_document(AnswerSetDoc)
+    logger.info(f'Combined answer set => {build_path.absolute().relative_to(Path.cwd()).as_posix()}/{AnswerSetBuilder.working_job_name}.pdf')
+    answerset_archive = AnswerSetBuilder.FC.archive(build_path / 'answerset_buildfiles', delete=True)
+    logger.info(f'Archived answer set build files to {answerset_archive.absolute().relative_to(Path.cwd()).as_posix()}')
+    return Path.cwd() / f'{AnswerSetBuilder.working_job_name}.tex'
+
+def answerset_subcommand(args):
+    logger.info(f'Generating answer set document from previous build specified in {args.f}...')
+    config = Config(args.f)
+    tex_file = answerset(config)
+    # remove the tex source
+    os.remove(tex_file)