BETSEE 1.1.1.0 (Nicer Nestor) released.

Significant changes include:

* Dependencies bumped:
  * PySide2 >= 5.12.3, the first official stable release of PySide2.
    This release is now supported by both the pip and conda packaging
    ecosystems and hence safely referenceable in this project.
* Issues resolved:
  * Python 3.8 temporarily blacklisted. As discussed at upstream issue
    PYSIDE-939, PySide2 and thus BETSEE as well is currently
    incompatible with Python 3.8.
  * Install-time Python version enforced. The minimum mandatory version
    of Python required by this project is now enforced at
    setuptools-based install time via the recently introduced
    "python_requires" setup() key in our top-level "setup.py" installer.
  * pypa/pip#6163 and pypa/pip#6434. This commit circumvents a countably
    infinite number of issues introduced by both pip 19.0.0 and 19.1.0 -
    all pertaining to PEP 517 and 518, which is to say "pyproject.toml".
    The mere existence of a "pyproject.toml" file fundamentally breaks
    pip in inexplicable and horrifying ways: a significantly worse state
    of affairs than the pre-PEP 517 and 518 days of setuptools yore. Say
    what you will of setuptools ("...so much hate"), but at least it
    sorta worked. The same cannot be said of recent pip versions, which
    absolutely do not work whatsoever. "Die, pip! Die!" Specifically:
    * pypa/pip#6163 resolved. All files and subdirectories of the
      project directory containing the top-level "setup.py" script are
      now safely registered to be importable modules and packages.
      Technically, this should not be needed. The current build
      framework (e.g., pip, setuptools) should implicitly guarantee this
      to be the case. Indeed, the obsolete setuptools-based
      "easy_install" script does so. Sadly, pip >= 19.0.0 fails to do so
      for projects defining a top-level "pyproject.toml" file. Although
      upstream purports to have resolved this, the most recent stable
      release of pip continues to suffer this. This is suffering.
    * pypa/pip#6434 resolved. The top-level "pyproject.toml" file now
      explicitly declares a default value for the "build-backend" key.
      Doing so safeguards backward compatibility with pip 19.1.0, which
      erroneously violated PEP 51{7,8} by failing to fallback to a sane
      default value in the absence of this key. If this key is left
      undeclared, pip 19.1.0 fails on attempting to perform an editable
      (i.e., developer-specific) installation of this project.
  * tox-dev/tox#765 resolved. "tox" bundles an obsolete version of
    "virtualenv" itself bundling obsolete versions of both "pip" and
    "setuptools", which obstructs sanity. Our "tox.ini" configuration
    resolves this issue by instructing "tox" to manually update both
    "setuptools" and "virtualenv" to their most recent stable releases.
  * Entry points (i.e., wrapper scripts) resolved. Specifically:
    * Windows-specific entry points installable. Entry points yet again
      install as expected under non-WSL Windows variants (i.e., vanilla,
      Cygwin Windows).
    * Dependency entry points preserved. Long-standing issues with a
      custom monkey patch applied by our top-level "setup.py" script at
      setuptools-based application installation time have now been
      resolved. Previously, this patch globally applied to all
      dependencies installed by "easy_install" (but neither "pip" nor
      "conda", which fortuitously remain unaffected). Now, this monkey
      patch only locally applies to this project and downstream
      consumers of this project (e.g., BETSEE).
  * Setuptools validation relaxed. Validation of the currently installed
    version of setuptools has been relaxed to accept recent non-standard
    version strings (e.g., "41.6.0.post20191029").
  * "all" extras installable. The "all" extra listing the set of all
    optional dependencies required by this project is now safely
    installable, as required for "tox" integration.
