Flet

https://flet.dev/docs/
Admin
Flet is a framework that allows building multi-platform web, desktop, and mobile applications in...
Tokens:1,120,454
Snippets:12,907
Trust Score:9.3
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Enable Examples tool group with FLET_MCP_ENABLE_EXAMPLES

Source: https://flet.dev/docs/cookbook/flet-mcp

Enables the Examples tool group by setting `FLET_MCP_ENABLE_EXAMPLES=1` before starting the server. Accepted truthy values are `1`, `true`, and `yes` (case-insensitive). The active groups are surfaced in the server's startup instructions.

```bash
FLET_MCP_ENABLE_EXAMPLES=1 flet mcp  
```

--------------------------------

### WebView example

Source: https://flet.dev/docs/controls/webview

Creates a Flet app that displays the flet.dev website in a WebView, with callbacks for page start, page end, and web resource errors.

```python
import flet as ft

import flet_webview as fwv



def main(page: ft.Page):

    page.add(

        ft.SafeArea(

            expand=True,

            content=fwv.WebView(

                url="https://flet.dev",

                on_page_started=lambda _: print("Page started"),

                on_page_ended=lambda _: print("Page ended"),

                on_web_resource_error=lambda e: print("WebView error:", e.data),

                expand=True,

            ),

        )

    )



if __name__ == "__main__":

    ft.run(main)
```

--------------------------------

### Inspect and install the .deb package

Source: https://flet.dev/docs/publish/linux

Check the contents of the .deb package, install it with apt, and run the installed application. The package is built for arm64 and the commands are run from the project root.

```bash
dpkg -c build/my-app_1.0.0_arm64.deb  

sudo apt install ./build/my-app_1.0.0_arm64.deb  

my-app  

```

--------------------------------

### Audio Recorder Basic Example

Source: https://flet.dev/docs/services/audiorecorder

Demonstrates a complete audio recorder app using flet_audio_recorder. It includes start, stop, pause, resume, device listing, WAV encoder support check, and permission status. The stop handler launches the output URL on web. Requires the flet_audio_recorder package.

```python
import flet as ft  

import flet_audio_recorder as far  

  

  

def main(page: ft.Page):  
    page.horizontal_alignment = ft.CrossAxisAlignment.CENTER  
    page.appbar = ft.AppBar(title=ft.Text("Audio Recorder"), center_title=True)  

    path = "test-audio-file.wav"  

    def show_snackbar(message):  
        page.show_dialog(ft.SnackBar(ft.Text(message)))  

    async def handle_recording_start(e: ft.Event[ft.Button]):  
        show_snackbar("Starting recording...")  
        await recorder.start_recording(output_path=path)  

    async def handle_recording_stop(e: ft.Event[ft.Button]):  
        output_path = await recorder.stop_recording()  
        show_snackbar(f"Stopped recording. Output Path: {output_path}")  
        if page.web and output_path is not None:  
            await ft.UrlLauncher().launch_url(output_path)  

    async def handle_list_devices(e: ft.Event[ft.Button]):  
        o = await recorder.get_input_devices()  
        show_snackbar(f"Input Devices: {', '.join([f'{d.id}:{d.label}' for d in o])}")  

    async def handle_has_permission(e: ft.Event[ft.Button]):  
        try:  
            status = await recorder.has_permission()  
            show_snackbar(f"Audio Recording Permission status: {status}")  
        except Exception as e:  
            show_snackbar(f"Error checking permission: {e}")  

    async def handle_pause(e: ft.Event[ft.Button]):  
        print(f"isRecording: {await recorder.is_recording()}")  
        if await recorder.is_recording():  
            await recorder.pause_recording()  

    async def handle_resume(e: ft.Event[ft.Button]):  
        print(f"isPaused: {await recorder.is_paused()}")  
        if await recorder.is_paused():  
            await recorder.resume_recording()  

    async def handle_audio_encoder_test(e: ft.Event[ft.Button]):  
        print(await recorder.is_supported_encoder(far.AudioEncoder.WAV))  

    recorder = far.AudioRecorder(  
        configuration=far.AudioRecorderConfiguration(encoder=far.AudioEncoder.WAV),  
        on_state_change=lambda e: print(f"State Changed: {e.data}"),  
    )  

    page.add(  
        ft.SafeArea(  
            content=ft.Column(  
                controls=[  
                    ft.Button(  
                        content="Start Audio Recorder", on_click=handle_recording_start  
                    ),  
                    ft.Button(  
                        content="Stop Audio Recorder", on_click=handle_recording_stop  
                    ),  
                    ft.Button(content="List Devices", on_click=handle_list_devices),  
                    ft.Button(content="Pause Recording", on_click=handle_pause),  
                    ft.Button(content="Resume Recording", on_click=handle_resume),  
                    ft.Button(  
                        content="WAV Encoder Support",  
                        on_click=handle_audio_encoder_test,  
                    ),  
                    ft.Button(  
                        content="Get Audio Recording Permission Status",  
                        on_click=handle_has_permission,  
                    ),  
                ],  
            ),  
        )  
    )  

  

if __name__ == "__main__":  
    ft.run(main)  
```

--------------------------------

### Start video recording

Source: https://flet.dev/docs/controls/camera

Starts video recording after verifying the camera is initialized. Prepares the preview, starts recording, updates state flags, syncs action buttons, and sets the status message.

```python
if not state.is_initialized:  
    status.value = "Initialize camera first"  
    page.update()  
    return  
await preview.prepare_for_video_recording()  
await preview.start_video_recording()  
state.is_recording = True  
state.is_recording_paused = False  
sync_action_buttons()  
status.value = "Recording video..."  
page.update()
```

--------------------------------

