MOOSE Tools Software Library List

Introduction

A software library is defined here as library that is integral to the ability to software being developed. This document lists libraries that are used by MOOSE Tools.

NumPy

MOOSE Tools relies on NumPy, which is summarized as follows on the project website: https://numpy.org.

NumPy is the fundamental package for scientific computing with Python. Fast and versatile, the NumPy vectorization, indexing, and broadcasting concepts are the de-facto standards of array computing today. NumPy offers comprehensive mathematical functions, random number generators, linear algebra routines, Fourier transforms, and more.

Matplotlib

MOOSE Tools relies on Matplotlib, which is summarized as follows on the project website: https://matplotlib.org.

Matplotlib is a comprehensive library for creating static, animated, and interactive visualizations in Python.

Pandas

MOOSE Tools relies on pandas, which is summarized as follows on the project website: https://pandas.pydata.org.

pandas is a fast, powerful, flexible and easy to use open source data analysis and manipulation tool, built on top of the Python programming language.

PyYAML

MOOSE Tools relies on PyYAML, which is summarized as follows on the project website: https://pyyaml.org/wiki/PyYAML.

PyYAML is a YAML parser and emitter for the Python programming language.

LibYAML

MOOSE Tools relies on LibYAML, which is summarized as follows on the project website: https://pyyaml.org/wiki/LibYAML.

LibYAML is a YAML parser and emitter library for C.

Lxml

MOOSE Tools relies on lxml, which is summarized as follows on the project website: https://lxml.de/.

lxml is the most feature-rich and easy-to-use library for processing XML and HTML in the Python language.

Scikit-image

MOOSE Tools relies on scikit-image, which is summarized as follows on the project website: https://scikit-image.org/.

scikit-image is a collection of algorithms for image processing in Python.

SymPy

MOOSE Tools relies on SymPy, which is summarized as follows on the project website: https://www.sympy.org/en/index.html.

SymPy is a Python library for symbolic mathematics. It aims to become a full-featured computer algebra system (CAS) while keeping the code as simple as possible in order to be comprehensible and easily extensible. SymPy is written entirely in Python.

DeepDiff

MOOSE Tools relies on DeefDiff, which is summarized as follows on the project website: https://zepworks.com/deepdiff/current/index.html.

DeepDiff returns the deep difference of (Python) dictionaries, iterables, strings, and almost any other object. It will recursively look for all the changes.

Pylatexenc

MOOSE Tools relies on pylatexenc, which is summarized as follows on the project website: https://pylatexenc.readthedocs.io/en/latest/.

A simple LaTeX parser providing latex-to-unicode and unicode-to-latex conversion.

Jinja2

MOOSE Tools relies on Jinja2, which is summarized as follows on the project website: https://palletsprojects.com/p/jinja/

Jinja2 is a full-featured template engine for Python. It has full unicode support, an optional integrated sandboxed execution environment, widely used and BSD licensed.

Mako

MOOSE Tools relies on Mako, which is summarized as follows on the project website: https://www.makotemplates.org/.

Mako is a template library written in Python. It provides a familiar, non-XML syntax which compiles into Python modules for maximum performance. Mako's syntax and API borrows from the best ideas of many others, including Django and Jinja2 templates, Cheetah, Myghty, and Genshi. Conceptually, Mako is an embedded Python (i.e. Python Server Page) language, which refines the familiar ideas of componentized layout and inheritance to produce one of the most straightforward and flexible models available, while also maintaining close ties to Python calling and scoping semantics.

Setuptools

MOOSE Tools relies on setuptools, which is summarized as follows on the project website: https://setuptools.pypa.io/en/latest/:

Setuptools is a fully-featured, actively-maintained, and stable library designed to facilitate packaging Python projects. It helps developers to easily share reusable code (in the form of a library) and programs (e.g., CLI/GUI tools implemented in Python), that can be installed with pip and uploaded to PyPI.

Graphviz

MOOSE Tools relies on Graphviz, which is summarized as follows on the project website: https://github.com/xflr6/graphviz.

This package facilitates the creation and rendering of graph descriptions in the DOT language of the Graphviz graph drawing software from Python.

Create a graph object, assemble the graph by adding nodes and edges, and retrieve its DOT source code string. Save the source code to a file and render it with the Graphviz installation of your system.

Use the view option/method to directly inspect the resulting (PDF, PNG, SVG, etc.) file with its default application. Graphs can also be rendered and displayed within Jupyter notebooks (formerly known as IPython notebooks) as well as the Jupyter QtConsole.

Pylint

MOOSE Tools relies on Pylint, which is summarized as follows on the project website: https://pylint.readthedocs.io/en/latest/

Pylint is a static code analyser for Python 2 or 3. The latest version supports Python 3.7.2 and above.