* Testing improved:
  * GitLab CI + "tox". Specifically:
    * Rewrote the top-level ".gitlab-ci.yml" file from the ground up to
      test both installation and runtime on all supported Python 3.x
      versions (rather than runtime on the most recent stable Python 3.x
      version) and leverage industry standards, including:
      * A test matrix exercising all official Python version-tagged
        Docker images rather than a single unofficial Python
        version-agnostic Docker image (i.e., "continuumio/anaconda3").
        Non-slim images are currently preferred to slim variants with
        names suffixed by "-slim" (e.g., "python:3.8-slim"), as the
        latter fail to include C and C++ compilers required to build and
        install wheels for Python packages both lacking official wheels
        and containing mandatory C extensions (e.g., "psutil").
      * The Python-specific "pip" and Debian-based "apt" package
        managers rather than the Anaconda-based "conda" package manager.
        An initial "apt" package cache is now explicitly created before
        attempting to install system-wide packages requiring this cache,
        including:
        * "libgl1-mesa-glx", providing the standard "libGL.so.1" shared
          library implicitly required by PySide2 Linux wheels.
      * The high-level "tox" wrapper rather than the lower-level
        "pytest" test harness.
      * The standard "virtualenv" package rather than GitLab-CI
        internals for isolating test results between different Python
        3.x versions.
      * YAML anchor-based key mapping interpolation rather than external
        scripts for resolving DRY between different Python 3.x versions.
    * Defined a top-level "tox.ini" configuration file, installing all
      optional runtime dependencies to maximize test coverage.
    * Removed the top-level "requirements-conda.txt" and
      "requirements-pip.txt" files, which were frankly superfluous.
* Documentation revised:
  * Installation instructions rewritten. These instructions have been
    revised from the ground up for simplicity, consistency, and with an
    increased emphasis on the standard pip ecosystem rather than the
    increasingly non-standard Anaconda ecosystem. Specifically:
    * "README.rst" truncated. The top-level "README.rst" file now
      provides only minimal instructions for installing BETSEE under the
      two most popular platform-agnostic package managers: pip
      (recommeded) and Anaconda.
  * pip-based editable installation. The top-level "README.rst" file now
    advises developers to leverage pip rather than setuptools when
    performing an editable installation of this project.
  * "setup.cfg"-based PyPI documentation. The top-level "setup.cfg" file
    now transcludes the contents of the top-level "README.rst" file, a
    substantial improvement over the prior code-based approach strewn
    throughout the codebase (e.g., "setup.py", "betse_setup.buputil").
* Git maintenance:
  * pip directories untracked. All top-level pip-specific temporary
    directories (e.g., "pip-wheel-metadata") are now ignored with
    respect to Git tracking.
* API generalized:
  * Generalized the top-level "setup.py" script:
    * Called the newly defined
      betsee_setup.beuputil.die_unless_setuptools_version_at_least()
      validator to ensure the currently installed version of setuptools
      satisfies all installation-time requirements.
    * Added a new "test" key-value pair to the setuptools-specific
      "extras_require" dictionary, enabling "tox" to install all
      mandatory testing requirements of this application without
      duplicating those requirements in the top-level "tox.ini" file.
  * Refactored the "betsee_setup.beupbuild" submodule to defer to the
    new "betse.lib.setuptools.command.supcmdbuild" submodule.
  * Generalized the "betsee_setup.beuputil" submodule:
    * Minimized this submodule to the smallest set of requisite
      functions required by the top-level "setup.py" script.
    * Defined a new die_unless_setuptools_version_at_least() validator.
    * Generalized the die_unless_setuptools_version_at_least() function
      to use the general-purpose "distutils.version.LooseVersion" class
      rather than the strict "distutils.version.StrictVersion" class.
  * Defined a new placeholder "betsee_test.unit.test_noop" submodule,
    defining a single placeholder test_noop() unit test guaranteed to
    pass. This submodule will be removed after defining the first
    non-placeholder test submodule, but is currently required to avoid
    "tox" test-time failures.

(Distortional contortionism exhibits surfactant bifurcations, unfurled!)

BETSEE 1.1.0.0 (Nice Nestor) released.

Significant changes include:

* Installation improvements:
  * BETSE 1.1.0 required. Each version of BETSEE now requires the same
    version of BETSE, excluding the trailing patch number of that
    version of BETSEE (e.g., BETSEE 1.1.0.0 and 1.1.0.1 both require
    BETSE 1.1.0). Since newer versions of BETSE typically break backward
    compatibility with older versions of BETSEE, this does not extend to
    newer versions of BETSE. Prior versions of BETSEE erroneously
    pretended to support arbitrary versions of BETSE.