### Install uv on macOS, Linux, and Windows

Source: https://flet.dev/docs/getting-started/installation

Install uv, a fast Python package and project manager, using the provided curl or PowerShell commands. This is the only installation step needed; no separate Flet installation or virtual environment creation is required.

```bash
# macOS and Linux  

curl -LsSf https://astral.sh/uv/install.sh | sh  

  

# Windows  

powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"  

```

--------------------------------

### Install desktop entry and icon for current user

Source: https://flet.dev/docs/publish/linux

Run from the bundle directory to register the app for the current user. Replace `<executable>` and `<bundle_id>`. Keep quotes around `Exec=` to avoid path splitting. A system-wide install to `/usr/share` works the same way.

```bash
cp -r share/. ~/.local/share/  

sed -i "s|^Exec=.*|Exec=\"$PWD/<executable>\" %U|" ~/.local/share/applications/<bundle_id>.desktop  

update-desktop-database ~/.local/share/applications  

```

--------------------------------

### PermissionHandler usage example

Source: https://flet.dev/docs/services/permissionhandler

Complete example showing how to use PermissionHandler to get status, request permission, and open app settings for the microphone permission.

```python
import flet as ft

import flet_permission_handler as fph



def main(page: ft.Page):
    page.appbar = ft.AppBar(title="PermissionHandler Playground")

    def show_snackbar(message: str):
        page.show_dialog(ft.SnackBar(ft.Text(message)))

    async def get_permission_status(e: ft.Event[ft.OutlinedButton]):
        status = await ph.get_status(fph.Permission.MICROPHONE)
        show_snackbar(f"Microphone permission status: {status.name}")

    async def request_permission(e: ft.Event[ft.OutlinedButton]):
        status = await ph.request(fph.Permission.MICROPHONE)
        show_snackbar(f"Requested microphone permission: {status.name}")

    async def open_app_settings(e: ft.Event[ft.OutlinedButton]):
        show_snackbar("Opening app settings...")
        await ph.open_app_settings()

    ph = fph.PermissionHandler()

    page.add(
        ft.SafeArea(
            content=ft.Column(
                controls=[
                    ft.OutlinedButton("Open app settings", on_click=open_app_settings),
                    ft.OutlinedButton(
                        "Request Microphone permission", on_click=request_permission
                    ),
                    ft.OutlinedButton(
                        "Get Microphone permission status",
                        on_click=get_permission_status,
                    ),
                ],
            ),
        )
    )


if __name__ == "__main__":
    ft.run(main)
```

--------------------------------

### Lambda starting async task with asyncio.create_task

Source: https://flet.dev/docs/cookbook/async-apps

A lambda can start async work by scheduling a task on the running loop. This example kicks off the reload coroutine without awaiting it.

```python
ft.Button(content="Reload", on_click=lambda e: asyncio.create_task(reload(e)))
```

--------------------------------

### flet build --permissions example

Source: https://flet.dev/docs/publish

Command-line example showing how to specify permissions for a build using the --permissions flag with the location and microphone bundles.

```bash
flet build <target_platform> --permissions location microphone  

```

--------------------------------

### List and start emulators, list devices (uv)

Source: https://flet.dev/docs/getting-started/integration-testing

Commands to list available emulators, start one, and list running devices with uv.

```bash
uv run flet emulators              # list available emulators

uv run flet emulators start <id>   # start an emulator

uv run flet devices                # list running devices and their ids
```

--------------------------------

### Get all keys with prefix

Source: https://flet.dev/docs/cookbook/client-storage

Retrieve all keys that start with the given prefix using get_keys.

```python
await prefs.get_keys("key-prefix.")
```

--------------------------------

### List and start emulators, list devices (pip)

Source: https://flet.dev/docs/getting-started/integration-testing

Commands to list available emulators, start one, and list running devices with pip-installed flet.

```bash
flet emulators              # list available emulators

flet emulators start <id>   # start an emulator

flet devices                # list running devices and their ids
```

--------------------------------

### Shimmer example with SafeArea

Source: https://flet.dev/docs/controls/shimmer

Full example showing a Shimmer inside a SafeArea, using a helper function to create placeholder tiles. Demonstrates the complete main function and page setup.

```python
import flet as ft  

  

def main(page: ft.Page):  

    page.add(  

        ft.SafeArea(  

            content=ft.Shimmer(  

                base_color=ft.Colors.with_opacity(0.3, ft.Colors.GREY_400),  

                highlight_color=ft.Colors.WHITE,  

                content=ft.Column(  

                    controls=[  

                        ft.Container(height=80, bgcolor=ft.Colors.GREY_300),  

                        ft.Container(height=80, bgcolor=ft.Colors.GREY_300),  

                        ft.Container(height=80, bgcolor=ft.Colors.GREY_300),  

                    ],  

                ),  

            )  

        )  

    )  

  

  

if __name__ == "__main__":  

    ft.run(main)  
```

--------------------------------

### Build example app for macOS

Source: https://flet.dev/docs/extend/user-extensions

Builds the example app for macOS with verbose output. Run this command from the folder containing the app's pyproject.toml (examples/flet_spinkit_example).

```bash
flet build macos -v  
```

--------------------------------

### ShaderMask pink radial glow example

Source: https://flet.dev/docs/controls/shadermask

Example of a ShaderMask with a pink radial glow effect. The code is incomplete in the source, showing only the start of the main function and a SafeArea with a Row containing an Image control.

```python
import flet as ft  

  

  

def main(page: ft.Page):  

    page.add(  

        ft.SafeArea(  

            content=ft.Row(  

                controls=[  

                    ft.Image(  
```

--------------------------------

### Launch Mode showcase example

