pygacity 0.4.0__tar.gz

pygacity-0.4.0/.gitignore

@@ -0,0 +1,138 @@
+*.bak
+__defunct__/
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+.idea/
+*tmp*
+*/results/
+.vscode/
+# C extensions
+*.so
+*.o
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+docs/source/_build
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+.vscode/settings.json
+

pygacity-0.4.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Cameron Abrams
+
+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.

pygacity-0.4.0/PKG-INFO

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: pygacity
+Version: 0.4.0
+Summary: A framework for exam and assignment generation using LaTeX and pythontex
+Author-email: Cameron F Abrams <cfa22@drexel.edu>
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.7
+Requires-Dist: iapws
+Requires-Dist: jinja2
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: progressbar
+Requires-Dist: pypdf2
+Requires-Dist: roman
+Requires-Dist: sandlerprops
+Requires-Dist: sandlersteam
+Requires-Dist: scipy
+Description-Content-Type: text/markdown
+
+# pygacity
+
+> A Python package to enable high-throughput generation of problems suitable for exams and problem sets for thermodynamics courses
+
+You may have learned how to use Python to solve thermodynamics problems, like equilibrium compositions for a reacting system, or phase compositions in vapor-liquid equilibrium.  `Pygacity` takes this idea and uses Python to generate new problems.  The problems are generated in such a way that they can be typeset into PDF's using LaTeX.  `Pygacity` relies on the `pythontex` package in LaTeX to allow Python code to run during document compilation and results of those calculations automatically included in the document.
+
+## Installation
+
+`Pygacity` is in development.  Best to install it that way.
+
+```sh
+git clone git@github.com:cameronabrams/pygacity.git
+cd pygacity
+pip install -e .
+```
+
+`Pygacity` includes the LaTeX class file `autoprob.cls` under `[INSTALL-DIR]/pygacity/resources/autoprob-package/tex/latex/`.  All `latex` commands that are managed by `pygacity` append this directory in a ``--include-directory`` argument.  If you would like to use `autoprob.cls` outside of `pygacity`, you will need to make your LaTeX installation aware of `autoprob-package` root.
+
+## Release History
+
+* 0.4.0
+   * examples
+* 0.3.0
+   * Added multiple choice, short answer, and fill in the blank question types
+* 0.2.0
+   * Package reorg
+   * updated config yaml
+* 0.1.4
+    * single-shot assignment creation with no serial numbers
+    * additional LaTeX header commands available via config
+    * upgraded ycleptic dependencies to 2.0.3
+* 0.1.3
+    * `combine` subcommand
+    * `build` subcommand
+    * renamed to `pygacity`
+* 0.1.1
+    * reorganized package
+* 0.0.1
+    * Initial version
+
+## Meta
+
+Cameron F. Abrams – cfa22@drexel.edu
+
+Distributed under the MIT license. See ``LICENSE`` for more information.
+
+[https://github.com/cameronabrams](https://github.com/cameronabrams/)
+
+## Contributing
+
+1. Fork it (<https://github.com/cameronabrams/pygacity/fork>)
+2. Create your feature branch (`git checkout -b feature/fooBar`)
+3. Commit your changes (`git commit -am 'Add some fooBar'`)
+4. Push to the branch (`git push origin feature/fooBar`)
+5. Create a new Pull Request

pygacity-0.4.0/README.md

@@ -0,0 +1,55 @@
+# pygacity
+
+> A Python package to enable high-throughput generation of problems suitable for exams and problem sets for thermodynamics courses
+
+You may have learned how to use Python to solve thermodynamics problems, like equilibrium compositions for a reacting system, or phase compositions in vapor-liquid equilibrium.  `Pygacity` takes this idea and uses Python to generate new problems.  The problems are generated in such a way that they can be typeset into PDF's using LaTeX.  `Pygacity` relies on the `pythontex` package in LaTeX to allow Python code to run during document compilation and results of those calculations automatically included in the document.
+
+## Installation
+
+`Pygacity` is in development.  Best to install it that way.
+
+```sh
+git clone git@github.com:cameronabrams/pygacity.git
+cd pygacity
+pip install -e .
+```
+
+`Pygacity` includes the LaTeX class file `autoprob.cls` under `[INSTALL-DIR]/pygacity/resources/autoprob-package/tex/latex/`.  All `latex` commands that are managed by `pygacity` append this directory in a ``--include-directory`` argument.  If you would like to use `autoprob.cls` outside of `pygacity`, you will need to make your LaTeX installation aware of `autoprob-package` root.
+
+## Release History
+
+* 0.4.0
+   * examples
+* 0.3.0
+   * Added multiple choice, short answer, and fill in the blank question types
+* 0.2.0
+   * Package reorg
+   * updated config yaml
+* 0.1.4
+    * single-shot assignment creation with no serial numbers
+    * additional LaTeX header commands available via config
+    * upgraded ycleptic dependencies to 2.0.3
+* 0.1.3
+    * `combine` subcommand
+    * `build` subcommand
+    * renamed to `pygacity`
+* 0.1.1
+    * reorganized package
+* 0.0.1
+    * Initial version
+
+## Meta
+
+Cameron F. Abrams – cfa22@drexel.edu
+
+Distributed under the MIT license. See ``LICENSE`` for more information.
+
+[https://github.com/cameronabrams](https://github.com/cameronabrams/)
+
+## Contributing
+
+1. Fork it (<https://github.com/cameronabrams/pygacity/fork>)
+2. Create your feature branch (`git checkout -b feature/fooBar`)
+3. Commit your changes (`git commit -am 'Add some fooBar'`)
+4. Push to the branch (`git push origin feature/fooBar`)
+5. Create a new Pull Request

pygacity-0.4.0/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+[project]
+name = "pygacity"
+version = "0.4.0"
+authors = [
+  { name="Cameron F Abrams", email="cfa22@drexel.edu" },
+]
+description = "A framework for exam and assignment generation using LaTeX and pythontex"
+readme = "README.md"
+requires-python = ">=3.7"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+]
+dependencies = [
+    "numpy",
+    "pandas",
+    "scipy",
+    "iapws",
+    "sandlersteam",
+    "sandlerprops",
+    "roman",
+    "progressbar",
+    "pypdf2",
+    "jinja2",
+]
+[tool.pytest.ini_options]
+log_cli = true
+[project.scripts]
+pygacity="pygacity.cli:cli"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/pygacity"]
+
+[tool.hatch.build]
+include = [
+  "src/pygacity/resources/**",
+]
+
+[tool.hatch.build.targets.sdist]
+include = [
+  "src/pygacity/**",
+]

pygacity-0.4.0/src/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-0.4.0/src/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)
+
+