* Runtime improvements:
  * High-DPI scaling detection. Platforms natively supporting high-DPI
    scaling are now implicitly detected at application startup, thanks
    to the newly defined betse.util.os.displays.is_dpi_scaling() tester.
* Testing improvements:
  * Top-level "test" shell script. This script has been imported
    verbatim from the BETSE codebase in preparation for eventual
    continuous integration (CI).
  * GitLab CI configuration. A first-draft implementation of a
    ".gitlab-ci.yml" file has been added to the repository. Note that
    this configuration lacks "pytest-xvfb" and "pytest-qt" support and
    hence is currently broken.
* Fatal errors resolved:
  * PYSIDE-1092. pyside2uic 5.13.0 broke backward API compatibility by
    requiring that the public
    pyside2uic.Compiler.compiler.UICompiler.__init__() method now be
    passed a new mandatory "all_pyside2_modules" parameter. Since the
    pyside2uic.__init__.compileUi() function defaults this parameter to
    simply "PySide2.__all__" (i.e., the list of all compiled PySide2 C
    extensions), it would have been trivial for Qt engineers to render
    this parameter optional via the same default. They did not; ergo, we
    do. For further details, see also:
        https://bugreports.qt.io/browse/PYSIDE-1092
  * Application shutdown exception. A fatal (albeit technically
    innocuous) exception raised at application shutdown caused by the
    now-guaranteed closure of previously open logfile handles has been
    summarily resolved.
* Deprecation warnings resolved:
  * A deprecation from the "betsee" script wrapper.
* API generalizations:
  * Generalized the "betsee.guiappmeta" submodule:
    * Overrode the late-time and thus safe BetseeAppMeta.deinit() method
      to call the betsee.util.app.guiappwindow.unset_main_window()
      function (which effectively garbage collects the entire Qt object
      stack), previously called by the early-time and thus unsafe
      betsee.gui.window.guiwindow.QBetseeMainWindow.closeEvent() method.
  * Generalized the "betsee.util.io.log.guiloghandle" submodule:
    * Refactored the "LogHandlerSignal" subclass integrating the Python
      logging API with the Qt signals and slots API:
      * Overrode the standard logging.Handler.close() method to
        explicitly nullify the signal to which this subclass forwards
        logging messages.
      * Overrode the standard logging.Handler.emit() method to silently
        reduce to a noop when this signal is nullified (i.e., when the
        close() method has been called at least once).

BETSEE 1.0.0.0 (Mighty Maxwell) released.

Significant changes include:

* Custom tissue profiles. Users may now define an arbitrary number of
  custom tissue profiles (i.e., contiguous regions of the cell cluster),
  each of which assigns all cells residing in that region the same
  simulation configuration settings -- including membrane diffusion
  constants for all available ions (e.g., sodium, potassium, chloride).
* Custom exports. Users may define an arbitrary number of custom exports
  (i.e., files saved to disk when one or more checkboxes beneath the
  "Export?" column in the "Phase Playlist" section are checked). For
  usability, the top-level tree widget now sports a nested subtree of
  export-specific tree items, complete with suitable vector-based
  iconography and human-readable tooltips. This includes:
  * Comma-separated value (CSV) files.
  * Cell cluster animations (i.e., compressed videos visualizing a
    single measurable quantity across the entire cell cluster at all
    simulation time steps).
  * Cell cluster plots (i.e., single images visualizing a single
    measurable quantity across the entire cell cluster at the last
    simulation time step).
  * Single cell plots (i.e., single images visualizing a single
    measurable quantity isolated to a single cell at all simulation time
    steps), where the cell to be visualized is selected by its uniquely
    identifying 0-based index in the currently generated cell cluster.
* Global export settings. The top-level "Export" item enables settings
  globally applicable to all custom exports to be trivially configured,
  including:
  * Cell index-centric settings,  enabling end users to configure
    whether cell indices are displayed in cell cluster visuals and the
    index of the cell to be displayed in single cell plots.
  * Matplotlib colormaps. The matplotlib-specific colormaps used to
    associate measurable quantities visualized by plots and animations
    (e.g., transmembrane potential) with color values are now globally
    configurable. This includes the default colormaps for intrinsically
    diverging, sequential, streamline, and network data.