Source: https://flet.dev/docs/types/launchmode

This example creates a UI to check support for each LaunchMode on the current platform. It uses ft.UrlLauncher to query supports_launch_mode and supports_close_for_launch_mode, displaying the results. The example is run with ft.run(main).

```python
import flet as ft  

  

def main(page: ft.Page):  
    page.horizontal_alignment = ft.CrossAxisAlignment.CENTER  
    launcher = ft.UrlLauncher()  

    def showcase_card(mode: ft.LaunchMode) -> ft.Container:  
        status = ft.Text("Click to check support on this platform.", size=11)  

        async def check_support():  
            try:  
                supported = await launcher.supports_launch_mode(mode)  
                closable = await launcher.supports_close_for_launch_mode(mode)  
                status.value = (  
                    f"supports_launch_mode={supported} / supports_close={closable}"  
                )  
            except Exception as ex:  
                status.value = f"Error: {ex}"  
            status.update()  

        return ft.Container(  
            width=360,  
            padding=12,  
            border=ft.Border.all(1, ft.Colors.RED),  
            border_radius=10,  
            bgcolor=ft.Colors.SURFACE_CONTAINER_LOW,  
            content=ft.Column(  
                spacing=8,  
                controls=[  
                    ft.Text(mode.name, weight=ft.FontWeight.BOLD),  
                    ft.Button(  
                        "Check support",  
                        icon=ft.Icons.CHECK_CIRCLE_OUTLINE,  
                        on_click=lambda: page.run_task(check_support),  
                    ),  
                    status,  
                ],  
            ),  
        )  

    page.appbar = ft.AppBar(title="LaunchMode Showcase")  
    page.add(  
        ft.SafeArea(  
            expand=True,  
            content=ft.Column(  
                controls=[  
                    ft.Text(  
                        "Check launch-mode support reported by the current platform."  
                    ),  
                    ft.Row(  
                        wrap=True,  
                        spacing=12,  
                        expand=True,  
                        scroll=ft.ScrollMode.AUTO,  
                        alignment=ft.MainAxisAlignment.CENTER,  
                        controls=[showcase_card(mode) for mode in ft.LaunchMode],  
                    ),  
                ],  
            ),  
        )  
    )  


if __name__ == "__main__":  
    ft.run(main)  
```

--------------------------------

### logout method signature

Source: https://flet.dev/docs/controls/page

Clears the current authentication context. See the Authentication guide for more information and examples.

```python
logout() -> None
```

--------------------------------

### initialize method

Source: https://flet.dev/docs/controls/camera

Initializes a new camera controller for the given description.

```python
initialize(
    description: CameraDescription,
    resolution_preset: ResolutionPreset,
    enable_audio: bool = True,
    fps: int | None = None,
    video_bitrate: int | None = None,
    audio_bitrate: int | None = None,
    image_format_group: ImageFormatGroup | None = None,
)
```

--------------------------------

### Window hidden on start with ft.AppView.FLET_APP_HIDDEN

Source: https://flet.dev/docs/controls/page

Starts a Flet desktop app with the window hidden using ft.AppView.FLET_APP_HIDDEN, performs setup (resize, center) while hidden, then shows the window after a delay. Useful for initial configuration before the user sees the window.

```python
import asyncio

import flet as ft


async def main(page: ft.Page):
    print("Window is hidden on start. Will show after 3 seconds...")
    page.add(
        ft.SafeArea(
            content=ft.Column(
                controls=[
                    ft.Text("Hello!"),
                ]
            )
        )
    )

    # some configuration that we want to do before showing the window
    page.window.width = 300
    page.window.height = 200
    page.update()
    await page.window.center()

    # wait for 3 seconds before showing the window
    await asyncio.sleep(3)

    # show the window
    page.window.visible = True
    page.update()


if __name__ == "__main__":
    ft.run(main, view=ft.AppView.FLET_APP_HIDDEN)
```

--------------------------------

### start_recording(output_path, configuration, upload)

Source: https://flet.dev/docs/services/audiorecorder

Starts recording audio and saves it to a file or streams it.

```APIDOC
## start_recording(output_path: str | None = None, configuration: AudioRecorderConfiguration | None = None, upload: AudioRecorderUploadSettings | None = None) -> bool

### Description
Starts recording audio and saves it to a file or streams it.
If neither `upload` nor `on_stream` is used, `output_path` must be provided on platforms other than web.
When streaming, use `PCM16BITS` as the encoder. In that case, emitted or uploaded `chunk`s contain raw PCM16 data. In some use cases, these chunks can be wrapped in a container such as WAV if the output must be directly playable as an audio file.

### Method
start_recording(output_path, configuration, upload)

### Parameters
- output_path (str | None, default: `None`) - The file path where the audio will be saved. It must be specified if not on web.
- configuration (AudioRecorderConfiguration | None, default: `None`) - The configuration for the audio recorder. If `None`, the `AudioRecorder.configuration` will be used.
- upload (AudioRecorderUploadSettings | None, default: `None`) - Upload settings to stream recording bytes directly to a destination, for example a URL returned by `Page.get_upload_url`.

### Returns
- bool - `True` if recording was successfully started, `False` otherwise.

### Raises
- ValueError - If `output_path` is not provided on platforms other than web when neither streaming nor uploads are requested.
- ValueError - If streaming is requested with an encoder other than `PCM16BITS`.
```

--------------------------------

### Install Linux dependencies using flet --version with jq

Source: https://flet.dev/docs/publish/linux

Install the same dependency list reported by `flet --version --json` using jq to extract the package names. This ensures the setup script stays up to date.

```bash
sudo apt update  

sudo apt install -y $(flet --version --json | jq -r '.linux_dependencies | join(" ")')  
```