Pylint analyses your code without actually running it. It checks for errors, enforces a coding standard, looks for code smells, and can make suggestions about how the code could be refactored. Pylint can infer actual values from your code using its internal code representation (astroid). If your code is import logging as argparse, Pylint will know that argparse.error(...) is in fact a logging call and not an argparse call.

Psycopg

MOOSE Tools relies on Psycopg, which is summarized as follows on the project website: https://www.psycopg.org/.

Psycopg is the most popular PostgreSQL adapter for the Python programming language. Its core is a complete implementation of the Python DB API 2.0 specifications. Several extensions allow access to many of the features offered by PostgreSQL.

Pycobertura

MOOSE Tools relies on pycobertura, which is summarized as follows on the project website: https://github.com/aconrad/pycobertura.

pycobertura is a generic Cobertura report parser. It was also designed to help prevent code coverage from decreasing with the pycobertura diff command: any line changed should be tested and uncovered changes should be clearly visible without letting legacy uncovered code get in the way so developers can focus solely on their changes.

Requests

MOOSE Tools relies on requests, which is summarized as follows on the project website: https://requests.readthedocs.io/en/latest/.

Requests allows you to send HTTP/1.1 requests extremely easily. There’s no need to manually add query strings to your URLs, or to form-encode your POST data. Keep-alive and HTTP connection pooling are 100% automatic, thanks to urllib3.

Tabulate

MOOSE Tools relies on tabulate, which is summarized as follows on the project website: https://github.com/astanin/python-tabulate.

Pretty-print tabular data in Python, a library and a command-line utility. The main use cases of the library are:

(1) printing small tables without hassle: just one function call, formatting is guided by the data itself.

(2) authoring tabular data for lightweight plain-text markup: multiple output formats suitable for further editing or transformation.

(3) readable presentation of mixed textual and numeric data: smart column alignment, configurable number formatting, alignment by a decimal point.

GitPython

MOOSE Tools relies on GitPython, which is summarized as follows on the project website: https://github.com/gitpython-developers/GitPython.

GitPython is a python library used to interact with git repositories, high-level like git-porcelain, or low-level like git-plumbing.

It provides abstractions of git objects for easy access of repository data, and additionally allows you to access the git repository more directly using either a pure python implementation, or the faster, but more resource intensive git command implementation.

The object database implementation is optimized for handling large quantities of objects and large datasets, which is achieved by using low-level structures and data streaming.

Packaging

MOOSE Tools relies on Packaging, which is summarized as follows on the project website: https://github.com/pypa/packaging.

Reusable core utilities for various Python Packaging interoperability specifications.

This library provides utilities that implement the interoperability specifications which have clearly one correct behaviour (eg: PEP 440) or benefit greatly from having a single shared implementation (eg: PEP 425).

The packaging project includes the following: version handling, specifiers, markers, requirements, tags, utilities.

Pyflakes

MOOSE Tools relies on Pyflakes, which is summarized as follows on the project website: https://github.com/PyCQA/pyflakes.

A simple program which checks Python source files for errors.

Pyflakes analyzes programs and detects various errors. It works by parsing the source file, not importing it, so it is safe to use on modules with side effects. It's also much faster.

It is available on PyPI and it supports all active versions of Python: 3.6+.

Xmltodict

MOOSE Tools relies on xmltodict, which is summarized as follows on the project website: https://github.com/martinblech/xmltodict.

xmltodict is a Python module that makes working with XML feel like you are working with JSON, as in this "spec".

Beautiful Soup

MOOSE Tools relies on Beautiful Soup, which is summarized as follows on the project website: https://www.crummy.com/software/BeautifulSoup/

Beautiful Soup is a Python library designed for quick turnaround projects like screen-scraping. Three features make it powerful:

(1) Beautiful Soup provides a few simple methods and Pythonic idioms for navigating, searching, and modifying a parse tree: a toolkit for dissecting a document and extracting what you need. It doesn't take much code to write an application.

(2) Beautiful Soup automatically converts incoming documents to Unicode and outgoing documents to UTF-8. You don't have to think about encodings, unless the document doesn't specify an encoding and Beautiful Soup can't detect one. Then you just have to specify the original encoding.

(3) Beautiful Soup sits on top of popular Python parsers like lxml and html5lib, allowing you to try out different parsing strategies or trade speed for flexibility.

LiveReload

MOOSE Tools relies on LiveReload, which is summarized as follows on the project website: https://github.com/lepture/python-livereload.

Reload webpages on changes, without hitting refresh in your browser.

Pybtex

MOOSE Tools relies on Pybtex, which is summarized as follows on the project website: https://pybtex.org/.

Pybtex is a BibTeX-compatible bibliography processor written in Python. You can simply type pybtex instead of bibtex.

Mock

MOOSE Tools relies on Mock, which is summarized as follows on the project website: https://mock.readthedocs.io/en/latest/.

mock is a library for testing in Python. It allows you to replace parts of your system under test with mock objects and make assertions about how they have been used.