* User-configurable tree list items. Predesignated parent items of the
  top-level tree widget (e.g., "Space/Tissue") now act as dynamically
  resizable lists of child items, each of which is associated with the
  same stacked widget page (e.g., "Custom Tissue Profile"). Likewise,
  end users may interactively add an arbitrary number of new child items
  and remove existing child items from such parent items. Additionally:
  * Automatic prepopulation and depopulation. Child tree items of such
    parent items are now dynamically added (i.e., prepopulated) and
    removed (i.e., depopulated) on opening and closing simulation
    configurations respectively.
  * Guaranteed success. Actions permitting users to append and remove
    child items to and from these lists are conditionally enabled and
    disabled, guaranteeing these actions to always succeed if enabled.
* Issue resolutions, including:
  * Infinite recursion on pushing undo commands from editable widgets.
  * Overflow error raised by "libshoken" in relation to undo command
    request handling.
  * Erroneous exceptions raised on pushing the "Browse..." buttons
    associated with all dirnames edited by the "Paths" stacked widget
    page.
  * Exceptions with empty messages, which are now displayed in a mildly
    more meaningful manner.
  * "--sim-conf-file" failures. To do so, the newly defined
    QBetseeSimConf.unload() method now provides an orthogonal analogue
    to the existing QBetseeSimConf.load() method, eliminating numerous
    awkward edge cases and subtle chiken-and-egg issues throughout the
    codebase.
* API generalizations, including:
  * The existing "betsee.gui.simconf.guisimconfundo" submodule, whose
    QBetseeSimConfUndoStack.push_undo_cmd_if_safe() method prevents undo
    commands from being pushed to this stack if no simulation
    configuration is currently open.
  * The existing "betsee.gui.simconf.stack.page" subpackage, which has
    been restructed for maintainability by:
    * Splitting all spatial-centric stacked widget pages into a new
      "betsee.gui.simconf.stack.page.space" subpackage.
    * Splitting all export-centric stacked widget pages into a new
      "betsee.gui.simconf.stack.page.export" subpackage.
  * The existing
    "betsee.gui.simconf.stack.page.space.guisimconfpagertis" submodule,
    which now defines a "QBetseeSimConfPagerTissueABC" superclass
    generally applicable to both default and custom tissue profile
    stacked widget pages.
  * The existing "betsee.gui.simconf.stack.widget.guisimconfcombobox"
    submodule. Notable new classes include:
    * "QBetseeSimConfComboBoxABC", the abstract base class of all
      simulation configuration-specific combo box subclasses.
    * "QBetseeSimConfComboBoxSequence", the concrete subclass of all
      simulation configuration-specific combo boxes backed by a simple
      sequence of raw strings.
  * The existing "betsee.gui.simconf.tree.guisimconftree" submodule,
    whose QBetseeSimConfTreeWidget._init_items() method efficiently and
    explicitly initializes all containers containing tree items,
    including those internally required by the corresponding
    "QBetseeSimConfStackedWidget" instance. This method obsoletes the
    the removed QBetseeSimConfStackedWidget._init_tree_to_stack() and
    QBetseeSimConfTreeWidget._init_items_list_root() methods.
  * The existing "betsee.util.widget.mixin.guiwdg" submodule, whose
    QBetseeObjectMixin.init() method now accepts an optional
    "is_reinitable" parameter permitting application-specific Qt objects
    to be reinitialized in a general-purpose manner. (This is strictly
    required for reinitializing each stacked widget page associated with
    a child tree item providing a dynamic list item immediately before
    that page is displayed on selecting that child tree item.)
  * The existing "betsee.util.widget.stock.tree.guitreewdg" submodule,
    whose "QBetseeTreeWidget" superclass now defines:
    * A get_item_current() method safely retrieving the currently
      selected tree item if any.
  * A new "betsee.gui.data.guidataicon" submodule, serving as an
    application-wide icon store efficiently caching instantiated icons.
    Notable functions include:
    * get_icon_dot(), caching a general-purpose bullet point icon.
  * A new "betsee.util.io.image.guiicon" submodule, providing a seamless
    cache for transparent creation, caching, and retrieval of SVG-based
    "QIcon" objects from arbitrary URIs. Notable functions include:
    * make_icon(), instantiating such icons.
  * A new "betsee.util.widget.abc.control" subpackage containing:
    * The prior "guicontrolabc" submodule, shifted for maintainability.
    * The new "guictlpagerabc" submodule, defining abstract base classes
      and mixins specific to pagers (i.e., stacked widget page
      controllers) -- all of which now subclass these abstract base
      classes and mixins as appropriate.
  * A new "betsee.util.widget.mixin.guiwdgedit" submodule, containing
    the "QBetseeEditWidgetMixin" superclass previously contained within
    the "betsee.util.widget.mixin.guiwdg" submodule. Subclasses of this
    superclass are now required to override the recursion-safe
    _init_safe() method rather than the recursion-unsafe init() method.
  * A new "betsee.util.widget.stock.guicombobox" submodule, whose
    "QBetseeComboBox" superclass generalizes the stock "QComboBox" API
    with improved Pythonics.
  * A new "betsee.util.widget.stock.tree.guitreeitem" submodule
    implementing a high-level tree widget item API encapsulating Qt's
    considerably lower-level "QTreeWidgetItem" API. Notable functions
    include:
    * get_child_item_with_text_path(), enabling callers to obtain
      arbitrary tree items via their absolute first-column text paths
      (i.e., the unique sequence of the first-column text of all items
      leading to the desired tree item, including itself).
    * get_item_preceding_or_none(), contextually retrieving the tree
      item preceding any arbitrary tree item.
  * A new "betsee.util.path.guipathenum" submodule, defining one global
    integer bit mask constant for each Qt-specific "QFileDialog::Option"
    enumeration member, enabling the codebase to trivially enable path
    dialag options in a Pythonic manner. Notably, the
    "betsee.util.path.guidir" and "betsee.util.path.guipath" submodules
    now leverage these constants.