--------------------------------

### Install and list provisioning profiles

Source: https://flet.dev/docs/publish/ios

These commands install a provisioning profile by extracting its UUID and copying it to the system directory, then list all installed profiles with names and UUIDs. The profile must be named {UUID}.mobileprovision in ~/Library/MobileDevice/Provisioning Profiles. If the copied profile disappears, ensure Xcode is not running.

```bash
profile_uuid=$(security cms -D -i ~/Downloads/{profile-name}.mobileprovision | xmllint --xpath "string(//key[.='UUID']/following-sibling::string[1])" -)  

echo $profile_uuid  

```

```bash
cp ~/Downloads/{profile-name}.mobileprovision ~/Library/MobileDevice/Provisioning\ Profiles/${profile_uuid}.mobileprovision  

```

```bash
for profile in ~/Library/MobileDevice/Provisioning\ Profiles/*.mobileprovision; do security cms -D -i "$profile" | grep -E -A1 '<key>(Name|UUID)</key>' | sed -n 's/.*<string>\(.*\)<\/string>/\1/p' | paste -d ' | ' - -; done  

```

--------------------------------

### get_keys method signature

Source: https://flet.dev/docs/services/sharedpreferences

Signature for the get_keys method, which gets all keys with a given prefix. Returns a list of keys that start with the prefix.

```python
get_keys(key_prefix: str) -> list[str]
```

--------------------------------

### initialize

Source: https://flet.dev/docs/controls/camera

Initializes a new camera controller for the given description.

```APIDOC
## initialize

### Description
Initializes a new camera controller for the given description.

### Method
async

### Parameters
- **description** (CameraDescription) - Required - Camera device to bind to.
- **resolution_preset** (ResolutionPreset) - Required - Desired resolution preset.
- **enable_audio** (bool, default: `True`) - Optional - Whether audio is enabled for recordings.
- **fps** (int | None, default: `None`) - Optional - Optional target frames per second.
- **video_bitrate** (int | None, default: `None`) - Optional - Optional video bitrate.
- **audio_bitrate** (int | None, default: `None`) - Optional - Optional audio bitrate.
- **image_format_group** (ImageFormatGroup | None, default: `None`) - Optional - Optional image format group override.
```

--------------------------------

### CupertinoSlider event handling example

Source: https://flet.dev/docs/controls/cupertinoslider

Full example that creates a CupertinoSlider with event handlers for change start, change, and change end. It updates text widgets to show the current value and status. The slider uses divisions, min/max, and custom colors.

```python
import flet as ft


def main(page: ft.Page):
    page.horizontal_alignment = ft.CrossAxisAlignment.CENTER
    page.vertical_alignment = ft.MainAxisAlignment.CENTER
    page.theme_mode = ft.ThemeMode.LIGHT

    slider_value = ft.Text("0.0")
    slider_status = ft.Text()

    def handle_change_start(_: ft.Event[ft.CupertinoSlider]):
        slider_status.value = "Sliding"

    def handle_change(e: ft.Event[ft.CupertinoSlider]):
        slider_value.value = str(e.control.value)

    def handle_change_end(_: ft.Event[ft.CupertinoSlider]):
        slider_status.value = "Finished sliding"

    page.add(
        ft.SafeArea(
            content=ft.Column(
                horizontal_alignment=ft.CrossAxisAlignment.CENTER,
                controls=[
                    slider_value,
                    ft.CupertinoSlider(
                        divisions=20,
                        min=0,
                        max=100,
                        active_color=ft.Colors.PURPLE,
                        thumb_color=ft.Colors.PURPLE,
                        on_change_start=handle_change_start,
                        on_change_end=handle_change_end,
                        on_change=handle_change,
                    ),
                    slider_status,
                ],
            ),
        )
    )


if __name__ == "__main__":
    ft.run(main)
```

--------------------------------

### initialize

Source: https://flet.dev/docs/controls/camera

Initializes a new camera controller for the given description.

```APIDOC
## initialize

### Description
Initializes a new camera controller for the given description.

### Method
initialize

### Parameters
- **description** (type unknown) - Required - The camera description to initialize with.

### Response
No return value.
```

--------------------------------

### Bundle desktop entry and icon paths

Source: https://flet.dev/docs/publish/linux

The bundle ships a ready-to-install desktop entry and icon under `share/`. The `<size>` matches the icon's pixel size when declared, otherwise defaults to `256x256`.

```text
share/applications/<bundle_id>.desktop  

share/icons/hicolor/<size>/apps/<bundle_id>.png  

```

--------------------------------

### uv: Install pre-release Flet with --prerelease allow

Source: https://flet.dev/docs/getting-started/installation

Use --prerelease allow with uv commands to install pre-release Flet. Includes scaffolding an app with uvx, pinning an exact version, installing a global CLI, and adding to an existing project.

```bash
# scaffold an app with the latest pre-release  

uvx --prerelease allow --with flet-cli flet create my-app  

  

# or pin an exact version  

uvx --prerelease allow --from 'flet[cli]==1.1.0.dev5' flet create my-app  

  

# a global CLI, or an existing project  

uv tool install --prerelease allow --with flet-cli flet  

uv add flet --prerelease allow  
```

--------------------------------

### did_mount

Source: https://flet.dev/docs/controls/basecontrol

Called after the control is mounted into the page tree. Override to start resources that require an attached page, for example subscriptions, timers, or service listeners.

```APIDOC
## did_mount()

### Description
Called after the control is mounted into the page tree. Override to start resources that require an attached page, for example subscriptions, timers, or service listeners.

### Method
did_mount

### Parameters
None

### Returns
None
```

--------------------------------

