FastCore

A foundational Python library providing core utilities for the fastai ecosystem. FastCore offers a comprehensive collection of functional programming tools, enhanced data structures, testing utilities, and system integration helpers that serve as building blocks for modern Python development.

Package Information

• Package Name: fastcore
• Version: 1.8.8
• Language: Python
• Installation: pip install fastcore
• Repository: https://github.com/fastai/fastcore

Core Imports

import fastcore

For accessing all public APIs:

from fastcore.all import *

For specific functionality:

from fastcore.basics import *      # Core utilities and data structures
from fastcore.foundation import *  # Collection classes (L) and config
from fastcore.test import *        # Testing framework
from fastcore.xtras import *       # Extended functionality
from fastcore.parallel import *    # Parallel processing
from fastcore.net import *         # Network utilities
from fastcore.meta import *        # Metaprogramming tools
from fastcore.xml import *         # HTML/XML generation

Basic Usage

Essential Utilities

from fastcore.basics import ifnone, listify, AttrDict

# Null-safe operations
result = ifnone(None, "default")  # Returns "default"
result = ifnone("value", "default")  # Returns "value"

# Convert objects to lists
items = listify("single_item")  # Returns ["single_item"]
items = listify([1, 2, 3])      # Returns [1, 2, 3]

# Dictionary with attribute access
config = AttrDict({"model": "resnet", "lr": 0.01})
print(config.model)  # Access like attribute: "resnet"
config.batch_size = 32  # Set like attribute

Enhanced Collections

from fastcore.foundation import L

# Enhanced list with functional operations
data = L([1, 2, 3, 4, 5])
filtered = data.filter(lambda x: x > 2)  # L([3, 4, 5])
mapped = data.map(lambda x: x * 2)       # L([2, 4, 6, 8, 10])
first_item = data.first()                # 1

# Chaining operations
result = L(range(10)).filter(lambda x: x % 2 == 0).map(str)
# Result: L(['0', '2', '4', '6', '8'])

Testing Framework

from fastcore.test import test_eq, test_close, test_fail

# Equality testing with informative errors
test_eq([1, 2, 3], [1, 2, 3])  # Passes
test_close(3.14159, 3.14160, eps=1e-4)  # Passes

# Exception testing
test_fail(lambda: 1/0, contains="division")  # Tests ZeroDivisionError

Architecture

FastCore is organized into focused modules that build upon each other:

Core Foundation

• basics.py: Fundamental utilities, data structures, and functional helpers
• foundation.py: Enhanced collection classes and configuration management
• imports.py: Common imports and compatibility utilities

Specialized Capabilities

• test.py: Comprehensive testing and assertion framework
• xtras.py: Extended functionality including caching, file operations, and async utilities
• parallel.py: Multi-threading and multi-processing utilities
• meta.py: Metaclasses and metaprogramming tools

Integration Tools

• net.py: HTTP utilities and networking functions
• xml.py: HTML/XML generation and manipulation
• script.py: Command-line argument parsing
• docments.py: Documentation extraction and parsing

This modular design allows developers to import only needed functionality while providing a cohesive ecosystem of tools that work seamlessly together.

Capabilities

Core Utilities and Data Structures

Fundamental utilities including null-safe operations, enhanced dictionaries, attribute access helpers, and functional programming tools that form the foundation of the fastcore ecosystem.

def ifnone(a, b): ...
def listify(o): ...
def tuplify(o): ...
class AttrDict(dict): ...
class AttrDictDefault(AttrDict): ...
def store_attr(names=None, self=None, but='', cast=False, **attrs): ...

Core Utilities

Enhanced Collections

Powerful collection classes with functional programming methods, lazy evaluation support, and advanced indexing capabilities built on top of standard Python collections.

class L(CollBase): ...
def mask2idxs(mask): ...
def is_indexer(idx): ...
class CollBase: ...

Enhanced Collections

Testing Framework

Comprehensive testing utilities with detailed error reporting, specialized assertion helpers for different data types, and utilities for testing exceptions and warnings.

def test_eq(a, b): ...
def test_close(a, b, eps=1e-5): ...
def test_fail(f, msg='', contains='', exc=Exception): ...
def test_stdout(f, exp, regex=False): ...
class ExceptionExpected: ...

Testing Framework

Extended Functionality

Advanced utilities including caching systems, file operations, async helpers, data serialization, and system integration tools for complex development scenarios.

def walk(path, symlinks=True, file_type=None, file_exts=None, **kwargs): ...
def run(cmd, *rest, same_in_win=False, ignore_ex=False, **kwargs): ...
class CachedIter: ...
def flexicache(cache_dir=None, **kwargs): ...

Extended Functionality

Parallel Processing

Multi-threading and multi-processing utilities with simplified APIs, progress tracking, and seamless integration with fastcore's functional programming patterns.

def parallel(f, items, *args, n_workers=defaults.cpus, **kwargs): ...
def threaded(process=False): ...
class ThreadPoolExecutor: ...
def parallel_gen(cls, items, n_workers=defaults.cpus, **kwargs): ...

Parallel Processing

Networking Utilities

HTTP client functionality with comprehensive error handling, URL manipulation utilities, and socket programming helpers for network-based applications.

def urlopen(url, data=None, **kwargs): ...
def urlread(url, decode=True, **kwargs): ...
def urljson(url, **kwargs): ...
def urlsave(url, dest=None, **kwargs): ...

Networking Utilities

Metaprogramming Tools

Advanced metaclasses, function signature manipulation, delegation patterns, and dynamic code generation utilities for building flexible and extensible APIs.

def delegates(to=None, keep=False, but=None): ...
class FixSigMeta: ...
class AutoInit: ...
def use_kwargs(f, **kwargs): ...

Metaprogramming

HTML/XML Generation

Programmatic HTML and XML generation with a fluent API, supporting all standard HTML elements and providing safe string handling for web development.

def ft(tag, *c, **kw): ...
class FT: ...
def Html(*c, **kwargs): ...
def to_xml(elm, lvl=0): ...

HTML/XML Generation

System Integration

Command-line argument parsing, documentation tools, file system utilities, and development aids that bridge fastcore functionality with system-level operations.

def call_parse(func=None, **kwargs): ...
class Param: ...
def docstring(sym): ...
def get_source(s): ...

System Integration

Version Information

FastCore version 1.8.8 provides stable APIs with comprehensive backward compatibility. The library follows semantic versioning and maintains API stability across minor version updates.

import fastcore
print(fastcore.__version__)  # "1.8.8"