BETSEE 0.9.2.0 (Luckiest Levin) released.

Significant changes include:

* Simulation configuration dialog improvements. Dialogs creating,
  opening, and saving simulation configuration files have been
  significantly sanitized, generalized, and improved across the board.
  Significant changes include:
  * Previously selected dirname persisted. The absolute dirname of the
    most recently selected directory (i.e., the directory containing the
    simulation configuration file selected by the most recent path
    dialog) is now globally persisted to the on-disk backing store of
    application settings and reused as the initially selected directory
    to which the next path dialog opens by default. This dirname is
    persisted across application invocations, effectively serving as a
    poor man's substitute for the traditional "File->Recent..." menu of
    recently opened files in standard desktop GUI applications,
    substantially improving usability.
  * Default selected basename sanitized. The basenames of the files
    opened and saved by the "File->New Simulation..." and "File->Save
    Simulation As..." dialogs now default to sanely YAML-compliant
    basenames (e.g., "sim_config.yaml"), improving usability.
  * Default selected directory safeguarded. The directory to which all
    path dialogs open by default is now effectively guaranteed to exist
    (ignoring filesystem race conditions), significantly improving
    sanity.
  * Simulation configurations creatable. Issue #5, kindly reported by
    the ever-faithful Eric Sinton in exhaustive detail, has now been
    resolved. The "File->New Simulation..." path dialog correctly
    creates new simulation configurations as expected. Thanks, Eric!
* Dependency initialization sanitized. Third-party application
  dependencies (e.g., PySide2) are now initialized correctly by the
  object-oriented application metadata singleton (i.e., instance of the
  "betse.util.app.meta.metaappabc.MetaAppABC" superclass) rather than
  procedurely by the antiquated "betsee.lib.guilib" submodule.
* Pip-based installation improved. Setuptools >= 38.2.0, which first
  introduced support for wheels, is now hard-required at installation
  time. Since the Qt Company necessarily distributes PySide2 (the
  principal mandatory dependency of this application) via universal
  wheels, this application always effectively required setuptools 38.2.0
  or newer at installation. This constraint is now contractually
  enforced, substantially improving end user experience (UX) under older
  systems.
* Application settings API generalized. The existing
  "betsee.util.io.guisettings" submodule now offers the full gamut of
  exception handlers, testers, getters, and setters for manipulating
  individual settings persisted to this application's settings store.

