========================
CODE SNIPPETS
========================
TITLE: Test Streamlit Installation with Hello App
DESCRIPTION: These commands launch Streamlit's built-in 'Hello' example application to verify a successful installation. A fallback command is provided if the direct `streamlit` command is not immediately available.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_5

LANGUAGE: bash
CODE:
```
streamlit hello
```

LANGUAGE: bash
CODE:
```
python -m streamlit hello
```

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

TITLE: Run Streamlit Hello App with Default Settings
DESCRIPTION: This command verifies Streamlit installation by running an included example application. It starts the 'Hello' app and opens it in the default web browser.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_734

LANGUAGE: bash
CODE:
```
streamlit hello
```

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

TITLE: Streamlit CLI: Configuration Options Examples
DESCRIPTION: Examples demonstrating how to pass configuration options to Streamlit CLI commands, such as `streamlit hello`, to customize app behavior or appearance.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_733

LANGUAGE: Bash
CODE:
```
--theme.primaryColor=blue
```

LANGUAGE: Bash
CODE:
```
--theme.primaryColor="blue"
```

LANGUAGE: Bash
CODE:
```
--theme.primaryColor=#0000FF
```

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

TITLE: Run Streamlit Component Example Application
DESCRIPTION: Commands to activate the Python environment, install the component template as an editable package, and run the Streamlit example application for both React and TypeScript-only templates.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_168

LANGUAGE: bash
CODE:
```
# React template
cd template
. venv/bin/activate # or similar to activate the venv/conda environment where Streamlit is installed
pip install -e . # install template as editable package
streamlit run my_component/example.py # run the example

# or

# TypeScript-only template
cd template-reactless
. venv/bin/activate # or similar to activate the venv/conda environment where Streamlit is installed
pip install -e . # install template as editable package
streamlit run my_component/example.py # run the example
```

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

TITLE: Install pytest for Streamlit Testing
DESCRIPTION: Installs the pytest framework, a common Python testing tool, into your Streamlit development environment. This is a prerequisite for running the Streamlit app testing examples.

SOURCE: https://github.com/streamlit/docs/blob/main/content/develop/concepts/app-testing/get-started.md#_snippet_0

LANGUAGE: bash
CODE:
```
pip install pytest
```

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

TITLE: Streamlit: Installation and Basic Usage
DESCRIPTION: This snippet provides commands for installing Streamlit, running a Streamlit application from the command line, and the standard Python import convention for Streamlit.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_866

LANGUAGE: bash
CODE:
```
pip install streamlit

streamlit run first_app.py
```

LANGUAGE: python
CODE:
```
# Import convention
>>> import streamlit as st
```

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

TITLE: Dockerfile for Streamlit Application
DESCRIPTION: This Dockerfile defines the steps to build a Docker image for a Streamlit application. It starts from a Python 3.9 slim image, sets the working directory, installs necessary build tools, clones a Streamlit example repository, installs Python dependencies, exposes port 8501, includes a health check, and sets the entrypoint to run the Streamlit application.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_1077

LANGUAGE: docker
CODE:
```
# app/Dockerfile

FROM python:3.9-slim

WORKDIR /app

RUN apt-get update  apt-get install -y \
    build-essential \
    curl \
    software-properties-common \
    git \
     rm -rf /var/lib/apt/lists/*

RUN git clone https://github.com/streamlit/streamlit-example.git .

RUN pip3 install -r requirements.txt

EXPOSE 8501

HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health

ENTRYPOINT ["streamlit", "run", "streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
```

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

TITLE: GitHub Actions Test Environment Setup
DESCRIPTION: YAML snippet detailing the setup steps for a GitHub Actions job, including checking out the repository code and installing a specific Python version (3.11) on an Ubuntu environment.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_238

LANGUAGE: yaml
CODE:
```
jobs:
  streamlit:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: "3.11"
```

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

TITLE: Install and Validate Streamlit via Command Line
DESCRIPTION: This snippet provides the essential command-line steps for installing Streamlit using pip and then validating the installation by running the built-in 'Hello' application. It's part of the recommended setup for local development and assumes a Python environment is already configured.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_0

LANGUAGE: Bash
CODE:
```
pip install streamlit
```

LANGUAGE: Bash
CODE:
```
streamlit hello
```

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

TITLE: Run Streamlit Hello App
DESCRIPTION: Executes the Streamlit "Hello" example application to validate the installation. This command starts a local web server and opens the app in your browser.

SOURCE: https://github.com/streamlit/docs/blob/main/content/get-started/installation/anaconda-distribution.md#_snippet_1

LANGUAGE: bash
CODE:
```
streamlit hello
```

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

TITLE: Streamlit CLI: Run Hello App
DESCRIPTION: The `streamlit hello` command runs an example Streamlit application that is included with the Streamlit library, demonstrating basic functionalities.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_732

LANGUAGE: Bash
CODE:
```
streamlit hello
```

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

TITLE: Install Streamlit Nightly Release
DESCRIPTION: Instructions on how to switch from the official Streamlit package to the nightly release. This involves uninstalling the stable `streamlit` package and then installing the `streamlit-nightly` package with an upgrade.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_1059

LANGUAGE: bash
CODE:
```
pip uninstall streamlit
pip install streamlit-nightly --upgrade
```

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

TITLE: Define Dockerfile for Streamlit Application
DESCRIPTION: A Dockerfile that defines the steps to build a Docker image for the Streamlit application. It sets up a Python environment, installs necessary dependencies, clones the Streamlit example app, and configures the entrypoint.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_1097

LANGUAGE: docker
CODE:
```
FROM python:3.9-slim

RUN groupadd --gid 1000 appuser \
     && useradd --uid 1000 --gid 1000 -ms /bin/bash appuser

RUN pip3 install --no-cache-dir --upgrade \
    pip \
    virtualenv

RUN apt-get update && apt-get install -y \
    build-essential \
    software-properties-common \
    git

USER appuser
WORKDIR /home/appuser

RUN git clone https://github.com/streamlit/streamlit-example.git app

ENV VIRTUAL_ENV=/home/appuser/venv
RUN virtualenv ${VIRTUAL_ENV}
RUN . ${VIRTUAL_ENV}/bin/activate && pip install -r app/requirements.txt

EXPOSE 8501

COPY run.sh /home/appuser
ENTRYPOINT ["./run.sh"]
```

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

