Powering the Python community

Our open source packages are built for the Python and Rust community and MIT licensed — and will remain so, forever.


The default data validation library for Python

from datetime import datetime
from typing import Tuple

from pydantic import BaseModel

class Delivery(BaseModel):
    timestamp: datetime
    dimensions: Tuple[int, int]

m = Delivery(timestamp='2020-01-02T03:04:05Z', dimensions=['10', '20'])
#> datetime.datetime(2020, 1, 2, 3, 4, 5, tzinfo=TzInfo(UTC))
#> (10, 20)

Pydantic is the most widely used data validation library, downloaded millions of times a day by thousands of developers all over the world.

Pydantic's success stems from its great developer experience.It's simple to use, even when doing complex things.


A new way to build web application UIs defined by declarative Python code.

  • Develop responsive apps using React, without writing a single line of JavaScript.
  • Concentrate on building magical components that are truly reusable.
from fastapi import HTTPException 
from fastui import FastUI, AnyComponent, components as c 
from fastui.components.display import DisplayMode, DisplayLookup 
from fastui.events import GoToEvent, BackEvent 

from my_app import router, fetch_users 

@router.get("/users", response_model=FastUI, response_model_exclude_none=True)
async def users_table() -> list[AnyComponent]:
    """Show a table of users"""
    users = await fetch_users()
    return [
        c.Page(  # Page provides a basic container for components
                c.Heading(text='Users', level=2),  # renders `<h2>Users</h2>`
                    # define two columns for the table
                        # the first is the users, name rendered as a link to their profile
                        DisplayLookup(field='name', on_click=GoToEvent(url='/user/{id}/')),
                        # the second is the date of birth, rendered as a date
                        DisplayLookup(field='dob', mode=DisplayMode.date),

Fast job queuing and RPC in Python with asyncio and redis.

  • Enjoy non-blocking job enqueuing and execution. Multiple jobs can run simultaneously.
  • Move fast — asyncio and no forking make Arq around 7x faster than other tools.
import asyncio

from arq import create_pool
from arq.connections import RedisSettings
from httpx import AsyncClient

async def main():
    redis = await create_pool(RedisSettings())
    for url in ('https://facebook.com', 'https://microsoft.com', 'https://github.com'):
        await redis.enqueue_job('download_content', url)

async def download_content(ctx, url):
    response = await ctx['session'].get(url)
    print(f'{url}: {response.text:.80}...')
    return len(response.text)

async def startup(ctx):
    ctx['session'] = AsyncClient()

Fast and simple datetime, date, time and duration parsing for Rust.

  • Build with total flexibility. Speedate supports multiple formats.
  • Enjoy peace of mind — all relaxations from RFC 3339 are compliant with ISO 8601.
use speedate::{DateTime, Date, Time};

fn main() {
    let dt = DateTime::parse_str("2022-01-01T12:13:14Z").unwrap();
        DateTime {
            date: Date {
                year: 2022,
                month: 1,
                day: 1,
            time: Time {
                hour: 12,
                minute: 13,
                second: 14,
                microsecond: 0,
                tz_offset: Some(0),
    println!("{}", dt.to_string()); // "2022-01-01T12:13:14Z"

The fast, iterable JSON parser with multiple interfaces.

  • Stable and battle tested, jiter is the most downloaded third party JSON parser for Python
  • Significantly faster than serde-json in most scenarios
  • Supports partial/incomplete JSON parsing, especially useful for LLM output
use jiter::JsonValue;

fn main() {
    let json_data = r#"
            \"name\": \"John Doe\",
            \"age\": 43,
            \"phones\": [
                \"+44 1234567\",
                \"+44 2345678\"
    let json_value = JsonValue::parse(json_data.as_bytes(), true).unwrap();
    println!("{:#?}", json_value);