BETSEE 0.9.1.0 (Luckier Levin) released.

Significant changes include:

* The "--cache-policy" command-line option, allowing developers, end
  users, and automated tests to enable alternative XML->Python caching
  strategies. Internally, BETSEE converts XML-formatted Qt
  (Creater|Designer) user interface (UI) files residing under the
  "betsee.data" subpackage into PySide2-based Python submodules residing
  under one of two subpackages:
  * "betsee.data.py", the application-wide cache containing the official
    versions of these submodules bundled with BETSEE itself.
  * "~/.betsee/py", the user-specific cache containing strictly
    unofficial versions of these submodules *NOT* bundled with BETSEE
    itself.
  In both cases, BETSEE itself dynamically regenerates these submodules
  at runtime as needed. The mandatory argument passed to this optional
  option dictates which of these submodules if any are actually
  regenerated:
  * "--cache-policy=dev", the developer-specific caching policy. Under
    this strategy, both the application-wide *AND* user-specific caches
    are regenerated as needed. Raised exceptions are treated as fatal
    errors.
  * "--cache-policy=dev", the end user-specific caching policy. Under
    this strategy, *ONLY* the user-specific cache is regenerated. If any
    exception is raised while doing so, that exception is logged as a
    non-fatal warning and the corresponding submodule from the
    application-wide cache is copied into the user-specific cache --
    ensuring that the latter always exists.
  * "--cache-policy=auto", the default caching policy. This strategy
    detects whether or not BETSEE is currently installed in development
    mode (i.e., tracked by a Git working tree), in which case the
    developer-specific caching policy is deferred to; else, the end
    user-specific caching policy is deferred to.
* Issue #1 (i.e., "Startup Error") resolved. For both portability and
  efficiency reasons, BETSEE only officially supports the
  (Ana|Mini)conda Python distribution. This support is provided by the
  conda-forge "betsee-feedstock," which necessarily depends on the
  conda-forge "pyside2-feedstock," whose most recent release installs
  only the Qt 5.6.0 pre-pre-release version of PySide2, which predates
  the official Qt 5.11.2 "technical preview" pre-release version of
  PySide2 produced in late Septemeber of this year by the Qt Company.
  Unsurprisingly, the pre-pre-release version of PySide2 distributed by
  (Ana|Mini)conda suffers various game-breaking deficiencies, including
  the failure of the "pyside2uic" package to convert Qt
  (Creater|Designer) user interface (UI) XML files into working
  PySide2-based Python logic. This core defect is circumvented by the
  new by the new "--cache-policy" option, which contextually ignores
  failures during cache regeneration when run as an end user.
* Issue #2 (i.e., "New Simulation Error") resolved. This release
  circumvents a trivial backward incompatibility with the Qt 5.6 API:
  notably, the failure of Qt < 5.7.0 to pass the "checked" boolean to
  slots connected to the prevalent "QAction.triggered" signal.
* Caching API centralized. Caching-specific logic previously distributed
  throughout the codebase (e.g., the "betsee.gui.guicache" submodule,
  the "betsee.util.io.xml" subpackage) has now been centralized into the
  new "betse.lib.pyside2.cache" subpackage for maintainability.