TITLE: Example Python Dependencies (requirements.txt)
DESCRIPTION: Shows typical Python dependencies listed in a `requirements.txt` file. These packages are installed by pip to ensure the Streamlit application has all necessary libraries to run correctly.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_1083

LANGUAGE: text
CODE:
```
altair
pandas
streamlit
```

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

TITLE: Run Streamlit App from Working Directory
DESCRIPTION: This example shows the basic command to start a Streamlit application when its entrypoint file is located in the current working directory.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_741

LANGUAGE: bash
CODE:
```
streamlit run your_app.py
```

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

TITLE: Example config.toml file for Streamlit settings
DESCRIPTION: Provides an example of a `config.toml` file, demonstrating how to define client and theme settings. This file uses TOML syntax for key-value pairs to customize Streamlit's appearance and behavior.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_687

LANGUAGE: toml
CODE:
```
[client]
showErrorDetails = "none"

[theme]
primaryColor = "#F63366"
backgroundColor = "black"
```

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

TITLE: Streamlit App Testing Example
DESCRIPTION: A Python test function demonstrating how to initialize, run, and interact with a Streamlit app using AppTest. It simulates user input and asserts the resulting output.

SOURCE: https://github.com/streamlit/docs/blob/main/content/develop/concepts/app-testing/get-started.md#_snippet_10

LANGUAGE: python
CODE:
```
"""test_app.py"""
from streamlit.testing.v1 import AppTest

def test_increment_and_add():
    """A user increments the number input, then clicks Add"""
    at = AppTest.from_file("app.py").run()
    at.number_input[0].increment().run()
    at.button[0].click().run()
    assert at.markdown[0].value == "Beans counted: 1"
```

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

TITLE: Verify Docker Engine Installation
DESCRIPTION: Command to run the `hello-world` Docker image to confirm Docker Engine is correctly installed on your server.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_1095

LANGUAGE: bash
CODE:
```
sudo docker run hello-world
```

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

TITLE: Example Project Directory Structure for Pytest
DESCRIPTION: Illustrates the recommended directory structure for a Streamlit application with a dedicated `tests/` directory for `pytest` test files.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_211

LANGUAGE: none
CODE:
```
myproject/
├── app.py
└── tests/
    └── test_app.py
```

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

TITLE: Streamlit: Install Pre-release Features
DESCRIPTION: This snippet shows how to uninstall the stable Streamlit version and install the `streamlit-nightly` package to access pre-release and experimental features.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_867

LANGUAGE: bash
CODE:
```
pip uninstall streamlit
pip install streamlit-nightly --upgrade
```

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

TITLE: Example Project Structure for Streamlit Login Page Testing
DESCRIPTION: This snippet outlines the recommended directory structure for a Streamlit application that includes a login page and its corresponding test files. It demonstrates a clear separation between the main application code and its tests.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_242

LANGUAGE: none
CODE:
```
myproject/
├── app.py
└── tests/
    └── test_app.py
```

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

TITLE: Creating and Populating a MySQL Database Table
DESCRIPTION: This SQL script creates a new database named 'pets', selects it, defines a table 'mytable' with 'name' and 'pet' columns, and inserts three example rows. This setup is necessary before connecting a Streamlit application to the MySQL database.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_811

LANGUAGE: SQL
CODE:
```
CREATE DATABASE pets;

USE pets;

CREATE TABLE mytable (
    name varchar(80),
    pet varchar(80)
);

INSERT INTO mytable VALUES ('Mary', 'dog'), ('John', 'cat'), ('Robert', 'bird');
```

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

TITLE: Create TiDB database and table
DESCRIPTION: This SQL snippet creates a new database named 'pets' and a table 'mytable' within it, populating it with example data. It demonstrates the initial setup for a TiDB cluster.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_838

LANGUAGE: sql
CODE:
```
CREATE DATABASE pets;

USE pets;

CREATE TABLE mytable (
    name            varchar(80),
    pet             varchar(80)
);

INSERT INTO mytable VALUES ('Mary', 'dog'), ('John', 'cat'), ('Robert', 'bird');
```

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

TITLE: Create PostgreSQL Table with Example Data
DESCRIPTION: SQL commands to create a sample table named `mytable` and insert three rows of example data. This table is used for demonstration purposes in the Streamlit application.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_822

LANGUAGE: sql
CODE:
```
CREATE TABLE mytable (
    name            varchar(80),
    pet             varchar(80)
);

INSERT INTO mytable VALUES ('Mary', 'dog'), ('John', 'cat'), ('Robert', 'bird');
```

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

TITLE: Verify Docker Engine Installation
DESCRIPTION: This command runs the `hello-world` Docker image to confirm that Docker Engine is correctly installed and operational on your server. It's a standard first step to ensure your Docker environment is set up.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_1076

LANGUAGE: bash
CODE:
```
sudo docker run hello-world
```

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

TITLE: Streamlit Version Prerequisite
DESCRIPTION: Specifies the minimum required Streamlit version for the tutorials and examples provided in this documentation.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_849

LANGUAGE: text
CODE:
```
streamlit>=1.37.0
```

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

TITLE: Install Python Package from Test PyPI
DESCRIPTION: This command shows how to install a Python package that has been uploaded to Test PyPI. It specifies the Test PyPI index URL and uses the `--no-deps` flag to avoid installing dependencies, allowing for a focused test of the newly uploaded package.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_186

LANGUAGE: bash
CODE:
```
python -m pip install --index-url https://test.pypi.org/simple/ --no-deps example-pkg-YOUR-USERNAME-HERE
```

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

TITLE: Install Streamlit via pip
DESCRIPTION: This command installs the Streamlit library into your activated Python virtual environment using the `pip` package manager, making it available for your projects.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_4

LANGUAGE: bash
CODE:
```
pip install streamlit
```

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