### 1.0 app entry point with ft.run()

Source: https://flet.dev/docs/updates/migrate-to-1-0

New 1.0 entry point using ft.run() with the main parameter. Use ft.run_async() when starting from existing async code.

```python
# 1.0

ft.run(main)

ft.run(main, view=ft.AppView.WEB_BROWSER)
```

--------------------------------

### SpinKit Wave wave_type property examples

Source: https://flet.dev/docs/controls/spinkit

Shows how to set the wave_type property of a Wave spinner to START, CENTER, and END. Each spinner uses color=ft.Colors.BLUE and size=50.

```python
labeled(
    spins.Wave(
        color=ft.Colors.BLUE, size=50, wave_type=spins.WaveType.START
    ),
    "START",
),
```

```python
labeled(
    spins.Wave(
        color=ft.Colors.BLUE, size=50, wave_type=spins.WaveType.CENTER
    ),
    "CENTER",
),
```

```python
labeled(
    spins.Wave(
        color=ft.Colors.BLUE, size=50, wave_type=spins.WaveType.END
    ),
    "END",
),
```

--------------------------------

### Deploy commands - create, deploy, open

Source: https://flet.dev/docs/publish/web/dynamic-website/hosting/fly-io

Commands to create the Fly app, deploy it, and open it in the browser. Replace <your-app-name> with your app name.

```bash
fly apps create --name <your-app-name>  
```

```bash
fly deploy  
```

```bash
fly apps open  
```

--------------------------------

### Basic ListTile example

Source: https://flet.dev/docs/controls/listtile

Creates a ListTile with a leading icon, title, subtitle, trailing icon, and background color. Use this as a starting point for building list items in Flet.

```python
ft.ListTile(  

    width=400,  

    leading=ft.Icon(ft.Icons.ACCOUNT_CIRCLE),  

    title="Jane Doe",  

    subtitle="Product Manager",  

    trailing=ft.Icon(ft.Icons.CHEVRON_RIGHT),  

    bgcolor=ft.Colors.SURFACE_CONTAINER_LOW,  

)  
```

--------------------------------

### Create virtualenv and install requirements

Source: https://flet.dev/docs/publish/web/dynamic-website/hosting/self-hosting

Commands to create a virtual environment and install the dependencies from requirements.txt. Run these in the project directory.

```bash
python -m venv .venv  

source .venv/bin/activate  

pip install -r requirements.txt  
```

--------------------------------

### login method signature

Source: https://flet.dev/docs/controls/page

Starts the OAuth flow. Parameters include provider, fetch_user, fetch_groups, scope, saved_token, on_open_authorization_url, complete_page_html, redirect_to_page, and authorization. See the Authentication guide for more information.

```python
login(
    provider: OAuthProvider,
    fetch_user: bool = True,
    fetch_groups: bool = False,
    scope: list[str] | None = None,
    saved_token: str | None = None,
    on_open_authorization_url: Callable[
        [str], Coroutine[Any, Any, None]
    ]
    | None = None,
    complete_page_html: str | None = None,
    redirect_to_page: bool | None = False,
    authorization: type[AT] | None = None,
) -> AT
```

--------------------------------

### PageView basic example with viewport_fraction and on_change

Source: https://flet.dev/docs/controls/pageview

Use this snippet to create a swipeable PageView with three pages. It sets viewport_fraction to 0.9 to show a peek of adjacent pages, uses on_change to print the current page index, and starts at index 1. The example uses horizontal swiping and includes containers with different background colors and content.

```python
import flet as ft  

  

def main(page: ft.Page):  
    page.padding = 0  

    page.add(  
        ft.SafeArea(  
            expand=True,  
            content=ft.PageView(  
                expand=True,  
                viewport_fraction=0.9,  
                on_change=lambda e: print(f"Currently viewing page {int(e.data)}"),  
                selected_index=1,  
                horizontal=True,  
                controls=[  
                    ft.Container(  
                        bgcolor=ft.Colors.INDIGO_400,  
                        content=ft.Column(  
                            alignment=ft.MainAxisAlignment.CENTER,  
                            horizontal_alignment=ft.CrossAxisAlignment.CENTER,  
                            controls=[  
                                ft.Text("Welcome", size=40, weight=ft.FontWeight.BOLD),  
                                ft.Text("Swipe to see what PageView can do."),  
                            ],  
                        ),  
                    ),  
                    ft.Container(  
                        bgcolor=ft.Colors.PINK_300,  
                        content=ft.Column(  
                            alignment=ft.MainAxisAlignment.CENTER,  
                            horizontal_alignment=ft.CrossAxisAlignment.CENTER,  
                            controls=[  
                                ft.Icon(ft.Icons.ANIMATION, size=72),  
                                ft.Text(  
                                    "Viewport fraction lets you peek at the next slide."  
                                ),  
                            ],  
                        ),  
                    ),  
                    ft.Container(  
                        bgcolor=ft.Colors.TEAL_300,  
                        content=ft.Column(  
                            alignment=ft.MainAxisAlignment.CENTER,  
                            horizontal_alignment=ft.CrossAxisAlignment.CENTER,  
                            controls=[  
                                ft.Icon(ft.Icons.TOUCH_APP, size=72),  
                                ft.Text("Use on_change to respond to page swipes."),  
                            ],  
                        ),  
                    ),  
                ],  
            ),  
        ),  
    )  

  

if __name__ == "__main__":  
    ft.run(main)  
```

--------------------------------

### start_recording()

Source: https://flet.dev/docs/services/audiorecorder

Starts recording audio and saves it to a file or streams it. Requires output_path on non-web platforms unless streaming or upload is used. When streaming, use PCM16BITS encoder. Raises ValueError if output_path is missing or if streaming with non-PCM16BITS encoder.

