Welcome to fastcore

Python is a powerful, dynamic language. Rather than bake everything into the language, it lets the programmer customize it to make it work for them. fastcore uses this flexibility to add to Python features inspired by other languages we’ve loved, mixins from Ruby, and currying, binding, and more from Haskell. It also adds some “missing features” and cleans up some rough edges in the Python standard library, such as simplifying parallel processing, and bringing ideas from NumPy over to Python’s list type.

Here are some tips on using fastcore:

• Use from fastcore.module import * freely. fastcore’s modules are built to be safe for wildcard imports.
• Use L in place of list. L behaves like a list, with extra indexing options, method chaining and more methods.
• Add methods to existing classes, including built-ins, with the @patch decorator instead of subclassing.
• In __init__ methods, call store_attr() to set multiple attributes at once instead of assigning each one.
• Apply the delegates decorator to show a function’s real parameters in place of **kwargs, for IDEs and generated documentation.
• Use fastcore’s versions of ThreadPoolExecutor and ProcessPoolExecutor for simpler concurrent processing.
• Prefer fastcore’s test functions, such as test_eq, test_ne and test_close, for assertions that read clearly and give informative failures.
• fastcore extends pathlib.Path with methods such as ls() and read_json().
• Convert between dictionaries and objects with attribute access using dict2obj and obj2dict.
• Write in a functional style with tools such as compose, maps and filter_ex.
• Document parameters and return values with docments, using source comments or Annotated metadata for generated APIs. MarkdownRenderer shows the effective signature and keeps usage sections such as Notes, Raises and Examples.
• Apply the timed_cache decorator to add time-based expiry to the standard lru_cache.
• Turn Python functions into command-line interfaces with fastcore.script.

For example, L is a drop-in replacement for list with extra superpowers:

x = L(1,2,3,4)
test_eq(x[[0,3]], [1,4])               # index with a collection
test_eq(x.map(lambda o:o*2), [2,4,6,8])
test_eq(x.filter(lambda o:o>2), [3,4])
x += [5]
test_eq(x.unique(), [1,2,3,4,5])

Tutorials

• Quick tour: A quick tour of a few highlights from fastcore.
• fastcore: an underrated Python library: A tour of some of the features of fastcore.
• API list: A succinct list of all functions and methods in fastcore.

Getting started

To install fastcore run: conda install fastcore -c fastai (if you use Anaconda, which we recommend) or pip install fastcore. For an editable install, clone this repo and run: pip install -e ".[dev]". fastcore is tested to work on Ubuntu, macOS and Windows (versions tested are those shown with the -latest suffix here).

fastcore contains many features, including:

• fastcore.test: Simple testing functions
• fastcore.foundation: Mixins, delegation, composition, and more
• fastcore.xtras: Utility functions to help with functional-style programming, parallel processing, and more
• fastcore.xml: HTML with ft, and case-preserving, namespace-aware XML with E factories

To get started, we recommend you read through the fastcore tour.

Contributing

After you clone this repository, please run nbdev_install_hooks in your terminal. This sets up git hooks, which clean up the notebooks to remove the extraneous stuff stored in the notebooks (e.g. which cells you ran) which causes unnecessary merge conflicts.

To run the tests in parallel, launch nbdev_test.

Before submitting a PR, check that the local library and notebooks match.

• If you made a change to the notebooks in one of the exported cells, you can export it to the library with nbdev_prepare.
• If you made a change to the library, you can export it back to the notebooks with nbdev_update.