Set up a GitHub Action.

Go through the classifiers that can be added to a package and add appropriate ones to setup.py.

Add a basic setup.py builds script for setuptools. Also add a build script for testing the building locally.

Should we unify the staging and publishing scripts? On the one hand it would reduce code duplication, but on the other hand it would be more risky?

Coverage reporting is not working because it references illud.

The pytests should be run against the wheel to make sure that when the wheel is installed it works correctly.

Formatting, linting, and type checking should ignore the venvs and dist directories.

The script to run all CI checks, scripts/all.sh does not build Python distributions. It should call scripts/build.sh to do this.

Add a GitHub Action to build the package to PRs to make sure that it does not get broken.

Do not run tests against the wheel built from the source distribution, instead just check that the contents of the wheel built using the source distribution match the contents of the wheel built from source. Wheel files are actually just .zip files so this can be done by unzipping both wheels and doing a comparison on the two file structures.

There should be one venv directory where different virtual environments are created. Right now, distribution building occurs in venv. It should be moved to venvs/building or something similar.

In setup.py, make the reference to the README.md relative to the setup.py file instead of absolute.

Add requirements for building Python distributions.

100% test coverage (by line?) should be required.

Set up a GitHub Action to build seligimus as a package and push to PyPI.

The wheel package is missing from the build requirements.

Do an initial pulling in of code from Arborista and Illud that is not specific to the function of those repositories and might be useful to other applications.

From Arborista:

• Same type equality operator decorator
• Tree and node?

From Illud:

• Math
• Generic inheritance test

Disallow merging directly to the master branch once the GitHub Action for PRs is set up.

Scripts should be using frozen requirements to make sure that the version of transitive dependencies are fixed.

Add a test which checks that the contents of the source distribution are what we expect them to be.

The deployment Action environments should have urls specified.

Add the dist directory to git to explicitly call out that workflow.

Make the status check of the GitHub Action required before merging is allowed.

This might have to wait until the action passes? Or I could use admin privileges to merge anyways to bootstrap the action into passing.

It would be nice to have an empty venv directory (with a .gitkeep file) in git so that the workflow is more clear without having to examine the files.

Maybe a readme with the purpose of each venv would also be nice but the issue with that would be that it could become out of sync.

Testing scripts should be run in a venv.

Change the build script to run setup.py in a venv so that the version of setuptools is fixed.

The build GitHub Action is currently not required before PRs are allowed to be merged. It probably should be.

The distribution Action should probably use downstream jobs for testing the wheel and testing the source distribution. The building job would upload artifacts and the downstream jobs would download them.

I'm not sure the duration implications, but organizationally, this would be cleaner.

We should be more intelligent about rebuliding the venv for wheel testing. Right now the venv is completely removed then rebuilt. This is overkill and we could save time by being smarter about it. The solution should also probably be factored out so that it can be used by other building and testing scripts.

Right now, I think we should lean towards just getting everything working and then we can work on nice-to-haves like this.

Do not rebuilt venvs every time scripts are run

The distribution job has a step for installing dependencies, but it doesn't need to do this because the scripts set up their own venvs.

Check that other workflows are not double installing as well.

The source distribution should not include the egg info because this is not needed to build the wheel. Make/modify a MANIFEST.in to fix this.

I don't think we need to use the popd trap in scripts because the scripts are not sourced, they are run in their own subprocess.

Add a badge to the readme with the status of the GitHub Action.

The README.md files should have a PyPI badge.

The source distribution is missing the build requirements file, requirements/build_requirements.txt.

The version string would be helpful for the source distribution testing script because the name of the tarball name includes the version string.

Move the version string into a file and then have setup.py read the version string from the file.

Make a script to freeze requirements.

Factor out the code for making a venv into a separate script.

Add a setup.py file as the build script for setuptools.

Also make sure to adjust the mypy configuration to include files in the root directory when this is added. Id est, add *.py to the files list in mypy.ini.

The VERSION.txt file is missing from the source distribution. This is needed to be able to build a wheel from the source distribution.

The name of the testing GitHub workflow is currently "Python package". It should be more related to what it does: test, type check, and lint.

In scripts/test_source_distribution, fix the error message for failing to find the source distribution. Right now it is just "Error: ...".

I misunderstood the meaning of a GitHub "Environment" at first. I thought it was just a way of controlling access to secrets. It turns out it is actually meant to correlate to external deployment environments. So, Seligimus should have one for Test PyPI and one for PyPI.

Here is what needs to be done:

• Make two new environments in GitHub "PyPI" and "Test PyPI"
• Delete the old tokens and make new ones for the two envs
• Change the staging and publishing scripts to use the new envs

The source distribution is missing the build script for building the source. This can be added in a MANIFEST.in.

Fix the filename of the build requirements file. It should be build_requirements.txt not build_requirement.txt (note the "s").

Add a test to make sure that the package can be built with the source distribution.

Should we then also run tests against the package built using the source distribution?

The Python distrubtions are missing packages. Taking a look inside the source distribution, only the root seligimus package is present, not all of the subpackages:

austin@austin-p7-1254:~/seligimus/dist/seligimus-0.1.0$ tree
.
├── PKG-INFO
├── README.md
├── seligimus
│   └── __init__.py
├── seligimus.egg-info
│   ├── dependency_links.txt
│   ├── PKG-INFO
│   ├── SOURCES.txt
│   └── top_level.txt
├── setup.cfg
└── setup.py

2 directories, 9 files

We could use setuptools.findpackages to fix this and be careful to exclude tests.

A lot of scripts are not using venvs that should be like testing, formatting, etc.

Use underscores instead of dashes in GitHub Action YAML filenames.