```python
start_recording(
    output_path: str | None = None,
    configuration: AudioRecorderConfiguration | None = None,
    upload: AudioRecorderUploadSettings | None = None,
) -> bool
```

--------------------------------

### RawImage zoom example: tap handler, reset, and page setup

Source: https://flet.dev/docs/controls/rawimage

Shows the tail of a RawImage zoom example: computing the zoom target from a tap position, a reset handler that cancels the zoom task and returns to the home view, and the page layout with a Reset button and a GestureDetector wrapping the raw image. Ends with the standard Flet entry point.

```python
        y = center_y + (frame_y / HEIGHT * 2 - 1) * scale * aspect  

        start_zoom(x, y, ZOOM_PER_CLICK)  

  

    def reset():  

        nonlocal zoom_task  

        if zoom_task is not None:  

            zoom_task.cancel()  

            zoom_task = None  

        asyncio.create_task(show(*HOME))  

  

    page.add(  

        ft.Row(  

            [  

                ft.OutlinedButton("Reset", on_click=reset),  

                zoom_text,  

                fps_text,  

                hint_text,  

            ],  

            spacing=20,  

        ),  

        ft.GestureDetector(content=raw_image, on_tap_down=tap, expand=True),  

    )  

  

    await show(*HOME)  

  

  

if __name__ == "__main__":  

    ft.run(main)  
```

--------------------------------

### Configuring OAuth callback handler

Source: https://flet.dev/docs/publish/web/dynamic-website

Handles OAuth flow callback requests. If your app doesn't use authentication, this endpoint is unnecessary. The example shows a GET endpoint that uses FletOAuth().handle(request).

```python
from flet.fastapi import FletOAuth  

  

@app.get("/oauth_callback")  

async def flet_oauth(request: Request):  

    return await FletOAuth().handle(request)  

```

--------------------------------

### URL Target showcase example

Source: https://flet.dev/docs/types/urltarget

Shows how to use ft.UrlTarget with ft.UrlLauncher to open a URL in a specified target. The example creates a UI with cards for each target, and clicking a card launches the URL with the selected target.

```python
import flet as ft  

  

def main(page: ft.Page):  

    page.horizontal_alignment = ft.CrossAxisAlignment.CENTER  

    async def open_url(target: ft.UrlTarget):  
        url = "https://flet.dev"  
        await ft.UrlLauncher().launch_url(ft.Url(url=url, target=target))  
        status.value = f"Opened {url} with target {target.name}"  
        status.update()  

    def showcase_card(target: ft.UrlTarget) -> ft.Container:  
        return ft.Container(  
            width=280,  
            padding=12,  
            border=ft.Border.all(1, ft.Colors.RED),  
            border_radius=10,  
            bgcolor=ft.Colors.SURFACE_CONTAINER_LOW,  
            content=ft.Column(  
                spacing=8,  
                controls=[  
                    ft.Text(target.name, weight=ft.FontWeight.BOLD),  
                    ft.Text(target.value, size=12, color=ft.Colors.ON_SURFACE_VARIANT),  
                    ft.Button(  
                        "Open flet.dev",  
                        icon=ft.Icons.OPEN_IN_NEW,  
                        on_click=lambda: page.run_task(open_url, target),  
                    ),  
                ],  
            ),  
        )  

    page.appbar = ft.AppBar(title="UrlTarget Showcase")  
    page.add(  
        ft.SafeArea(  
            expand=True,  
            content=ft.Column(  
                controls=[  
                    ft.Text(  
                        "Click a card to launch URL with the selected browser target."  
                    ),  
                    status := ft.Text(),  
                    ft.Row(  
                        wrap=True,  
                        spacing=12,  
                        expand=True,  
                        scroll=ft.ScrollMode.AUTO,  
                        alignment=ft.MainAxisAlignment.CENTER,  
                        controls=[showcase_card(target) for target in ft.UrlTarget],  
                    ),  
                ],  
            ),  
        )  
    )  


if __name__ == "__main__":  
    ft.run(main)  
```

--------------------------------

### Async main with asyncio.sleep

Source: https://flet.dev/docs/cookbook/async-apps

Use an async main function to await asyncio APIs. This example sleeps for 1 second before adding a text control. Use `await ft.run_async(main)` when starting from async code.

```python
import asyncio

import flet as ft

async def main(page: ft.Page):
    await asyncio.sleep(1)
    page.add(ft.Text("Hello, async world!"))

ft.run(main)
```

--------------------------------

### Music Info Card Example

Source: https://flet.dev/docs/controls/card

Complete example of a Card with a ListTile and action buttons. Sets the page title and light theme, wraps the Card in a SafeArea, and runs the app with ft.run.

```python
import flet as ft  

  

def main(page: ft.Page):  
    page.title = "Card Example"  
    page.theme_mode = ft.ThemeMode.LIGHT  

    page.add(  
        ft.SafeArea(  
            content=ft.Card(  
                shadow_color=ft.Colors.ON_SURFACE_VARIANT,  
                content=ft.Container(  
                    width=400,  
                    padding=10,  
                    content=ft.Column(  
                        controls=[  
                            ft.ListTile(  
                                bgcolor=ft.Colors.GREY_400,  
                                leading=ft.Icon(ft.Icons.ALBUM),  
                                title=ft.Text("The Enchanted Nightingale"),  
                                subtitle=ft.Text(  
                                    "Music by Julie Gable. Lyrics by Sidney Stein."  
                                ),  
                            ),  
                            ft.Row(  
                                alignment=ft.MainAxisAlignment.END,  
                                controls=[  
                                    ft.TextButton("Buy tickets"),  
                                    ft.TextButton("Listen"),  
                                ],  
                            ),  
                        ]  
                    ),  
                ),  
            ),  
        )  
    )  

  

if __name__ == "__main__":  
    ft.run(main)  
```