* Pathtree -> MetaAppABC API. The prior procedural-based
  "betsee.guipathtree" submodule has been refactored into the
  object-oriented "betsee.guimetaapp" submodule leveraging the newly
  minted "betse.util.meta.metaappabc" API, reducing DRY (i.e., "Don't
  Repeat Yourself") violations across both codebases.
* Test suite planning. This release also adds the rudimentary outline
  for what will subsequently be developed into a full-blown continuous
  integration (CI) test suite. While currently non-working, something
  >>>>>>>> nothing.

Thanks to Eric Sinton (@esinton) for voluminously documenting both
issues and supplying an ad-hoc solution for the first issue. Our
userbase rocks!

BETSEE 0.9.0.0 (Lucky Levin) released.

Significant changes include:

* Python >= 3.5 required. In accordance with the looming end-of-life
  (EOL) of Python 3.4, BETSEE now strictly requires at least Python 3.5.
* Simulator phase queueing. Simulator phases (e.g., seed, simulation)
  may now be independently queued and dequeued such that the end user
  clicking the simulator-specific start button now sequentially runs
  each currently queued simulator phase.
* Simulator phase running. Simulator phases (e.g., seed, simulation)
  may now be independently run, paused, resumed, and stopped in a robust
  manner leveraging our newly introduced thread pool API.
* Simulator progress. Feedback metadata is now contextually displayed
  (in quasi-realtime) for the current simulator state:
  * Percentage-based progress.
  * Human-readable terse status.
  * Human-readable verbose substatus.
* Simulator widget synchronization. The internal state of all simulator
  widgets is now explicitly synchronized against the external state of
  both the simulator as a whole and the currently running simulator
  phase if any, substantially improving the User eXperience (UX).
* Placeholder text excised. Placeholder simulation configuration tree
  items (e.g., "Dynamic Channels", "Network") have now been dynamically
  pruned at runtime, dramatically improving usability.
* Font sizes normalized. The BETSEE GUI was initially developed on a
  high-DPI system, which understandably resulted in substantially
  smaller font sizes than desirable on standard DPI systems. Font sizes
  are now normalized to conform to standard aesthetic expectations.
* Stylesheet simplified. The global application stylesheet has now been
  sanitized, simplified, and streamlined: AKA, 3S.
* Thread pool API. The new "betsee.util.thread.pool" subpackage now
  implements a rather efficient, portable, multithreaded framework for
  independently starting, stopping, pausing, and resuming an arbitrary
  number of arbitrary long-running threads. This framework largely
  obsoletes all prevailing low- and high-level Python and Qt
  parallelization APIs, including (but presumably not limited to):
  * "multiprocessing.dummy".
  * "threading".
  * "PySide2.QtConcurrent".
  * "PySide2.QtCore.QFuture".
  * "PySide2.QtCore.QRunnable".
  * "PySide2.QtCore.QThread".
  * "PySide2.QtCore.QThreadPool".
  Note that this framework is effectively unencumbered by the Global
  Interpreter Lock (GIL), assuming worker threads that routinely defer
  to the canonical QBetseeThreadPoolWorker._halt_work_if_requested()
  method to enable user responsiveness. Naturally, all BETSEE-specific
  worker threads satisfy this sensible constraint.
* Installation instructions conda-fied. Installation instructions have
  been significantly streamlined to leverage the newly released Anaconda
  package for BETSEE, kindly hosted by the non-profit conda-forge
  organization. The obsolete Ubuntu-specific installation script has
  been removed.

BETSEE 0.8.2.0 (Kindest Kaufmann) released.

Significant changes include:

* Setuptools-based installation sanitized. PySide2 is no longer
  erroneously required at pre-installation time, thus resolving a
  significant blocker for distribution by PyPI and conda-forge.
* Startup dependency validation sanitized. The application startup process
  now validates the satisfiability (i.e., the importability and sufficient
  version) of BETSE only once rather than twice, thus resolving
  discrepancies between setuptools-specific versioning for BETSE and the
  actual physical version of BETSE on developer machines.
* Startup errors displayed graphically. Fatal exceptions raised on
  startup are now embedded within a PySide2-based message box.

BETSEE 0.8.1.0 (Kinder Kaufmann) released.

This marks the first stable release of BETSEE. Significant features
include:

* Creatable simulations. New simulation configurations are trivially
  creatable from within the BETSEE GUI.
* Loadable and savable simulations. Existing simulation configurations
  are trivially loaded and saved from within the BETSEE GUI.
* Partially editable simulations. While numerous simulation
  configuration options remain unsupported, this initial release
  attempts to support the most essential such options (e.g., world size,
  simulation duration).
* Partially runnable simulations. While running specific simulation
  phases (e.g., seed) remains unsupported, this initial release does
  support running all simulation phases in a sequential manner. Each
  such run is isolated to an effectively backgrounded thread preserving
  the usability of the foregrounded GUI.
* Partially visualized simulation runs. Visualization of the currently
  running simulation phase is limited to:
  * Partially updated progress. A progress bar reflects the current
    state of work completed for the current phase. Only the seed,
    initialization, and simulation phases update progress; exporting
    phases (e.g., "betse plot seed") all ignore progress, currently.