TITLE: Create a Streamlit SQL Connection
DESCRIPTION: Demonstrates how to create a connection to a SQL database using `st.connection` and query data. This example connects to a 'pets_db' and fetches pet owners.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_650

LANGUAGE: Python
CODE:
```
conn = st.connection('pets_db', type='sql')
pet_owners = conn.query('select * from pet_owners')
st.dataframe(pet_owners)
```

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

TITLE: Install Git and Build Essentials in Docker
DESCRIPTION: Updates apt-get and installs necessary packages like `build-essential`, `curl`, `software-properties-common`, and `git`. These are often required for compiling software or cloning repositories within the Docker container.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_1080

LANGUAGE: docker
CODE:
```
RUN apt-get update  apt-get install -y \
    build-essential \
    curl \
    software-properties-common \
    git \
     rm -rf /var/lib/apt/lists/*
```

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

TITLE: Running Streamlit Hello for Installation Verification
DESCRIPTION: Illustrates how to run the `streamlit hello` command to confirm a successful Streamlit installation. Executing this command launches the example application in your default web browser, providing visual confirmation.

SOURCE: https://github.com/streamlit/docs/blob/main/content/develop/api-reference/command-line/hello.md#_snippet_1

LANGUAGE: bash
CODE:
```
streamlit hello
```

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

TITLE: Streamlit CLI Run Command API Reference
DESCRIPTION: Provides the comprehensive API documentation for the `streamlit run` command, which starts a Streamlit app. It covers syntax, the `<entrypoint>` argument, configuration options, and how script arguments are handled.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_740

LANGUAGE: APIDOC
CODE:
```
streamlit run <entrypoint> [-- config options] [script args]

Arguments:
  <entrypoint>: The path to your entrypoint file for your Streamlit app. In a multipage app with `st.navigation`, your entrypoint file acts as a router between your pages. Otherwise, your entrypoint file is your app's homepage.

Options:
  Configuration options are passed in the form of `--<section>.<option>=<value>`. For example, if you want to set the primary color of your app to blue, you could use one of the three equivalent options:
  - `--theme.primaryColor=blue`
  - `--theme.primaryColor="blue"`
  - `--theme.primaryColor=#0000FF`
  For a complete list of configuration options, see [`config.toml`](/develop/api-reference/configuration/config.toml) in the API reference. For examples, see below.

Script Arguments:
  If you need to pass arguments directly to your script, you can pass them as positional arguments. If you use `sys.argv` to read your arguments, `sys.arfgv` returns a list of all arugments and does _not_ include any configuration options. Python interprets all arguments as strings.
  - `sys.argv[0]` returns the provided path to your entrypoint file (`<entrypoint>`).
  - `sys.argv[1:]` returns a list of arguments in order and does not include any configuration options.
```

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

TITLE: Recommended requirements.txt for Streamlit App
DESCRIPTION: This `requirements.txt` file lists the recommended packages for the example Streamlit application. It includes `streamlit`, `pandas`, and `numpy`, following the best practice of accurately recording all used packages, even if some are transitive dependencies.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_1061

LANGUAGE: none
CODE:
```
streamlit
pandas
numpy
```

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

TITLE: Create a "Hello World" app
DESCRIPTION: This Python code creates a simple Streamlit application that displays "Hello world" in the browser.

SOURCE: https://github.com/streamlit/docs/blob/main/content/get-started/installation/command-line.md#_snippet_8

LANGUAGE: python
CODE:
```
import streamlit as st

st.write("Hello world")
```

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

TITLE: Build Custom Streamlit Connection with BaseConnection
DESCRIPTION: Provides an example of creating a custom connection class by inheriting from `BaseConnection`. It demonstrates implementing `_connect` and `query` methods.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_653

LANGUAGE: Python
CODE:
```
class MyConnection(BaseConnection[myconn.MyConnection]):
    def _connect(self, **kwargs) -> MyConnection:
        return myconn.connect(**self._secrets, **kwargs)
    def query(self, query):
        return self._instance.query(query)
```

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

TITLE: Install Python packages for Streamlit and PostgreSQL
DESCRIPTION: Lists the required Python packages and their minimum versions for connecting Streamlit to a PostgreSQL database like Neon. These packages include `streamlit`, `psycopg2-binary`, and `sqlalchemy`.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_815

LANGUAGE: txt
CODE:
```
streamlit>=1.28
psycopg2-binary>=2.9.6
sqlalchemy>=2.0.0
```

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

TITLE: Streamlit Dockerfile Example
DESCRIPTION: A sample Dockerfile for building a Streamlit application image. It sets up a Python environment, clones an example app, installs dependencies, exposes the Streamlit port, and defines a health check and entrypoint.

SOURCE: https://github.com/streamlit/docs/blob/main/content/deploy/tutorials/docker.md#_snippet_1

LANGUAGE: dockerfile
CODE:
```
# app/Dockerfile

FROM python:3.9-slim

WORKDIR /app