--------------------------------

### Flet MenuBar with nested submenus

Source: https://flet.dev/docs/controls/menubar

Creates a MenuBar with nested submenus using Flet. Includes SubmenuButton and MenuItemButton controls with hover styles and event handlers. The example ends with ft.run(main) to start the app.

```python
ft.Colors.GREEN_100  

                                                )  

                                            }  

                                        ),  

                                    ),  

                                ],  

                            ),  

                            ft.SubmenuButton(  

                                content=ft.Text("View"),  

                                on_open=handle_submenu_open,  

                                on_close=handle_submenu_close,  

                                on_hover=handle_submenu_hover,  

                                controls=[  

                                    ft.SubmenuButton(  

                                        content=ft.Text("Zoom"),  

                                        controls=[  

                                            ft.MenuItemButton(  

                                                content=ft.Text("Magnify"),  

                                                leading=ft.Icon(ft.Icons.ZOOM_IN),  

                                                close_on_click=False,  

                                                on_click=handle_menu_item_click,  

                                                style=ft.ButtonStyle(  

                                                    bgcolor={  

                                                        ft.ControlState.HOVERED: (  

                                                            ft.Colors.PURPLE_200  

                                                        )  

                                                    }  

                                                },  

                                            ),  

                                            ft.MenuItemButton(  

                                                content=ft.Text("Minify"),  

                                                leading=ft.Icon(ft.Icons.ZOOM_OUT),  

                                                close_on_click=False,  

                                                on_click=handle_menu_item_click,  

                                                style=ft.ButtonStyle(  

                                                    bgcolor={  

                                                        ft.ControlState.HOVERED: (  

                                                            ft.Colors.PURPLE_200  

                                                        )  

                                                    }  

                                                },  

                                            ),  

                                        ],  

                                    )  

                                ],  

                            ),  

                        ],  

                    )  

                ],  

            ),  

        )  

    )  

  

  

if __name__ == "__main__":  

    ft.run(main)  
```

--------------------------------

### Camera playground example

Source: https://flet.dev/docs/controls/camera

This is the main example for the camera control page. It demonstrates how to set up a camera preview, create control buttons, and handle camera events. The code includes a State dataclass to track camera state, a main async function that builds the UI, and helper functions for camera labels and orientation conversion.

```python
import base64  

import logging  

from dataclasses import dataclass, field  

from datetime import datetime  

from math import cos, pi, sin  

  

import flet as ft  

import flet_camera as fc  

  

  

@dataclass  

class State:  

    cameras: list[fc.CameraDescription] = field(default_factory=list)  

    selected_camera: fc.CameraDescription | None = None  

    camera_labels: dict[str, str] = field(default_factory=dict)  

    is_streaming: bool = False  

    is_streaming_supported: bool = False  

    is_initialized: bool = False  

    is_preview_paused: bool = False  

    is_recording: bool = False  

    is_recording_paused: bool = False  

    device_orientation: ft.DeviceOrientation | None = None  

    last_frame_width: int | None = None  

    last_frame_height: int | None = None  

  

  

async def main(page: ft.Page):  

    image_frame_width = 280  

    image_frame_height = 200  

    page.title = "Camera control"  

    page.padding = 16  

    page.scroll = ft.ScrollMode.AUTO  

    page.horizontal_alignment = ft.CrossAxisAlignment.STRETCH  

  

    state = State()  

  

    preview = fc.Camera(  

        expand=True,  

        preview_enabled=True,  

        content=ft.Container(  

            alignment=ft.Alignment.CENTER,  

            content=ft.Icon(  

                ft.Icons.CENTER_FOCUS_STRONG,  

                color=ft.Colors.WHITE_70,  

                size=48,  

            ),  

        ),  

    )  

  

    status = ft.Text(value="Select a camera", size=12)  

    last_photo_label = ft.Text("Last photo", visible=False)  

    last_image = ft.Image(  

        src=base64.b64decode(  

            "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/wIAAgMBAp0YVwAAAABJRU5ErkJggg=="  

        ),  

        width=image_frame_width,  

        height=image_frame_height,  

        fit=ft.BoxFit.CONTAIN,  

        gapless_playback=True,  

    )  

    last_image_frame = ft.Container(  

        width=image_frame_width,  

        height=image_frame_height,  

        alignment=ft.Alignment.CENTER,  

        content=last_image,  

        visible=False,  

    )  

    selector = ft.Dropdown(label="Camera", options=[])  

    recorded_video_path = ft.Text(value="Recorded video: not saved yet", size=12)  

    take_photo_btn = ft.FilledIconButton(  

        icon=ft.Icons.PHOTO_CAMERA,  

        tooltip="Take photo",  

        disabled=True,  

    )  

    record_btn = ft.FilledTonalIconButton(  

        icon=ft.Icons.VIDEOCAM,  

        selected_icon=ft.Icons.STOP,  

        selected=False,  

        tooltip="Start / stop recording",  

        disabled=True,  

    )  

    pause_recording_btn = ft.OutlinedIconButton(  

        icon=ft.Icons.PAUSE,  

        selected_icon=ft.Icons.PLAY_ARROW,  

        selected=False,  

        tooltip="Pause / resume recording",  

        disabled=True,  

    )  

    stream_btn = ft.OutlinedIconButton(  

        icon=ft.Icons.PLAY_ARROW,  

        selected_icon=ft.Icons.STOP,  

        selected=False,  

        tooltip="Start / stop image stream",  

        disabled=True,  

    )  

    preview_btn = ft.OutlinedIconButton(  

        icon=ft.Icons.VISIBILITY_OFF,  

        selected_icon=ft.Icons.VISIBILITY,  

        selected=True,  

        tooltip="Pause / resume preview",  

        disabled=True,  

    )  

  

    def has_human_readable_name(camera: fc.CameraDescription) -> bool:  

        name = camera.name.strip()  

        if not name:  

            return False  

        if name.startswith("com.apple.avfoundation."):  

            return False  

        return not (":" in name and "." in name)  

  

    def camera_label(camera: fc.CameraDescription) -> str:  

        if has_human_readable_name(camera):  

            return camera.name  

  

        direction = camera.lens_direction.value.capitalize()  

        lens_map = {  

            "wide": "Wide",  

            "telephoto": "Telephoto",  

            "ultraWide": "Ultra Wide",  

            "unknown": "Unknown",  

        }  

        lens_type = lens_map.get(camera.lens_type.value, camera.lens_type.value)  

        return f"{direction} ({lens_type})"  

  

    def device_orientation_degrees(orientation: ft.DeviceOrientation | None) -> int:  

        if orientation == ft.DeviceOrientation.PORTRAIT_UP:  

            return 0  

        if orientation == ft.DeviceOrientation.LANDSCAPE_RIGHT:  

            return 90  

        if orientation == ft.DeviceOrientation.PORTRAIT_DOWN:  

            return 180  

        if orientation == ft.DeviceOrientation.LANDSCAPE_LEFT:  

            return 270  

        return 0  

  

    def image_rotation_radians() -> float:  

        camera = state.selected_camera  

        if camera is None:  

            return 0.0  

        sensor_orientation = camera.sensor_orientation
```

