Fable Python

Fable is a compiler that translates F# source files to JavaScript and Python.

Fable.Python provides Python type bindings for Fable, enabling you to write type-safe F# code that compiles to Python. This community-driven library includes bindings for the Python standard library and popular frameworks like Flask, FastAPI, and Pydantic.

Requirements

Python 3.12 or greater
.NET 8.0 or greater
Fable compiler

Installation

Install the Fable compiler:

dotnet tool install --global fable --prerelease
dotnet add package Fable.Core --prerelease

Add Fable.Python to your project:

dotnet add package Fable.Python

Quick Start

open Fable.Python.Json

let data = {| name = "Alice"; age = 30 |}
let jsonStr = dumps data

Compile to Python:

fable --lang Python MyProject.fsproj

Available Bindings

Python Standard Library

| Module | Description | | ----------------------- | ------------------------------------------- | | Fable.Python.Builtins | Built-in functions (open, print, len, etc.) | | Fable.Python.Json | JSON serialization with Fable type support | | Fable.Python.Os | Operating system interfaces | | Fable.Python.Sys | System-specific parameters | | Fable.Python.Math | Mathematical functions | | Fable.Python.Random | Random number generation | | Fable.Python.Logging | Logging facilities | | Fable.Python.Time | Time-related functions | | Fable.Python.String | String operations | | Fable.Python.Base64 | Base64 encoding/decoding | | Fable.Python.Queue | Queue data structures | | Fable.Python.Ast | Abstract Syntax Tree | | Fable.Python.AsyncIO | Async programming (Events, Futures, Tasks) | | Fable.Python.TkInter | GUI toolkit |

Web Frameworks

| Package | Description | | ----------------------- | ----------------------------------- | | Fable.Python.Flask | Flask web framework | | Fable.Python.FastAPI | FastAPI with automatic OpenAPI docs | | Fable.Python.Pydantic | Data validation and settings |

JSON Serialization

Fable types (like Int32, F# records, unions) need special handling for JSON serialization. Use Fable.Python.Json.dumps:

open Fable.Python.Json

type User = { Id: int; Name: string }
let user = { Id = 1; Name = "Bob" }
let json = dumps user  // {"Id": 1, "Name": "Bob"}

See JSON.md for detailed documentation on serialization patterns.

Web Framework Examples

FastAPI

open Fable.Python.FastAPI
open Fable.Python.Pydantic

[<Py.ClassAttributes(style = Py.ClassAttributeStyle.Attributes, init = false)>]
type UserResponse(Id: int, Name: string) =
    inherit BaseModel()
    member val Id: int = Id with get, set
    member val Name: string = Name with get, set

[<APIClass>]
type API() =
    [<Get("/users/{user_id}")>]
    static member get_user(user_id: int) : UserResponse =
        UserResponse(Id = user_id, Name = "Alice")

Flask

open Fable.Python.Flask
open Fable.Python.Json

[<APIClass>]
type Routes() =
    [<Get("/api/hello")>]
    static member hello() : string =
        dumps {| message = "Hello, World!" |}

Examples

The examples directory contains working applications:

| Example | Description | | ------------------------------------------ | ---------------------------------------------- | | fastapi | REST API with Pydantic models and Swagger docs | | flask | Web app with Feliz.ViewEngine HTML rendering | | django | Full Django project | | django-minimal | Single-file Django app | | pydantic | Pydantic model examples | | timeflies | Tkinter GUI with AsyncRx |

Run an example:

just example-fastapi   # FastAPI with auto-reload
just example-flask     # Flask web app
just example-timeflies # Tkinter desktop app

Development

This project uses just as a command runner and uv for Python package management.

Setup

# Install just (macOS)
brew install just

# Full setup (restore .NET and Python dependencies)
just setup

Commands

just              # Show all available commands
just build        # Build F# to Python
just test         # Run all tests (native .NET and Python)
just test-python  # Run only Python tests
just format       # Format code with Fantomas
just pack         # Create NuGet package
just clean        # Clean build artifacts

Project Structure

src/
├── stdlib/       # Python standard library bindings
├── flask/        # Flask bindings
├── fastapi/      # FastAPI bindings
├── pydantic/     # Pydantic bindings
└── jupyter/      # Jupyter bindings
test/             # Test suite
examples/         # Example applications
build/            # Generated Python output (gitignored)

Compatible Libraries

These libraries work with Fable.Python:

AsyncRx - Reactive programming
Fable.Giraffe - Giraffe port
Fable.Logging - Logging
Fable.Requests - HTTP requests
Fable.Jupyter - Jupyter notebooks
Fable.Pyexpecto - Testing
Fable.SimpleJson.Python - JSON parsing
Fable.Sedlex - Lexer generator
Feliz.ViewEngine - HTML rendering
Femto - Package management
FsToolkit.ErrorHandling - Error handling
TypedCssClasses - Type-safe CSS

Contributing

Contributions are welcome! If a type binding you need is missing, open a PR to add it.

Commit Convention

This project uses Conventional Commits for automated releases:

| Type | Description | | ---------- | ---------------------------------- | | feat | New features (bumps minor version) | | fix | Bug fixes (bumps patch version) | | docs | Documentation changes | | chore | Maintenance tasks | | refactor | Code refactoring | | test | Tests |

Breaking changes use ! (e.g., feat!: breaking change).

Adding Bindings

The src/stdlib/ directory contains Python standard library bindings. Third-party library bindings are accepted if:

The package is publicly available on PyPI
The package supports Python 3.12+
The package doesn't ship with its own type stubs

For guidance on creating bindings, see:

Fable JS Interop (patterns apply to Python)
F# Interop Guide

Import Pattern

Note that ImportAll generates a module import:

[<ImportAll("flask")>]
let flask: IExports = nativeOnly

This generates import flask, not from flask import *.

License

MIT

Fable.Python

Install / Use

README