RUN apt-get update && apt-get install -y \
    build-essential \
    curl \
    software-properties-common \
    git \
    && rm -rf /var/lib/apt/lists/*

RUN git clone https://github.com/streamlit/streamlit-example.git .

RUN pip3 install -r requirements.txt

EXPOSE 8501

HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health

ENTRYPOINT ["streamlit", "run", "streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
```

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

TITLE: Create a basic Streamlit 'Hello World' app
DESCRIPTION: Create a Python file named `app.py` in your project directory. This file will contain a simple Streamlit script that writes 'Hello world' to the web interface.

SOURCE: https://github.com/streamlit/docs/blob/main/content/get-started/installation/command-line.md#_snippet_5

LANGUAGE: python
CODE:
```
import streamlit as st

st.write("Hello world")
```

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

TITLE: Initialize and Build Streamlit Component Frontend
DESCRIPTION: Commands to initialize the project and start the Webpack development server for both React and TypeScript-only Streamlit component templates using npm.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_167

LANGUAGE: bash
CODE:
```
# React template
template/my_component/frontend
npm install    # Initialize the project and install npm dependencies
npm run start  # Start the Webpack dev server

# or

# TypeScript-only template
template-reactless/my_component/frontend
npm install    # Initialize the project and install npm dependencies
npm run start  # Start the Webpack dev server
```

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

TITLE: Streamlit Multipage App Navigation Setup
DESCRIPTION: This Python snippet demonstrates how to define multiple pages using `st.Page` and organize them into a navigation structure with `st.navigation`. The `pg.run()` method then executes the selected page, enabling a multipage application.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_36

LANGUAGE: python
CODE:
```
main_page = st.Page("main_page.py", title="Main Page", icon="🎈")
page_2 = st.Page("page_2.py", title="Page 2", icon="❄️")
page_3 = st.Page("page_3.py", title="Page 3", icon="🎉")

# Set up navigation
pg = st.navigation([main_page, page_2, page_3])

# Run the selected page
pg.run()
```

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

TITLE: Initialize and Run Streamlit App Test
DESCRIPTION: Initializes the Streamlit application for testing using `AppTest.from_file()` and executes the first script run. This sets up the testing environment for subsequent interactions.

SOURCE: https://github.com/streamlit/docs/blob/main/content/develop/concepts/app-testing/get-started.md#_snippet_3

LANGUAGE: python
CODE:
```
at = AppTest.from_file("app.py").run()
```

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

TITLE: Install GitHub Package from Specific Tag in requirements.txt
DESCRIPTION: Shows how to install a Python package from a specific Git tag (e.g., 'v1.1.0') in the 'requirements.txt' file, useful for installing stable releases from GitHub.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_1125

LANGUAGE: bash
CODE:
```
git+https://github.com/SomePackage.git@v1.1.0#egg=SomePackage
```

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

TITLE: Example Output: Listing Docker Images
DESCRIPTION: Illustrates the expected output after successfully building and listing the 'streamlit' Docker image. Shows the repository name, tag, image ID, creation time, and size.

SOURCE: https://github.com/streamlit/docs/blob/main/content/deploy/tutorials/docker.md#_snippet_16

LANGUAGE: cli-output
CODE:
```
REPOSITORY   TAG       IMAGE ID       CREATED              SIZE
streamlit    latest    70b0759a094d   About a minute ago   1.02GB
```

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

TITLE: Clear All `st.cache_resource` Caches in Streamlit
DESCRIPTION: This Python example demonstrates how to clear all cached resources from functions decorated with `@st.cache_resource` by using `st.cache_resource.clear()`. It includes example functions for getting a database session and a model, which are then cleared when a "Clear All" button is pressed.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_609

LANGUAGE: python
CODE:
```
import streamlit as st
from transformers import BertModel

@st.cache_resource
 def get_database_session(url):
     # Create a database session object that points to the URL.
     return session

@st.cache_resource
def get_model(model_type):
    # Create a model of the specified type.
    return BertModel.from_pretrained(model_type)

if st.button("Clear All"):
    # Clears all st.cache_resource caches:
    st.cache_resource.clear()
```

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

TITLE: Example Streamlit App Directory Structure
DESCRIPTION: Illustrates the typical directory structure within the Docker container's working directory after cloning a Streamlit application. It shows the presence of `requirements.txt` for dependencies and `streamlit_app.py` as the main script.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_1082

LANGUAGE: bash
CODE:
```
app/
- requirements.txt
- streamlit_app.py
```

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

TITLE: Displaying Streamlit Help via Command Line
DESCRIPTION: This command provides quick access to Streamlit's help documentation directly from the command line. It displays available commands, options, and general usage information for Streamlit.

SOURCE: https://github.com/streamlit/docs/blob/main/content/get-started/fundamentals/tutorials/create-an-app.md#_snippet_18

LANGUAGE: bash
CODE:
```
streamlit help
```

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

TITLE: Example output of Docker images command
DESCRIPTION: This snippet shows a typical output from the `docker images` command. It confirms the presence of the `streamlit` image, along with its tag, image ID, creation time, and size.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_1092

LANGUAGE: text
CODE:
```
REPOSITORY   TAG       IMAGE ID       CREATED              SIZE
streamlit    latest    70b0759a094d   About a minute ago   1.02GB
```

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

TITLE: Install and Test Streamlit
DESCRIPTION: With your environment activated, install Streamlit using pip. Then, test the installation by running the built-in 'Hello' app, which opens in your web browser.

SOURCE: https://github.com/streamlit/docs/blob/main/content/get-started/installation/command-line.md#_snippet_2

LANGUAGE: bash
CODE:
```
pip install streamlit
streamlit hello
```

LANGUAGE: bash
CODE:
```
python -m streamlit hello
```

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

TITLE: Example output of Docker run command for Streamlit
DESCRIPTION: This snippet displays the expected output when successfully running the Streamlit Docker container. It confirms that the Streamlit app is accessible via the specified URL, indicating successful deployment and port mapping.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_1094

LANGUAGE: text
CODE:
```
docker run -p 8501:8501 streamlit

  You can now view your Streamlit app in your browser.

  URL: http://0.0.0.0:8501
```

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

TITLE: Dockerfile: Install Dependencies
DESCRIPTION: Installs necessary packages using apt-get. This example updates package lists, installs build-essential, curl, software-properties-common, and git, then cleans up apt cache to reduce image size.

SOURCE: https://github.com/streamlit/docs/blob/main/content/deploy/tutorials/docker.md#_snippet_4

LANGUAGE: Dockerfile
CODE:
```
RUN apt-get update && apt-get install -y \
    build-essential \
    curl \
    software-properties-common \
    git \
    && rm -rf /var/lib/apt/lists/*
```

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

TITLE: Install pytest for Streamlit App Testing
DESCRIPTION: This command installs the `pytest` framework, a popular Python testing tool, into your development environment. `pytest` is recommended for use with Streamlit's native app testing framework to automate and execute tests for your Streamlit applications.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_210

LANGUAGE: bash
CODE:
```
pip install pytest
```

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

TITLE: Streamlit AppTest API
DESCRIPTION: Documentation for the Streamlit AppTest framework, covering initialization, running the app, and simulating user interactions with widgets. AppTest provides methods to interact with elements like number inputs and buttons, and to assert their state.

SOURCE: https://github.com/streamlit/docs/blob/main/content/develop/concepts/app-testing/get-started.md#_snippet_9

LANGUAGE: APIDOC
CODE:
```
AppTest:
  __init__(file_path: str)
    Initializes the AppTest instance with the specified Python file.

  from_file(file_path: str) -> AppTest
    Class method to create an AppTest instance from a file path.
    Parameters:
      file_path: Path to the Streamlit app file.
    Returns:
      An initialized AppTest instance.

  from_string(app_code: str) -> AppTest
    Class method to create an AppTest instance from a string of Python code.
    Parameters:
      app_code: A string containing the Streamlit app's code.
    Returns:
      An initialized AppTest instance.

  from_function(app_function: callable) -> AppTest
    Class method to create an AppTest instance from a Python function that returns Streamlit app code.
    Parameters:
      app_function: A callable that returns the Streamlit app's code.
    Returns:
      An initialized AppTest instance.

  run() -> AppTest
    Executes the Streamlit app simulation. This method must be called after initialization and after any simulated user interaction that triggers a rerun.
    Returns:
      The AppTest instance for chaining operations.

  # Element Interaction Examples:
  # Elements are accessed via attributes like .number_input, .button, .markdown, etc.
  # Elements are typically sequences, accessed by index or key.

  # Example: Simulate incrementing a number input and clicking a button
  # at.number_input[0].increment().run()
  # at.button[0].click().run()

  # Element Attributes:
  # .value: Retrieves the current value of an element.
  # .exists: Checks if an element exists.
  # .visible: Checks if an element is visible.

  # Assertions:
  # Assertions are made using standard Python assert statements on element attributes.
  # Example: assert at.markdown[0].value == "Beans counted: 1"

  # Element Types:
  # number_input: Represents a Streamlit number input widget.
  #   - increment(): Simulates clicking the increment button.
  #   - decrement(): Simulates clicking the decrement button.
  # button: Represents a Streamlit button widget.
  #   - click(): Simulates clicking the button.
  # markdown: Represents a Streamlit markdown element.
  #   - value: The content of the markdown element.

  # Limitations:
  # Each interaction that reruns the app must be followed by a .run() call.
  # Element retrieval is based on display order or widget keys.
```

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

TITLE: Streamlit Basic Multipage App with st.navigation
DESCRIPTION: This example demonstrates a basic two-page Streamlit application using `st.navigation`. It defines two pages from Python files (`page_1.py`, `page_2.py`) and registers them with `st.navigation`, then executes the selected page using `.run()`. The directory structure shows the entrypoint file (`streamlit_app.py`) alongside the page files:
```
your-repository/
├── page_1.py
├── page_2.py
└── streamlit_app.py
```

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_90

LANGUAGE: python
CODE:
```
import streamlit as st

pg = st.navigation([st.Page("page_1.py"), st.Page("page_2.py")])
pg.run()
```

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

TITLE: Example Streamlit App with Built-in and Direct Dependencies
DESCRIPTION: This Python script demonstrates a basic Streamlit application that imports Streamlit, Pandas, NumPy, Math, and Random. It illustrates that Pandas and NumPy are installed as direct dependencies of Streamlit, while Math and Random are built-in Python libraries and do not need to be explicitly listed in `requirements.txt`.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_1060

LANGUAGE: python
CODE:
```
import streamlit as st
import pandas as pd
import numpy as np
import math
import random

st.write('Hi!')
```

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

TITLE: Basic Streamlit App Example
DESCRIPTION: A simple Streamlit application demonstrating how to create an interactive slider and display its value. This snippet illustrates the core concept of building interactive data apps with Streamlit.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_1063

LANGUAGE: python
CODE:
```
import streamlit as st
number = st.slider("Pick a number: ", min_value=1, max_value=10)
st.text("Your number is " + str(number))
```

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

TITLE: Install GitHub Package from Specific Branch in requirements.txt
DESCRIPTION: Demonstrates how to specify a particular Git branch (e.g., 'main', 'master', 'develop') when installing a Python package from a GitHub repository in the 'requirements.txt' file.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_1123

LANGUAGE: bash
CODE:
```
git+https://github.com/SomePackage.git@main#egg=SomePackage
```

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

TITLE: Installing Python dependencies in Docker container
DESCRIPTION: This Dockerfile instruction installs all necessary Python dependencies for the Streamlit application. It reads the dependencies from the `requirements.txt` file, ensuring the application has all required libraries within the container.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_1086

LANGUAGE: docker
CODE:
```
RUN pip3 install -r requirements.txt
```

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

TITLE: Initialize and Run AppTest
DESCRIPTION: Initializes a Streamlit app simulation using AppTest.from_file() and then runs the simulation. This is the first step in testing a Streamlit application.

SOURCE: https://github.com/streamlit/docs/blob/main/content/develop/concepts/app-testing/get-started.md#_snippet_8

LANGUAGE: python
CODE:
```
# Path to app file is relative to myproject/
at = AppTest.from_file("app.py").run()
```

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

TITLE: Streamlit Sidebar: Using `st.echo` and `st.spinner`
DESCRIPTION: Demonstrates how to incorporate `st.echo` and `st.spinner` within the Streamlit sidebar, which specifically require the 'with' context manager. This example illustrates displaying code snippets and a loading indicator directly within the sidebar for enhanced user feedback.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_531

LANGUAGE: python
CODE:
```
import streamlit as st
import time

with st.sidebar:
    with st.echo():
        st.write("This code will be printed to the sidebar.")

    with st.spinner("Loading..."):
        time.sleep(5)
    st.success("Done!")
```

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

TITLE: AppTest Initialization and Run Breakdown
DESCRIPTION: This Python snippet illustrates the two distinct steps involved in the common `AppTest.from_file().run()` pattern: first initializing the `AppTest` instance, and then explicitly running the simulated Streamlit app.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_222

LANGUAGE: python
CODE:
```
# Initialize the app.
at = AppTest.from_file("app.py")
# Run the app.
at.run()
```

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

TITLE: Install Python Libraries for Altair Chart Annotation
DESCRIPTION: This snippet lists the required Python libraries, including `streamlit`, `altair`, and `vega_datasets`, necessary for following the Altair chart annotation tutorial. It specifies a minimum version for Altair.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_847

LANGUAGE: txt
CODE:
```
streamlit
altair>=4.0.0
vega_datasets
```

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

TITLE: Set up Streamlit entrypoint file (Hello.py)
DESCRIPTION: This Python code defines the main entrypoint for a Streamlit multi-page application. It sets the page configuration, displays a welcome message, and provides links to Streamlit resources and complex demos. The file name `Hello.py` capitalizes the sidebar title and allows customization of the browser tab's title and favicon.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_60

LANGUAGE: python
CODE:
```
import streamlit as st

st.set_page_config(
    page_title="Hello",
    page_icon="👋"
)

st.write("# Welcome to Streamlit! 👋")

st.sidebar.success("Select a demo above.")

st.markdown(
    """
    Streamlit is an open-source app framework built specifically for
    Machine Learning and Data Science projects.
    **👈 Select a demo from the sidebar** to see some examples
    of what Streamlit can do!
    ### Want to learn more?
    - Check out [streamlit.io](https://streamlit.io)
    - Jump into our [documentation](https://docs.streamlit.io)
    - Ask a question in our [community
        forums](https://discuss.streamlit.io)
    ### See more complex demos
    - Use a neural net to [analyze the Udacity Self-driving Car Image
        Dataset](https://github.com/streamlit/demo-self-driving)
    - Explore a [New York City rideshare dataset](https://github.com/streamlit/demo-uber-nyc-pickups)
"""
)
```

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

TITLE: Streamlit App Test Example
DESCRIPTION: A pytest test script for the Streamlit bean counter app. It initializes the app using `AppTest`, simulates user interactions like incrementing a number input and clicking a button, and asserts the final output.

SOURCE: https://github.com/streamlit/docs/blob/main/content/develop/concepts/app-testing/get-started.md#_snippet_2

LANGUAGE: python
CODE:
```
"""test_app.py"""
from streamlit.testing.v1 import AppTest

def test_increment_and_add():
    """A user increments the number input, then clicks Add"""
    at = AppTest.from_file("app.py").run()
    at.number_input[0].increment().run()
    at.button[0].click().run()
    assert at.markdown[0].value == "Beans counted: 1"
```

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

TITLE: Deprecated Streamlit Snowpark Connection
DESCRIPTION: Example of using the deprecated `st.connection` for Snowpark. Note that this connection type is no longer recommended.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_656

LANGUAGE: Python
CODE:
```
conn = st.connection("snowpark")
```

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

TITLE: Example Neon PostgreSQL database connection string
DESCRIPTION: Illustrates the format of a Neon PostgreSQL database connection string, including the owner, host, and database name. This string is essential for establishing a secure connection to the database.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_817

LANGUAGE: bash
CODE:
```
postgresql://neondb_owner:xxxxxxxxxxxx@ep-adjective-noun-xxxxxxxx.us-east-2.aws.neon.tech/neondb?sslmode=require
```

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

TITLE: Set Streamlit Application Title
DESCRIPTION: Sets the main title of the Streamlit application using `st.title()` to '🦜🔗 Quickstart App'.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_768

LANGUAGE: python
CODE:
```
st.title("🦜🔗 Quickstart App")
```

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

TITLE: Install SQLAlchemy for Streamlit SQL Connections
DESCRIPTION: All Streamlit SQL connections rely on SQLAlchemy. This step installs the necessary SQLAlchemy library. While most SQL dialects require a separate driver, SQLite's driver is bundled with Python 3, making it unnecessary to install separately.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_136

LANGUAGE: bash
CODE:
```
pip install SQLAlchemy==1.4.0
```

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

TITLE: Clear All st.cache_data Caches Example
DESCRIPTION: This Python example demonstrates how to use `st.cache_data.clear()` to invalidate and remove all cached values from functions decorated with `@st.cache_data`. Pressing the 'Clear All' button will clear both in-memory and on-disk caches for all such functions.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_603

LANGUAGE: python
CODE:
```
import streamlit as st

@st.cache_data
def square(x):
    return x**2

@st.cache_data
def cube(x):
    return x**3

if st.button("Clear All"):
    # Clear values from *all* all in-memory and on-disk data caches:
    # i.e. clear values from both square and cube
    st.cache_data.clear()
```

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

TITLE: TOML Configuration File Example
DESCRIPTION: Example of setting server port in a Streamlit TOML configuration file. Configuration files can be global or per-project.

SOURCE: https://github.com/streamlit/docs/blob/main/content/develop/concepts/configuration/options.md#_snippet_0

LANGUAGE: toml
CODE:
```
[server]
port = 80
```

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

TITLE: Create Streamlit Project Files in Current Directory
DESCRIPTION: This example shows how to use `streamlit init` without a directory argument to create `requirements.txt` and `streamlit_app.py` directly in the current working directory. It also prompts to run the app immediately.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_738

LANGUAGE: bash
CODE:
```
streamlit init
```

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

TITLE: Git Commit and Push Workflow
DESCRIPTION: Illustrates the typical Git commands used to stage, commit, and push changes from a local codespace to a remote repository. This process is essential for deploying updates.

SOURCE: https://github.com/streamlit/docs/blob/main/content/get-started/installation/cloud-quickstart.md#_snippet_1

LANGUAGE: git
CODE:
```
# Stage changes
git add .

# Commit changes
git commit -m "<Your commit message>"

# Push changes to remote repository
git push origin main
```

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

TITLE: Start Development Server
DESCRIPTION: Starts the development server for the Streamlit documentation site using the 'make up' command. The docs will be viewable at http://localhost:3000.

SOURCE: https://github.com/streamlit/docs/blob/main/README.md#_snippet_4

LANGUAGE: make
CODE:
```
make up
```

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

TITLE: Install GitHub Package from Specific Commit Hash in requirements.txt
DESCRIPTION: Illustrates how to install a Python package from a specific Git commit hash in the 'requirements.txt' file, allowing for precise version control when deploying to Streamlit Community Cloud.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_1124

LANGUAGE: bash
CODE:
```
git+https://github.com/SomePackage.git@eb40b4ff6f7c5c1e4366cgfg0671291bge918#egg=SomePackage
```

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

TITLE: Run Streamlit App with Component (bash)
DESCRIPTION: Commands to activate the Python virtual environment, install the component as an editable package, and run the Streamlit example application. This is done from the respective template directory.

SOURCE: https://github.com/streamlit/docs/blob/main/content/develop/concepts/custom-components/components-api.md#_snippet_3

LANGUAGE: bash
CODE:
```
# React template
cd template
. venv/bin/activate # or similar to activate the venv/conda environment where Streamlit is installed
pip install -e . # install template as editable package
streamlit run my_component/example.py # run the example

# or

# TypeScript-only template
cd template-reactless
. venv/bin/activate # or similar to activate the venv/conda environment where Streamlit is installed
pip install -e . # install template as editable package
streamlit run my_component/example.py # run the example
```

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

TITLE: Streamlit AppTest Class API Reference
DESCRIPTION: This section provides an API reference for the `AppTest` class, which is central to testing Streamlit applications. It details the class methods for initializing a simulated app and the `run()` method for executing the app, along with how to retrieve elements.

SOURCE: https://github.com/streamlit/docs/blob/main/content/develop/concepts/app-testing/get-started.md#_snippet_14

LANGUAGE: APIDOC
CODE:
```
AppTest:
  - Class Methods:
    - from_file(path: str) -> AppTest
      - Description: Initializes AppTest with code from a file path.
      - Parameters:
        - path (str): The path to the Streamlit app page file.
      - Returns: An instance of AppTest.
    - from_string(code: str) -> AppTest
      - Description: Initializes AppTest with code from a string.
    - from_function(func: Callable) -> AppTest
      - Description: Initializes AppTest with code from a Python function.
  - Instance Methods:
    - run() -> AppTest
      - Description: Runs the simulated Streamlit app. Must be called explicitly for initial run and reruns.
      - Returns: The AppTest instance for chaining.
  - Attributes:
    - Elements (e.g., number_input, button, markdown): Sequences of elements sorted by display order. Can be retrieved by index or key (for widgets).
```

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

TITLE: Install Public GitHub Package in Streamlit requirements.txt
DESCRIPTION: Provides the basic syntax for installing a Python package from a public GitHub repository using 'pip' via the 'requirements.txt' file, which is supported for Streamlit Community Cloud deployments.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_1122

LANGUAGE: bash
CODE:
```
git+https://github.com/SomePackage#egg=SomePackage
```

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

TITLE: Execute Pytest Tests
DESCRIPTION: Commands to navigate to a project directory and execute pytest tests. Pytest scans for files prefixed with 'test_' and functions prefixed with 'test_' within those files.

SOURCE: https://github.com/streamlit/docs/blob/main/content/develop/concepts/app-testing/get-started.md#_snippet_7

LANGUAGE: bash
CODE:
```
cd myproject
pytest
```

LANGUAGE: bash
CODE:
```
cd myproject
pytest tests/
```

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

TITLE: Pyarrow Build Dependency Error During Streamlit Installation
DESCRIPTION: This error message indicates a failure during the installation of `pyarrow`, a dependency of Streamlit, often due to missing build tools like Visual C++ Build Tools on Windows. Resolving this typically requires installing the necessary development tools.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_1117

LANGUAGE: bash
CODE:
```
Using cached pyarrow-1.0.1.tar.gz (1.3 MB)
  Installing build dependencies ... error
  ERROR: Command errored out with exit status 1:
   command: 'c:\users\streamlit\appdata\local\programs\python\python38-32\python.exe' 'c:\users\streamlit\appdata\local\programs\python\python38-32\lib\site-packages\pip' install --ignore-installed --no-user --prefix 'C:\Users\streamlit\AppData\Local\Temp\pip-build-env-s7owjrle\overlay' --no-warn-script-location --no-binary :none: --only-binary :none: -i https://pypi.org/simple -- 'cython >= 0.29' 'numpy==1.14.5; python_version
```

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

TITLE: Frontend Package Management
DESCRIPTION: Provides examples of common npm commands used for managing dependencies and building custom components within the frontend directory.

SOURCE: https://github.com/streamlit/docs/blob/main/content/develop/concepts/custom-components/components-api.md#_snippet_12

LANGUAGE: bash
CODE:
```
# Add a new package
npm add baseui

# Build a static version of the component for deployment
npm run export
```

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

TITLE: Directory Structure for Custom Streamlit Navigation Example
DESCRIPTION: This snippet outlines the file structure for a Streamlit application demonstrating custom navigation. It includes a `.streamlit` directory for configuration files like `config.toml` and a `pages` directory for individual app pages.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_855

LANGUAGE: Text
CODE:
```
your-repository/
├── .streamlit/
│   └── config.toml
├── pages/
│   ├── admin.py
│   ├── super-admin.py
│   └── user.py
├── menu.py
└── app.py
```

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

TITLE: Complete Streamlit LLM Quickstart App
DESCRIPTION: This snippet provides the full 18-line Python code for a Streamlit application that interacts with OpenAI's LLM. It includes UI elements for API key input, a text area for prompts, and displays AI-generated responses.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_766

LANGUAGE: python
CODE:
```
import streamlit as st
from langchain_openai.chat_models import ChatOpenAI

st.title("🦜🔗 Quickstart App")

openai_api_key = st.sidebar.text_input("OpenAI API Key", type="password")


def generate_response(input_text):
    model = ChatOpenAI(temperature=0.7, api_key=openai_api_key)
    st.info(model.invoke(input_text))


with st.form("my_form"):
    text = st.text_area(
        "Enter text:",
        "What are the three key pieces of advice for learning how to code?",
    )
    submitted = st.form_submit_button("Submit")
    if not openai_api_key.startswith("sk-"):
        st.warning("Please enter your OpenAI API key!", icon="⚠")
    if submitted and openai_api_key.startswith("sk-"):
        generate_response(text)
```

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

TITLE: Streamlit Query Parameters URL Example
DESCRIPTION: This Javascript snippet provides an example of a Streamlit app URL containing multiple query parameters. It demonstrates the format of how parameters are appended to the URL, with the first parameter prefixed by '?' and subsequent ones by '&'.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_641

LANGUAGE: Javascript
CODE:
```
https://your_app.streamlit.app/?first_key=1=two=true
```

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

TITLE: Test Streamlit App with AppTest Class
DESCRIPTION: Demonstrates how to use the `st.testing.v1.AppTest` class to simulate a Streamlit app. This example initializes an app from a file, injects a secret, runs the app, and then simulates user input to test a text input widget and assert warnings.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_706

LANGUAGE: python
CODE:
```
from streamlit.testing.v1 import AppTest

at = AppTest.from_file("streamlit_app.py")
at.secrets["WORD"] = "Foobar"
at.run()
assert not at.exception

at.text_input("word").input("Bazbat").run()
assert at.warning[0].value == "Try again."
```

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

TITLE: Install Streamlit Custom Component using pip
DESCRIPTION: This snippet shows the command to install a Streamlit custom component, specifically `streamlit-aggrid`, using the `pip` package manager. This is the first step required before importing and using the component in your Python application.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_162

LANGUAGE: python
CODE:
```
pip install streamlit-aggrid
```

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

TITLE: Recommended Repository Structure for Streamlit Deployment
DESCRIPTION: Illustrates the recommended file structure for deploying a Streamlit application to Streamlit Cloud, including the app file and a requirements file.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_773

LANGUAGE: text
CODE:
```
your-repository/
├── streamlit_app.py
└── requirements.txt
```

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

TITLE: Streamlit AppTest: Element Order with Containers
DESCRIPTION: Demonstrates how `AppTest` sequences elements based on their visual appearance on the page, which can differ from the order they are defined in the code when using Streamlit containers. The example shows two buttons defined in one order but appearing in a different order due to container placement, and how `AppTest` reflects the visual order.

SOURCE: https://github.com/streamlit/docs/blob/main/content/develop/concepts/app-testing/get-started.md#_snippet_15

LANGUAGE: python
CODE:
```
import streamlit as st

first = st.container()
second = st.container()

second.button("A")
first.button("B")
```

LANGUAGE: python
CODE:
```
assert at.button[0].label == "B"
assert at.button[1].label == "A"
```

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

TITLE: Example Streamlit Application Code
DESCRIPTION: A sample Streamlit application demonstrating how to create an interactive spiral chart using `st.slider` for user input and `st.altair_chart` for data visualization. It showcases basic Streamlit components and data manipulation with pandas and altair.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_1084

LANGUAGE: python
CODE:
```
from collections import namedtuple
import altair as alt
import math
import pandas as pd
import streamlit as st

"""
# Welcome to Streamlit!

Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:

If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
forums](https://discuss.streamlit.io).

In the meantime, below is an example of what you can do with just a few lines of code:
"""

with st.echo(code_location='below'):
   total_points = st.slider("Number of points in spiral", 1, 5000, 2000)
   num_turns = st.slider("Number of turns in spiral", 1, 100, 9)

   Point = namedtuple('Point', 'x y')
   data = []

   points_per_turn = total_points / num_turns

   for curr_point_num in range(total_points):
      curr_turn, i = divmod(curr_point_num, points_per_turn)
      angle = (curr_turn + 1) * 2 * math.pi * i / points_per_turn
      radius = curr_point_num / total_points
      x = radius * math.cos(angle)
      y = radius * math.sin(angle)
      data.append(Point(x, y))

   st.altair_chart(alt.Chart(pd.DataFrame(data), height=500, width=500)
      .mark_circle(color='#0068c9', opacity=0.5)
      .encode(x='x:Q', y='y:Q'))
```

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

TITLE: Create SQL table and insert sample data in Neon
DESCRIPTION: SQL commands to create a `home` table with `id`, `name`, and `pet` columns, and then insert three sample rows into it. This prepares the database with sample data for the Streamlit application.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_816

LANGUAGE: sql
CODE:
```
CREATE TABLE home (
    id SERIAL PRIMARY KEY,
    name VARCHAR(100),
    pet VARCHAR(100)
);

INSERT INTO home (name, pet)
VALUES
    ('Mary', 'dog'),
    ('John', 'cat'),
    ('Robert', 'bird');
```

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

TITLE: Define Secrets in Streamlit TOML File
DESCRIPTION: Example of a `secrets.toml` file structure for storing sensitive information like API keys for Streamlit applications.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_655

LANGUAGE: TOML
CODE:
```
OpenAI_key = "<YOUR_SECRET_KEY>"
```

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

TITLE: Initialize AppTest from File
DESCRIPTION: This Python snippet demonstrates how to initialize an `AppTest` instance by providing a relative path to the Streamlit application file, followed by immediately running the simulated app.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_219

LANGUAGE: python
CODE:
```
# Path to app file is relative to myproject/
at = AppTest.from_file("app.py").run()
```

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

TITLE: Streamlit AppTest Class and Instance Methods
DESCRIPTION: Documentation for the `AppTest` class in Streamlit's testing framework, detailing its initialization methods (`from_file`, `from_string`, `from_function`) and the `run()` method for executing the simulated app.

SOURCE: https://github.com/streamlit/docs/blob/main/public/llms-full.txt#_snippet_223

LANGUAGE: APIDOC
CODE:
```
AppTest:
  Class Methods:
    from_file(path: str) -> AppTest:
      description: Initializes an AppTest instance from a file path.
      parameters:
        path: The path to the Streamlit app page file.
      returns: An initialized AppTest instance.

    from_string(code: str) -> AppTest:
      description: Initializes an AppTest instance from a string containing app code.
      parameters:
        code: The Streamlit app code as a string.
      returns: An initialized AppTest instance.

    from_function(func: Callable) -> AppTest:
      description: Initializes an AppTest instance from a Python function.
      parameters:
        func: The Python function representing the Streamlit app.
      returns: An initialized AppTest instance.

  Instance Methods:
    run() -> AppTest:
      description: Runs the simulated Streamlit app. This method must be explicitly called for the app's first run and any subsequent reruns due to simulated user input.
      returns: The AppTest instance, allowing for method chaining.
```