--------------------------------

### Column vertical alignment

Source: https://flet.dev/docs/controls/column

Defines a custom Column subclass that demonstrates vertical alignment using MainAxisAlignment. The example creates multiple instances with different alignments (START, CENTER, END, SPACE_BETWEEN, SPACE_AROUND, SPACE_EVENLY) in a scrollable row.

```python
import flet as ft  

  

@ft.control  
class ColumnFromVerticalAlignment(ft.Column):  
    alignment: ft.MainAxisAlignment = ft.MainAxisAlignment.START  

    def init(self):  
        self.controls = [  
            ft.Text(str(self.alignment), size=10),  
            ft.Container(  
                content=ft.Column(self.generate_items(3), alignment=self.alignment),  
                bgcolor=ft.Colors.AMBER_100,  
                height=400,  
            ),  
        ]  

    @staticmethod  
    def generate_items(count: int):  
        """Generates a list of custom Containers with length `count`."""  
        return [  
            ft.Container(  
                content=ft.Text(value=str(i)),  
                alignment=ft.Alignment.CENTER,  
                width=50,  
                height=50,  
                bgcolor=ft.Colors.AMBER_500,  
            )  
            for i in range(1, count + 1)  
        ]  

  

def main(page: ft.Page):  
    page.add(  
        ft.SafeArea(  
            content=ft.Row(  
                spacing=30,  
                alignment=ft.MainAxisAlignment.START,  
                scroll=ft.ScrollMode.AUTO,  
                controls=[  
                    ColumnFromVerticalAlignment(alignment=ft.MainAxisAlignment.START),  
                    ColumnFromVerticalAlignment(alignment=ft.MainAxisAlignment.CENTER),  
                    ColumnFromVerticalAlignment(alignment=ft.MainAxisAlignment.END),  
                    ColumnFromVerticalAlignment(  
                        alignment=ft.MainAxisAlignment.SPACE_BETWEEN  
                    ),  
                    ColumnFromVerticalAlignment(  
                        alignment=ft.MainAxisAlignment.SPACE_AROUND  
                    ),  
                    ColumnFromVerticalAlignment(  
                        alignment=ft.MainAxisAlignment.SPACE_EVENLY  
                    ),  
                ],  
            )  
        )  
    )  

  

if __name__ == "__main__":  
    ft.run(main)  
```

--------------------------------

### Shared preferences example: set and get values

Source: https://flet.dev/docs/services/sharedpreferences

Shows how to use SharedPreferences to store and retrieve values. The set_value function stores a value and shows a SnackBar; get_value retrieves and displays the stored value. Requires a Flet app with a page.

```python
import flet as ft  

  

async def main(page: ft.Page):  

    async def set_value():  

        await ft.SharedPreferences().set(store_key.value, store_value.value)  

        get_key.value = store_key.value  

        store_key.value = ""  

        store_value.value = ""  

        page.show_dialog(ft.SnackBar("Value saved to SharedPreferences"))  

  

    async def get_value():  

        contents = await ft.SharedPreferences().get(get_key.value)  

        page.add(ft.Text(f"SharedPreferences contents: {contents}"))  

  

    page.add(  

        ft.SafeArea(  

            content=ft.Column(  

                controls=[  

                    ft.Column(  

                        [  

                            ft.Row(  

                                [  

                                    store_key := ft.TextField(label="Key"),  

                                    store_value := ft.TextField(label="Value"),  

                                    ft.Button("Set", on_click=set_value),  

                                ]  

                            ),  

                            ft.Row(  

                                [  

                                    get_key := ft.TextField(label="Key"),  

                                    ft.Button("Get", on_click=get_value),  

                                ]  

                            ),  

                        ],  

                    )  

                ],  

            ),  

        )  

    )  

  

if __name__ == "__main__":  

    ft.run(main)  
```

--------------------------------

### start_video_recording()

Source: https://flet.dev/docs/controls/camera

Starts capturing video.

```python
start_video_recording()
```
Tokens:
Raw