[
{
"path": ".cargo/config",
"content": "[target.x86_64-apple-darwin]\nrustflags = [\n \"-C\", \"link-arg=-undefined\",\n \"-C\", \"link-arg=dynamic_lookup\",\n]\n\n[target.aarch64-apple-darwin]\nrustflags = [\n \"-C\", \"link-arg=-undefined\",\n \"-C\", \"link-arg=dynamic_lookup\",\n]\n"
},
{
"path": ".github/FUNDING.yml",
"content": "# These are supported funding model platforms\n\ngithub: [sansyrox] # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]\n#patreon: # Replace with a single Patreon username\nopen_collective: robyn_oss # Replace with a single Open Collective username\n#ko_fi: # Replace with a single Ko-fi username\n#tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel\n#community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry\n# liberapay: # Replace with a single Liberapay username\n# issuehunt: # Replace with a single IssueHunt username\n# otechie: # Replace with a single Otechie username\n# lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry\n# custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']\n"
},
{
"path": ".github/ISSUE_TEMPLATE/blank_issue.md",
"content": "---\nname: 📝 Blank Issue\nabout: Create a blank issue.\n---"
},
{
"path": ".github/ISSUE_TEMPLATE/bug_report.yml",
"content": "name: 🐛 Bug Report\ndescription: Create a bug report\nlabels: [bug]\nbody:\n - type: markdown\n attributes:\n value: |\n Thank you for taking the time to fill out this bug report!\n Please fill out the form below...\n - type: textarea\n id: description\n attributes:\n label: Bug Description\n description: Please provide a clear and concise description of what the bug is, and what you would expect to happen.\n placeholder: The bug is...\n validations:\n required: true\n - type: textarea\n id: reproduce\n attributes:\n label: Steps to Reproduce\n description: Please provide the steps to reproduce this bug. You can include your code here if it is relevant.\n placeholder: |\n 1.\n 2.\n 3.\n validations:\n required: false\n - type: dropdown\n id: os\n attributes:\n label: Your operating system\n options:\n - Windows\n - MacOS\n - Linux\n - Other (specify below)\n validations:\n required: false\n - type: dropdown\n id: py_version\n attributes:\n label: Your Python version (`python --version`)\n options:\n - 3.9\n - 3.10\n - 3.11\n - 3.12\n - 3.13\n - Other (specify below)\n validations:\n required: false\n - type: dropdown\n id: robyn_version\n attributes:\n label: Your Robyn version\n options:\n - main branch\n - latest\n - Other (specify below)\n validations:\n required: false\n - type: textarea\n id: additional-info\n attributes:\n label: Additional Info\n description: Any additional info that you think might be useful or relevant to this bug\n"
},
{
"path": ".github/ISSUE_TEMPLATE/config.yml",
"content": "blank_issues_enabled: true\ncontact_links:\n - name: Discord Community Support\n url: https://discord.gg/rkERZ5eNU8\n about: You can ask and answer questions here.\n - name: Documentation\n url: https://robyn.tech\n about: The Robyn documentation.\n"
},
{
"path": ".github/ISSUE_TEMPLATE/feature_request.md",
"content": "---\nname: 💡 Feature request\nabout: Suggest an idea to improve Robyn\nlabels: [enhancement]\n---\n\n"
},
{
"path": ".github/dependabot.yml",
"content": "# Keep GitHub Actions up to date with GitHub's Dependabot...\n# https://docs.github.com/en/code-security/dependabot/working-with-dependabot/keeping-your-actions-up-to-date-with-dependabot\n# https://docs.github.com/en/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file#package-ecosystem\nversion: 2\nupdates:\n - package-ecosystem: github-actions\n directory: /\n groups:\n github-actions:\n patterns:\n - \"*\" # Group all Actions updates into a single larger pull request\n schedule:\n interval: weekly\n"
},
{
"path": ".github/pull_request_template.md",
"content": "## Description\n\nThis PR fixes #\n\n## Summary\n\nThis PR does....\n\n\n\n## PR Checklist\n\nPlease ensure that:\n\n- [ ] The PR contains a descriptive title\n- [ ] The PR contains a descriptive summary of the changes\n- [ ] You build and test your changes before submitting a PR.\n- [ ] You have added relevant documentation\n- [ ] You have added relevant tests. We prefer integration tests wherever possible\n\n## Pre-Commit Instructions:\n\n- [ ] Ensure that you have run the [pre-commit hooks](https://github.com/sparckles/robyn#%EF%B8%8F-to-develop-locally) on your PR.\n\n"
},
{
"path": ".github/workflows/codspeed.yml",
"content": "name: codspeed-benchmarks\n\non:\n push:\n branches:\n - \"main\" # or \"master\"\n pull_request:\n # `workflow_dispatch` allows CodSpeed to trigger backtest\n # performance analysis in order to generate initial data.\n workflow_dispatch:\n\n\njobs:\n benchmarks:\n runs-on: ubuntu-22.04\n steps:\n - uses: actions/checkout@v4\n\n - name: Set up Python\n uses: actions/setup-python@v6\n with:\n python-version: \"3.10\"\n\n - name: Install uv\n uses: astral-sh/setup-uv@v6\n with:\n version: \"0.7.5\"\n\n - name: Install the project + deps.\n run: |\n echo \"# Syncing Project + Installing project.\"\n uv sync --dev --group test --verbose\n\n - name: Run benchmarks\n uses: CodSpeedHQ/action@v3.5.0\n with:\n token: ${{ secrets.CODSPEED_TOKEN }}\n run: uv run pytest integration_tests --codspeed\n\n"
},
{
"path": ".github/workflows/lint-pr.yml",
"content": "name: Lint PR\n\non:\n pull_request:\n branches: [main]\n\n\nenv:\n UV_SYSTEM_PYTHON: 1\n\njobs:\n lint:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@v4\n - name: Install uv\n uses: astral-sh/setup-uv@v3\n\n - uses: actions/setup-python@v6\n with:\n python-version: \"3.11\"\n\n - name: Install dependencies with uv\n run: |\n uv pip install ruff isort black\n - name: Run linters\n run: |\n uv run ruff check .\n uv run isort --check-only --diff .\n"
},
{
"path": ".github/workflows/preview-deployments.yml",
"content": "# CI to release the project for Linux, Windows, and MacOS\n# The purpose of this action is to verify if the release builds are working or not.\n\nname: Preview Release\n\non:\n push:\n branches:\n - main\n pull_request:\n branches:\n - main\n\nenv:\n UV_SYSTEM_PYTHON: 1\n\njobs:\n macos:\n runs-on: macos-latest\n strategy:\n matrix:\n python-version: [\"3.10\", \"3.11\", \"3.12\", \"3.13\", \"3.14\"]\n steps:\n - uses: actions/checkout@v4\n - name: Install uv\n uses: astral-sh/setup-uv@v3\n - uses: actions/setup-python@v6\n with:\n python-version: ${{ matrix.python-version }}\n - uses: dtolnay/rust-toolchain@stable\n with:\n targets: aarch64-apple-darwin\n - name: Build wheels - x86_64\n uses: PyO3/maturin-action@v1\n with:\n target: x86_64\n args: -i python --release --out dist\n - name: Build wheels - universal2\n uses: PyO3/maturin-action@v1\n with:\n target: universal2-apple-darwin\n args: -i python --release --out dist\n - name: Install build wheel - universal2\n run: |\n uv pip install --force-reinstall dist/robyn*_universal2.whl\n cd ~ && python -c 'import robyn'\n\n windows:\n runs-on: windows-latest\n strategy:\n matrix:\n python-version: [\"3.10\", \"3.11\", \"3.12\", \"3.13\", \"3.14\"]\n target: [x64, x86]\n steps:\n - uses: actions/checkout@v4\n - name: Install uv\n uses: astral-sh/setup-uv@v3\n - uses: actions/setup-python@v6\n with:\n python-version: ${{ matrix.python-version }}\n architecture: ${{ matrix.target }}\n - uses: dtolnay/rust-toolchain@stable\n - name: Build wheels\n uses: PyO3/maturin-action@v1\n with:\n target: ${{ matrix.target }}\n args: -i python --release --out dist\n - name: Install build wheel\n shell: bash\n run: |\n uv pip install --force-reinstall dist/robyn*.whl\n cd ~ && python -c 'import robyn'\n\n linux:\n runs-on: ubuntu-latest\n strategy:\n matrix:\n python-version: [\"3.10\", \"3.11\", \"3.12\", \"3.13\", \"3.14\"]\n target: [x86_64, i686]\n steps:\n - uses: actions/checkout@v4\n - uses: dtolnay/rust-toolchain@stable\n - name: Install uv\n uses: astral-sh/setup-uv@v3\n - uses: actions/setup-python@v6\n with:\n python-version: ${{ matrix.python-version }}\n - name: Build Wheels\n uses: PyO3/maturin-action@v1\n with:\n target: ${{ matrix.target }}\n manylinux: auto\n args: -i python${{ matrix.python-version }} --release --out dist\n - name: Install build wheel\n if: matrix.target == 'x86_64'\n run: |\n uv pip install --force-reinstall dist/robyn*.whl\n cd ~ && python -c 'import robyn'\n\n linux-cross:\n runs-on: ubuntu-latest\n strategy:\n fail-fast: false\n matrix:\n python:\n [\n { version: \"3.10\", abi: \"cp310-cp310\" },\n { version: \"3.11\", abi: \"cp311-cp311\" },\n { version: \"3.12\", abi: \"cp312-cp312\" },\n { version: \"3.13\", abi: \"cp313-cp313\" },\n { version: \"3.14\", abi: \"cp314-cp314\" },\n ]\n target: [aarch64, armv7]\n steps:\n - uses: actions/checkout@v3\n - name: Build Wheels\n uses: PyO3/maturin-action@v1\n env:\n PYO3_CROSS_LIB_DIR: /opt/python/${{ matrix.python.abi }}/lib\n with:\n target: ${{ matrix.target }}\n manylinux: auto\n args: -i python${{matrix.python.version}} --release --out dist\n - uses: uraimo/run-on-arch-action@v2\n name: Install build wheel\n with:\n arch: ${{ matrix.target }}\n distro: ubuntu22.04\n githubToken: ${{ github.token }}\n # Mount the dist directory as /artifacts in the container\n dockerRunArgs: |\n --volume \"${PWD}/dist:/artifacts\"\n install: |\n apt update -y\n apt install -y software-properties-common\n add-apt-repository -y ppa:deadsnakes/ppa\n apt update -y\n apt install -y gcc musl-dev python3-dev python${{ matrix.python.version }} python${{ matrix.python.version }}-venv\n run: |\n ls -lrth /artifacts\n python${{ matrix.python.version }} -m venv venv\n source venv/bin/activate\n python -m pip install --upgrade pip setuptools wheel\n python -m pip install --force-reinstall /artifacts/robyn*.whl\n cd ~ && python -c 'import robyn'\n"
},
{
"path": ".github/workflows/python-CI.yml",
"content": "# CI to test Robyn on major Linux, MacOS and Windows\n\non: [push, pull_request]\n\nname: Python Continuous integration\n\njobs:\n tests:\n strategy:\n fail-fast: false\n matrix:\n os: [\"windows\", \"ubuntu\", \"macos\"]\n python-version: [\"3.10\", \"3.11\", \"3.12\", \"3.13\", \"3.14\"]\n name: ${{ matrix.os }} tests with python ${{ matrix.python-version }}\n runs-on: ${{ matrix.os }}-latest\n steps:\n - uses: actions/checkout@v4\n - name: Set up Python ${{ matrix.python-version }}\n uses: actions/setup-python@v6\n with:\n python-version: ${{ matrix.python-version }}\n - name: Set up Nox\n uses: wntrblm/nox@2024.03.02\n with:\n python-versions: ${{ matrix.python-version }}\n - name: Test with Nox\n run: nox --non-interactive --error-on-missing-interpreter -p ${{ matrix.python-version }}\n"
},
{
"path": ".github/workflows/release-CI.yml",
"content": "# CI to release the project for Linux, Windows, and MacOS\nname: Release CI\non:\n push:\n tags:\n - v*\n workflow_dispatch:\n inputs:\n enable_linux_cross:\n description: 'Enable Linux cross-compilation (ARM64/ARMv7)'\n required: false\n default: true\n type: boolean\n \nenv:\n UV_SYSTEM_PYTHON: 1\njobs:\n macos:\n runs-on: macos-latest\n strategy:\n matrix:\n python-version: [\"3.10\", \"3.11\", \"3.12\", \"3.13\", \"3.14\"]\n steps:\n - uses: actions/checkout@v3\n - name: Install uv\n uses: astral-sh/setup-uv@v3\n - uses: actions/setup-python@v6\n with:\n python-version: ${{ matrix.python-version }}\n - uses: dtolnay/rust-toolchain@stable\n with:\n targets: aarch64-apple-darwin\n - name: Build wheels - x86_64\n uses: PyO3/maturin-action@v1\n with:\n target: x86_64\n args: -i python --release --out dist\n - name: Build wheels - universal2\n uses: PyO3/maturin-action@v1\n with:\n target: universal2-apple-darwin\n args: -i python --release --out dist\n - name: Install build wheel - universal2\n run: |\n uv pip install --force-reinstall dist/robyn*_universal2.whl\n cd ~ && python -c 'import robyn'\n - name: Upload wheels\n uses: actions/upload-artifact@v4\n with:\n name: wheels-${{ github.job }}-universal-${{ matrix.python-version }}\n path: dist\n windows:\n runs-on: windows-latest\n strategy:\n matrix:\n python-version: [\"3.10\", \"3.11\", \"3.12\", \"3.13\", \"3.14\"]\n target: [x64, x86]\n steps:\n - uses: actions/checkout@v3\n - name: Install uv\n uses: astral-sh/setup-uv@v3\n - uses: actions/setup-python@v6\n with:\n python-version: ${{ matrix.python-version }}\n architecture: ${{ matrix.target }}\n - uses: dtolnay/rust-toolchain@stable\n - name: Build wheels\n uses: PyO3/maturin-action@v1\n with:\n target: ${{ matrix.target }}\n args: -i python --release --out dist\n - name: Install build wheel\n shell: bash\n run: |\n uv pip install --force-reinstall dist/robyn*.whl\n cd ~ && python -c 'import robyn'\n - name: Upload wheels\n uses: actions/upload-artifact@v4\n with:\n name: wheels-${{ github.job }}-${{ matrix.target }}-${{ matrix.python-version }}\n path: dist\n linux:\n runs-on: ubuntu-latest\n strategy:\n matrix:\n python-version: [\"3.10\", \"3.11\", \"3.12\", \"3.13\", \"3.14\"]\n target: [x86_64, i686]\n steps:\n - uses: actions/checkout@v3\n - uses: dtolnay/rust-toolchain@stable\n - name: Install uv\n uses: astral-sh/setup-uv@v3\n - uses: actions/setup-python@v6\n with:\n python-version: ${{ matrix.python-version }}\n - name: Build Wheels\n uses: PyO3/maturin-action@v1\n with:\n target: ${{ matrix.target }}\n manylinux: auto\n args: -i python${{ matrix.python-version }} --release --out dist\n - name: Install build wheel\n if: matrix.target == 'x86_64'\n run: |\n uv pip install --force-reinstall dist/robyn*.whl\n cd ~ && python -c 'import robyn'\n - name: Upload wheels\n uses: actions/upload-artifact@v4\n with:\n name: wheels-${{ github.job }}-${{ matrix.target }}-${{ matrix.python-version }}\n path: dist\n linux-cross:\n runs-on: ubuntu-latest\n if: github.event_name == 'push' || (github.event_name == 'workflow_dispatch' && inputs.enable_linux_cross)\n strategy:\n matrix:\n python:\n [\n { version: \"3.10\", abi: \"cp310-cp310\" },\n { version: \"3.11\", abi: \"cp311-cp311\" },\n { version: \"3.12\", abi: \"cp312-cp312\" },\n { version: \"3.13\", abi: \"cp313-cp313\" },\n ]\n target: [aarch64, armv7]\n steps:\n - uses: actions/checkout@v3\n - name: Build Wheels\n uses: PyO3/maturin-action@v1\n env:\n PYO3_CROSS_LIB_DIR: /opt/python/${{ matrix.python.abi }}/lib\n with:\n target: ${{ matrix.target }}\n manylinux: auto\n maturin-version: \"v1.12.0\"\n args: -i python${{matrix.python.version}} --release --out dist\n - uses: uraimo/run-on-arch-action@v2\n name: Install build wheel\n with:\n arch: ${{ matrix.target }}\n distro: ubuntu22.04\n githubToken: ${{ github.token }}\n # Mount the dist directory as /artifacts in the container\n dockerRunArgs: |\n --volume \"${PWD}/dist:/artifacts\"\n install: |\n apt update -y\n apt install -y software-properties-common\n add-apt-repository -y ppa:deadsnakes/ppa\n apt update -y\n apt install -y gcc musl-dev python3-dev python${{ matrix.python.version }} python${{ matrix.python.version }}-venv\n run: |\n ls -lrth /artifacts\n python${{ matrix.python.version }} -m venv venv\n source venv/bin/activate\n python -m pip install --upgrade pip setuptools wheel\n python -m pip install --force-reinstall /artifacts/robyn*.whl\n cd ~ && python -c 'import robyn'\n - name: Upload wheels\n uses: actions/upload-artifact@v4\n with:\n name: wheels-${{ github.job }}-${{ matrix.target }}-${{ matrix.python.version }}-${{ matrix.python.abi }}\n path: dist\n merge:\n name: Building Single Artifact\n runs-on: ubuntu-latest\n needs: [macos, windows, linux, linux-cross]\n if: always() && needs.macos.result == 'success' && needs.windows.result == 'success' && needs.linux.result == 'success' && (needs.linux-cross.result == 'success' || needs.linux-cross.result == 'skipped')\n steps:\n - name: Downloading all Artifacts\n uses: actions/download-artifact@v4\n with:\n path: artifacts\n pattern: wheels-*\n merge-multiple: true\n - run: |\n echo \"Listing directories\"\n ls -R\n - name: Uploading Artifact's Bundle\n uses: actions/upload-artifact@v4\n with:\n name: wheels\n path: artifacts\n\n release:\n name: Release\n runs-on: ubuntu-latest\n needs: [macos, windows, linux, linux-cross, merge]\n if: always() && needs.merge.result == 'success'\n steps:\n - uses: actions/download-artifact@v4\n with:\n name: wheels\n - name: Install uv\n uses: astral-sh/setup-uv@v3\n - uses: actions/setup-python@v6\n with:\n python-version: 3.x\n - name: Publish to PyPi\n env:\n TWINE_USERNAME: __token__\n TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }}\n run: |\n uv pip install --upgrade twine\n twine upload --skip-existing *.whl\n"
},
{
"path": ".github/workflows/rust-CI.yml",
"content": "# CI to build, test, format, and lint the Rust code\n\non: [push, pull_request]\n\nname: Rust Continuous integration\n\njobs:\n check:\n name: Check\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@v4\n - uses: dtolnay/rust-toolchain@stable\n - run: cargo check\n\n test:\n name: Test Suite\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@v4\n - uses: dtolnay/rust-toolchain@stable\n - run: cargo test\n\n fmt:\n name: Rustfmt\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@v4\n - uses: dtolnay/rust-toolchain@stable\n with:\n components: rustfmt\n - run: cargo fmt --check\n\n clippy:\n name: Clippy\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@v4\n - uses: dtolnay/rust-toolchain@stable\n with:\n components: clippy\n - run: cargo clippy\n # -- -D warnings\n\n"
},
{
"path": ".gitignore",
"content": ".python-version\n/target\n\n# ignore pre compiled binaries\n*.so\ndist/\n\n#python cache\n*__pycache__\n*tags\n\n# DS_Store\n*.DS_Store\n.vscode\n\n# pycharm\n.idea\n\n# python venv\n.venv\nvenv\nrobyn.code-workspace\nhello_robyn.py\nrobyn.env\n\n# nox\n.nox/\n\n# new docs dependencies\n# dependencies\ndocs_src/node_modules\ndocs_src/.pnp\ndocs_src/.pnp.js\n\n# testing\ndocs_src/coverage\n\n# next.js\ndocs_src/.next/\ndocs_src/out/\n\n# production\ndocs_src/build\n\n# misc\ndocs_src/.DS_Store\ndocs_src/*.pem\n\n# debug\ndocs_src/npm-debug.log*\ndocs_src/yarn-debug.log*\ndocs_src/yarn-error.log*\ndocs_src/.pnpm-debug.log*\n\n# local env files\ndocs_src/.env*.local\n\n# vercel\ndocs_src/.vercel\n\n# generated files\ndocs_src/public/rss/\n\n#https://github.com/PyO3/maturin/issues/2141\n*.pyd"
},
{
"path": ".pre-commit-config.yaml",
"content": "repos:\n - repo: https://github.com/astral-sh/ruff-pre-commit\n rev: v0.14.13\n hooks:\n - id: ruff\n args:\n - --fix\n - id: ruff-format\n\nci:\n autoupdate_schedule: weekly\n"
},
{
"path": ".well-known/funding-manifest-urls",
"content": "https://robyn.tech/funding.json\n"
},
{
"path": "CHANGELOG.md",
"content": "# Changelog\n\n## [Unreleased](https://github.com/sparckles/robyn/tree/HEAD)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.26.1...HEAD)\n\n**Implemented enhancements:**\n\n- Allow empty returns on websocket handling [\\#1263](https://github.com/sparckles/robyn/issues/1263)\n\n**Closed issues:**\n\n- Payload reached size limit. [\\#463](https://github.com/sparckles/robyn/issues/463)\n- Proposal to rename `params` with `path_params` [\\#457](https://github.com/sparckles/robyn/issues/457)\n\n**Merged pull requests:**\n\n- feat: allow configurable payload sizes [\\#465](https://github.com/sparckles/robyn/pull/465) ([sansyrox](https://github.com/sansyrox))\n- docs: remove test pypi instructions from pr template [\\#462](https://github.com/sparckles/robyn/pull/462) ([sansyrox](https://github.com/sansyrox))\n- Rename params with path\\_params [\\#460](https://github.com/sparckles/robyn/pull/460) ([carlosm27](https://github.com/carlosm27))\n- feat: Implement global CORS [\\#458](https://github.com/sparckles/robyn/pull/458) ([sansyrox](https://github.com/sansyrox))\n\n## [v0.26.1](https://github.com/sparckles/robyn/tree/v0.26.1) (2023-04-05)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.26.0...v0.26.1)\n\n**Fixed bugs:**\n\n- Can't access new or updated route while on dev option [\\#439](https://github.com/sparckles/robyn/issues/439)\n\n**Closed issues:**\n\n- Add documentation for `robyn.env` file [\\#454](https://github.com/sparckles/robyn/issues/454)\n\n**Merged pull requests:**\n\n- Release v0.26.1 [\\#461](https://github.com/sparckles/robyn/pull/461) ([sansyrox](https://github.com/sansyrox))\n- \\[pre-commit.ci\\] pre-commit autoupdate [\\#459](https://github.com/sparckles/robyn/pull/459) ([pre-commit-ci[bot]](https://github.com/apps/pre-commit-ci))\n- \\[pre-commit.ci\\] pre-commit autoupdate [\\#452](https://github.com/sparckles/robyn/pull/452) ([pre-commit-ci[bot]](https://github.com/apps/pre-commit-ci))\n- docs: Add docs for v0.26.0 [\\#451](https://github.com/sparckles/robyn/pull/451) ([sansyrox](https://github.com/sansyrox))\n- fix\\(dev\\): fix hot reloading with dev flag [\\#446](https://github.com/sparckles/robyn/pull/446) ([AntoineRR](https://github.com/AntoineRR))\n\n## [v0.26.0](https://github.com/sparckles/robyn/tree/v0.26.0) (2023-03-24)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.25.0...v0.26.0)\n\n**Implemented enhancements:**\n\n- \\[Feature Request\\] Robyn providing Status Codes? [\\#423](https://github.com/sparckles/robyn/issues/423)\n- \\[Feature Request\\] Allow global level Response headers [\\#335](https://github.com/sparckles/robyn/issues/335)\n\n**Fixed bugs:**\n\n- \\[BUG\\] `uvloop` ModuleNotFoundError: No module named 'uvloop' on Ubuntu Docker Image [\\#395](https://github.com/sparckles/robyn/issues/395)\n\n**Closed issues:**\n\n- \\[Feature Request\\] When Robyn can have a middleware mechanism like flask or django [\\#350](https://github.com/sparckles/robyn/issues/350)\n- Forced shutdown locks console. \\[BUG\\] [\\#317](https://github.com/sparckles/robyn/issues/317)\n\n**Merged pull requests:**\n\n- \\[pre-commit.ci\\] pre-commit autoupdate [\\#449](https://github.com/sparckles/robyn/pull/449) ([pre-commit-ci[bot]](https://github.com/apps/pre-commit-ci))\n- fix: Implement auto installation of uvloop on linux arm [\\#445](https://github.com/sparckles/robyn/pull/445) ([sansyrox](https://github.com/sansyrox))\n- chore: update rust dependencies [\\#444](https://github.com/sparckles/robyn/pull/444) ([AntoineRR](https://github.com/AntoineRR))\n- feat: Implement performance benchmarking [\\#443](https://github.com/sparckles/robyn/pull/443) ([sansyrox](https://github.com/sansyrox))\n- feat: expose request/connection info [\\#441](https://github.com/sparckles/robyn/pull/441) ([r3b-fish](https://github.com/r3b-fish))\n- Install the CodeSee workflow. [\\#438](https://github.com/sparckles/robyn/pull/438) ([codesee-maps[bot]](https://github.com/apps/codesee-maps))\n- \\[pre-commit.ci\\] pre-commit autoupdate [\\#437](https://github.com/sparckles/robyn/pull/437) ([pre-commit-ci[bot]](https://github.com/apps/pre-commit-ci))\n- Replace integer status codes with Enum values of StatusCodes [\\#436](https://github.com/sparckles/robyn/pull/436) ([Noborita9](https://github.com/Noborita9))\n- added `star-history` [\\#434](https://github.com/sparckles/robyn/pull/434) ([hemangjoshi37a](https://github.com/hemangjoshi37a))\n- \\[pre-commit.ci\\] pre-commit autoupdate [\\#433](https://github.com/sparckles/robyn/pull/433) ([pre-commit-ci[bot]](https://github.com/apps/pre-commit-ci))\n- feat: Robyn providing status codes [\\#429](https://github.com/sparckles/robyn/pull/429) ([carlosm27](https://github.com/carlosm27))\n- feat: Allow global level Response headers [\\#410](https://github.com/sparckles/robyn/pull/410) ([ParthS007](https://github.com/ParthS007))\n- feat: get rid of intermediate representations of requests and responses [\\#397](https://github.com/sparckles/robyn/pull/397) ([AntoineRR](https://github.com/AntoineRR))\n\n## [v0.25.0](https://github.com/sparckles/robyn/tree/v0.25.0) (2023-02-20)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.24.1...v0.25.0)\n\n**Implemented enhancements:**\n\n- using robyn with some frameworks [\\#420](https://github.com/sparckles/robyn/issues/420)\n\n**Fixed bugs:**\n\n- Template Rendering is not working in some browsers [\\#426](https://github.com/sparckles/robyn/issues/426)\n\n**Closed issues:**\n\n- \\[Feature Request\\] Show support for Python versions in the README [\\#396](https://github.com/sparckles/robyn/issues/396)\n- \\[BUG\\] The dev flag doesn't set the log level to DEBUG [\\#385](https://github.com/sparckles/robyn/issues/385)\n- \\[BUG\\] All tests are not passing on windows [\\#372](https://github.com/sparckles/robyn/issues/372)\n- \\[Feature Request\\] Add views/view controllers [\\#221](https://github.com/sparckles/robyn/issues/221)\n\n**Merged pull requests:**\n\n- fix: Add proper headers to the templates return types [\\#427](https://github.com/sparckles/robyn/pull/427) ([sansyrox](https://github.com/sansyrox))\n- \\[pre-commit.ci\\] pre-commit autoupdate [\\#425](https://github.com/sparckles/robyn/pull/425) ([pre-commit-ci[bot]](https://github.com/apps/pre-commit-ci))\n- docs: Add documentation for views [\\#424](https://github.com/sparckles/robyn/pull/424) ([sansyrox](https://github.com/sansyrox))\n- better way to compare type [\\#421](https://github.com/sparckles/robyn/pull/421) ([jmishra01](https://github.com/jmishra01))\n- style\\(landing\\_page\\): fix the style of github logo on the landing page [\\#419](https://github.com/sparckles/robyn/pull/419) ([sansyrox](https://github.com/sansyrox))\n- docs: improve readme [\\#418](https://github.com/sparckles/robyn/pull/418) ([AntoineRR](https://github.com/AntoineRR))\n- docs: add dark mode to website [\\#416](https://github.com/sparckles/robyn/pull/416) ([AntoineRR](https://github.com/AntoineRR))\n- chore: improve issue templates [\\#413](https://github.com/sparckles/robyn/pull/413) ([AntoineRR](https://github.com/AntoineRR))\n- \\[pre-commit.ci\\] pre-commit autoupdate [\\#412](https://github.com/sparckles/robyn/pull/412) ([pre-commit-ci[bot]](https://github.com/apps/pre-commit-ci))\n- fix: fixed CONTRIBUTE.md link into docs/README.md file, changing it f… [\\#411](https://github.com/sparckles/robyn/pull/411) ([Kop3sh](https://github.com/Kop3sh))\n- chore\\(ci\\): fix rust ci warnings [\\#408](https://github.com/sparckles/robyn/pull/408) ([AntoineRR](https://github.com/AntoineRR))\n- feat: Add view controllers [\\#407](https://github.com/sparckles/robyn/pull/407) ([mikaeelghr](https://github.com/mikaeelghr))\n- Fix docs: support version [\\#404](https://github.com/sparckles/robyn/pull/404) ([Oluwaseun241](https://github.com/Oluwaseun241))\n- fix: Fix Windows tests [\\#402](https://github.com/sparckles/robyn/pull/402) ([sansyrox](https://github.com/sansyrox))\n- docs: Update PyPi metadata [\\#401](https://github.com/sparckles/robyn/pull/401) ([sansyrox](https://github.com/sansyrox))\n- fix\\(test\\): fix tests on windows [\\#400](https://github.com/sparckles/robyn/pull/400) ([AntoineRR](https://github.com/AntoineRR))\n- fix: various improvements around the dev flag [\\#388](https://github.com/sparckles/robyn/pull/388) ([AntoineRR](https://github.com/AntoineRR))\n\n## [v0.24.1](https://github.com/sparckles/robyn/tree/v0.24.1) (2023-02-09)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.24.0...v0.24.1)\n\n**Closed issues:**\n\n- \\[BUG\\] \\[Windows\\] Terminal hanging after Ctrl+C is pressed on Robyn server [\\#373](https://github.com/sparckles/robyn/issues/373)\n\n**Merged pull requests:**\n\n- \\[pre-commit.ci\\] pre-commit autoupdate [\\#394](https://github.com/sparckles/robyn/pull/394) ([pre-commit-ci[bot]](https://github.com/apps/pre-commit-ci))\n- docs: add documentation regarding byte response [\\#392](https://github.com/sparckles/robyn/pull/392) ([sansyrox](https://github.com/sansyrox))\n- fix: fix terminal hijacking in windows [\\#391](https://github.com/sparckles/robyn/pull/391) ([sansyrox](https://github.com/sansyrox))\n- chore: fix requirements files and update packages [\\#389](https://github.com/sparckles/robyn/pull/389) ([AntoineRR](https://github.com/AntoineRR))\n- small correction in docs [\\#387](https://github.com/sparckles/robyn/pull/387) ([tkanhe](https://github.com/tkanhe))\n- \\[pre-commit.ci\\] pre-commit autoupdate [\\#384](https://github.com/sparckles/robyn/pull/384) ([pre-commit-ci[bot]](https://github.com/apps/pre-commit-ci))\n- ci: build artifacts on every push and pull [\\#378](https://github.com/sparckles/robyn/pull/378) ([sansyrox](https://github.com/sansyrox))\n- test: organize and add tests [\\#377](https://github.com/sparckles/robyn/pull/377) ([AntoineRR](https://github.com/AntoineRR))\n- Changed Response to use body: bytes [\\#375](https://github.com/sparckles/robyn/pull/375) ([madhavajay](https://github.com/madhavajay))\n\n## [v0.24.0](https://github.com/sparckles/robyn/tree/v0.24.0) (2023-02-06)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.23.1...v0.24.0)\n\n**Closed issues:**\n\n- \\[BUG\\] Release builds are not working [\\#386](https://github.com/sparckles/robyn/issues/386)\n- \\[BUG\\] Can't send raw bytes [\\#374](https://github.com/sparckles/robyn/issues/374)\n\n## [v0.23.1](https://github.com/sparckles/robyn/tree/v0.23.1) (2023-01-30)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.23.0...v0.23.1)\n\n**Closed issues:**\n\n- \\[BUG\\] Return 500 status code when route is raising [\\#381](https://github.com/sparckles/robyn/issues/381)\n- \\[BUG\\] Return 404 status code when route isn't set [\\#376](https://github.com/sparckles/robyn/issues/376)\n- Add Appwrite as a sponsor in the README [\\#348](https://github.com/sparckles/robyn/issues/348)\n- \\[BUG\\] Get Stared failed on Windows [\\#340](https://github.com/sparckles/robyn/issues/340)\n- \\[BUG\\] Fix CI/CD pipeline [\\#310](https://github.com/sparckles/robyn/issues/310)\n\n**Merged pull requests:**\n\n- chore\\(ci\\): fix robyn installation in test CI [\\#383](https://github.com/sparckles/robyn/pull/383) ([AntoineRR](https://github.com/AntoineRR))\n- fix: return 500 status code when route raise [\\#382](https://github.com/sparckles/robyn/pull/382) ([AntoineRR](https://github.com/AntoineRR))\n- fix: return 404 status code when route isn't found [\\#380](https://github.com/sparckles/robyn/pull/380) ([AntoineRR](https://github.com/AntoineRR))\n- ci: enable precommit hooks on everything [\\#371](https://github.com/sparckles/robyn/pull/371) ([sansyrox](https://github.com/sansyrox))\n- chore: run tests on linux, macos and windows and release builds on ta… [\\#370](https://github.com/sparckles/robyn/pull/370) ([AntoineRR](https://github.com/AntoineRR))\n- docs: add appwrite logo as sponsors [\\#369](https://github.com/sparckles/robyn/pull/369) ([sansyrox](https://github.com/sansyrox))\n- test: improve pytest fixtures [\\#368](https://github.com/sparckles/robyn/pull/368) ([AntoineRR](https://github.com/AntoineRR))\n- Move pre-commit hooks to use Ruff [\\#364](https://github.com/sparckles/robyn/pull/364) ([patrick91](https://github.com/patrick91))\n\n## [v0.23.0](https://github.com/sparckles/robyn/tree/v0.23.0) (2023-01-21)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.22.1...v0.23.0)\n\n**Closed issues:**\n\n- \\[Feature Request\\] Improve the release and testing pipeline [\\#341](https://github.com/sparckles/robyn/issues/341)\n\n**Merged pull requests:**\n\n- ci: delete the test pypi workflow [\\#367](https://github.com/sparckles/robyn/pull/367) ([sansyrox](https://github.com/sansyrox))\n- docs: Add page icon to index page [\\#365](https://github.com/sparckles/robyn/pull/365) ([Abdur-rahmaanJ](https://github.com/Abdur-rahmaanJ))\n- test: speed up tests [\\#362](https://github.com/sparckles/robyn/pull/362) ([AntoineRR](https://github.com/AntoineRR))\n- Replace the default port with 8080 [\\#352](https://github.com/sparckles/robyn/pull/352) ([sansyrox](https://github.com/sansyrox))\n\n## [v0.22.1](https://github.com/sparckles/robyn/tree/v0.22.1) (2023-01-16)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.22.0...v0.22.1)\n\n**Closed issues:**\n\n- \\[BUG\\] Python 3.11 error: metadata-generation-failed [\\#357](https://github.com/sparckles/robyn/issues/357)\n\n**Merged pull requests:**\n\n- ci: update precommit config [\\#361](https://github.com/sparckles/robyn/pull/361) ([sansyrox](https://github.com/sansyrox))\n- \\[pre-commit.ci\\] pre-commit autoupdate [\\#359](https://github.com/sparckles/robyn/pull/359) ([pre-commit-ci[bot]](https://github.com/apps/pre-commit-ci))\n- chore\\(ci\\): add python 3.11 to the build and test CI [\\#358](https://github.com/sparckles/robyn/pull/358) ([AntoineRR](https://github.com/AntoineRR))\n- Updates prose to format code block and docs [\\#356](https://github.com/sparckles/robyn/pull/356) ([rachfop](https://github.com/rachfop))\n\n## [v0.22.0](https://github.com/sparckles/robyn/tree/v0.22.0) (2023-01-14)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.21.0...v0.22.0)\n\n**Closed issues:**\n\n- AttributeError: 'Robyn' object has no attribute 'headers'\\[BUG\\] [\\#353](https://github.com/sparckles/robyn/issues/353)\n- \\[Feature Request\\] Allow support for multiple file types [\\#344](https://github.com/sparckles/robyn/issues/344)\n- \\[Feature Request\\] Investigate if we need an unit tests for Python functions created in Rust [\\#311](https://github.com/sparckles/robyn/issues/311)\n- \\[Experimental Feature Request\\] Story driven programming [\\#258](https://github.com/sparckles/robyn/issues/258)\n\n**Merged pull requests:**\n\n- fix: windows support [\\#354](https://github.com/sparckles/robyn/pull/354) ([sansyrox](https://github.com/sansyrox))\n- fix: better handling of route return type [\\#349](https://github.com/sparckles/robyn/pull/349) ([AntoineRR](https://github.com/AntoineRR))\n\n## [v0.21.0](https://github.com/sparckles/robyn/tree/v0.21.0) (2023-01-06)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.20.0...v0.21.0)\n\n**Closed issues:**\n\n- \\[Feature Request\\] Support for image file type [\\#343](https://github.com/sparckles/robyn/issues/343)\n- Not able to see the added logs [\\#342](https://github.com/sparckles/robyn/issues/342)\n- \\[Feature Request\\] Hope robyn can support returning f-string format [\\#338](https://github.com/sparckles/robyn/issues/338)\n- \\[Feature Request\\] Refactor Robyn response to allow objects other than strings [\\#336](https://github.com/sparckles/robyn/issues/336)\n- \\[BUG\\] Custom headers not sent when const=False [\\#323](https://github.com/sparckles/robyn/issues/323)\n- \\[Feature Request\\] Add documentation for custom template support in v0.19.0 [\\#321](https://github.com/sparckles/robyn/issues/321)\n- \\[BUG\\] Always need to return a string in a route [\\#305](https://github.com/sparckles/robyn/issues/305)\n\n**Merged pull requests:**\n\n- fix: fix the static file serving [\\#347](https://github.com/sparckles/robyn/pull/347) ([sansyrox](https://github.com/sansyrox))\n- feat: return Response from routes [\\#346](https://github.com/sparckles/robyn/pull/346) ([AntoineRR](https://github.com/AntoineRR))\n\n## [v0.20.0](https://github.com/sparckles/robyn/tree/v0.20.0) (2022-12-20)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.19.2...v0.20.0)\n\n**Closed issues:**\n\n- \\[Feature Request\\] Add an automated benchmark script [\\#320](https://github.com/sparckles/robyn/issues/320)\n\n**Merged pull requests:**\n\n- feat: allow non string types in response [\\#337](https://github.com/sparckles/robyn/pull/337) ([sansyrox](https://github.com/sansyrox))\n- feat: add an auto benchmark script [\\#329](https://github.com/sparckles/robyn/pull/329) ([AntoineRR](https://github.com/AntoineRR))\n\n## [v0.19.2](https://github.com/sparckles/robyn/tree/v0.19.2) (2022-12-14)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.19.1...v0.19.2)\n\n**Closed issues:**\n\n- \\[BUG\\] The --dev flag not working on Ubuntu 20.04 [\\#332](https://github.com/sparckles/robyn/issues/332)\n- \\[Feature Request\\] Allow the ability of sending the headers from the same route [\\#325](https://github.com/sparckles/robyn/issues/325)\n\n**Merged pull requests:**\n\n- fix: allow response headers and fix headers not working in const requests [\\#331](https://github.com/sparckles/robyn/pull/331) ([sansyrox](https://github.com/sansyrox))\n- fix: factorizing code [\\#322](https://github.com/sparckles/robyn/pull/322) ([AntoineRR](https://github.com/AntoineRR))\n\n## [v0.19.1](https://github.com/sparckles/robyn/tree/v0.19.1) (2022-12-03)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.19.0...v0.19.1)\n\n## [v0.19.0](https://github.com/sparckles/robyn/tree/v0.19.0) (2022-12-02)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.18.3...v0.19.0)\n\n**Closed issues:**\n\n- \\[Feature Request\\] Allow the ability of sending the headers from the same route [\\#326](https://github.com/sparckles/robyn/issues/326)\n- \\[Feature Request\\] Allow the ability of sending the headers from the same route [\\#324](https://github.com/sparckles/robyn/issues/324)\n- \\[BUG\\] Error in Examples section in Documentation [\\#314](https://github.com/sparckles/robyn/issues/314)\n- \\[BUG\\] Wrong link for the blog post on Robyn [\\#306](https://github.com/sparckles/robyn/issues/306)\n- Add documentation about deployment [\\#93](https://github.com/sparckles/robyn/issues/93)\n- Add support for templates! [\\#10](https://github.com/sparckles/robyn/issues/10)\n\n**Merged pull requests:**\n\n- docs: update hosting docs [\\#319](https://github.com/sparckles/robyn/pull/319) ([sansyrox](https://github.com/sansyrox))\n- Various improvements around the index method [\\#318](https://github.com/sparckles/robyn/pull/318) ([AntoineRR](https://github.com/AntoineRR))\n- Add Railway deployment process. [\\#316](https://github.com/sparckles/robyn/pull/316) ([carlosm27](https://github.com/carlosm27))\n- docs: fix middleware section in examples [\\#315](https://github.com/sparckles/robyn/pull/315) ([sansyrox](https://github.com/sansyrox))\n- docs: fix blog link in website [\\#309](https://github.com/sparckles/robyn/pull/309) ([sansyrox](https://github.com/sansyrox))\n- Router refactor [\\#307](https://github.com/sparckles/robyn/pull/307) ([AntoineRR](https://github.com/AntoineRR))\n\n## [v0.18.3](https://github.com/sparckles/robyn/tree/v0.18.3) (2022-11-10)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.18.2...v0.18.3)\n\n**Closed issues:**\n\n- \\[BUG\\] `--log-level` not working [\\#300](https://github.com/sparckles/robyn/issues/300)\n- \\[Feature Request\\] Refactor Code to include better types [\\#254](https://github.com/sparckles/robyn/issues/254)\n\n**Merged pull requests:**\n\n- fix: log level not working [\\#303](https://github.com/sparckles/robyn/pull/303) ([sansyrox](https://github.com/sansyrox))\n- add route type enum [\\#299](https://github.com/sparckles/robyn/pull/299) ([suhailmalik07](https://github.com/suhailmalik07))\n\n## [v0.18.2](https://github.com/sparckles/robyn/tree/v0.18.2) (2022-11-05)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.18.1...v0.18.2)\n\n**Closed issues:**\n\n- \\[Feature Request?\\] Update `matchit` crate to the most recent version [\\#291](https://github.com/sparckles/robyn/issues/291)\n- \\[Feature Request\\] Add `@wraps` in route dectorators [\\#285](https://github.com/sparckles/robyn/issues/285)\n- \\[Feature Request\\] fix clippy issues [\\#265](https://github.com/sparckles/robyn/issues/265)\n\n**Merged pull requests:**\n\n- style: add logging for url port and host [\\#304](https://github.com/sparckles/robyn/pull/304) ([sansyrox](https://github.com/sansyrox))\n- fix config of port and url [\\#302](https://github.com/sparckles/robyn/pull/302) ([kimhyun5u](https://github.com/kimhyun5u))\n- update rust packages to latest [\\#298](https://github.com/sparckles/robyn/pull/298) ([suhailmalik07](https://github.com/suhailmalik07))\n- fix: retain metadata of the route functions [\\#295](https://github.com/sparckles/robyn/pull/295) ([sansyrox](https://github.com/sansyrox))\n- `SocketHeld::new` refactor [\\#294](https://github.com/sparckles/robyn/pull/294) ([Jamyw7g](https://github.com/Jamyw7g))\n\n## [v0.18.1](https://github.com/sparckles/robyn/tree/v0.18.1) (2022-10-23)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.18.0...v0.18.1)\n\n**Merged pull requests:**\n\n- fix: replaced match with if let [\\#293](https://github.com/sparckles/robyn/pull/293) ([Markaeus](https://github.com/Markaeus))\n- Hotfix detecting robyn.env [\\#292](https://github.com/sparckles/robyn/pull/292) ([Shending-Help](https://github.com/Shending-Help))\n- fix: enable hot reload on windows [\\#290](https://github.com/sparckles/robyn/pull/290) ([guilefoylegaurav](https://github.com/guilefoylegaurav))\n\n## [v0.18.0](https://github.com/sparckles/robyn/tree/v0.18.0) (2022-10-12)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.17.5...v0.18.0)\n\n**Closed issues:**\n\n- \\[BUG\\] The --dev mode spawns more servers without clearing previous ones. [\\#249](https://github.com/sparckles/robyn/issues/249)\n- \\[Feature\\] Add support for Env variables and a robyn.yaml config file [\\#97](https://github.com/sparckles/robyn/issues/97)\n\n**Merged pull requests:**\n\n- testing env support [\\#288](https://github.com/sparckles/robyn/pull/288) ([Shending-Help](https://github.com/Shending-Help))\n- Feature add support for env variables [\\#286](https://github.com/sparckles/robyn/pull/286) ([Shending-Help](https://github.com/Shending-Help))\n- fix: add proper kill process to conftest. \\#249 [\\#278](https://github.com/sparckles/robyn/pull/278) ([guilefoylegaurav](https://github.com/guilefoylegaurav))\n\n## [v0.17.5](https://github.com/sparckles/robyn/tree/v0.17.5) (2022-09-14)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.17.4...v0.17.5)\n\n**Closed issues:**\n\n- \\[BUG\\] README.md Discord link is invalid [\\#272](https://github.com/sparckles/robyn/issues/272)\n- \\[Feature Request\\] Add Digital Ocean to list of sponsors in Robyn Docs [\\#270](https://github.com/sparckles/robyn/issues/270)\n- \\[Feature Request\\] Add PyCon USA lightning talk in resources section [\\#204](https://github.com/sparckles/robyn/issues/204)\n- \\[Feature Request\\] Add community/ resources section in Docs or README [\\#203](https://github.com/sparckles/robyn/issues/203)\n- \\[Feature Request\\] Update the new architecture on the docs website [\\#191](https://github.com/sparckles/robyn/issues/191)\n- Add examples section [\\#101](https://github.com/sparckles/robyn/issues/101)\n\n**Merged pull requests:**\n\n- Don't run sync functions in pool [\\#282](https://github.com/sparckles/robyn/pull/282) ([JackThomson2](https://github.com/JackThomson2))\n- Add documentation of Adding GraphQL support | version 1 [\\#275](https://github.com/sparckles/robyn/pull/275) ([sansyrox](https://github.com/sansyrox))\n- docs: improve documentation [\\#269](https://github.com/sparckles/robyn/pull/269) ([sansyrox](https://github.com/sansyrox))\n\n## [v0.17.4](https://github.com/sparckles/robyn/tree/v0.17.4) (2022-08-25)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.17.3...v0.17.4)\n\n**Closed issues:**\n\n- \\[BUG?\\] Startup failure OSError: \\[WinError 87\\] The parameter is incorrect [\\#252](https://github.com/sparckles/robyn/issues/252)\n- \\[Feature Request\\] Add mypy for pyi\\(stubs\\) synchronisation [\\#226](https://github.com/sparckles/robyn/issues/226)\n- not working on mac/windows [\\#140](https://github.com/sparckles/robyn/issues/140)\n\n**Merged pull requests:**\n\n- Father, forgive me, for I am adding inline types. [\\#266](https://github.com/sparckles/robyn/pull/266) ([sansyrox](https://github.com/sansyrox))\n\n## [v0.17.3](https://github.com/sparckles/robyn/tree/v0.17.3) (2022-08-17)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.17.2...v0.17.3)\n\n**Merged pull requests:**\n\n- fix: parse int status code to str [\\#264](https://github.com/sparckles/robyn/pull/264) ([hougesen](https://github.com/hougesen))\n\n## [v0.17.2](https://github.com/sparckles/robyn/tree/v0.17.2) (2022-08-11)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.17.1...v0.17.2)\n\n**Fixed bugs:**\n\n- Cannot run Robyn on Windows [\\#139](https://github.com/sparckles/robyn/issues/139)\n\n**Closed issues:**\n\n- \\[BUG\\] Move away from circle ci [\\#240](https://github.com/sparckles/robyn/issues/240)\n- Migrate the community to discord [\\#239](https://github.com/sparckles/robyn/issues/239)\n- \\[Feature Request\\] Release on test pypi before releasing on the main PyPi [\\#224](https://github.com/sparckles/robyn/issues/224)\n- For 0.8.x [\\#75](https://github.com/sparckles/robyn/issues/75)\n- Add a layer of caching in front of router [\\#59](https://github.com/sparckles/robyn/issues/59)\n\n**Merged pull requests:**\n\n- Windows fix [\\#261](https://github.com/sparckles/robyn/pull/261) ([sansyrox](https://github.com/sansyrox))\n- ci: enable fail fast for faster response time in the pipelines [\\#260](https://github.com/sparckles/robyn/pull/260) ([sansyrox](https://github.com/sansyrox))\n- ci: add github actions to publish every PR on test pypi [\\#259](https://github.com/sparckles/robyn/pull/259) ([sansyrox](https://github.com/sansyrox))\n- Fix typo in README [\\#246](https://github.com/sparckles/robyn/pull/246) ([bartbroere](https://github.com/bartbroere))\n- chore\\(ci\\): move pytest from CircleCi to Github Actions [\\#241](https://github.com/sparckles/robyn/pull/241) ([AntoineRR](https://github.com/AntoineRR))\n\n## [v0.17.1](https://github.com/sparckles/robyn/tree/v0.17.1) (2022-07-19)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.17.0...v0.17.1)\n\n**Closed issues:**\n\n- \\[Feature Request\\] add clippy in ci [\\#236](https://github.com/sparckles/robyn/issues/236)\n- \\[BUG\\] Headers not available [\\#231](https://github.com/sparckles/robyn/issues/231)\n- \\[Feature Request\\] Add an all contributor bot in the README of the repo [\\#225](https://github.com/sparckles/robyn/issues/225)\n\n**Merged pull requests:**\n\n- Add Rust CI [\\#237](https://github.com/sparckles/robyn/pull/237) ([AntoineRR](https://github.com/AntoineRR))\n- Contributors added in Readme [\\#235](https://github.com/sparckles/robyn/pull/235) ([orvil1026](https://github.com/orvil1026))\n- fix external project link in README [\\#234](https://github.com/sparckles/robyn/pull/234) ([touilleMan](https://github.com/touilleMan))\n- fix: fix request headers not being propagated [\\#232](https://github.com/sparckles/robyn/pull/232) ([sansyrox](https://github.com/sansyrox))\n- Upgrade GitHub Actions and add Python 3.10 [\\#230](https://github.com/sparckles/robyn/pull/230) ([cclauss](https://github.com/cclauss))\n- OrbUp: Upgrade the CircleCI Orbs [\\#229](https://github.com/sparckles/robyn/pull/229) ([cclauss](https://github.com/cclauss))\n- CHANGELOG.md: Fix typo [\\#228](https://github.com/sparckles/robyn/pull/228) ([cclauss](https://github.com/cclauss))\n\n## [v0.17.0](https://github.com/sparckles/robyn/tree/v0.17.0) (2022-07-06)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.16.6...v0.17.0)\n\n**Closed issues:**\n\n- A refactor [\\#176](https://github.com/sparckles/robyn/issues/176)\n- \\[Proposal\\] Const Requests [\\#48](https://github.com/sparckles/robyn/issues/48)\n\n**Merged pull requests:**\n\n- Add a const router [\\#210](https://github.com/sparckles/robyn/pull/210) ([sansyrox](https://github.com/sansyrox))\n\n## [v0.16.6](https://github.com/sparckles/robyn/tree/v0.16.6) (2022-07-02)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.16.5...v0.16.6)\n\n## [v0.16.5](https://github.com/sparckles/robyn/tree/v0.16.5) (2022-07-01)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.16.4...v0.16.5)\n\n**Closed issues:**\n\n- \\[Feature Request\\] Add sponsors in the repo and website [\\#212](https://github.com/sparckles/robyn/issues/212)\n- \\[Feature Request\\] Add commitizen as a dev dependency [\\#211](https://github.com/sparckles/robyn/issues/211)\n- Add better logging [\\#158](https://github.com/sparckles/robyn/issues/158)\n- Remove freeport dependency [\\#151](https://github.com/sparckles/robyn/issues/151)\n- Add websocket support [\\#104](https://github.com/sparckles/robyn/issues/104)\n- Maintenance issue [\\#56](https://github.com/sparckles/robyn/issues/56)\n- Improve Readme [\\#4](https://github.com/sparckles/robyn/issues/4)\n\n**Merged pull requests:**\n\n- fix: Fixes the crashing dev mode [\\#218](https://github.com/sparckles/robyn/pull/218) ([sansyrox](https://github.com/sansyrox))\n- feat: add commitizen as a dev dependency [\\#216](https://github.com/sparckles/robyn/pull/216) ([sansyrox](https://github.com/sansyrox))\n- Isort imports [\\#205](https://github.com/sparckles/robyn/pull/205) ([sansyrox](https://github.com/sansyrox))\n- Add bridged logger. Improves performance substantially. [\\#201](https://github.com/sparckles/robyn/pull/201) ([sansyrox](https://github.com/sansyrox))\n- Adds pre-commit hooks for black, flake8, isort [\\#198](https://github.com/sparckles/robyn/pull/198) ([chrismoradi](https://github.com/chrismoradi))\n- Resolves port open issue when app is killed \\#183 [\\#196](https://github.com/sparckles/robyn/pull/196) ([anandtripathi5](https://github.com/anandtripathi5))\n- Removing unwraps [\\#195](https://github.com/sparckles/robyn/pull/195) ([sansyrox](https://github.com/sansyrox))\n\n## [v0.16.4](https://github.com/sparckles/robyn/tree/v0.16.4) (2022-05-30)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.16.3...v0.16.4)\n\n**Closed issues:**\n\n- \\[Feature Request\\] Remove extra logs [\\#200](https://github.com/sparckles/robyn/issues/200)\n- \\[Feature Request\\] Add precommit hook for black, flake8 and isort [\\#194](https://github.com/sparckles/robyn/issues/194)\n- \\[BUG\\] Get rid of Hashmap Clones and Unwraps! [\\#186](https://github.com/sparckles/robyn/issues/186)\n\n## [v0.16.3](https://github.com/sparckles/robyn/tree/v0.16.3) (2022-05-18)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.16.2...v0.16.3)\n\n**Closed issues:**\n\n- \\[BUG\\] Port not being free on app kill [\\#183](https://github.com/sparckles/robyn/issues/183)\n- Build failure [\\#166](https://github.com/sparckles/robyn/issues/166)\n\n## [v0.16.2](https://github.com/sparckles/robyn/tree/v0.16.2) (2022-05-09)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.16.1...v0.16.2)\n\n## [v0.16.1](https://github.com/sparckles/robyn/tree/v0.16.1) (2022-05-09)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.16.0...v0.16.1)\n\n**Closed issues:**\n\n- Add Python stubs [\\#130](https://github.com/sparckles/robyn/issues/130)\n\n**Merged pull requests:**\n\n- Setup types for Robyn [\\#192](https://github.com/sparckles/robyn/pull/192) ([sansyrox](https://github.com/sansyrox))\n- Fix build pipeline [\\#190](https://github.com/sparckles/robyn/pull/190) ([sansyrox](https://github.com/sansyrox))\n- fix typo :pencil2: in api docs. [\\#189](https://github.com/sparckles/robyn/pull/189) ([sombralibre](https://github.com/sombralibre))\n- Remove hashmap clones [\\#187](https://github.com/sparckles/robyn/pull/187) ([sansyrox](https://github.com/sansyrox))\n- Code clean up | Modularise rust code [\\#185](https://github.com/sparckles/robyn/pull/185) ([sansyrox](https://github.com/sansyrox))\n- Add experimental io-uring [\\#184](https://github.com/sparckles/robyn/pull/184) ([sansyrox](https://github.com/sansyrox))\n- Implement Response headers [\\#179](https://github.com/sparckles/robyn/pull/179) ([sansyrox](https://github.com/sansyrox))\n- Code cleanup [\\#178](https://github.com/sparckles/robyn/pull/178) ([sansyrox](https://github.com/sansyrox))\n\n## [v0.16.0](https://github.com/sparckles/robyn/tree/v0.16.0) (2022-04-29)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.15.1...v0.16.0)\n\n**Closed issues:**\n\n- \\[Feature Request\\] Add list of sponsors on the project website [\\#182](https://github.com/sparckles/robyn/issues/182)\n- Optional build feature for io\\_uring [\\#177](https://github.com/sparckles/robyn/issues/177)\n- Create Custom headers for the response. [\\#174](https://github.com/sparckles/robyn/issues/174)\n\n## [v0.15.1](https://github.com/sparckles/robyn/tree/v0.15.1) (2022-03-24)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.15.0...v0.15.1)\n\n**Closed issues:**\n\n- Add middleware support [\\#95](https://github.com/sparckles/robyn/issues/95)\n\n**Merged pull requests:**\n\n- Make websocket id accessible [\\#173](https://github.com/sparckles/robyn/pull/173) ([sansyrox](https://github.com/sansyrox))\n- Use Clippy tool optimized code [\\#171](https://github.com/sparckles/robyn/pull/171) ([mrxiaozhuox](https://github.com/mrxiaozhuox))\n- Modify headers [\\#170](https://github.com/sparckles/robyn/pull/170) ([sansyrox](https://github.com/sansyrox))\n- Update README.md [\\#168](https://github.com/sparckles/robyn/pull/168) ([Polokghosh53](https://github.com/Polokghosh53))\n\n## [v0.15.0](https://github.com/sparckles/robyn/tree/v0.15.0) (2022-03-17)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.14.0...v0.15.0)\n\n**Closed issues:**\n\n- \\[BUG\\] Unable to modify headers in middlewares [\\#167](https://github.com/sparckles/robyn/issues/167)\n- Add Pycon talk link to docs [\\#102](https://github.com/sparckles/robyn/issues/102)\n\n## [v0.14.0](https://github.com/sparckles/robyn/tree/v0.14.0) (2022-03-03)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.13.1...v0.14.0)\n\n**Fixed bugs:**\n\n- Build error [\\#161](https://github.com/sparckles/robyn/issues/161)\n\n**Merged pull requests:**\n\n- Implement Custom Response objects. [\\#165](https://github.com/sparckles/robyn/pull/165) ([sansyrox](https://github.com/sansyrox))\n- Remove deprecated endpoints [\\#162](https://github.com/sparckles/robyn/pull/162) ([sansyrox](https://github.com/sansyrox))\n- Fix: default url param in app.start [\\#160](https://github.com/sparckles/robyn/pull/160) ([sansyrox](https://github.com/sansyrox))\n- Add middlewares [\\#157](https://github.com/sparckles/robyn/pull/157) ([sansyrox](https://github.com/sansyrox))\n- Remove arc\\(ing\\) [\\#156](https://github.com/sparckles/robyn/pull/156) ([sansyrox](https://github.com/sansyrox))\n\n## [v0.13.1](https://github.com/sparckles/robyn/tree/v0.13.1) (2022-02-19)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.13.0...v0.13.1)\n\n## [v0.13.0](https://github.com/sparckles/robyn/tree/v0.13.0) (2022-02-15)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.12.1...v0.13.0)\n\n## [v0.12.1](https://github.com/sparckles/robyn/tree/v0.12.1) (2022-02-13)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.12.0...v0.12.1)\n\n**Closed issues:**\n\n- \\[BUG\\] Default URL cannot be assigned [\\#159](https://github.com/sparckles/robyn/issues/159)\n- Upcoming release\\(s\\) [\\#141](https://github.com/sparckles/robyn/issues/141)\n\n## [v0.12.0](https://github.com/sparckles/robyn/tree/v0.12.0) (2022-01-21)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.11.1...v0.12.0)\n\n**Closed issues:**\n\n- Consider adding startup events [\\#153](https://github.com/sparckles/robyn/issues/153)\n- Remove poetry dependency [\\#150](https://github.com/sparckles/robyn/issues/150)\n\n**Merged pull requests:**\n\n- Add Event handlers [\\#154](https://github.com/sparckles/robyn/pull/154) ([sansyrox](https://github.com/sansyrox))\n- Remove poetry [\\#152](https://github.com/sparckles/robyn/pull/152) ([sansyrox](https://github.com/sansyrox))\n- Use print instead of input after starting server [\\#149](https://github.com/sparckles/robyn/pull/149) ([klaa97](https://github.com/klaa97))\n- Fix dev server [\\#148](https://github.com/sparckles/robyn/pull/148) ([sansyrox](https://github.com/sansyrox))\n- URL queries [\\#146](https://github.com/sparckles/robyn/pull/146) ([patchgamestudio](https://github.com/patchgamestudio))\n- Add project wide flake8 settings [\\#143](https://github.com/sparckles/robyn/pull/143) ([sansyrox](https://github.com/sansyrox))\n\n## [v0.11.1](https://github.com/sparckles/robyn/tree/v0.11.1) (2022-01-11)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.11.0...v0.11.1)\n\n## [v0.11.0](https://github.com/sparckles/robyn/tree/v0.11.0) (2022-01-07)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.10.0...v0.11.0)\n\n**Fixed bugs:**\n\n- Hot Reloading goes in an infinite loop [\\#115](https://github.com/sparckles/robyn/issues/115)\n\n**Closed issues:**\n\n- Benchmarks to Björn, uvicorn etc. [\\#142](https://github.com/sparckles/robyn/issues/142)\n- Add Python linter setup [\\#129](https://github.com/sparckles/robyn/issues/129)\n- Add fixtures in testing [\\#84](https://github.com/sparckles/robyn/issues/84)\n\n## [v0.10.0](https://github.com/sparckles/robyn/tree/v0.10.0) (2021-12-20)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.9.0...v0.10.0)\n\n**Closed issues:**\n\n- Add PyPI classifiers [\\#127](https://github.com/sparckles/robyn/issues/127)\n- Robyn version 0.9.0 doesn't work on Mac M1 Models [\\#120](https://github.com/sparckles/robyn/issues/120)\n- Inconsistency in steps mentioned in Readme to run locally [\\#119](https://github.com/sparckles/robyn/issues/119)\n- Async web socket support [\\#116](https://github.com/sparckles/robyn/issues/116)\n- Reveal Logo to be removed from Future Roadmap [\\#107](https://github.com/sparckles/robyn/issues/107)\n- Dead Link for Test Drive Button on Robyn Landing Page [\\#106](https://github.com/sparckles/robyn/issues/106)\n- Add issue template, pr template and community guidelines [\\#105](https://github.com/sparckles/robyn/issues/105)\n- For v0.7.0 [\\#72](https://github.com/sparckles/robyn/issues/72)\n- Add better support for requests and response! [\\#13](https://github.com/sparckles/robyn/issues/13)\n\n**Merged pull requests:**\n\n- Add async support in WS [\\#134](https://github.com/sparckles/robyn/pull/134) ([sansyrox](https://github.com/sansyrox))\n- Add help messages and simplify 'dev' option [\\#128](https://github.com/sparckles/robyn/pull/128) ([Kludex](https://github.com/Kludex))\n- Apply Python highlight on api.md [\\#126](https://github.com/sparckles/robyn/pull/126) ([Kludex](https://github.com/Kludex))\n- Update comparison.md [\\#124](https://github.com/sparckles/robyn/pull/124) ([Kludex](https://github.com/Kludex))\n- Update comparison.md [\\#123](https://github.com/sparckles/robyn/pull/123) ([Kludex](https://github.com/Kludex))\n- Fix readme documentation [\\#122](https://github.com/sparckles/robyn/pull/122) ([sansyrox](https://github.com/sansyrox))\n- Release v0.9.0 Changelog [\\#121](https://github.com/sparckles/robyn/pull/121) ([sansyrox](https://github.com/sansyrox))\n- \\[FEAT\\] Open Source Contribution Templates [\\#118](https://github.com/sparckles/robyn/pull/118) ([shivaylamba](https://github.com/shivaylamba))\n- FIX : Wrong link for Test Drive [\\#117](https://github.com/sparckles/robyn/pull/117) ([shivaylamba](https://github.com/shivaylamba))\n\n## [v0.9.0](https://github.com/sparckles/robyn/tree/v0.9.0) (2021-12-01)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.8.1...v0.9.0)\n\n**Closed issues:**\n\n- Add more HTTP methods [\\#74](https://github.com/sparckles/robyn/issues/74)\n\n**Merged pull requests:**\n\n- Fix default url bug [\\#111](https://github.com/sparckles/robyn/pull/111) ([sansyrox](https://github.com/sansyrox))\n- Web socket integration attempt 2 [\\#109](https://github.com/sparckles/robyn/pull/109) ([sansyrox](https://github.com/sansyrox))\n\n## [v0.8.1](https://github.com/sparckles/robyn/tree/v0.8.1) (2021-11-17)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.8.0...v0.8.1)\n\n**Fixed bugs:**\n\n- The default start is running the server at '0.0.0.0' instead of '127.0.0.1' [\\#110](https://github.com/sparckles/robyn/issues/110)\n\n## [v0.8.0](https://github.com/sparckles/robyn/tree/v0.8.0) (2021-11-10)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.7.1...v0.8.0)\n\n**Closed issues:**\n\n- Share the TCP web socket across different cores [\\#91](https://github.com/sparckles/robyn/issues/91)\n- Improve the router [\\#52](https://github.com/sparckles/robyn/issues/52)\n- \\[Stretch Goal\\] Create a a way of writing async request [\\#32](https://github.com/sparckles/robyn/issues/32)\n- Improve the router [\\#29](https://github.com/sparckles/robyn/issues/29)\n\n**Merged pull requests:**\n\n- Fix the failing testing suite! [\\#100](https://github.com/sparckles/robyn/pull/100) ([sansyrox](https://github.com/sansyrox))\n- Requests object is now optional [\\#99](https://github.com/sparckles/robyn/pull/99) ([sansyrox](https://github.com/sansyrox))\n- Add socket sharing [\\#94](https://github.com/sparckles/robyn/pull/94) ([sansyrox](https://github.com/sansyrox))\n\n## [v0.7.1](https://github.com/sparckles/robyn/tree/v0.7.1) (2021-10-28)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.7.0...v0.7.1)\n\n**Closed issues:**\n\n- Remove the solution using dockerisation of tests [\\#98](https://github.com/sparckles/robyn/issues/98)\n- Functions not working without request param [\\#96](https://github.com/sparckles/robyn/issues/96)\n- Add actix router [\\#85](https://github.com/sparckles/robyn/issues/85)\n- Request apart from GET are not working in directory subroutes [\\#79](https://github.com/sparckles/robyn/issues/79)\n- Add the ability to share the server across the network [\\#69](https://github.com/sparckles/robyn/issues/69)\n- Add the ability to view headers in the HTTP Methods [\\#54](https://github.com/sparckles/robyn/issues/54)\n- Add tests! [\\#8](https://github.com/sparckles/robyn/issues/8)\n\n## [v0.7.0](https://github.com/sparckles/robyn/tree/v0.7.0) (2021-10-03)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.6.1...v0.7.0)\n\n**Closed issues:**\n\n- Robyn the replacement of Quart [\\#86](https://github.com/sparckles/robyn/issues/86)\n- Add Pytest support for the test endpoints [\\#81](https://github.com/sparckles/robyn/issues/81)\n\n**Merged pull requests:**\n\n- Finally completed router integration [\\#90](https://github.com/sparckles/robyn/pull/90) ([sansyrox](https://github.com/sansyrox))\n- Address clippy lints [\\#89](https://github.com/sparckles/robyn/pull/89) ([SanchithHegde](https://github.com/SanchithHegde))\n- Initial docs update [\\#83](https://github.com/sparckles/robyn/pull/83) ([sansyrox](https://github.com/sansyrox))\n- Add the basics of python testing [\\#82](https://github.com/sparckles/robyn/pull/82) ([sansyrox](https://github.com/sansyrox))\n- Add a new landing page [\\#80](https://github.com/sparckles/robyn/pull/80) ([sansyrox](https://github.com/sansyrox))\n\n## [v0.6.1](https://github.com/sparckles/robyn/tree/v0.6.1) (2021-08-30)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.6.0...v0.6.1)\n\n**Closed issues:**\n\n- Make a new release [\\#71](https://github.com/sparckles/robyn/issues/71)\n- Update to the pyo3 v0.14 [\\#63](https://github.com/sparckles/robyn/issues/63)\n- Add the support to serve static directories [\\#55](https://github.com/sparckles/robyn/issues/55)\n- Add support for mounting directory [\\#38](https://github.com/sparckles/robyn/issues/38)\n\n**Merged pull requests:**\n\n- Add the base of http requests [\\#78](https://github.com/sparckles/robyn/pull/78) ([sansyrox](https://github.com/sansyrox))\n- Add default port and a variable url [\\#77](https://github.com/sparckles/robyn/pull/77) ([sansyrox](https://github.com/sansyrox))\n- Make the request object accessible in every route [\\#76](https://github.com/sparckles/robyn/pull/76) ([sansyrox](https://github.com/sansyrox))\n- Add the basics for circle ci and testing framework [\\#67](https://github.com/sparckles/robyn/pull/67) ([sansyrox](https://github.com/sansyrox))\n- Update to pyo3 v0.14 [\\#65](https://github.com/sparckles/robyn/pull/65) ([sansyrox](https://github.com/sansyrox))\n- Add the static directory serving [\\#64](https://github.com/sparckles/robyn/pull/64) ([sansyrox](https://github.com/sansyrox))\n- Create a request object [\\#61](https://github.com/sparckles/robyn/pull/61) ([sansyrox](https://github.com/sansyrox))\n- Add the ability to add body in PUT, PATCH and DELETE [\\#60](https://github.com/sparckles/robyn/pull/60) ([sansyrox](https://github.com/sansyrox))\n- Implement a working dev server [\\#40](https://github.com/sparckles/robyn/pull/40) ([sansyrox](https://github.com/sansyrox))\n- Use Actix as base [\\#35](https://github.com/sparckles/robyn/pull/35) ([JackThomson2](https://github.com/JackThomson2))\n\n## [v0.6.0](https://github.com/sparckles/robyn/tree/v0.6.0) (2021-08-11)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.5.3...v0.6.0)\n\n**Closed issues:**\n\n- Add body support for PUT, POST and PATCH [\\#53](https://github.com/sparckles/robyn/issues/53)\n- Away with limited internet access till 1st August [\\#51](https://github.com/sparckles/robyn/issues/51)\n- Add doc stings [\\#42](https://github.com/sparckles/robyn/issues/42)\n- OSX builds are failing [\\#41](https://github.com/sparckles/robyn/issues/41)\n- Add a dev server implementation [\\#37](https://github.com/sparckles/robyn/issues/37)\n- Mini Roadmap | A list of issues that would require fixing [\\#19](https://github.com/sparckles/robyn/issues/19)\n- Add support for Object/JSON Return Type! [\\#9](https://github.com/sparckles/robyn/issues/9)\n\n## [v0.5.3](https://github.com/sparckles/robyn/tree/v0.5.3) (2021-07-12)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.5.2...v0.5.3)\n\n**Merged pull requests:**\n\n- Improve the HTML file serving [\\#46](https://github.com/sparckles/robyn/pull/46) ([sansyrox](https://github.com/sansyrox))\n- Add the basics to add serving of static files [\\#36](https://github.com/sparckles/robyn/pull/36) ([sansyrox](https://github.com/sansyrox))\n\n## [v0.5.2](https://github.com/sparckles/robyn/tree/v0.5.2) (2021-07-11)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.5.1...v0.5.2)\n\n## [v0.5.1](https://github.com/sparckles/robyn/tree/v0.5.1) (2021-07-10)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.5.0...v0.5.1)\n\n**Closed issues:**\n\n- Make html file serving more robust [\\#45](https://github.com/sparckles/robyn/issues/45)\n- Try to serve individual static files using vanilla rust [\\#43](https://github.com/sparckles/robyn/issues/43)\n- Error on import [\\#16](https://github.com/sparckles/robyn/issues/16)\n- Add multiple process sharing [\\#2](https://github.com/sparckles/robyn/issues/2)\n\n## [v0.5.0](https://github.com/sparckles/robyn/tree/v0.5.0) (2021-07-01)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.4.1...v0.5.0)\n\n**Closed issues:**\n\n- QPS drops drastically after processing many requests [\\#31](https://github.com/sparckles/robyn/issues/31)\n- Improve the way you parse TCP streams [\\#30](https://github.com/sparckles/robyn/issues/30)\n- Re-introduce thread pool for the sync functions \\(maybe\\) [\\#22](https://github.com/sparckles/robyn/issues/22)\n- Add async listener object in rust stream! [\\#11](https://github.com/sparckles/robyn/issues/11)\n\n**Merged pull requests:**\n\n- Make the server http compliant [\\#33](https://github.com/sparckles/robyn/pull/33) ([sansyrox](https://github.com/sansyrox))\n\n## [v0.4.1](https://github.com/sparckles/robyn/tree/v0.4.1) (2021-06-26)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/0.4.0...v0.4.1)\n\n**Closed issues:**\n\n- Add PyPi Metadata [\\#5](https://github.com/sparckles/robyn/issues/5)\n\n**Merged pull requests:**\n\n- Build and publish wheels on GitHub Actions [\\#26](https://github.com/sparckles/robyn/pull/26) ([messense](https://github.com/messense))\n- Code cleanup using PyFunction type [\\#25](https://github.com/sparckles/robyn/pull/25) ([sansyrox](https://github.com/sansyrox))\n- Add non blocking sync functions [\\#23](https://github.com/sparckles/robyn/pull/23) ([sansyrox](https://github.com/sansyrox))\n- Add support for sync functions [\\#20](https://github.com/sparckles/robyn/pull/20) ([sansyrox](https://github.com/sansyrox))\n\n## [0.4.0](https://github.com/sparckles/robyn/tree/0.4.0) (2021-06-22)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.3.0...0.4.0)\n\n**Closed issues:**\n\n- Add support for Sync functions as well! [\\#7](https://github.com/sparckles/robyn/issues/7)\n\n## [v0.3.0](https://github.com/sparckles/robyn/tree/v0.3.0) (2021-06-21)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/v0.2.3...v0.3.0)\n\n**Closed issues:**\n\n- Architecture link in readme redirects to raw content [\\#18](https://github.com/sparckles/robyn/issues/18)\n- Link pointing to the wrong destination [\\#6](https://github.com/sparckles/robyn/issues/6)\n\n**Merged pull requests:**\n\n- Pure tokio [\\#17](https://github.com/sparckles/robyn/pull/17) ([JackThomson2](https://github.com/JackThomson2))\n- Remove Mutex lock on Threadpool and routes [\\#15](https://github.com/sparckles/robyn/pull/15) ([JackThomson2](https://github.com/JackThomson2))\n\n## [v0.2.3](https://github.com/sparckles/robyn/tree/v0.2.3) (2021-06-18)\n\n[Full Changelog](https://github.com/sparckles/robyn/compare/c14f52e6faa79917e89de4220590da7bf28f6a65...v0.2.3)\n\n**Closed issues:**\n\n- Improve async runtime [\\#3](https://github.com/sparckles/robyn/issues/3)\n\n\n\n\\* *This Changelog was automatically generated by [github_changelog_generator](https://github.com/github-changelog-generator/github-changelog-generator)*\n"
},
{
"path": "CODE_OF_CONDUCT.md",
"content": "### Robyn Open Source Community Guidelines\n\n- **Be friendly and patient**.\n- **Be welcoming**.\n- **Be respectful**.\n- **Be careful in the words that we choose**.\n"
},
{
"path": "CONTRIBUTING.md",
"content": "## Contributing Guidelines\n\nFirst off, thank you for considering contributing to `Robyn`. This guide details all the general information that one should know before contributing to the project.\nPlease stick as close as possible to the guidelines. That way, we ensure that you have a smooth experience contributing to this project.\n\n### General Rules:\n\nThese are, in general, rules that you should be following while contributing to an Open-Source project :\n\n- Be Nice, Be Respectful (BNBR)\n- Check if the Issue you created, exists or not.\n- While creating a new issue, make sure you describe the issue clearly.\n- Make proper commit messages and document your PR well.\n- Always add comments in your Code and explain it at points if possible, add Doctest.\n- Always create a Pull Request from a Branch; Never from the Main.\n- Follow proper code conventions because writing clean code is important.\n- Issues would be assigned on a \"First Come, First Served\" basis.\n- Do mention (@sansyrox) the project maintainer if your PR isn't reviewed within a few days.\n\n## First time contributors:\n\nPushing files in your own repository is easy, but how to contribute to someone else's project? If you have the same question, then below are the steps that you can follow\nto make your first contribution in this repository.\n\n### Pull Request\n\n**1.** The very first step includes forking the project. Click on the `fork` button as shown below to fork the project.\n
\n\n**2.** Clone the forked repository. Open up the GitBash/Command Line and type\n\n```\ngit clone https://github.com//robyn.git\n```\n\n**3.** Navigate to the project directory.\n\n```\ncd robyn\n```\n\n**4.** Add a reference to the original repository.\n\n```\ngit remote add upstream https://github.com/sparckles/robyn.git\n```\n\n**5.** See latest changes to the repo using\n\n```\ngit remote -v\n```\n\n**6.** Create a new branch.\n\n```\ngit checkout -b \n```\n\n**7.** Always take a pull from the upstream repository to your main branch to keep it even with the main project. This will save you from frequent merge conflicts.\n\n```\ngit pull upstream main\n```\n\n**8.** You can make the required changes now. Make appropriate commits with proper commit messages.\n\n**9.** Add and then commit your changes.\n\n```\ngit add .\n```\n\n```\ngit commit -m \"\"\n```\n\n**10.** Push your local branch to the remote repository.\n\n```\ngit push -u origin \n```\n\n**11.** Once you have pushed the changes to your repository, go to your forked repository. Click on the `Compare & pull request` button as shown below.\n
\n\n**12.** The image below is what the new page would look like. Give a proper title to your PR and describe the changes made by you in the description box.(Note - Sometimes there are PR templates which are to be filled as instructed.)\n
\n\n**13.** Open a pull request by clicking the `Create pull request` button.\n\n`Voila, you have made your first contribution to this project`\n\n## Issue\n\n- Issues can be used to keep track of bugs, enhancements, or other requests. Creating an issue to let the project maintainers know about the changes you are planning to make before raising a PR is a good open-source practice.\n \n\nLet's walk through the steps to create an issue:\n\n**1.** On GitHub, navigate to the main page of the repository. [Here](https://github.com/sparckles/robyn.git) in this case.\n\n**2.** Under your repository name, click on the `Issues` button.\n
\n\n**3.** Click on the `New issue` button.\n
\n\n**4.** Select one of the Issue Templates to get started.\n
\n\n**5.** Fill in the appropriate `Title` and `Issue description` and click on `Submit new issue`.\n
\n\n### Tutorials that may help you:\n\n- [Git & GitHub Tutorial](https://www.youtube.com/watch?v=RGOj5yH7evk)\n- [Resolve merge conflict](https://docs.github.com/en/free-pro-team@latest/github/collaborating-with-issues-and-pull-requests/resolving-a-merge-conflict-on-github)\n"
},
{
"path": "Cargo.toml",
"content": "[package]\nname = \"robyn\"\nversion = \"0.82.0\"\nauthors = [\"Sanskar Jethi \"]\nedition = \"2021\"\ndescription = \"Robyn is a Super Fast Async Python Web Framework with a Rust runtime.\"\nlicense = \"BSD License (BSD)\"\nhomepage = \"https://github.com/sparckles/robyn\"\nreadme = \"README.md\"\n\n# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html\n[lib]\nname = \"robyn\"\ncrate-type = [\"cdylib\", \"rlib\"]\n\n[dependencies]\npyo3 = { version = \"0.27.2\", features = [\"extension-module\", \"py-clone\"]}\npyo3-async-runtimes = { version = \"0.27\", features = [\"tokio-runtime\"] }\npyo3-async-runtimes-macros = { version = \"0.27\" }\npyo3-log = \"0.13.2\"\ntokio = { version = \"1.40\", features = [\"full\"] }\ndashmap = \"5.4.3\"\nanyhow = \"1.0.69\"\nactix = \"0.13.4\"\nactix-web-actors = \"4.3.0\"\nactix-web = \"4.4.2\"\nactix-http = \"3.3.1\"\nactix-files = \"0.6.2\"\nfutures = \"0.3.27\"\nfutures-util = \"0.3.27\"\nmatchit = \"0.7.3\"\nsocket2 = { version = \"0.5.1\", features = [\"all\"] }\nuuid = { version = \"1.3.0\", features = [\"serde\", \"v4\"] }\nlog = \"0.4.17\"\npythonize = \"0.27\"\nserde = \"1.0.187\"\nserde_json = \"1.0.109\"\nonce_cell = \"1.8.0\"\nactix-multipart = \"0.6.1\"\nparking_lot = \"0.12.3\"\ncrossbeam-channel = \"0.5\"\n\n[features]\nio-uring = [\"actix-web/experimental-io-uring\"]\n\n[profile.release]\ncodegen-units = 1\nlto = \"fat\"\npanic = \"abort\"\nstrip = true\nopt-level = 3\n\n[profile.release.build-override]\nopt-level = 3\n\n[package.metadata.maturin]\nname = \"robyn\"\n"
},
{
"path": "LICENSE",
"content": "BSD 2-Clause License\n\nCopyright (c) 2021, Sanskar Jethi\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n\n1. Redistributions of source code must retain the above copyright notice, this\n list of conditions and the following disclaimer.\n\n2. Redistributions in binary form must reproduce the above copyright notice,\n this list of conditions and the following disclaimer in the documentation\n and/or other materials provided with the distribution.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\nAND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\nIMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\nFOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\nDAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\nSERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\nCAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\nOR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\nOF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n"
},
{
"path": "README.md",
"content": "
\n\n# Robyn\n\n[](https://twitter.com/Robyn_oss)\n[](https://pepy.tech/project/Robyn)\n[](https://github.com/sparckles/Robyn/releases/)\n[](https://github.com/sparckles/Robyn/blob/main/LICENSE)\n\n[](https://deepwiki.com/sparckles/Robyn)\n\n[](https://robyn.tech/documentation)\n[](https://discord.gg/rkERZ5eNU8)\n[](https://gurubase.io/g/robyn)\n\nRobyn is a High-Performance, Community-Driven, and Innovator Friendly Web Framework with a Rust runtime. You can learn more by checking our [community resources](https://robyn.tech/documentation/en/community-resources#talks)!\n\n\n\n\nSource: [TechEmpower Round 22](https://www.techempower.com/benchmarks/#section=data-r22&test=plaintext)\n\n## 📦 Installation\n\nYou can simply use Pip for installation.\n\n```bash\npip install robyn\n```\n\nOr, with [conda-forge](https://conda-forge.org/)\n\n```bash\nconda install -c conda-forge robyn\n```\n\nTo install with all optional features (Pydantic validation, Jinja2 templating):\n\n```bash\npip install \"robyn[all]\"\n```\n\n## 🤔 Usage\n\n### 🚀 Define your API\n\nTo define your API, you can add the following code in an `app.py` file.\n\n```python\nfrom robyn import Robyn\n\napp = Robyn(__file__)\n\n@app.get(\"/\")\nasync def h(request):\n return \"Hello, world!\"\n\napp.start(port=8080)\n```\n\n### 🏃 Run your code\n\nSimply run the app.py file you created. You will then have access to a server on the `localhost:8080`, that you can request from an other program. Robyn provides several options to customize your web server.\n\n```\n$ python3 app.py\n```\n\nTo see the usage\n\n```\nusage: app.py [-h] [--processes PROCESSES] [--workers WORKERS] [--dev] [--log-level LOG_LEVEL]\n\nRobyn, a fast async web framework with a rust runtime.\n\noptions:\n -h, --help show this help message and exit\n --processes PROCESSES\n Choose the number of processes. [Default: 1]\n --workers WORKERS Choose the number of workers. [Default: 1]\n --dev Development mode. It restarts the server based on file changes.\n --log-level LOG_LEVEL\n Set the log level name\n --create Create a new project template.\n --docs Open the Robyn documentation.\n --open-browser Open the browser on successful start.\n --version Show the Robyn version.\n --compile-rust-path COMPILE_RUST_PATH\n Compile rust files in the given path.\n --create-rust-file CREATE_RUST_FILE\n Create a rust file with the given name.\n --disable-openapi Disable the OpenAPI documentation.\n --fast Enable the fast mode.\n```\n\nLog level can be `DEBUG`, `INFO`, `WARNING`, or `ERROR`.\n\nWhen running the app using `--open-browser` a new browser window will open at the app location, e.g:\n\n```\n$ python3 app.py --open-browser\n```\n\n### 💻 Add more routes\n\nYou can add more routes to your API. Check out the routes in [this file](https://github.com/sparckles/Robyn/blob/main/integration_tests/base_routes.py) as examples.\n\n### 🐍 Python Version Support\n\nRobyn is compatible with the following Python versions:\n\n> Python >= 3.10\n\nIt is recommended to use the latest version of Python for the best performances.\n\nPlease make sure you have the correct version of Python installed before starting to use\nthis project. You can check your Python version by running the following command in your\nterminal:\n\n```bash\npython --version\n```\n\n## 💡 Features\n\n- Under active development!\n- A multithreaded Runtime\n- Extensible\n- A simple API\n- Sync and Async Function Support\n- Dynamic URL Routing\n- Multi Core Scaling\n- WebSockets\n- Middlewares (before and after request hooks)\n- Built in form data handling\n- Dependency Injection\n- Hot Reloading\n- Direct Rust Integration\n- Automatic OpenAPI generation\n- Jinja2 Templating\n- Static File Serving\n- File Responses and Downloads\n- Authentication Support\n- CORS Configuration\n- Streaming / SSE Responses\n- Startup and Shutdown Events\n- Exception Handling\n- SubRouters\n- Project Scaffolding via CLI\n- Experimental io-uring Support\n- **🤖 AI Agent Support** - Built-in agent routing and execution\n- **🔌 MCP (Model Context Protocol)** - Connect to AI applications as a server\n- Community First and truly FOSS!\n\n## 🗒️ How to contribute\n\n### 🏁 Get started\n\nPlease read the [code of conduct](https://github.com/sparckles/Robyn/blob/main/CODE_OF_CONDUCT.md) and go through [CONTRIBUTING.md](https://github.com/sparckles/Robyn/blob/main/CONTRIBUTING.md) before contributing to Robyn.\nFeel free to open an issue for any clarifications or suggestions.\n\nIf you're feeling curious. You can take a look at a more detailed architecture [here](https://robyn.tech/documentation/architecture).\n\nIf you still need help to get started, feel free to reach out on our [community discord](https://discord.gg/rkERZ5eNU8).\n\n### ⚙️ To Develop Locally\n\n#### Prerequisites\n\nBefore starting, ensure you have the following installed:\n- Python >= 3.10, <= 3.14\n- Rust (latest stable)\n- C compiler (gcc/clang)\n\n#### Setup\n\n- Clone the repository:\n\n ```\n git clone https://github.com/sparckles/Robyn.git\n ```\n\n- Setup a virtual environment:\n ```\n python3 -m venv .venv\n source .venv/bin/activate\n ```\n\n- Install required packages\n\n ```\n pip install pre-commit poetry maturin\n ```\n- Install development dependencies\n ```\n poetry install --with dev --with test\n ```\n- Install pre-commit git hooks\n ```\n pre-commit install\n ```\n- Build & install Robyn Rust package\n ```\n maturin develop\n ```\n- Build & install Robyn Rust package (**experimental**)\n ```\n maturin develop --cargo-extra-args=\"--features=io-uring\"\n ```\n- Run!\n ```\n poetry run test_server\n ```\n- Run all tests\n ```\n pytest\n ```\n- Run only the integration tests\n ```\n pytest integration_tests\n ```\n- Run only the unit tests (you don't need to be running the test_server for these)\n ```\n pytest unit_tests\n ```\n- Test (refer to `integration_tests/base_routes.py` for more endpoints)\n ```\n curl http://localhost:8080/sync/str\n ```\n\n- **tip:** One liners for testing changes!\n ```\n maturin develop && poetry run test_server\n\n maturin develop && pytest \n ```\n\n- **tip:** For IO-uring support, you can use the following command:\n ```\n maturin develop --cargo-extra-args=\"--features=io-uring\"\n ```\n\n- **tip:** To use your local Robyn version in other projects, you can install it using pip:\n ```\n pip install -e path/to/robyn/target/wheels/robyn---.whl\n ```\ne.g.\n ```\n pip install -e /repos/Robyn/target/wheels/robyn-0.63.0-cp312-cp312-macosx_10_15_universal2.whl\n ```\n\n#### Troubleshooting\nIf you face any issues, here are some common fixes:\n - install `patchelf` with `pip install patchelf` if you face `patchelf` not found issue during `maturin develop` (esp. on Arch Linux)\n - If you get Rust compilation errors, ensure you have a C compiler installed:\n - Ubuntu/Debian: `sudo apt install build-essential`\n - Fedora: `sudo dnf install gcc`\n - macOS: Install Xcode Command Line Tools\n - Windows: Install Visual Studio Build Tools\n\n\n## ✨ Special thanks\n\n### ✨ Contributors/Supporters\n\nThanks to all the contributors of the project. Robyn will not be what it is without all your support :heart:.\n\n\n \n\n\nSpecial thanks to the [PyO3](https://pyo3.rs/v0.13.2/) community and [Andrew from PyO3-asyncio](https://github.com/awestlake87/pyo3-asyncio) for their amazing libraries and their support for my queries. 💖\n\n### ✨ Sponsors\n\nThese sponsors help us make the magic happen!\n\n[](https://www.digitalocean.com/?refcode=3f2b9fd4968d&utm_campaign=Referral_Invite&utm_medium=Referral_Program&utm_source=badge)\n[](https://github.com/appwrite)\n\n\n## Star History\n\n[](https://star-history.com/#sparckles/Robyn&Date)\n"
},
{
"path": "benchmark.sh",
"content": "#!/bin/sh\n\n# Benchmark script to get info about Robyn's performances\n# You can use this benchmark when developing on Robyn to test if your changes had a huge\n# impact on performances. You cannot compare benchmarks from different machine and even\n# several runs on the same machine can give very different results sometimes.\n# Be aware of this when using this script!\n\nHelp() {\n echo \"Benchmark script to get info about Robyn's performances.\"\n echo\n echo \"USAGE:\"\n echo \" benchmark [-h|m|n|y]\"\n echo\n echo \"OPTIONS:\"\n echo \" -h Print this help.\"\n echo \" -m Run 'maturin develop' to compile the Rust part of Robyn.\"\n echo \" -n Set the number of requests that oha sends.\"\n echo \" -y Skip prompt\"\n exit 0\n}\n\nyes_flag=false\nrun_maturin=false\nnumber=100000\nwhile getopts hymn: opt; do\n case $opt in\n h)\n Help\n ;;\n y)\n yes_flag=true\n ;;\n m)\n run_maturin=true\n ;;\n n)\n number=$OPTARG\n ;;\n ?)\n echo 'Error in command line parsing' >&2\n Help\n exit 1\n ;;\n esac\ndone\n\n# Prompt user to check if he installed the requirements for running the benchmark\nif [ \"$yes_flag\" = false ]; then\n echo \"Make sure you are running this in your venv and you installed 'oha' using 'cargo install oha'\"\n echo \"Do you want to proceed?\"\n while true; do\n read -p \"\" yn\n case $yn in\n [Yy]* ) break;;\n [Nn]* ) exit;;\n * ) echo \"Please answer yes or no.\";;\n esac\n done\nfi\n\n\n# Compile Rust\nif $run_maturin; then\n maturin develop\nfi\n\n# Run the server in the background\npython3 ./integration_tests/base_routes.py &\nsleep 1\n\n# oha will display benchmark results\noha -n \"$number\" http://localhost:8080/sync\n\n# Kill subprocesses after exiting the script (python + robyn server)\n# (see https://stackoverflow.com/questions/360201/how-do-i-kill-background-processes-jobs-when-my-shell-script-exits)\ntrap \"trap - TERM && kill 0\" INT TERM EXIT\n"
},
{
"path": "ci-local.sh",
"content": "#!/usr/bin/env bash\nset -euo pipefail\n\nRED='\\033[0;31m'\nGREEN='\\033[0;32m'\nYELLOW='\\033[1;33m'\nCYAN='\\033[0;36m'\nNC='\\033[0m'\n\nFAILED=()\nPASSED=()\nSKIPPED=()\n\nrun_step() {\n local name=\"$1\"\n shift\n echo -e \"\\n${CYAN}── $name ──${NC}\"\n echo -e \"${YELLOW}$ $*${NC}\"\n if \"$@\"; then\n PASSED+=(\"$name\")\n echo -e \"${GREEN}✓ $name${NC}\"\n else\n FAILED+=(\"$name\")\n echo -e \"${RED}✗ $name${NC}\"\n fi\n}\n\nskip_step() {\n local name=\"$1\"\n local reason=\"$2\"\n SKIPPED+=(\"$name ($reason)\")\n echo -e \"\\n${YELLOW}── $name [SKIPPED: $reason] ──${NC}\"\n}\n\nusage() {\n echo \"Usage: $0 [rust|lint|python|all|fix]\"\n echo \"\"\n echo \"Mirrors the GitHub Actions CI workflows locally.\"\n echo \"\"\n echo \" rust Rust CI: cargo check, test, fmt --check, clippy\"\n echo \" lint Lint PR: ruff check, isort --check-only\"\n echo \" python Python CI: nox test suite (current Python version)\"\n echo \" all Everything (default)\"\n echo \" fix Auto-fix: cargo fmt, ruff --fix, isort\"\n exit 0\n}\n\n# ── rust-CI.yml ───────────────────────────────────────────────────────────────\nrun_rust() {\n echo -e \"\\n${CYAN}═══ Rust CI (.github/workflows/rust-CI.yml) ═══${NC}\"\n run_step \"cargo check\" cargo check\n run_step \"cargo test\" cargo test\n run_step \"cargo fmt\" cargo fmt --check\n run_step \"cargo clippy\" cargo clippy\n}\n\n# ── lint-pr.yml ───────────────────────────────────────────────────────────────\nrun_lint() {\n echo -e \"\\n${CYAN}═══ Lint PR (.github/workflows/lint-pr.yml) ═══${NC}\"\n\n if command -v ruff &>/dev/null; then\n run_step \"ruff check\" ruff check .\n else\n skip_step \"ruff check\" \"ruff not installed (pip install ruff)\"\n fi\n\n if command -v isort &>/dev/null; then\n run_step \"isort check\" isort --check-only --diff .\n else\n skip_step \"isort check\" \"isort not installed (pip install isort)\"\n fi\n}\n\n# ── python-CI.yml ─────────────────────────────────────────────────────────────\nrun_python() {\n echo -e \"\\n${CYAN}═══ Python CI (.github/workflows/python-CI.yml) ═══${NC}\"\n local pyver\n pyver=$(python3 -c \"import sys; print(f'{sys.version_info.major}.{sys.version_info.minor}')\")\n\n if command -v nox &>/dev/null; then\n run_step \"nox (python $pyver)\" nox --non-interactive --error-on-missing-interpreter -p \"$pyver\"\n else\n skip_step \"nox tests\" \"nox not installed (pip install nox)\"\n fi\n}\n\n# ── fix mode ──────────────────────────────────────────────────────────────────\nrun_fix() {\n echo -e \"\\n${CYAN}═══ Auto-fix ═══${NC}\"\n run_step \"cargo fmt\" cargo fmt\n command -v ruff &>/dev/null && run_step \"ruff fix\" ruff check --fix . || skip_step \"ruff fix\" \"not installed\"\n command -v isort &>/dev/null && run_step \"isort fix\" isort . || skip_step \"isort fix\" \"not installed\"\n}\n\n# ── main ──────────────────────────────────────────────────────────────────────\nMODE=\"${1:-all}\"\n\ncase \"$MODE\" in\n rust) run_rust ;;\n lint) run_lint ;;\n python) run_python ;;\n fix) run_fix ;;\n all) run_rust; run_lint; run_python ;;\n -h|--help|help) usage ;;\n *) echo \"Unknown mode: $MODE\"; usage ;;\nesac\n\n# ── summary ───────────────────────────────────────────────────────────────────\necho -e \"\\n${CYAN}═══ Summary ═══${NC}\"\nfor s in \"${PASSED[@]+\"${PASSED[@]}\"}\"; do echo -e \" ${GREEN}✓${NC} $s\"; done\nfor s in \"${SKIPPED[@]+\"${SKIPPED[@]}\"}\"; do echo -e \" ${YELLOW}⊘${NC} $s\"; done\nfor s in \"${FAILED[@]+\"${FAILED[@]}\"}\"; do echo -e \" ${RED}✗${NC} $s\"; done\n\nif [ ${#FAILED[@]} -gt 0 ]; then\n echo -e \"\\n${RED}CI would fail: ${#FAILED[@]} check(s) failed.${NC}\"\n exit 1\nelse\n echo -e \"\\n${GREEN}All checks passed. Safe to push.${NC}\"\n exit 0\nfi\n"
},
{
"path": "docs_src/.eslintrc.json",
"content": "{\n \"extends\": [\"next\",\"next/core-web-vitals\"],\n \"rules\": {\n \"react/no-unescaped-entities\": \"off\"\n }\n}\n"
},
{
"path": "docs_src/.gitignore",
"content": "# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.\n\n# dependencies\n/node_modules\n/.pnp\n.pnp.js\n\n# testing\n/coverage\n\n# next.js\n/.next/\n/out/\n\n# production\n/build\n\n# misc\n.DS_Store\n*.pem\n\n# debug\nnpm-debug.log*\nyarn-debug.log*\nyarn-error.log*\n.pnpm-debug.log*\n\n# local env files\n.env*.local\n\n# vercel\n.vercel\n\n# generated files\n/public/rss/\n"
},
{
"path": "docs_src/README.md",
"content": "## Docs Base\n\nThis is the documentation website that will be used as a base for Robyn and Starfyre docs.\n\n## Setup\n\n1. Clone this repo\n2. Run `npm install`\n3. Run `npm run dev`\n4. Open `http://localhost:3000` in your browser\n\n"
},
{
"path": "docs_src/jsconfig.json",
"content": "{\n \"compilerOptions\": {\n \"baseUrl\": \".\",\n \"paths\": {\n \"@/*\": [\"src/*\"]\n }\n }\n}\n"
},
{
"path": "docs_src/mdx/recma.mjs",
"content": "import { mdxAnnotations } from 'mdx-annotations'\nimport recmaNextjsStaticProps from 'recma-nextjs-static-props'\nimport { recmaImportImages } from 'recma-import-images'\n\nfunction recmaRemoveNamedExports() {\n return (tree) => {\n tree.body = tree.body.map((node) => {\n if (node.type === 'ExportNamedDeclaration') {\n return node.declaration\n }\n return node\n })\n }\n}\n\nexport const recmaPlugins = [\n mdxAnnotations.recma,\n recmaRemoveNamedExports,\n recmaNextjsStaticProps,\n recmaImportImages,\n]\n"
},
{
"path": "docs_src/mdx/rehype.mjs",
"content": "import { mdxAnnotations } from 'mdx-annotations'\nimport { visit } from 'unist-util-visit'\nimport rehypeMdxTitle from 'rehype-mdx-title'\nimport shiki from 'shiki'\nimport { toString } from 'mdast-util-to-string'\nimport * as acorn from 'acorn'\nimport { slugifyWithCounter } from '@sindresorhus/slugify'\nimport rehypeSlug from 'rehype-slug'\nimport { remarkRehypeWrap } from 'remark-rehype-wrap'\nimport rehypeAutolinkHeadings from 'rehype-autolink-headings'\n\nfunction rehypeParseCodeBlocks() {\n return (tree) => {\n visit(tree, 'element', (node, _nodeIndex, parentNode) => {\n if (node.tagName === 'code' && node.properties.className) {\n parentNode.properties.language = node.properties.className[0]?.replace(\n /^language-/,\n ''\n )\n }\n })\n }\n}\n\nlet highlighter\n\nfunction rehypeShiki() {\n return async (tree) => {\n highlighter =\n highlighter ?? (await shiki.getHighlighter({ theme: 'css-variables' }))\n\n visit(tree, 'element', (node) => {\n if (node.tagName === 'pre' && node.children[0]?.tagName === 'code') {\n let codeNode = node.children[0]\n let textNode = codeNode.children[0]\n\n node.properties.code = textNode.value\n\n if (node.properties.language) {\n let tokens = highlighter.codeToThemedTokens(\n textNode.value,\n node.properties.language\n )\n\n textNode.value = shiki.renderToHtml(tokens, {\n elements: {\n pre: ({ children }) => children,\n code: ({ children }) => children,\n line: ({ children }) => `${children}`,\n },\n })\n }\n }\n })\n }\n}\n\nfunction rehypeSlugify() {\n return (tree) => {\n let slugify = slugifyWithCounter()\n visit(tree, 'element', (node) => {\n if (node.tagName === 'h2' && !node.properties.id) {\n node.properties.id = slugify(toString(node))\n }\n })\n }\n}\n\nfunction rehypeAddMDXExports(getExports) {\n return (tree) => {\n let exports = Object.entries(getExports(tree))\n\n for (let [name, value] of exports) {\n for (let node of tree.children) {\n if (\n node.type === 'mdxjsEsm' &&\n new RegExp(`export\\\\s+const\\\\s+${name}\\\\s*=`).test(node.value)\n ) {\n return\n }\n }\n\n let exportStr = `export const ${name} = ${value}`\n\n tree.children.push({\n type: 'mdxjsEsm',\n value: exportStr,\n data: {\n estree: acorn.parse(exportStr, {\n sourceType: 'module',\n ecmaVersion: 'latest',\n }),\n },\n })\n }\n }\n}\n\nfunction getSections(node) {\n let sections = []\n\n for (let child of node.children ?? []) {\n if (child.type === 'element' && child.tagName === 'h2') {\n sections.push(`{\n title: ${JSON.stringify(toString(child))},\n id: ${JSON.stringify(child.properties.id)},\n ...${child.properties.annotation}\n }`)\n } else if (child.children) {\n sections.push(...getSections(child))\n }\n }\n\n return sections\n}\n\nexport const rehypePlugins = [\n rehypeSlug,\n [rehypeAutolinkHeadings, { behavior: 'wrap', test: ['h2'] }],\n [\n remarkRehypeWrap,\n {\n node: { type: 'element', tagName: 'article' },\n start: 'element[tagName=hr]',\n transform: (article) => {\n article.children.splice(0, 1)\n let heading = article.children.find((n) => n.tagName === 'h2')\n if (heading) {\n article.properties = { ...heading.properties, title: toString(heading) }\n heading.properties = {}\n } else {\n article.properties = {}\n }\n return article\n },\n },\n ],\n\n mdxAnnotations.rehype,\n rehypeParseCodeBlocks,\n rehypeShiki,\n rehypeSlugify,\n rehypeMdxTitle,\n [\n rehypeAddMDXExports,\n (tree) => ({\n sections: `[${getSections(tree).join()}]`,\n }),\n ],\n]\n"
},
{
"path": "docs_src/mdx/remark.mjs",
"content": "import { mdxAnnotations } from 'mdx-annotations'\nimport remarkGfm from 'remark-gfm'\nimport remarkUnwrapImages from 'remark-unwrap-images'\n\nexport const remarkPlugins = [\n mdxAnnotations.remark,\n remarkGfm,\n remarkUnwrapImages,\n]\n"
},
{
"path": "docs_src/next.config.mjs",
"content": "import nextMDX from '@next/mdx'\nimport { remarkPlugins } from './mdx/remark.mjs'\nimport { rehypePlugins } from './mdx/rehype.mjs'\nimport { recmaPlugins } from './mdx/recma.mjs'\n\nconst withMDX = nextMDX({\n options: {\n remarkPlugins,\n rehypePlugins,\n recmaPlugins,\n providerImportSource: '@mdx-js/react',\n },\n})\n\n/** @type {import('next').NextConfig} */\nconst nextConfig = {\n reactStrictMode: true,\n pageExtensions: ['js', 'jsx', 'ts', 'tsx', 'mdx'],\n experimental: {\n scrollRestoration: true,\n },\n i18n: {\n locales: ['en', 'zh'],\n defaultLocale: 'en',\n localeDetection: false,\n },\n async redirects() {\n return [\n {\n source: '/documentation',\n destination: '/documentation/en',\n permanent: false,\n },\n ]\n },\n}\n\nexport default withMDX(nextConfig)\n"
},
{
"path": "docs_src/package.json",
"content": "{\n \"name\": \"tailwindui-template\",\n \"version\": \"0.1.0\",\n \"private\": true,\n \"scripts\": {\n \"dev\": \"next dev\",\n \"build\": \"next build\",\n \"start\": \"next start\",\n \"lint\": \"next lint\"\n },\n \"browserslist\": \"defaults, not ie <= 11\",\n \"dependencies\": {\n \"@algolia/autocomplete-core\": \"^1.9.3\",\n \"@algolia/autocomplete-preset-algolia\": \"^1.9.3\",\n \"@headlessui/react\": \"^1.7.15\",\n \"@heroicons/react\": \"^2.0.18\",\n \"@mapbox/rehype-prism\": \"^0.8.0\",\n \"@mdx-js/loader\": \"^2.1.5\",\n \"@mdx-js/react\": \"^2.1.5\",\n \"@next/mdx\": \"^13.0.2\",\n \"@sindresorhus/slugify\": \"^2.2.1\",\n \"@tailwindcss/typography\": \"^0.5.4\",\n \"@vercel/analytics\": \"^1.0.2\",\n \"algoliasearch\": \"^4.17.2\",\n \"autoprefixer\": \"^10.4.12\",\n \"axios\": \"^1.4.0\",\n \"clsx\": \"^1.2.1\",\n \"fast-glob\": \"^3.2.11\",\n \"feed\": \"^4.2.2\",\n \"focus-visible\": \"^5.2.0\",\n \"framer-motion\": \"^10.12.16\",\n \"highlight.js\": \"^11.8.0\",\n \"mdx-annotations\": \"^0.1.3\",\n \"meilisearch\": \"^0.33.0\",\n \"next\": \"13.4.2\",\n \"next-mdx-remote\": \"^6.0.0\",\n \"next-router-mock\": \"^0.9.3\",\n \"postcss-focus-visible\": \"^6.0.4\",\n \"prism-themes\": \"^1.9.0\",\n \"prismjs\": \"^1.29.0\",\n \"react\": \"18.2.0\",\n \"react-dom\": \"18.2.0\",\n \"react-markdown\": \"^8.0.7\",\n \"recma-import-images\": \"^0.0.3\",\n \"recma-nextjs-static-props\": \"^1.0.0\",\n \"rehype-autolink-headings\": \"^6.1.1\",\n \"rehype-mdx-title\": \"^2.0.0\",\n \"rehype-slug\": \"^5.1.0\",\n \"remark-gfm\": \"^3.0.1\",\n \"remark-rehype-wrap\": \"^0.0.2\",\n \"remark-unwrap-images\": \"^3.0.1\",\n \"shiki\": \"^0.14.2\",\n \"tailwindcss\": \"^3.3.0\",\n \"zustand\": \"^4.3.8\"\n },\n \"devDependencies\": {\n \"eslint\": \"8.26.0\",\n \"eslint-config-next\": \"13.0.2\",\n \"prettier\": \"^2.8.7\",\n \"prettier-plugin-tailwindcss\": \"^0.2.6\"\n }\n}\n"
},
{
"path": "docs_src/postcss.config.js",
"content": "module.exports = {\n plugins: {\n tailwindcss: {},\n 'postcss-focus-visible': {\n replaceWith: '[data-focus-visible-added]',\n },\n autoprefixer: {},\n },\n}\n"
},
{
"path": "docs_src/prettier.config.js",
"content": "module.exports = {\n singleQuote: true,\n semi: false,\n plugins: [require('prettier-plugin-tailwindcss')],\n}\n"
},
{
"path": "docs_src/public/funding.json",
"content": "{\n \"version\": \"v1.0.0\",\n \"entity\": {\n \"type\": \"individual\",\n \"role\": \"owner\",\n \"name\": \"Sanskar Jethi\",\n \"email\": \"sansyrox@gmail.com\",\n \"phone\": \"\",\n \"description\": \"Sanskar is a FOSS engineer who created Robyn and Starfyre. Sanskar has created software for over half his life and used it for almost all of his.\",\n \"webpageUrl\": {\n \"url\": \"https://robyn.tech/\"\n }\n },\n \"projects\": [\n {\n \"guid\": \"robyn\",\n \"name\": \"robyn\",\n \"description\": \"Robyn is one of the fastest Python web frameworks, which comes with a built in web server and a Rust runtime.\",\n \"webpageUrl\": {\n \"url\": \"https://robyn.tech/\"\n },\n \"repositoryUrl\": {\n \"url\": \"https://github.com/sparckles/Robyn\",\n \"wellKnown\": \"https://github.com/sparckles/Robyn/blob/main/.well-known/funding-manifest-urls\"\n },\n \"licenses\": [\"BSD 2-Clause \\\"Simplified\\\" License\"],\n \"tags\": [\"programming\", \"python\", \"rust\", \"web\", \"backend\", \"async\"]\n }\n ],\n \"funding\": {\n \"channels\": [\n {\n \"guid\": \"mybank\",\n \"type\": \"bank\",\n \"address\": \"\",\n \"description\": \"Send me an email to get my bank details\"\n }\n ],\n \"plans\": [\n {\n \"guid\": \"mybank\",\n \"status\": \"active\",\n \"name\": \"Support Maintainer Part Time\",\n \"description\": \"Support the maintainer for his work on Robyn part time.\",\n \"amount\": 500,\n \"currency\": \"GBP\",\n \"frequency\": \"monthly\",\n \"channels\": [\"mybank\"]\n },\n {\n \"guid\": \"mybank\",\n \"status\": \"active\",\n \"name\": \"Support Maintainer Full Time\",\n \"description\": \"Support the maintainer for his work on Robyn full time.\",\n \"amount\": 3000,\n \"currency\": \"GBP\",\n \"frequency\": \"monthly\",\n \"channels\": [\"mybank\"]\n },\n {\n \"guid\": \"150\",\n \"status\": \"active\",\n \"name\": \" Support Contributor Part Time\",\n \"description\": \"Support for one contributor per month\",\n \"amount\": 150,\n \"currency\": \"GBP\",\n \"frequency\": \"monthly\",\n \"channels\": [\"mybank\"]\n },\n {\n \"guid\": \"500\",\n \"status\": \"active\",\n \"name\": \" Support Contributor Full Time\",\n \"description\": \"Support for one contributor per month\",\n \"amount\": 500,\n \"currency\": \"GBP\",\n \"frequency\": \"monthly\",\n \"channels\": [\"mybank\"]\n }\n ],\n \"history\": []\n }\n}\n"
},
{
"path": "docs_src/public/llms.txt",
"content": "# Robyn\n\n> Robyn is a high-performance, community-driven, and innovator-friendly async web framework for Python with a Rust runtime. It combines Python's ease of use with Rust's performance.\n\n## Quick Facts\n\n- Version: 0.79.0\n- Python: >= 3.10\n- License: BSD 2.0\n- Repository: https://github.com/sparckles/robyn\n- Documentation: https://robyn.tech/documentation\n- Discord: https://discord.gg/rkERZ5eNU8\n\n## Installation\n\n```bash\npip install robyn\n```\n\n## Basic Usage\n\n```python\nfrom robyn import Robyn\n\napp = Robyn(__file__)\n\n@app.get(\"/\")\nasync def index(request):\n return \"Hello, World!\"\n\napp.start(port=8080)\n```\n\n## Key Features\n\n- **Rust Runtime**: Core server written in Rust using actix-web for high performance\n- **Async/Sync Support**: Both async and sync route handlers supported\n- **Multi-Process Scaling**: Built-in multiprocess execution via `--processes` and `--workers`\n- **WebSockets**: Native WebSocket support\n- **Middlewares**: Before/after request middlewares\n- **Dependency Injection**: Built-in DI system\n- **OpenAPI/Swagger**: Automatic OpenAPI documentation generation\n- **Hot Reloading**: Development mode with `--dev` flag\n- **AI Agents**: Built-in AI agent routing via `robyn.ai`\n- **MCP Support**: Model Context Protocol server capabilities via `app.mcp`\n- **Templating**: Jinja2 templating support (optional)\n- **CORS**: Built-in CORS helper via `ALLOW_CORS()`\n- **Authentication**: AuthenticationHandler base class for custom auth\n- **Static Files**: Directory serving via `app.serve_directory()`\n- **SSE**: Server-Sent Events support via `SSEResponse`\n- **Easy Access Parameters**: Typed path/query params with automatic coercion in handler signatures\n- **Direct Rust Integration**: Embed Rust code directly in routes\n\n## Project Structure\n\n```\nrobyn/\n├── src/ # Rust source code\n│ ├── lib.rs # PyO3 module entry point\n│ ├── server.rs # Main HTTP server implementation\n│ ├── types/ # Request, Response, Headers, Cookie types\n│ ├── routers/ # HTTP, WebSocket, middleware routers\n│ ├── executors/ # Route execution handlers\n│ └── websockets/ # WebSocket implementation\n├── robyn/ # Python package\n│ ├── __init__.py # Main Robyn and SubRouter classes\n│ ├── router.py # Python router implementation\n│ ├── authentication.py # AuthenticationHandler\n│ ├── dependency_injection.py\n│ ├── openapi.py # OpenAPI generation\n│ ├── mcp.py # MCP protocol support\n│ ├── ai.py # AI agent support\n│ ├── responses.py # Response helpers (serve_file, html, SSE)\n│ ├── ws.py # WebSocket class\n│ └── robyn.pyi # Type stubs\n├── integration_tests/ # Integration test suite\n├── unit_tests/ # Unit test suite\n├── docs_src/ # Documentation (Next.js)\n├── granian/ # Bundled Granian server (fork)\n└── examples/ # Example applications\n```\n\n## Core Classes\n\n### Robyn / SubRouter\nMain application class and sub-router for modular routes.\n\n```python\nfrom robyn import Robyn, SubRouter\n\napp = Robyn(__file__)\napi = SubRouter(__file__, prefix=\"/api\")\n\n@api.get(\"/users\")\ndef get_users(request):\n return {\"users\": []}\n\napp.include_router(api)\n```\n\n### Request Object\n```python\nrequest.method # HTTP method\nrequest.url # Url object (scheme, host, path)\nrequest.headers # Headers dict-like\nrequest.query_params # QueryParams\nrequest.path_params # Dict of URL params\nrequest.body # Raw bytes\nrequest.json() # Parse JSON body\nrequest.form_data # Multipart form data\nrequest.ip_addr # Client IP\nrequest.identity # Identity (if authenticated)\n```\n\n### Response Object\n```python\nfrom robyn import Response\n\nResponse(\n status_code=200,\n headers={\"Content-Type\": \"application/json\"},\n description=\"body content\" # or body bytes\n)\n```\n\n### Decorators\n```python\n@app.get(\"/path\")\n@app.post(\"/path\")\n@app.put(\"/path\")\n@app.delete(\"/path\")\n@app.patch(\"/path\")\n@app.head(\"/path\")\n@app.options(\"/path\")\n\n@app.before_request(\"/path\") # Middleware before\n@app.after_request(\"/path\") # Middleware after\n\n@app.startup_handler # Server startup\n@app.shutdown_handler # Server shutdown\n```\n\n### WebSockets\n```python\nfrom robyn import WebSocketDisconnect\n\n@app.websocket(\"/ws\")\nasync def handler(websocket):\n try:\n while True:\n msg = await websocket.receive_text()\n await websocket.send_text(f\"Echo: {msg}\")\n except WebSocketDisconnect:\n pass\n\n@handler.on_connect\ndef on_connect(websocket):\n return \"Connected\"\n\n@handler.on_close\ndef on_close(websocket):\n return \"Closed\"\n```\n\n### Easy Access Parameters\nDeclare typed path and query parameters directly in handler signatures. Works for both HTTP and WebSocket handlers.\n\n```python\nfrom typing import List, Optional\n\n# HTTP: path params + query params with type coercion\n@app.get(\"/items/:id\")\nasync def get_item(id: int, q: str, page: int = 1):\n return {\"id\": id, \"q\": q, \"page\": page}\n\n# Optional, List, and bool params\n@app.get(\"/search\")\ndef search(name: str, tags: List[str], active: bool = False, age: Optional[int] = None):\n return {\"name\": name, \"tags\": tags, \"active\": active, \"age\": age}\n\n# WebSocket: typed query params on handler and callbacks\n@app.websocket(\"/ws\")\nasync def handler(websocket, room: str = \"default\", page: int = 1):\n while True:\n msg = await websocket.receive_text()\n await websocket.send_text(f\"room={room} page={page} msg={msg}\")\n\n@handler.on_connect\ndef on_connect(websocket, room: str = \"default\"):\n return f\"connected to {room}\"\n```\n\n### MCP (Model Context Protocol)\n```python\n@app.mcp.resource(\"time://current\")\ndef get_time():\n return datetime.now().isoformat()\n\n@app.mcp.tool(name=\"calc\", description=\"Calculate\", input_schema={...})\ndef calculate(args):\n return eval(args[\"expression\"])\n\n@app.mcp.prompt(name=\"explain\", description=\"Explain code\", arguments=[...])\ndef explain_prompt(args):\n return f\"Please explain: {args['code']}\"\n```\n\n## CLI Commands\n\n```bash\npython app.py # Start server\npython app.py --dev # Development mode (hot reload)\npython app.py --processes 4 # Multi-process\npython app.py --workers 2 # Workers per process\npython app.py --log-level DEBUG # Log level\npython app.py --open-browser # Open browser on start\npython app.py --create # Create new project scaffold\npython app.py --docs # Open documentation\n```\n\n## Development Setup\n\n```bash\n# Clone\ngit clone https://github.com/sparckles/robyn.git\ncd robyn\n\n# Virtual environment\npython3 -m venv .venv && source .venv/bin/activate\n\n# Install tools\npip install pre-commit poetry maturin\n\n# Install dependencies\npoetry install --with dev --with test\n\n# Build Rust extension\nmaturin develop\n\n# Run tests\npytest\n```\n\n## Key Dependencies\n\n- **PyO3**: Rust-Python bindings\n- **actix-web**: Rust HTTP server (via cookie crate)\n- **orjson**: Fast JSON serialization\n- **multiprocess**: Multi-process support\n- **uvloop**: Fast event loop (non-Windows)\n- **watchdog**: File watching for hot reload\n\n## Configuration\n\nEnvironment variables:\n- `ROBYN_HOST`: Server host (default: 127.0.0.1)\n- `ROBYN_PORT`: Server port (default: 8080)\n- `ROBYN_DEV_MODE`: Enable dev mode\n- `ROBYN_BROWSER_OPEN`: Open browser on start\n- `ROBYN_CLIENT_TIMEOUT`: Client timeout seconds\n- `ROBYN_KEEP_ALIVE_TIMEOUT`: Keep-alive timeout\n\n## Documentation Structure\n\nMain docs at `docs_src/src/pages/documentation/`:\n- `api_reference/getting_started.mdx` - Quick start guide\n- `api_reference/request_object.mdx` - Request handling\n- `api_reference/middlewares.mdx` - Middleware usage\n- `api_reference/websockets.mdx` - WebSocket guide\n- `api_reference/authentication.mdx` - Auth patterns\n- `api_reference/openapi.mdx` - OpenAPI docs\n- `api_reference/agents.mdx` - AI agent integration\n- `api_reference/mcps.mdx` - MCP server guide\n- `example_app/` - Full example application tutorial\n"
},
{
"path": "docs_src/src/components/Button.jsx",
"content": "import Link from 'next/link'\nimport clsx from 'clsx'\n\nconst variantStyles = {\n primary:\n 'font-semibold text-zinc-100 bg-zinc-700 hover:bg-zinc-600 active:bg-zinc-700 active:text-zinc-100/70',\n secondary:\n 'font-medium bg-zinc-800/50 text-zinc-300 hover:bg-zinc-800 hover:text-zinc-50 active:bg-zinc-800/50 active:text-zinc-50/70',\n}\n\nexport function Button({ variant = 'primary', className, href, ...props }) {\n className = clsx(\n 'inline-flex items-center gap-2 justify-center rounded-md py-2 px-3 text-sm outline-offset-2 transition active:transition-none',\n variantStyles[variant],\n className\n )\n\n return href ? (\n \n ) : (\n \n )\n}\n"
},
{
"path": "docs_src/src/components/Card.jsx",
"content": "import Link from 'next/link'\nimport clsx from 'clsx'\n\nfunction ChevronRightIcon(props) {\n return (\n \n )\n}\n\nexport function Card({ as: Component = 'div', className, children }) {\n return (\n \n {children}\n \n )\n}\n\nCard.Link = function CardLink({ children, ...props }) {\n return (\n <>\n \n \n \n {children}\n \n \n )\n}\n\nCard.Title = function CardTitle({ as: Component = 'h2', href, children }) {\n return (\n \n {href ? {children} : children}\n \n )\n}\n\nCard.Description = function CardDescription({ children }) {\n return
\n}\n"
},
{
"path": "docs_src/src/components/Section.jsx",
"content": "import { useId } from 'react'\n\nexport function Section({ title, children }) {\n let id = useId()\n\n return (\n \n
\n
\n {title}\n
\n
{children}
\n
\n \n )\n}\n"
},
{
"path": "docs_src/src/components/SimpleLayout.jsx",
"content": "import { Container } from '@/components/Container'\n\nexport function SimpleLayout({ title, intro, children }) {\n return (\n \n \n
\n {title}\n
\n
{intro}
\n \n
{children}
\n \n )\n}\n"
},
{
"path": "docs_src/src/components/SocialIcons.jsx",
"content": "export function TwitterIcon(props) {\n return (\n \n )\n}\n\nexport function InstagramIcon(props) {\n return (\n \n )\n}\n\nexport function GitHubIcon(props) {\n return (\n \n )\n}\n\nexport function LinkedInIcon(props) {\n return (\n \n )\n}\n\nexport function DiscordIcon(props) {\n return (\n \n \n \n )\n}\n"
},
{
"path": "docs_src/src/components/Testimonials.jsx",
"content": "import { useEffect } from 'react'\n\nlet testimonials = [\n {\n body: \"Robyn has revolutionized the way I develop web solutions. Its seamless integration of Python's async capabilities with a Rust runtime not only ensures reliability and scalability but also provides quick project setup, a delightful user experience, and robust plugin support. With its exceptional speed and multithreaded efficiency, Robyn's real-time communication through WebSockets and dynamic URL routing has empowered me to create highly performant and interactive applications while maintaining full control over navigation and workflows. A game-changer for modern web development!\",\n author: {\n name: 'Kunal Kushwaha',\n handle: 'kunalstwt',\n imageUrl: '/testimonials/kunalstwt.jpg',\n title: 'DevRel manager at Civo',\n },\n },\n\n {\n body: \"Having worked with a company building a Rust based open source search engine for over a year, I strongly believe in the notion that rewriting software with Rust can significantly improve software performance. Sanskar's idea to recreate Flask with Rust, was just incredible. Having used Robyn myself, it is refreshing to see such a performant Python framework and just the amazing developer ecosystem around it. Yes it still new and being developed, but I can say this with confidence that given the underlying Rust-based multithreaded run time will provide immense performance for running high throughout applications. I am glad to be one of the early sponsors and adopters for Robyn!\",\n author: {\n name: 'Shivay Lamba',\n handle: 'howdevelop',\n imageUrl: '/testimonials/howdevelop.jpg',\n title: 'Developer Experience Engineer at MeiliSearch',\n },\n },\n {\n body: \"I'm impressed with Robyn. It's a fast asynchronous web framework for the Python ecosystem that's built on top of Rust. The syntax is similar to other popular web frameworks, so it's easy to learn and be productive with. I've been using it to build web applications and services, and I'm really happy with the results. I'm also impressed with the Robyn community. They are very supportive and the developers are very responsive to feedback\",\n author: {\n name: 'Carlos A. Marcano Vargas',\n handle: 'carlos_marcv',\n imageUrl: '/testimonials/carlos_marcv.jpg',\n title: 'Technical Writer',\n },\n },\n // More testimonials...\n {\n body: 'Great to see a Community Driven Open Source project, achieve new heights! Robyn is built by the community for the community',\n author: {\n name: 'Eddie Jaoude',\n handle: 'eddiejaoude',\n imageUrl: '/testimonials/eddiejaoude.jpg',\n title: 'Creator of EddieHub',\n },\n },\n // More testimonials...\n {\n body: 'I used to be a Batman fan, but having met Robyn I now think the sidekick has become the hero. Free, OSS, straight forward and powerful, what is not to love?',\n author: {\n name: 'GrahamTheDev',\n handle: 'GrahamTheDev',\n imageUrl: '/testimonials/GrahamTheDev.jpg',\n title: 'The Accessibility First DevRel ',\n },\n },\n {\n body: 'Having used both, Flask and Django for writing web applications in Python in the past, Robyn looks like their combined successor in terms of ergonomics and features available. Its reliance on a Rust runtime for performance and security is the cherry on the cake!',\n author: {\n name: 'Daniel Bodky',\n handle: 'd_bodky',\n imageUrl: '/testimonials/d_bodky.jpg',\n title: 'Consultant, Trainer, Speaker @NETWAYS',\n },\n },\n // More testimonials...\n {\n body: 'Robyn has made a big difference in my projects. Its flexible structure allows my work to adapt smoothly to my needs, even when I face complex challenges. The community-driven and open-source nature of Robyn makes it a welcoming place for developers like me. Plus, its simple yet powerful API has greatly streamlined my development process, reducing my wor oad. I highly recommend it!',\n author: {\n name: 'Julia Furst Morgado',\n handle: 'juliafmorgado',\n imageUrl: '/testimonials/juliafmorgado.jpg',\n title: 'Global technologist @Veeam',\n },\n },\n // More testimonials...\n {\n body: 'Robyn opens a new chapter in the Python web frameworks scene: the Rust powered one, where performance and safety are not the sole protagonists.',\n author: {\n name: 'Giovanni Barillari',\n handle: 'gi0baro',\n imageUrl: '/testimonials/gi0baro.jpeg',\n title: 'Author of Granian and Emmett',\n },\n },\n // More testimonials...\n {\n body: \"I collaborate with Robyn's team and I must say, Sanskar does an excellent job maintaining the community. The project as a whole is immensely beneficial, both for collaboration and its practical uses. The tool is impressive, easy to use and the entire community is very welcoming to first-time contributors\",\n author: {\n name: 'Jyoti Bisht',\n handle: 'joeyousss',\n imageUrl: '/testimonials/joeyousss.jpg',\n title: 'Open Source Developer',\n },\n },\n // More testimonials...\n {\n body: \"Robyn is a breath of fresh air in web development. Merging Python's simplicity with Rust's speed, it offers a seamless experience for developers. Its features are precisely what today's web projects need. I'm particularly impressed with its community focus; it's evident that everyone's voice matters in shaping Robyn's journey. In a sea of web frameworks, Robyn stands out not just for its tech but also for its heart.\",\n author: {\n name: 'Francesco Ciulla',\n handle: 'FrancescoCiull4',\n imageUrl: '/testimonials/FrancescoCiull4.jpg',\n title: 'DevRel at daily.dev',\n },\n },\n // More testimonials...\n]\n\n//shuflle testimonials\n\nfunction classNames(...classes) {\n return classes.filter(Boolean).join(' ')\n}\n\nconst chunk = (arr, size) =>\n Array.from({ length: Math.ceil(arr.length / size) }, (v, i) =>\n arr.slice(i * size, i * size + size)\n )\n\nexport default function Testimonials() {\n let chunkedTestimonials = [];\n \n // Separate testimonials into groups of 3, 4, and 3\n const firstGroup = chunk(testimonials.slice(0, 3), 3);\n const secondGroup = chunk(testimonials.slice(3, 7), 4);\n const thirdGroup = chunk(testimonials.slice(7), 3);\n \n // Concatenate the groups in the desired order\n chunkedTestimonials = firstGroup.concat(secondGroup, thirdGroup);\n return (\n
\n \n \n
\n \n \n \n
\n
\n
\n Testimonials\n
\n
\n Some amazing people have said nice things about us.\n
\n \n )\n}\n"
},
{
"path": "docs_src/src/components/documentation/ApiDocs.jsx",
"content": "import { Button } from '@/components/documentation/Button'\nimport { Heading } from '@/components/documentation/Heading'\n\nconst guides = [\n {\n href: '/documentation/en/api_reference',\n name: 'Installation',\n description: 'Start using Robyn in your project.',\n },\n {\n href: '/documentation/en/api_reference/getting_started',\n name: 'Getting Started',\n description: 'Start with creating basic routes in Robyn.',\n },\n {\n href: '/documentation/en/api_reference/request_object',\n name: 'The Request Object',\n description: 'Learn about the Request Object in Robyn.',\n },\n {\n href: '/documentation/en/api_reference/robyn_env',\n name: 'The Robyn Env file',\n description: 'Learn about the Robyn variables',\n },\n {\n href: '/documentation/en/api_reference/middlewares',\n name: 'Middlewares, Events and Websockets',\n description: 'Learn about Middlewares, Events and Websockets in Robyn.',\n },\n {\n href: '/documentation/en/api_reference/authentication',\n name: 'Authentication',\n description: 'Learn about Authentication in Robyn.',\n },\n {\n href: '/documentation/en/api_reference/const_requests',\n name: 'Const Requests and Multi Core Scaling',\n description: 'Learn about Const Requests and Multi Core Scaling in Robyn.',\n },\n {\n href: '/documentation/en/api_reference/cors',\n name: 'CORS',\n description: 'CORS',\n },\n {\n href: '/documentation/en/api_reference/templating',\n name: 'Templating',\n description: 'Learn about Templating in Robyn.',\n },\n {\n href: '/documentation/en/api_reference/redirection',\n name: 'Redirection',\n description: 'Learn how to redirect requests to different endpoints.',\n },\n {\n href: '/documentation/en/api_reference/file-uploads',\n name: 'File Uploads',\n description:\n 'Learn how to upload and download files to your server using Robyn.',\n },\n {\n href: '/documentation/en/api_reference/form_data',\n name: 'Form Data and Multi Part Form Data',\n description: 'Learn how to handle form data.',\n },\n {\n href: '/documentation/en/api_reference/websockets',\n name: 'Websockets',\n description: 'Learn how to use Websockets in Robyn.',\n },\n {\n href: '/documentation/en/api_reference/server_sent_events',\n name: 'Server-Sent Events',\n description: 'Learn how to implement Server-Sent Events for real-time communication.',\n },\n {\n href: '/documentation/en/api_reference/exceptions',\n name: 'Exceptions',\n description: 'Learn how to handle exceptions in Robyn.',\n },\n {\n href: '/documentation/en/api_reference/scaling',\n name: 'Scaling the Application',\n description: 'Learn how to scaled Robyn across multiple cores.',\n },\n {\n href: '/documentation/en/api_reference/advanced_features',\n name: 'Advanced Features',\n description: 'Learn about advanced features in Robyn.',\n },\n {\n href: '/documentation/en/api_reference/multiprocess_execution',\n name: 'Multiprocess Execution',\n description: 'Learn about the behaviour or variables during multithreading',\n },\n {\n href: '/documentation/en/api_reference/using_rust_directly',\n name: 'Direct Rust Usage',\n description: 'Learn about directly using Rust in Robyn.',\n },\n {\n href: '/documentation/en/api_reference/graphql-support',\n name: 'GraphQL Support',\n description: 'Learn about GraphQL Support in Robyn.',\n },\n {\n href: '/documentation/en/api_reference/openapi',\n name: 'OpenAPI Documentation',\n description: 'Learn how to generate OpenAPI docs for your applications.',\n },\n {\n href: '/documentation/en/api_reference/dependency_injection',\n name: 'Dependency Injection',\n description: 'Learn about Dependency Injection in Robyn.',\n },\n]\n\nexport function ApiDocs() {\n return (\n
\n \n
Api Docs
\n \n
\n {guides.map((guide) => (\n
\n
{guide.name}
\n
{guide.description}
\n
\n \n
\n
\n ))}\n
\n
\n )\n}\n"
},
{
"path": "docs_src/src/components/documentation/BottomNavbar.jsx",
"content": "import { forwardRef } from 'react'\nimport Link from 'next/link'\nimport clsx from 'clsx'\nimport { motion, useScroll, useTransform } from 'framer-motion'\n\nimport { MobileNavigation } from '@/components/documentation/MobileNavigation'\nimport { useMobileNavigationStore } from '@/components/documentation/MobileNavigation'\nimport { MobileSearch, Search } from '@/components/documentation/Search'\n\nexport const BottomNavbar = forwardRef(function Header({ className }, ref) {\n let { scrollY } = useScroll()\n let bgOpacityLight = useTransform(scrollY, [0, 72], [0.5, 0.9])\n let bgOpacityDark = useTransform(scrollY, [0, 72], [0.2, 0.8])\n\n return (\n <>\n \n
\n \n )\n}\n"
},
{
"path": "docs_src/src/components/documentation/Libraries.jsx",
"content": "import Image from 'next/image'\n\nimport { Button } from '@/components/documentation/Button'\nimport { Heading } from '@/components/documentation/Heading'\n\nconst libraries = [\n {\n href: '#',\n name: 'PHP',\n description:\n 'A popular general-purpose scripting language that is especially suited to web development.',\n },\n {\n href: '#',\n name: 'Ruby',\n description:\n 'A dynamic, open source programming language with a focus on simplicity and productivity.',\n },\n {\n href: '#',\n name: 'Node.js',\n description:\n 'Node.js® is an open-source, cross-platform JavaScript runtime environment.',\n },\n {\n href: '#',\n name: 'Python',\n description:\n 'Python is a programming language that lets you work quickly and integrate systems more effectively.',\n },\n {\n href: '#',\n name: 'Go',\n description:\n 'An open-source programming language supported by Google with built-in concurrency.',\n },\n]\n\nexport function Libraries() {\n return (\n
\n \n Official libraries\n \n
\n {libraries.map((library) => (\n
\n
\n
\n {library.name}\n
\n
\n {library.description}\n
\n
\n \n
\n
\n \n
\n ))}\n
\n
\n )\n}\n"
},
{
"path": "docs_src/src/components/documentation/MobileNavigation.jsx",
"content": "import { createContext, Fragment, useContext } from 'react'\nimport { Dialog, Transition } from '@headlessui/react'\nimport { motion } from 'framer-motion'\nimport { create } from 'zustand'\n\nimport { BottomNavbar } from '@/components/documentation/BottomNavbar'\nimport { Navigation } from '@/components/documentation/Navigation'\n\nfunction MenuIcon(props) {\n return (\n \n \n \n \n \n )\n}\n\nfunction XIcon(props) {\n return (\n \n \n \n )\n}\n\nconst IsInsideMobileNavigationContext = createContext(false)\n\nexport function useIsInsideMobileNavigation() {\n return useContext(IsInsideMobileNavigationContext)\n}\n\nexport const useMobileNavigationStore = create((set) => ({\n isOpen: false,\n open: () => set({ isOpen: true }),\n close: () => set({ isOpen: false }),\n toggle: () => set((state) => ({ isOpen: !state.isOpen })),\n}))\n\nexport function MobileNavigation() {\n let isInsideMobileNavigation = useIsInsideMobileNavigation()\n let { isOpen, toggle, close } = useMobileNavigationStore()\n let ToggleIcon = isOpen ? XIcon : MenuIcon\n\n return (\n \n \n \n \n {!isInsideMobileNavigation && (\n \n \n \n )}\n \n )\n}\n"
},
{
"path": "docs_src/src/components/documentation/ModeToggle.jsx",
"content": "function SunIcon(props) {\n return (\n \n )\n}\n\nfunction MoonIcon(props) {\n return (\n \n )\n}\n"
},
{
"path": "docs_src/src/components/documentation/Navigation.jsx",
"content": "import { useRef } from 'react'\nimport Link from 'next/link'\nimport { useRouter } from 'next/router'\nimport clsx from 'clsx'\nimport { AnimatePresence, motion, useIsPresent } from 'framer-motion'\n\nimport { useIsInsideMobileNavigation } from '@/components/documentation/MobileNavigation'\nimport { useSectionStore } from '@/components/documentation/SectionProvider'\nimport { Tag } from '@/components/documentation/Tag'\nimport LanguageSelector from '@/components/documentation/LanguageSelector'\nimport { remToPx } from '@/lib/remToPx'\n\nfunction useInitialValue(value, condition = true) {\n let initialValue = useRef(value).current\n return condition ? initialValue : value\n}\n\nfunction TopLevelNavItem({ href, children }) {\n return (\n
\n \n {children}\n \n
\n )\n}\n\nfunction NavLink({ href, tag, active, isAnchorLink = false, children }) {\n return (\n \n {children}\n {tag && (\n \n {tag}\n \n )}\n \n )\n}\n\nfunction VisibleSectionHighlight({ group, pathname }) {\n let [sections, visibleSections] = useInitialValue(\n [\n useSectionStore((s) => s.sections),\n useSectionStore((s) => s.visibleSections),\n ],\n useIsInsideMobileNavigation()\n )\n\n let isPresent = useIsPresent()\n let firstVisibleSectionIndex = Math.max(\n 0,\n [{ id: '_top' }, ...sections].findIndex(\n (section) => section.id === visibleSections[0]\n )\n )\n let itemHeight = remToPx(2)\n let height = isPresent\n ? Math.max(1, visibleSections.length) * itemHeight\n : itemHeight\n let top =\n group.links.findIndex((link) => link.href === pathname) * itemHeight +\n firstVisibleSectionIndex * itemHeight\n\n return (\n \n )\n}\n\nfunction ActivePageMarker({ group, pathname }) {\n let itemHeight = remToPx(2)\n let offset = remToPx(0.25)\n let activePageIndex = group.links.findIndex((link) => link.href === pathname)\n let top = offset + activePageIndex * itemHeight\n\n return (\n \n )\n}\n\nfunction NavigationGroup({ group, className }) {\n // If this is the mobile navigation then we always render the initial\n // state, so that the state does not change during the close animation.\n // The state will still update when we re-open (re-render) the navigation.\n let isInsideMobileNavigation = useIsInsideMobileNavigation()\n let [router, sections] = useInitialValue(\n [useRouter(), useSectionStore((s) => s.sections)],\n isInsideMobileNavigation\n )\n\n let isActiveGroup =\n group.links.findIndex((link) => link.href === router.pathname) !== -1\n\n return (\n
\n \n {\n if (\n event.key === 'Escape' &&\n !autocompleteState.isOpen &&\n autocompleteState.query === ''\n ) {\n // In Safari, closing the dialog with the escape key can sometimes cause the scroll position to jump to the\n // bottom of the page. This is a workaround for that until we can figure out a proper fix in Headless UI.\n document.activeElement?.blur()\n\n onClose()\n } else {\n inputProps.onKeyDown(event)\n }\n }}\n />\n {autocompleteState.status === 'stalled' && (\n
\n )\n}\n"
},
{
"path": "docs_src/src/components/releases/Button.jsx",
"content": "import Link from 'next/link'\nimport clsx from 'clsx'\n\nfunction ButtonInner({ arrow = false, children }) {\n return (\n <>\n \n \n {children} {arrow ? → : null}\n \n )\n}\n\nexport function Button({ href, className, arrow, children, ...props }) {\n className = clsx(\n className,\n 'group relative isolate flex-none rounded-md py-1.5 text-[0.8125rem]/6 font-semibold text-white',\n arrow ? 'pl-2.5 pr-[calc(9/16*1rem)]' : 'px-2.5'\n )\n\n return href ? (\n \n {children}\n \n ) : (\n \n )\n}\n"
},
{
"path": "docs_src/src/components/releases/FeedProvider.jsx",
"content": "import { createContext, useContext } from 'react'\n\nlet FeedContext = createContext({ isFeed: false })\n\nexport function FeedProvider({ children }) {\n return (\n \n {children}\n \n )\n}\n\nexport function useFeed() {\n return useContext(FeedContext)\n}\n"
},
{
"path": "docs_src/src/components/releases/FormattedDate.jsx",
"content": "const dateFormatter = new Intl.DateTimeFormat('en-US', {\n year: 'numeric',\n month: 'short',\n day: 'numeric',\n timeZone: 'UTC',\n})\n\nexport function FormattedDate({ date, ...props }) {\n date = typeof date === 'string' ? new Date(date) : date\n\n return (\n \n )\n}\n"
},
{
"path": "docs_src/src/components/releases/IconLink.jsx",
"content": "import Link from 'next/link'\nimport clsx from 'clsx'\n\nexport function IconLink({\n children,\n className,\n compact = false,\n large = false,\n icon: Icon,\n ...props\n}) {\n return (\n \n \n \n {children}\n \n )\n}\n"
},
{
"path": "docs_src/src/components/releases/Intro.jsx",
"content": "import { IconLink } from '@/components/releases/IconLink'\nimport { SignUpForm } from '@/components/releases/SignUpForm'\nimport {\n InstagramIcon,\n LinkedInIcon,\n TwitterIcon,\n} from '@/components/SocialIcons'\n\nfunction BookIcon(props) {\n return (\n \n )\n}\n\nfunction GitHubIcon(props) {\n return (\n \n )\n}\n\nfunction FeedIcon(props) {\n return (\n \n )\n}\n\nexport function Intro() {\n return (\n <>\n
\n All the latest Robyn releases,\n right here.\n
\n
\n \n Twitter\n \n \n Release Page\n \n
\n \n )\n}\n"
},
{
"path": "docs_src/src/components/releases/Layout.jsx",
"content": "import { useId } from 'react'\n\nimport { Intro } from '@/components/releases/Intro'\n\nfunction Timeline() {\n let id = useId()\n\n return (\n
\n \n \n \n \n \n \n \n \n
\n )\n}\n\nfunction FixedSidebar({ main }) {\n return (\n
\n
\n
\n
\n
{main}
\n
\n
\n
\n
\n )\n}\n\nexport function Layout({ children }) {\n return (\n <>\n } />\n \n \n \n\n
\n \n \n {children}\n \n
\n \n )\n}\n"
},
{
"path": "docs_src/src/components/releases/SignUpForm.jsx",
"content": "import { useId } from 'react'\n\nimport { Button } from '@/components/Button'\n\nexport function SignUpForm() {\n let id = useId()\n\n return (\n \n )\n}\n"
},
{
"path": "docs_src/src/components/releases/mdx.jsx",
"content": "import { useEffect, useRef, useState } from 'react'\nimport Image from 'next/image'\nimport Link from 'next/link'\nimport clsx from 'clsx'\n\nimport { useFeed } from '@/components/releases/FeedProvider'\nimport { FormattedDate } from '@/components/releases/FormattedDate'\n\nexport const a = Link\n\nexport const wrapper = function Wrapper({ children }) {\n return children\n}\n\nexport function H2(props) {\n let { isFeed } = useFeed()\n\n if (isFeed) {\n return null\n }\n\n return (\n \n )\n}\n\nexport const p = function Paragraph({ children }) {\n return
{children}
\n}\n\nexport const img = function Img(props) {\n return (\n
\n \n \n
\n )\n}\n\nfunction ContentWrapper({ className, children }) {\n return (\n
\n Robyn is a community project and is housed under the sparckles\n organisation.\n
\n
\n
\n\n {/* Content section */}\n\n
\n
\n
\n
\n
\n Our Amazing Contributors\n
\n \n
\n
\n
\n
\n\n {/* Values section */}\n
\n
\n
\n Join us on our journey\n
\n
\n Join us on our journey to spark new ideas, ignite the spirit of\n open-source development, and break down the walls that limit\n innovation and progress. Together, we can create a brighter future\n for the Python ecosystem and the global software community.\n
\n\n
\n \n Join our community! →\n \n
\n
\n
\n\n {/* Team section */}\n
\n
\n
\n Our team\n
\n
\n Robyn is housed under an open source organisation called\n Sparckles. We are a group of developers passionate about the open\n source community. Come join us and help us empower the Python web\n ecosystem.\n
\n
\n
\n\n {/* CTA section */}\n
\n
\n
\n \n
\n
\n Sparckles\n
\n
\n Sparckles is an innovative open-source organization dedicated\n to enhancing the Python ecosystem by developing cutting-edge\n tools, fostering a vibrant community, and providing robust\n infrastructure solutions.\n
\n
\n \n Visit our homepage →\n \n
\n
\n
\n
\n \n \n
\n \n\n {/* sponsors */}\n
\n
\n
\n
\n
\n Sponsors\n
\n
\n Thanks to our sponsors for supporting us!\n
\n
\n
\n
\n \n
\n \n
\n \n
\n
\n \n \n
\n \n
\n \n
\n
\n
\n {/* Community Contributors */}\n
\n \n
\n \n
\n \n
\n
\n
\n
\n
\n \n \n )\n}\n"
},
{
"path": "docs_src/src/pages/documentation/en/api_reference/advanced_features.mdx",
"content": "export const description =\n 'On this page, we’ll dive into the different conversation endpoints you can use to manage conversations programmatically.'\n\n## Keep a track of client's IP address\n\nNow that the portal was up and ready, Batman realised that the Joker was using the Gotham Police Dashboard too. So, he wanted to keep a track of the IP address of the client who was accessing his application. He used the following code to do so:\n\n\n\n
\nBatman scaled his application across multiple cores for better performance. He used the following command:\n\n
\n\n \n\n ```python\n from robyn import Robyn, Request\n\n app = Robyn(__file__)\n\n @app.get(\"/\")\n async def h(request: Request):\n return f\"hello to you, {request.ip_addr}\"\n\n ```\n\n \n \n\n---\n\n\n## What's next?\n\n\nBatman wondered about how to help users explore the endpoints in his application.\n\nRobyn showed him the OpenAPI Documentation!\n\n[OpenAPI Documentation](/documentation/en/api_reference/openapi)\n\n\n\n\n"
},
{
"path": "docs_src/src/pages/documentation/en/api_reference/advanced_routing.mdx",
"content": "export const description =\n 'Master Robyn\\'s advanced routing features including parameter injection, route optimization, and complex URL patterns.'\n\n# Advanced Routing and Parameter Injection\n\nRobyn's routing system goes far beyond simple URL matching. It includes sophisticated parameter injection, route optimization, and flexible pattern matching that makes building complex APIs effortless.\n\n## Understanding Parameter Injection\n\nRobyn automatically analyzes your function signatures and injects the appropriate request components. This eliminates boilerplate code and makes handlers cleaner.\n\n### The Injection Engine\n\nThe parameter injection system works in two phases:\n\n1. **Function Introspection**: Robyn analyzes your function signature at registration time\n2. **Runtime Injection**: For each request, Robyn provides the exact parameters your function needs\n\n\n
\n **Type-Based Injection**: Uses type annotations to determine what to inject\n \n
\n While Robyn doesn't have built-in parameter validation, you can implement it in your handlers for type safety.\n \n
\n \n ```python\n import re\n from robyn import HTTPException\n \n @app.get(\"/users/:user_id\")\n def get_user(path_params):\n user_id = path_params[\"user_id\"]\n \n # Validate that user_id is numeric\n if not user_id.isdigit():\n raise HTTPException(400, \"user_id must be numeric\")\n \n user_id = int(user_id)\n if user_id <= 0:\n raise HTTPException(400, \"user_id must be positive\")\n \n return {\"user_id\": user_id}\n \n @app.get(\"/posts/:slug\")\n def get_post_by_slug(path_params):\n slug = path_params[\"slug\"]\n \n # Validate slug format\n if not re.match(r'^[a-z0-9-]+$', slug):\n raise HTTPException(400, \"Invalid slug format\")\n \n return {\"slug\": slug}\n ```\n \n \n\n\n## Route Optimization\n\n### Const Routes for Static Responses\n\n\n
\n Use `const=True` for responses that never change. These are cached in Rust memory and the handler function is never re-executed after startup.\n\n When no middleware is registered, const routes take a fast path served entirely from the Rust layer without entering Python at all. When middleware is registered (including global before-request and after-request handlers), const routes still serve the cached response but middleware executes normally for every request. This means const routes are always safe to use alongside middleware.\n \n
\n Add timing middleware to monitor route performance.\n \n
\n \n ```python\n import time\n from robyn import Robyn\n \n app = Robyn(__file__)\n \n @app.before_request\n def timing_middleware(request):\n request.start_time = time.time()\n return request\n \n @app.after_request\n def timing_after_middleware(request, response):\n duration = time.time() - request.start_time\n print(f\"{request.method} {request.url.path} - {duration:.3f}s\")\n response.headers[\"X-Response-Time\"] = f\"{duration:.3f}s\"\n return response\n \n @app.get(\"/slow\")\n def slow_endpoint():\n time.sleep(0.1) # Simulate work\n return {\"message\": \"slow response\"}\n ```\n \n \n\n\n## Best Practices\n\n### 1. Parameter Injection Patterns\n\n- **Use type annotations** for better IDE support and self-documenting code\n- **Inject only what you need** to keep handlers focused\n- **Validate parameters early** to provide clear error messages\n\n### 2. Route Organization\n\n- **Group related routes** using SubRouters\n- **Order routes from specific to general** to avoid matching issues\n- **Use consistent naming conventions** for path parameters\n\n### 3. Performance Optimization\n\n- **Use const routes** for static responses\n- **Minimize parameter injection** in high-traffic endpoints\n- **Cache expensive computations** rather than repeating them\n\n### 4. Error Handling\n\n- **Validate path parameters** early in handlers\n- **Provide meaningful error messages** for invalid input\n- **Use consistent error response formats** across your API\n\n## What's Next?\n\nNow that you've mastered advanced routing, explore other Robyn features:\n\n- [Middleware Development Guide](/documentation/en/api_reference/middlewares_advanced)\n- [Performance Optimization](/documentation/en/api_reference/performance_optimization)\n- [WebSocket Advanced Features](/documentation/en/api_reference/websockets_advanced)"
},
{
"path": "docs_src/src/pages/documentation/en/api_reference/agents.mdx",
"content": "export const description =\n 'Robyn AI Agents provide intelligent functionality for building AI-powered applications using MCP (Model Context Protocol) implementation with file system access, task management, and context-aware capabilities.'\n\n# Agents\n\nThis guide demonstrates how to build AI-powered agents using Robyn's MCP (Model Context Protocol) implementation.\n\n## Overview\n\nThe agent system connects AI assistants like Claude Desktop to your development environment, providing seamless access to:\n\n- File system operations (read, search, organize)\n- Task and note management\n- System monitoring and git integration\n- Web content fetching and analysis\n- Context-aware code analysis\n\n## Quick Start\n\n1. Run the MCP server:\n ```bash\n python examples/agents.py\n ```\n\n2. Connect your AI assistant to `http://localhost:8080/mcp`\n\n3. Start using natural language commands:\n - \"What files are in my projects directory?\"\n - \"Show me my recent git commits\"\n - \"Create a note about today's standup meeting\"\n - \"What processes are using the most CPU?\"\n - \"Add a task to review the quarterly report\"\n\n## Configuration\n\nThe assistant creates the following structure:\n\n```\n~/Documents/\n├── notes/ # Markdown notes\n└── tasks.json # Task list\n\n~/projects/ # Development projects\n├── project1/\n└── project2/\n```\n\n## Security\n\n- File access restricted to home directory\n- Safe mathematical expression evaluation\n- Path validation for all file operations\n- Read-only git operations\n\n## Available Resources\n\n### File System\n- `fs://{path}` - Read files in home directory\n- `fs://dir/{path}` - List directory contents\n\n### Git Integration\n- `git://repo/{repo_name}` - Repository status and commits\n\n### System Monitoring\n- `system://processes` - Running processes\n- `system://stats` - System statistics\n\n## Available Tools\n\n- `create_note(title, content, tags)` - Create markdown notes\n- `add_task(task, priority, due_date)` - Add tasks\n- `complete_task(task_id)` - Mark tasks complete\n- `search_files(query, directory)` - Search file contents\n- `fetch_url_content(url, max_length)` - Download web content\n\n## Available Prompts\n\n- `analyze_file_structure(directory)` - Generate project analysis\n- `code_review_request(file_path, focus_area)` - Create code reviews\n- `task_prioritization(context)` - Organize and prioritize work\n\n## Dependencies\n\nOptional enhanced functionality:\n\n```bash\npip install psutil # Enhanced system monitoring\n```\n\n## Implementation Examples\n\n### Development Workflow\n\"Analyze my projects directory and help prioritize work based on recent activity\"\n\n### Project Analysis\n\"Review my web-app project structure and suggest improvements\"\n\n### Meeting Notes\n\"Create a note about today's architecture review with key decisions\"\n\n### Code Search\n\"Find all files mentioning 'authentication' and summarize approaches\"\n\n### Task Management\n\"Add high-priority task to refactor user service, due Friday\"\n\n## Integration Benefits\n\nConnecting AI assistants to your development environment enables:\n- Native file system browsing\n- Context-aware project conversations\n- Personalized code suggestions\n- Real-time task management\n- Workspace-specific code reviews\n\n## Advanced Features\n\nThe MCP implementation includes:\n- URI templates with parameter extraction\n- Auto-generated schemas from type hints\n- Async/sync operation handlers\n- MCP-compliant error handling\n- Type-safe parameter passing\n\nExtend easily with custom resources, tools, and prompts for your specific workflow."
},
{
"path": "docs_src/src/pages/documentation/en/api_reference/ai.mdx",
"content": "export const description =\n 'Robyn AI provides agent and memory functionality for building intelligent applications with conversation history, context awareness, and pluggable AI runners.'\n\n# AI Agent and Memory\n\nRobyn includes built-in AI capabilities that allow you to create intelligent applications with conversation memory, context awareness, and pluggable agent runners. The AI module provides abstractions for memory storage and agent execution that can be easily integrated into your Robyn applications.\n\n## Installation\n\nThe AI features are included with the base Robyn installation:\n\n```bash\npip install robyn\n```\n\n\n## Quick Start\n\nHere's a simple example of using Robyn's AI features:\n\n```python\nfrom robyn import Robyn\nfrom robyn.ai import agent, memory\n\napp = Robyn(__file__)\n\n# Create memory instance\nmem = memory(provider=\"inmemory\", user_id=\"user123\")\n\n# Create agent with memory\nchat_agent = agent(runner=\"simple\", memory=mem)\n\n@app.get(\"/chat\")\nasync def chat_endpoint(request):\n query = request.query_params.get(\"q\", [\"\"])[0]\n if not query:\n return {\"error\": \"Query required\"}\n \n # Run agent with conversation history\n result = await chat_agent.run(query, history=True)\n return result\n```\n\n## Memory System\n\nThe memory system provides persistent storage for conversation history and context. It supports multiple providers and offers a consistent interface for storing and retrieving conversation data.\n\n### Memory Providers\n\n#### InMemory Provider\n\nThe simplest provider that stores data in memory. Data is lost when the application restarts.\n\n```python\nfrom robyn.ai import memory\n\n# Create in-memory storage\nmem = memory(provider=\"inmemory\", user_id=\"user123\")\n\n# Add messages\nawait mem.add(\"Hello, how are you?\")\nawait mem.add(\"I'm doing great, thanks!\")\n\n# Retrieve all messages\nmessages = await mem.get()\n\n# Clear memory\nawait mem.clear()\n```\n\n\n### Memory API\n\nThe Memory class provides these key methods:\n\n- `add(message, metadata=None)` - Store a message with optional metadata\n- `get(query=None)` - Retrieve messages, optionally filtered by query\n- `clear()` - Clear all stored messages for the user\n\n## Agent System\n\nAgents provide the execution layer for AI functionality. They can use different runners and integrate with memory for context-aware responses.\n\n### Agent Runners\n\n#### Simple Runner\n\nA runner with OpenAI integration that provides intelligent responses:\n\n```python\nfrom robyn.ai import agent\n\n# Create simple agent with OpenAI\nfrom robyn.ai import configure\n\nconfig = configure(openai_api_key=\"your-openai-key\")\nsimple_agent = agent(runner=\"simple\", config=config)\n\n# Use the agent\nresult = await simple_agent.run(\"What's the weather like?\")\n# Returns structured response with AI-generated content\n```\n\n\n### Agent API\n\nThe Agent class provides:\n\n- `run(query, history=False, **kwargs)` - Execute the agent with optional history context\n- Automatic memory integration when provided\n- Support for custom runners and configuration\n\n## Complete Example\n\nHere's a comprehensive example showing all features:\n\n```python\nfrom robyn import Robyn\nfrom robyn.ai import agent, memory\n\napp = Robyn(__file__)\n\n# Create memory with InMemory provider\nmem = memory(\n provider=\"inmemory\",\n user_id=\"guest\"\n)\n\n# Create agent with memory\nchat_agent = agent(runner=\"simple\", memory=mem)\n\n@app.get(\"/\")\nasync def home():\n return {\"message\": \"Robyn AI Chat API\"}\n\n@app.post(\"/chat\") \nasync def chat(request):\n \"\"\"Chat with AI agent\"\"\"\n data = request.json()\n query = data.get(\"query\", \"\")\n include_history = data.get(\"history\", True)\n \n if not query:\n return {\"error\": \"Query is required\"}\n \n try:\n result = await chat_agent.run(query, history=include_history)\n return {\n \"query\": query,\n \"response\": result.get(\"response\"),\n \"history_included\": include_history\n }\n except Exception as e:\n return {\"error\": str(e)}\n\n@app.get(\"/memory\")\nasync def get_memory():\n \"\"\"Retrieve conversation history\"\"\"\n try:\n memories = await mem.get()\n return {\"memories\": memories, \"count\": len(memories)}\n except Exception as e:\n return {\"error\": str(e)}\n\n@app.delete(\"/memory\")\nasync def clear_memory():\n \"\"\"Clear conversation history\"\"\"\n try:\n await mem.clear()\n return {\"message\": \"Memory cleared\"}\n except Exception as e:\n return {\"error\": str(e)}\n\n@app.post(\"/memory\")\nasync def add_memory(request):\n \"\"\"Add message to memory\"\"\"\n data = request.json()\n message = data.get(\"message\", \"\")\n metadata = data.get(\"metadata\", {})\n \n if not message:\n return {\"error\": \"Message is required\"}\n \n try:\n await mem.add(message, metadata)\n return {\"message\": \"Added to memory\"}\n except Exception as e:\n return {\"error\": str(e)}\n\nif __name__ == \"__main__\":\n app.start(host=\"127.0.0.1\", port=8080)\n```\n\n## Advanced Usage\n\n### Custom Memory Providers\n\nYou can create custom memory providers by extending the `MemoryProvider` abstract base class:\n\n```python\nfrom robyn.ai import MemoryProvider\nfrom typing import Dict, List, Any, Optional\n\nclass CustomMemoryProvider(MemoryProvider):\n async def store(self, user_id: str, data: Dict[str, Any]) -> None:\n # Implement custom storage logic\n pass\n \n async def retrieve(self, user_id: str, query: Optional[str] = None) -> List[Dict[str, Any]]:\n # Implement custom retrieval logic\n return []\n \n async def clear(self, user_id: str) -> None:\n # Implement custom clearing logic\n pass\n\n# Use custom provider\nfrom robyn.ai import Memory\ncustom_mem = Memory(provider=CustomMemoryProvider(), user_id=\"user123\")\n```\n\n### Custom Agent Runners\n\nSimilarly, you can create custom agent runners:\n\n```python\nfrom robyn.ai import AgentRunner\nfrom typing import Dict, Any\n\nclass CustomAgentRunner(AgentRunner):\n async def run(self, query: str, **kwargs) -> Dict[str, Any]:\n # Implement custom agent logic\n return {\n \"response\": f\"Custom response to: {query}\",\n \"processed\": True\n }\n\n# Use custom runner\nfrom robyn.ai import Agent\ncustom_agent = Agent(runner=CustomAgentRunner())\n```\n\n## Best Practices\n\n1. **User Isolation**: Always use unique user IDs to isolate memory between different users\n2. **Error Handling**: Wrap AI operations in try-catch blocks as external services may fail\n3. **Memory Management**: Regularly clear or archive old memories to prevent unbounded growth\n4. **Configuration**: Store sensitive configuration (API keys, etc.) in environment variables\n5. **Testing**: Use the simple runner for development and testing before deploying complex agents\n\n## Troubleshooting\n\n### Common Issues\n\n**ImportError for openai**: Install the required package:\n```bash\npip install openai\n```\n\n**Memory not persisting**: Note that the in-memory provider loses data when the application restarts. Consider implementing a custom persistent provider for production use.\n\n**Agent timeouts**: Complex operations may take time. Consider implementing timeout handling in your endpoints.\n\n**Memory growing too large**: Implement periodic cleanup or use providers with built-in retention policies."
},
{
"path": "docs_src/src/pages/documentation/en/api_reference/architecture_deep_dive.mdx",
"content": "export const description =\n 'Deep dive into Robyn\\'s unique hybrid Python-Rust architecture and how it delivers exceptional performance while maintaining Python\\'s ease of use.'\n\n# Architecture Deep Dive\n\nRobyn's architecture is unique in the Python web framework landscape. It combines Python's expressiveness with Rust's performance through a carefully designed hybrid system. This deep dive explains how Robyn works under the hood and why it's so fast.\n\n## The Hybrid Python-Rust Design\n\n### Two-Layer Architecture\n\nRobyn operates on two distinct but interconnected layers:\n\n1. **Python Layer**: Provides the developer-facing API, routing configuration, and business logic\n2. **Rust Layer**: Handles HTTP parsing, request routing, response generation, and I/O operations\n\n\n
\n The Python layer is where you write your application code. It handles:\n - Route definitions and decorators\n - Request parameter injection\n - Middleware configuration\n - Business logic execution\n - Response formatting\n \n
\n \n ```python\n from robyn import Robyn, Request\n \n app = Robyn(__file__)\n \n @app.get(\"/users/:id\")\n async def get_user(request: Request, user_id: str):\n # Business logic runs in Python\n user = await fetch_user_from_db(user_id)\n return {\"user\": user.to_dict()}\n ```\n \n \n\n\n\n
\n The Rust layer handles all performance-critical operations:\n - HTTP request parsing\n - URL routing and matching\n - WebSocket connections\n - Static file serving\n - Response serialization\n \n
\n \n ```rust\n // This happens internally in Robyn's Rust core\n impl HttpRouter {\n pub fn route_request(&self, method: &str, path: &str) -> Option {\n // High-performance routing using matchit crate\n self.router.at(path).ok().map(|matched| {\n RouteInfo {\n handler: matched.value.clone(),\n params: matched.params.clone(),\n }\n })\n }\n }\n ```\n \n \n\n\n### PyO3 Bridge: Connecting Python and Rust\n\nThe magic happens through PyO3, which enables seamless communication between Python and Rust:\n\n\n
\n **Function Registration**: When you define a route handler in Python, Robyn registers it with the Rust runtime through PyO3 bindings.\n \n
\n \n ```python\n # Python side - route registration\n @app.get(\"/api/data\")\n def handler(request):\n return {\"data\": \"example\"}\n \n # Internally, this creates a FunctionInfo object\n # that's passed to the Rust runtime\n ```\n \n \n\n\n\n
\n **Request Execution Flow**: When a request arrives, the Rust layer routes it and then calls back into Python to execute your handler.\n \n
\n When you mark a route as `const`, Robyn caches the response in Rust memory and never re-executes the Python handler. If no middleware is registered, const routes are served entirely from the Rust layer without entering Python at all. When middleware is present, the cached response is still used but before-request and after-request middleware execute normally.\n \n
\n \n ```python\n # This response is cached in Rust memory\n @app.get(\"/health\", const=True)\n def health_check():\n return {\"status\": \"healthy\"}\n \n # Without middleware: served directly from Rust, bypassing Python entirely\n # With middleware: cached response is used, but middleware still runs\n ```\n \n \n\n\n### Zero-Copy Request Handling\n\nThe Rust layer uses zero-copy techniques wherever possible:\n\n- Request bodies are parsed once and shared between layers\n- String data is referenced rather than copied\n- Response buffers are reused across requests\n\n### Async Runtime Integration\n\nRobyn integrates with Python's asyncio while maintaining Rust's async runtime:\n\n\n
\n **Sync Handlers**: Executed in a thread pool to avoid blocking the async runtime\n \n
\n **Async Handlers**: Executed directly in the async runtime for maximum performance\n \n
\n \n ```python\n @app.get(\"/async\")\n async def async_handler(request):\n # Runs in main async runtime\n await asyncio.sleep(1)\n return \"Done\"\n ```\n \n \n\n\n## Advanced Parameter Injection\n\nOne of Robyn's most sophisticated features is its parameter injection system:\n\n### Type-Based Injection\n\n\n
\n Robyn analyzes your function signatures and automatically injects the appropriate request components based on type annotations.\n \n
\n You can also use reserved parameter names without type annotations.\n \n
\n \n ```python\n @app.get(\"/simple/:id\")\n def simple_handler(query_params, path_params, headers):\n # Parameters injected based on names\n return {\n \"id\": path_params[\"id\"],\n \"search\": query_params.get(\"q\", \"\"),\n \"auth\": headers.get(\"authorization\")\n }\n ```\n \n \n\n\n## Memory Management\n\n### Python Object Lifecycle\n\nRobyn carefully manages Python objects across the Python-Rust boundary:\n\n1. **Request Objects**: Created once per request and reused\n2. **Response Objects**: Efficiently serialized and passed to Rust\n3. **Handler References**: Stored in Rust and called via PyO3\n\n### Rust Memory Safety\n\nThe Rust layer benefits from Rust's ownership system:\n\n- No memory leaks from HTTP parsing\n- Safe concurrent access to shared data\n- Automatic cleanup of connection resources\n\n## Scaling Architecture\n\n### Multi-Process Mode\n\n\n
\n Robyn can spawn multiple processes to utilize all CPU cores.\n \n
\n \n ```bash\n # Spawn 4 worker processes\n python app.py --processes 4 --workers 2\n \n # Each process runs independently with shared-nothing architecture\n ```\n \n \n\n\n### Multi-Worker Mode\n\n\n
\n Within each process, multiple worker threads handle requests concurrently.\n \n
\n \n ```python\n # Workers share the same Python interpreter\n # but handle requests concurrently\n app.start(port=8080, workers=4)\n ```\n \n \n\n\n## WebSocket Architecture\n\n### Persistent Connections\n\nRobyn's WebSocket implementation maintains persistent connections in the Rust layer while allowing Python handlers to process messages:\n\n\n
\n **Connection Management**: Handled entirely in Rust for efficiency\n \n **Message Processing**: Python handlers process individual messages\n \n **Broadcasting**: Rust-based message distribution for high throughput\n \n
\n \n ```python\n from robyn import WebSocketDisconnect\n\n @app.websocket(\"/chat\")\n async def websocket_handler(websocket):\n try:\n while True:\n message = await websocket.receive_text()\n response = process_chat_message(message)\n await websocket.send_text(response)\n except WebSocketDisconnect:\n pass\n ```\n \n \n\n\n## Why This Architecture Works\n\n1. **Best of Both Worlds**: Python's productivity with Rust's performance\n2. **Gradual Optimization**: Hot paths can be moved to Rust incrementally \n3. **Memory Efficiency**: Minimal copying between layers\n4. **Async Integration**: Seamless integration with Python's async/await\n5. **Safety**: Rust's memory safety prevents common server vulnerabilities\n\nThis architecture allows Robyn to achieve performance comparable to pure Rust web frameworks while maintaining the ease of development that Python developers expect.\n\n## What's Next?\n\nNow that you understand Robyn's architecture, explore how to leverage its advanced features:\n\n- [Advanced Routing and Parameter Injection](/documentation/en/api_reference/advanced_routing)\n- [Performance Optimization Guide](/documentation/en/api_reference/performance_optimization)\n- [WebSocket Deep Dive](/documentation/en/api_reference/websockets_advanced)"
},
{
"path": "docs_src/src/pages/documentation/en/api_reference/authentication.mdx",
"content": "\nexport const description =\n 'On this page, we’ll dive into the different conversation endpoints you can use to manage conversations programmatically.'\n\nAfter Creating a basic version of the app, Batman wanted to restrict the access to the Gotham Police Department. So, he enquired about the Authentication functionalities in Robyn.\n\n\n## Authentication\n\n\nAs Batman found out, Robyn provides an easy way to add an authentication middleware to your application. You can then specify `auth_required=True` in your routes to make them accessible only to authenticated users.\n\n\n\n\n
\n\n
\n\n \n\n ```python\n @app.get(\"/auth\", auth_required=True)\n async def auth(request: Request):\n # This route method will only be executed if the user is authenticated\n # Otherwise, a 401 response will be returned\n return \"Hello, world\"\n\n ```\n \n \n\n\n\n
\n To add an authentication middleware, you can use the `configure_authentication` method. This method requires an `AuthenticationHandler` object as an argument. This object specifies how to authenticate a user, and uses a `TokenGetter` object to retrieve the token from the request. Robyn does currently provide a `BearerGetter` class that gets the token from the `Authorization` header, using the `Bearer` scheme. Here is an example of a basic authentication handler:\n\n\n \n
\n \n\n ```python\n class BasicAuthHandler(AuthenticationHandler):\n def authenticate(self, request: Request) -> Optional[Identity]:\n token = self.token_getter.get_token(request)\n if token == \"valid\":\n return Identity(claims={})\n return None\n\n app.configure_authentication(BasicAuthHandler(token_getter=BearerGetter()))\n\n ```\n \n \n\nThe authenticate method should return an `Identity` object if the user is authenticated, or `None` otherwise. The Identity object can contain any data you want, and will be accessible in the route methods using the `request.identity` attribute.\n\n\n Note: that this authentication system is basically only using a `before request` middleware under the hood. This means you can overlook it and create your own authentication system using middlewares if you want to. However, Robyn still provides this easy to implement solution that should suit most use cases.\n\n\n\n\n\n--- \n\n## What's next?\n\nNow, that Batman has learned about authentication, he wanted to know about certain optimization techniques that he could use to make his application faster. He found out about the following features\n\n- [Const Requests and Multi Core Scaling](/documentation/en/api_reference/const_requests)\n\n\n\n"
},
{
"path": "docs_src/src/pages/documentation/en/api_reference/const_requests.mdx",
"content": "\nexport const description =\n 'On this page, we’ll dive into the different conversation endpoints you can use to manage conversations programmatically.'\n\nAfter authentication, Batman was worried about the website traffic during the rush hours. He was worried about the server crashing when Joker would try to break all the criminals from the Arkham asylum one more time. So, Robyn told him about the `Const Requests` feature and the multi-core scaling potential.\n\n\n## Const Requests\n\n\nRobyn told Batman that you can pre-compute the response for each route. This will compute the response even before execution. This will improve the response time bypassing the need to access the router.\n\n\n\n
\n\n
\n\n \n\n ```python\n @app.get(\"/\", const=True)\n async def h():\n return \"Hello, world\"\n\n ```\n \n \n\n\n## Muli-core scaling\n\nRobyn told Batman that he can use the `--workers` flag to scale the application to multiple cores. This will create multiple instances of the application and will distribute the load among them. This will improve the performance of the application.\n\n\n\n\n
\n\n \n
\n \n\n ```python\n python3 app.py --workers=N --process=M\n ```\n \n \n\nThe authenticate method should return an `Identity` object if the user is authenticated, or `None` otherwise. The Identity object can contain any data you want, and will be accessible in the route methods using the `request.identity` attribute.\n\n\n Note: that this authentication system is basically only using a `before request` middleware under the hood. This means you can overlook it and create your own authentication system using middlewares if you want to. However, Robyn still provides this easy to implement solution that should suit most use cases.\n\n\n\n\n\n--- \n\n## What's next?\n\nAfter making the application faster, Batman was happy and wanted to make a request from his Frontend Dashboard.\n\nBut he was faced with CORS issues! He asked Robyn about how to solve this issue. Robyn told him about the following features\n\n- [CORS](/documentation/en/api_reference/cors)\n\n"
},
{
"path": "docs_src/src/pages/documentation/en/api_reference/cors.mdx",
"content": "export const description =\n 'On this page, we’ll dive into the different conversation endpoints you can use to manage conversations programmatically.'\n\n\n## CORS\n\nBatman was annoyed on getting a CORS error whenever he tried to access the API.\n\n\n## Scaling the Application\n\n\n
\nYou can allow CORS for your application by adding the following code:\n\n
\n\n \n\n ```python\n from robyn import Robyn, ALLOW_CORS\n\n app = Robyn(__file__)\n ALLOW_CORS(app, origins = [\"http://localhost:/\"])\n ```\n\n \n \n\n\n---\n\n\n## What's next?\n\nAfter fixing the CORS issues. Batman was satisfied but he wanted to learn about ways to have small frontend pages in the server itself.\n\nRobyn told him about templates and how he can use them to render HTML pages.\n\n- [Templating](/documentation/en/api_reference/templating)\n\n"
},
{
"path": "docs_src/src/pages/documentation/en/api_reference/dependency_injection.mdx",
"content": "export const description =\n 'On this page, we will learn about dependency injection in Robyn.'\n\n\n## Dependency Injection\n\nBatman wanted to learn about dependency injection in Robyn. Robyn introduced him to the concept of dependency injection and how it can be used in Robyn.\n\n\n\nRobyn has two types of dependency injection:\nOne is for the application level and the other is for the router level.\n\n### Application Level Dependency Injection\n\n\n
\nApplication level dependency injection is used to inject dependencies into the application. These dependencies are available to all the requests.\n\n
\nRouter level dependency injection is used to inject dependencies into the router. These dependencies are available to all the requests of that router.\n\n
\nNote: `router_dependencies`, `global_dependencies` are reserved parameters and **must** be named as such. The order of the parameters does not matter among them. However, the `router_dependencies` and `global_dependencies` must only come after the `request` parameter. \n\n\n\n### WebSocket Dependency Injection\n\n\n
\nWebSockets support the same dependency injection system as HTTP routes. The `global_dependencies` and `router_dependencies` parameters work in the main handler, `on_connect`, and `on_close` callbacks.\n\n
\n \n ```python {{ title: 'WebSocket DI' }}\n from robyn import Robyn\n import logging\n\n app = Robyn(__file__)\n\n app.inject_global(logger=logging.getLogger(__name__))\n app.inject(cache=RedisCache())\n\n @app.websocket(\"/chat\")\n async def chat(websocket, global_dependencies=None, router_dependencies=None):\n logger = global_dependencies.get(\"logger\")\n cache = router_dependencies.get(\"cache\")\n logger.info(f\"New connection: {websocket.id}\")\n\n while True:\n message = await websocket.receive_text()\n cache.set(f\"ws_{websocket.id}\", message)\n await websocket.broadcast(f\"User {websocket.id}: {message}\")\n\n @chat.on_connect\n async def on_connect(websocket, global_dependencies=None):\n logger = global_dependencies.get(\"logger\")\n logger.info(f\"Client connected: {websocket.id}\")\n return \"Connected\"\n ```\n \n \n\n\n---\n\n\n## What's next?\n\nBatman, being the familiar with the dark side wanted to know about Exceptions!\n\nRobyn introduced him to the concept of exceptions and how he can use them to handle errors in his application.\n\n- [Exceptions](/documentation/en/api_reference/exceptions)\n\n"
},
{
"path": "docs_src/src/pages/documentation/en/api_reference/exceptions.mdx",
"content": "## Custom Exception Handler\n\nBatman learned how to create custom error handlers for different exception types in his application. He wrote the following code to handle exceptions and return a custom error response:\n\n\n
\n\n
\n\n \n\n ```python\n @app.exception\n def handle_exception(error: Exception):\n return Response(status_code=500, description=f\"error msg: {error}\", headers={})\n ```\n \n \n\n\n---\n\n## What's next?\n\nNow, Batman wanted to scale his application across multiple cores. Robyn led him to Scaling.\n\n- [Scaling](/documentation/en/api_reference/scaling)\n\n"
},
{
"path": "docs_src/src/pages/documentation/en/api_reference/file-uploads.mdx",
"content": "export const description =\n 'On this page, we’ll dive into the different conversation endpoints you can use to manage conversations programmatically.'\n\n## File Uploads\n\nBatman learned how to handle file uploads using Robyn. He created an endpoint to handle file uploads using the following code:\n\n\n## Sending a File without MultiPart Form Data\n\n\n
\nBatman scaled his application across multiple cores for better performance. He used the following command:\n\n
\n\n \n\n ```python\n @app.post(\"/upload\")\n async def upload():\n body = request.body\n file = bytearray(body)\n\n # write whatever filename\n with open('test.txt', 'wb') as f:\n f.write(file)\n\n return {'message': 'success'}\n ```\n\n \n \n\n\n\n## Sending a File with MultiPart Form Data\n\n\n
\nBatman scaled his application across multiple cores for better performance. He used the following command:\n\n
\n\n \n\n ```python\n\n @app.post(\"/sync/multipart-file\")\n def sync_multipart_file(request: Request):\n files = request.files\n file_names = files.keys()\n return {\"file_names\": list(file_names)}\n ```\n\n \n \n\n\n---\n\n## File Downloads\n\nBatman now wanted to allow users to download files from his application. He created an endpoint to handle file downloads using the following code:\n\n\n### Serving Simple HTML Files\n\n\n
\nBatman scaled his application across multiple cores for better performance. He used the following command:\n\n
\"\n return html(html_string)\n\n app.start(port=8080)\n\n ```\n \n \n\n\n\n### Serving Other Files\n\n\n\n
\nNow, that Batman was able to serve HTML files, he wanted to serve other files like CSS, JS, and images. He was suggested to use the following code:\n\n
\nAfter serving other files, Batman wanted to serve directories, e.g. to serve a React build directory or just a simple HTML/CSS/JS directory. He was suggested to use the following code:\n\n
\n\n \n\n ```python\n from robyn import Robyn, serve_file, Request\n\n app = Robyn(__file__)\n\n\n app.serve_directory(\n route=\"/test_dir\",\n directory_path=os.path.join(current_file_path, \"build\"),\n index_file=\"index.html\",\n )\n\n app.start(port=8080)\n\n ```\n\n \n \n\n\n\n## What's next?\n\nNow, Batman was ready to learn about the advanced features of Robyn. He wanted to find a way to handle form data\n\n- [Form Data](/documentation/en/api_reference/form_data)\n\n\n"
},
{
"path": "docs_src/src/pages/documentation/en/api_reference/form_data.mdx",
"content": "export const description =\n 'On this page, we’ll dive into using the form data.'\n\n## Form Data and Multi Part Form Data\n\nBatman learned how to handle file uploads using Robyn. Now, he wanted to handle the form data.\n\n\n## Handling Multi Part Form Data\n\n\n
\nBatman uploaded some multipart form data and wanted to handle it using the following code:\n\n
\n\n \n\n ```python\n @app.post(\"/upload\")\n async def upload(request: Request):\n form_data = request.form_data\n\n return form_data\n ```\n\n \n \n\n\n\n## What's next?\n\nNow, Batman was ready to learn about the advanced features of Robyn. He wanted to find a way to get realtime updates in his dashboard.\n\n- [WebSockets](/documentation/en/api_reference/websockets)\n"
},
{
"path": "docs_src/src/pages/documentation/en/api_reference/future-roadmap.mdx",
"content": "export const description =\n 'On this page, we`ll take a look at the future roadmap for Robyn.'\n\n\n- Add performance optimizations\n- Pydantic Integration\n- Implement Auto Const Requests\n- Add ORM support, especially Prisma integration \n- Improve Plugin Ecosystem\n- Better Documentation\n- Improve the Websockets\n- Template Support\n- Graphql integration with Strawberry\n- Invest more time in the community around Robyn.\n\n## Next Steps\n\n- [Advanced Features](/documentation/en/api_reference/advanced_features)\n"
},
{
"path": "docs_src/src/pages/documentation/en/api_reference/getting_started.mdx",
"content": "export const description =\n 'On this page, we’ll dive into the different fundamentals of building web applications with Robyn, including examples and best practices.'\n\n\n## Building Your First Robyn Application\n\nRobyn is the fastest Python web framework, combining Python's simplicity with Rust's performance. Whether you're building APIs, web services, or full-stack applications, Robyn makes it easy to get started and scale.\n\n### Quick Start\n\nInstall Robyn and create your first application in minutes:\n\n```bash\npip install robyn\n```\n\n## Understanding Handler Types\n\nRobyn supports both synchronous and asynchronous request handlers, allowing you to choose the best approach for your use case:\n\n- **Synchronous handlers**: Perfect for CPU-bound operations, simple logic, or when you don't need to wait for external resources\n- **Asynchronous handlers**: Ideal for I/O-bound operations like database calls, HTTP requests, file operations, or any task that involves waiting\n\n\n\n
\n**Synchronous handlers** are perfect for simple operations, calculations, or when you don't need to wait for external resources:\n\n
\n\n \n\n ```python\n from robyn import Robyn, Request\n\n app = Robyn(__file__)\n\n @app.get(\"/\")\n def h(request: Request):\n return \"Hello, world\"\n\n app.start(port=8080, host=\"0.0.0.0\") # host is optional, defaults to 127.0.0.1\n ```\n \n \n\n\n\n
\n **Asynchronous handlers** are ideal for database operations, HTTP requests, file I/O, or any operation that involves waiting:\n \n
\n Here's a comprehensive example that demonstrates both sync and async handlers, proper error handling, and real-world patterns:\n \n
\n \n ```python\n from robyn import Robyn, Request\n import asyncio\n import json\n import time\n from typing import Dict, Any\n \n app = Robyn(__file__)\n \n # In-memory storage for demo (use a real database in production)\n users: Dict[str, Dict[str, Any]] = {\n \"1\": {\"id\": \"1\", \"name\": \"Alice\", \"email\": \"alice@example.com\", \"created_at\": \"2024-01-01\"},\n \"2\": {\"id\": \"2\", \"name\": \"Bob\", \"email\": \"bob@example.com\", \"created_at\": \"2024-01-02\"}\n }\n \n # Const route for health checks (cached in Rust for max performance)\n @app.get(\"/health\", const=True)\n def health_check():\n return {\"status\": \"healthy\", \"version\": \"1.0.0\"}\n \n # Async handler for database-like operations\n @app.get(\"/users/:id\")\n async def get_user(path_params):\n user_id = path_params[\"id\"]\n \n # Simulate async database lookup\n await asyncio.sleep(0.01) # Simulate DB query time\n \n if user_id in users:\n return {\"success\": True, \"user\": users[user_id]}\n else:\n return {\"success\": False, \"error\": \"User not found\"}, 404\n \n # Get all users with pagination\n @app.get(\"/users\")\n async def list_users(query_params):\n page = int(query_params.get(\"page\", \"1\"))\n limit = int(query_params.get(\"limit\", \"10\"))\n \n # Simulate async operation\n await asyncio.sleep(0.01)\n \n user_list = list(users.values())\n start = (page - 1) * limit\n end = start + limit\n \n return {\n \"users\": user_list[start:end],\n \"total\": len(user_list),\n \"page\": page,\n \"limit\": limit\n }\n \n # Create new user\n @app.post(\"/users\")\n async def create_user(body):\n try:\n data = json.loads(body)\n \n # Validate required fields\n if not data.get(\"name\") or not data.get(\"email\"):\n return {\"success\": False, \"error\": \"Name and email are required\"}, 400\n \n # Generate new ID\n new_id = str(len(users) + 1)\n new_user = {\n \"id\": new_id,\n \"name\": data[\"name\"],\n \"email\": data[\"email\"],\n \"created_at\": time.strftime(\"%Y-%m-%d\")\n }\n \n # Simulate async database save\n await asyncio.sleep(0.02)\n users[new_id] = new_user\n \n return {\"success\": True, \"user\": new_user}, 201\n \n except json.JSONDecodeError:\n return {\"success\": False, \"error\": \"Invalid JSON\"}, 400\n \n # Sync handler for CPU-intensive operations\n @app.post(\"/calculate\")\n def calculate_fibonacci(body):\n try:\n data = json.loads(body)\n n = data.get(\"number\", 10)\n \n if n < 0 or n > 35: # Prevent excessive computation\n return {\"error\": \"Number must be between 0 and 35\"}, 400\n \n # CPU-intensive calculation (runs in thread pool)\n def fib(x):\n if x <= 1:\n return x\n return fib(x-1) + fib(x-2)\n \n start_time = time.time()\n result = fib(n)\n calc_time = time.time() - start_time\n \n return {\n \"input\": n,\n \"result\": result,\n \"calculation_time\": f\"{calc_time:.4f}s\"\n }\n \n except json.JSONDecodeError:\n return {\"error\": \"Invalid JSON\"}, 400\n \n if __name__ == \"__main__\":\n app.start(port=8080)\n ```\n \n \n\n\n### Testing Your API\n\n\n
\n Once your server is running, you can test these endpoints using curl or any HTTP client:\n \n
\n \n ```bash\n # Test health endpoint\n curl http://localhost:8080/health\n \n # Get a user\n curl http://localhost:8080/users/1\n \n # List users with pagination\n curl \"http://localhost:8080/users?page=1&limit=5\"\n \n # Create a new user\n curl -X POST http://localhost:8080/users \\\n -H \"Content-Type: application/json\" \\\n -d '{\"name\": \"Charlie\", \"email\": \"charlie@example.com\"}'\n \n # Calculate fibonacci\n curl -X POST http://localhost:8080/calculate \\\n -H \"Content-Type: application/json\" \\\n -d '{\"number\": 20}'\n ```\n \n \n\n\n--- \n\n## Running Your Application\n\nRobyn applications can be run in several ways, each optimized for different scenarios. Here are the most common approaches:\n\n\n\n
\n **Direct execution** - Run your application file directly with various optimization flags:\n \n - `--dev`: Development mode with auto-reload\n - `--fast`: Optimized settings for production\n - `--processes N`: Scale across multiple CPU cores\n - `--workers N`: Multiple workers per process\n \n
\n \n ```bash\n usage: app.py [-h] [--processes PROCESSES] [--workers WORKERS] [--log-level LOG_LEVEL] [--create] [--docs] [--open-browser] [--version]\n\n Robyn, a fast async web framework with a rust runtime.\n\n options:\n -h, --help show this help message and exit\n --processes PROCESSES\n Choose the number of processes. [Default: 1]\n --workers WORKERS Choose the number of workers. [Default: 1]\n --dev Development mode. It restarts the server based on file changes.\n --log-level LOG_LEVEL\n Set the log level name\n --create Create a new project template.\n --docs Open the Robyn documentation.\n --open-browser Open the browser on successful start.\n --version Show the Robyn version.\n --compile-rust-path COMPILE_RUST_PATH\n Compile rust files in the given path.\n --create-rust-file CREATE_RUST_FILE\n Create a rust file with the given name.\n --disable-openapi Disable the OpenAPI documentation.\n --fast Fast mode. It sets the optimal values for processes, workers and log level. However, you can override them.\n ```\n \n \n\n\n### Common Run Configurations\n\n\n
\n **Development Mode**: Best for local development with automatic reloading when files change.\n \n
\n \n ```bash\n # Basic development mode\n python app.py --dev\n \n # Development with custom port\n python app.py --dev --port 3000\n \n # Development with debug logging\n python app.py --dev --log-level DEBUG\n ```\n \n \n\n\n\n
\n **Production Mode**: Optimized for performance with multiple processes and workers.\n \n
\n \n ```bash\n # Fast mode (automatic optimization)\n python app.py --fast\n \n # Custom scaling configuration\n python app.py --processes 4 --workers 2\n \n # Production with specific log level\n python app.py --fast --log-level INFO\n ```\n \n \n\n\n\n\n\n
\n **Module execution** - Use Robyn's CLI module for additional features and consistent behavior across environments:\n \n\n
\n \n ```bash\n\n usage: python -m robyn app.py [-h] [--processes PROCESSES] [--workers WORKERS] [--dev] [--log-level LOG_LEVEL] [--create] [--docs] [--open-browser] [--version]\n\n\n Robyn, a fast async web framework with a rust runtime.\n\n options:\n -h, --help show this help message and exit\n --processes PROCESSES\n Choose the number of processes. [Default: 1]\n --workers WORKERS Choose the number of workers. [Default: 1]\n --dev Development mode. It restarts the server based on file changes.\n --log-level LOG_LEVEL\n Set the log level name\n --create Create a new project template.\n --docs Open the Robyn documentation.\n --open-browser Open the browser on successful start.\n --version Show the Robyn version.\n --compile-rust-path COMPILE_RUST_PATH\n Compile rust files in the given path.\n --create-rust-file CREATE_RUST_FILE\n Create a rust file with the given name.\n --disable-openapi Disable the OpenAPI documentation.\n --fast Fast mode. It sets the optimal values for processes, workers and log level. However, you can override them.\n ```\n \n \n\n\n\n\n\n---\n\n## Handling Different HTTP Methods\n\nRobyn supports all standard HTTP methods. Here's how to create a complete RESTful API with proper request handling:\n\n\n
\n**Complete REST API Example**: Here's a practical example showing all HTTP methods for a blog post API:\n\n
\n\n \n\n ```python\n from robyn import Robyn, Request\n \n app = Robyn(__file__)\n \n # In-memory storage for demo\n posts = {\n \"1\": {\"id\": \"1\", \"title\": \"First Post\", \"content\": \"Hello World\"},\n \"2\": {\"id\": \"2\", \"title\": \"Second Post\", \"content\": \"Learning Robyn\"}\n }\n \n # GET - Retrieve all posts\n @app.get(\"/posts\")\n def get_posts(query_params):\n limit = int(query_params.get(\"limit\", \"10\"))\n posts_list = list(posts.values())[:limit]\n return {\"posts\": posts_list, \"total\": len(posts)}\n \n # GET - Retrieve specific post\n @app.get(\"/posts/:id\")\n def get_post(path_params):\n post_id = path_params[\"id\"]\n if post_id in posts:\n return {\"post\": posts[post_id]}\n return {\"error\": \"Post not found\"}, 404\n \n # POST - Create new post\n @app.post(\"/posts\")\n def create_post(request: Request):\n data = request.json()\n post_id = str(len(posts) + 1)\n new_post = {\n \"id\": post_id,\n \"title\": data.get(\"title\", \"\"),\n \"content\": data.get(\"content\", \"\")\n }\n posts[post_id] = new_post\n return {\"message\": \"Post created\", \"post\": new_post}, 201\n \n # PUT - Update entire post\n @app.put(\"/posts/:id\")\n def update_post(request: Request, path_params):\n post_id = path_params[\"id\"]\n if post_id not in posts:\n return {\"error\": \"Post not found\"}, 404\n \n data = request.json()\n posts[post_id] = {\n \"id\": post_id,\n \"title\": data.get(\"title\", \"\"),\n \"content\": data.get(\"content\", \"\")\n }\n return {\"message\": \"Post updated\", \"post\": posts[post_id]}\n \n # PATCH - Partial update\n @app.patch(\"/posts/:id\")\n def patch_post(request: Request, path_params):\n post_id = path_params[\"id\"]\n if post_id not in posts:\n return {\"error\": \"Post not found\"}, 404\n \n data = request.json()\n post = posts[post_id]\n \n # Update only provided fields\n if \"title\" in data:\n post[\"title\"] = data[\"title\"]\n if \"content\" in data:\n post[\"content\"] = data[\"content\"]\n \n return {\"message\": \"Post updated\", \"post\": post}\n \n # DELETE - Remove post\n @app.delete(\"/posts/:id\")\n def delete_post(path_params):\n post_id = path_params[\"id\"]\n if post_id not in posts:\n return {\"error\": \"Post not found\"}, 404\n \n deleted_post = posts.pop(post_id)\n return {\"message\": \"Post deleted\", \"post\": deleted_post}\n ```\n \n \n\n\n---\n\n\n## Working with JSON and Response Formats\n\nRobyn automatically handles JSON serialization, but also provides flexible response formatting options for different use cases.\n\n\n
\n **Automatic JSON Handling**: Robyn automatically converts Python dictionaries and lists to JSON responses with the correct Content-Type headers.\n\n
\n\n **Path Parameters**: Extract dynamic segments from URLs using colon syntax (`:param`)\n \n **Type-Safe Injection**: Use type annotations for automatic parameter injection with IDE support\n \n\n \n
\n\n Any request param can be used in the handler function either using type annotations or using the reserved names.\n \n \n Do note that the type annotations will take precedence over the reserved names.\n \n \n Robyn showed Batman example syntaxes of accessing the request params:\n\n \n
\n\n \n\n ```python\n from robyn.robyn import QueryParams, Headers\n from robyn.types import PathParams, RequestMethod, RequestBody, RequestURL\n \n @app.get(\"/untyped/query_params\")\n def untyped_basic(query_params):\n return query_params.to_dict()\n \n \n @app.get(\"/typed/query_params\")\n def typed_basic(query_data: QueryParams):\n return query_data.to_dict()\n \n \n @app.get(\"/untyped/path_params/:id\")\n def untyped_path_params(query_params: PathParams):\n return query_params # contains the path params since the type annotations takes precedence over the reserved names\n \n \n @app.post(\"/typed_untyped/combined\")\n def typed_untyped_combined(\n query_params,\n method_data: RequestMethod,\n body_data: RequestBody,\n url: RequestURL,\n headers_item: Headers,\n ):\n return {\n \"body\": body_data,\n \"query_params\": query_params.to_dict(),\n \"method\": method_data,\n \"url\": url.path,\n \"headers\": headers_item.get(\"server\"),\n }\n ```\n\n \n \n\n\nType Aliases: `Request`, `QueryParams`, `Headers`, `PathParams`, `RequestBody`, `RequestMethod`, `RequestURL`, `FormData`, `RequestFiles`, `RequestIP`, `RequestIdentity`\n\nReserved Names: `r`, `req`, `request`, `query_params`, `headers`, `path_params`, `body`, `method`, `url`, `ip_addr`, `identity`, `form_data`, `files`\n\n---\n\nAs Batman continued to develop his web application with Robyn, he explored more features and implemented them using code samples.\n\n## Customizing Response Formats and Headers\n\n\nAfter understanding the dynamic nature of Robyn, Batman, now wanted the ability to customize response formats and headers. Robyn showed him how to do this using dictionaries and Robyn's Response object.\n\n### Using Dictionaries\n\n\n
\nBatman learned to customize response formats by returning dictionaries or using Robyn's Response object. He could also set status codes and headers for each response. For example, Batman created a response with a dictionary like this:\n\n
\n\n \n\n ```python\n from robyn import Request\n\n @app.post(\"/dictionary\")\n async def dictionary(request: Request):\n return {\n \"status_code\": 200,\n \"description\": \"This is a regular response\",\n \"type\": \"text\",\n \"headers\": {\"Header\": \"header_value\"},\n }\n\n ```\n \n \n\n\n\n### Using the Response object\n\n
\nBatman then wanted to return a binary output from his application. He could do this by setting the type of the response to \"binary\" and returning a bytes object. For example, he wrote:\n\n
\n\n \n\n ```python\n from robyn import Request, Response\n\n @app.get(\"/binary_output_response_sync\")\n def binary_output_response_sync(request: Request):\n return Response(\n status_code=200,\n headers={\"Content-Type\": \"application/octet-stream\"},\n description=\"OK\",\n )\n\n\n @app.get(\"/binary_output_async\")\n async def binary_output_async(request: Request):\n return b\"OK\"\n\n\n @app.get(\"/binary_output_response_async\")\n async def binary_output_response_async(request: Request):\n return Response(\n status_code=200,\n headers={\"Content-Type\": \"application/octet-stream\"},\n description=\"OK\",\n )\n ```\n \n \n\n\n\n\n---\n\n## Response Headers\n\nBatman, being the world's greatest detective, spotted the `headers` field in the `Response` object. He, naturally wanted to know more about it. Robyn explained that he could use the `headers` field to set response headers. For example, he could set the `Content-Type` header to `application/json` by writing:\n\n### Local Response Headers\n\n\n
\nEither, by using the `headers` field in the `Response` object:\n\n
\nYou can set additional cookie attributes for security and control:\n\n- **path**: Cookie path (default: \"/\")\n- **domain**: Cookie domain\n- **max_age**: Cookie lifetime in seconds\n- **secure**: Only send over HTTPS\n- **http_only**: Not accessible via JavaScript\n- **same_site**: CSRF protection (\"Strict\", \"Lax\", or \"None\" - case insensitive)\n\n
\nTo delete a cookie from the browser, use the `delete` method on the cookies collection. This sets `max_age=0` which tells the browser to remove the cookie.\n\n
\nYou can iterate over cookies or access them by name:\n\n
\n\n \n\n ```python\n from robyn import Request, Response, Headers\n\n @app.get(\"/debug\")\n def debug_cookies(request: Request):\n response = Response(200, Headers({}), \"Cookies set\")\n response.set_cookie(\"a\", \"1\")\n response.set_cookie(\"b\", \"2\")\n \n # Get all cookie names\n names = response.cookies.keys()\n \n # Iterate over cookies\n for name in response.cookies:\n print(f\"Cookie: {name}\")\n \n # Check if cookie exists\n if \"a\" in response.cookies:\n print(\"Cookie 'a' exists\")\n \n return response\n ```\n \n \n\n\n\n## Request Headers\n\nBatman, now wanted to know how to read request headers. Robyn explained that he could use the `request.headers` field to read request headers. For example, he could read the `Content-Type` header by writing:\n\n### Local Request Headers\n\n\n
\nEither, by using the `headers` field in the `Request` object:\n\n
\n\n\n \n\n ```python\n from robyn import Request\n\n @app.get(\"/\")\n def binary_output_response_sync(request: Request):\n headers = request.headers\n\n print(\"These are the request headers: \", headers)\n existing_header = headers.get(\"exisiting_header\")\n existing_header = headers.get(\"exisiting_header\", \"default_value\")\n exisiting_header = headers[\"exisiting_header\"] # This syntax is also valid\n\n headers.set(\"modified\", \"modified_value\")\n headers[\"new_header\"] = \"new_value\" # This syntax is also valid\n\n print(\"These are the modified request headers: \", headers)\n \n return \"\"\n\n ```\n \n \n\n\n\n
\n`add_request_header` appends the header to the list of headers, while `set_request_header` replaces the header if it exists.\n\n
\n\n\n \n\n ```python\n app.set_request_header(\"server\", \"robyn\")\n ```\n \n \n\n\n\n---\n\n## Status Codes\n\n\n
\nAfter learning about response formats and headers, Batman learned to set status codes for his responses. \n\n
\n\n \n\n ```python\n from robyn import status_codes, Request\n\n\n @app.get(\"/response\")\n async def response(request: Request):\n return Response(status_code=status_codes.HTTP_200_OK, headers=Headers({}), description=\"OK\")\n ```\n \n \n\n\n\n---\n\n## What's next?\n\nGreat, now Robyn, what is the `Request` Object that you keep talking about?, Batman said. \"Next section\", said Robyn.\n\n- [The Request Object](/documentation/en/api_reference/request_object)\n\nBatman was also interested to know about the architecture of Robyn. \"Next section\", said Robyn.\n\n- [Architecture](/documentation/en/architecture)\n\n\n\n"
},
{
"path": "docs_src/src/pages/documentation/en/api_reference/graphql-support.mdx",
"content": "export const description =\n 'On this page, we`ll understand how GraphQL support is provided in the existing Robyn codebase to ensure faster data fetching in modern webapps .'\n\n## GraphQL Support [(With Strawberry 🍓)](https://strawberry.rocks/)\n\nThis is in a very early stage right now. We will have a much more stable version when we have a stable API for Views and View Controllers.\n\n## Step 1: Creating a virtualenv\n\nTo ensure that there are isolated dependencies, we will use virtual environments.\n\n \n\n```bash {{ title: 'pip' }}\npython3 -m venv venv\n```\n\n \n\n## Step 2: Activate the virtualenv and install Robyn\n\n \n\n```bash {{ title: 'pip' }}\nsource venv/bin/activate\n```\n\n \n\n \n\n```bash {{ title: 'pip' }}\npip install robyn strawberry-graphql\n```\n\n \n\n## Step 3: Coding the App\n\n \n\n```python {{ title: 'python' }}\nfrom typing import List, Optional\nfrom robyn import Robyn, jsonify\nimport json\n\nimport dataclasses\nimport strawberry\nimport strawberry.utils.graphiql\n\n\n@strawberry.type\nclass User:\n name: str\n\n\n@strawberry.type\nclass Query:\n @strawberry.field\n def user(self) -> Optional[User]:\n return User(name=\"Hello\")\n\n\nschema = strawberry.Schema(Query)\n\napp = Robyn(__file__)\n\n\n@app.get(\"/\", const=True)\nasync def get():\n return strawberry.utils.graphiql.get_graphiql_html()\n\n\n@app.post(\"/\")\nasync def post(request):\n body = request.json()\n query = body[\"query\"]\n variables = body.get(\"variables\", None)\n context_value = {\"request\": request}\n root_value = body.get(\"root_value\", None)\n operation_name = body.get(\"operation_name\", None)\n\n data = await schema.execute(\n query,\n variables,\n context_value,\n root_value,\n operation_name,\n )\n\n return jsonify(\n {\n \"data\": (data.data),\n **({\"errors\": data.errors} if data.errors else {}),\n **({\"extensions\": data.extensions} if data.extensions else {}),\n }\n )\n\n\nif __name__ == \"__main__\":\n app.start(port=8080, host=\"0.0.0.0\")\n```\n\n \n\nLet us try to decipher the usage line by line.\n\n\n
\nThese statements just import the dependencies.\n\n
\nNow, we are initializing a Robyn app. For us, to serve a GraphQl app, we need to have a `get` route to return the `GraphiQL(ide)` and then a post route to process the `GraphQl` request.\n\n
\nWe are populating the html page with the GraphiQL IDE using `strawberry`. We are using `const=True` to precompute this population. Essentially, making it very fast and bypassing the execution overhead in this get request.\n\n
\nFinally, we are getting params(body, query, variables, context_value, root_value, operation_name) from the `request` object.\n\n
\n\n \n\n ```python {{ title: 'python' }}\n @app.post(\"/\")\n async def post(request):\n body = request.json()\n query = body[\"query\"]\n variables = body.get(\"variables\", None)\n context_value = {\"request\": request}\n root_value = body.get(\"root_value\", None)\n operation_name = body.get(\"operation_name\", None)\n\n data = await schema.execute(\n query,\n variables,\n context_value,\n root_value,\n operation_name,\n )\n\n return jsonify(\n {\n \"data\": (data.data),\n **({\"errors\": data.errors} if data.errors else {}),\n **({\"extensions\": data.extensions} if data.extensions else {}),\n }\n )\n ```\n \n\n \n\n\nThe above is the example for just one route. You can do the same for as many as you like. :)\n\n\n## What's next?\n\nThat's all folks. :D Keep an eye out for more updates on this page. We will be adding more examples and documentation as we go along.\n\n\n"
},
{
"path": "docs_src/src/pages/documentation/en/api_reference/index.mdx",
"content": "export const description =\n 'On this page, we’ll dive into the different conversation endpoints you can use to manage conversations programmatically.'\n\nOnce upon a time in the city of Gotham, there was a powerful superhero named Robyn. Robyn had a unique set of abilities that allowed it to fetch information from the far corners of the internet. It could send requests and receive responses at lightning speed, and its prowess was admired by developers everywhere.\n\nOne day, Batman approached Robyn for help with building a web application. Batman had heard about Robyn's powerful features and wanted to harness them to create a remarkable application. Batman was looking for an ally and in Robyn, he found the best one!\n\n\n## Installing Robyn\n\n\nRobyn is a Python library that you can install using `pip` or `conda`\n\n \n\n ```bash {{ title: 'pip' }}\n pip install robyn\n ```\n\n ```bash {{ title: 'conda' }}\n conda install robyn -c conda-forge\n ```\n \n\nWhile there are other more extensions of Robyn like\n\n \n\n ```bash {{ title: 'pip' }}\n pip install \"robyn[templating]\"\n ```\n\n ```bash {{ title: 'conda' }}\n conda install \"robyn[templating]\" -c conda-forge\n ```\n \n\n\n\nIt is recommended to install the base package first and then install the extensions as needed.\n\n## What's next?\n\nNow, we can start using Robyn to build our application.\n\n\n- [Getting Started](/documentation/en/api_reference/getting_started)\n\n\n\n"
},
{
"path": "docs_src/src/pages/documentation/en/api_reference/mcps.mdx",
"content": "# Model Context Protocol (MCP)\n\n> **⚠️ Experimental**: MCP support is experimental and may change.\n\nRobyn supports MCP, allowing AI applications like Claude Desktop to connect to your application's resources and tools.\n\n## Quick Start\n\n```python\nfrom robyn import Robyn\n\napp = Robyn(__file__)\n\n@app.mcp.resource(\"echo://{message}\")\ndef echo_resource(message: str) -> str:\n return f\"Resource echo: {message}\"\n\n@app.mcp.tool()\ndef echo_tool(message: str) -> str:\n return f\"Tool echo: {message}\"\n\n@app.mcp.prompt()\ndef echo_prompt(message: str) -> str:\n return f\"Please process: {message}\"\n\napp.start()\n```\n\n## Features\n\n- Auto-generated JSON schemas from function signatures\n- URI templates with parameter extraction\n- JSON-RPC 2.0 protocol compliance\n- Type-aware parameter handling\n\n## Decorator Reference\n\n### `@app.mcp.resource(uri, name=None, description=None, mime_type=None)`\n\nRegister a resource that can be read by clients.\n\n```python\n@app.mcp.resource(\"user://{user_id}/profile\")\ndef user_profile(user_id: str) -> str:\n return f\"Profile for user {user_id}\"\n```\n\n### `@app.mcp.tool(name=None, description=None, input_schema=None)`\n\nRegister a tool that can be executed by AI models.\n\n```python\n@app.mcp.tool()\ndef greet(name: str, formal: bool = False) -> str:\n if formal:\n return f\"Good day, {name}.\"\n return f\"Hi {name}!\"\n```\n\n### `@app.mcp.prompt(name=None, description=None, arguments=None)`\n\nRegister a prompt template for AI workflows.\n\n```python\n@app.mcp.prompt()\ndef code_review(code: str, language: str = \"python\") -> str:\n return f\"Please review this {language} code: {code}\"\n```\n\n## Type Support\n\nSupported types: `str`, `int`, `float`, `bool`, `List`, `Dict`\n\n## URI Templates\n\nExtract parameters from URIs:\n\n```python\n@app.mcp.resource(\"user://{user_id}/posts/{post_id}\")\ndef get_user_post(user_id: str, post_id: str) -> str:\n return f\"Post {post_id} from user {user_id}\"\n```\n\n## Client Usage\n\nTest with curl:\n\n```bash\n# List resources\ncurl -X POST http://localhost:8080/mcp \\\n -H \"Content-Type: application/json\" \\\n -d '{\"jsonrpc\": \"2.0\", \"id\": 1, \"method\": \"resources/list\", \"params\": {}}'\n```\n\n## Integration with Claude Desktop\n\nTo connect your Robyn MCP server to Claude Desktop:\n\n1. Start your Robyn app with MCP endpoints\n2. Configure Claude Desktop to connect to `http://localhost:8080/mcp`\n3. Use the registered resources, tools, and prompts in your conversations\n\n## Error Handling\n\n```python\n@app.mcp.tool()\ndef divide(a: float, b: float) -> str:\n if b == 0:\n raise ValueError(\"Division by zero\")\n return str(a / b)\n```\n\n## Testing\n\n```bash\n# Unit tests\npython examples/mcp.py test-unit\n\n# Live tests\npython examples/mcp.py test-live\n\n# All tests\npython examples/mcp.py test-all\n```\n\n## Configuration\n\nMCP runs at `/mcp` endpoint using JSON-RPC 2.0 over HTTP. No additional setup required.\n\n## Claude Desktop Integration\n\n1. Start your Robyn server\n2. Configure Claude Desktop to connect to `http://localhost:8080/mcp`\n3. Use resources, tools, and prompts in conversations\n\n\n\nSee `examples/mcp.py` for a complete example.\n\nFor more information: https://modelcontextprotocol.io/"
},
{
"path": "docs_src/src/pages/documentation/en/api_reference/middlewares.mdx",
"content": "export const description =\n 'On this page, we’ll dive into the different conversation endpoints you can use to manage conversations programmatically.'\n\n## Working with Middlewares and Events\n\nAs Batman's application grew more complex, Robyn taught him about middlewares, startup and shutdown events, and even working with WebSockets. Batman learned how to create functions that could execute before or after a request, manage the application's life cycle, and handle real-time communication with clients using WebSockets.\n\n\n## Handling Events\n\nBatman discovered that he could add startup and shutdown events to manage his application's life cycle. He added the following code to define these events:\n\n\n
\nBatman was excited to learn that he could add events as functions as well as decorators.\n\n
\n\n Batman learned to use both sync and async functions for middlewares. He wrote the following code to add a middleware that would execute before and after each request.\n A before request middleware is a function that executes before each request. It can modify the request object or perform any other operation before the request is processed.\n An after request middleware is a function that executes after each request. It can modify the response object or perform any other operation after the request is processed.\n\n Every before request middleware should accept a request object and return a request object. Every after-request middleware should accept a response object and return a response object on happy case scenario. After-request middlewares can also optionally accept the request object as the first parameter to access request data.\n\n The execution of the before request middleware is stopped if any of the before request middleware returns a response object. The response object is returned to the client without executing the after request middleware or the main entry point code.\n\n\n \n\n \n
\n\n \n\n ```python\n from robyn import Request, Response\n\n @app.before_request(\"/\")\n async def hello_before_request(request: Request):\n request.headers.set(\"before\", \"sync_before_request\")\n return request\n\n @app.after_request(\"/\")\n def hello_after_request(response: Response):\n response.headers.set(\"after\", \"sync_after_request\")\n return response\n ```\n\n ```python {{ title: 'after_request with request access' }}\n from robyn import Request, Response\n\n @app.after_request(\"/\")\n def hello_after_request(request: Request, response: Response):\n # Access request data in after_request\n response.headers.set(\"request_path\", request.url.path)\n response.headers.set(\"after\", \"sync_after_request\")\n return response\n ```\n\n\n \n\n\n \n\n\n---\n\n\n## What's next?\n\nRobyn - Great, you're now familiar with the certain advanced concepts of Robyn.\n\nBatman - \"Authentication! I want to learn about authentication. I want to make sure that only the right people can access my application.\"\n\nRobyn - Yes, Authentication!\n\n\n- [Authentication](/documentation/en/api_reference/authentication)\n\n"
},
{
"path": "docs_src/src/pages/documentation/en/api_reference/multiprocess_execution.mdx",
"content": "export const description =\n 'On this page, we’ll dive into the different conversation endpoints you can use to manage conversations programmatically.'\n\n## Multiprocess Execution\n\nBatman wondered about the behaviour of variables in a Robyn multiprocessing environment.\n\nRobyn reassured that it can indeed support them! i.e, handlers can be dispatched to multiple threads.\n\nAny variable used in a multiprocessing environment is shared across multiple processes.\n\nWhilst using multithreading in Robyn, the variables are not protected from multiple threads access by default.\n\n\n
\n\nIf one needs a variable to be protected within a process, while accessing it from different threads, one can use `multiprocessing.Value` for achieving the required protection.\n\n\n
\n\n \n\n ```python\n import threading\n import time\n from multiprocessing import Value\n\n from robyn import Robyn, Request\n\n app = Robyn(__file__)\n\n count: Value = Value(\"i\", 0)\n\n def counter():\n while True:\n count.value += 1\n time.sleep(0.2)\n print(count.value, \"added 1\")\n\n @app.get(\"/\")\n def index(request: Request):\n return f\"{count.value}\"\n\n threading.Thread(target=counter, daemon=True).start()\n\n app.start()\n ```\n\n \n \n\n---\n\n\n## What's next?\n\n\nBatman wondered if it was possible to use Rust directly from Robyn's codebase.\n\nRobyn showed him the path.\n\n[Using Rust Directly](/documentation/en/api_reference/using_rust_directly)\n\n\n\n\n"
},
{
"path": "docs_src/src/pages/documentation/en/api_reference/openapi.mdx",
"content": "export const description =\n 'Welcome to the Robyn API documentation. You will find comprehensive guides and documentation to help you start working with Robyn as quickly as possible, as well as support if you get stuck.'\n\n\n## OpenAPI Docs a.k.a Swagger\n\nAfter deploying the application, Batman got multiple queries from the users on how to use the endpoints. Robyn showed him how to generate OpenAPI specifications for his application.\n\nOut of the box, the following endpoints are setup for you:\n\n- `/docs` The Swagger UI\n- `/openapi.json` The JSON Specification\n\nTo use a custom openapi configuration, you can:\n\n - Place the `openapi.json` config file in the root directory.\n - Or, pass the file path to the `openapi_file_path` parameter in the `Robyn()` constructor. (the parameter gets priority over the file).\n\nHowever, if you don't want to generate the OpenAPI docs, you can disable it by passing `--disable-openapi` flag while starting the application.\n\n```bash\npython app.py --disable-openapi\n```\n\n## How to use?\n\n- Query Params: The typing for query params can be added as `def get(r: Request, query_params: GetRequestParams)` where `GetRequestParams` is a subclass of `QueryParams`\n- Path Params are defaulted to string type (ref: https://en.wikipedia.org/wiki/Query_string)\n\n\n\n```python\nfrom robyn.robyn import QueryParams\n\nfrom robyn import Robyn, Request\n\napp = Robyn(\n file_object=__file__,\n openapi=OpenAPI(\n info=OpenAPIInfo(\n title=\"Sample App\",\n description=\"This is a sample server application.\",\n termsOfService=\"https://example.com/terms/\",\n version=\"1.0.0\",\n contact=Contact(\n name=\"API Support\",\n url=\"https://www.example.com/support\",\n email=\"support@example.com\",\n ),\n license=License(\n name=\"BSD2.0\",\n url=\"https://opensource.org/license/bsd-2-clause\",\n ),\n externalDocs=ExternalDocumentation(description=\"Find more info here\", url=\"https://example.com/\"),\n components=Components(),\n ),\n ),\n)\n\n\n@app.get(\"/\")\nasync def welcome():\n \"\"\"welcome endpoint\"\"\"\n return \"hi\"\n\n\nclass GetRequestParams(QueryParams):\n appointment_id: str\n year: int\n\n\n@app.get(\"/api/v1/name\", openapi_name=\"Name Route\", openapi_tags=[\"Name\"])\nasync def get(r: Request, query_params: GetRequestParams):\n \"\"\"Get Name by ID\"\"\"\n return r.query_params\n\n\n@app.delete(\"/users/:name\", openapi_tags=[\"Name\"])\nasync def delete(r: Request):\n \"\"\"Delete Name by ID\"\"\"\n return r.path_params\n\n\nif __name__ == \"__main__\":\n app.start()\n```\n\n\n\n## How does it work with subrouters?\n\n\n\n```python\nfrom robyn.robyn import QueryParams\n\nfrom robyn import Request, SubRouter\n\nsubrouter: SubRouter = SubRouter(__name__, prefix=\"/sub\")\n\n\n@subrouter.get(\"/\")\nasync def subrouter_welcome():\n \"\"\"welcome subrouter\"\"\"\n return \"hiiiiii subrouter\"\n\n\nclass SubRouterGetRequestParams(QueryParams):\n _id: int\n value: str\n\n\n@subrouter.get(\"/name\")\nasync def subrouter_get(r: Request, query_params: SubRouterGetRequestParams):\n \"\"\"Get Name by ID\"\"\"\n return r.query_params\n\n\n@subrouter.delete(\"/:name\")\nasync def subrouter_delete(r: Request):\n \"\"\"Delete Name by ID\"\"\"\n return r.path_params\n\n\napp.include_router(subrouter)\n```\n\n\n\n## Other Specification Params\n\nWe support all the params mentioned in the latest OpenAPI specifications (https://swagger.io/specification/). See an example using request & response bodies below:\n\n\n\n```python\nfrom robyn.types import JSONResponse, Body\n\nclass Initial(Body):\n is_present: bool\n letter: Optional[str]\n\n\nclass FullName(Body):\n first: str\n second: str\n initial: Initial\n\n\nclass CreateItemBody(Body):\n name: FullName\n description: str\n price: float\n tax: float\n\n\nclass CreateResponse(JSONResponse):\n success: bool\n items_changed: int\n\n\n@app.post(\"/\")\ndef create_item(request: Request, body: CreateItemBody) -> CreateResponse:\n return CreateResponse(success=True, items_changed=2)\n```\n\n\n\nWith the reference documentation deployed and running smoothly, Batman had a powerful new tool at his disposal. The Robyn framework had provided him with the flexibility, scalability, and performance needed to create an effective crime-fighting application, giving him a technological edge in his ongoing battle to protect Gotham City.\n\n## Using Pydantic Models\n\nIf you have Pydantic installed (`pip install \"robyn[pydantic]\"` or `pip install \"robyn[all]\"`), you can use Pydantic `BaseModel` classes directly as handler parameter annotations. Robyn will automatically validate the request body **and** generate a rich OpenAPI schema — including property types, required fields, defaults, and `$ref` for nested models.\n\n\n\n```python\nfrom pydantic import BaseModel\n\nclass UserCreate(BaseModel):\n name: str\n email: str\n age: int\n active: bool = True\n\n@app.post(\"/users\", openapi_tags=[\"Users\"])\ndef create_user(user: UserCreate) -> dict:\n \"\"\"Create a new user\"\"\"\n return {\"name\": user.name}\n```\n\n\n\nFor the full guide on Pydantic validation, nested models, error responses, and OpenAPI integration, see the dedicated [Pydantic Integration](/documentation/en/api_reference/pydantic) page.\n\n\n## What's next?\n\n\nBatman wondered about whether Robyn handlers can be dispatched to multiple processes.\n\nRobyn showed him the way!\n\n[Multiprocess Execution](/documentation/en/api_reference/multiprocess_execution)\n\n\n\n"
},
{
"path": "docs_src/src/pages/documentation/en/api_reference/pydantic.mdx",
"content": "export const description =\n 'Learn how to use Pydantic models with Robyn for automatic request body validation and OpenAPI schema generation.'\n\n\n## Pydantic Integration\n\nRobyn supports [Pydantic](https://docs.pydantic.dev/) v2 as an optional dependency for automatic request body validation and rich OpenAPI schema generation. Validation is **opt-in per handler** — it only activates when you annotate a parameter with a Pydantic `BaseModel`. Handlers without Pydantic annotations are completely unaffected: no parsing, no validation, no overhead. When Pydantic is not installed at all, Robyn never imports it.\n\n\n## Installation\n\nInstall Robyn with Pydantic support using the optional extra:\n\n\n\n```bash {{ title: 'Pydantic only' }}\npip install \"robyn[pydantic]\"\n```\n\n```bash {{ title: 'All extras' }}\npip install \"robyn[all]\"\n```\n\n```bash {{ title: 'conda' }}\nconda install robyn pydantic -c conda-forge\n```\n\n\n\n`robyn[all]` includes Pydantic, Jinja2 templating, and any future optional features.\n\n\n## Basic Usage\n\nDefine a Pydantic `BaseModel` and use it as a type annotation on your handler parameter. Robyn will automatically parse the incoming JSON body, validate it against the model, and inject the validated instance into your handler.\n\n\n\n```python {{ title: 'Synchronous' }}\nfrom pydantic import BaseModel\nfrom robyn import Robyn\n\napp = Robyn(__file__)\n\n\nclass UserCreate(BaseModel):\n name: str\n email: str\n age: int\n active: bool = True\n\n\n@app.post(\"/users\")\ndef create_user(user: UserCreate):\n \"\"\"Create a new user\"\"\"\n return {\n \"name\": user.name,\n \"email\": user.email,\n \"age\": user.age,\n \"active\": user.active,\n }\n\n\nif __name__ == \"__main__\":\n app.start()\n```\n\n```python {{ title: 'Asynchronous' }}\nfrom pydantic import BaseModel\nfrom robyn import Robyn\n\napp = Robyn(__file__)\n\n\nclass UserCreate(BaseModel):\n name: str\n email: str\n age: int\n active: bool = True\n\n\n@app.post(\"/users\")\nasync def create_user(user: UserCreate):\n \"\"\"Create a new user\"\"\"\n return {\n \"name\": user.name,\n \"email\": user.email,\n \"age\": user.age,\n \"active\": user.active,\n }\n\n\nif __name__ == \"__main__\":\n app.start()\n```\n\n\n\n\n## Validation Errors\n\nWhen the request body fails validation, Robyn automatically returns a **422 Unprocessable Entity** response with structured error details. You do not need to write any error handling code.\n\nFor example, sending `{\"name\": \"Alice\", \"email\": \"alice@example.com\", \"age\": \"not_a_number\"}` would produce:\n\n```json\n{\n \"error\": \"Validation Error\",\n \"detail\": [\n {\n \"type\": \"int_parsing\",\n \"loc\": [\"age\"],\n \"msg\": \"Input should be a valid integer, unable to parse string as an integer\",\n \"input\": \"not_a_number\"\n }\n ]\n}\n```\n\nMissing required fields are also caught:\n\n```json\n{\n \"error\": \"Validation Error\",\n \"detail\": [\n {\n \"type\": \"missing\",\n \"loc\": [\"email\"],\n \"msg\": \"Field required\",\n \"input\": {\"name\": \"Alice\", \"age\": 30}\n }\n ]\n}\n```\n\n\n## Nested Models\n\nPydantic models can reference other models. Robyn handles nested validation automatically.\n\n\n\n```python\nfrom pydantic import BaseModel\nfrom robyn import Robyn\n\napp = Robyn(__file__)\n\n\nclass Address(BaseModel):\n street: str\n city: str\n zip_code: str\n\n\nclass UserWithAddress(BaseModel):\n name: str\n email: str\n address: Address\n\n\n@app.post(\"/users\")\ndef create_user(data: UserWithAddress):\n \"\"\"Create a user with an address\"\"\"\n return {\"name\": data.name, \"city\": data.address.city}\n```\n\n\n\nIf the nested `address` object is missing or malformed, Robyn returns a 422 with the full error path (e.g. `[\"address\", \"city\"]`).\n\n\n## Using with the Request Object\n\nYou can combine Pydantic parameters with the standard `Request` object in the same handler. This gives you access to headers, query params, and other request metadata alongside the validated body.\n\n\n\n```python\nfrom pydantic import BaseModel\nfrom robyn import Robyn, Request\n\napp = Robyn(__file__)\n\n\nclass UserCreate(BaseModel):\n name: str\n email: str\n age: int\n active: bool = True\n\n\n@app.post(\"/users\")\ndef create_user(request: Request, user: UserCreate):\n \"\"\"Create a user — access both raw request and validated model\"\"\"\n return {\n \"method\": request.method,\n \"name\": user.name,\n \"email\": user.email,\n }\n```\n\n\n\n\n## Returning Pydantic Models Directly\n\nYou can return a Pydantic model instance (or a list of them) directly from a handler. Robyn will automatically serialize it to JSON with the correct `Content-Type` header — no need to call `.model_dump()` manually.\n\n\n\n```python {{ title: 'Single model' }}\n@app.post(\"/users\")\ndef create_user(user: UserCreate) -> UserCreate:\n \"\"\"Validate and echo back the user\"\"\"\n return user\n```\n\n```python {{ title: 'List of models' }}\n@app.post(\"/users/batch\")\ndef create_users(user: UserCreate) -> list[UserCreate]:\n \"\"\"Return multiple model instances\"\"\"\n return [user, user]\n```\n\n\n\nBoth forms produce an `application/json` response. The single-model path uses Pydantic's Rust-based `model_dump_json()` for maximum throughput.\n\n\n## How Validation Is Triggered\n\nPydantic validation is **annotation-driven, not method-driven**. The router inspects each handler's signature at registration time; any parameter annotated with a `BaseModel` subclass triggers automatic validation of `request.body` when that route is called. This works with every HTTP method — `POST`, `PUT`, `PATCH`, `DELETE`, or any other method that carries a body.\n\n\n\n```python {{ title: 'PUT' }}\n@app.put(\"/users/:id\")\ndef update_user(user: UserCreate):\n return {\"updated\": True, \"name\": user.name}\n```\n\n```python {{ title: 'PATCH' }}\n@app.patch(\"/users/:id\")\ndef patch_user(user: UserCreate):\n return {\"patched\": True, \"name\": user.name}\n```\n\n\n\n\n## OpenAPI Integration\n\nWhen you use Pydantic models, Robyn automatically generates rich JSON Schema in your OpenAPI specification at `/openapi.json`. This includes:\n\n- **Property types** — `string`, `integer`, `boolean`, etc.\n- **Required fields** — fields without defaults are listed in `required`\n- **Default values** — shown in the schema\n- **Nested models** — referenced via `$ref` and placed in `components/schemas`\n\n\n\n```python\nfrom pydantic import BaseModel\nfrom robyn import Robyn, Request\n\napp = Robyn(__file__)\n\n\nclass Address(BaseModel):\n street: str\n city: str\n zip_code: str\n\n\nclass UserWithAddress(BaseModel):\n name: str\n email: str\n address: Address\n\n\n@app.post(\"/users\", openapi_tags=[\"Users\"])\ndef create_user(request: Request, data: UserWithAddress) -> dict:\n \"\"\"Create a user with a nested address\"\"\"\n return {\"name\": data.name, \"city\": data.address.city}\n```\n\n\n\nThe generated `/openapi.json` will contain:\n\n```json\n{\n \"paths\": {\n \"/users\": {\n \"post\": {\n \"requestBody\": {\n \"content\": {\n \"application/json\": {\n \"schema\": {\n \"type\": \"object\",\n \"properties\": {\n \"name\": {\"type\": \"string\", \"title\": \"Name\"},\n \"email\": {\"type\": \"string\", \"title\": \"Email\"},\n \"address\": {\"$ref\": \"#/components/schemas/Address\"}\n },\n \"required\": [\"name\", \"email\", \"address\"],\n \"title\": \"UserWithAddress\"\n }\n }\n }\n }\n }\n }\n },\n \"components\": {\n \"schemas\": {\n \"Address\": {\n \"type\": \"object\",\n \"properties\": {\n \"street\": {\"type\": \"string\", \"title\": \"Street\"},\n \"city\": {\"type\": \"string\", \"title\": \"City\"},\n \"zip_code\": {\"type\": \"string\", \"title\": \"Zip Code\"}\n },\n \"required\": [\"street\", \"city\", \"zip_code\"],\n \"title\": \"Address\"\n }\n }\n }\n}\n```\n\n\n## Pydantic vs Body\n\nRobyn supports two approaches for typed request bodies. Choose the one that fits your needs:\n\n| Feature | `Body` subclass | Pydantic `BaseModel` |\n|---|---|---|\n| Installation | Built-in | `pip install \"robyn[pydantic]\"` |\n| Validation | No automatic validation | Full validation with detailed errors |\n| Error responses | Manual | Automatic 422 with structured errors |\n| Return serialization | Manual `dict()` | Auto-serialize model to JSON |\n| OpenAPI schema | Basic type inference | Full JSON Schema (types, required, defaults, `$ref`) |\n| Nested models | Supported (basic) | Supported (with `$ref` in OpenAPI) |\n| Performance overhead | None | Only when Pydantic is installed and used |\n\nBoth approaches work with OpenAPI documentation. If you need validation, use Pydantic. If you just need OpenAPI schema hints without validation, `Body` is sufficient.\n\n\n## Important Notes\n\n- **Opt-in per handler** — Validation only runs on handlers where a parameter is annotated with a Pydantic `BaseModel`. All other handlers (using `Body`, `Request`, path params, etc.) behave exactly as before with zero additional overhead.\n- **One Pydantic body per handler** — Each handler can have at most one parameter annotated with a Pydantic model. The entire request body is parsed into that single model. If you need multiple model inputs, compose them into a single parent model with nested fields.\n- **Request validation only** — Robyn validates *incoming* request bodies against Pydantic models but does not validate *outgoing* responses. When you return a model instance, it is serialized as-is without re-validation. This is a deliberate design choice for performance — if you constructed the model, it's already valid.\n\n\n## What's next?\n\nBatman wondered about whether Robyn handlers can be dispatched to multiple processes.\n\nRobyn showed him the way!\n\n[Multiprocess Execution](/documentation/en/api_reference/multiprocess_execution)\n\n\n"
},
{
"path": "docs_src/src/pages/documentation/en/api_reference/redirection.mdx",
"content": "## Redirection\n\nBatman wanted to redirect some endpoints to others. Robyn helped him do so by the following:\n\n\n
\n \n
\n \n\n ```python\n from robyn import Robyn, Response\n app = Robyn(__file__)\n\n @app.get(\"/\")\n async def index():\n return Response(\n status_code=307,\n description=\"\",\n headers={\"Location\": \"landing\"},\n )\n\n @app.get(\"/landing\")\n def landing():\n return \"hii!\"\n ```\n \n \n\n\n---\n\n## What's next?\n\nNow, Batman wanted to have the ability to upload files to the server if any new villain appeared. Robyn introduced him to the file upload and some of the form data features. \n\n- [File Uploads](/documentation/en/api_reference/file-uploads)\n"
},
{
"path": "docs_src/src/pages/documentation/en/api_reference/request_object.mdx",
"content": "export const description =\n 'On this page, we’ll dive into the different conversation endpoints you can use to manage conversations programmatically.'\n\n\n## Request Object\n\nThe request object is a dataclass that contains all the information about the request. It is available in the route handler as the first argument.\n\n\n\n\n
\nThe request object is created in Rust side but is exposed to Python as a dataclass.\n\n
\n
\nAttributes:\n
\n
\nquery_params (QueryParams): The query parameters of the request. `e.g. /user?id=123 -> {\"id\": [ \"123\" ]}`\n
\n
\nheaders (dict[str, str]): The headers of the request. `e.g. {\"Content-Type\": \"application/json\"}`\n
\n
\nparams (dict[str, str]): The parameters of the request. `e.g. /user/:id -> {\"id\": \"123\"}`\n
\n
\nbody (Union[str, bytes]): The raw body of the request. For JSON payloads, use the `json()` method to parse the body into a dict with proper type preservation.\n
\n
\nmethod (str): The method of the request. `e.g. GET, POST, PUT, DELETE`\n
\n
\nip_addr (Optional[str]): The IP Address of the client\n
\n
\nidentity (Optional[Identity]): The identity of the client\n
\n\n\n
\n\n\n\n\n\n\n
\n\n \n\n ```python\n @dataclass\n class Request:\n \"\"\"\n query_params: QueryParams\n headers: Headers\n path_params: dict[str, str]\n body: Union[str, bytes]\n method: str\n url: Url\n form_data: dict[str, str]\n files: dict[str, bytes]\n ip_addr: Optional[str]\n identity: Optional[Identity]\n \"\"\"\n ```\n \n \n\n\n## Parsing JSON Body\n\nThe `request.json()` method parses the request body as JSON and returns a Python `dict` with full type preservation:\n\n- JSON `null` becomes Python `None`\n- JSON numbers become Python `int` or `float`\n- JSON booleans become Python `bool`\n- JSON strings become Python `str`\n- JSON arrays become Python `list`\n- JSON objects become Python `dict`\n\nNested structures are handled recursively up to a maximum depth of 128 levels.\n\n\n\n```python\n@app.post(\"/example\")\nasync def handler(request: Request):\n data = request.json() # Returns a dict with preserved types\n # e.g. {\"count\": 42, \"active\": true, \"tags\": [\"a\", \"b\"]}\n # -> {\"count\": 42, \"active\": True, \"tags\": [\"a\", \"b\"]}\n return {\"received\": data}\n```\n\n\nIf the body is not valid JSON or is not a JSON object, a `ValueError` will be raised.\n\n## Extra Path Parameters\n\nRobyn supports capturing extra path parameters using the `*extra` syntax in route definitions. This allows you to capture any additional segments in the URL path that come after the defined route.\n\nFor example, if you define a route like this:\n\n\n```python\n@app.get(\"/sync/extra/*extra\")\ndef sync_param_extra(request: Request):\n extra = request.path_params[\"extra\"]\n return extra\n```\n\n\nAny additional path segments after `/sync/extra/` will be captured in the `extra` parameter. For instance:\n\n
\n
\nA request to `/sync/extra/foo/bar` would result in `extra = \"foo/bar\"`\n
\n
\n A request to `/sync/extra/123/456/789` would result in `extra = \"123/456/789\"`\n
\n
\n\nYou can access the extra path parameters through `request.path_params[\"extra\"]` in your route handler.\n\nThis feature is particularly useful when you need to handle dynamic, nested routes or when you want to capture an unknown number of path segments.\n\n---\n\n## Easy Access Parameters\n\nInstead of manually extracting and converting query parameters and path parameters from the request object, you can declare them directly in your function signature with type annotations. Robyn will automatically resolve and coerce them for you.\n\nAny handler parameter that doesn't match a known request component (`Request`, `QueryParams`, `Headers`, etc.) is treated as an individual path or query parameter.\n\n\n
\n **Basic usage** — path params and query params with type coercion and defaults.\n \n
\n \n\n ```python {{ title: 'Typed Params' }}\n @app.get(\"/items/:id\")\n async def get_item(id: int, q: str, page: int = 1):\n # id is coerced from the path param string to int\n # q is taken from ?q=...\n # page defaults to 1 if not provided\n return {\"id\": id, \"q\": q, \"page\": page}\n ```\n\n ```python {{ title: 'Mixed with Request' }}\n @app.get(\"/items/:id\")\n async def get_item(request: Request, id: int, q: str = \"\"):\n # request is still injected as usual\n # id and q are resolved as individual params\n return {\"id\": id, \"q\": q, \"method\": request.method}\n ```\n \n \n\n\n\n
\n **Optional, List, Bool, and Float params** — Robyn handles common Python types automatically.\n\n - `Optional[T]` — resolves to `None` when not provided\n - `List[T]` — collects repeated query params (e.g. `?tag=a&tag=b`)\n - `bool` — accepts `true/false`, `1/0`, `yes/no`, `on/off`\n - `float` — standard float coercion\n \n
\n **Error handling** — if a required parameter is missing or a value cannot be coerced to the declared type, Robyn returns a `400 Bad Request` response automatically.\n \n
\n \n\n ```python {{ title: 'Automatic 400' }}\n @app.get(\"/items/:id\")\n def get_item(id: int, q: str):\n return {\"id\": id, \"q\": q}\n\n # GET /items/42 -> 400 (missing required 'q')\n # GET /items/abc?q=test -> 400 (cannot coerce 'abc' to int)\n ```\n \n \n\n\n---\n\n\n## What's next?\n\nNow, Batman wanted to understand the configuration of the Robyn server. He was then introduced to the concept of Robyn env files.\n\n- [Robyn Env](/documentation/en/api_reference/robyn_env)\n\n"
},
{
"path": "docs_src/src/pages/documentation/en/api_reference/robyn_env.mdx",
"content": "export const description = 'In this section, we will learn how to configure the server through a configuration file.'\n\n\n## Configuring the server through an environment file\n\nBatman wanted to configure the server through an environment file. Changing code continuously induced the risk of error.\n\n## Environment Variables\n\n - `ROBYN_PORT`: Specifies the port on which the Robyn server will listen.\n - Default: `8080`\n - Example: `ROBYN_PORT=3000`\n - `ROBYN_HOST`: Specifies the host address for the Robyn server.\n - Default: `127.0.0.1`\n - Example: `ROBYN_HOST=0.0.0.0`\n - `ROBYN_BROWSER_OPEN`: Open the browser on successful start.\n - Default: `False`\n - Example: `ROBYN_BROWSER_OPEN=True`\n - `ROBYN_DEV_MODE`: Configures the dev mode\n - Default: `False`\n - Example: `ROBYN_DEV_MODE=True`\n - `ROBYN_MAX_PAYLOAD_SIZE`: Sets the maximum payload size for HTTP requests and WebSocket messages in bytes.\n - Default: `1000000` bytes\n - Example: `ROBYN_MAX_PAYLOAD_SIZE=1000000`\n\nYou can have a `robyn.env` file to load them automatically in your environment.\n\nThese environment variables are typically set in a `robyn.env` file located at the root of the project. The server parses this file at startup to configure itself accordingly.\n\nFor more details on the structure and usage of the `robyn.env` file, refer to the documentation snippet:\n\n```bash {{title: 'Sample project directory'}}\n--project/\n --robyn.env\n --index.py\n ...\n```\n\nSample `robyn.env` file:\n\n```bash {{ title: 'Sample Robyn.env' }}\nROBYN_PORT=8080\nROBYN_HOST=127.0.0.1\nRANDOM_ENV=123\nROBYN_BROWSER_OPEN=True\nROBYN_DEV_MODE=True\nROBYN_MAX_PAYLOAD_SIZE=1000000\n```\n\nWith the web application deployed and running smoothly, Batman had a powerful new tool at his disposal. The Robyn framework had provided him with the flexibility, scalability, and performance needed to create an effective crime-fighting application, giving him a technological edge in his ongoing battle to protect Gotham City.\n\n\n## What's next?\n\nBatman - Thanks, Robyn. Now tell me more.\nRobyn - Let us learn about the Middlewares and events now!\n\n- [Middlewares](/documentation/en/api_reference/middlewares)\n\n"
},
{
"path": "docs_src/src/pages/documentation/en/api_reference/scaling.mdx",
"content": "export const description =\n 'Comprehensive guide to scaling Robyn applications from development to production, including multi-process configuration, load balancing, and deployment strategies.'\n\n# Scaling and Production Deployment\n\nRobyn is designed to scale efficiently from development to production. This guide covers scaling strategies, production deployment patterns, and performance optimization techniques.\n\n## Understanding Robyn's Scaling Model\n\n### Multi-Process Architecture\n\nRobyn uses a **shared-nothing multi-process model** optimized for modern multi-core systems. Each process:\n- Runs independently with its own Python interpreter and memory space\n- Has its own Global Interpreter Lock (GIL), eliminating GIL contention\n- Can handle multiple concurrent requests via worker threads\n- Scales linearly across CPU cores for true parallelism\n- Provides fault isolation - one process crash doesn't affect others\n\n### Worker Threads\n\nWithin each process, multiple worker threads provide concurrency:\n- Share the same Python interpreter and memory space\n- Are subject to the GIL for CPU-bound tasks (use more processes for CPU work)\n- Excel at I/O-bound operations where threads can release the GIL\n- Handle database calls, HTTP requests, file operations efficiently\n- Provide request-level concurrency within the same process\n\n## Scaling Configuration\n\n### Basic Scaling\n\n\n
\n **Single Process Development**: Start simple during development with auto-reload enabled.\n \n
\n \n ```bash\n # Development mode (single process, single worker)\n python app.py --dev\n \n # Development with custom port\n python app.py --dev --port 3000\n ```\n \n \n\n\n\n
\n **Multi-Core Production**: Scale across all available CPU cores for maximum performance.\n \n
\n **Load Testing**: Use tools like wrk, Apache Bench, or Locust to test different configurations and find optimal settings.\n \n
\n \n ```bash\n # Install wrk for load testing\n # macOS: brew install wrk\n # Ubuntu: sudo apt install wrk\n \n # Test baseline performance\n wrk -t4 -c100 -d30s http://localhost:8080/health\n \n # Test with different configurations\n # Configuration 1: Single process\n python app.py --processes 1 --workers 1 &\n wrk -t4 -c100 -d30s http://localhost:8080/api/endpoint\n \n # Configuration 2: Multi-process\n python app.py --processes 4 --workers 2 &\n wrk -t4 -c100 -d30s http://localhost:8080/api/endpoint\n \n # Configuration 3: Fast mode\n python app.py --fast &\n wrk -t4 -c100 -d30s http://localhost:8080/api/endpoint\n \n # Compare results and choose the best configuration\n ```\n \n ```python\n # Python script for automated testing\n import subprocess\n import time\n import requests\n \n def test_configuration(processes, workers, duration=30):\n # Start server\n cmd = f\"python app.py --processes {processes} --workers {workers}\"\n server = subprocess.Popen(cmd.split())\n time.sleep(2) # Wait for startup\n \n try:\n # Run load test\n wrk_cmd = f\"wrk -t4 -c100 -d{duration}s http://localhost:8080/health\"\n result = subprocess.run(wrk_cmd.split(), capture_output=True, text=True)\n return result.stdout\n finally:\n server.terminate()\n time.sleep(1)\n \n # Test different configurations\n configs = [(1, 1), (2, 2), (4, 1), (4, 2), (8, 1)]\n for processes, workers in configs:\n print(f\"\\nTesting: {processes} processes, {workers} workers\")\n result = test_configuration(processes, workers)\n print(result)\n ```\n \n \n\n\n### Environment Variables\n\n\n
\n **Configuration via Environment**: Use environment variables for deployment flexibility.\n \n
\n \n ```bash\n # Production environment variables\n export ROBYN_HOST=0.0.0.0\n export ROBYN_PORT=8080\n export ROBYN_LOG_LEVEL=INFO\n export ROBYN_PROCESSES=4\n export ROBYN_WORKERS=2\n \n # Database configuration\n export DATABASE_URL=postgresql://user:pass@localhost/db\n export REDIS_URL=redis://localhost:6379/0\n \n # Application settings\n export SECRET_KEY=your-secret-key\n export DEBUG=false\n export ENVIRONMENT=production\n \n # Start application with environment config\n python app.py\n ```\n \n ```python\n # app.py - Using environment variables\n import os\n from robyn import Robyn\n \n app = Robyn(__file__)\n \n # Configuration from environment\n HOST = os.getenv(\"ROBYN_HOST\", \"127.0.0.1\")\n PORT = int(os.getenv(\"ROBYN_PORT\", \"8080\"))\n PROCESSES = int(os.getenv(\"ROBYN_PROCESSES\", \"1\"))\n WORKERS = int(os.getenv(\"ROBYN_WORKERS\", \"1\"))\n LOG_LEVEL = os.getenv(\"ROBYN_LOG_LEVEL\", \"INFO\")\n \n if __name__ == \"__main__\":\n app.start(\n host=HOST,\n port=PORT,\n processes=PROCESSES,\n workers=WORKERS,\n log_level=LOG_LEVEL\n )\n ```\n \n \n\n\n---\n\n## What's next?\n\nNow, Batman wanted to extend Robyn. Robyn told him about the advanced features.\n\n- [Advanced Features](/documentation/en/api_reference/advanced_features)\n\n"
},
{
"path": "docs_src/src/pages/documentation/en/api_reference/server_sent_events.mdx",
"content": "export const description =\n 'Learn how to implement Server-Sent Events (SSE) in Robyn for real-time server-to-client communication.'\n\n# Server-Sent Events (SSE)\n\nAfter learning about [form data handling](/documentation/en/api_reference/form_data), Batman realized he needed a way to push real-time updates to his crime monitoring dashboard. Criminals don't wait for Batman to refresh his browser!\n\nHe discovered Server-Sent Events (SSE) - a perfect solution for one-way communication from server to client over HTTP. SSE allows Batman to stream live data to his dashboard without the complexity of full bidirectional communication.\n\n\"This is exactly what I need for my crime alerts!\" Batman exclaimed. \"I can push updates to the dashboard instantly when new crimes are detected.\"\n\nServer-Sent Events are ideal for:\n- Real-time notifications\n- Live data feeds\n- Progress updates\n- Chat applications (server-to-client only)\n- Dashboard updates\n- Log streaming\n\n## How does it work?\n\n\n
\n\nBatman can create Server-Sent Events streams by using the `SSEResponse` and `SSEMessage` classes. He can use both regular generators and async generators depending on his needs:\n\n- **Regular generators**: Perfect for simple data streams or when working with synchronous operations\n- **Async generators**: Ideal when Batman needs to perform async operations like database queries or API calls within the stream\n\n\n\n
\n\n\n\n```python {{ title: 'Basic SSE Stream' }}\nfrom robyn import Robyn, SSEResponse, SSEMessage\nimport time\n\napp = Robyn(__file__)\n\n@app.get(\"/events\")\ndef stream_events(request):\n def event_generator():\n for i in range(10):\n yield SSEMessage(f\"Event {i}\", id=str(i))\n time.sleep(1)\n \n return SSEResponse(event_generator())\n```\n```python {{ title: 'JSON Data Stream' }}\nfrom robyn import Robyn, SSEResponse, SSEMessage\nimport json\nimport time\n\napp = Robyn(__file__)\n\n@app.get(\"/events/json\")\ndef stream_json_events(request):\n def json_event_generator():\n for i in range(5):\n data = {\n \"id\": i,\n \"message\": f\"Update {i}\",\n \"timestamp\": time.time()\n }\n yield SSEMessage(\n json.dumps(data), \n event=\"update\", \n id=str(i)\n )\n time.sleep(2)\n return SSEResponse(json_event_generator())\n```\n\n```python {{ title: 'Async Generator Stream' }}\nfrom robyn import Robyn, SSEResponse, SSEMessage\nimport asyncio\nimport time\n\napp = Robyn(__file__)\n\n@app.get(\"/events/async\")\nasync def stream_async_events(request):\n async def async_event_generator():\n for i in range(8):\n # Simulate async work like database calls\n await asyncio.sleep(0.5)\n yield SSEMessage(\n f\"Async message {i} - {time.strftime('%H:%M:%S')}\", \n event=\"async\", \n id=str(i)\n )\n \n return SSEResponse(async_event_generator())\n```\n\n\n\n\n\n---\n\n## Async Generators\n\n\n
\n\nWhen Batman needs to perform async operations during his SSE streams - like fetching data from databases or making API calls - he uses async generators with `async def` and `await`. This allows him to handle multiple streams concurrently without blocking other operations.\n\nThe key difference is using `async def` for the generator function and `await` for async operations inside the generator:\n\n\n\n
\n\n\n\n```python {{ title: 'Database Stream' }}\nfrom robyn import Robyn, SSEResponse, SSEMessage\nimport asyncio\nimport json\nimport time\n\napp = Robyn(__file__)\n\n@app.get(\"/events/database\")\nasync def stream_database_events(request):\n async def database_event_generator():\n for i in range(10):\n # Simulate async database query\n await asyncio.sleep(0.3)\n \n # Simulate fetching data from database\n data = {\n \"crime_id\": i,\n \"location\": f\"Gotham District {i}\",\n \"severity\": \"high\" if i % 2 == 0 else \"low\",\n \"timestamp\": time.time()\n }\n \n yield SSEMessage(\n json.dumps(data),\n event=\"crime_alert\",\n id=str(i)\n )\n \n return SSEResponse(database_event_generator())\n```\n\n```python {{ title: 'API Integration Stream' }}\nfrom robyn import Robyn, SSEResponse, SSEMessage\nimport asyncio\nimport aiohttp\nimport json\n\napp = Robyn(__file__)\n\n@app.get(\"/events/api\")\nasync def stream_api_events(request):\n async def api_event_generator():\n async with aiohttp.ClientSession() as session:\n for i in range(5):\n try:\n # Make async API call\n async with session.get(f\"https://api.example.com/data/{i}\") as response:\n data = await response.json()\n \n yield SSEMessage(\n json.dumps(data),\n event=\"api_update\",\n id=str(i)\n )\n except Exception as e:\n yield SSEMessage(\n f\"Error fetching data: {str(e)}\",\n event=\"error\",\n id=f\"error_{i}\"\n )\n \n await asyncio.sleep(1)\n \n return SSEResponse(api_event_generator())\n```\n\n\n\n\n\n---\n\n## What's next?\n\nBatman has mastered Server-Sent Events and can now stream real-time updates to his crime dashboard. While SSE is perfect for one-way communication from server to client, Batman realizes he needs bidirectional communication for more interactive features like real-time chat with his allies.\n\nNext, he wants to explore how to handle bidirectional communication with [WebSockets](/documentation/en/api_reference/websockets) for more interactive features.\n\nIf Batman needs to handle unexpected situations, he'll learn about [Exception handling](/documentation/en/api_reference/exceptions) to make his applications more robust.\n\nFor scaling his crime monitoring system across multiple processes, Batman will explore [Scaling the Application](/documentation/en/api_reference/scaling).\n\n"
},
{
"path": "docs_src/src/pages/documentation/en/api_reference/templating.mdx",
"content": "export const description =\n 'On this page, we’ll dive into the different conversation endpoints you can use to manage conversations programmatically.'\n\n\n\n## Templating.\n\nBatman wanted to quickly render html pages on the website. He wanted to use a templating engine to render the html pages. Robyn told him that he can use the Jinja2 templating engine to render the html pages. He can use the `JinjaTemplate` class to render the html pages.\n\n\n\n
\nBatman was excited to learn that he could add events as functions as well as decorators.\n\n
\n \n\n ```html\n \n \n \n \n Results\n \n\n \n Hello {{ framework }}! You're using {{ templating_engine }}.\n \n ```\n \n \n\n\n\n## Supporting Custom Templating Engines\n\nBatman was also super excited to know that Robyn allows the support of custom templating engines.\n\n\n
\nTo do that, you need to import the `TemplateInterface` from `robyn.templating`\n\n
\n \n\n ```python\n from robyn.templating import TemplateInterface\n ```\n \n \n\n\n\n\n
\nThen You need to have a `render_template` method inside your implementation. So, an example would look like the following:\n\n
\n \n\n ```python\n class JinjaTemplate(TemplateInterface):\n def __init__(self, directory, encoding=\"utf-8\", followlinks=False):\n self.env = Environment(\n loader=FileSystemLoader(\n searchpath=directory, encoding=encoding, followlinks=followlinks\n )\n )\n\n def render_template(self, template_name: str, **kwargs):\n return self.env.get_template(template_name).render(**kwargs)\n ```\n \n \n\n\n\n\n## What's next?\n\nNow, Batman wanted to have the ability to redirect the endpoints.\n\n- [Redirection](/documentation/en/api_reference/redirection)\n"
},
{
"path": "docs_src/src/pages/documentation/en/api_reference/timeout_configuration.mdx",
"content": "export const description =\n 'Configure timeout settings to handle high-concurrency scenarios and prevent resource exhaustion.'\n\n# Timeout Configuration\n\nRobyn supports comprehensive timeout configuration to handle high-concurrency scenarios and prevent resource exhaustion like the \"Too many open files\" error. {{ className: 'lead' }}\n\n## Configuration Options\n\n### Method Parameters\n\nConfigure timeouts directly in the `app.start()` method:\n\n```python\nfrom robyn import Robyn\n\napp = Robyn(__file__)\n\n@app.get(\"/\")\nasync def hello(request):\n return \"Hello, world!\"\n\n# Configure timeout settings\napp.start(\n host=\"0.0.0.0\", \n port=8080,\n client_timeout=30, # Client connection timeout (seconds)\n keep_alive_timeout=20 # Keep-alive timeout (seconds)\n)\n```\n\n### Environment Variables\n\nOverride configuration using environment variables:\n\n```bash\n# Set timeout configurations\nexport ROBYN_CLIENT_TIMEOUT=45\nexport ROBYN_KEEP_ALIVE_TIMEOUT=30\n\n# Start your application\npython app.py\n```\n\n## Configuration Parameters\n\n| Parameter | Default | Description | Environment Variable |\n|-----------|---------|-------------|---------------------|\n| `client_timeout` | 30 | Maximum time (seconds) for client request processing | `ROBYN_CLIENT_TIMEOUT` |\n| `keep_alive_timeout` | 20 | Time (seconds) to keep idle connections alive | `ROBYN_KEEP_ALIVE_TIMEOUT` |\n\n## Usage Examples\n\n### Basic Configuration\n\n```python\n# Minimal timeout configuration\napp.start(client_timeout=30)\n```\n\n### High-Traffic Production Setup\n\n```python\n# Optimized for high-traffic scenarios\napp.start(\n host=\"0.0.0.0\",\n port=8080,\n client_timeout=60, # Allow longer processing time\n keep_alive_timeout=15 # Shorter keep-alive for faster turnover\n)\n```\n\n### Development Setup\n\n```python\n# Development-friendly settings\napp.start(\n client_timeout=300, # Long timeout for debugging\n keep_alive_timeout=60 # Longer keep-alive for testing\n)\n```\n\n### Load Testing Configuration\n\n```python\n# Optimized for load testing with tools like wrk\napp.start(\n client_timeout=10, # Quick timeouts\n keep_alive_timeout=5 # Fast connection turnover\n)\n```\n\n## Environment Variable Priority\n\nEnvironment variables take precedence over method parameters:\n\n```python\n# This will use ROBYN_CLIENT_TIMEOUT=60 if set, otherwise 30\napp.start(client_timeout=30)\n```\n\n## Troubleshooting\n\n### \"Too Many Open Files\" Error\n\nIf you encounter file descriptor exhaustion:\n\n1. **Increase system limits:**\n ```bash\n ulimit -n 65536\n ```\n\n2. **Optimize timeout settings:**\n ```python\n app.start(\n client_timeout=15, # Shorter timeouts\n keep_alive_timeout=5 # Faster connection cleanup\n )\n ```\n\n3. **Use environment variables for deployment:**\n ```bash\n export ROBYN_CLIENT_TIMEOUT=15\n export ROBYN_KEEP_ALIVE_TIMEOUT=5\n ```\n\n### Performance Tuning\n\n**For high-throughput APIs:**\n- Lower `keep_alive_timeout` (5-15s)\n- Moderate `client_timeout` (15-30s)\n\n**For long-running operations:**\n- Higher `client_timeout` (60-300s)\n- Standard `keep_alive_timeout` (20-30s)\n\n\n## Best Practices\n\n1. **Always set explicit timeouts** in production\n2. **Use environment variables** for deployment-specific configuration\n3. **Test timeout settings** with realistic load patterns\n4. **Start with conservative values** and tune based on metrics\n\n## Migration Guide\n\n### From Previous Versions\n\nIf upgrading from earlier Robyn versions, the default behavior changes:\n\n**Before (infinite timeout):**\n```python\n# Previously: no timeout (could cause resource exhaustion)\napp.start(host=\"0.0.0.0\", port=8080)\n```\n\n**After (sensible defaults):**\n```python\n# Now: automatic 30s client timeout, 20s keep-alive\napp.start(host=\"0.0.0.0\", port=8080)\n# Equivalent to:\napp.start(\n host=\"0.0.0.0\", \n port=8080,\n client_timeout=30,\n keep_alive_timeout=20\n)\n```"
},
{
"path": "docs_src/src/pages/documentation/en/api_reference/using_rust_directly.mdx",
"content": "\n## Using Rust to extend Robyn\n\n\nThere may be occasions where Batman may be working with a high computation task, or a task that requires a lot of memory. In such cases, he may want to use Rust to implement that task. Robyn introduces a special way to do this. Not only you can use Rust to extend Python code, you can do it while maintaining the hot reloading nature of your codebase. Making it *feel* like an interpreted version in many situations.\n\n\n\n\n
\nThe first thing you need to is to create a Rust file. Let's call it `hello_world.rs`. You can do it using the cli:\n\n
\n Then you can open the file and write your Rust code. For example, let's write a function that returns a string.\n\n\n \n
\n \n\n ```rust\n // hello_world.rs\n\n // rustimport:pyo3\n\n use pyo3::prelude::*;\n\n #[pyfunction]\n fn square(n: i32) -> i32 {\n n * n\n // this is another comment\n }\n\n ```\n\n \n \n\n\n\n\n
\n Every Rust file that you create using the cli will have a special comment at the top of the file. This comment is used by Robyn to know which dependencies to import. In this case, we are importing the `pyo3` crate. You can import as many crates as you want. You can also import crates from crates.io. For example, if you want to use the `rusqlite` crate, you can do it like this:\n\n\n\n \n
\n \n\n ```rust\n // rustimport:pyo3\n\n //:\n //: [dependencies]\n //: rusqlite = \"0.19.0\"\n\n use pyo3::prelude::*;\n\n #[pyfunction]\n fn square(n: i32) -> i32 {\n n * n * n\n // this is another comment\n }\n\n ```\n\n \n \n\n\n\n\n Then you can import the function in your Python code and use it.\n\n
\n \n\n ```python\n from hello_world import square\n\n print(square(5))\n ```\n \n \n\n To run the code, you need to use the `--compile-rust-path` flag. This will compile the Rust code and run it. You can also use the `--dev` flag to watch for changes in the Rust code and recompile it on the fly.\n\n
\n \n\n ```python\n python -m robyn --compile-rust-path \".\" --dev\n ```\n \n\n \n\n\nAn example of a Robyn app with a Rust file that using the `rusqlite` crate to connect to a database and return the number of rows in a table: https://github.com/sansyrox/rusty-sql\n\n\n## What's next?\n\n\nBatman was curious to know what else he could do with Robyn. \n\nRobyn told him to keep an eye on the GraphQl support.\n\n[GraphQl Support](/documentation/en/api_reference/graphql_support)\n\n\n\n\n\n\n\n"
},
{
"path": "docs_src/src/pages/documentation/en/api_reference/websockets.mdx",
"content": "export const description =\n 'Learn how to use Robyn\\'s WebSocket API for real-time, bidirectional communication — including message streaming, connect/close callbacks, broadcasting, and common patterns like live updates, presence tracking, and low-latency messaging.'\n\n\n## WebSockets {{ tag: 'WebSockets', label: 'WebSockets' }}\n\n\n
\nAfter mastering [Server-Sent Events](/documentation/en/api_reference/server_sent_events) for one-way communication, Batman realized he needed something more powerful. When Commissioner Gordon wanted to chat with him in real-time during crisis situations, Batman needed bidirectional communication.\n\n\"SSE is great for pushing updates to my dashboard,\" Batman thought, \"but I need two-way communication for coordinating with my allies!\"\n\nTo handle real-time bidirectional communication, Batman learned how to work with WebSockets using Robyn's modern decorator-based API. Under the hood, messages flow through Rust channels for maximum performance — no Python GIL overhead during message dispatch.\n\n
\n The `receive_text()` method blocks until the next message arrives from the client. It is backed by a Rust `tokio::mpsc` channel, so the Python handler genuinely suspends without holding the GIL.\n\n When the client disconnects, `receive_text()` raises `WebSocketDisconnect`. You can either catch it explicitly or let the internal wrapper handle it silently.\n \n
\n To send a message to all connected clients on the same WebSocket endpoint, use the `broadcast()` method.\n \n
\n \n\n ```python {{ title: 'Broadcast' }}\n @app.websocket(\"/chat\")\n async def handler(websocket):\n while True:\n msg = await websocket.receive_text()\n # Send to all connected clients\n await websocket.broadcast(f\"User {websocket.id}: {msg}\")\n # Also send a confirmation to this client only\n await websocket.send_text(\"Your message was sent\")\n ```\n \n \n\n\n---\n\n## Query Parameters {{ tag: 'query_params', label: 'query_params' }}\n\n\n
\n You can access query parameters from the WebSocket connection URL via `websocket.query_params`.\n \n
\n \n\n ```python {{ title: 'Query Params' }}\n @app.websocket(\"/ws\")\n async def handler(websocket):\n name = websocket.query_params.get(\"name\")\n role = websocket.query_params.get(\"role\")\n\n if name == \"gordon\" and role == \"commissioner\":\n await websocket.broadcast(\"Gordon authorized!\")\n\n while True:\n msg = await websocket.receive_text()\n await websocket.send_text(f\"Hello {name}: {msg}\")\n ```\n \n \n\n\n---\n\n## Easy Access Query Parameters {{ tag: 'easy_access', label: 'easy_access' }}\n\n\n
\n Instead of manually calling `websocket.query_params.get(...)`, you can declare typed query parameters directly in your handler, `on_connect`, and `on_close` signatures. Robyn will automatically resolve and coerce them — just like HTTP easy access parameters.\n\n Parameters with defaults are optional. Parameters without defaults are required — if missing, the connection is rejected with an error message.\n \n
\n To programmatically close a WebSocket connection from the server side, use `websocket.close()`. This will:\n1. Close the WebSocket connection.\n2. Remove the client from the WebSocket registry.\n3. Cause any pending `receive_text()` to raise `WebSocketDisconnect`.\n \n
\n You can attach optional `on_connect` and `on_close` callbacks to your WebSocket handler. These are decorators on the handler function itself.\n\n - `on_connect` is called when a new client connects. Its return value is sent to the client as the first message.\n - `on_close` is called when the connection closes. Its return value is sent to the client as the final message.\n\n Both callbacks receive a `websocket` object with access to `id` and `query_params`. Both are optional.\n \n
\n The `websocket` object passed to handlers exposes the following methods and properties:\n\n | Method / Property | Description |\n |---|---|\n | `await websocket.receive_text()` | Block until next message; raises `WebSocketDisconnect` on close |\n | `await websocket.receive_bytes()` | Block until next binary message; raises `WebSocketDisconnect` on close |\n | `await websocket.receive_json()` | Same as `receive_text()` but JSON-decoded |\n | `await websocket.send_text(data)` | Send string to this client |\n | `await websocket.send_bytes(data)` | Send binary data to this client |\n | `await websocket.send_json(data)` | Send JSON to this client |\n | `await websocket.broadcast(data)` | Send to all clients on this endpoint |\n | `await websocket.close()` | Close the connection server-side |\n | `websocket.id` | Connection UUID string |\n | `websocket.query_params` | Query parameters from the connection URL |\n \n\n\n---\n\n## What's next?\n\nAs the codebase grew, Batman wanted to onboard the justice league to help him manage the application. \n\nRobyn told him about the different ways he could scale his application, and how to use views and subrouters to make his code more readable. \n\n\n- [Views and SubRouters](/documentation/en/api_reference/views)\n\n\n"
},
{
"path": "docs_src/src/pages/documentation/en/api_reference/zh/getting_started.mdx",
"content": "export const description =\n '开始使用Robyn构建您的第一个应用程序。'\n\n# 入门指南\n\n## 创建您的第一个Robyn应用程序\n\n让我们从创建一个简单的Robyn应用程序开始。首先，使用pip安装Robyn：\n\n```bash\npip install robyn\n```\n\n然后，创建一个新的Python文件 `app.py`：\n\n```python\nfrom robyn import Robyn\n\napp = Robyn(__file__)\n\n@app.get(\"/\")\nasync def hello_world():\n return \"Hello, World!\"\n\nif __name__ == \"__main__\":\n app.start()\n```\n\n现在运行您的应用程序：\n\n```bash\npython app.py\n```\n\n访问 `http://localhost:8080`，您应该能看到 \"Hello, World!\" 消息。\n\n## 命令行选项\n\nRobyn提供了多个命令行选项来配置您的应用程序：\n\n```bash\npython app.py --help\n```\n\n输出将显示所有可用选项：\n\n```text\noptions:\n -h, --help 显示帮助信息\n --processes PROCESSES\n 选择进程数量。[默认值: 1]\n --workers WORKERS 选择工作线程数量。[默认值: 1]\n --dev 开发模式。根据文件更改自动重启服务器。\n --log-level LOG_LEVEL\n 设置日志级别\n --create 创建新项目模板。\n --docs 打开Robyn文档。\n --open-browser 成功启动时打开浏览器。\n --version 显示Robyn版本。\n --compile-rust-path COMPILE_RUST_PATH\n 编译指定路径中的rust文件。\n --create-rust-file CREATE_RUST_FILE\n 创建指定名称的rust文件。\n --disable-openapi 禁用OpenAPI文档。\n --fast 快速模式。设置最优的进程、工作线程和日志级别。但您可以覆盖这些设置。\n```\n\n## 路由装饰器\n\nRobyn支持所有标准的HTTP方法：\n\n```python\n@app.get(\"/users\")\nasync def get_users():\n return {\"users\": [\"user1\", \"user2\"]}\n\n@app.post(\"/users\")\nasync def create_user(request):\n return {\"message\": \"用户已创建\"}\n\n@app.put(\"/users/:id\")\nasync def update_user(request):\n return {\"message\": \"用户已更新\"}\n\n@app.delete(\"/users/:id\")\nasync def delete_user(request):\n return {\"message\": \"用户已删除\"}\n```\n\n## 请求参数\n\n您可以通过多种方式访问请求数据：\n\n```python\n@app.post(\"/api/data\")\nasync def handle_data(request):\n # 访问JSON数据\n json_data = request.json()\n \n # 访问查询参数\n query_params = request.query_params\n \n # 访问路径参数\n path_params = request.path_params\n \n # 访问请求头\n headers = request.headers\n \n return {\n \"json\": json_data,\n \"query\": query_params,\n \"path\": path_params,\n \"headers\": headers\n }\n```\n\n## 响应类型\n\nRobyn支持多种响应类型：\n\n```python\nfrom robyn import Response, jsonify\n\n@app.get(\"/text\")\nasync def text_response():\n return \"纯文本响应\"\n\n@app.get(\"/json\")\nasync def json_response():\n return jsonify({\"message\": \"JSON响应\"})\n\n@app.get(\"/custom\")\nasync def custom_response():\n return Response(\n status_code=201,\n description=\"自定义响应\",\n headers={\"Content-Type\": \"text/plain\"}\n )\n``` "
},
{
"path": "docs_src/src/pages/documentation/en/architecture.mdx",
"content": "export const description = 'Robyn is a Python web server that employs the tokio runtime and leverages a blend of Python and Rust, enabling efficient request handling through a worker event cycle, multi-core scaling, and introducing \"Const Requests\" for optimized, cached responses in a multi-threaded environment.'\n\n\n## Robyn Architecture Overview\n\nRobyn's unique architecture combines Python's ease of development with Rust's performance. This hybrid design allows developers to write familiar Python code while benefiting from Rust's speed and memory safety.\n\n## The Python-Rust Hybrid Design\n\n### Two-Layer Architecture\n\nRobyn operates on two interconnected but distinct layers:\n\n**Python Layer (Developer Interface)**:\n- Route definitions and decorators (`@app.get`, `@app.post`, etc.)\n- Request parameter injection and validation\n- Business logic execution\n- Middleware configuration\n- Response formatting\n\n**Rust Layer (Performance Engine)**:\n- HTTP request parsing and validation\n- URL routing and pattern matching\n- WebSocket connection management \n- Static file serving\n- Response serialization\n- Memory management\n\n### Communication Bridge\n\nThe layers communicate through **PyO3**, a Rust crate that enables seamless Python-Rust interoperability:\n\n1. **Function Registration**: Python route handlers are registered with the Rust runtime at startup\n2. **Request Flow**: Rust handles incoming HTTP requests and calls Python handlers via PyO3\n3. **Response Processing**: Python responses are converted back to Rust for efficient HTTP serialization\n\n### Why This Design Works\n\n- **Best of Both Worlds**: Python's productivity with Rust's performance\n- **Zero-Copy Operations**: Minimal data copying between layers\n- **Memory Safety**: Rust prevents common server vulnerabilities\n- **Async Integration**: Seamless integration with Python's asyncio\n\n## Server Process Model\n\nRobyn is built on a multi-process, multi-threaded model that maximizes hardware utilization:\n\n## Master Process\n\nThe master process in Robyn is responsible for initializing the server, managing worker processes, and handling signals. It creates a socket and passes it to the worker processes, allowing them to accept connections. The master process is implemented in Python, providing a familiar interface for developers while leveraging Rust's performance for core operations.\n\n\n```python\n216:257:robyn/__init__.py\n def start(self, host: str = \"127.0.0.1\", port: int = 8080, _check_port: bool = True):\n \"\"\"\n Starts the server\n\n :param host str: represents the host at which the server is listening\n :param port int: represents the port number at which the server is listening\n :param _check_port bool: represents if the port should be checked if it is already in use\n \"\"\"\n\n host = os.getenv(\"ROBYN_HOST\", host)\n port = int(os.getenv(\"ROBYN_PORT\", port))\n open_browser = bool(os.getenv(\"ROBYN_BROWSER_OPEN\", self.config.open_browser))\n\n if _check_port:\n while self.is_port_in_use(port):\n logger.error(\"Port %s is already in use. Please use a different port.\", port)\n try:\n port = int(input(\"Enter a different port: \"))\n except Exception:\n logger.error(\"Invalid port number. Please enter a valid port number.\")\n continue\n\n logger.info(\"Robyn version: %s\", __version__)\n logger.info(\"Starting server at http://%s:%s\", host, port)\n\n mp.allow_connection_pickling()\n\n run_processes(\n host,\n port,\n self.directories,\n self.request_headers,\n self.router.get_routes(),\n self.middleware_router.get_global_middlewares(),\n self.middleware_router.get_route_middlewares(),\n self.web_socket_router.get_routes(),\n self.event_handlers,\n self.config.workers,\n self.config.processes,\n self.response_headers,\n open_browser,\n )\n```\n\n\n## Worker Processes\n\nRobyn uses multiple worker processes to handle incoming requests. Each worker process is capable of managing multiple threads, allowing for efficient concurrent processing. The number of worker processes can be configured using the `--processes` flag, with a default of 1.\n\n\n```python\n66:116:robyn/processpool.py\ndef init_processpool(\n directories: List[Directory],\n request_headers: Headers,\n routes: List[Route],\n global_middlewares: List[GlobalMiddleware],\n route_middlewares: List[RouteMiddleware],\n web_sockets: Dict[str, WebSocket],\n event_handlers: Dict[Events, FunctionInfo],\n socket: SocketHeld,\n workers: int,\n processes: int,\n response_headers: Headers,\n) -> List[Process]:\n process_pool = []\n if sys.platform.startswith(\"win32\") or processes == 1:\n spawn_process(\n directories,\n request_headers,\n routes,\n global_middlewares,\n route_middlewares,\n web_sockets,\n event_handlers,\n socket,\n workers,\n response_headers,\n )\n\n return process_pool\n\n for _ in range(processes):\n copied_socket = socket.try_clone()\n process = Process(\n target=spawn_process,\n args=(\n directories,\n request_headers,\n routes,\n global_middlewares,\n route_middlewares,\n web_sockets,\n event_handlers,\n copied_socket,\n workers,\n response_headers,\n ),\n )\n process.start()\n process_pool.append(process)\n\n return process_pool\n```\n\n\n## Worker Threads\n\nWithin each worker process, Robyn utilizes multiple threads to handle requests concurrently. The number of worker threads can be configured using the `--workers` flag. By default, Robyn uses a single worker thread per process.\n\n## Request Processing Flow\n\nUnderstanding how requests flow through Robyn's hybrid architecture:\n\n### 1. Request Arrival\n```\nHTTP Request → Rust HTTP Parser → Fast Validation\n```\n\n### 2. Routing and Matching\n```\nValidated Request → Rust Router (matchit crate) → Route Resolution\n```\n\n### 3. Parameter Extraction\n```\nMatched Route → Rust Parameter Parser → Path/Query/Header Extraction\n```\n\n### 4. Python Handler Execution\n```\nExtracted Parameters → PyO3 Bridge → Python Handler → Response\n```\n\n### 5. Response Processing\n```\nPython Response → Rust Serializer → HTTP Response → Client\n```\n\n## Rust Integration Deep Dive\n\nRobyn's Rust integration is powered by the **Tokio** async runtime and several high-performance crates:\n\n### Core Components\n\n- **Tokio Runtime**: Handles async I/O and task scheduling\n- **Actix Web**: Provides HTTP server functionality\n- **PyO3**: Enables Python-Rust communication\n- **matchit**: Ultra-fast URL routing with radix tree implementation\n- **Serde**: JSON serialization/deserialization\n\n### Performance Benefits\n\n1. **Zero-allocation routing** using compiled radix trees\n2. **Memory-efficient HTTP parsing** with minimal allocations\n3. **Async task scheduling** without GIL interference\n4. **Direct memory access** for static file serving\n\n\n```python\n76:107:src/server.rs\n pub fn start(\n &mut self,\n py: Python,\n socket: &PyCell,\n workers: usize,\n ) -> PyResult<()> {\n pyo3_log::init();\n\n if STARTED\n .compare_exchange(false, true, SeqCst, Relaxed)\n .is_err()\n {\n debug!(\"Robyn is already running...\");\n return Ok(());\n }\n\n let raw_socket = socket.try_borrow_mut()?.get_socket();\n\n let router = self.router.clone();\n let const_router = self.const_router.clone();\n let middleware_router = self.middleware_router.clone();\n let web_socket_router = self.websocket_router.clone();\n let global_request_headers = self.global_request_headers.clone();\n let global_response_headers = self.global_response_headers.clone();\n let directories = self.directories.clone();\n\n let asyncio = py.import(\"asyncio\")?;\n let event_loop = asyncio.call_method0(\"new_event_loop\")?;\n asyncio.call_method1(\"set_event_loop\", (event_loop,))?;\n\n let startup_handler = self.startup_handler.clone();\n let shutdown_handler = self.shutdown_handler.clone();\n```\n\n\n## Const Requests Optimization\n\nRobyn's \"Const Requests\" feature provides significant performance improvements for static endpoints:\n\n### How Const Requests Work\n\n1. **Route Registration**: Routes marked with `const=True` are identified at startup\n2. **Response Caching**: The first response is cached in Rust memory\n3. **Direct Serving**: Subsequent requests bypass Python entirely\n4. **Zero Overhead**: Responses are served directly from Rust with minimal CPU usage\n\n### Performance Impact\n\n- **10x faster response times** compared to regular Python handlers\n- **Minimal memory usage** with efficient caching\n- **No Python GIL contention** for cached responses\n- **Ideal for**: Health checks, API metadata, configuration endpoints\n\n### Example Usage\n\n```python\nfrom robyn import Robyn\n\napp = Robyn(__file__)\n\n# Regular route - executes Python on every request\n@app.get(\"/dynamic\")\ndef dynamic_endpoint():\n return {\"timestamp\": time.time()} # Changes every request\n\n# Const route - cached in Rust after first request\n@app.get(\"/health\", const=True)\ndef health_check():\n return {\"status\": \"healthy\", \"version\": \"1.0.0\"} # Static response\n\n# Perfect for API metadata\n@app.get(\"/api/info\", const=True)\ndef api_info():\n return {\n \"name\": \"My API\",\n \"version\": \"2.1.0\",\n \"endpoints\": [\"/users\", \"/posts\", \"/health\"]\n }\n```\n\n### When to Use Const Routes\n\n- **Health/status endpoints** that return consistent data\n- **API documentation** or metadata endpoints\n- **Configuration endpoints** with static values\n- **Version information** endpoints\n\n## Scaling Configuration Guide\n\n### Understanding Processes vs Workers\n\n**Processes**:\n- Independent Python interpreters\n- Share no memory (shared-nothing architecture)\n- Each process has its own GIL\n- Best for CPU-bound applications\n- Recommended: 1 process per CPU core\n\n**Workers** (within each process):\n- Threads sharing the same Python interpreter\n- Affected by Python's GIL\n- Better for I/O-bound operations\n- Recommended: 2-4 workers per process\n\n### Configuration Strategies\n\n#### CPU-Intensive Applications\n```bash\n# Favor more processes, fewer workers\npython app.py --processes=8 --workers=1\n\n# Example: Image processing, data analysis, calculations\n```\n\n#### I/O-Intensive Applications \n```bash\n# Favor fewer processes, more workers\npython app.py --processes=2 --workers=8\n\n# Example: Database queries, API calls, file operations\n```\n\n#### Balanced Applications\n```bash\n# General-purpose configuration\npython app.py --processes=4 --workers=2\n\n# Most web applications fit this pattern\n```\n\n### Hardware-Based Recommendations\n\nFor a system with **N CPU cores**:\n\n| Application Type | Processes | Workers | Total Concurrency |\n|-----------------|-----------|---------|-------------------|\n| CPU-bound | N | 1 | N |\n| I/O-bound | N/2 | 4 | 2N |\n| Balanced | N/2 | 2 | N |\n| High-traffic | N | 2 | 2N |\n\n### Performance Testing\n\nAlways benchmark your specific application:\n\n```bash\n# Test different configurations\npython app.py --processes=1 --workers=1 # Baseline\npython app.py --processes=2 --workers=2 # Moderate scaling\npython app.py --processes=4 --workers=1 # CPU-focused\npython app.py --processes=2 --workers=4 # I/O-focused\npython app.py --fast # Auto-optimized\n```\n\n## Scaling Considerations\n\n- Robyn's multi-process model allows it to scale across multiple CPU cores effectively.\n- The combination of Python and Rust allows for both ease of development and high performance.\n- Const Requests feature can significantly improve performance for routes with constant output.\n- When scaling, consider both the number of processes and workers to find the optimal configuration for your hardware and application needs.\n\n## Development Mode\n\nRobyn provides a development mode that can be activated using the `--dev` flag. This mode is designed for ease of development and includes features like hot reloading. Note that in development mode, multi-process and multi-worker configurations are disabled to ensure consistent behavior during development.\n\n\n```python\n92:101:robyn/argument_parser.py\n if self.dev and (self.processes != 1 or self.workers != 1):\n raise Exception(\"--processes and --workers shouldn't be used with --dev\")\n\n if self.dev and args.log_level is None:\n self.log_level = \"DEBUG\"\n\n elif args.log_level is None:\n self.log_level = \"INFO\"\n else:\n self.log_level = args.log_level\n```\n\n\nBy understanding these design principles and adjusting the configuration accordingly, developers can leverage Robyn's unique architecture to build high-performance web applications that efficiently utilize system resources.\n\n\n## Design Diagram\n\n\n\n"
},
{
"path": "docs_src/src/pages/documentation/en/community-resources.mdx",
"content": "export const description =\n 'On this page, we`ll take a look at some community resources contributed by our amazing members to help developers get started with Robyn.'\n\n\n## Talks\n- [EuroPython 2022](https://www.youtube.com/watch?v=AutugvJNVkY&)\n- [GeoPython 2022](https://www.youtube.com/watch?v=YCpbCQwbkd4)\n- [PyCon US 2022](https://youtu.be/1IiL31tUEVk?t=2101)\n- [PyCon Sweden 2021](https://www.youtube.com/watch?v=DK9teAs72Do)\n\n## Blogs\n- [Hello, Robyn!](https://www.sanskar.me/posts/hello-robyn)\n\n\n## Next Steps\n\nBatman was now interes\n\n- [Hosting](/documentation/hosting)\n\n"
},
{
"path": "docs_src/src/pages/documentation/en/example_app/authentication-middlewares.mdx",
"content": "export const description =\n 'Welcome to the Robyn API documentation. You will find comprehensive guides and documentation to help you start working with Robyn as quickly as possible, as well as support if you get stuck.'\n\n## Authentication and Authorization Middleware\nBatman added middleware to the Robyn application to verify the JWT tokens and to restrict access to certain endpoints based on the user's role.\n\n\n```python {{ title: 'Setting up Authentication Middlewares' }}\nfrom robyn.authentication import AuthenticationHandler, BearerGetter, Identity\n\n\nclass BasicAuthHandler(AuthenticationHandler):\n def authenticate(self, request: Request):\n token = self.token_getter.get_token(request)\n\n try:\n payload = crud.decode_access_token(token)\n username = payload[\"sub\"]\n except Exception:\n return\n\n with SessionLocal() as db:\n user = crud.get_user_by_username(db, username=username)\n\n return Identity(claims={\"user\": f\"{ user }\"})\n\n\napp.configure_authentication(BasicAuthHandler(token_getter=BearerGetter()))\n\n\n@app.get(\"/users/me\", auth_required=True)\nasync def get_current_user(request):\n user = request.identity.claims[\"user\"]\n return user\n\n\n```\n\nWith the web application in place, the Gotham City Police Department could now efficiently manage crime data and track criminal activities in real-time. Batman had successfully used the Robyn web framework to build a real-world application to help fight crime in Gotham City.\n\n\n\n\n
\n \n
\n\n\n"
},
{
"path": "docs_src/src/pages/documentation/en/example_app/authentication.mdx",
"content": "export const description =\n 'Welcome to the Robyn API documentation. You will find comprehensive guides and documentation to help you start working with Robyn as quickly as possible, as well as support if you get stuck.'\n\n## Authentication and Authorization\nTo restrict access to the crime data, Batman added authentication and authorization to the application. He decided to use JWT (JSON Web Token) for authentication. He created a new table for users and added an endpoint for user registration.\n\n\n## User Model\n\nBatman added a new User model to represent the users who can access the application.\n\n\n```python {{ title: 'Example request with basic auth' }}\n# models.py\nfrom sqlalchemy import Column, Integer, String, Boolean\n\nclass User(Base):\n __tablename__ = \"users\"\n\n id = Column(Integer, primary_key=True, index=True)\n username = Column(String, unique=True, index=True)\n hashed_password = Column(String)\n\n \n def __repr__(self):\n return \"\".format(\n id=self.id,\n username=self.username,\n hashed_password=self.hashed_password,\n )\n\n\n```\n\nThen in crud.py, he added a new method to create a user.\n\n```python {{ title: 'Example request with basic auth' }}\n# crud.py\n# also need to do pip install passlib[bcrypt]\n\nfrom sqlalchemy.orm import Session\nfrom .models import User\n\nfrom passlib.context import CryptContext\n\npwd_context = CryptContext(schemes=[\"bcrypt\"], deprecated=\"auto\")\n\ndef get_password_hash(password: str) -> str:\n return pwd_context.hash(password)\n\ndef get_user(db: Session, user_id: int):\n return db.query(User).filter(User.id == user_id).first()\n\ndef create_user(db: Session, user: User):\n hashed_password = get_password_hash(user.password)\n db_user = User(username=user.username, hashed_password=hashed_password)\n db.add(db_user)\n db.commit()\n db.refresh(db_user)\n return db_user\n\n```\n\n\n## Authentication Utilities\n\nBatman created utility functions to handle authentication, including hashing passwords and verifying passwords.\n\n```python {{ title: 'Example request with bearer token' }}\n# crud.py\n# also need to do pip install passlib[bcrypt]\n# pip install \"python-jose[cryptography]\"\nfrom passlib.context import CryptContext\nfrom jose import JWTError, jwt\n\npwd_context = CryptContext(schemes=[\"bcrypt\"], deprecated=\"auto\")\n\ndef verify_password(plain_password, hashed_password):\n return pwd_context.verify(plain_password, hashed_password)\n\ndef get_password_hash(password):\n return pwd_context.hash(password)\n\nALGORITHM = \"HS256\"\nSECRET_KEY = \"your_secret_key\"\n\ndef create_access_token(data: dict, expires_delta: timedelta = None):\n to_encode = data.copy()\n if expires_delta:\n expire = datetime.utcnow() + expires_delta\n else:\n expire = datetime.utcnow() + timedelta(minutes=15)\n to_encode.update({\"exp\": expire})\n encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)\n return encoded_jwt\n\ndef decode_access_token(token: str):\n return jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])\n\n\ndef authenticate_user(db: Session, username: str, password: str):\n user = get_user_by_username(db, username)\n if user is None:\n return False\n if not verify_password(password, user.hashed_password):\n return False\n\n created_token = create_access_token(data={\"sub\": user.username})\n return created_token\n\n\n```\n\n\n## User Registration Endpoint\n\nBatman added a new endpoint to allow users to register.\n\n```python {{ title: 'Setting up Routes' }}\nfrom . import crud\n\n@app.post(\"/users/register\")\nasync def register_user(request):\n user = request.json()\n with SessionLocal() as db:\n created_user = crud.create_user(db, user)\n return created_user\n\n@app.post(\"/users/login\")\nasync def login_user(request):\n user = request.json()\n with SessionLocal() as db:\n token = crud.authenticate_user(db, **user)\n\n if token is None:\n raise HTTPException(status_code=401, detail=\"Invalid credentials\")\n\n\n return {\"access_token\": token}\n\n```\n\n
\n \n
\n\n"
},
{
"path": "docs_src/src/pages/documentation/en/example_app/deployment.mdx",
"content": "export const description =\n 'Welcome to the Robyn API documentation. You will find comprehensive guides and documentation to help you start working with Robyn as quickly as possible, as well as support if you get stuck.'\n\n\n## Deploying the Application\n\nAfter thoroughly testing the web application and ensuring that all features were working as expected, Batman decided it was time to deploy it to a production server. He chose to use a robust and scalable platform, ensuring that his application would be available and performant at all times.\n\n\n```python {{ title: 'Deploying the Application' }}\npython app.py --processes=n --workers=m\n```\n\nWith the web application deployed and running smoothly, Batman had a powerful new tool at his disposal. The Robyn framework had provided him with the flexibility, scalability, and performance needed to create an effective crime-fighting application, giving him a technological edge in his ongoing battle to protect Gotham City.\n\n\n
\n \n
\n\n\n\n"
},
{
"path": "docs_src/src/pages/documentation/en/example_app/index.mdx",
"content": "export const description =\n 'Welcome to the Robyn API documentation. You will find comprehensive guides and documentation to help you start working with Robyn as quickly as possible, as well as support if you get stuck.'\n\n# Real Life Web Apps with Robyn\n\nBatman was tasked with building a web application to manage the crime data in Gotham City. The application would allow the Gotham police department to store and retrieve data on criminal activities, suspects, and their locations. He decided to use the Robyn web framework to build this application efficiently and quickly.\n\nYou can find the source code for this application [here](https://github.com/sparckles/example_robyn_app).\n\n## Installing Robyn\n\nThe first step was to install Robyn. Batman created a virtual environment and installed Robyn using pip.\n\n```bash\n$ python3 -m venv venv\n$ source venv/bin/activate\n$ pip install robyn\n```\n\n## Creating a Robyn Application\n\nBatman wanted to create a Robyn app and was about to create an `src/app.py` before he was told that Robyn comes with a CLI tool to create a new application. He ran the following command to create a new Robyn application.\n\n```bash\n$ python -m robyn --create\n```\n\nThis, would result in the following output.\n\n```bash\n$ python3 -m robyn --create\n? Directory Path: .\n? Need Docker? (Y/N) Y\n? Please select project type (Mongo/Postgres/Sqlalchemy/Prisma):\n❯ No DB\n Sqlite\n Postgres\n MongoDB\n SqlAlchemy\n Prisma\n```\n\nand the following directory structure.\n\n\nBatman was asked a set of questions to configure the application. He chose to use the default values for most of the questions.\n\nAnd he was done! The Robyn CLI created a new application with the following structure.\n\n```bash\n\n├── src\n│ ├── app.py\n├── Dockerfile\n\n```\n\n\n
\n \n
\n\n"
},
{
"path": "docs_src/src/pages/documentation/en/example_app/modeling_routes.mdx",
"content": "export const description =\n 'Welcome to the Robyn API documentation. You will find comprehensive guides and documentation to help you start working with Robyn as quickly as possible, as well as support if you get stuck.'\n\n\n## Crime Data Model and Database Connection\n\nBatman designed a data model to represent crime data, including information about the crime, suspect, and location. He decided to use a SQLite database to store the data and used an ORM (Object Relational Mapping) library to interact with the database.\n\n\n```python\n# models.py\nfrom sqlalchemy import create_engine, Column, Integer, String, DateTime, Float\nfrom sqlalchemy.orm import declarative_base, sessionmaker\n\nDATABASE_URL = \"sqlite:///./gotham_crime_data.db\"\n\nengine = create_engine(DATABASE_URL)\nSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)\n\n\nBase = declarative_base()\n\nclass Crime(Base):\n __tablename__ = \"crimes\"\n\n id = Column(Integer, primary_key=True, index=True)\n type = Column(String, index=True)\n description = Column(String)\n location = Column(String)\n suspect_name = Column(String)\n date_time = Column(DateTime)\n latitude = Column(Float)\n longitude = Column(Float)\n\n```\n\n\n## Setting up the Robyn Application\n\nBatman set up a Robyn application and configured it to use the database session to access the SQLite database.\n\n\nBased on the Database model, Batman created a few helper methods to interact with the database. These methods would be used by the endpoints to perform CRUD operations on the database.\n\n```python {{ title: 'crud.py' }}\n# crud.py\nfrom sqlalchemy.orm import Session\nfrom .models import Crime\n\n\ndef get_crime(db: Session, crime_id: int):\n return db.query(Crime).filter(Crime.id == crime_id).first()\n\ndef get_crimes(db: Session, skip: int = 0, limit: int = 100):\n return db.query(Crime).offset(skip).limit(limit).all()\n\ndef create_crime(db: Session, crime):\n db_crime = Crime(**crime)\n db.add(db_crime)\n db.commit()\n db.refresh(db_crime)\n return db_crime\n\ndef update_crime(db: Session, crime_id: int, crime):\n db_crime = get_crime(db, crime_id)\n if db_crime is None:\n return None\n for key, value in crime.items():\n setattr(db_crime, key, value)\n db.commit()\n db.refresh(db_crime)\n return db_crime\n\ndef delete_crime(db: Session, crime_id: int):\n db_crime = get_crime(db, crime_id)\n if db_crime is None:\n return False\n db.delete(db_crime)\n db.commit()\n return True\n\n```\n\n\n## Crime Data Endpoints\n\nBatman created various endpoints to manage crime data. These endpoints allowed the Gotham City Police Department to add, update, and retrieve crime data.\n\n```python {{ title: 'Setting up Routes' }}\n# __main__.py\nfrom robyn import Robyn\nfrom robyn.robyn import Request, Response\nfrom sqlalchemy.orm import Session\n\napp = Robyn(__file__)\n\n@app.post(\"/crimes\")\nasync def add_crime(request):\n with SessionLocal() as db:\n crime = request.json()\n insertion = crud.create_crime(db, crime)\n\n if insertion is None:\n raise Exception(\"Crime not added\")\n\n return {\n \"description\": \"Crime added successfully\",\n \"status_code\": 200,\n }\n\n@app.get(\"/crimes\")\nasync def get_crimes(request):\n with SessionLocal() as db:\n skip = request.query_params.get(\"skip\", \"0\")\n limit = request.query_params.get(\"limit\", \"100\")\n crimes = crud.get_crimes(db, skip=skip, limit=limit)\n\n return crimes\n\n@app.get(\"/crimes/:crime_id\", auth_required=True)\nasync def get_crime(request):\n crime_id = int(request.path_params.get(\"crime_id\"))\n with SessionLocal() as db:\n crime = crud.get_crime(db, crime_id=crime_id)\n\n if crime is None:\n raise Exception(\"Crime not found\")\n\n return crime\n\n@app.put(\"/crimes/:crime_id\")\nasync def update_crime(request):\n crime = request.json()\n crime_id = int(request.path_params.get(\"crime_id\"))\n with SessionLocal() as db:\n updated_crime = crud.update_crime(db, crime_id=crime_id, crime=crime)\n if updated_crime is None:\n raise Exception(\"Crime not found\")\n return updated_crime\n\n@app.delete(\"/crimes/{crime_id}\")\nasync def delete_crime(request):\n crime_id = int(request.path_params.get(\"crime_id\"))\n with SessionLocal() as db:\n success = crud.delete_crime(db, crime_id=crime_id)\n if not success:\n raise Exception(\"Crime not found\")\n return {\"message\": \"Crime deleted successfully\"}\n\n\n```\n\n\n
\n \n
\n\n"
},
{
"path": "docs_src/src/pages/documentation/en/example_app/monitoring_and_logging.mdx",
"content": "\n## Monitoring and Logging\nTo keep an eye on the performance of his application and troubleshoot issues, Batman decided to implement monitoring and logging. He used a third-party library to integrate logging middleware, enabling him to track requests, errors, and performance metrics.\n\n```python {{ title: 'Monitoring and Logging' }}\nfrom robyn import Logger\n\nlogger = Logger(app)\n\n@app.before_request()\nasync def log_request(request: Request):\n logger.info(f\"Received request: %s\", request)\n\n@app.after_request()\nasync def log_response(response: Response):\n logger.info(f\"Sending response: %s\", response)\n```\n\nWith monitoring and logging in place, Batman could now easily detect issues and analyze the performance of his web application, ensuring that it was always running optimally and ready to assist him in his fight against crime.\n\n\n
\n \n
\n\n\n"
},
{
"path": "docs_src/src/pages/documentation/en/example_app/openapi.mdx",
"content": "export const description =\n 'Welcome to the Robyn API documentation. You will find comprehensive guides and documentation to help you start working with Robyn as quickly as possible, as well as support if you get stuck.'\n\n\n## OpenAPI Docs a.k.a Swagger\n\nAfter deploying the application, Batman got multiple queries from the users on how to use the endpoints. Robyn showed him how to generate OpenAPI specifications for his application.\n\nOut of the box, the following endpoints are setup for you:\n\n- `/docs` The Swagger UI\n- `/openapi.json` The JSON Specification\n\nHowever, if you don't want to generate the OpenAPI docs, you can disable it by passing `--disable-openapi` flag while starting the application.\n\nTo use a custom openapi configuration, you can:\n\n - Place the `openapi.json` config file in the root directory.\n - Or, pass the file path to the `openapi_file_path` parameter in the `Robyn()` constructor. (the parameter gets priority over the file).\n\n```bash\npython app.py --disable-openapi\n```\n\n## How to use?\n\n- Query Params: The typing for query params can be added as `def get(r: Request, query_params: GetRequestParams)` where `GetRequestParams` is a subclass of `QueryParams`\n- Path Params are defaulted to string type (ref: https://en.wikipedia.org/wiki/Query_string)\n\n\n\n```python\nfrom robyn.robyn import QueryParams\n\nfrom robyn import Robyn, Request\n\napp = Robyn(\n file_object=__file__,\n openapi=OpenAPI(\n info=OpenAPIInfo(\n title=\"Sample App\",\n description=\"This is a sample server application.\",\n termsOfService=\"https://example.com/terms/\",\n version=\"1.0.0\",\n contact=Contact(\n name=\"API Support\",\n url=\"https://www.example.com/support\",\n email=\"support@example.com\",\n ),\n license=License(\n name=\"BSD2.0\",\n url=\"https://opensource.org/license/bsd-2-clause\",\n ),\n externalDocs=ExternalDocumentation(description=\"Find more info here\", url=\"https://example.com/\"),\n components=Components(),\n ),\n ),\n)\n\n\n@app.get(\"/\")\nasync def welcome():\n \"\"\"welcome endpoint\"\"\"\n return \"hi\"\n\n\nclass GetRequestParams(QueryParams):\n appointment_id: str\n year: int\n\n\n@app.get(\"/api/v1/name\", openapi_name=\"Name Route\", openapi_tags=[\"Name\"])\nasync def get(r: Request, query_params: GetRequestParams):\n \"\"\"Get Name by ID\"\"\"\n return r.query_params\n\n\n@app.delete(\"/users/:name\", openapi_tags=[\"Name\"])\nasync def delete(r: Request):\n \"\"\"Delete Name by ID\"\"\"\n return r.path_params\n\n\nif __name__ == \"__main__\":\n app.start()\n```\n\n\n\n## How does it work with subrouters?\n\n\n\n```python\nfrom robyn.robyn import QueryParams\n\nfrom robyn import Request, SubRouter\n\nsubrouter: SubRouter = SubRouter(__name__, prefix=\"/sub\")\n\n\n@subrouter.get(\"/\")\nasync def subrouter_welcome():\n \"\"\"welcome subrouter\"\"\"\n return \"hiiiiii subrouter\"\n\n\nclass SubRouterGetRequestParams(QueryParams):\n _id: int\n value: str\n\n\n@subrouter.get(\"/name\")\nasync def subrouter_get(r: Request, query_params: SubRouterGetRequestParams):\n \"\"\"Get Name by ID\"\"\"\n return r.query_params\n\n\n@subrouter.delete(\"/:name\")\nasync def subrouter_delete(r: Request):\n \"\"\"Delete Name by ID\"\"\"\n return r.path_params\n\n\napp.include_router(subrouter)\n```\n\n\n\n## Other Specification Params\n\nWe support all the params mentioned in the latest OpenAPI specifications (https://swagger.io/specification/). See an example using request & response bodies below:\n\n\n\n```python\nfrom robyn.types import JSONResponse, Body\n\nclass Initial(Body):\n is_present: bool\n letter: Optional[str]\n\n\nclass FullName(Body):\n first: str\n second: str\n initial: Initial\n\n\nclass CreateItemBody(Body):\n name: FullName\n description: str\n price: float\n tax: float\n\n\nclass CreateResponse(JSONResponse):\n success: bool\n items_changed: int\n\n\n@app.post(\"/\")\ndef create_item(request: Request, body: CreateItemBody) -> CreateResponse:\n return CreateResponse(success=True, items_changed=2)\n```\n\n\n\nWith the reference documentation deployed and running smoothly, Batman had a powerful new tool at his disposal. The Robyn framework had provided him with the flexibility, scalability, and performance needed to create an effective crime-fighting application, giving him a technological edge in his ongoing battle to protect Gotham City.\n\n\n
\n \n
\n\n\n\n"
},
{
"path": "docs_src/src/pages/documentation/en/example_app/real_time_notifications.mdx",
"content": "export const description =\n 'Welcome to the Robyn API documentation. You will find comprehensive guides and documentation to help you start working with Robyn as quickly as possible, as well as support if you get stuck.'\n\n## Real time notifications\nBatman decided to implement real-time notifications for police officers using WebSockets. This would allow officers to receive instant updates on criminal activities, as well as alerts when a new crime is reported.\n\n\n\n```python {{ title: 'Setting up Real-time Notifications' }}\nfrom robyn import WebSocketDisconnect\n\n@app.websocket(\"/notifications\")\nasync def notify_handler(websocket):\n try:\n while True:\n message = await websocket.receive_text()\n await websocket.send_text(f\"Received: {message}\")\n except WebSocketDisconnect:\n pass\n\n@notify_handler.on_connect\ndef notify_connect(websocket):\n return \"Connected to notifications\"\n\n@notify_handler.on_close\ndef notify_close(websocket):\n return \"Disconnected from notifications\"\n\n```\n\n## Advanced Search and Filtering \n\nTo make it easier for the police officers to search for specific crimes or criminals, Batman added advanced search and filtering options to the application. He implemented a new endpoint that allows users to search based on various criteria like crime type, date, location, and status.\n\n\n```python {{ title: 'Advanced Search and Filtering' }}\n@app.get(\"/crimes/search\")\nasync def search_crimes(request):\n crime_type = request.query_params.get(\"crime_type\")\n date = request.query_params.get(\"date\")\n location = request.query_params.get(\"location\")\n status = request.query_params.get(\"status\")\n\n crimes = crud.search_crimes(db, crime_type=crime_type, date=date, location=location, status=status)\n return crimes\n\n```\n\n\nWith the new features in place, the Gotham City Police Department was able to use the web application more effectively to track criminal activities and deploy resources efficiently. Batman's work on the Robyn web framework had a significant impact on Gotham City's crime-fighting efforts, making it a safer place for its citizens.\n\nAlthough Batman had achieved great success with the current implementation, he knew that there would always be room for improvement and new features to add. But for now, he could take a moment to appreciate his work and focus on his primary duty - protecting Gotham City as the Dark Knight.\n\n\n\n\n\n
\n \n
\n\n"
},
{
"path": "docs_src/src/pages/documentation/en/example_app/subrouters.mdx",
"content": "export const description =\n 'Welcome to the Robyn API documentation. You will find comprehensive guides and documentation to help you start working with Robyn as quickly as possible, as well as support if you get stuck.'\n\n## Code Organization with SubRouters\n\nAs the application grew, Batman needed a way to organize his routes better. He decided to use Robyn's SubRouter feature to group related routes together.\n\n```python\nfrom robyn import SubRouter\n\n# Create a subrouter for crime-related routes\ncrime_router = SubRouter(__file__, prefix=\"/crimes\")\n\n@crime_router.get(\"/list\")\ndef list_crimes():\n return {\"crimes\": get_all_crimes()}\n\n@crime_router.post(\"/report\")\ndef report_crime(request):\n crime_data = request.json()\n return {\"id\": create_crime_report(crime_data)}\n\n# Create a subrouter for suspect-related routes\nsuspect_router = SubRouter(__file__, prefix=\"/suspects\")\n\n@suspect_router.get(\"/list\")\ndef list_suspects():\n return {\"suspects\": get_all_suspects()}\n\n@suspect_router.get(\"/:id\")\ndef get_suspect(request, path_params):\n suspect_id = path_params.id\n return {\"suspect\": get_suspect_by_id(suspect_id)}\n\n# Include the subrouters in the main app\napp.include_router(crime_router)\napp.include_router(suspect_router)\n```\n\nSubRouters help organize related routes under a common prefix, making the code more maintainable and easier to understand. In this example:\n\n- All crime-related routes are under `/crimes`\n- All suspect-related routes are under `/suspects`\n\nThis organization makes it clear which routes handle what functionality and keeps related code together.\n\n\n\n\n\n\n\n"
},
{
"path": "docs_src/src/pages/documentation/en/example_app/templates.mdx",
"content": "export const description =\n 'Welcome to the Robyn API documentation. You will find comprehensive guides and documentation to help you start working with Robyn as quickly as possible, as well as support if you get stuck.'\n\n\n## Templates\n\nAfter implementing the backend, Batman decided to add a frontend to his application. He wanted to create a simple web page that would allow him to view the data he had collected. He also wanted to be able to add new data to the database and edit existing data.\n\nThis is when he was introduced to templates!\n\nTemplates are a powerful feature of the Robyn framework that allow you to create dynamic web pages using HTML and Python. They are a great way to add a frontend to your application without having to learn a new language or framework.\n\nRobyn supports Jinja2 templates by default but provides an easy way to add other templating engines as well.\n\n### Creating a Template\n\nTo create a template, you need to create a file with the `.html` extension in the a directory, usually it is convention to use the `templates` directory. For example, if you wanted to create a template called `index.html`, you would create a file called `index.html` in the `templates` directory.\n\nSo the folder structure would look like this:\n\n```bash\n├── app.py\n├── templates\n│ └── index.html\n├── Dockerfile\n└── requirements.txt\n\n```\n\n### Rendering a Template\n\nOnce you have created a template, you can render it by using the `render_template` function. This function takes the name of the template as its first argument and a dictionary of variables as its second argument.\n\nFor example, if you wanted to render the `index.html` template, you would use the following code:\n\n```python {{ title: 'Rendering a Template' }}\n\nimport os\nimport pathlib\nfrom robyn.templating import JinjaTemplate\n\n\ncurrent_file_path = pathlib.Path(__file__).parent.resolve()\njinja_template = JinjaTemplate(os.path.join(current_file_path, \"templates\"))\n\n@app.get(\"/frontend\")\nasync def get_frontend(request):\n context = {\"framework\": \"Robyn\", \"templating_engine\": \"Jinja2\"}\n return jinja_template.render_template(\"index.html\", **context)\n\napp.include_router(frontend)\n```\n\n\nNow Batman very happy that the application had come to completion. However, he was not satisfied with the current state of the application. He felt the code was all crammed in a single file and asked Robyn if there was a way to split the codebase in other parts.\n\nThis is Robyn introduced him to the concept of routers and views.\n\n
\n \n
\n\n\n\n\n"
},
{
"path": "docs_src/src/pages/documentation/en/example_app/zh/index.mdx",
"content": "export const description =\n '欢迎来到Robyn API文档。您将找到全面的指南和文档，帮助您尽快开始使用Robyn，并在遇到困难时获得支持。'\n\n# 使用Robyn构建实际应用\n\n蝙蝠侠被委托开发一个Web应用程序来管理哥谭市的犯罪数据。该应用程序将允许哥谭警察局存储和检索有关犯罪活动、嫌疑人及其位置的数据。他决定使用Robyn Web框架来高效快速地构建这个应用程序。\n\n您可以在[这里](https://github.com/sparckles/example_robyn_app)找到此应用程序的源代码。\n\n## 安装Robyn\n\n第一步是安装Robyn。蝙蝠侠创建了一个虚拟环境并使用pip安装了Robyn。\n\n```bash\n$ python3 -m venv venv\n$ source venv/bin/activate\n$ pip install robyn\n```\n\n## 创建Robyn应用程序\n\n蝙蝠侠正准备创建一个`src/app.py`文件，这时他得知Robyn提供了一个CLI工具来创建新应用程序。他运行以下命令来创建一个新的Robyn应用程序：\n\n```bash\n$ python -m robyn --create\n```\n\n这个示例应用程序将展示如何：\n\n- 设计和实现RESTful API\n- 处理身份验证和授权\n- 使用中间件进行请求处理\n- 实现实时通知\n- 设置监控和日志记录\n- 部署应用程序\n- 生成API文档\n- 组织和构建可维护的代码 "
},
{
"path": "docs_src/src/pages/documentation/en/example_app/zh/subrouters.mdx",
"content": "export const description =\n '欢迎来到Robyn API文档。您将找到全面的指南和文档，帮助您尽快开始使用Robyn，并在遇到困难时获得支持。'\n\n## 使用SubRouters组织代码\n\n随着应用程序的增长，蝙蝠侠需要一种更好的方式来组织他的路由。他决定使用Robyn的SubRouter功能来对相关路由进行分组。\n\n```python\nfrom robyn import SubRouter\n\n# 创建处理犯罪相关路由的子路由器\ncrime_router = SubRouter(__file__, prefix=\"/crimes\")\n\n@crime_router.get(\"/list\")\ndef list_crimes():\n return {\"crimes\": get_all_crimes()}\n\n@crime_router.post(\"/report\")\ndef report_crime(request):\n crime_data = request.json()\n return {\"id\": create_crime_report(crime_data)}\n\n# 创建处理嫌疑人相关路由的子路由器\nsuspect_router = SubRouter(__file__, prefix=\"/suspects\")\n\n@suspect_router.get(\"/list\")\ndef list_suspects():\n return {\"suspects\": get_all_suspects()}\n\n@suspect_router.get(\"/:id\")\ndef get_suspect(request, path_params):\n suspect_id = path_params.id\n return {\"suspect\": get_suspect_by_id(suspect_id)}\n\n# 将子路由器包含在主应用程序中\napp.include_router(crime_router)\napp.include_router(suspect_router)\n```\n\nSubRouters帮助在公共前缀下组织相关路由，使代码更易于维护和理解。在这个例子中：\n\n- 所有与犯罪相关的路由都在 `/crimes` 下\n- 所有与嫌疑人相关的路由都在 `/suspects` 下\n\n这种组织方式清晰地表明了哪些路由处理什么功能，并将相关代码保持在一起。 "
},
{
"path": "docs_src/src/pages/documentation/en/framework_performance_comparison.mdx",
"content": "export const description =\n 'On this page, we`ll understand the performance comparison across different frameworks.'\n\n\n# Performance comparison across different frameworks\n\n## Read this before you scroll down\n\nBefore delving into the details, it is imperative to note that this comparison doesn’t aim to discredit any developers or the frameworks listed below. Mentioning the names of the frameworks is solely for elucidating a clear comparison. My profound inclination towards the Python web ecosystem has been significantly influenced by all these frameworks, and my intention is not to cause offense to anyone by listing them here.\n\nMoreover, these tests were conducted on my development machine, and thus, the figures portrayed below are not absolute. The numbers only serve to indicate the relative performance of these frameworks under the specific testing conditions.\n\n\nThe [oha](https://github.com/hatoo/oha) tool was utilized to test 10,000 requests on the following frameworks, yielding the subsequent results:\n\n1. Flask(Gunicorn)\n\n```\nTotal: 5.5254 secs\nSlowest: 0.0784 secs\nFastest: 0.0028 secs\nAverage: 0.0275 secs\nRequests/sec: 1809.8082\n```\n\n1. FastAPI(Uvicorn)\n\n```\nTotal: 4.1314 secs\nSlowest: 0.0733 secs\nFastest: 0.0027 secs\nAverage: 0.0206 secs\nRequests/sec: 2420.4851\n```\n\n1. Django(Gunicorn)\n\n```\nTotal: 13.5070 secs\nSlowest: 0.3635 secs\nFastest: 0.0249 secs\nAverage: 0.0674 secs\nRequests/sec: 740.3558\n```\n\n1. Robyn(Doesn't need a *SGI)\n\n```\nTotal:\t1.8324 secs\nSlowest:\t0.0269 secs\nFastest:\t0.0024 secs\nAverage:\t0.0091 secs\nRequests/sec:\t5457.2339\n```\n\n1. Robyn (5 workers)\n\n```\nTotal:\t1.5592 secs\nSlowest:\t0.0211 secs\nFastest:\t0.0017 secs\nAverage:\t0.0078 secs\nRequests/sec:\t6413.6480\n```\n\nRobyn is able to serve the 10k requests in 1.8 seconds followed by Flask and FastAPI, which take around 5 seconds(using 5 workers on a dual-core machine). Finally, Django takes around 13.5070 seconds.\n\n## Verbose Logs\n\nFlask(Gunicorn)\n\n```\nSummary:\n Success rate: 1.0000\n Total: 5.5254 secs\n Slowest: 0.0784 secs\n Fastest: 0.0028 secs\n Average: 0.0275 secs\n Requests/sec: 1809.8082\n\n Total data: 126.95 KiB\n Size/request: 13 B\n Size/sec: 22.98 KiB\n\nResponse time histogram:\n 0.007 [55] |\n 0.014 [641] |■■■■■\n 0.021 [2413] |■■■■■■■■■■■■■■■■■■■■\n 0.027 [3771] |■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■\n 0.034 [1999] |■■■■■■■■■■■■■■■■\n 0.041 [737] |■■■■■■\n 0.048 [236] |■■\n 0.055 [75] |\n 0.062 [46] |\n 0.069 [24] |\n 0.076 [3] |\n\nLatency distribution:\n 10% in 0.0178 secs\n 25% in 0.0223 secs\n 50% in 0.0266 secs\n 75% in 0.0317 secs\n 90% in 0.0378 secs\n 95% in 0.0419 secs\n 99% in 0.0551 secs\n\nDetails (average, fastest, slowest):\n DNS+dialup: 0.0071 secs, 0.0001 secs, 0.0443 secs\n DNS-lookup: 0.0000 secs, 0.0000 secs, 0.0010 secs\n\nStatus code distribution:\n [200] 10000 responses\n```\n\nFastAPI(Uvicorn)\n\n```\nSummary:\n Success rate: 1.0000\n Total: 4.1314 secs\n Slowest: 0.0733 secs\n Fastest: 0.0027 secs\n Average: 0.0206 secs\n Requests/sec: 2420.4851\n\n Total data: 166.02 KiB\n Size/request: 17 B\n Size/sec: 40.18 KiB\n\nResponse time histogram:\n 0.005 [175] |■\n 0.011 [1541] |■■■■■■■■■■■■■■■■\n 0.016 [2942] |■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■\n 0.021 [2770] |■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■\n 0.027 [1479] |■■■■■■■■■■■■■■■■\n 0.032 [608] |■■■■■■\n 0.038 [217] |■■\n 0.043 [103] |■\n 0.048 [53] |\n 0.054 [54] |\n 0.059 [58] |\n\nLatency distribution:\n 10% in 0.0120 secs\n 25% in 0.0151 secs\n 50% in 0.0194 secs\n 75% in 0.0243 secs\n 90% in 0.0300 secs\n 95% in 0.0348 secs\n 99% in 0.0522 secs\n\nDetails (average, fastest, slowest):\n DNS+dialup: 0.0088 secs, 0.0073 secs, 0.0103 secs\n DNS-lookup: 0.0001 secs, 0.0000 secs, 0.0008 secs\n\nStatus code distribution:\n [200] 10000 responses\n```\n\nRobyn\n\n```\nSummary:\n Success rate:\t1.0000\n Total:\t1.8324 secs\n Slowest:\t0.0269 secs\n Fastest:\t0.0024 secs\n Average:\t0.0091 secs\n Requests/sec:\t5457.2339\n\n Total data:\t117.19 KiB\n Size/request:\t12 B\n Size/sec:\t63.95 KiB\n\nResponse time histogram:\n 0.002 [183] |■\n 0.004 [1669] |■■■■■■■■■■■■■■\n 0.007 [3724] |■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■\n 0.009 [2631] |■■■■■■■■■■■■■■■■■■■■■■\n 0.011 [1060] |■■■■■■■■■\n 0.013 [496] |■■■■\n 0.016 [188] |■\n 0.018 [34] |\n 0.020 [12] |\n 0.022 [2] |\n 0.025 [1] |\n\nLatency distribution:\n 10% in 0.0061 secs\n 25% in 0.0073 secs\n 50% in 0.0087 secs\n 75% in 0.0105 secs\n 90% in 0.0129 secs\n 95% in 0.0143 secs\n 99% in 0.0171 secs\n\nDetails (average, fastest, slowest):\n DNS+dialup:\t0.0049 secs, 0.0035 secs, 0.0065 secs\n DNS-lookup:\t0.0001 secs, 0.0000 secs, 0.0010 secs\n\nStatus code distribution:\n [200] 10000 responses\n```\n\nDjango(Gunicorn)\n\n```\nSummary:\n Success rate: 1.0000\n Total: 13.5070 secs\n Slowest: 0.3635 secs\n Fastest: 0.0249 secs\n Average: 0.0674 secs\n Requests/sec: 740.3558\n\n Total data: 102.01 MiB\n Size/request: 10.45 KiB\n Size/sec: 7.55 MiB\n\nResponse time histogram:\n 0.016 [283] |■\n 0.032 [2616] |■■■■■■■■■■■■■■■■■■\n 0.048 [4587] |■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■\n 0.064 [1829] |■■■■■■■■■■■■\n 0.081 [362] |■■\n 0.097 [98] |\n 0.113 [105] |\n 0.129 [20] |\n 0.145 [7] |\n 0.161 [28] |\n 0.177 [65] |\n\nLatency distribution:\n 10% in 0.0493 secs\n 25% in 0.0559 secs\n 50% in 0.0638 secs\n 75% in 0.0733 secs\n 90% in 0.0840 secs\n 95% in 0.0948 secs\n 99% in 0.1543 secs\n\nDetails (average, fastest, slowest):\n DNS+dialup: 0.0097 secs, 0.0001 secs, 0.0444 secs\n DNS-lookup: 0.0000 secs, 0.0000 secs, 0.0007 secs\n\nStatus code distribution:\n [200] 10000 responses\n```\n\nRobyn(with 5 workers)\n\n```\nSummary:\n Success rate:\t1.0000\n Total:\t1.5592 secs\n Slowest:\t0.0211 secs\n Fastest:\t0.0017 secs\n Average:\t0.0078 secs\n Requests/sec:\t6413.6480\n\n Total data:\t126.95 KiB\n Size/request:\t13 B\n Size/sec:\t81.42 KiB\n\nResponse time histogram:\n 0.002 [30] |\n 0.004 [599] |■■■■■\n 0.005 [3336] |■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■\n 0.007 [3309] |■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■\n 0.009 [1614] |■■■■■■■■■■■■■■■\n 0.011 [749] |■■■■■■■\n 0.012 [253] |■■\n 0.014 [94] |\n 0.016 [14] |\n 0.018 [1] |\n 0.019 [1] |\n\nLatency distribution:\n 10% in 0.0055 secs\n 25% in 0.0063 secs\n 50% in 0.0074 secs\n 75% in 0.0089 secs\n 90% in 0.0107 secs\n 95% in 0.0117 secs\n 99% in 0.0142 secs\n\nDetails (average, fastest, slowest):\n DNS+dialup:\t0.0022 secs, 0.0013 secs, 0.0028 secs\n DNS-lookup:\t0.0000 secs, 0.0000 secs, 0.0001 secs\n\nStatus code distribution:\n [200] 10000 responses\n```\n"
},
{
"path": "docs_src/src/pages/documentation/en/hosting.mdx",
"content": "export const description =\n 'On this page, we`ll understand how Robyn can be deployed on various cloud providers .'\n\nThe process of hosting a Robyn app on various cloud providers.\n\n\n## Railway\n\nWe will be deploying the app on `Railway`.\n\nA GitHub account is needed as a mandatory prerequisite.\n\nWe will deploy a sample \"Hello World,\" demonstrating a simple GET route and serving an HTML file.\n\nDirectory structure:\n\n \n\n```bash \napp folder/\n main.py\n requirements.txt\n index.html\n```\n\n \n\n Note - Railway looks for a main.py as an entry point instead of app.py. The build process will fail if there is no main.py file.\n\n\n\n \n\n```python {{ title: 'python' }}\nfrom robyn import Robyn, serve_html\n\n\napp = Robyn(__file__)\n\n\n@app.get(\"/hello\")\nasync def h(request):\n print(request)\n return \"Hello, world!\"\n\n\n@app.get(\"/\")\nasync def get_page(request):\n return serve_html(\"./index.html\")\n\n\nif __name__ == \"__main__\":\n app.start(url=\"0.0.0.0\", port=PORT)\n```\n\n \n\n\n\n \n\n ```python {{ title: 'python' }}\n
Hello World, this is Robyn framework!
\n ```\n\n
\n\n## Exposing Ports\n\nThe Railway documentation says the following about the listening to ports:\n\n> The easiest way to get up and running is to have your application listen on 0.0.0.0:$PORT, where PORT is a Railway-provided environment variable.\n\nSo, passing the host as `0.0.0.0` to `app.start()` as an argument is necessary.\n\nWe need to create a Railway account to deploy this app on Railway. We can do so by going on the `Railway HomePage`.\n\nPress the \"Login\" button and select \"login with a GitHub account.\"\n\n\n\nThen, we press the \"New Project\" button and select \"Deploy from GitHub repo\".\n\n\n\nThen we select the repo we want to deploy. And click \"Deploy Now\".\n\n\n\n\nNow, we click on our project's card.\n\nSelect \"Variables\" and press the \"New Variable\" button to set the environments variables.\n\n\n\nThen, we go to the \"Settings\" tab and click on \"Generate Domain.\"\n\nWe can generate a temporary domain under the \"Domains\" tab.\n\n\n\nWe can go to our domain `/hello` and confirm that the message \"Hello World\" is displayed.\n\n\n## Next Steps\n\n- [Future Roadmap](/documentation/en/api_reference/future-roadmap)\n"
},
{
"path": "docs_src/src/pages/documentation/en/index.mdx",
"content": "import { Guides } from '@/components/documentation/Guides'\nimport { ApiDocs } from '@/components/documentation/ApiDocs'\nimport { HeroPattern } from '@/components/documentation/HeroPattern'\n\nexport const description =\n 'Welcome to the Robyn API documentation. You will find comprehensive guides and documentation to help you start working with Robyn as quickly as possible, as well as support if you get stuck.'\n\nexport const sections = [\n { title: 'Example Application', id: 'guides' },\n { title: 'Api Reference', id: 'api_docs' },\n]\n\n\n\n
\n# API Documentation\nWelcome to the Robyn API documentation. You'll find comprehensive guides and documentation to help you start working with Robyn as quickly as possible, as well as support if you get stuck. \n\nWe have divided the documentation into two parts: the [Example Application](#guides) and the [API Docs](#api_docs).\n\n
\n \n \n
\n\n## Getting started {{ anchor: false }}\n\nThe Example Application is a simple web application that demonstrates how to use the Robyn API. It is a great place to start if you are new to Robyn.\n\nThe API Reference contains detailed information about the Robyn API. It is a great place to start if you are already familiar with Robyn and want to learn more about the API.\n\n\n
\n\n\n\n\n"
},
{
"path": "docs_src/src/pages/documentation/en/plugins.mdx",
"content": "## Plugins\n\nRobyn is a versatile and extensible web framework that allows anyone to make plugins over the top of Robyn.\nPlugins in Robyn allow you to enhance and customize the framework's functionality to suit your specific needs. Here are some noteworthy plugins that can supercharge your Robyn-based projects:\n\n### Rate Limit Plugin\n\n- Description: This plugin enables you to implement rate limiting for your Robyn application's routes. It helps prevent abuse, and brute-force attacks and ensures fair usage of your resources.\n- GitHub repository: [robyn-rate-limits](https://github.com/IdoKendo/robyn_rate_limits)\n- Installation:\n `python -m pip install robyn-rate-limits`\n- Usage:\n\n```py\nfrom robyn import Robyn, Request\nfrom robyn_rate_limits import InMemoryStore\nfrom robyn_rate_limits import RateLimiter\n\napp = Robyn(__file__)\nlimiter = RateLimiter(store=InMemoryStore, calls_limit=3, limit_ttl=100)\n\n@app.before_request()\ndef middleware(request: Request):\n return limiter.handle_request(app, request)\n\n@app.get(\"/\")\ndef h():\n return \"Hello, World!\"\n\napp.start(port=8080)\n```\n\nIn this example, robyn-rate-limits is used to enforce a rate limit of 3 requests per 100-seconds window for specific routes. If a client exceeds this limit, they will receive a \"Too many requests\" message.\n\nThe plugin integrates seamlessly with the Robyn web framework, enhancing the security and stability of your application by preventing excessive requests from a single client.\n\n## What's next?\n\nAfter exploring the plugins, Batman wanted to explore the community.So, Robyn pointed him to\n\n- [Future Roadmap](/documentation/en/api_reference/future-roadmap)\n"
},
{
"path": "docs_src/src/pages/documentation/zh/api_reference/advanced_features.mdx",
"content": "export const description =\n '在此页面中，我们将深入探讨如何通过不同的接口实现符合预期的交互。'\n\n## 获取客户端 IP 地址\n\n意识到小丑可能也在使用哥谭警察控制面板后，蝙蝠侠决定在他的应用程序中实现访问者 IP 地址追踪功能。\n\n\n
\n\n \n\n ```python\n @app.get(\"/auth\", auth_required=True)\n async def auth(request: Request):\n # This route method will only be executed if the user is authenticated\n # Otherwise, a 401 response will be returned\n return \"Hello, world\"\n ```\n \n\n \n\n\n\n
\n )\n}\n\nexport default function Home({ articles }) {\n return (\n <>\n \n \n Robyn - A Fast, Innovator Friendly, and Community Driven Python Web\n Framework.\n \n \n \n \n \n \n\n {/*Twitter specific meta tags*/}\n \n \n \n \n \n\n {/*LinkedIn specific meta tags*/}\n \n \n \n\n \n
\n \n \n
\n
\n
\n
\n
\n Meet Robyn\n
\n
\n A Fast, Innovator Friendly, and Community Driven Python Web\n Framework\n
\n
\n Robyn merges Python's async capabilities with a Rust runtime\n for reliable, scalable web solutions. Experience quick project\n scaffolding, enjoyable usage, and robust plugin support.\n
\n
\n \n Get started\n \n \n Learn more\n \n
\n
\n \n
\n
\n \n \n \n \n \n \n \n
\n
\n
\n Our Philosophy\n
\n
\n Fast. Innovator Friendly. Robust. Community Driven.\n
\n
\n
\n
\n
\n \n \n \n Fast.{' '}\n
\n
\n Robyn, written in Rust, embodies speed and reliability. Our\n multithreaded runtime creates a highly efficient and secure\n environment optimized for peak performance.\n
\n
\n
\n
\n \n \n \n Simple API.\n
\n
\n With Robyn, complexity takes a backseat. Our API is simple yet\n potent, built to streamline your development process and\n minimize your workload.\n
\n
\n
\n
\n \n \n \n Hacker Friendly.\n
\n
\n While many focus on large-scale challenges that many of us might\n never encounter, Robyn prioritizes the broader issues most\n developers face. We foster innovation for all, ensuring both\n common and complex challenges are met with expertise. At Robyn,\n every developer feels at home.\n
\n
\n\n
\n
\n \n \n \n \n Community First and Truly FOSS.\n
\n
\n Rooted in a community-first ethos, Robyn is built with\n collective effort and is a true representation of free and\n open-source software.\n
\n \n\n"
},
{
"path": "integration_tests/conftest.py",
"content": "import os\nimport pathlib\nimport platform\nimport signal\nimport socket\nimport subprocess\nimport time\nfrom typing import List\n\nimport pytest\n\nfrom integration_tests.helpers.network_helpers import get_network_host\n\n\ndef spawn_process(command: List[str]) -> subprocess.Popen:\n if platform.system() == \"Windows\":\n command[0] = \"python\"\n process = subprocess.Popen(command, shell=True, creationflags=subprocess.CREATE_NEW_PROCESS_GROUP)\n return process\n process = subprocess.Popen(command, preexec_fn=os.setsid)\n return process\n\n\ndef kill_process(process: subprocess.Popen) -> None:\n if platform.system() == \"Windows\":\n process.send_signal(signal.CTRL_BREAK_EVENT)\n process.kill()\n return\n\n try:\n os.killpg(os.getpgid(process.pid), signal.SIGKILL)\n except ProcessLookupError:\n pass\n\n\ndef start_server(domain: str, port: int, is_dev: bool = False) -> subprocess.Popen:\n \"\"\"\n Call this method to wait for the server to start\n \"\"\"\n # Start the server\n current_file_path = pathlib.Path(__file__).parent.resolve()\n base_routes = os.path.join(current_file_path, \"./base_routes.py\")\n command = [\"python3\", base_routes]\n if is_dev:\n command.append(\"--dev\")\n\n # Ensure environment variables are properly set for the subprocess\n env = os.environ.copy()\n env[\"ROBYN_HOST\"] = domain\n env[\"ROBYN_PORT\"] = str(port)\n\n process = spawn_process(command)\n\n # Wait for the server to be reachable\n timeout = 15 # The maximum time we will wait for an answer\n start_time = time.time()\n while True:\n current_time = time.time()\n if current_time - start_time > timeout:\n # Robyn didn't start correctly before timeout, kill the process and exit with an exception\n kill_process(process)\n raise ConnectionError(f\"Could not reach Robyn server on {domain}:{port} after {timeout} seconds\")\n try:\n sock = socket.create_connection((domain, port), timeout=2)\n sock.close()\n break # We were able to reach the server, exit the loop\n except Exception:\n time.sleep(0.5) # Longer delay before retrying\n\n # Give the server a moment to fully initialize after accepting connections\n time.sleep(1)\n return process\n\n\n@pytest.fixture(scope=\"session\")\ndef session():\n domain = \"127.0.0.1\"\n port = 8080\n os.environ[\"ROBYN_HOST\"] = domain\n process = start_server(domain, port)\n yield\n kill_process(process)\n\n\n@pytest.fixture(scope=\"session\")\ndef default_session():\n domain = \"127.0.0.1\"\n port = 8080\n process = start_server(domain, port)\n yield\n kill_process(process)\n\n\n@pytest.fixture(scope=\"session\")\ndef global_session():\n domain = get_network_host()\n port = 8080\n os.environ[\"ROBYN_HOST\"] = domain\n process = start_server(domain, port)\n yield\n kill_process(process)\n\n\n@pytest.fixture(scope=\"session\")\ndef dev_session():\n domain = \"127.0.0.1\"\n port = 8081\n os.environ[\"ROBYN_HOST\"] = domain\n os.environ[\"ROBYN_PORT\"] = str(port)\n # This doesn't test is_dev=True!!!!\n process = start_server(domain, port)\n yield\n kill_process(process)\n\n\n@pytest.fixture(scope=\"session\")\ndef test_session():\n domain = \"127.0.0.1\"\n port = 8080\n os.environ[\"ROBYN_HOST\"] = domain\n os.environ[\"ROBYN_PORT\"] = str(port)\n process = start_server(domain, port, is_dev=True)\n yield\n kill_process(process)\n\n\n# create robyn.env before test and delete it after test\n@pytest.fixture\ndef env_file():\n CONTENT = \"\"\"ROBYN_PORT=8081\n ROBYN_URL=127.0.0.1\"\"\"\n path = pathlib.Path(__file__).parent\n env_path = path / \"robyn.env\"\n env_path.write_text(CONTENT)\n yield\n env_path.unlink()\n del os.environ[\"ROBYN_PORT\"]\n del os.environ[\"ROBYN_HOST\"]\n"
},
{
"path": "integration_tests/downloads/test.txt",
"content": "This is a test file for the downloading purpose"
},
{
"path": "integration_tests/helpers/__init__.py",
"content": ""
},
{
"path": "integration_tests/helpers/http_methods_helpers.py",
"content": "from typing import Optional\n\nimport requests\n\nBASE_URL = \"http://127.0.0.1:8080\"\n\n\ndef check_response(response: requests.Response, expected_status_code: int):\n \"\"\"\n Raises if the response status code is not the expected one or if one of the global\n headers is not present in the response.\n \"\"\"\n assert response.status_code == expected_status_code\n assert response.headers.get(\"global_after\") == \"global_after_request\"\n assert \"server\" in response.headers\n assert response.headers.get(\"server\") == \"robyn\"\n\n\ndef get(\n endpoint: str,\n expected_status_code: int = 200,\n headers: dict = {},\n should_check_response: bool = True,\n) -> requests.Response:\n \"\"\"\n Makes a GET request to the given endpoint and checks the response.\n\n endpoint str: The endpoint to make the request to.\n expected_status_code int: The expected status code of the response.\n headers dict: The headers to send with the request.\n should_check_response bool: A boolean to indicate if the status code and headers should be checked.\n \"\"\"\n endpoint = endpoint.lstrip(\"/\")\n response = requests.get(f\"{BASE_URL}/{endpoint}\", headers=headers)\n if should_check_response:\n check_response(response, expected_status_code)\n return response\n\n\ndef post(\n endpoint: str,\n data: Optional[dict] = None,\n expected_status_code: int = 200,\n headers: dict = {},\n should_check_response: bool = True,\n) -> requests.Response:\n \"\"\"\n Makes a POST request to the given endpoint and checks the response.\n\n endpoint str: The endpoint to make the request to.\n data Optional[dict]: The data to send with the request.\n expected_status_code int: The expected status code of the response.\n headers dict: The headers to send with the request.\n should_check_response bool: A boolean to indicate if the status code and headers should be checked.\n \"\"\"\n\n endpoint = endpoint.lstrip(\"/\")\n response = requests.post(f\"{BASE_URL}/{endpoint}\", data=data, headers=headers)\n if should_check_response:\n check_response(response, expected_status_code)\n return response\n\n\ndef json_post(\n endpoint: str,\n json_data=None,\n expected_status_code: int = 200,\n headers: dict = {},\n should_check_response: bool = True,\n) -> requests.Response:\n \"\"\"\n Makes a POST request with JSON body to the given endpoint and checks the response.\n\n endpoint str: The endpoint to make the request to.\n json_data: The JSON-serializable data to send with the request (dict, list, etc.).\n expected_status_code int: The expected status code of the response.\n headers dict: The headers to send with the request.\n should_check_response bool: A boolean to indicate if the status code and headers should be checked.\n \"\"\"\n\n endpoint = endpoint.strip(\"/\")\n response = requests.post(f\"{BASE_URL}/{endpoint}\", json=json_data, headers=headers)\n if should_check_response:\n check_response(response, expected_status_code)\n return response\n\n\ndef multipart_post(\n endpoint: str,\n files: Optional[dict] = None,\n expected_status_code: int = 200,\n should_check_response: bool = True,\n) -> requests.Response:\n \"\"\"\n Makes a POST request to the given endpoint and checks the response.\n\n endpoint str: The endpoint to make the request to.\n files Optional[dict]: The files to send with the request.\n expected_status_code int: The expected status code of the response.\n should_check_response bool: A boolean to indicate if the status code and headers should be checked.\n \"\"\"\n\n endpoint = endpoint.lstrip(\"/\")\n response = requests.post(f\"{BASE_URL}/{endpoint}\", files=files)\n if should_check_response:\n check_response(response, expected_status_code)\n return response\n\n\ndef put(\n endpoint: str,\n data: Optional[dict] = None,\n expected_status_code: int = 200,\n headers: dict = {},\n should_check_response: bool = True,\n) -> requests.Response:\n \"\"\"\n Makes a PUT request to the given endpoint and checks the response.\n\n endpoint str: The endpoint to make the request to.\n expected_status_code int: The expected status code of the response.\n headers dict: The headers to send with the request.\n should_check_response bool: A boolean to indicate if the status code and headers should be checked.\n \"\"\"\n\n endpoint = endpoint.lstrip(\"/\")\n response = requests.put(f\"{BASE_URL}/{endpoint}\", data=data, headers=headers)\n if should_check_response:\n check_response(response, expected_status_code)\n return response\n\n\ndef patch(\n endpoint: str,\n data: Optional[dict] = None,\n expected_status_code: int = 200,\n headers: dict = {},\n should_check_response: bool = True,\n) -> requests.Response:\n \"\"\"\n Makes a PATCH request to the given endpoint and checks the response.\n\n endpoint str: The endpoint to make the request to.\n expected_status_code int: The expected status code of the response.\n headers dict: The headers to send with the request.\n should_check_response bool: A boolean to indicate if the status code and headers should be checked.\n \"\"\"\n\n endpoint = endpoint.lstrip(\"/\")\n response = requests.patch(f\"{BASE_URL}/{endpoint}\", data=data, headers=headers)\n if should_check_response:\n check_response(response, expected_status_code)\n return response\n\n\ndef delete(\n endpoint: str,\n data: Optional[dict] = None,\n expected_status_code: int = 200,\n headers: dict = {},\n should_check_response: bool = True,\n) -> requests.Response:\n \"\"\"\n Makes a DELETE request to the given endpoint and checks the response.\n\n endpoint str: The endpoint to make the request to.\n expected_status_code int: The expected status code of the response.\n headers dict: The headers to send with the request.\n should_check_response bool: A boolean to indicate if the status code and headers should be checked.\n \"\"\"\n\n endpoint = endpoint.lstrip(\"/\")\n response = requests.delete(f\"{BASE_URL}/{endpoint}\", data=data, headers=headers)\n if should_check_response:\n check_response(response, expected_status_code)\n return response\n\n\ndef head(\n endpoint: str,\n data: Optional[dict] = None,\n expected_status_code: int = 200,\n headers: dict = {},\n should_check_response: bool = True,\n) -> requests.Response:\n \"\"\"\n Makes a HEAD request to the given endpoint and checks the response.\n\n endpoint str: The endpoint to make the request to.\n expected_status_code int: The expected status code of the response.\n headers dict: The headers to send with the request.\n should_check_response bool: A boolean to indicate if the status code and headers should be checked.\n \"\"\"\n\n endpoint = endpoint.lstrip(\"/\")\n response = requests.head(f\"{BASE_URL}/{endpoint}\", data=data, headers=headers)\n if should_check_response:\n check_response(response, expected_status_code)\n return response\n\n\n# TODO - at some point this should be the defacto\n# and every other method should be replaced with this\ndef generic_http_helper(\n method: str,\n endpoint: str,\n data: Optional[dict] = None,\n expected_status_code: int = 200,\n headers: dict = {},\n should_check_response: bool = True,\n) -> requests.Response:\n \"\"\"\n Makes a request to the given endpoint and checks the response.\n\n endpoint str: The endpoint to make the request to.\n expected_status_code int: The expected status code of the response.\n headers dict: The headers to send with the request.\n should_check_response bool: A boolean to indicate if the status code and headers should be checked.\n \"\"\"\n\n endpoint = endpoint.lstrip(\"/\")\n if method not in [\"get\", \"post\", \"put\", \"patch\", \"delete\", \"options\", \"trace\"]:\n raise ValueError(f\"{method} method must be one of get, post, put, patch, delete\")\n if method == \"get\":\n response = requests.get(f\"{BASE_URL}/{endpoint}\", headers=headers)\n else:\n response = requests.request(method, f\"{BASE_URL}/{endpoint}\", data=data, headers=headers)\n if should_check_response:\n check_response(response, expected_status_code)\n return response\n"
},
{
"path": "integration_tests/helpers/network_helpers.py",
"content": "import platform\nimport socket\n\n\ndef get_network_host():\n # windows doesn't support 0.0.0.0\n if platform.system() == \"Windows\":\n hostname = socket.gethostname()\n ip_address = socket.gethostbyname(hostname)\n return ip_address\n else:\n return \"0.0.0.0\"\n"
},
{
"path": "integration_tests/index.html",
"content": "\n\n \n \n \n Document\n \n \n Hello world. How are you?\n \n\n"
},
{
"path": "integration_tests/index.py",
"content": "from robyn import Robyn\n\napp = Robyn(__file__)\n\n\n@app.get(\"/\")\nasync def h():\n return \"Hello, world!\"\n\n\napp.start()\n"
},
{
"path": "integration_tests/openapi_config.json",
"content": "{\n \"openapi\": \"3.1.0\",\n \"info\": {\n \"title\": \"Robyn Test API\",\n \"version\": \"1.0.0\",\n \"description\": null,\n \"termsOfService\": null,\n \"contact\": {\n \"name\": null,\n \"url\": null,\n \"email\": null\n },\n \"license\": {\n \"name\": null,\n \"url\": null\n },\n \"servers\": [],\n \"externalDocs\": {\n \"description\": null,\n \"url\": null\n },\n \"components\": {\n \"schemas\": {},\n \"responses\": {},\n \"parameters\": {},\n \"examples\": {},\n \"requestBodies\": {},\n \"securitySchemes\": {},\n \"links\": {},\n \"callbacks\": {},\n \"pathItems\": {}\n }\n },\n \"paths\": {\n \"/\": {\n \"get\": {\n \"summary\": \"\",\n \"description\": \"No description provided\",\n \"parameters\": [],\n \"tags\": [\n \"get\"\n ],\n \"responses\": {\n \"200\": {\n \"description\": \"Successful Response\",\n \"content\": {\n \"text/plain\": {\n \"schema\": {}\n }\n }\n }\n }\n }\n }\n },\n \"components\": {\n \"schemas\": {},\n \"responses\": {},\n \"parameters\": {},\n \"examples\": {},\n \"requestBodies\": {},\n \"securitySchemes\": {},\n \"links\": {},\n \"callbacks\": {},\n \"pathItems\": {}\n },\n \"servers\": [],\n \"externalDocs\": null\n}"
},
{
"path": "integration_tests/random_number.rs",
"content": "// rustimport:pyo3\n\nuse pyo3::prelude::*;\n\n#[pyfunction]\nfn say_hello() {\n println!(\"Hello from random_number, implemented in Rust!\")\n}\n\n// Uncomment the below to implement custom pyo3 binding code. Otherwise, \n// rustimport will generate it for you for all functions annotated with\n// #[pyfunction] and all structs annotated with #[pyclass].\n//\n//#[pymodule]\n//fn random_number(_py: Python, m: &PyModule) -> PyResult<()> {\n// m.add_function(wrap_pyfunction!(say_hello, m)?)?;\n// Ok(())\n//}\n"
},
{
"path": "integration_tests/subroutes/__init__.py",
"content": "from robyn import SubRouter, WebSocketDisconnect, jsonify\n\nfrom .di_subrouter import di_subrouter\nfrom .file_api import static_router\n\nsub_router = SubRouter(__name__, prefix=\"/sub_router\")\n\n__all__ = [\"sub_router\", \"di_subrouter\", \"static_router\"]\n\n\n@sub_router.websocket(\"/ws\")\nasync def ws_handler(websocket):\n try:\n while True:\n await websocket.receive_text()\n await websocket.send_text(\"Message\")\n except WebSocketDisconnect:\n pass\n\n\n@ws_handler.on_connect\nasync def connect(websocket):\n return \"Hello world, from ws\"\n\n\n@ws_handler.on_close\nasync def close(websocket):\n return jsonify({\"message\": \"closed\"})\n\n\n@sub_router.get(\"/foo\")\ndef get_foo():\n return {\"message\": \"foo\"}\n\n\n@sub_router.post(\"/foo\")\ndef post_foo():\n return {\"message\": \"foo\"}\n\n\n@sub_router.put(\"/foo\")\ndef put_foo():\n return {\"message\": \"foo\"}\n\n\n@sub_router.delete(\"/foo\")\ndef delete_foo():\n return {\"message\": \"foo\"}\n\n\n@sub_router.patch(\"/foo\")\ndef patch_foo():\n return {\"message\": \"foo\"}\n\n\n@sub_router.options(\"/foo\")\ndef option_foo():\n return {\"message\": \"foo\"}\n\n\n@sub_router.trace(\"/foo\")\ndef trace_foo():\n return {\"message\": \"foo\"}\n\n\n@sub_router.head(\"/foo\")\ndef head_foo():\n return {\"message\": \"foo\"}\n\n\n@sub_router.post(\"/openapi_test\", openapi_tags=[\"test subrouter tag\"])\ndef sample_subrouter_openapi_endpoint():\n \"\"\"Get subrouter openapi\"\"\"\n return 200\n"
},
{
"path": "integration_tests/subroutes/di_subrouter.py",
"content": "from robyn import Request, SubRouter\n\ndi_subrouter = SubRouter(__file__, \"/di_subrouter\")\nGLOBAL_DEPENDENCY = \"GLOBAL DEPENDENCY OVERRIDE\"\nROUTER_DEPENDENCY = \"ROUTER DEPENDENCY\"\ndi_subrouter.inject_global(GLOBAL_DEPENDENCY=GLOBAL_DEPENDENCY)\ndi_subrouter.inject(ROUTER_DEPENDENCY=ROUTER_DEPENDENCY)\n\n\n@di_subrouter.get(\"/subrouter_router_di\")\ndef sync_subrouter_route_dependency(r: Request, router_dependencies, global_dependencies):\n return router_dependencies[\"ROUTER_DEPENDENCY\"]\n\n\n@di_subrouter.get(\"/subrouter_global_di\")\ndef sync_subrouter_global_dependency(global_dependencies):\n return global_dependencies[\"GLOBAL_DEPENDENCY\"]\n"
},
{
"path": "integration_tests/subroutes/file_api.py",
"content": "\"\"\"\nTest routes for issue #1251: static files + API routes at same base path.\n\nNotes:\n1. No need to test every method, just one is enough to ensure no conflict.\n2. The static files are served from ./integration_tests to avoid conflict with the /test_dir route in main app.\n3. The static file serving route is defined in a separate SubRouter to isolate it from the main app routes.\n4. Serving api & files from the same /static path to test the fix.\n\"\"\"\n\nfrom robyn import Request, SubRouter\n\nstatic_router = SubRouter(__name__, \"/static\")\n\n\n@static_router.get(\"/build\")\n@static_router.post(\"/build\")\nasync def build_handler(request: Request):\n \"\"\"\n Test route ensuring no conflict with static file serving at /static.\n\n Although static files are served at /static, this API route should be reached\n because /build is not a file, so the request falls through to the API handler.\n \"\"\"\n return f\"{request.method}:{request.url.path} works\"\n"
},
{
"path": "integration_tests/templates/test.html",
"content": "{# templates/test.html #}\n\n\n\n\n \n Results\n\n\n\n
{{framework}} 🤝 {{templating_engine}}
\n\n\n"
},
{
"path": "integration_tests/test_add_route_without_decorator.py",
"content": "from collections.abc import Callable\n\nimport pytest\n\nfrom integration_tests.helpers.http_methods_helpers import get, post, put\n\n\n@pytest.mark.benchmark\n@pytest.mark.usefixtures(\"session\")\n@pytest.mark.parametrize(\n \"route,method\",\n [\n (\"/sync/get/no_dec\", get),\n (\"/async/get/no_dec\", get),\n (\"/sync/put/no_dec\", put),\n (\"/async/put/no_dec\", put),\n (\"/sync/post/no_dec\", post),\n (\"/async/post/no_dec\", post),\n ],\n)\ndef test_exception_handling(route: str, method: Callable):\n r = method(route, expected_status_code=200)\n assert r.text == \"Success!\"\n"
},
{
"path": "integration_tests/test_app.py",
"content": "import pytest\n\nfrom robyn import ALLOW_CORS, Robyn\nfrom robyn.events import Events\nfrom robyn.robyn import Headers\n\n\n@pytest.mark.benchmark\ndef test_add_request_header():\n app = Robyn(__file__)\n app.set_request_header(\"server\", \"robyn\")\n assert app.request_headers.get_headers() == Headers({\"server\": \"robyn\"}).get_headers()\n\n\n@pytest.mark.benchmark\ndef test_add_response_header():\n app = Robyn(__file__)\n app.add_response_header(\"content-type\", \"application/json\")\n assert app.response_headers.get_headers() == Headers({\"content-type\": \"application/json\"}).get_headers()\n\n\n@pytest.mark.benchmark\ndef test_lifecycle_handlers():\n def mock_startup_handler():\n pass\n\n async def mock_shutdown_handler():\n pass\n\n app = Robyn(__file__)\n\n app.startup_handler(mock_startup_handler)\n assert Events.STARTUP in app.event_handlers\n startup = app.event_handlers[Events.STARTUP]\n assert startup.handler == mock_startup_handler\n assert startup.is_async is False\n assert startup.number_of_params == 0\n\n app.shutdown_handler(mock_shutdown_handler)\n assert Events.SHUTDOWN in app.event_handlers\n shutdown = app.event_handlers[Events.SHUTDOWN]\n assert shutdown.handler == mock_shutdown_handler\n assert shutdown.is_async is True\n assert shutdown.number_of_params == 0\n\n\n@pytest.mark.benchmark\ndef test_allow_cors():\n app = Robyn(__file__)\n ALLOW_CORS(app, [\"*\"])\n\n headers = Headers({})\n headers.set(\"Access-Control-Allow-Origin\", \"*\")\n headers.set(\n \"Access-Control-Allow-Methods\",\n \"GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS\",\n )\n headers.set(\"Access-Control-Allow-Headers\", \"Content-Type, Authorization\")\n headers.set(\"Access-Control-Allow-Credentials\", \"true\")\n assert app.response_headers.get_headers() == headers.get_headers()\n"
},
{
"path": "integration_tests/test_authentication.py",
"content": "from urllib.parse import urlparse\n\nimport pytest\n\nfrom integration_tests.helpers.http_methods_helpers import get\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_valid_authentication(session, function_type: str):\n r = get(f\"/{function_type}/auth\", headers={\"Authorization\": \"Bearer valid\"})\n assert r.text == \"authenticated\"\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_valid_authentication_trailing_slash(session, function_type: str):\n r = get(f\"/{function_type}/auth/\", headers={\"Authorization\": \"Bearer valid\"})\n # Checks whether request is being sent to exact /trailing/ route.\n assert urlparse(r.url).path == f\"/{function_type}/auth/\"\n assert r.text == \"authenticated\"\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_invalid_authentication_token(session, function_type: str):\n r = get(\n f\"/{function_type}/auth\",\n headers={\"Authorization\": \"Bearer invalid\"},\n should_check_response=False,\n )\n assert r.status_code == 401\n assert r.headers.get(\"WWW-Authenticate\") == \"BearerGetter\"\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_invalid_authentication_token_trailing_slash(session, function_type: str):\n r = get(\n f\"/{function_type}/auth/\",\n headers={\"Authorization\": \"Bearer invalid\"},\n should_check_response=False,\n )\n assert urlparse(r.url).path == f\"/{function_type}/auth/\"\n assert r.status_code == 401\n assert r.headers.get(\"WWW-Authenticate\") == \"BearerGetter\"\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_invalid_authentication_header(session, function_type: str):\n r = get(\n f\"/{function_type}/auth\",\n headers={\"Authorization\": \"Bear valid\"},\n should_check_response=False,\n )\n assert r.status_code == 401\n assert r.headers.get(\"WWW-Authenticate\") == \"BearerGetter\"\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_invalid_authentication_header_trailing_slash(session, function_type: str):\n r = get(\n f\"/{function_type}/auth/\",\n headers={\"Authorization\": \"Bear valid\"},\n should_check_response=False,\n )\n assert r.status_code == 401\n assert r.headers.get(\"WWW-Authenticate\") == \"BearerGetter\"\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_invalid_authentication_no_token(session, function_type: str):\n r = get(f\"/{function_type}/auth\", should_check_response=False)\n assert r.status_code == 401\n assert r.headers.get(\"WWW-Authenticate\") == \"BearerGetter\"\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_invalid_authentication_no_token_trailing_slash(session, function_type: str):\n r = get(f\"/{function_type}/auth/\", should_check_response=False)\n assert r.status_code == 401\n assert r.headers.get(\"WWW-Authenticate\") == \"BearerGetter\"\n"
},
{
"path": "integration_tests/test_base_url.py",
"content": "import os\n\nimport pytest\nimport requests\n\nfrom integration_tests.helpers.network_helpers import get_network_host\n\n\n@pytest.mark.benchmark\ndef test_default_url_index_request(default_session):\n BASE_URL = \"http://127.0.0.1:8080\"\n res = requests.get(f\"{BASE_URL}\")\n assert res.status_code == 200\n\n\n@pytest.mark.benchmark\ndef test_local_index_request(session):\n BASE_URL = \"http://127.0.0.1:8080\"\n res = requests.get(f\"{BASE_URL}\")\n assert os.getenv(\"ROBYN_HOST\") == \"127.0.0.1\"\n assert res.status_code == 200\n\n\n@pytest.mark.benchmark\ndef test_global_index_request(global_session):\n host = get_network_host()\n BASE_URL = f\"http://{host}:8080\"\n res = requests.get(f\"{BASE_URL}\")\n assert os.getenv(\"ROBYN_HOST\") == f\"{host}\"\n assert res.status_code == 200\n"
},
{
"path": "integration_tests/test_basic_routes.py",
"content": "# Test the routes with:\n# - the GET method\n# - most common return types\n# - sync and async\n\nfrom typing import Optional\n\nimport pytest\n\nfrom integration_tests.helpers.http_methods_helpers import get\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\n \"route,expected_text,expected_header_key,expected_header_value\",\n [\n (\"/sync/str\", \"sync str get\", None, None),\n (\"/sync/dict\", \"sync dict get\", \"sync\", \"dict\"),\n (\"/sync/response\", \"sync response get\", \"sync\", \"response\"),\n (\"/sync/str/const\", \"sync str const get\", None, None),\n (\"/sync/dict/const\", \"sync dict const get\", \"sync_const\", \"dict\"),\n (\"/sync/response/const\", \"sync response const get\", \"sync_const\", \"response\"),\n (\"/async/str\", \"async str get\", None, None),\n (\"/async/dict\", \"async dict get\", \"async\", \"dict\"),\n (\"/async/response\", \"async response get\", \"async\", \"response\"),\n (\"/async/str/const\", \"async str const get\", None, None),\n (\"/async/dict/const\", \"async dict const get\", \"async_const\", \"dict\"),\n (\n \"/async/response/const\",\n \"async response const get\",\n \"async_const\",\n \"response\",\n ),\n ],\n)\ndef test_basic_get(\n route: str,\n expected_text: str,\n expected_header_key: Optional[str],\n expected_header_value: Optional[str],\n session,\n):\n res = get(route)\n assert res.text == expected_text\n if expected_header_key is not None:\n assert expected_header_key in res.headers\n assert res.headers[expected_header_key] == expected_header_value\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\n \"route, expected_json\",\n [\n (\"/sync/json\", {\"sync json get\": \"json\"}),\n (\"/async/json\", {\"async json get\": \"json\"}),\n (\"/sync/json/const\", {\"sync json const get\": \"json\"}),\n (\"/async/json/const\", {\"async json const get\": \"json\"}),\n ],\n)\ndef test_json_get(route: str, expected_json: dict, session):\n res = get(route)\n for key in expected_json.keys():\n assert key in res.json()\n assert res.json()[key] == expected_json[key]\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\n \"route, expected_json\",\n [\n (\n \"/sync/http/param\",\n {\n \"method\": \"GET\",\n \"url\": {\n \"host\": \"127.0.0.1:8080\",\n \"path\": \"/sync/http/param\",\n \"scheme\": \"http\",\n },\n },\n ),\n (\n \"/async/http/param\",\n {\n \"method\": \"GET\",\n \"url\": {\n \"host\": \"127.0.0.1:8080\",\n \"path\": \"/async/http/param\",\n \"scheme\": \"http\",\n },\n },\n ),\n ],\n)\ndef test_http_request_info_get(route: str, expected_json: dict, session):\n res = get(route)\n for key in expected_json.keys():\n assert key in res.json()\n assert res.json()[key] == expected_json[key]\n"
},
{
"path": "integration_tests/test_binary_output.py",
"content": "import pytest\n\nfrom integration_tests.helpers.http_methods_helpers import get\n\nBASE_URL = \"http://127.0.0.1:8080\"\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\n \"route, text\",\n [\n (\"/sync/octet\", \"sync octet\"),\n (\"/async/octet\", \"async octet\"),\n (\"/sync/octet/response\", \"sync octet response\"),\n (\"/async/octet/response\", \"async octet response\"),\n ],\n)\ndef test_binary_output(route: str, text: str, session):\n r = get(route)\n assert r.headers.get(\"Content-Type\") == \"application/octet-stream\"\n assert r.text == text\n"
},
{
"path": "integration_tests/test_delete_requests.py",
"content": "import pytest\n\nfrom integration_tests.helpers.http_methods_helpers import delete\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_delete(function_type: str, session):\n res = delete(f\"/{function_type}/dict\")\n assert res.text == f\"{function_type} dict delete\"\n assert function_type in res.headers\n assert res.headers[function_type] == \"dict\"\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_delete_with_param(function_type: str, session):\n res = delete(f\"/{function_type}/body\", data={\"hello\": \"world\"})\n assert res.text == \"hello=world\"\n"
},
{
"path": "integration_tests/test_dependency_injection.py",
"content": "import pytest\n\nfrom integration_tests.helpers.http_methods_helpers import get\n\n\n@pytest.mark.benchmark\ndef test_global_dependency_injection():\n r = get(\"/sync/global_di\")\n assert r.status_code == 200\n assert r.text == \"GLOBAL DEPENDENCY\"\n\n\n@pytest.mark.benchmark\ndef test_router_dependency_injection():\n r = get(\"/sync/router_di\")\n assert r.status_code == 200\n assert r.text == \"ROUTER DEPENDENCY\"\n\n\n@pytest.mark.benchmark\ndef test_subrouter_global_dependency_injection():\n r = get(\"/di_subrouter/subrouter_global_di\")\n assert r.status_code == 200\n assert r.text == \"GLOBAL DEPENDENCY\"\n\n\n@pytest.mark.benchmark\ndef test_subrouter_router_dependency_injection():\n r = get(\"/di_subrouter/subrouter_router_di\")\n assert r.status_code == 200\n assert r.text == \"ROUTER DEPENDENCY\"\n"
},
{
"path": "integration_tests/test_easy_access_params.py",
"content": "import os\n\nimport pytest\nfrom websocket import create_connection\n\nfrom integration_tests.helpers.http_methods_helpers import get\n\nWS_BASE_URL = f\"ws://127.0.0.1:{os.environ.get('ROBYN_PORT', '8080')}\"\n\n\n# ===== HTTP: Path param + query param with type coercion =====\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_easy_access_path_and_query_params(session, function_type):\n r = get(f\"/easy/{function_type}/42?q=hello&page=5\")\n assert r.json() == {\"id\": 42, \"q\": \"hello\", \"page\": 5}\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_easy_access_default_value(session, function_type):\n r = get(f\"/easy/{function_type}/42?q=hello\")\n assert r.json() == {\"id\": 42, \"q\": \"hello\", \"page\": 1}\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_easy_access_missing_required_param(session, function_type):\n \"\"\"Missing required 'q' param should return 400.\"\"\"\n r = get(f\"/easy/{function_type}/42\", should_check_response=False)\n assert r.status_code == 400\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_easy_access_bad_type_coercion(session, function_type):\n \"\"\"Path param :id declared as int but given 'abc' should return 400.\"\"\"\n r = get(f\"/easy/{function_type}/abc?q=hello\", should_check_response=False)\n assert r.status_code == 400\n\n\n# ===== HTTP: Optional params =====\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_easy_access_optional_present(session, function_type):\n r = get(f\"/easy/{function_type}/optional?name=bob&age=30\")\n assert r.json() == {\"name\": \"bob\", \"age\": 30}\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_easy_access_optional_missing(session, function_type):\n r = get(f\"/easy/{function_type}/optional?name=bob\")\n assert r.json() == {\"name\": \"bob\", \"age\": None}\n\n\n# ===== HTTP: List params =====\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_easy_access_list_params(session, function_type):\n r = get(f\"/easy/{function_type}/list?tag=python&tag=rust&tag=web\")\n assert r.json() == {\"tags\": [\"python\", \"rust\", \"web\"]}\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_easy_access_list_single_value(session, function_type):\n r = get(f\"/easy/{function_type}/list?tag=python\")\n assert r.json() == {\"tags\": [\"python\"]}\n\n\n# ===== HTTP: Bool params =====\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_easy_access_bool_true(session, function_type):\n r = get(f\"/easy/{function_type}/bool?active=true\")\n assert r.json() == {\"active\": True}\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_easy_access_bool_false(session, function_type):\n r = get(f\"/easy/{function_type}/bool?active=false\")\n assert r.json() == {\"active\": False}\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_easy_access_bool_default(session, function_type):\n r = get(f\"/easy/{function_type}/bool\")\n assert r.json() == {\"active\": False}\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_easy_access_bool_numeric(session, function_type):\n r = get(f\"/easy/{function_type}/bool?active=1\")\n assert r.json() == {\"active\": True}\n\n\n# ===== HTTP: Mixed (Request object + individual params) =====\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_easy_access_mixed_with_request(session, function_type):\n r = get(f\"/easy/{function_type}/mixed/99?q=search\")\n assert r.json() == {\"id\": 99, \"q\": \"search\", \"method\": \"GET\"}\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_easy_access_mixed_with_default(session, function_type):\n r = get(f\"/easy/{function_type}/mixed/99\")\n assert r.json() == {\"id\": 99, \"q\": \"\", \"method\": \"GET\"}\n\n\n# ===== HTTP: Float params =====\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_easy_access_float(session, function_type):\n r = get(f\"/easy/{function_type}/float?price=19.99\")\n assert r.json() == {\"price\": 19.99}\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_easy_access_float_bad_value(session, function_type):\n r = get(f\"/easy/{function_type}/float?price=notanumber\", should_check_response=False)\n assert r.status_code == 400\n\n\n# ===== WebSocket: Easy access query params =====\n\n\ndef test_easy_access_ws_with_params(session):\n ws = create_connection(f\"{WS_BASE_URL}/web_socket_easy_access?room=chat&page=5\")\n connect_msg = ws.recv()\n assert connect_msg == \"connected to chat\"\n\n ws.send(\"hello\")\n response = ws.recv()\n assert response == \"room=chat page=5 msg=hello\"\n\n ws.close()\n\n\ndef test_easy_access_ws_with_defaults(session):\n ws = create_connection(f\"{WS_BASE_URL}/web_socket_easy_access\")\n connect_msg = ws.recv()\n assert connect_msg == \"connected to default\"\n\n ws.send(\"hello\")\n response = ws.recv()\n assert response == \"room=default page=1 msg=hello\"\n\n ws.close()\n"
},
{
"path": "integration_tests/test_exception_handling.py",
"content": "from collections.abc import Callable\n\nimport pytest\n\nfrom integration_tests.helpers.http_methods_helpers import get, post, put\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\n \"route,method\",\n [\n (\"/sync/exception/get\", get),\n (\"/async/exception/get\", get),\n (\"/sync/exception/put\", put),\n (\"/async/exception/put\", put),\n (\"/sync/exception/post\", post),\n (\"/async/exception/post\", post),\n ],\n)\ndef test_exception_handling(\n route: str,\n method: Callable,\n session,\n):\n r = method(route, expected_status_code=500)\n assert r.text == \"error msg: value error\"\n"
},
{
"path": "integration_tests/test_file_download.py",
"content": "import pytest\n\nfrom integration_tests.helpers.http_methods_helpers import get\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_file_download(function_type: str, session):\n r = get(f\"/{function_type}/file/download\")\n assert r.headers.get(\"Content-Disposition\") == \"attachment; filename=test.txt\"\n\n assert r.text == \"This is a test file for the downloading purpose\"\n"
},
{
"path": "integration_tests/test_get_requests.py",
"content": "import pytest\nimport requests\nfrom requests import Response\n\nfrom integration_tests.helpers.http_methods_helpers import get\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_param(function_type: str, session):\n r = get(f\"/{function_type}/param/1\")\n assert r.text == \"1\"\n r = get(f\"/{function_type}/param/12345\")\n assert r.text == \"12345\"\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_param_suffix(function_type: str, session):\n r = get(f\"/{function_type}/extra/foo/1/baz\")\n assert r.text == \"foo/1/baz\"\n r = get(f\"/{function_type}/extra/foo/bar/baz\")\n assert r.text == \"foo/bar/baz\"\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_serve_html(function_type: str, session):\n def check_response(r: Response):\n assert r.text.startswith(\"\")\n assert \"Hello world. How are you?\" in r.text\n\n check_response(get(f\"/{function_type}/serve/html\"))\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_template(function_type: str, session):\n def check_response(r: Response):\n assert r.text.startswith(\"\\n\\n\")\n assert \"Jinja2\" in r.text\n assert \"Robyn\" in r.text\n\n check_response(get(f\"/{function_type}/template\"))\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_queries(function_type: str, session):\n r = get(f\"/{function_type}/queries?hello=robyn\")\n assert r.json() == {\"hello\": [\"robyn\"]}\n\n r = get(f\"/{function_type}/queries\")\n assert r.json() == {}\n\n\n@pytest.mark.benchmark\ndef test_trailing_slash(session):\n r = requests.get(\"http://localhost:8080/trailing\") # `integration_tests#get` strips the trailing slash, tests always pass!`\n assert r.text == \"Trailing slash test successful!\"\n\n r = requests.get(\"http://localhost:8080/trailing/\")\n assert r.text == \"Trailing slash test successful!\"\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\"key, value\", [(\"fakesession\", \"fake-cookie-session-value\")])\ndef test_cookies(session, key, value):\n response = get(\"/cookie\", 200)\n\n # Cookies should be sent via Set-Cookie header, accessible via response.cookies\n assert response.cookies[key] == value\n\n\n@pytest.mark.benchmark\ndef test_multiple_cookies(session):\n response = get(\"/cookie/multiple\", 200)\n\n assert response.cookies[\"session\"] == \"abc123\"\n assert response.cookies[\"theme\"] == \"dark\"\n\n\n@pytest.mark.benchmark\ndef test_cookie_with_attributes(session):\n response = get(\"/cookie/attributes\", 200)\n\n # Check the cookie value\n assert response.cookies[\"secure_session\"] == \"secret123\"\n\n # Check the Set-Cookie header for attributes\n set_cookie_header = response.headers.get(\"Set-Cookie\", \"\")\n assert \"secure_session=secret123\" in set_cookie_header\n assert \"Path=/\" in set_cookie_header\n assert \"HttpOnly\" in set_cookie_header\n assert \"Secure\" in set_cookie_header\n assert \"SameSite=Strict\" in set_cookie_header\n assert \"Max-Age=3600\" in set_cookie_header\n\n\n@pytest.mark.benchmark\ndef test_cookie_overwrite(session):\n response = get(\"/cookie/overwrite\", 200)\n\n # Same-name cookies should be overwritten, final value should be used\n assert response.cookies[\"session\"] == \"final-value\"\n"
},
{
"path": "integration_tests/test_json_types.py",
"content": "import pytest\n\nfrom integration_tests.helpers.http_methods_helpers import get, json_post\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_json_integer_type_preserved(function_type: str, session):\n \"\"\"Test that integer values in JSON are preserved as integers, not strings\"\"\"\n json_data = {\"lid\": 570, \"count\": 42}\n res = json_post(f\"/{function_type}/request_json/types\", json_data=json_data)\n result = res.json()\n\n assert result[\"lid\"][\"value\"] == 570\n assert result[\"lid\"][\"type\"] == \"int\"\n assert result[\"count\"][\"value\"] == 42\n assert result[\"count\"][\"type\"] == \"int\"\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_json_null_type_preserved(function_type: str, session):\n \"\"\"Test that null values in JSON are preserved as None, not string 'null'\"\"\"\n json_data = {\"start\": None, \"end\": None}\n res = json_post(f\"/{function_type}/request_json/types\", json_data=json_data)\n result = res.json()\n\n assert result[\"start\"][\"value\"] is None\n assert result[\"start\"][\"type\"] == \"NoneType\"\n assert result[\"end\"][\"value\"] is None\n assert result[\"end\"][\"type\"] == \"NoneType\"\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_json_boolean_type_preserved(function_type: str, session):\n \"\"\"Test that boolean values in JSON are preserved as booleans, not strings\"\"\"\n json_data = {\"active\": True, \"deleted\": False}\n res = json_post(f\"/{function_type}/request_json/types\", json_data=json_data)\n result = res.json()\n\n assert result[\"active\"][\"value\"] is True\n assert result[\"active\"][\"type\"] == \"bool\"\n assert result[\"deleted\"][\"value\"] is False\n assert result[\"deleted\"][\"type\"] == \"bool\"\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_json_float_type_preserved(function_type: str, session):\n \"\"\"Test that float values in JSON are preserved as floats\"\"\"\n json_data = {\"price\": 19.99, \"rate\": 0.15}\n res = json_post(f\"/{function_type}/request_json/types\", json_data=json_data)\n result = res.json()\n\n assert result[\"price\"][\"value\"] == 19.99\n assert result[\"price\"][\"type\"] == \"float\"\n assert result[\"rate\"][\"value\"] == 0.15\n assert result[\"rate\"][\"type\"] == \"float\"\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_json_string_type_preserved(function_type: str, session):\n \"\"\"Test that string values in JSON remain strings\"\"\"\n json_data = {\"field_name\": \"mobile\", \"field_value\": \"111000111\"}\n res = json_post(f\"/{function_type}/request_json/types\", json_data=json_data)\n result = res.json()\n\n assert result[\"field_name\"][\"value\"] == \"mobile\"\n assert result[\"field_name\"][\"type\"] == \"str\"\n assert result[\"field_value\"][\"value\"] == \"111000111\"\n assert result[\"field_value\"][\"type\"] == \"str\"\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_json_array_type_preserved(function_type: str, session):\n \"\"\"Test that array values in JSON are preserved as lists\"\"\"\n json_data = {\"items\": [1, 2, 3], \"tags\": [\"a\", \"b\"]}\n res = json_post(f\"/{function_type}/request_json/types\", json_data=json_data)\n result = res.json()\n\n assert result[\"items\"][\"value\"] == [1, 2, 3]\n assert result[\"items\"][\"type\"] == \"list\"\n assert result[\"tags\"][\"value\"] == [\"a\", \"b\"]\n assert result[\"tags\"][\"type\"] == \"list\"\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_json_nested_object_type_preserved(function_type: str, session):\n \"\"\"Test that nested object values in JSON are preserved as dicts\"\"\"\n json_data = {\"user\": {\"name\": \"John\", \"age\": 30}}\n res = json_post(f\"/{function_type}/request_json/types\", json_data=json_data)\n result = res.json()\n\n assert result[\"user\"][\"value\"] == {\"name\": \"John\", \"age\": 30}\n assert result[\"user\"][\"type\"] == \"dict\"\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_json_mixed_types_preserved(function_type: str, session):\n \"\"\"Test the exact scenario from the bug report - mixed types in one request\"\"\"\n json_data = {\n \"lid\": 570,\n \"start\": None,\n \"field_name\": \"mobile\",\n \"field_value\": \"111000111\",\n }\n res = json_post(f\"/{function_type}/request_json/types\", json_data=json_data)\n result = res.json()\n\n # Integer should remain integer (not become \"570\")\n assert result[\"lid\"][\"value\"] == 570\n assert result[\"lid\"][\"type\"] == \"int\"\n\n # None should remain None (not become \"null\")\n assert result[\"start\"][\"value\"] is None\n assert result[\"start\"][\"type\"] == \"NoneType\"\n\n # Strings should remain strings\n assert result[\"field_name\"][\"value\"] == \"mobile\"\n assert result[\"field_name\"][\"type\"] == \"str\"\n assert result[\"field_value\"][\"value\"] == \"111000111\"\n assert result[\"field_value\"][\"type\"] == \"str\"\n\n\n# ===== Top-level JSON Array Parsing Tests (Issue #1145) =====\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_json_top_level_array_of_strings(function_type: str, session):\n \"\"\"Test that request.json() handles a top-level array of strings (exact scenario from #1145)\"\"\"\n json_data = [\"google_docs\", \"notion\"]\n res = json_post(f\"/{function_type}/request_json/array\", json_data=json_data)\n result = res.json()\n\n assert result[\"type\"] == \"list\"\n assert result[\"parsed\"] == [\"google_docs\", \"notion\"]\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_json_top_level_array_of_objects(function_type: str, session):\n \"\"\"Test that request.json() handles a top-level array of objects\"\"\"\n json_data = [{\"id\": 1, \"name\": \"Alice\"}, {\"id\": 2, \"name\": \"Bob\"}]\n res = json_post(f\"/{function_type}/request_json/array\", json_data=json_data)\n result = res.json()\n\n assert result[\"type\"] == \"list\"\n assert result[\"parsed\"] == [{\"id\": 1, \"name\": \"Alice\"}, {\"id\": 2, \"name\": \"Bob\"}]\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_json_top_level_empty_array(function_type: str, session):\n \"\"\"Test that request.json() handles an empty top-level array\"\"\"\n json_data = []\n res = json_post(f\"/{function_type}/request_json/array\", json_data=json_data)\n result = res.json()\n\n assert result[\"type\"] == \"list\"\n assert result[\"parsed\"] == []\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_json_top_level_array_of_mixed_types(function_type: str, session):\n \"\"\"Test that request.json() handles a top-level array with mixed types\"\"\"\n json_data = [1, \"two\", True, None, {\"key\": \"value\"}]\n res = json_post(f\"/{function_type}/request_json/array\", json_data=json_data)\n result = res.json()\n\n assert result[\"type\"] == \"list\"\n assert result[\"parsed\"] == [1, \"two\", True, None, {\"key\": \"value\"}]\n\n\n# ===== JSON List Serialization Tests (Issue #1300) =====\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_json_list_response_serialization(function_type: str, session):\n \"\"\"Test that returning a list from a handler is properly serialized as JSON\"\"\"\n res = get(f\"/{function_type}/json/list\")\n\n # Check content type is application/json\n assert res.headers[\"content-type\"] == \"application/json\"\n\n # Check that response is valid JSON (not Python str representation)\n result = res.json()\n assert isinstance(result, list)\n assert len(result) == 3\n\n # Verify the data structure and types are correct\n assert result[0] == {\"id\": 1, \"title\": \"First Post\", \"published\": True}\n assert result[1] == {\"id\": 2, \"title\": \"Draft Post\", \"published\": False}\n assert result[2] == {\"id\": 3, \"title\": \"Latest Post\", \"published\": True}\n\n # Verify booleans are proper JSON booleans (true/false), not Python (True/False)\n # This is implicitly tested by res.json() succeeding, but let's verify the raw response too\n assert \"true\" in res.text.lower()\n assert \"false\" in res.text.lower()\n assert \"True\" not in res.text # Python boolean should not appear\n assert \"False\" not in res.text\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_json_empty_list_response_serialization(function_type: str, session):\n \"\"\"Test that returning an empty list is properly serialized as JSON\"\"\"\n res = get(f\"/{function_type}/json/list/empty\")\n\n assert res.headers[\"content-type\"] == \"application/json\"\n result = res.json()\n assert result == []\n assert res.text == \"[]\"\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_json_list_primitives_response_serialization(function_type: str, session):\n \"\"\"Test that a list of primitives is properly serialized as JSON\"\"\"\n res = get(f\"/{function_type}/json/list/primitives\")\n\n assert res.headers[\"content-type\"] == \"application/json\"\n result = res.json()\n assert result == [1, 2, 3, \"four\", True, None]\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_json_dict_response_auto_serialization(function_type: str, session):\n \"\"\"Test that returning a dict from a handler is properly auto-serialized as JSON\"\"\"\n res = get(f\"/{function_type}/json/dict\")\n\n assert res.headers[\"content-type\"] == \"application/json\"\n result = res.json()\n assert result[\"message\"] == f\"{function_type} dict\"\n assert result[\"count\"] == 42\n assert result[\"active\"] is True\n"
},
{
"path": "integration_tests/test_middlewares.py",
"content": "import pytest\n\nfrom integration_tests.helpers.http_methods_helpers import get\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_middlewares(function_type: str, session):\n r = get(f\"/{function_type}/middlewares\")\n headers = r.headers\n # We do not want the request headers to be in the response\n assert not headers.get(\"before\")\n assert headers.get(\"after\")\n assert r.headers.get(\"after\") == f\"{function_type}_after_request\"\n assert r.text == f\"{function_type} middlewares after\"\n\n\n@pytest.mark.benchmark\ndef test_global_middleware(session):\n r = get(\"/sync/global/middlewares\")\n headers = r.headers\n assert headers.get(\"global_after\")\n assert r.headers.get(\"global_after\") == \"global_after_request\"\n assert r.text == \"sync global middlewares\"\n\n\n@pytest.mark.benchmark\ndef test_response_in_before_middleware(session):\n r = get(\"/sync/middlewares/401\", should_check_response=False)\n assert r.status_code == 401\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\n \"route\",\n [\n \"/sync/str/const\",\n \"/async/str/const\",\n \"/sync/dict/const\",\n \"/async/dict/const\",\n \"/sync/response/const\",\n \"/async/response/const\",\n ],\n)\ndef test_global_middleware_applied_to_const_routes(route: str, session):\n r = get(route)\n assert r.headers.get(\"global_after\") == \"global_after_request\", f\"Global after-request middleware was not applied to const route {route}\"\n"
},
{
"path": "integration_tests/test_multipart_data.py",
"content": "import pytest\n\nfrom integration_tests.helpers.http_methods_helpers import multipart_post\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\"function_type\", [\"sync\"])\ndef test_form_data(function_type: str, session):\n res = multipart_post(f\"/{function_type}/form_data\", files={\"hello\": \"world\"})\n assert \"multipart\" in res.text\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\"function_type\", [\"sync\"])\ndef test_multipart_file(function_type: str, session):\n res = multipart_post(f\"/{function_type}/multipart-file\", files={\"hello\": \"world\"})\n assert \"hello\" in res.text\n"
},
{
"path": "integration_tests/test_openapi.py",
"content": "import pytest\n\nfrom integration_tests.helpers.http_methods_helpers import get, json_post\nfrom robyn import Robyn\n\n\n@pytest.mark.benchmark\ndef test_custom_openapi_spec():\n app = Robyn(__file__, openapi_file_path=\"openapi_config.json\")\n\n openapi_spec = app.openapi.openapi_spec\n\n assert isinstance(openapi_spec, dict)\n\n assert \"openapi\" in openapi_spec\n assert \"info\" in openapi_spec\n assert \"paths\" in openapi_spec\n assert \"components\" in openapi_spec\n assert \"servers\" in openapi_spec\n assert \"externalDocs\" in openapi_spec\n\n assert openapi_spec[\"info\"][\"title\"] == \"Robyn Test API\"\n assert openapi_spec[\"info\"][\"version\"] == \"1.0.0\"\n\n\n@pytest.mark.benchmark\ndef test_docs_handler():\n # should_check_response = False because check_response raises a\n # failure if the global headers are not present in the response\n # provided we are excluding headers for /docs and /openapi.json\n html_response = get(\"/docs\", should_check_response=False)\n assert html_response.status_code == 200\n\n\n@pytest.mark.benchmark\ndef test_json_handler():\n openapi_response = get(\"/openapi.json\", should_check_response=False)\n\n assert openapi_response.status_code == 200\n\n openapi_spec = openapi_response.json()\n\n assert isinstance(openapi_spec, dict)\n assert \"openapi\" in openapi_spec\n assert \"info\" in openapi_spec\n assert \"paths\" in openapi_spec\n assert \"components\" in openapi_spec\n assert \"servers\" in openapi_spec\n assert \"externalDocs\" in openapi_spec\n\n\n@pytest.mark.benchmark\ndef test_add_openapi_path():\n openapi_response = get(\"/openapi.json\", should_check_response=False)\n\n assert openapi_response.status_code == 200\n\n openapi_spec = openapi_response.json()\n\n assert isinstance(openapi_spec, dict)\n\n route_type = \"get\"\n endpoint = \"/openapi_test\"\n openapi_description = \"Get openapi\"\n openapi_tags = [\"test tag\"]\n\n assert endpoint in openapi_spec[\"paths\"]\n assert route_type in openapi_spec[\"paths\"][endpoint]\n assert openapi_description == openapi_spec[\"paths\"][endpoint][route_type][\"description\"]\n assert openapi_tags == openapi_spec[\"paths\"][endpoint][route_type][\"tags\"]\n\n\n@pytest.mark.benchmark\ndef test_add_subrouter_paths():\n openapi_response = get(\"/openapi.json\", should_check_response=False)\n\n assert openapi_response.status_code == 200\n\n openapi_spec = openapi_response.json()\n\n assert isinstance(openapi_spec, dict)\n\n route_type = \"post\"\n endpoint = \"/sub_router/openapi_test\"\n openapi_description = \"Get subrouter openapi\"\n openapi_tags = [\"test subrouter tag\"]\n\n assert endpoint in openapi_spec[\"paths\"]\n assert route_type in openapi_spec[\"paths\"][endpoint]\n assert openapi_description == openapi_spec[\"paths\"][endpoint][route_type][\"description\"]\n assert openapi_tags == openapi_spec[\"paths\"][endpoint][route_type][\"tags\"]\n\n\n@pytest.mark.benchmark\ndef test_openapi_request_body():\n openapi_response = get(\"/openapi.json\", should_check_response=False)\n\n assert openapi_response.status_code == 200\n\n openapi_spec = openapi_response.json()\n\n assert isinstance(openapi_spec, dict)\n\n route_type = \"post\"\n endpoint = \"/openapi_request_body\"\n\n assert endpoint in openapi_spec[\"paths\"]\n assert route_type in openapi_spec[\"paths\"][endpoint]\n assert \"requestBody\" in openapi_spec[\"paths\"][endpoint][route_type]\n assert \"content\" in openapi_spec[\"paths\"][endpoint][route_type][\"requestBody\"]\n assert \"application/json\" in openapi_spec[\"paths\"][endpoint][route_type][\"requestBody\"][\"content\"]\n assert \"schema\" in openapi_spec[\"paths\"][endpoint][route_type][\"requestBody\"][\"content\"][\"application/json\"]\n assert \"properties\" in openapi_spec[\"paths\"][endpoint][route_type][\"requestBody\"][\"content\"][\"application/json\"][\"schema\"]\n\n assert \"name\" in openapi_spec[\"paths\"][endpoint][route_type][\"requestBody\"][\"content\"][\"application/json\"][\"schema\"][\"properties\"]\n assert \"description\" in openapi_spec[\"paths\"][endpoint][route_type][\"requestBody\"][\"content\"][\"application/json\"][\"schema\"][\"properties\"]\n assert \"price\" in openapi_spec[\"paths\"][endpoint][route_type][\"requestBody\"][\"content\"][\"application/json\"][\"schema\"][\"properties\"]\n assert \"tax\" in openapi_spec[\"paths\"][endpoint][route_type][\"requestBody\"][\"content\"][\"application/json\"][\"schema\"][\"properties\"]\n\n assert \"string\" == openapi_spec[\"paths\"][endpoint][route_type][\"requestBody\"][\"content\"][\"application/json\"][\"schema\"][\"properties\"][\"description\"][\"type\"]\n assert \"number\" == openapi_spec[\"paths\"][endpoint][route_type][\"requestBody\"][\"content\"][\"application/json\"][\"schema\"][\"properties\"][\"price\"][\"type\"]\n assert \"number\" == openapi_spec[\"paths\"][endpoint][route_type][\"requestBody\"][\"content\"][\"application/json\"][\"schema\"][\"properties\"][\"tax\"][\"type\"]\n\n assert \"object\" == openapi_spec[\"paths\"][endpoint][route_type][\"requestBody\"][\"content\"][\"application/json\"][\"schema\"][\"properties\"][\"name\"][\"type\"]\n\n assert \"first\" in openapi_spec[\"paths\"][endpoint][route_type][\"requestBody\"][\"content\"][\"application/json\"][\"schema\"][\"properties\"][\"name\"][\"properties\"]\n assert \"second\" in openapi_spec[\"paths\"][endpoint][route_type][\"requestBody\"][\"content\"][\"application/json\"][\"schema\"][\"properties\"][\"name\"][\"properties\"]\n assert \"initial\" in openapi_spec[\"paths\"][endpoint][route_type][\"requestBody\"][\"content\"][\"application/json\"][\"schema\"][\"properties\"][\"name\"][\"properties\"]\n\n assert (\n \"object\"\n in openapi_spec[\"paths\"][endpoint][route_type][\"requestBody\"][\"content\"][\"application/json\"][\"schema\"][\"properties\"][\"name\"][\"properties\"][\"initial\"][\n \"type\"\n ]\n )\n\n assert (\n \"is_present\"\n in openapi_spec[\"paths\"][endpoint][route_type][\"requestBody\"][\"content\"][\"application/json\"][\"schema\"][\"properties\"][\"name\"][\"properties\"][\"initial\"][\n \"properties\"\n ]\n )\n assert (\n \"letter\"\n in openapi_spec[\"paths\"][endpoint][route_type][\"requestBody\"][\"content\"][\"application/json\"][\"schema\"][\"properties\"][\"name\"][\"properties\"][\"initial\"][\n \"properties\"\n ]\n )\n\n assert {\"type\": \"string\"} in openapi_spec[\"paths\"][endpoint][route_type][\"requestBody\"][\"content\"][\"application/json\"][\"schema\"][\"properties\"][\"name\"][\n \"properties\"\n ][\"initial\"][\"properties\"][\"letter\"][\"anyOf\"]\n assert {\"type\": \"null\"} in openapi_spec[\"paths\"][endpoint][route_type][\"requestBody\"][\"content\"][\"application/json\"][\"schema\"][\"properties\"][\"name\"][\n \"properties\"\n ][\"initial\"][\"properties\"][\"letter\"][\"anyOf\"]\n\n\n@pytest.mark.benchmark\ndef test_openapi_response_body():\n openapi_response = get(\"/openapi.json\", should_check_response=False)\n\n assert openapi_response.status_code == 200\n\n openapi_spec = openapi_response.json()\n\n assert isinstance(openapi_spec, dict)\n\n route_type = \"post\"\n endpoint = \"/openapi_request_body\"\n\n assert endpoint in openapi_spec[\"paths\"]\n assert route_type in openapi_spec[\"paths\"][endpoint]\n assert \"responses\" in openapi_spec[\"paths\"][endpoint][route_type]\n assert \"200\" in openapi_spec[\"paths\"][endpoint][route_type][\"responses\"]\n\n assert openapi_spec[\"paths\"][endpoint][route_type][\"responses\"][\"200\"][\"description\"] == \"Successful Response\"\n\n assert \"content\" in openapi_spec[\"paths\"][endpoint][route_type][\"responses\"][\"200\"]\n\n assert \"application/json\" in openapi_spec[\"paths\"][endpoint][route_type][\"responses\"][\"200\"][\"content\"]\n assert \"schema\" in openapi_spec[\"paths\"][endpoint][route_type][\"responses\"][\"200\"][\"content\"][\"application/json\"]\n assert \"properties\" in openapi_spec[\"paths\"][endpoint][route_type][\"responses\"][\"200\"][\"content\"][\"application/json\"][\"schema\"]\n\n assert \"success\" in openapi_spec[\"paths\"][endpoint][route_type][\"responses\"][\"200\"][\"content\"][\"application/json\"][\"schema\"][\"properties\"]\n assert \"items_changed\" in openapi_spec[\"paths\"][endpoint][route_type][\"responses\"][\"200\"][\"content\"][\"application/json\"][\"schema\"][\"properties\"]\n\n assert (\n \"boolean\" == openapi_spec[\"paths\"][endpoint][route_type][\"responses\"][\"200\"][\"content\"][\"application/json\"][\"schema\"][\"properties\"][\"success\"][\"type\"]\n )\n\n assert (\n \"integer\"\n == openapi_spec[\"paths\"][endpoint][route_type][\"responses\"][\"200\"][\"content\"][\"application/json\"][\"schema\"][\"properties\"][\"items_changed\"][\"type\"]\n )\n\n\n@pytest.mark.benchmark\ndef test_openapi_query_params():\n openapi_response = get(\"/openapi.json\", should_check_response=False)\n\n assert openapi_response.status_code == 200\n\n openapi_spec = openapi_response.json()\n\n assert isinstance(openapi_spec, dict)\n\n route_type = \"post\"\n endpoint = \"/openapi_request_body\"\n\n assert endpoint in openapi_spec[\"paths\"]\n assert route_type in openapi_spec[\"paths\"][endpoint]\n assert \"parameters\" in openapi_spec[\"paths\"][endpoint][route_type]\n\n assert \"required\" == openapi_spec[\"paths\"][endpoint][route_type][\"parameters\"][0][\"name\"]\n assert \"query\" == openapi_spec[\"paths\"][endpoint][route_type][\"parameters\"][0][\"in\"]\n assert {\"type\": \"boolean\"} == openapi_spec[\"paths\"][endpoint][route_type][\"parameters\"][0][\"schema\"]\n\n\n@pytest.mark.benchmark\ndef test_openapi_json_body_typed():\n \"\"\"Test that a typed JsonBody subclass generates a proper requestBody schema in OpenAPI docs.\"\"\"\n openapi_response = get(\"/openapi.json\", should_check_response=False)\n\n assert openapi_response.status_code == 200\n\n openapi_spec = openapi_response.json()\n\n assert isinstance(openapi_spec, dict)\n\n route_type = \"post\"\n endpoint = \"/openapi_json_body\"\n\n assert endpoint in openapi_spec[\"paths\"]\n assert route_type in openapi_spec[\"paths\"][endpoint]\n assert \"requestBody\" in openapi_spec[\"paths\"][endpoint][route_type]\n assert \"content\" in openapi_spec[\"paths\"][endpoint][route_type][\"requestBody\"]\n assert \"application/json\" in openapi_spec[\"paths\"][endpoint][route_type][\"requestBody\"][\"content\"]\n assert \"schema\" in openapi_spec[\"paths\"][endpoint][route_type][\"requestBody\"][\"content\"][\"application/json\"]\n assert \"properties\" in openapi_spec[\"paths\"][endpoint][route_type][\"requestBody\"][\"content\"][\"application/json\"][\"schema\"]\n\n properties = openapi_spec[\"paths\"][endpoint][route_type][\"requestBody\"][\"content\"][\"application/json\"][\"schema\"][\"properties\"]\n assert \"fahrenheit\" in properties\n assert \"number\" == properties[\"fahrenheit\"][\"type\"]\n\n\n@pytest.mark.benchmark\ndef test_openapi_json_body_bare():\n \"\"\"Test that a bare JsonBody generates a requestBody with empty properties in OpenAPI docs.\"\"\"\n openapi_response = get(\"/openapi.json\", should_check_response=False)\n\n assert openapi_response.status_code == 200\n\n openapi_spec = openapi_response.json()\n\n assert isinstance(openapi_spec, dict)\n\n route_type = \"post\"\n # bare JsonBody routes should still have requestBody in the spec\n endpoint = \"/sync/json_body/bare\"\n\n assert endpoint in openapi_spec[\"paths\"]\n assert route_type in openapi_spec[\"paths\"][endpoint]\n assert \"requestBody\" in openapi_spec[\"paths\"][endpoint][route_type]\n assert \"content\" in openapi_spec[\"paths\"][endpoint][route_type][\"requestBody\"]\n assert \"application/json\" in openapi_spec[\"paths\"][endpoint][route_type][\"requestBody\"][\"content\"]\n\n\ntry:\n import pydantic # noqa: F401\n\n _HAS_PYDANTIC = True\nexcept ImportError:\n _HAS_PYDANTIC = False\n\n\n@pytest.mark.benchmark\n@pytest.mark.skipif(not _HAS_PYDANTIC, reason=\"pydantic not installed\")\ndef test_openapi_pydantic_request_body():\n \"\"\"Pydantic model on a regular route should produce a full JSON Schema in\n requestBody — no dedicated OpenAPI route needed.\"\"\"\n openapi_response = get(\"/openapi.json\", should_check_response=False)\n assert openapi_response.status_code == 200\n openapi_spec = openapi_response.json()\n\n endpoint = \"/sync/pydantic/user\"\n route = openapi_spec[\"paths\"][endpoint][\"post\"]\n\n assert route[\"tags\"] == [\"pydantic\"]\n assert route[\"description\"] == \"Create a user with Pydantic validation\"\n\n assert \"requestBody\" in route\n schema = route[\"requestBody\"][\"content\"][\"application/json\"][\"schema\"]\n\n assert schema[\"type\"] == \"object\"\n assert schema[\"title\"] == \"UserCreate\"\n\n props = schema[\"properties\"]\n assert props[\"name\"][\"type\"] == \"string\"\n assert props[\"name\"][\"title\"] == \"Name\"\n assert props[\"email\"][\"type\"] == \"string\"\n assert props[\"email\"][\"title\"] == \"Email\"\n assert props[\"age\"][\"type\"] == \"integer\"\n assert props[\"age\"][\"title\"] == \"Age\"\n assert props[\"active\"][\"type\"] == \"boolean\"\n assert props[\"active\"][\"title\"] == \"Active\"\n assert props[\"active\"][\"default\"] is True\n\n assert set(schema[\"required\"]) == {\"name\", \"email\", \"age\"}\n assert \"active\" not in schema[\"required\"]\n\n assert \"responses\" in route\n assert \"200\" in route[\"responses\"]\n assert \"application/json\" in route[\"responses\"][\"200\"][\"content\"]\n\n\n@pytest.mark.benchmark\n@pytest.mark.skipif(not _HAS_PYDANTIC, reason=\"pydantic not installed\")\ndef test_openapi_pydantic_nested_model():\n \"\"\"Nested Pydantic models on a regular route should use $ref and populate\n components/schemas — no dedicated OpenAPI route needed.\"\"\"\n openapi_response = get(\"/openapi.json\", should_check_response=False)\n assert openapi_response.status_code == 200\n openapi_spec = openapi_response.json()\n\n endpoint = \"/sync/pydantic/nested\"\n route = openapi_spec[\"paths\"][endpoint][\"post\"]\n\n assert route[\"tags\"] == [\"pydantic\"]\n assert route[\"description\"] == \"Create a user with nested address\"\n\n schema = route[\"requestBody\"][\"content\"][\"application/json\"][\"schema\"]\n assert schema[\"type\"] == \"object\"\n assert schema[\"title\"] == \"UserWithAddress\"\n\n assert schema[\"properties\"][\"name\"][\"type\"] == \"string\"\n assert schema[\"properties\"][\"email\"][\"type\"] == \"string\"\n assert schema[\"properties\"][\"address\"][\"$ref\"] == \"#/components/schemas/Address\"\n\n assert set(schema[\"required\"]) == {\"name\", \"email\", \"address\"}\n\n assert \"Address\" in openapi_spec[\"components\"][\"schemas\"]\n address_schema = openapi_spec[\"components\"][\"schemas\"][\"Address\"]\n assert address_schema[\"type\"] == \"object\"\n assert address_schema[\"title\"] == \"Address\"\n\n assert address_schema[\"properties\"][\"street\"][\"type\"] == \"string\"\n assert address_schema[\"properties\"][\"street\"][\"title\"] == \"Street\"\n assert address_schema[\"properties\"][\"city\"][\"type\"] == \"string\"\n assert address_schema[\"properties\"][\"city\"][\"title\"] == \"City\"\n assert address_schema[\"properties\"][\"zip_code\"][\"type\"] == \"string\"\n assert address_schema[\"properties\"][\"zip_code\"][\"title\"] == \"Zip Code\"\n\n assert set(address_schema[\"required\"]) == {\"street\", \"city\", \"zip_code\"}\n\n assert \"responses\" in route\n assert \"200\" in route[\"responses\"]\n assert \"application/json\" in route[\"responses\"][\"200\"][\"content\"]\n\n\n@pytest.mark.benchmark\n@pytest.mark.skipif(not _HAS_PYDANTIC, reason=\"pydantic not installed\")\ndef test_openapi_pydantic_return_type():\n \"\"\"When a route has a Pydantic model as return type annotation, the response\n schema should reflect the full Pydantic model schema, not just 'object'.\"\"\"\n openapi_response = get(\"/openapi.json\", should_check_response=False)\n assert openapi_response.status_code == 200\n openapi_spec = openapi_response.json()\n\n endpoint = \"/sync/pydantic/return_model\"\n route = openapi_spec[\"paths\"][endpoint][\"post\"]\n\n assert route[\"tags\"] == [\"pydantic\"]\n assert route[\"description\"] == \"Return the validated Pydantic model directly\"\n\n response_schema = route[\"responses\"][\"200\"][\"content\"][\"application/json\"][\"schema\"]\n assert response_schema[\"type\"] == \"object\"\n assert response_schema[\"title\"] == \"UserCreate\"\n assert \"properties\" in response_schema\n assert response_schema[\"properties\"][\"name\"][\"type\"] == \"string\"\n assert response_schema[\"properties\"][\"age\"][\"type\"] == \"integer\"\n assert set(response_schema[\"required\"]) == {\"name\", \"email\", \"age\"}\n\n\n@pytest.mark.benchmark\n@pytest.mark.skipif(not _HAS_PYDANTIC, reason=\"pydantic not installed\")\ndef test_openapi_pydantic_return_list_type():\n \"\"\"When a route returns list[PydanticModel], the response schema should be\n an array with items containing the full Pydantic model schema.\"\"\"\n openapi_response = get(\"/openapi.json\", should_check_response=False)\n assert openapi_response.status_code == 200\n openapi_spec = openapi_response.json()\n\n endpoint = \"/sync/pydantic/return_list\"\n route = openapi_spec[\"paths\"][endpoint][\"post\"]\n\n assert route[\"tags\"] == [\"pydantic\"]\n assert route[\"description\"] == \"Return a list of Pydantic models\"\n\n response_schema = route[\"responses\"][\"200\"][\"content\"][\"application/json\"][\"schema\"]\n assert response_schema[\"type\"] == \"array\"\n assert \"items\" in response_schema\n\n items = response_schema[\"items\"]\n assert items[\"type\"] == \"object\"\n assert items[\"title\"] == \"UserCreate\"\n assert items[\"properties\"][\"name\"][\"type\"] == \"string\"\n assert items[\"properties\"][\"age\"][\"type\"] == \"integer\"\n\n\n# ===== TypedDict request body tests =====\n\n\n@pytest.mark.benchmark\ndef test_openapi_typeddict_request_body():\n \"\"\"TypedDict subclass used as a parameter annotation should produce a\n requestBody schema in OpenAPI docs (issue #1254).\"\"\"\n openapi_response = get(\"/openapi.json\", should_check_response=False)\n assert openapi_response.status_code == 200\n openapi_spec = openapi_response.json()\n\n endpoint = \"/sync/typeddict/body\"\n route = openapi_spec[\"paths\"][endpoint][\"post\"]\n\n assert route[\"tags\"] == [\"typeddict\"]\n assert \"requestBody\" in route\n schema = route[\"requestBody\"][\"content\"][\"application/json\"][\"schema\"]\n assert \"properties\" in schema\n assert \"name\" in schema[\"properties\"]\n assert \"value\" in schema[\"properties\"]\n assert schema[\"properties\"][\"name\"][\"type\"] == \"string\"\n assert schema[\"properties\"][\"value\"][\"type\"] == \"integer\"\n\n assert \"responses\" in route\n assert \"200\" in route[\"responses\"]\n response_schema = route[\"responses\"][\"200\"][\"content\"][\"application/json\"][\"schema\"]\n assert \"properties\" in response_schema\n assert \"result\" in response_schema[\"properties\"]\n assert \"count\" in response_schema[\"properties\"]\n\n\n@pytest.mark.benchmark\ndef test_openapi_typeddict_with_request():\n \"\"\"TypedDict body combined with a Request param should still produce\n a requestBody schema (issue #1254).\"\"\"\n openapi_response = get(\"/openapi.json\", should_check_response=False)\n assert openapi_response.status_code == 200\n openapi_spec = openapi_response.json()\n\n endpoint = \"/sync/typeddict/with_request\"\n route = openapi_spec[\"paths\"][endpoint][\"post\"]\n\n assert \"requestBody\" in route\n schema = route[\"requestBody\"][\"content\"][\"application/json\"][\"schema\"]\n assert \"properties\" in schema\n assert \"name\" in schema[\"properties\"]\n assert \"value\" in schema[\"properties\"]\n\n\n@pytest.mark.benchmark\ndef test_typeddict_body_injection_sync():\n \"\"\"TypedDict-annotated parameter should receive the parsed JSON dict\n at runtime, not the raw string (issue #1254).\"\"\"\n response = json_post(\n \"/sync/typeddict/body\",\n json_data={\"name\": \"alice\", \"value\": 42},\n )\n assert response.status_code == 200\n data = response.json()\n assert data[\"result\"] == \"alice\"\n assert data[\"count\"] == 42\n\n\n@pytest.mark.benchmark\ndef test_typeddict_body_injection_async():\n \"\"\"Async handler with TypedDict body should also receive parsed JSON.\"\"\"\n response = json_post(\n \"/async/typeddict/body\",\n json_data={\"name\": \"bob\", \"value\": 7},\n )\n assert response.status_code == 200\n data = response.json()\n assert data[\"result\"] == \"bob\"\n assert data[\"count\"] == 7\n\n\n@pytest.mark.benchmark\ndef test_typeddict_body_with_request_injection():\n \"\"\"TypedDict body and Request object should coexist in the same handler.\"\"\"\n response = json_post(\n \"/sync/typeddict/with_request\",\n json_data={\"name\": \"charlie\", \"value\": 99},\n )\n assert response.status_code == 200\n data = response.json()\n assert data[\"method\"] == \"POST\"\n assert data[\"name\"] == \"charlie\"\n\n\n@pytest.mark.benchmark\ndef test_typeddict_body_invalid_json():\n \"\"\"Sending invalid JSON to a TypedDict-annotated handler should return 400.\"\"\"\n import requests\n\n response = requests.post(\n \"http://127.0.0.1:8080/sync/typeddict/body\",\n data=\"not valid json\",\n headers={\"Content-Type\": \"application/json\"},\n )\n assert response.status_code == 400\n"
},
{
"path": "integration_tests/test_patch_requests.py",
"content": "import pytest\n\nfrom integration_tests.helpers.http_methods_helpers import patch\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_patch(function_type: str, session):\n res = patch(f\"/{function_type}/dict\")\n assert res.text == f\"{function_type} dict patch\"\n assert function_type in res.headers\n assert res.headers[function_type] == \"dict\"\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_patch_with_param(function_type: str, session):\n res = patch(f\"/{function_type}/body\", data={\"hello\": \"world\"})\n assert res.text == \"hello=world\"\n"
},
{
"path": "integration_tests/test_post_requests.py",
"content": "import pytest\n\nfrom integration_tests.helpers.http_methods_helpers import post\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_post(function_type: str, session):\n res = post(f\"/{function_type}/dict\")\n assert res.text == f\"{function_type} dict post\"\n assert function_type in res.headers\n assert res.headers[function_type] == \"dict\"\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_post_with_param(function_type: str, session):\n res = post(f\"/{function_type}/body\", data={\"hello\": \"world\"})\n assert res.text == \"hello=world\"\n"
},
{
"path": "integration_tests/test_put_requests.py",
"content": "import pytest\n\nfrom integration_tests.helpers.http_methods_helpers import put\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_put(function_type: str, session):\n res = put(f\"/{function_type}/dict\")\n assert res.text == f\"{function_type} dict put\"\n assert function_type in res.headers\n assert res.headers[function_type] == \"dict\"\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_put_with_param(function_type: str, session):\n res = put(f\"/{function_type}/body\", data={\"hello\": \"world\"})\n assert res.text == \"hello=world\"\n"
},
{
"path": "integration_tests/test_pydantic.py",
"content": "import pytest\nimport requests\n\nfrom integration_tests.helpers.http_methods_helpers import json_post\n\nBASE_URL = \"http://127.0.0.1:8080\"\n\ntry:\n import pydantic\n\n _HAS_PYDANTIC = True\nexcept ImportError:\n _HAS_PYDANTIC = False\n\npytestmark = pytest.mark.skipif(not _HAS_PYDANTIC, reason=\"pydantic not installed\")\n\n\ndef _raw_post(endpoint: str, data: str, content_type: str = \"application/json\") -> requests.Response:\n url = f\"{BASE_URL}/{endpoint.lstrip('/')}\"\n return requests.post(url, data=data, headers={\"Content-Type\": content_type})\n\n\n# ===== Valid Pydantic Body =====\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_pydantic_valid_user_all_fields(function_type: str, session):\n \"\"\"All fields provided explicitly — every field value must round-trip correctly.\"\"\"\n json_data = {\"name\": \"Alice\", \"email\": \"alice@example.com\", \"age\": 30, \"active\": False}\n res = json_post(f\"/{function_type}/pydantic/user\", json_data=json_data)\n result = res.json()\n\n assert result[\"name\"] == \"Alice\"\n assert result[\"email\"] == \"alice@example.com\"\n assert result[\"age\"] == 30\n assert result[\"active\"] is False\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_pydantic_default_field_applied(function_type: str, session):\n \"\"\"Omitting 'active' should use the model default (True) and the handler must see it.\"\"\"\n json_data = {\"name\": \"Bob\", \"email\": \"bob@example.com\", \"age\": 25}\n res = json_post(f\"/{function_type}/pydantic/user\", json_data=json_data)\n result = res.json()\n\n assert result[\"name\"] == \"Bob\"\n assert result[\"email\"] == \"bob@example.com\"\n assert result[\"age\"] == 25\n assert result[\"active\"] is True\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_pydantic_string_to_int_coercion(function_type: str, session):\n \"\"\"Pydantic v2 in lax mode (default) coerces '30' string to int 30.\"\"\"\n json_data = {\"name\": \"Coerce\", \"email\": \"c@test.com\", \"age\": \"30\"}\n res = json_post(f\"/{function_type}/pydantic/user\", json_data=json_data)\n result = res.json()\n\n assert result[\"name\"] == \"Coerce\"\n assert result[\"age\"] == 30\n assert isinstance(result[\"age\"], int)\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_pydantic_extra_fields_ignored(function_type: str, session):\n \"\"\"Extra fields not in the model should be silently ignored (pydantic v2 default).\"\"\"\n json_data = {\"name\": \"Eve\", \"email\": \"eve@example.com\", \"age\": 28, \"extra_field\": \"should_be_ignored\", \"another\": 99}\n res = json_post(f\"/{function_type}/pydantic/user\", json_data=json_data)\n result = res.json()\n\n assert result[\"name\"] == \"Eve\"\n assert result[\"age\"] == 28\n assert \"extra_field\" not in result\n assert \"another\" not in result\n\n\n# ===== Invalid Pydantic Body — error structure verification =====\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_pydantic_missing_single_required_field(function_type: str, session):\n \"\"\"Missing 'age' should produce exactly one error with correct loc, type, and msg.\"\"\"\n json_data = {\"name\": \"Charlie\", \"email\": \"charlie@example.com\"}\n res = json_post(\n f\"/{function_type}/pydantic/user\",\n json_data=json_data,\n expected_status_code=422,\n should_check_response=False,\n )\n assert res.status_code == 422\n result = res.json()\n assert result[\"error\"] == \"Validation Error\"\n\n errors = result[\"detail\"]\n assert isinstance(errors, list)\n assert len(errors) == 1\n\n err = errors[0]\n assert err[\"loc\"] == [\"age\"]\n assert err[\"type\"] == \"missing\"\n assert \"required\" in err[\"msg\"].lower()\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_pydantic_missing_all_required_fields(function_type: str, session):\n \"\"\"Sending {} should produce errors for all 3 required fields (name, email, age).\"\"\"\n res = json_post(\n f\"/{function_type}/pydantic/user\",\n json_data={},\n expected_status_code=422,\n should_check_response=False,\n )\n assert res.status_code == 422\n result = res.json()\n assert result[\"error\"] == \"Validation Error\"\n\n errors = result[\"detail\"]\n assert isinstance(errors, list)\n error_fields = {tuple(e[\"loc\"]) for e in errors}\n assert (\"name\",) in error_fields\n assert (\"email\",) in error_fields\n assert (\"age\",) in error_fields\n\n for err in errors:\n assert err[\"type\"] == \"missing\"\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_pydantic_wrong_type_error_detail(function_type: str, session):\n \"\"\"Wrong type should produce error with correct loc and a meaningful msg.\"\"\"\n json_data = {\"name\": \"Diana\", \"email\": \"diana@example.com\", \"age\": \"not_a_number\"}\n res = json_post(\n f\"/{function_type}/pydantic/user\",\n json_data=json_data,\n expected_status_code=422,\n should_check_response=False,\n )\n assert res.status_code == 422\n result = res.json()\n assert result[\"error\"] == \"Validation Error\"\n\n errors = result[\"detail\"]\n age_errors = [e for e in errors if e[\"loc\"] == [\"age\"]]\n assert len(age_errors) == 1\n assert \"int\" in age_errors[0][\"type\"]\n assert \"input\" in age_errors[0]\n assert age_errors[0][\"input\"] == \"not_a_number\"\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_pydantic_multiple_type_errors(function_type: str, session):\n \"\"\"Multiple fields with wrong types should each produce their own error.\"\"\"\n json_data = {\"name\": 12345, \"email\": True, \"age\": \"bad\"}\n res = json_post(\n f\"/{function_type}/pydantic/user\",\n json_data=json_data,\n expected_status_code=422,\n should_check_response=False,\n )\n assert res.status_code == 422\n result = res.json()\n error_locs = {tuple(e[\"loc\"]) for e in result[\"detail\"]}\n assert (\"name\",) in error_locs\n assert (\"email\",) in error_locs\n assert (\"age\",) in error_locs\n\n\n# ===== Malformed / edge-case bodies =====\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_pydantic_invalid_json_syntax(function_type: str, session):\n \"\"\"Completely invalid JSON should return 422 with 'Invalid request body' error.\"\"\"\n res = _raw_post(f\"/{function_type}/pydantic/user\", data=\"not json at all {{{\")\n assert res.status_code == 422\n result = res.json()\n assert \"error\" in result\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_pydantic_empty_body(function_type: str, session):\n \"\"\"Empty body should return 422.\"\"\"\n res = _raw_post(f\"/{function_type}/pydantic/user\", data=\"\")\n assert res.status_code == 422\n result = res.json()\n assert \"error\" in result\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_pydantic_json_array_body(function_type: str, session):\n \"\"\"A JSON array instead of an object should return 422.\"\"\"\n res = _raw_post(f\"/{function_type}/pydantic/user\", data='[{\"name\": \"X\"}]')\n assert res.status_code == 422\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_pydantic_null_body(function_type: str, session):\n \"\"\"JSON null body should return 422.\"\"\"\n res = _raw_post(f\"/{function_type}/pydantic/user\", data=\"null\")\n assert res.status_code == 422\n\n\n# ===== Pydantic + Request object =====\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_pydantic_with_request_object(function_type: str, session):\n \"\"\"Handler receiving both Request and Pydantic model must see both correctly.\"\"\"\n json_data = {\"name\": \"Frank\", \"email\": \"frank@example.com\", \"age\": 35}\n res = json_post(f\"/{function_type}/pydantic/user_with_request\", json_data=json_data)\n result = res.json()\n\n assert result[\"method\"] == \"POST\"\n assert result[\"name\"] == \"Frank\"\n assert result[\"email\"] == \"frank@example.com\"\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_pydantic_with_request_validation_still_works(function_type: str, session):\n \"\"\"Validation must still trigger 422 even when Request is in the signature.\"\"\"\n json_data = {\"name\": \"Frank\"} # missing email and age\n res = json_post(\n f\"/{function_type}/pydantic/user_with_request\",\n json_data=json_data,\n expected_status_code=422,\n should_check_response=False,\n )\n assert res.status_code == 422\n result = res.json()\n assert result[\"error\"] == \"Validation Error\"\n error_fields = {tuple(e[\"loc\"]) for e in result[\"detail\"]}\n assert (\"email\",) in error_fields\n assert (\"age\",) in error_fields\n\n\n# ===== Nested Pydantic Models =====\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_pydantic_nested_model_valid(function_type: str, session):\n \"\"\"Valid nested model should be parsed and accessible through the parent.\"\"\"\n json_data = {\n \"name\": \"Grace\",\n \"email\": \"grace@example.com\",\n \"address\": {\"street\": \"123 Main St\", \"city\": \"Springfield\", \"zip_code\": \"62701\"},\n }\n res = json_post(f\"/{function_type}/pydantic/nested\", json_data=json_data)\n result = res.json()\n\n assert result[\"name\"] == \"Grace\"\n assert result[\"city\"] == \"Springfield\"\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_pydantic_nested_model_missing_nested_fields(function_type: str, session):\n \"\"\"Missing fields in nested model should produce errors with correct nested loc paths.\"\"\"\n json_data = {\n \"name\": \"Grace\",\n \"email\": \"grace@example.com\",\n \"address\": {\"street\": \"123 Main St\"}, # missing city and zip_code\n }\n res = json_post(\n f\"/{function_type}/pydantic/nested\",\n json_data=json_data,\n expected_status_code=422,\n should_check_response=False,\n )\n assert res.status_code == 422\n result = res.json()\n assert result[\"error\"] == \"Validation Error\"\n\n errors = result[\"detail\"]\n error_locs = {tuple(e[\"loc\"]) for e in errors}\n assert (\"address\", \"city\") in error_locs\n assert (\"address\", \"zip_code\") in error_locs\n\n for err in errors:\n assert err[\"type\"] == \"missing\"\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_pydantic_nested_model_missing_entirely(function_type: str, session):\n \"\"\"Missing the entire nested object should produce an error at the parent field.\"\"\"\n json_data = {\"name\": \"Grace\", \"email\": \"grace@example.com\"}\n res = json_post(\n f\"/{function_type}/pydantic/nested\",\n json_data=json_data,\n expected_status_code=422,\n should_check_response=False,\n )\n assert res.status_code == 422\n result = res.json()\n\n errors = result[\"detail\"]\n address_errors = [e for e in errors if e[\"loc\"] == [\"address\"]]\n assert len(address_errors) == 1\n assert address_errors[0][\"type\"] == \"missing\"\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_pydantic_nested_model_wrong_type(function_type: str, session):\n \"\"\"Passing a non-object for the nested model should return 422.\"\"\"\n json_data = {\n \"name\": \"Grace\",\n \"email\": \"grace@example.com\",\n \"address\": \"not an object\",\n }\n res = json_post(\n f\"/{function_type}/pydantic/nested\",\n json_data=json_data,\n expected_status_code=422,\n should_check_response=False,\n )\n assert res.status_code == 422\n result = res.json()\n errors = result[\"detail\"]\n address_errors = [e for e in errors if \"address\" in e[\"loc\"]]\n assert len(address_errors) >= 1\n\n\n# ===== Pydantic with PUT =====\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_pydantic_put_valid(function_type: str, session):\n \"\"\"Pydantic validation must work with PUT method.\"\"\"\n json_data = {\"name\": \"Hank\", \"email\": \"hank@example.com\", \"age\": 40}\n res = requests.put(f\"{BASE_URL}/{function_type}/pydantic/user\", json=json_data)\n result = res.json()\n\n assert result[\"updated\"] is True\n assert result[\"name\"] == \"Hank\"\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_pydantic_put_invalid(function_type: str, session):\n \"\"\"PUT with invalid body must also return 422 with proper error structure.\"\"\"\n json_data = {\"name\": \"Hank\"} # missing email and age\n res = requests.put(f\"{BASE_URL}/{function_type}/pydantic/user\", json=json_data)\n assert res.status_code == 422\n result = res.json()\n assert result[\"error\"] == \"Validation Error\"\n error_fields = {tuple(e[\"loc\"]) for e in result[\"detail\"]}\n assert (\"email\",) in error_fields\n assert (\"age\",) in error_fields\n\n\n# ===== Pydantic with PATCH =====\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_pydantic_patch_valid(function_type: str, session):\n \"\"\"Pydantic validation must work with PATCH method.\"\"\"\n json_data = {\"name\": \"Iris\", \"email\": \"iris@example.com\", \"age\": 29}\n res = requests.patch(f\"{BASE_URL}/{function_type}/pydantic/user\", json=json_data)\n result = res.json()\n\n assert result[\"patched\"] is True\n assert result[\"name\"] == \"Iris\"\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_pydantic_patch_invalid(function_type: str, session):\n \"\"\"PATCH with invalid body must also return 422.\"\"\"\n json_data = {\"name\": \"Iris\"} # missing email and age\n res = requests.patch(f\"{BASE_URL}/{function_type}/pydantic/user\", json=json_data)\n assert res.status_code == 422\n result = res.json()\n assert result[\"error\"] == \"Validation Error\"\n error_fields = {tuple(e[\"loc\"]) for e in result[\"detail\"]}\n assert (\"email\",) in error_fields\n assert (\"age\",) in error_fields\n\n\n# ===== Pydantic with DELETE =====\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_pydantic_delete_valid(function_type: str, session):\n \"\"\"Pydantic validation must work with DELETE method.\"\"\"\n json_data = {\"name\": \"Zara\", \"email\": \"zara@example.com\", \"age\": 33}\n res = requests.delete(f\"{BASE_URL}/{function_type}/pydantic/user\", json=json_data)\n result = res.json()\n\n assert result[\"deleted\"] is True\n assert result[\"name\"] == \"Zara\"\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_pydantic_delete_invalid(function_type: str, session):\n \"\"\"DELETE with invalid body must also return 422 with proper error structure.\"\"\"\n json_data = {\"name\": \"Zara\"} # missing email and age\n res = requests.delete(f\"{BASE_URL}/{function_type}/pydantic/user\", json=json_data)\n assert res.status_code == 422\n result = res.json()\n assert result[\"error\"] == \"Validation Error\"\n error_fields = {tuple(e[\"loc\"]) for e in result[\"detail\"]}\n assert (\"email\",) in error_fields\n assert (\"age\",) in error_fields\n\n\n# ===== Returning Pydantic models directly =====\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_pydantic_return_model_directly(function_type: str, session):\n \"\"\"Returning a Pydantic model from a handler should auto-serialize to JSON.\"\"\"\n json_data = {\"name\": \"Jack\", \"email\": \"jack@example.com\", \"age\": 32}\n res = requests.post(f\"{BASE_URL}/{function_type}/pydantic/return_model\", json=json_data)\n\n assert res.status_code == 200\n assert \"application/json\" in res.headers.get(\"content-type\", \"\")\n\n result = res.json()\n assert result[\"name\"] == \"Jack\"\n assert result[\"email\"] == \"jack@example.com\"\n assert result[\"age\"] == 32\n assert result[\"active\"] is True # default field\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_pydantic_return_model_preserves_all_fields(function_type: str, session):\n \"\"\"Returned model should include every field, including those with defaults.\"\"\"\n json_data = {\"name\": \"Kate\", \"email\": \"kate@example.com\", \"age\": 27, \"active\": False}\n res = requests.post(f\"{BASE_URL}/{function_type}/pydantic/return_model\", json=json_data)\n result = res.json()\n\n assert result[\"name\"] == \"Kate\"\n assert result[\"email\"] == \"kate@example.com\"\n assert result[\"age\"] == 27\n assert result[\"active\"] is False\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_pydantic_return_model_validation_still_works(function_type: str, session):\n \"\"\"Validation should still trigger 422 even when the route returns a model.\"\"\"\n json_data = {\"name\": \"Kate\"} # missing email and age\n res = requests.post(f\"{BASE_URL}/{function_type}/pydantic/return_model\", json=json_data)\n assert res.status_code == 422\n result = res.json()\n assert result[\"error\"] == \"Validation Error\"\n\n\n# ===== Returning lists of Pydantic models =====\n\n\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_pydantic_return_list_of_models(function_type: str, session):\n \"\"\"Returning a list of Pydantic models should auto-serialize to a JSON array.\"\"\"\n json_data = {\"name\": \"Leo\", \"email\": \"leo@example.com\", \"age\": 45}\n res = requests.post(f\"{BASE_URL}/{function_type}/pydantic/return_list\", json=json_data)\n\n assert res.status_code == 200\n assert \"application/json\" in res.headers.get(\"content-type\", \"\")\n\n result = res.json()\n assert isinstance(result, list)\n assert len(result) == 2\n assert result[0][\"name\"] == \"Leo\"\n assert result[1][\"name\"] == \"Leo\"\n assert result[0][\"active\"] is True\n"
},
{
"path": "integration_tests/test_request_json.py",
"content": "import pytest\n\nfrom integration_tests.helpers.http_methods_helpers import post\n\n\n@pytest.mark.parametrize(\n \"route, body, expected_result\",\n [\n (\"/sync/request_json\", '{\"hello\": \"world\"}', \"\"),\n (\"/sync/request_json/key\", '{\"key\": \"world\"}', \"world\"),\n (\"/sync/request_json\", '{\"hello\": \"world\"', \"None\"),\n (\"/async/request_json\", '{\"hello\": \"world\"}', \"\"),\n (\"/async/request_json\", '{\"hello\": \"world\"', \"None\"),\n ],\n)\ndef test_request(route, body, expected_result):\n res = post(route, body)\n assert res.text == expected_result\n"
},
{
"path": "integration_tests/test_split_request_params.py",
"content": "import pytest\n\nfrom integration_tests.helpers.http_methods_helpers import get, json_post, post\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\n@pytest.mark.parametrize(\"type_route\", [\"split_request_untyped\", \"split_request_typed\"])\ndef test_split_request_params_get_query_params(session, type_route, function_type):\n r = get(f\"/{function_type}/{type_route}/query_params?hello=robyn\")\n assert r.json() == {\"hello\": [\"robyn\"]}\n r = get(f\"/{function_type}/{type_route}/query_params?hello=robyn&a=1&b=2\")\n assert r.json() == {\"hello\": [\"robyn\"], \"a\": [\"1\"], \"b\": [\"2\"]}\n r = get(f\"/{function_type}/{type_route}/query_params\")\n assert r.json() == {}\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\n@pytest.mark.parametrize(\"type_route\", [\"split_request_untyped\", \"split_request_typed\"])\ndef test_split_request_params_get_headers(session, type_route, function_type):\n r = get(f\"/{function_type}/{type_route}/headers\")\n assert r.text == \"robyn\"\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\n@pytest.mark.parametrize(\"type_route\", [\"split_request_untyped\", \"split_request_typed\"])\ndef test_split_request_params_get_path_params(session, type_route, function_type):\n r = get(f\"/{function_type}/{type_route}/path_params/123\")\n assert r.json() == {\"id\": \"123\"}\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\n@pytest.mark.parametrize(\"type_route\", [\"split_request_untyped\", \"split_request_typed\"])\ndef test_split_request_params_get_method(session, type_route, function_type):\n r = get(f\"/{function_type}/{type_route}/method\")\n assert r.text == \"GET\"\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\n@pytest.mark.parametrize(\"type_route\", [\"split_request_untyped\", \"split_request_typed\"])\ndef test_split_request_params_get_body(session, type_route, function_type):\n res = post(f\"/{function_type}/{type_route}/body\", data={\"hello\": \"world\"})\n assert res.text == \"hello=world\"\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\n@pytest.mark.parametrize(\"type_route\", [\"split_request_untyped\", \"split_request_typed\"])\ndef test_split_request_params_get_combined(session, type_route, function_type):\n res = post(\n f\"/{function_type}/{type_route}/combined?hello=robyn&a=1&b=2\",\n data={\"hello\": \"world\"},\n )\n out = res.json()\n assert out[\"query_params\"] == {\"hello\": [\"robyn\"], \"a\": [\"1\"], \"b\": [\"2\"]}\n assert out[\"body\"] == \"hello=world\"\n assert out[\"method\"] == \"POST\"\n assert out[\"url\"] == f\"/{function_type}/{type_route}/combined\"\n assert out[\"headers\"] == \"robyn\"\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_split_request_params_typed_untyped_post_combined(session, function_type):\n res = post(\n f\"/{function_type}/split_request_typed_untyped/combined?hello=robyn&a=1&b=2\",\n data={\"hello\": \"world\"},\n )\n out = res.json()\n assert out[\"query_params\"] == {\"hello\": [\"robyn\"], \"a\": [\"1\"], \"b\": [\"2\"]}\n assert out[\"body\"] == \"hello=world\"\n assert out[\"method\"] == \"POST\"\n assert out[\"url\"] == f\"/{function_type}/split_request_typed_untyped/combined\"\n assert out[\"headers\"] == \"robyn\"\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_split_request_params_get_combined_failure(session, function_type):\n # 'vishnu' is an unknown param with no default — now returns 400 (was 500 before easy-access params)\n # because unresolved params are treated as missing required query params\n res = post(f\"/{function_type}/split_request_typed_untyped/combined/failure?hello=robyn&a=1&b=2\", data={\"hello\": \"world\"}, should_check_response=False)\n assert 400 == res.status_code\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_json_body_bare(session, function_type):\n \"\"\"Test that bare JsonBody passes the parsed JSON dict to the handler.\"\"\"\n res = json_post(f\"/{function_type}/json_body/bare\", json_data={\"hello\": \"world\", \"count\": 42})\n assert res.json() == {\"hello\": \"world\", \"count\": 42}\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_json_body_typed(session, function_type):\n \"\"\"Test that typed JsonBody subclass passes the parsed JSON dict to the handler.\"\"\"\n res = json_post(f\"/{function_type}/json_body/typed\", json_data={\"fahrenheit\": 212})\n result = res.json()\n assert result[\"celsius\"] == pytest.approx(100.0)\n"
},
{
"path": "integration_tests/test_sse.py",
"content": "import json\n\nimport pytest\nimport requests\n\nfrom integration_tests.helpers.http_methods_helpers import BASE_URL\nfrom robyn.responses import SSEMessage, SSEResponse, StreamingResponse\n\n\n@pytest.mark.benchmark\ndef test_sse_basic_headers(session):\n \"\"\"Test that SSE endpoints return correct headers\"\"\"\n response = requests.get(f\"{BASE_URL}/sse/basic\", stream=True)\n\n assert response.status_code == 200\n assert response.headers.get(\"Content-Type\") == \"text/event-stream\"\n # Accept either clean optimized headers or legacy compatibility\n cache_control = response.headers.get(\"Cache-Control\")\n assert cache_control in [\"no-cache, no-store, must-revalidate\", \"no-cache, no-cache, no-store, must-revalidate\"]\n\n\n@pytest.mark.benchmark\ndef test_sse_basic_stream(session):\n \"\"\"Test basic SSE streaming with simple data messages\"\"\"\n response = requests.get(f\"{BASE_URL}/sse/basic\", stream=True, timeout=5)\n response.raise_for_status()\n\n content = \"\"\n for chunk in response.iter_content(chunk_size=1024, decode_unicode=True):\n if chunk:\n content += chunk\n if content.count(\"\\n\\n\") >= 3: # Got 3 messages\n break\n\n # Parse events\n events = []\n for line in content.split(\"\\n\"):\n if line.startswith(\"data: \"):\n events.append(line[6:]) # Remove 'data: ' prefix\n\n assert len(events) >= 3\n for i in range(3):\n assert f\"Test message {i}\" in events\n\n\n@pytest.mark.benchmark\ndef test_sse_formatted_messages(session):\n \"\"\"Test SSE messages formatted with SSEMessage helper\"\"\"\n response = requests.get(f\"{BASE_URL}/sse/formatted\", stream=True, timeout=5)\n response.raise_for_status()\n\n content = \"\"\n for chunk in response.iter_content(chunk_size=1024, decode_unicode=True):\n if chunk:\n content += chunk\n if content.count(\"\\n\\n\") >= 3:\n break\n\n # Should contain event and id fields\n assert \"event: test\" in content\n assert \"id: 0\" in content\n assert \"id: 1\" in content\n assert \"id: 2\" in content\n\n # Parse data lines\n data_lines = []\n for line in content.split(\"\\n\"):\n if line.startswith(\"data: \"):\n data_lines.append(line[6:])\n\n assert len(data_lines) >= 3\n for i in range(3):\n assert f\"Formatted message {i}\" in data_lines\n\n\n@pytest.mark.benchmark\ndef test_sse_json_data(session):\n \"\"\"Test SSE streaming with JSON data\"\"\"\n response = requests.get(f\"{BASE_URL}/sse/json\", stream=True, timeout=5)\n response.raise_for_status()\n\n content = \"\"\n for chunk in response.iter_content(chunk_size=1024, decode_unicode=True):\n if chunk:\n content += chunk\n if content.count(\"\\n\\n\") >= 3:\n break\n\n # Parse data lines\n data_lines = []\n for line in content.split(\"\\n\"):\n if line.startswith(\"data: \"):\n data_lines.append(line[6:])\n\n assert len(data_lines) >= 3\n for i in range(3):\n json_data = json.loads(data_lines[i])\n assert json_data[\"id\"] == i\n assert json_data[\"message\"] == f\"JSON message {i}\"\n assert json_data[\"type\"] == \"test\"\n\n\n@pytest.mark.benchmark\ndef test_sse_named_events(session):\n \"\"\"Test SSE with different event types\"\"\"\n response = requests.get(f\"{BASE_URL}/sse/named_events\", stream=True, timeout=5)\n response.raise_for_status()\n\n content = \"\"\n for chunk in response.iter_content(chunk_size=1024, decode_unicode=True):\n if chunk:\n content += chunk\n if content.count(\"\\n\\n\") >= 3:\n break\n\n # Should contain different event types\n assert \"event: start\" in content\n assert \"event: progress\" in content\n assert \"event: end\" in content\n\n # Should contain corresponding data\n assert \"data: Test started\" in content\n assert \"data: Test in progress\" in content\n assert \"data: Test completed\" in content\n\n\n@pytest.mark.benchmark\ndef test_sse_async_endpoint(session):\n \"\"\"Test async SSE endpoint\"\"\"\n response = requests.get(f\"{BASE_URL}/sse/async\", stream=True, timeout=5)\n response.raise_for_status()\n\n content = \"\"\n for chunk in response.iter_content(chunk_size=1024, decode_unicode=True):\n if chunk:\n content += chunk\n if content.count(\"\\n\\n\") >= 3:\n break\n\n # Parse data lines\n data_lines = []\n for line in content.split(\"\\n\"):\n if line.startswith(\"data: \"):\n data_lines.append(line[6:])\n\n assert len(data_lines) >= 3\n for i in range(3):\n assert f\"Async message {i}\" in data_lines\n\n\n@pytest.mark.benchmark\ndef test_sse_single_message(session):\n \"\"\"Test SSE endpoint that sends only one message\"\"\"\n response = requests.get(f\"{BASE_URL}/sse/single\", stream=True, timeout=3)\n response.raise_for_status()\n\n content = \"\"\n for chunk in response.iter_content(chunk_size=1024, decode_unicode=True):\n if chunk:\n content += chunk\n if \"\\n\\n\" in content: # Got at least one message\n break\n\n # Parse data lines\n data_lines = []\n for line in content.split(\"\\n\"):\n if line.startswith(\"data: \"):\n data_lines.append(line[6:])\n\n assert len(data_lines) == 1\n assert data_lines[0] == \"Single message\"\n\n\n@pytest.mark.benchmark\ndef test_sse_empty_stream(session):\n \"\"\"Test SSE endpoint that sends no messages\"\"\"\n response = requests.get(f\"{BASE_URL}/sse/empty\", stream=True, timeout=2)\n response.raise_for_status()\n\n content = \"\"\n for chunk in response.iter_content(chunk_size=1024, decode_unicode=True):\n if chunk:\n content += chunk\n # Don't wait forever for empty stream\n break\n\n # Parse data lines\n data_lines = []\n for line in content.split(\"\\n\"):\n if line.startswith(\"data: \"):\n data_lines.append(line[6:])\n\n assert len(data_lines) == 0\n\n\n@pytest.mark.benchmark\ndef test_sse_custom_headers(session):\n \"\"\"Test SSE endpoint with custom headers; SSE responses should not include default CORS headers for cross-origin EventSource support\"\"\"\n response = requests.get(f\"{BASE_URL}/sse/with_headers\", stream=True)\n\n assert response.status_code == 200\n assert response.headers.get(\"X-Custom-Header\") == \"custom-value\"\n assert response.headers.get(\"Content-Type\") == \"text/event-stream\"\n\n # SSE responses should not include default CORS headers\n assert response.headers.get(\"Access-Control-Allow-Origin\") is None\n assert response.headers.get(\"Access-Control-Allow-Headers\") is None\n\n\n@pytest.mark.benchmark\ndef test_sse_custom_status_code(session):\n \"\"\"Test SSE endpoint with custom status code\"\"\"\n response = requests.get(f\"{BASE_URL}/sse/status_code\", stream=True)\n\n assert response.status_code == 201\n assert response.headers.get(\"Content-Type\") == \"text/event-stream\"\n\n\n@pytest.mark.benchmark\ndef test_sse_middleware_compatibility(session):\n \"\"\"Test that SSE endpoints work with global middleware\"\"\"\n response = requests.get(f\"{BASE_URL}/sse/basic\", stream=True)\n\n # Should have global response headers from middleware\n assert response.headers.get(\"server\") == \"robyn\"\n\n\ndef test_sse_message_formatter():\n \"\"\"Test the SSEMessage formatter utility function\"\"\"\n\n # Test basic message\n result = SSEMessage(\"Hello world\")\n assert \"data: Hello world\\n\\n\" in result\n\n # Test with event type\n result = SSEMessage(\"Hello\", event=\"greeting\")\n assert \"event: greeting\\n\" in result\n assert \"data: Hello\\n\\n\" in result\n\n # Test with ID\n result = SSEMessage(\"Hello\", id=\"123\")\n assert \"id: 123\\n\" in result\n assert \"data: Hello\\n\\n\" in result\n\n # Test with retry\n result = SSEMessage(\"Hello\", retry=5000)\n assert \"retry: 5000\\n\" in result\n assert \"data: Hello\\n\\n\" in result\n\n # Test with all parameters\n result = SSEMessage(\"Hello\", event=\"test\", id=\"456\", retry=3000)\n assert \"event: test\\n\" in result\n assert \"id: 456\\n\" in result\n assert \"retry: 3000\\n\" in result\n assert \"data: Hello\\n\\n\" in result\n\n # Test multiline data\n result = SSEMessage(\"Line 1\\nLine 2\")\n assert \"data: Line 1\\ndata: Line 2\\n\\n\" in result\n\n\ndef test_sse_message_edge_cases():\n \"\"\"Test SSEMessage with edge cases\"\"\"\n\n # Test empty message\n result = SSEMessage(\"\")\n assert result == \"data: \\n\\n\"\n\n # Test None message (should handle gracefully)\n try:\n result = SSEMessage(None)\n assert \"data:\" in result\n except TypeError:\n # This is acceptable behavior\n pass\n\n # Test message with special characters\n special_message = \"Hello\\nWorld\\r\\nWith\\tTabs\"\n result = SSEMessage(special_message)\n assert \"data: Hello\\ndata: World\\ndata: With\\tTabs\\n\\n\" in result\n\n\ndef test_sse_response_classes():\n \"\"\"Test that SSE response classes can be imported correctly\"\"\"\n assert SSEResponse is not None\n assert SSEMessage is not None\n assert StreamingResponse is not None\n\n # Test basic functionality\n def simple_generator():\n yield \"data: test\\n\\n\"\n\n response = SSEResponse(simple_generator())\n assert response.media_type == \"text/event-stream\"\n assert response.status_code == 200\n\n\ndef test_sse_error_handling():\n \"\"\"Test error handling in SSE streams\"\"\"\n # Test with a non-existent endpoint\n response = requests.get(f\"{BASE_URL}/sse/nonexistent\", stream=True)\n assert response.status_code == 404\n\n\ndef test_sse_http_methods():\n \"\"\"Test that SSE endpoints only work with GET\"\"\"\n # GET should work\n response = requests.get(f\"{BASE_URL}/sse/basic\", stream=True)\n assert response.status_code == 200\n\n # POST should not work (404 or 405)\n response = requests.post(f\"{BASE_URL}/sse/basic\")\n assert response.status_code in [404, 405]\n\n\n@pytest.mark.benchmark\ndef test_sse_streaming_sync_real_time(session):\n \"\"\"Test that sync SSE streaming happens in real-time with timing delays\"\"\"\n import time\n\n start_time = time.time()\n response = requests.get(f\"{BASE_URL}/sse/streaming_sync\", stream=True, timeout=10)\n response.raise_for_status()\n\n messages_received = 0\n message_times = []\n\n content = \"\"\n for chunk in response.iter_content(chunk_size=1, decode_unicode=True):\n if chunk:\n content += chunk\n # Check for complete messages\n while \"\\n\\n\" in content:\n message_end = content.find(\"\\n\\n\") + 2\n message = content[:message_end]\n content = content[message_end:]\n\n if \"data:\" in message:\n messages_received += 1\n message_times.append(time.time() - start_time)\n\n if messages_received >= 3: # Got all 3 data messages\n break\n\n if messages_received >= 3:\n break\n\n # Verify we got 3 messages\n assert messages_received == 3\n\n # Verify timing: each message should arrive ~0.5s after the previous\n # Allow some tolerance for processing time (±200ms)\n for i in range(1, len(message_times)):\n time_diff = message_times[i] - message_times[i - 1]\n assert 0.3 <= time_diff <= 0.8, f\"Message {i} arrived {time_diff:.2f}s after previous (expected ~0.5s)\"\n\n\n@pytest.mark.benchmark\ndef test_sse_streaming_async_real_time(session):\n \"\"\"Test that async SSE streaming happens in real-time with timing delays\"\"\"\n import time\n\n start_time = time.time()\n response = requests.get(f\"{BASE_URL}/sse/streaming_async\", stream=True, timeout=10)\n response.raise_for_status()\n\n messages_received = 0\n message_times = []\n\n content = \"\"\n for chunk in response.iter_content(chunk_size=1, decode_unicode=True):\n if chunk:\n content += chunk\n # Check for complete messages\n while \"\\n\\n\" in content:\n message_end = content.find(\"\\n\\n\") + 2\n message = content[:message_end]\n content = content[message_end:]\n\n if \"data:\" in message and \"event: async\" in message:\n messages_received += 1\n message_times.append(time.time() - start_time)\n\n if messages_received >= 3: # Got all 3 data messages\n break\n\n if messages_received >= 3:\n break\n\n # Verify we got 3 messages\n assert messages_received == 3\n\n # Verify timing: each message should arrive ~0.3s after the previous\n # Allow some tolerance for processing time (±150ms)\n for i in range(1, len(message_times)):\n time_diff = message_times[i] - message_times[i - 1]\n assert 0.15 <= time_diff <= 0.5, f\"Async message {i} arrived {time_diff:.2f}s after previous (expected ~0.3s)\"\n\n\n@pytest.mark.benchmark\ndef test_sse_optimization_headers(session):\n \"\"\"Test that optimized SSE headers are present\"\"\"\n response = requests.get(f\"{BASE_URL}/sse/streaming_sync\", stream=True)\n\n assert response.status_code == 200\n\n # Check for optimization headers\n assert response.headers.get(\"Content-Type\") == \"text/event-stream\"\n # Accept either clean optimized headers or legacy compatibility\n cache_control = response.headers.get(\"Cache-Control\")\n assert cache_control in [\"no-cache, no-store, must-revalidate\", \"no-cache, no-cache, no-store, must-revalidate\"]\n assert response.headers.get(\"Pragma\") == \"no-cache\"\n assert response.headers.get(\"Expires\") == \"0\"\n assert response.headers.get(\"X-Accel-Buffering\") == \"no\" # Nginx buffering disabled\n # Connection header might be managed by underlying HTTP infrastructure\n connection = response.headers.get(\"Connection\")\n assert connection is None or connection == \"keep-alive\"\n\n\ndef test_sse_message_optimization():\n \"\"\"Test that SSEMessage formatting is optimized\"\"\"\n import time\n\n # Test single-line fast path\n start_time = time.perf_counter()\n for _ in range(1000):\n result = SSEMessage(\"Simple message\", id=\"123\")\n single_line_time = time.perf_counter() - start_time\n\n # Test multi-line path\n start_time = time.perf_counter()\n for _ in range(1000):\n result = SSEMessage(\"Line 1\\nLine 2\\nLine 3\", id=\"123\")\n multi_line_time = time.perf_counter() - start_time\n\n # Single-line should be faster (this is more of a performance regression test)\n assert single_line_time < multi_line_time * 2, \"Single-line SSEMessage optimization may have regressed\"\n\n # Verify correctness\n result = SSEMessage(\"Test\", event=\"test\", id=\"1\", retry=1000)\n expected_parts = [\"event: test\\n\", \"id: 1\\n\", \"retry: 1000\\n\", \"data: Test\\n\", \"\\n\"]\n for part in expected_parts:\n assert part in result\n"
},
{
"path": "integration_tests/test_static_files_with_api_routes.py",
"content": "\"\"\"\nTest for issue #1251: Verify that API routes work correctly\nwhen static files are served from the same base path.\n\nThis test ensures that non-GET/HEAD HTTP methods properly fall through\nto API handlers when a static file service is mounted at the same route.\n\"\"\"\n\nimport pytest\n\nfrom integration_tests.helpers.http_methods_helpers import get, post\n\n# Notes:\n# 1. The /static route serves the integration_tests having files & directories.\n\n\n@pytest.mark.benchmark\ndef test_post_api_route_with_root_static_files(session):\n \"\"\"Test that POST requests reach API handlers (issue #1251).\n This ensures that non-GET/HEAD methods are not blocked by static file serving.\n \"\"\"\n response = post(\"/static/build\")\n assert response.status_code == 200\n assert response.text == f\"{response.request.method}:{response.request.path_url} works\"\n\n\n@pytest.mark.benchmark\ndef test_static_file_still_served_correctly(session):\n \"\"\"Verify that actual static files are still served correctly.\"\"\"\n response = get(\"/static/build/index.html\", should_check_response=False)\n assert response.status_code == 200\n # Should serve the index.html file\n assert \"html\" in response.text.lower()\n"
},
{
"path": "integration_tests/test_status_code.py",
"content": "import pytest\nimport requests\n\nfrom integration_tests.helpers.http_methods_helpers import BASE_URL, get\n\n\n@pytest.mark.benchmark\ndef test_404_status_code(session):\n get(\"/404\", expected_status_code=404)\n\n\n@pytest.mark.benchmark\ndef test_404_not_found(session):\n r = get(\"/real/404\", expected_status_code=404)\n assert r.text == \"Not found\"\n\n\n@pytest.mark.benchmark\ndef test_202_status_code(session):\n get(\"/202\", expected_status_code=202)\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_sync_500_internal_server_error(function_type: str, session):\n get(f\"/{function_type}/raise\", expected_status_code=500)\n\n\n# ===== Content-Type on error responses =====\n\n\n@pytest.mark.benchmark\ndef test_404_not_found_content_type(session):\n \"\"\"A request to a non-existent route should return Content-Type: text/plain\"\"\"\n r = get(\"/real/404\", expected_status_code=404)\n assert r.text == \"Not found\"\n content_type = r.headers.get(\"Content-Type\", \"\")\n assert \"text/plain\" in content_type\n\n\n@pytest.mark.benchmark\n@pytest.mark.parametrize(\"function_type\", [\"sync\", \"async\"])\ndef test_500_error_content_type(function_type: str, session):\n \"\"\"An unhandled exception should return Content-Type: text/plain\"\"\"\n r = get(f\"/{function_type}/raise\", expected_status_code=500)\n content_type = r.headers.get(\"Content-Type\", \"\")\n assert \"text/plain\" in content_type\n\n\n@pytest.mark.benchmark\ndef test_405_method_not_allowed_content_type(session):\n \"\"\"An unsupported HTTP method should return 405 with Content-Type: text/plain\"\"\"\n response = requests.request(\"NONSTANDARD\", f\"{BASE_URL}/\")\n assert response.status_code == 405\n content_type = response.headers.get(\"Content-Type\", \"\")\n assert \"text/plain\" in content_type\n"
},
{
"path": "integration_tests/test_subrouter.py",
"content": "import pytest\nfrom websocket import create_connection\n\nfrom integration_tests.helpers.http_methods_helpers import generic_http_helper, head\n\n\n@pytest.mark.parametrize(\n \"http_method_type\",\n [\"get\", \"post\", \"put\", \"delete\", \"patch\", \"options\", \"trace\"],\n)\n@pytest.mark.benchmark\ndef test_sub_router(http_method_type, session):\n response = generic_http_helper(http_method_type, \"sub_router/foo\")\n assert response.json() == {\"message\": \"foo\"}\n\n\n@pytest.mark.benchmark\ndef test_sub_router_head(session):\n response = head(\"sub_router/foo\")\n assert response.text == \"\" # response body is expected to be empty\n\n\n@pytest.mark.benchmark\ndef test_sub_router_web_socket(session):\n BASE_URL = \"ws://127.0.0.1:8080\"\n ws = create_connection(f\"{BASE_URL}/sub_router/ws\")\n assert ws.recv() == \"Hello world, from ws\"\n ws.send(\"My name is?\")\n assert ws.recv() == \"Message\"\n"
},
{
"path": "integration_tests/test_web_sockets.py",
"content": "import json\n\nimport pytest\nfrom websocket import create_connection\n\nBASE_URL = \"ws://127.0.0.1:8080\"\n\n\n@pytest.mark.benchmark\ndef test_web_socket_raw_benchmark(session):\n ws = create_connection(f\"{BASE_URL}/web_socket?one=hi&two=hello\")\n assert ws.recv() == \"Hello world, from ws\"\n\n ws.send(\"My name is?\")\n # Messages may arrive in any order due to WebSocket broadcast behavior\n received = sorted([ws.recv() for _ in range(3)])\n expected = sorted([\"This is a broadcast message\", \"This is a message to self\", \"Whaaat??\"])\n assert received == expected\n\n ws.send(\"My name is?\")\n assert ws.recv() == \"Whooo??\"\n\n ws.send(\"My name is?\")\n received = sorted([ws.recv() for _ in range(3)])\n expected = sorted([\"hi\", \"hello\", \"*chika* *chika* Slim Shady.\"])\n assert received == expected\n\n # this will close the connection\n ws.send(\"test\")\n assert ws.recv() == \"Connection closed\"\n\n\ndef test_web_socket_json(session):\n \"\"\"\n Not using this as the benchmark test since this involves JSON marshalling/unmarshalling\n which pollutes the benchmark measurement.\n \"\"\"\n ws = create_connection(f\"{BASE_URL}/web_socket_json\")\n assert ws.recv() == \"Hello world, from ws\"\n\n msg = \"My name is?\"\n\n ws.send(msg)\n resp = json.loads(ws.recv())\n assert resp[\"resp\"] == \"Whaaat??\"\n assert resp[\"msg\"] == msg\n\n ws.send(msg)\n resp = json.loads(ws.recv())\n assert resp[\"resp\"] == \"Whooo??\"\n assert resp[\"msg\"] == msg\n\n ws.send(msg)\n resp = json.loads(ws.recv())\n assert resp[\"resp\"] == \"*chika* *chika* Slim Shady.\"\n assert resp[\"msg\"] == msg\n\n\ndef test_websocket_di(session):\n \"\"\"Test dependency injection in WebSocket connect and handler phases.\"\"\"\n\n ws = create_connection(f\"{BASE_URL}/web_socket_di\")\n\n # 1. on_connect should receive both global and router dependencies\n assert ws.recv() == \"connect: GLOBAL DEPENDENCY ROUTER DEPENDENCY\"\n\n # 2. Main handler should also receive both dependencies when processing messages\n ws.send(\"test\")\n assert ws.recv() == \"handler: GLOBAL DEPENDENCY ROUTER DEPENDENCY\"\n\n # Send another message to confirm DI is stable across multiple messages\n ws.send(\"test again\")\n assert ws.recv() == \"handler: GLOBAL DEPENDENCY ROUTER DEPENDENCY\"\n\n ws.close()\n\n\ndef test_websocket_large_payload(session):\n \"\"\"Test that WebSocket can handle messages larger than the default 64KB frame size (#1269)\"\"\"\n ws = create_connection(f\"{BASE_URL}/web_socket_echo\")\n # Consume the empty connect message\n ws.recv()\n\n large_message = \"A\" * (128 * 1024) # 128KB, well above the old 64KB default\n ws.send(large_message)\n response = ws.recv()\n assert response == large_message\n assert len(response) == 128 * 1024\n\n ws.close()\n\n\ndef test_websocket_empty_returns(session):\n \"\"\"Test that WebSocket handlers can return nothing without causing errors\"\"\"\n ws = create_connection(f\"{BASE_URL}/web_socket_empty_returns\")\n\n # Connect handler returns None - no message should be received on connection\n # We need to send a message to verify the connection is still active\n ws.send(\"test message\")\n\n # Message handler returns None - no response should be sent\n # The socket should still be open, not crashed\n # We can verify this by closing the connection gracefully\n ws.close()\n # If we got here without exceptions, the test passed\n"
},
{
"path": "llms.txt",
"content": "# Robyn\n\n> Robyn is a high-performance, community-driven, and innovator-friendly async web framework for Python with a Rust runtime. It combines Python's ease of use with Rust's performance.\n\n## Quick Facts\n\n- Version: 0.79.0\n- Python: >= 3.10\n- License: BSD 2.0\n- Repository: https://github.com/sparckles/robyn\n- Documentation: https://robyn.tech/documentation\n- Discord: https://discord.gg/rkERZ5eNU8\n\n## Installation\n\n```bash\npip install robyn\n```\n\n## Basic Usage\n\n```python\nfrom robyn import Robyn\n\napp = Robyn(__file__)\n\n@app.get(\"/\")\nasync def index(request):\n return \"Hello, World!\"\n\napp.start(port=8080)\n```\n\n## Key Features\n\n- **Rust Runtime**: Core server written in Rust using actix-web for high performance\n- **Async/Sync Support**: Both async and sync route handlers supported\n- **Multi-Process Scaling**: Built-in multiprocess execution via `--processes` and `--workers`\n- **WebSockets**: Native WebSocket support\n- **Middlewares**: Before/after request middlewares\n- **Dependency Injection**: Built-in DI system\n- **OpenAPI/Swagger**: Automatic OpenAPI documentation generation\n- **Hot Reloading**: Development mode with `--dev` flag\n- **AI Agents**: Built-in AI agent routing via `robyn.ai`\n- **MCP Support**: Model Context Protocol server capabilities via `app.mcp`\n- **Templating**: Jinja2 templating support (optional)\n- **CORS**: Built-in CORS helper via `ALLOW_CORS()`\n- **Authentication**: AuthenticationHandler base class for custom auth\n- **Static Files**: Directory serving via `app.serve_directory()`\n- **SSE**: Server-Sent Events support via `SSEResponse`\n- **Easy Access Parameters**: Typed path/query params with automatic coercion in handler signatures\n- **Direct Rust Integration**: Embed Rust code directly in routes\n\n## Project Structure\n\n```\nrobyn/\n├── src/ # Rust source code\n│ ├── lib.rs # PyO3 module entry point\n│ ├── server.rs # Main HTTP server implementation\n│ ├── types/ # Request, Response, Headers, Cookie types\n│ ├── routers/ # HTTP, WebSocket, middleware routers\n│ ├── executors/ # Route execution handlers\n│ └── websockets/ # WebSocket implementation\n├── robyn/ # Python package\n│ ├── __init__.py # Main Robyn and SubRouter classes\n│ ├── router.py # Python router implementation\n│ ├── authentication.py # AuthenticationHandler\n│ ├── dependency_injection.py\n│ ├── openapi.py # OpenAPI generation\n│ ├── mcp.py # MCP protocol support\n│ ├── ai.py # AI agent support\n│ ├── responses.py # Response helpers (serve_file, html, SSE)\n│ ├── ws.py # WebSocket class\n│ └── robyn.pyi # Type stubs\n├── integration_tests/ # Integration test suite\n├── unit_tests/ # Unit test suite\n├── docs_src/ # Documentation (Next.js)\n├── granian/ # Bundled Granian server (fork)\n└── examples/ # Example applications\n```\n\n## Core Classes\n\n### Robyn / SubRouter\nMain application class and sub-router for modular routes.\n\n```python\nfrom robyn import Robyn, SubRouter\n\napp = Robyn(__file__)\napi = SubRouter(__file__, prefix=\"/api\")\n\n@api.get(\"/users\")\ndef get_users(request):\n return {\"users\": []}\n\napp.include_router(api)\n```\n\n### Request Object\n```python\nrequest.method # HTTP method\nrequest.url # Url object (scheme, host, path)\nrequest.headers # Headers dict-like\nrequest.query_params # QueryParams\nrequest.path_params # Dict of URL params\nrequest.body # Raw bytes\nrequest.json() # Parse JSON body\nrequest.form_data # Multipart form data\nrequest.ip_addr # Client IP\nrequest.identity # Identity (if authenticated)\n```\n\n### Response Object\n```python\nfrom robyn import Response\n\nResponse(\n status_code=200,\n headers={\"Content-Type\": \"application/json\"},\n description=\"body content\" # or body bytes\n)\n```\n\n### Decorators\n```python\n@app.get(\"/path\")\n@app.post(\"/path\")\n@app.put(\"/path\")\n@app.delete(\"/path\")\n@app.patch(\"/path\")\n@app.head(\"/path\")\n@app.options(\"/path\")\n\n@app.before_request(\"/path\") # Middleware before\n@app.after_request(\"/path\") # Middleware after\n\n@app.startup_handler # Server startup\n@app.shutdown_handler # Server shutdown\n```\n\n### WebSockets\n```python\nfrom robyn import WebSocketDisconnect\n\n@app.websocket(\"/ws\")\nasync def handler(websocket):\n try:\n while True:\n msg = await websocket.receive_text()\n await websocket.send_text(f\"Echo: {msg}\")\n except WebSocketDisconnect:\n pass\n\n@handler.on_connect\ndef on_connect(websocket):\n return \"Connected\"\n\n@handler.on_close\ndef on_close(websocket):\n return \"Closed\"\n```\n\n### Easy Access Parameters\nDeclare typed path and query parameters directly in handler signatures. Works for both HTTP and WebSocket handlers.\n\n```python\nfrom typing import List, Optional\n\n# HTTP: path params + query params with type coercion\n@app.get(\"/items/:id\")\nasync def get_item(id: int, q: str, page: int = 1):\n return {\"id\": id, \"q\": q, \"page\": page}\n\n# Optional, List, and bool params\n@app.get(\"/search\")\ndef search(name: str, tags: List[str], active: bool = False, age: Optional[int] = None):\n return {\"name\": name, \"tags\": tags, \"active\": active, \"age\": age}\n\n# WebSocket: typed query params on handler and callbacks\n@app.websocket(\"/ws\")\nasync def handler(websocket, room: str = \"default\", page: int = 1):\n while True:\n msg = await websocket.receive_text()\n await websocket.send_text(f\"room={room} page={page} msg={msg}\")\n\n@handler.on_connect\ndef on_connect(websocket, room: str = \"default\"):\n return f\"connected to {room}\"\n```\n\n### MCP (Model Context Protocol)\n```python\n@app.mcp.resource(\"time://current\")\ndef get_time():\n return datetime.now().isoformat()\n\n@app.mcp.tool(name=\"calc\", description=\"Calculate\", input_schema={...})\ndef calculate(args):\n return eval(args[\"expression\"])\n\n@app.mcp.prompt(name=\"explain\", description=\"Explain code\", arguments=[...])\ndef explain_prompt(args):\n return f\"Please explain: {args['code']}\"\n```\n\n## CLI Commands\n\n```bash\npython app.py # Start server\npython app.py --dev # Development mode (hot reload)\npython app.py --processes 4 # Multi-process\npython app.py --workers 2 # Workers per process\npython app.py --log-level DEBUG # Log level\npython app.py --open-browser # Open browser on start\npython app.py --create # Create new project scaffold\npython app.py --docs # Open documentation\n```\n\n## Development Setup\n\n```bash\n# Clone\ngit clone https://github.com/sparckles/robyn.git\ncd robyn\n\n# Virtual environment\npython3 -m venv .venv && source .venv/bin/activate\n\n# Install tools\npip install pre-commit poetry maturin\n\n# Install dependencies\npoetry install --with dev --with test\n\n# Build Rust extension\nmaturin develop\n\n# Run tests\npytest\n```\n\n## Key Dependencies\n\n- **PyO3**: Rust-Python bindings\n- **actix-web**: Rust HTTP server (via cookie crate)\n- **orjson**: Fast JSON serialization\n- **multiprocess**: Multi-process support\n- **uvloop**: Fast event loop (non-Windows)\n- **watchdog**: File watching for hot reload\n\n## Configuration\n\nEnvironment variables:\n- `ROBYN_HOST`: Server host (default: 127.0.0.1)\n- `ROBYN_PORT`: Server port (default: 8080)\n- `ROBYN_DEV_MODE`: Enable dev mode\n- `ROBYN_BROWSER_OPEN`: Open browser on start\n- `ROBYN_CLIENT_TIMEOUT`: Client timeout seconds\n- `ROBYN_KEEP_ALIVE_TIMEOUT`: Keep-alive timeout\n\n## Documentation Structure\n\nMain docs at `docs_src/src/pages/documentation/`:\n- `api_reference/getting_started.mdx` - Quick start guide\n- `api_reference/request_object.mdx` - Request handling\n- `api_reference/middlewares.mdx` - Middleware usage\n- `api_reference/websockets.mdx` - WebSocket guide\n- `api_reference/authentication.mdx` - Auth patterns\n- `api_reference/openapi.mdx` - OpenAPI docs\n- `api_reference/agents.mdx` - AI agent integration\n- `api_reference/mcps.mdx` - MCP server guide\n- `example_app/` - Full example application tutorial\n"
},
{
"path": "noxfile.py",
"content": "import sys\n\nimport nox\n\n\n@nox.session(python=[\"3.10\", \"3.11\", \"3.12\", \"3.13\", \"3.14\"])\ndef tests(session):\n session.run(\"pip\", \"install\", \"poetry==1.3.0\")\n session.run(\"pip\", \"install\", \"maturin\")\n session.run(\n \"poetry\",\n \"export\",\n \"--with\",\n \"test\",\n \"--with\",\n \"dev\",\n \"--without-hashes\",\n \"--output\",\n \"requirements.txt\",\n )\n session.run(\"pip\", \"install\", \"-r\", \"requirements.txt\")\n session.run(\"pip\", \"install\", \"-e\", \".\")\n\n args = [\n \"maturin\",\n \"build\",\n \"-i\",\n \"python\",\n \"--out\",\n \"dist\",\n ]\n\n if sys.platform == \"darwin\":\n session.run(\"rustup\", \"target\", \"add\", \"x86_64-apple-darwin\")\n session.run(\"rustup\", \"target\", \"add\", \"aarch64-apple-darwin\")\n args.append(\"--target\")\n args.append(\"universal2-apple-darwin\")\n\n session.run(*args)\n session.run(\"pip\", \"install\", \"--no-index\", \"--find-links=dist/\", \"robyn\")\n session.run(\"pytest\")\n\n\n@nox.session(python=[\"3.11\"])\ndef lint(session):\n session.run(\"pip\", \"install\", \"black\", \"ruff\")\n session.run(\"black\", \"robyn/\", \"integration_tests/\")\n"
},
{
"path": "pyproject.toml",
"content": "[build-system]\nrequires = [\"maturin>=1.0,<2.0\"]\nbuild-backend = \"maturin\"\n\n[project]\nname = \"robyn\"\nversion = \"0.82.0\"\ndescription = \"A Super Fast Async Python Web Framework with a Rust runtime.\"\nreadme = \"README.md\"\nauthors = [{ name = \"Sanskar Jethi\", email = \"sansyrox@gmail.com\" }]\nlicense = { file = \"LICENSE\" }\nclassifiers = [\n \"Development Status :: 3 - Alpha\",\n \"Environment :: Web Environment\",\n \"Intended Audience :: Developers\",\n \"License :: OSI Approved :: BSD License\",\n \"Operating System :: OS Independent\",\n \"Topic :: Internet :: WWW/HTTP\",\n \"Programming Language :: Python :: 3\",\n \"Programming Language :: Python :: 3.10\",\n \"Programming Language :: Python :: 3.11\",\n \"Programming Language :: Python :: 3.12\",\n \"Programming Language :: Python :: 3.13\",\n \"Programming Language :: Python :: 3.14\",\n \"Programming Language :: Python :: Implementation :: CPython\",\n]\ndependencies = [\n \"inquirerpy == 0.3.4\",\n \"multiprocess >= 0.70.18, < 0.71.0\",\n \"orjson >= 3.11.5, < 4.0.0\",\n \"rustimport == 1.3.4\",\n # conditional\n \"uvloop~=0.22.1; sys_platform != 'win32' and platform_python_implementation == 'CPython' and platform_machine != 'armv7l'\",\n \"watchdog >= 6.0.0, < 7.0.0\",\n]\n\n[project.optional-dependencies]\n\"templating\" = [\"jinja2 >= 3.1.6, < 4.0.0\"]\n\"pydantic\" = [\"pydantic >= 2.0.0, < 3.0.0\"]\n\"all\" = [\"jinja2 >= 3.1.6, < 4.0.0\", \"pydantic >= 2.0.0, < 3.0.0\"]\n\n[project.urls]\nDocumentation = \"https://robyn.tech/\"\nRepository = \"https://github.com/sparckles/robyn\"\nIssues = \"https://github.com/sparckles/robyn/issues\"\nChangelog = \"https://github.com/sparckles/robyn/blob/main/CHANGELOG.md\"\n\n[project.scripts]\nrobyn = \"robyn.cli:run\"\ntest_server = \"integration_tests.base_routes:main\"\n\n[dependency-groups]\ndev = [\n \"black==23.1\",\n \"commitizen==2.40\",\n \"isort==5.11.5\",\n \"maturin==1.7.4\",\n \"pre-commit>=4.5.1,<5.0.0\",\n \"ruff>=0.9.0\",\n]\ntest = [\n \"nox==2023.4.22\",\n \"pytest>=9.0.2\",\n \"pytest-codspeed>=4.2.0\",\n \"requests==2.28.2\",\n \"websocket-client==1.5.0\",\n]\n\n\n[tool.poetry]\nname = \"robyn\"\nversion = \"0.82.0\"\ndescription = \"A Super Fast Async Python Web Framework with a Rust runtime.\"\nauthors = [\"Sanskar Jethi \"]\n\n\n[tool.poetry.dependencies]\npython = \"^3.10\"\ninquirerpy = \"0.3.4\"\nmaturin = \"1.7.4\"\nwatchdog = \"^6.0.0\"\nmultiprocess = \"^0.70.18\"\nuvloop = { version = \"0.22.1\", markers = \"sys_platform != 'win32' and (sys_platform != 'cygwin' and platform_python_implementation != 'PyPy')\" }\njinja2 = { version = \"^3.1.6\", optional = true }\npydantic = { version = \"^2.0.0\", optional = true }\nrustimport = \"^1.3.4\"\norjson = \"^3.11.5\"\n\n[tool.poetry.extras]\ntemplating = [\"jinja2\"]\npydantic = [\"pydantic\"]\nall = [\"jinja2\", \"pydantic\"]\n\n[tool.poetry.group.dev]\noptional = true\n\n[tool.poetry.group.dev.dependencies]\nruff = \">=0.9.0\"\nblack = \"23.1\"\nisort = \"5.11.5\"\npre-commit = \"^4.5.1\"\ncommitizen = \"2.40\"\n\n[tool.poetry.group.test]\noptional = true\n\n[tool.poetry.group.test.dependencies]\npytest = \"^9.0.2\"\npytest-codspeed = \"^4.2.0\"\nrequests = \"2.28.2\"\nnox = \"2023.4.22\"\nwebsocket-client = \"1.5.0\"\n\n[tool.poetry.scripts]\ntest_server = { callable = \"integration_tests.base_routes:main\" }\n\n[tool.ruff]\nline-length = 160\nexclude = [\"src/*\", \".git\", \"docs\"]\n\n[tool.ruff.lint.mccabe]\nmax-complexity = 10\n\n[tool.isort]\nprofile = \"black\"\nline_length = 160\n\n[tool.black]\nline-length = 160\ntarget-version = ['py39']\ninclude = '\\.pyi?$'\nextend-exclude = '''\n/(\n # directories\n \\.eggs\n | \\.git\n | \\.hg\n | \\.mypy_cache\n | \\.tox\n | \\.venv\n | build\n | dist\n)/\n'''\n\n[tool.pytest.ini_options]\nmarkers = [\n \"benchmark: marks tests as benchmarks for performance measurement (deselect with '-m \\\"not benchmark\\\"')\",\n]\n\n[tool.maturin]\nmodule-name = \"robyn\"\n"
},
{
"path": "robyn/__init__.py",
"content": "import inspect\nimport logging\nimport os\nimport socket\nfrom abc import ABC\nfrom pathlib import Path\nfrom typing import Callable, List, Optional, Union\n\nimport multiprocess as mp # type: ignore\n\nfrom robyn import status_codes\nfrom robyn.argument_parser import Config\nfrom robyn.authentication import AuthenticationHandler\nfrom robyn.dependency_injection import DependencyMap\nfrom robyn.env_populator import load_vars\nfrom robyn.events import Events\nfrom robyn.jsonify import jsonify\nfrom robyn.logger import Colors, logger\nfrom robyn.mcp import MCPApp\nfrom robyn.openapi import OpenAPI\nfrom robyn.processpool import run_processes\nfrom robyn.reloader import compile_rust_files\nfrom robyn.responses import SSEMessage, SSEResponse, StreamingResponse, html, serve_file, serve_html\nfrom robyn.robyn import FunctionInfo, Headers, HttpMethod, Request, Response, WebSocketConnector, get_version\nfrom robyn.router import MiddlewareRouter, MiddlewareType, Router, WebSocketRouter\nfrom robyn.types import Directory, JsonBody\nfrom robyn.ws import WebSocketAdapter, WebSocketDisconnect, create_websocket_decorator\n\n__version__ = get_version()\n\n\ndef _normalize_endpoint(endpoint: Optional[str], treat_empty_as_root: bool = False) -> Optional[str]:\n \"\"\"\n Normalize an endpoint to ensure consistent routing.\n\n Rules:\n - Root \"/\" remains unchanged\n - All other endpoints get leading slash added if missing\n - Trailing slashes are removed from all endpoints except root\n - Empty or blank strings are handled based on treat_empty_as_root flag\n - treat_empty_as_root is used for prefixes where empty/blank strings are valid\n\n Args:\n endpoint: The endpoint path to normalize.\n treat_empty_as_root (used for prefixes):\n If True, empty/blank strings are converted to \"/\" (root).\n If False, empty/blank strings return None (invalid endpoint).\n\n Returns:\n Normalized endpoint path or None if invalid.\n \"\"\"\n if endpoint is None or (not endpoint and not treat_empty_as_root):\n return None\n\n # Remove trailing slashes\n endpoint = endpoint.strip().rstrip(\"/\")\n\n # Handle empty result\n if not endpoint:\n return \"/\"\n\n # Add leading slash if missing\n if not endpoint.startswith(\"/\"):\n endpoint = \"/\" + endpoint\n\n return endpoint\n\n\nconfig = Config()\n\nif (compile_path := config.compile_rust_path) is not None:\n compile_rust_files(compile_path)\n print(\"Compiled rust files\")\n\n\nclass BaseRobyn(ABC):\n \"\"\"This is the python wrapper for the Robyn binaries.\"\"\"\n\n def __init__(\n self,\n file_object: str,\n config: Config = Config(),\n openapi_file_path: Optional[str] = None,\n openapi: Optional[OpenAPI] = None,\n dependencies: DependencyMap = DependencyMap(),\n ) -> None:\n directory_path = os.path.dirname(os.path.abspath(file_object))\n self.file_path = file_object\n self.directory_path = directory_path\n self.config = config\n self.dependencies = dependencies\n self.openapi = openapi\n\n self.init_openapi(openapi_file_path)\n\n if not bool(os.environ.get(\"ROBYN_CLI\", False)):\n # the env variables are already set when are running through the cli\n load_vars(project_root=directory_path)\n\n self._handle_dev_mode()\n\n logging.basicConfig(level=self.config.log_level)\n\n if self.config.log_level.lower() != \"warn\":\n logger.info(\n \"SERVER IS RUNNING IN VERBOSE/DEBUG MODE. Set --log-level to WARN to run in production mode.\",\n color=Colors.BLUE,\n )\n\n self.router = Router()\n self.middleware_router = MiddlewareRouter()\n self.web_socket_router = WebSocketRouter()\n self.request_headers: Headers = Headers({})\n self.response_headers: Headers = Headers({})\n self.excluded_response_headers_paths: Optional[List[str]] = None\n self.directories: List[Directory] = []\n self.event_handlers: dict = {}\n self.exception_handler: Optional[Callable] = None\n self.authentication_handler: Optional[AuthenticationHandler] = None\n self.included_routers: List[Router] = []\n self._mcp_app: Optional[MCPApp] = None\n\n def init_openapi(self, openapi_file_path: Optional[str]) -> None:\n if self.config.disable_openapi:\n return\n\n if self.openapi is None:\n self.openapi = OpenAPI()\n\n if openapi_file_path:\n self.openapi.override_openapi(Path(self.directory_path).joinpath(openapi_file_path))\n elif Path(self.directory_path).joinpath(\"openapi.json\").exists():\n self.openapi.override_openapi(Path(self.directory_path).joinpath(\"openapi.json\"))\n else:\n logger.debug(\"No OpenAPI spec file found; using auto-generated documentation only.\", color=Colors.YELLOW)\n\n def _handle_dev_mode(self):\n cli_dev_mode = self.config.dev # --dev\n env_dev_mode = os.getenv(\"ROBYN_DEV_MODE\", \"False\").lower() == \"true\" # ROBYN_DEV_MODE=True\n is_robyn = os.getenv(\"ROBYN_CLI\", False)\n\n if cli_dev_mode and not is_robyn:\n raise SystemExit(\"Dev mode is not supported in the python wrapper. Please use the Robyn CLI. e.g. python3 -m robyn app.py --dev\")\n\n if env_dev_mode and not is_robyn:\n logger.error(\"Ignoring ROBYN_DEV_MODE environment variable. Dev mode is not supported in the python wrapper.\")\n raise SystemExit(\"Dev mode is not supported in the python wrapper. Please use the Robyn CLI. e.g. python3 -m robyn app.py\")\n\n def add_route(\n self,\n route_type: Union[HttpMethod, str],\n endpoint: str,\n handler: Callable,\n is_const: bool = False,\n auth_required: bool = False,\n openapi_name: str = \"\",\n openapi_tags: Union[List[str], None] = None,\n ):\n \"\"\"\n Connect a URI to a handler\n\n :param route_type str: route type between GET/POST/PUT/DELETE/PATCH/HEAD/OPTIONS/TRACE\n :param endpoint str: endpoint for the route added\n :param handler function: represents the sync or async function passed as a handler for the route\n :param is_const bool: represents if the handler is a const function or not\n :param auth_required bool: represents if the route needs authentication or not\n \"\"\"\n\n \"\"\" We will add the status code here only\n \"\"\"\n injected_dependencies = self.dependencies.get_dependency_map(self)\n\n list_openapi_tags: List[str] = openapi_tags if openapi_tags else []\n\n if isinstance(route_type, str):\n http_methods = {\n \"GET\": HttpMethod.GET,\n \"POST\": HttpMethod.POST,\n \"PUT\": HttpMethod.PUT,\n \"DELETE\": HttpMethod.DELETE,\n \"PATCH\": HttpMethod.PATCH,\n \"HEAD\": HttpMethod.HEAD,\n \"OPTIONS\": HttpMethod.OPTIONS,\n }\n route_type = http_methods[route_type]\n\n # Normalize endpoint before adding\n normalized_endpoint = _normalize_endpoint(endpoint)\n\n if normalized_endpoint is None:\n raise ValueError(\"Endpoint cannot be blank, do specify '/' for root endpoint\")\n\n if auth_required:\n self.middleware_router.add_auth_middleware(normalized_endpoint, route_type)(handler)\n\n # Check if this exact route (method + normalized_endpoint) already exists\n route_key = f\"{route_type}:{normalized_endpoint}\"\n if not hasattr(self, \"_added_routes\"):\n self._added_routes = set()\n\n if route_key in self._added_routes:\n # Route already exists, raise an error\n raise ValueError(f\"Route {route_type} {normalized_endpoint} already exists\")\n\n # Add to our tracking set\n self._added_routes.add(route_key)\n\n add_route_response = self.router.add_route(\n route_type=route_type,\n endpoint=normalized_endpoint,\n handler=handler,\n is_const=is_const,\n auth_required=auth_required,\n openapi_name=openapi_name,\n openapi_tags=list_openapi_tags,\n exception_handler=self.exception_handler,\n injected_dependencies=injected_dependencies,\n )\n\n logger.info(\"Added route %s %s\", route_type, normalized_endpoint)\n\n return add_route_response\n\n def inject(self, **kwargs):\n \"\"\"\n Injects the dependencies for the route\n\n :param kwargs dict: the dependencies to be injected\n \"\"\"\n self.dependencies.add_router_dependency(self, **kwargs)\n\n def inject_global(self, **kwargs):\n \"\"\"\n Injects the dependencies for the global routes\n Ideally, this function should be a global function\n\n :param kwargs dict: the dependencies to be injected\n \"\"\"\n self.dependencies.add_global_dependency(**kwargs)\n\n def before_request(self, endpoint: Optional[str] = None) -> Callable[..., None]:\n \"\"\"\n You can use the @app.before_request decorator to call a method before routing to the specified endpoint\n\n :param endpoint str|None: endpoint to server the route. If None, the middleware will be applied to all the routes.\n \"\"\"\n return self.middleware_router.add_middleware(MiddlewareType.BEFORE_REQUEST, _normalize_endpoint(endpoint))\n\n def after_request(self, endpoint: Optional[str] = None) -> Callable[..., None]:\n \"\"\"\n You can use the @app.after_request decorator to call a method after routing to the specified endpoint\n\n :param endpoint str|None: endpoint to server the route. If None, the middleware will be applied to all the routes.\n \"\"\"\n return self.middleware_router.add_middleware(MiddlewareType.AFTER_REQUEST, _normalize_endpoint(endpoint))\n\n def serve_directory(\n self,\n route: str,\n directory_path: str,\n index_file: Optional[str] = None,\n show_files_listing: bool = False,\n ):\n \"\"\"\n Serves a directory at the given route\n\n :param route str: the route at which the directory is to be served\n :param directory_path str: the path of the directory to be served\n :param index_file str|None: the index file to be served\n :param show_files_listing bool: if the files listing should be shown or not\n \"\"\"\n self.directories.append(Directory(route, directory_path, show_files_listing, index_file))\n\n def add_request_header(self, key: str, value: str) -> None:\n self.request_headers.append(key, value)\n\n def add_response_header(self, key: str, value: str) -> None:\n self.response_headers.append(key, value)\n\n def set_request_header(self, key: str, value: str) -> None:\n self.request_headers.set(key, value)\n\n def set_response_header(self, key: str, value: str) -> None:\n self.response_headers.set(key, value)\n\n def exclude_response_headers_for(self, excluded_response_headers_paths: Optional[List[str]]):\n \"\"\"\n To exclude response headers from certain routes\n @param exclude_paths: the paths to exclude response headers from\n \"\"\"\n self.excluded_response_headers_paths = excluded_response_headers_paths\n\n def add_web_socket(self, endpoint: str, handlers) -> None:\n self.web_socket_router.add_route(endpoint, handlers)\n\n def websocket(self, endpoint: str):\n \"\"\"\n Modern WebSocket decorator backed by Rust channels.\n\n Usage:\n @app.websocket(\"/ws\")\n async def handler(websocket):\n while True:\n msg = await websocket.receive_text()\n await websocket.send_text(f\"Echo: {msg}\")\n\n @handler.on_connect\n def on_connect(websocket):\n return \"Welcome!\"\n\n @handler.on_close\n def on_close(websocket):\n return \"Goodbye\"\n \"\"\"\n return create_websocket_decorator(self)(endpoint)\n\n def _add_event_handler(self, event_type: Events, handler: Callable) -> None:\n logger.info(\"Added event %s handler\", event_type)\n if event_type not in {Events.STARTUP, Events.SHUTDOWN}:\n return\n\n is_async = inspect.iscoroutinefunction(handler)\n self.event_handlers[event_type] = FunctionInfo(handler, is_async, 0, {}, {})\n\n def startup_handler(self, handler: Callable) -> None:\n self._add_event_handler(Events.STARTUP, handler)\n\n def shutdown_handler(self, handler: Callable) -> None:\n self._add_event_handler(Events.SHUTDOWN, handler)\n\n def is_port_in_use(self, port: int) -> bool:\n try:\n with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:\n return s.connect_ex((\"localhost\", port)) == 0\n except Exception:\n raise Exception(f\"Invalid port number: {port}\")\n\n def _add_openapi_routes(self, auth_required: bool = False):\n if self.config.disable_openapi:\n return\n\n if self.openapi is None:\n logger.error(\"No openAPI\")\n return\n\n self.router.prepare_routes_openapi(self.openapi, self.included_routers)\n\n self.add_route(\n route_type=HttpMethod.GET,\n endpoint=\"/openapi.json\",\n handler=self.openapi.get_openapi_config,\n is_const=True,\n auth_required=auth_required,\n )\n self.add_route(\n route_type=HttpMethod.GET,\n endpoint=\"/docs\",\n handler=self.openapi.get_openapi_docs_page,\n is_const=True,\n auth_required=auth_required,\n )\n self.exclude_response_headers_for([\"/docs\", \"/openapi.json\"])\n\n def exception(self, exception_handler: Callable):\n self.exception_handler = exception_handler\n\n def get(\n self,\n endpoint: str,\n const: bool = False,\n auth_required: bool = False,\n openapi_name: str = \"\",\n openapi_tags: List[str] = [\"get\"],\n ):\n \"\"\"\n The @app.get decorator to add a route with the GET method\n\n :param endpoint str: endpoint for the route added\n :param const bool: represents if the handler is a const function or not\n :param auth_required bool: represents if the route needs authentication or not\n :param openapi_name: str -- the name of the endpoint in the openapi spec\n :param openapi_tags: List[str] -- for grouping of endpoints in the openapi spec\n \"\"\"\n\n def inner(handler):\n return self.add_route(HttpMethod.GET, endpoint, handler, const, auth_required, openapi_name, openapi_tags)\n\n return inner\n\n def post(\n self,\n endpoint: str,\n auth_required: bool = False,\n openapi_name: str = \"\",\n openapi_tags: List[str] = [\"post\"],\n ):\n \"\"\"\n The @app.post decorator to add a route with POST method\n\n :param endpoint str: endpoint for the route added\n :param auth_required bool: represents if the route needs authentication or not\n :param openapi_name: str -- the name of the endpoint in the openapi spec\n :param openapi_tags: List[str] -- for grouping of endpoints in the openapi spec\n \"\"\"\n\n def inner(handler):\n return self.add_route(HttpMethod.POST, endpoint, handler, auth_required=auth_required, openapi_name=openapi_name, openapi_tags=openapi_tags)\n\n return inner\n\n def put(\n self,\n endpoint: str,\n auth_required: bool = False,\n openapi_name: str = \"\",\n openapi_tags: List[str] = [\"put\"],\n ):\n \"\"\"\n The @app.put decorator to add a get route with PUT method\n\n :param endpoint str: endpoint for the route added\n :param auth_required bool: represents if the route needs authentication or not\n :param openapi_name: str -- the name of the endpoint in the openapi spec\n :param openapi_tags: List[str] -- for grouping of endpoints in the openapi spec\n \"\"\"\n\n def inner(handler):\n return self.add_route(HttpMethod.PUT, endpoint, handler, auth_required=auth_required, openapi_name=openapi_name, openapi_tags=openapi_tags)\n\n return inner\n\n def delete(\n self,\n endpoint: str,\n auth_required: bool = False,\n openapi_name: str = \"\",\n openapi_tags: List[str] = [\"delete\"],\n ):\n \"\"\"\n The @app.delete decorator to add a route with DELETE method\n\n :param endpoint str: endpoint for the route added\n :param auth_required bool: represents if the route needs authentication or not\n :param openapi_name: str -- the name of the endpoint in the openapi spec\n :param openapi_tags: List[str] -- for grouping of endpoints in the openapi spec\n \"\"\"\n\n def inner(handler):\n return self.add_route(HttpMethod.DELETE, endpoint, handler, auth_required=auth_required, openapi_name=openapi_name, openapi_tags=openapi_tags)\n\n return inner\n\n def patch(\n self,\n endpoint: str,\n auth_required: bool = False,\n openapi_name: str = \"\",\n openapi_tags: List[str] = [\"patch\"],\n ):\n \"\"\"\n The @app.patch decorator to add a route with PATCH method\n\n :param endpoint str: endpoint for the route added\n :param auth_required bool: represents if the route needs authentication or not\n :param openapi_name: str -- the name of the endpoint in the openapi spec\n :param openapi_tags: List[str] -- for grouping of endpoints in the openapi spec\n \"\"\"\n\n def inner(handler):\n return self.add_route(HttpMethod.PATCH, endpoint, handler, auth_required=auth_required, openapi_name=openapi_name, openapi_tags=openapi_tags)\n\n return inner\n\n def head(\n self,\n endpoint: str,\n auth_required: bool = False,\n openapi_name: str = \"\",\n openapi_tags: List[str] = [\"head\"],\n ):\n \"\"\"\n The @app.head decorator to add a route with HEAD method\n\n :param endpoint str: endpoint for the route added\n :param auth_required bool: represents if the route needs authentication or not\n :param openapi_name: str -- the name of the endpoint in the openapi spec\n :param openapi_tags: List[str] -- for grouping of endpoints in the openapi spec\n \"\"\"\n\n def inner(handler):\n return self.add_route(HttpMethod.HEAD, endpoint, handler, auth_required=auth_required, openapi_name=openapi_name, openapi_tags=openapi_tags)\n\n return inner\n\n def options(\n self,\n endpoint: str,\n auth_required: bool = False,\n openapi_name: str = \"\",\n openapi_tags: List[str] = [\"options\"],\n ):\n \"\"\"\n The @app.options decorator to add a route with OPTIONS method\n\n :param endpoint str: endpoint for the route added\n :param auth_required bool: represents if the route needs authentication or not\n :param openapi_name: str -- the name of the endpoint in the openapi spec\n :param openapi_tags: List[str] -- for grouping of endpoints in the openapi spec\n \"\"\"\n\n def inner(handler):\n return self.add_route(HttpMethod.OPTIONS, endpoint, handler, auth_required=auth_required, openapi_name=openapi_name, openapi_tags=openapi_tags)\n\n return inner\n\n def connect(\n self,\n endpoint: str,\n auth_required: bool = False,\n openapi_name: str = \"\",\n openapi_tags: List[str] = [\"connect\"],\n ):\n \"\"\"\n The @app.connect decorator to add a route with CONNECT method\n\n :param endpoint str: endpoint for the route added\n :param auth_required bool: represents if the route needs authentication or not\n :param openapi_name: str -- the name of the endpoint in the openapi spec\n :param openapi_tags: List[str] -- for grouping of endpoints in the openapi spec\n \"\"\"\n\n def inner(handler):\n return self.add_route(HttpMethod.CONNECT, endpoint, handler, auth_required=auth_required, openapi_name=openapi_name, openapi_tags=openapi_tags)\n\n return inner\n\n def trace(\n self,\n endpoint: str,\n auth_required: bool = False,\n openapi_name: str = \"\",\n openapi_tags: List[str] = [\"trace\"],\n ):\n \"\"\"\n The @app.trace decorator to add a route with TRACE method\n\n :param endpoint str: endpoint for the route added\n :param auth_required bool: represents if the route needs authentication or not\n :param openapi_name: str -- the name of the endpoint in the openapi spec\n :param openapi_tags: List[str] -- for grouping of endpoints in the openapi spec\n \"\"\"\n\n def inner(handler):\n return self.add_route(HttpMethod.TRACE, endpoint, handler, auth_required=auth_required, openapi_name=openapi_name, openapi_tags=openapi_tags)\n\n return inner\n\n def include_router(self, router: \"SubRouter\"):\n \"\"\"\n The method to include the routes from another router.\n Merge another SubRouter's routes, middlewares, websocket routes, and dependencies into this router.\n Note: This operation mutates the current router's internal collections (route list, middleware lists,\n websocket routes, and dependencies) and does not deep-copy the included router. Callers should ensure\n there are no path or name conflicts before including a router.\n\n :param router SubRouter: the router object to include the routes from\n \"\"\"\n self.included_routers.append(router)\n\n self.router.routes.extend(router.router.routes)\n self.middleware_router.global_middlewares.extend(router.middleware_router.global_middlewares)\n self.middleware_router.route_middlewares.extend(router.middleware_router.route_middlewares)\n\n if not self.config.disable_openapi and self.openapi is not None:\n self.openapi.add_subrouter_paths(self.openapi)\n\n # extend the websocket routes\n prefix = _normalize_endpoint(router.prefix, treat_empty_as_root=True)\n if prefix == \"/\":\n prefix = \"\"\n for route, handlers in router.web_socket_router.routes.items():\n normalized_route = _normalize_endpoint(route)\n new_endpoint = f\"{prefix}{normalized_route}\"\n self.web_socket_router.routes[new_endpoint] = handlers\n\n self.dependencies.merge_dependencies(router)\n\n def configure_authentication(self, authentication_handler: AuthenticationHandler):\n \"\"\"\n Configures the authentication handler for the application.\n\n :param authentication_handler: the instance of a class inheriting the AuthenticationHandler base class\n \"\"\"\n self.authentication_handler = authentication_handler\n self.middleware_router.set_authentication_handler(authentication_handler)\n\n @property\n def mcp(self):\n \"\"\"\n Get the MCP (Model Context Protocol) interface for this app.\n\n Enables registering MCP resources, tools, and prompts that can be accessed\n by MCP clients like Claude Desktop or other AI applications.\n\n Returns:\n MCPApp: MCP interface for registering handlers\n\n Example:\n @app.mcp.resource(\"file://documents\", \"Documents\", \"Access to document files\")\n def get_documents(params):\n return \"Document content here\"\n\n @app.mcp.tool(\"calculate\", \"Perform calculations\", {\n \"type\": \"object\",\n \"properties\": {\n \"expression\": {\"type\": \"string\", \"description\": \"Math expression to evaluate\"}\n },\n \"required\": [\"expression\"]\n })\n def calculate_tool(args):\n return eval(args[\"expression\"])\n \"\"\"\n if self._mcp_app is None:\n self._mcp_app = MCPApp(self)\n return self._mcp_app\n\n\nclass Robyn(BaseRobyn):\n def start(self, host: str = \"127.0.0.1\", port: int = 8080, _check_port: bool = True, client_timeout: int = 30, keep_alive_timeout: int = 20):\n \"\"\"\n Starts the server\n\n :param host str: represents the host at which the server is listening\n :param port int: represents the port number at which the server is listening\n :param _check_port bool: represents if the port should be checked if it is already in use\n :param client_timeout int: timeout for client connections in seconds (default: 30)\n :param keep_alive_timeout int: timeout for keep-alive connections in seconds (default: 20)\n \"\"\"\n\n host = os.getenv(\"ROBYN_HOST\", host)\n port = int(os.getenv(\"ROBYN_PORT\", port))\n client_timeout = int(os.getenv(\"ROBYN_CLIENT_TIMEOUT\", client_timeout))\n keep_alive_timeout = int(os.getenv(\"ROBYN_KEEP_ALIVE_TIMEOUT\", keep_alive_timeout))\n open_browser = bool(os.getenv(\"ROBYN_BROWSER_OPEN\", self.config.open_browser))\n\n if _check_port:\n while self.is_port_in_use(port):\n logger.error(\"Port %s is already in use. Please use a different port.\", port)\n try:\n port = int(input(\"Enter a different port: \"))\n except Exception:\n logger.error(\"Invalid port number. Please enter a valid port number.\")\n continue\n\n if not self.config.disable_openapi:\n self._add_openapi_routes()\n logger.info(\"Docs hosted at http://%s:%s/docs\", host, port)\n\n logger.info(\"Robyn version: %s\", __version__)\n logger.info(\"Starting server at http://%s:%s\", host, port)\n\n mp.allow_connection_pickling()\n\n run_processes(\n host,\n port,\n self.directories,\n self.request_headers,\n self.router.get_routes(),\n self.middleware_router.get_global_middlewares(),\n self.middleware_router.get_route_middlewares(),\n self.web_socket_router.get_routes(),\n self.event_handlers,\n self.config.workers,\n self.config.processes,\n self.response_headers,\n self.excluded_response_headers_paths,\n open_browser,\n client_timeout,\n keep_alive_timeout,\n )\n\n\nclass SubRouter(BaseRobyn):\n def __init__(self, file_object: str, prefix: str = \"\", config: Config = Config(), openapi: OpenAPI = OpenAPI()) -> None:\n super().__init__(file_object=file_object, config=config, openapi=openapi)\n self.prefix = prefix\n\n def __add_prefix(self, endpoint: str):\n # Normalize prefix, treating empty as empty (not root)\n normalized_prefix = _normalize_endpoint(self.prefix, treat_empty_as_root=True)\n\n # Handle empty endpoint - should just be the prefix\n if endpoint in (\"\", \"/\"):\n return normalized_prefix if normalized_prefix else \"/\"\n\n # Convert root prefix to empty to avoid double slashes when making endpoint\n if normalized_prefix == \"/\":\n normalized_prefix = \"\" # Empty prefix for root\n\n # Normalize and validate endpoint\n normalized_endpoint = _normalize_endpoint(endpoint)\n if normalized_endpoint is None:\n raise ValueError(\"Endpoint cannot be blank, do specify '/' for root endpoint\")\n\n return f\"{normalized_prefix}{normalized_endpoint}\"\n\n def get(self, endpoint: str, const: bool = False, auth_required: bool = False, openapi_name: str = \"\", openapi_tags: List[str] = [\"get\"]):\n return super().get(endpoint=self.__add_prefix(endpoint), const=const, auth_required=auth_required, openapi_name=openapi_name, openapi_tags=openapi_tags)\n\n def post(self, endpoint: str, auth_required: bool = False, openapi_name: str = \"\", openapi_tags: List[str] = [\"post\"]):\n return super().post(endpoint=self.__add_prefix(endpoint), auth_required=auth_required, openapi_name=openapi_name, openapi_tags=openapi_tags)\n\n def put(self, endpoint: str, auth_required: bool = False, openapi_name: str = \"\", openapi_tags: List[str] = [\"put\"]):\n return super().put(endpoint=self.__add_prefix(endpoint), auth_required=auth_required, openapi_name=openapi_name, openapi_tags=openapi_tags)\n\n def delete(self, endpoint: str, auth_required: bool = False, openapi_name: str = \"\", openapi_tags: List[str] = [\"delete\"]):\n return super().delete(endpoint=self.__add_prefix(endpoint), auth_required=auth_required, openapi_name=openapi_name, openapi_tags=openapi_tags)\n\n def patch(self, endpoint: str, auth_required: bool = False, openapi_name: str = \"\", openapi_tags: List[str] = [\"patch\"]):\n return super().patch(endpoint=self.__add_prefix(endpoint), auth_required=auth_required, openapi_name=openapi_name, openapi_tags=openapi_tags)\n\n def head(self, endpoint: str, auth_required: bool = False, openapi_name: str = \"\", openapi_tags: List[str] = [\"head\"]):\n return super().head(endpoint=self.__add_prefix(endpoint), auth_required=auth_required, openapi_name=openapi_name, openapi_tags=openapi_tags)\n\n def trace(self, endpoint: str, auth_required: bool = False, openapi_name: str = \"\", openapi_tags: List[str] = [\"trace\"]):\n return super().trace(endpoint=self.__add_prefix(endpoint), auth_required=auth_required, openapi_name=openapi_name, openapi_tags=openapi_tags)\n\n def options(self, endpoint: str, auth_required: bool = False, openapi_name: str = \"\", openapi_tags: List[str] = [\"options\"]):\n return super().options(endpoint=self.__add_prefix(endpoint), auth_required=auth_required, openapi_name=openapi_name, openapi_tags=openapi_tags)\n\n def websocket(self, endpoint: str):\n \"\"\"\n Modern WebSocket decorator for SubRouter with prefix support.\n \"\"\"\n return create_websocket_decorator(self)(endpoint)\n\n\ndef ALLOW_CORS(app: Robyn, origins: Union[List[str], str], headers: Union[List[str], str] = None):\n \"\"\"\n Configure CORS headers for the application.\n\n Args:\n app: Robyn application instance\n origins: List of allowed origins or \"*\" for all origins\n headers: List of allowed headers or \"*\" for all headers\n \"\"\"\n # Handle string input for origins\n if isinstance(origins, str):\n origins = [origins]\n\n default_headers = [\"Content-Type\", \"Authorization\"]\n if isinstance(headers, list):\n headers = list(set(default_headers + headers))\n headers = \", \".join(headers)\n\n @app.before_request()\n def cors_middleware(request):\n origin = request.headers.get(\"Origin\")\n\n # If specific origins are set, validate the request origin\n if origin and \"*\" not in origins and origin not in origins:\n return Response(status_code=403, description=\"\", headers={})\n\n # Handle preflight requests\n if request.method == \"OPTIONS\":\n return Response(\n status_code=204,\n headers={\n \"Access-Control-Allow-Origin\": origin if origin else (origins[0] if origins else \"*\"),\n \"Access-Control-Allow-Methods\": \"GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS\",\n \"Access-Control-Allow-Headers\": str(headers) if headers else \"Content-Type, Authorization\",\n \"Access-Control-Allow-Credentials\": \"true\",\n \"Access-Control-Max-Age\": \"3600\",\n },\n description=\"\",\n )\n\n return request\n\n # Set default CORS headers for all responses\n if len(origins) == 1:\n app.set_response_header(\"Access-Control-Allow-Origin\", origins[0])\n else:\n # For multiple origins, we'll handle it dynamically in the response\n app.set_response_header(\"Access-Control-Allow-Origin\", \"*\")\n\n app.set_response_header(\"Access-Control-Allow-Methods\", \"GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS\")\n app.set_response_header(\"Access-Control-Allow-Headers\", str(headers) if headers else \"Content-Type, Authorization\")\n app.set_response_header(\"Access-Control-Allow-Credentials\", \"true\")\n\n\n__all__ = [\n \"Robyn\",\n \"Request\",\n \"Response\",\n \"status_codes\",\n \"jsonify\",\n \"serve_file\",\n \"serve_html\",\n \"html\",\n \"StreamingResponse\",\n \"SSEResponse\",\n \"SSEMessage\",\n \"ALLOW_CORS\",\n \"SubRouter\",\n \"AuthenticationHandler\",\n \"Headers\",\n \"WebSocketConnector\",\n \"WebSocketAdapter\",\n \"WebSocketDisconnect\",\n \"JsonBody\",\n \"MCPApp\",\n]\n"
},
{
"path": "robyn/__main__.py",
"content": "from robyn.cli import run\n\nif __name__ == \"__main__\":\n run()\n"
},
{
"path": "robyn/_param_utils.py",
"content": "\"\"\"\nShared utilities for resolving individual query/path parameters\nfrom handler function signatures, with type coercion.\n\nUsed by both robyn/router.py (HTTP handlers) and robyn/ws.py (WebSocket handlers).\n\"\"\"\n\nimport inspect\nimport logging\nfrom typing import Any, Dict, Optional, Set, Tuple, Union\n\n_logger = logging.getLogger(__name__)\n\n_MISSING = object()\n\n# Values that map to True/False from query string bool params\n_BOOL_TRUE_STRINGS = frozenset({\"true\", \"1\", \"yes\", \"on\"})\n_BOOL_FALSE_STRINGS = frozenset({\"false\", \"0\", \"no\", \"off\", \"\"})\n\n\nclass QueryParamValidationError(Exception):\n \"\"\"Raised when a query or path parameter cannot be coerced to the expected type,\n or when a required parameter is missing.\"\"\"\n\n def __init__(self, param_name: str, value: Optional[str], expected_type: type, message: Optional[str] = None):\n self.param_name = param_name\n self.value = value\n self.expected_type = expected_type\n if message:\n self.detail = message\n elif value is None:\n self.detail = f\"Missing required parameter: '{param_name}'\"\n else:\n self.detail = f\"Invalid value '{value}' for parameter '{param_name}': expected {expected_type.__name__}\"\n super().__init__(self.detail)\n\n\ndef unwrap_optional(annotation) -> Tuple[Any, bool]:\n \"\"\"\n If annotation is Optional[T] (i.e. Union[T, None]), return (T, True).\n Otherwise return (annotation, False).\n \"\"\"\n origin = getattr(annotation, \"__origin__\", None)\n if origin is Union:\n args = annotation.__args__\n non_none_args = [a for a in args if a is not type(None)]\n if len(non_none_args) == 1 and type(None) in args:\n return non_none_args[0], True\n return annotation, False\n\n\ndef is_list_type(annotation) -> bool:\n \"\"\"Check if annotation is List[T] or list[T].\"\"\"\n origin = getattr(annotation, \"__origin__\", None)\n return origin is list\n\n\ndef get_list_element_type(annotation) -> type:\n \"\"\"Get the element type from List[T]. Defaults to str if not specified.\"\"\"\n args = getattr(annotation, \"__args__\", None)\n if args and len(args) > 0:\n return args[0]\n return str\n\n\ndef coerce_value(value: str, target_type: type, param_name: str):\n \"\"\"\n Convert a string value to the target type.\n Raises QueryParamValidationError on failure.\n \"\"\"\n if target_type is str or target_type is inspect.Parameter.empty:\n return value\n\n try:\n if target_type is int:\n return int(value)\n if target_type is float:\n return float(value)\n if target_type is bool:\n lower = value.lower()\n if lower in _BOOL_TRUE_STRINGS:\n return True\n if lower in _BOOL_FALSE_STRINGS:\n return False\n raise ValueError(f\"Cannot interpret '{value}' as bool\")\n # Fallback: try calling the type constructor (covers Enum, UUID, etc.)\n return target_type(value)\n except (ValueError, TypeError) as e:\n raise QueryParamValidationError(param_name, value, target_type) from e\n\n\ndef resolve_individual_params(\n unresolved_params: Dict[str, inspect.Parameter],\n query_params,\n path_params: Optional[Dict[str, str]],\n route_param_names: Set[str],\n) -> Dict[str, Any]:\n \"\"\"\n Resolve handler parameters as individual path or query parameters.\n\n For each unresolved parameter:\n 1. If its name matches a route param name (from the endpoint pattern), look it up in path_params.\n 2. Otherwise, look it up in query_params.\n 3. Apply type coercion based on the parameter's annotation.\n 4. Fall back to the parameter's default value, or None for Optional types.\n 5. Raise QueryParamValidationError if a required parameter is missing.\n\n Args:\n unresolved_params: dict of param_name -> inspect.Parameter for params not yet resolved.\n query_params: QueryParams object with .get() and .get_all() methods.\n path_params: dict of path parameter values (may be None for WebSocket).\n route_param_names: set of parameter names declared in the route pattern (e.g. from /:id).\n\n Returns:\n dict mapping param names to their resolved values.\n \"\"\"\n resolved = {}\n\n for param_name, param in unresolved_params.items():\n annotation = param.annotation\n if annotation is inspect.Parameter.empty:\n annotation = str\n\n inner_type, is_optional = unwrap_optional(annotation)\n is_list = is_list_type(inner_type)\n elem_type = get_list_element_type(inner_type) if is_list else inner_type\n\n raw_value = _MISSING\n\n # 1. Check path params first\n if path_params is not None and param_name in route_param_names:\n pv = path_params.get(param_name)\n if pv is not None:\n raw_value = pv\n\n # 2. Check query params\n if raw_value is _MISSING and query_params is not None:\n if is_list:\n all_values = query_params.get_all(param_name)\n if all_values is not None:\n resolved[param_name] = [coerce_value(v, elem_type, param_name) for v in all_values]\n continue\n else:\n qp_value = query_params.get(param_name, None)\n if qp_value is not None:\n raw_value = qp_value\n\n # 3. Got a value — coerce it\n if raw_value is not _MISSING:\n resolved[param_name] = coerce_value(raw_value, inner_type, param_name)\n continue\n\n # 4. Use default value if available\n if param.default is not inspect.Parameter.empty:\n resolved[param_name] = param.default\n continue\n\n # 5. Optional with no default -> None\n if is_optional:\n resolved[param_name] = None\n continue\n\n # 6. Truly missing required parameter\n raise QueryParamValidationError(param_name, None, elem_type)\n\n return resolved\n\n\ndef parse_route_param_names(endpoint: str) -> Set[str]:\n \"\"\"\n Extract parameter names from a route endpoint pattern.\n e.g. \"/users/:id/posts/:post_id\" -> {\"id\", \"post_id\"}\n\n Walks the string character by character looking for ':' followed by\n word characters (alphanumeric + underscore).\n \"\"\"\n names = set()\n i = 0\n length = len(endpoint)\n while i < length:\n if endpoint[i] == \":\":\n # Start of a param name — collect word characters\n i += 1\n start = i\n while i < length and (endpoint[i].isalnum() or endpoint[i] == \"_\"):\n i += 1\n if i > start:\n names.add(endpoint[start:i])\n else:\n i += 1\n return names\n"
},
{
"path": "robyn/ai.py",
"content": "\"\"\"\nThis is an experimental AI integration module for Robyn framework.\n\nA poc for the blog at https://sanskar.wtf/posts/the-future-of-robyn\n\nProvides agent and memory functionality for building AI-powered applications for the demonstration of the vision mentioned in\n\"\"\"\n\nimport logging\nimport os\nfrom abc import ABC, abstractmethod\nfrom typing import Any, Dict, List, Optional, Union\n\nlogger = logging.getLogger(__name__)\n\n\nclass AIConfig:\n \"\"\"Configuration class for AI providers and settings\"\"\"\n\n def __init__(self, **kwargs):\n self.config = kwargs\n self._load_from_env()\n\n def _load_from_env(self):\n \"\"\"Load configuration from environment variables\"\"\"\n env_vars = {\n \"OPENAI_API_KEY\": \"openai_api_key\",\n \"ANTHROPIC_API_KEY\": \"anthropic_api_key\",\n \"GOOGLE_API_KEY\": \"google_api_key\",\n \"AI_MODEL\": \"model\",\n \"AI_TEMPERATURE\": \"temperature\",\n \"AI_MAX_TOKENS\": \"max_tokens\",\n }\n\n for env_var, config_key in env_vars.items():\n if env_var in os.environ and config_key not in self.config:\n value = os.environ[env_var]\n # Convert numeric values\n if config_key in [\"temperature\", \"max_tokens\"]:\n try:\n value = float(value) if config_key == \"temperature\" else int(value)\n except ValueError:\n pass\n self.config[config_key] = value\n\n def get(self, key: str, default: Any = None) -> Any:\n \"\"\"Get configuration value\"\"\"\n return self.config.get(key, default)\n\n def set(self, key: str, value: Any) -> None:\n \"\"\"Set configuration value\"\"\"\n self.config[key] = value\n\n def update(self, **kwargs) -> None:\n \"\"\"Update configuration with new values\"\"\"\n self.config.update(kwargs)\n\n def to_dict(self) -> Dict[str, Any]:\n \"\"\"Get configuration as dictionary\"\"\"\n return self.config.copy()\n\n\nclass MemoryProvider(ABC):\n \"\"\"Abstract base class for memory providers\"\"\"\n\n @abstractmethod\n async def store(self, user_id: str, data: Dict[str, Any]) -> None:\n \"\"\"Store data in memory\"\"\"\n pass\n\n @abstractmethod\n async def retrieve(self, user_id: str, query: Optional[str] = None) -> List[Dict[str, Any]]:\n \"\"\"Retrieve data from memory\"\"\"\n pass\n\n @abstractmethod\n async def clear(self, user_id: str) -> None:\n \"\"\"Clear memory for a user\"\"\"\n pass\n\n\nclass InMemoryProvider(MemoryProvider):\n \"\"\"Simple in-memory storage provider\"\"\"\n\n def __init__(self):\n self._storage: Dict[str, List[Dict[str, Any]]] = {}\n\n async def store(self, user_id: str, data: Dict[str, Any]) -> None:\n if user_id not in self._storage:\n self._storage[user_id] = []\n self._storage[user_id].append(data)\n\n async def retrieve(self, user_id: str, query: Optional[str] = None) -> List[Dict[str, Any]]:\n return self._storage.get(user_id, [])\n\n async def clear(self, user_id: str) -> None:\n if user_id in self._storage:\n del self._storage[user_id]\n\n\nclass Memory:\n \"\"\"Memory interface for storing and retrieving conversation history and context\"\"\"\n\n def __init__(self, provider: Union[str, MemoryProvider], user_id: str, **kwargs):\n self.user_id = user_id\n\n if isinstance(provider, str):\n if provider == \"inmemory\":\n self.provider = InMemoryProvider()\n else:\n raise ValueError(f\"Unknown memory provider: {provider}\")\n else:\n self.provider = provider\n\n async def add(self, message: str, metadata: Optional[Dict[str, Any]] = None) -> None:\n \"\"\"Add a message to memory\"\"\"\n data = {\"message\": message, \"metadata\": metadata or {}}\n await self.provider.store(self.user_id, data)\n\n async def get(self, query: Optional[str] = None) -> List[Dict[str, Any]]:\n \"\"\"Get messages from memory\"\"\"\n return await self.provider.retrieve(self.user_id, query)\n\n async def clear(self) -> None:\n \"\"\"Clear all memory for this user\"\"\"\n await self.provider.clear(self.user_id)\n\n\nclass AgentRunner(ABC):\n \"\"\"Abstract base class for agent runners\"\"\"\n\n @abstractmethod\n async def run(self, query: str, **kwargs) -> Dict[str, Any]:\n \"\"\"Execute the agent with the given query\"\"\"\n pass\n\n\nclass SimpleRunner(AgentRunner):\n \"\"\"Simple runner with OpenAI integration and fallback responses\"\"\"\n\n def __init__(self, **config):\n self.config = AIConfig(**config)\n self._client = None\n\n def _get_client(self):\n \"\"\"Get OpenAI client if API key is available\"\"\"\n if self._client is None and self.config.get(\"openai_api_key\"):\n try:\n import openai\n\n self._client = openai.OpenAI(api_key=self.config.get(\"openai_api_key\"))\n except ImportError:\n raise ImportError(\"openai package not installed. Install with: pip install openai\")\n return self._client\n\n async def run(self, query: str, **kwargs) -> Dict[str, Any]:\n \"\"\"Execute with OpenAI (requires API key)\"\"\"\n client = self._get_client()\n\n if not client:\n raise ValueError(\"OpenAI API key is required. Set 'openai_api_key' in configuration.\")\n\n try:\n # Use OpenAI\n messages = [{\"role\": \"user\", \"content\": query}]\n\n # Add conversation history\n context = kwargs.get(\"context\", {})\n history = context.get(\"history\", [])\n\n if history:\n for item in history[-10:]:\n msg = item.get(\"message\", str(item))\n if msg.startswith(\"Query: \"):\n messages.insert(-1, {\"role\": \"user\", \"content\": msg[7:]})\n elif msg.startswith(\"Response: \"):\n messages.insert(-1, {\"role\": \"assistant\", \"content\": msg[10:]})\n\n response = client.chat.completions.create(\n model=self.config.get(\"model\", \"gpt-4o\"),\n messages=messages,\n temperature=self.config.get(\"temperature\", 0.7),\n max_tokens=self.config.get(\"max_tokens\", 1000),\n )\n\n content = response.choices[0].message.content\n metadata = {\n \"runner_type\": \"simple_openai\",\n \"model\": self.config.get(\"model\", \"gpt-4o\"),\n \"usage\": {\n \"prompt_tokens\": response.usage.prompt_tokens,\n \"completion_tokens\": response.usage.completion_tokens,\n \"total_tokens\": response.usage.total_tokens,\n },\n }\n\n if self.config.get(\"debug\", False):\n metadata[\"debug_info\"] = {\"config\": self.config.to_dict()}\n\n return {\"response\": content, \"query\": query, \"metadata\": metadata}\n\n except Exception as e:\n logger.error(f\"Error in SimpleRunner: {e}\")\n raise e\n\n\nclass Agent:\n \"\"\"AI Agent interface for handling queries with memory and execution\"\"\"\n\n def __init__(self, runner: Union[str, AgentRunner], memory: Optional[Memory] = None, **kwargs):\n self.memory = memory\n\n if isinstance(runner, str):\n if runner == \"simple\":\n self.runner = SimpleRunner(**kwargs)\n else:\n raise ValueError(f\"Unknown runner type: {runner}\")\n else:\n self.runner = runner\n\n async def run(self, query: str, history: bool = False, **kwargs) -> Dict[str, Any]:\n \"\"\"Run the agent with the given query\"\"\"\n context = {}\n\n if self.memory and history:\n context[\"history\"] = await self.memory.get()\n\n # Add context to kwargs\n if context:\n kwargs[\"context\"] = context\n\n # Execute the agent\n result = await self.runner.run(query, **kwargs)\n\n # Store the interaction in memory if available\n if self.memory:\n await self.memory.add(f\"Query: {query}\")\n if \"response\" in result:\n await self.memory.add(f\"Response: {result['response']}\")\n\n return result\n\n\ndef memory(provider: str = \"inmemory\", user_id: str = \"default\", **kwargs) -> Memory:\n \"\"\"\n Create a memory instance with the specified provider\n\n Args:\n provider: Memory provider type (\"inmemory\")\n user_id: User identifier for memory isolation\n **kwargs: Additional configuration for the provider\n\n Returns:\n Memory instance\n \"\"\"\n return Memory(provider=provider, user_id=user_id, **kwargs)\n\n\ndef configure(**kwargs) -> AIConfig:\n \"\"\"\n Create and configure AI settings\n\n Args:\n **kwargs: Configuration options including API keys, model settings, etc.\n\n Returns:\n AIConfig instance\n\n Example:\n config = configure(\n openai_api_key=\"your-key\",\n model=\"gpt-4\",\n temperature=0.7\n )\n \"\"\"\n return AIConfig(**kwargs)\n\n\ndef agent(runner: str = \"simple\", memory: Optional[Memory] = None, config: Optional[AIConfig] = None, **kwargs) -> Agent:\n \"\"\"\n Create an agent instance with the specified runner\n\n Args:\n runner: Agent runner type (\"simple\")\n memory: Optional memory instance for context\n config: Optional AIConfig instance for configuration\n **kwargs: Additional configuration for the runner\n\n Returns:\n Agent instance\n\n Example:\n # Simple usage\n chat = agent()\n\n # With configuration\n config = configure(openai_api_key=\"your-key\")\n chat = agent(runner=\"simple\", config=config)\n\n # With memory\n mem = memory(provider=\"inmemory\", user_id=\"user123\")\n chat = agent(runner=\"simple\", memory=mem)\n \"\"\"\n # Merge config if provided\n if config:\n kwargs.update(config.to_dict())\n\n return Agent(runner=runner, memory=memory, **kwargs)\n"
},
{
"path": "robyn/argument_parser.py",
"content": "import argparse\nimport os\n\n\nclass Config:\n def __init__(self) -> None:\n parser = argparse.ArgumentParser(description=\"Robyn, a fast async web framework with a rust runtime.\")\n self.parser = parser\n parser.add_argument(\n \"--processes\",\n type=int,\n default=None,\n required=False,\n help=\"Choose the number of processes. [Default: 1]\",\n )\n parser.add_argument(\n \"--workers\",\n type=int,\n default=None,\n required=False,\n help=\"Choose the number of workers. [Default: 1]\",\n )\n parser.add_argument(\n \"--dev\",\n dest=\"dev\",\n action=\"store_true\",\n default=None,\n help=\"Development mode. It restarts the server based on file changes.\",\n )\n parser.add_argument(\n \"--log-level\",\n dest=\"log_level\",\n default=None,\n help=\"Set the log level name\",\n )\n parser.add_argument(\n \"--create\",\n action=\"store_true\",\n default=False,\n help=\"Create a new project template.\",\n )\n parser.add_argument(\n \"--docs\",\n action=\"store_true\",\n default=False,\n help=\"Open the Robyn documentation.\",\n )\n parser.add_argument(\n \"--open-browser\",\n action=\"store_true\",\n default=False,\n help=\"Open the browser on successful start.\",\n )\n parser.add_argument(\n \"--version\",\n action=\"store_true\",\n default=False,\n help=\"Show the Robyn version.\",\n )\n parser.add_argument(\n \"--compile-rust-path\",\n dest=\"compile_rust_path\",\n default=None,\n help=\"Compile rust files in the given path.\",\n )\n\n parser.add_argument(\n \"--create-rust-file\",\n dest=\"create_rust_file\",\n default=None,\n help=\"Create a rust file with the given name.\",\n )\n parser.add_argument(\n \"--disable-openapi\",\n dest=\"disable_openapi\",\n action=\"store_true\",\n default=False,\n help=\"Disable the OpenAPI documentation.\",\n )\n parser.add_argument(\n \"--fast\",\n dest=\"fast\",\n action=\"store_true\",\n default=False,\n help=\"Fast mode. It sets the optimal values for processes, workers and log level. However, you can override them.\",\n )\n\n args, unknown_args = parser.parse_known_args()\n self.fast = args.fast\n self.dev = args.dev\n self.processes = args.processes\n self.workers = args.workers\n self.create = args.create\n self.docs = args.docs\n self.open_browser = args.open_browser\n self.version = args.version\n self.compile_rust_path = args.compile_rust_path\n self.create_rust_file = args.create_rust_file\n self.file_path = None\n self.disable_openapi = args.disable_openapi\n self.log_level = args.log_level\n\n if self.fast:\n # doing this here before every other check\n # so that processes, workers and log_level can be overridden\n cpu_count: int = os.cpu_count() or 1\n self.processes = self.processes or ((cpu_count * 2) + 1) or 1\n self.workers = self.workers or 2\n self.log_level = self.log_level or \"WARNING\"\n\n self.processes = self.processes or 1\n self.workers = self.workers or 1\n\n # find something that ends with .py in unknown_args\n for arg in unknown_args:\n if arg.endswith(\".py\"):\n self.file_path = arg\n break\n\n if self.fast and self.dev:\n raise ValueError(\"--fast and --dev shouldn't be used together\")\n\n if self.dev and (self.processes != 1 or self.workers != 1):\n raise ValueError(\"--processes and --workers shouldn't be used with --dev\")\n\n if self.dev and self.log_level is None:\n self.log_level = \"DEBUG\"\n elif self.log_level is None:\n self.log_level = \"INFO\"\n"
},
{
"path": "robyn/authentication.py",
"content": "from abc import ABC, abstractmethod\nfrom typing import Optional\n\nfrom robyn.robyn import Headers, Identity, Request, Response\nfrom robyn.status_codes import HTTP_401_UNAUTHORIZED\n\n\nclass AuthenticationNotConfiguredError(Exception):\n \"\"\"\n This exception is raised when the authentication is not configured.\n \"\"\"\n\n def __str__(self):\n return \"Authentication is not configured. Use app.configure_authentication() to configure it.\"\n\n\nclass TokenGetter(ABC):\n @property\n def scheme(self) -> str:\n \"\"\"\n Gets the scheme of the token.\n :return: The scheme of the token.\n \"\"\"\n return self.__class__.__name__\n\n @classmethod\n @abstractmethod\n def get_token(cls, request: Request) -> Optional[str]:\n \"\"\"\n Gets the token from the request.\n This method should not decode the token. Decoding is the role of the authentication handler.\n :param request: The request object.\n :return: The encoded token.\n \"\"\"\n raise NotImplementedError()\n\n @classmethod\n @abstractmethod\n def set_token(cls, request: Request, token: str):\n \"\"\"\n Sets the token in the request.\n This method should not encode the token. Encoding is the role of the authentication handler.\n :param request: The request object.\n :param token: The encoded token.\n \"\"\"\n raise NotImplementedError()\n\n\nclass AuthenticationHandler(ABC):\n def __init__(self, token_getter: TokenGetter):\n \"\"\"\n Creates a new instance of the AuthenticationHandler class.\n This class is an abstract class used to authenticate a user.\n :param token_getter: The token getter used to get the token from the request.\n \"\"\"\n self.token_getter = token_getter\n\n @property\n def unauthorized_response(self) -> Response:\n return Response(\n headers=Headers({\"WWW-Authenticate\": self.token_getter.scheme}),\n description=\"Unauthorized\",\n status_code=HTTP_401_UNAUTHORIZED,\n )\n\n @abstractmethod\n def authenticate(self, request: Request) -> Optional[Identity]:\n \"\"\"\n Authenticates the user.\n :param request: The request object.\n :return: The identity of the user.\n \"\"\"\n raise NotImplementedError()\n\n\nclass BearerGetter(TokenGetter):\n \"\"\"\n This class is used to get the token from the Authorization header.\n The scheme of the header must be Bearer.\n \"\"\"\n\n @classmethod\n def get_token(cls, request: Request) -> Optional[str]:\n if request.headers.contains(\"authorization\"):\n authorization_header = request.headers.get(\"authorization\")\n else:\n authorization_header = None\n\n if not authorization_header or not authorization_header.startswith(\"Bearer \"):\n return None\n\n return authorization_header[7:] # Remove the \"Bearer \" prefix\n\n @classmethod\n def set_token(cls, request: Request, token: str):\n request.headers[\"Authorization\"] = f\"Bearer {token}\"\n"
},
{
"path": "robyn/cli.py",
"content": "import os\nimport shutil\nimport subprocess\nimport sys\nimport webbrowser\nfrom pathlib import Path\nfrom typing import Optional\n\nfrom InquirerPy.base.control import Choice\nfrom InquirerPy.resolver import prompt\n\nfrom robyn.env_populator import load_vars\nfrom robyn.robyn import get_version\n\nfrom .argument_parser import Config\nfrom .reloader import create_rust_file, setup_reloader\n\nSCAFFOLD_DIR = Path(__file__).parent / \"scaffold\"\nCURRENT_WORKING_DIR = Path.cwd()\n\n\ndef create_robyn_app():\n questions = [\n {\n \"type\": \"input\",\n \"message\": \"Directory Path:\",\n \"name\": \"directory\",\n },\n {\n \"type\": \"list\",\n \"message\": \"Need Docker? (Y/N)\",\n \"choices\": [\n Choice(\"Y\", name=\"Y\"),\n Choice(\"N\", name=\"N\"),\n ],\n \"default\": Choice(\"N\", name=\"N\"),\n \"name\": \"docker\",\n },\n {\n \"type\": \"list\",\n \"message\": \"Please select project type (Mongo/Postgres/Sqlalchemy/Prisma): \",\n \"choices\": [\n Choice(\"no-db\", name=\"No DB\"),\n Choice(\"sqlite\", name=\"Sqlite\"),\n Choice(\"postgres\", name=\"Postgres\"),\n Choice(\"mongo\", name=\"MongoDB\"),\n Choice(\"sqlalchemy\", name=\"SqlAlchemy\"),\n Choice(\"prisma\", name=\"Prisma\"),\n Choice(\"sqlmodel\", name=\"SQLModel\"),\n ],\n \"default\": Choice(\"no-db\", name=\"No DB\"),\n \"name\": \"project_type\",\n },\n ]\n result = prompt(questions=questions)\n project_dir_path = Path(str(result[\"directory\"])).resolve()\n docker = result[\"docker\"]\n project_type = str(result[\"project_type\"])\n\n final_project_dir_path = (CURRENT_WORKING_DIR / project_dir_path).resolve()\n\n print(f\"Creating a new Robyn project '{final_project_dir_path}'...\")\n\n # Create a new directory for the project\n os.makedirs(final_project_dir_path, exist_ok=True)\n\n selected_project_template = (SCAFFOLD_DIR / Path(project_type)).resolve()\n shutil.copytree(str(selected_project_template), str(final_project_dir_path), dirs_exist_ok=True)\n\n # If docker is not needed, delete the docker file\n if docker == \"N\":\n os.remove(f\"{final_project_dir_path}/Dockerfile\")\n\n print(f\"New Robyn project created in '{final_project_dir_path}' \")\n\n\ndef docs():\n print(\"Opening Robyn documentation... | Offline docs coming soon!\")\n webbrowser.open(\"https://robyn.tech\")\n\n\ndef start_dev_server(config: Config, file_path: Optional[str] = None):\n if file_path is None:\n return\n\n absolute_file_path = (Path.cwd() / file_path).resolve()\n directory_path = absolute_file_path.parent\n\n if config.dev and not os.environ.get(\"IS_RELOADER_RUNNING\", False):\n setup_reloader(str(directory_path), str(absolute_file_path))\n return\n\n\ndef start_app_normally(config: Config):\n command = [sys.executable]\n\n for arg in sys.argv[1:]:\n command.append(arg)\n\n # Run the subprocess\n subprocess.run(command, start_new_session=False)\n\n\ndef run():\n config = Config()\n\n if not config.file_path:\n config.file_path = f\"{os.getcwd()}/{__name__}\"\n\n load_vars(project_root=os.path.dirname(os.path.abspath(config.file_path)))\n os.environ[\"ROBYN_CLI\"] = \"True\"\n\n if config.dev is None:\n config.dev = os.getenv(\"ROBYN_DEV_MODE\", False) == \"True\"\n\n if config.create:\n create_robyn_app()\n\n elif file_name := config.create_rust_file:\n create_rust_file(file_name)\n\n elif config.version:\n print(get_version())\n\n elif config.docs:\n docs()\n\n elif config.dev:\n print(\"Starting dev server...\")\n start_dev_server(config, config.file_path)\n else:\n try:\n start_app_normally(config)\n except KeyboardInterrupt:\n # for the crash happening upon pressing Ctrl + C\n pass\n"
},
{
"path": "robyn/dependency_injection.py",
"content": "\"\"\"This is Robyn's dependency injection file.\"\"\"\n\nfrom typing import Any\n\n\nclass DependencyMap:\n def __init__(self) -> None:\n self.global_dependency_map: dict[str, Any] = {}\n # {'router': {'dependency_name': dependency_class}\n self.router_dependency_map: dict[str, dict[str, Any]] = {}\n\n def add_router_dependency(self, router, **kwargs):\n \"\"\"Adds a dependency to a route.\n\n Args:\n router App Object: The route to add the dependency to.\n kwargs (dict): The dependencies to add to the route.\n \"\"\"\n if router not in self.router_dependency_map:\n self.router_dependency_map[router] = {}\n\n self.router_dependency_map[router].update(**kwargs)\n\n def add_global_dependency(self, **kwargs):\n \"\"\"Adds a dependency to all routes.\n\n Args:\n kwargs (dict): The dependencies to add to all routes.\n \"\"\"\n for name, element in kwargs.items():\n self.global_dependency_map.update({name: element})\n\n def get_router_dependencies(self, router):\n \"\"\"Gets the dependencies for a specific route.\n\n Args:\n router\n\n Returns:\n dict: The dependencies for the specified route.\n \"\"\"\n return self.router_dependency_map.get(router, {})\n\n def get_global_dependencies(self):\n \"\"\"Gets the dependencies for a route.\n\n Args:\n route (str): The route to get the dependencies for.\n \"\"\"\n return self.global_dependency_map\n\n def merge_dependencies(self, target_router):\n \"\"\"\n Merge dependencies from this DependencyMap into another router's DependencyMap.\n\n Args:\n target_router: The router with which to merge dependencies.\n\n This method iterates through the dependencies of this DependencyMap and adds any dependencies\n that are not already present in the target router's DependencyMap.\n \"\"\"\n for dep_key in self.get_global_dependencies():\n if dep_key in target_router.dependencies.get_global_dependencies():\n continue\n target_router.dependencies.get_global_dependencies()[dep_key] = self.get_global_dependencies()[dep_key]\n\n def get_dependency_map(self, router) -> dict:\n return {\n \"global_dependencies\": self.get_global_dependencies(),\n \"router_dependencies\": self.get_router_dependencies(router),\n }\n"
},
{
"path": "robyn/env_populator.py",
"content": "import logging\nimport os\nfrom pathlib import Path\n\nlogger = logging.getLogger(__name__)\n\n\n# parse the configuration file returning a list of tuples (key, value) containing the environment variables\ndef parser(config_path=None, project_root=\"\"):\n \"\"\"Find robyn.env file in root of the project and parse it\"\"\"\n if config_path is None:\n config_path = Path(project_root) / \"robyn.env\"\n\n if config_path.exists():\n with open(config_path, \"r\") as f:\n for line in f:\n if line.startswith(\"#\"):\n continue\n yield line.strip().split(\"=\")\n\n\n# check for the environment variables set in cli and if not set them\ndef load_vars(variables=None, project_root=\"\"):\n \"\"\"Main function\"\"\"\n\n if variables is None:\n variables = parser(project_root=project_root)\n\n for var in variables:\n if var[0] in os.environ:\n logger.info(\" Variable %s already set\", var[0])\n continue\n else:\n os.environ[var[0]] = var[1]\n logger.info(\" Variable %s set to %s\", var[0], var[1])\n"
},
{
"path": "robyn/events.py",
"content": "from enum import Enum\n\n\nclass Events(Enum):\n STARTUP = \"startup\"\n SHUTDOWN = \"shutdown\"\n"
},
{
"path": "robyn/exceptions.py",
"content": "import http\n\n\nclass HTTPException(Exception):\n def __init__(self, status_code: int, detail: str | None = None) -> None:\n if detail is None:\n detail = http.HTTPStatus(status_code).phrase\n self.status_code = status_code\n self.detail = detail\n\n def __str__(self) -> str:\n return f\"{self.status_code}: {self.detail}\"\n\n def __repr__(self) -> str:\n class_name = self.__class__.__name__\n return f\"{class_name}(status_code={self.status_code}, detail={self.detail})\"\n\n\nclass WebSocketException(Exception):\n def __init__(self, code: int, reason: str | None = None) -> None:\n self.code = code\n self.reason = reason or \"\"\n\n def __str__(self) -> str:\n return f\"{self.code}: {self.reason}\"\n\n def __repr__(self) -> str:\n class_name = self.__class__.__name__\n return f\"{class_name}(code={self.code}, reason={self.reason})\"\n\n\n__all__ = [\"HTTPException\", \"WebSocketException\"]\n"
},
{
"path": "robyn/jsonify.py",
"content": "from typing import Any, Dict, List, Union\n\nimport orjson\n\n\ndef jsonify(data: Union[Dict[str, Any], List[Any]]) -> str:\n \"\"\"\n This function serializes input data to a json string\n\n Attributes:\n data: dict or list to serialize as JSON response\n \"\"\"\n output_binary = orjson.dumps(data)\n output_str = output_binary.decode(\"utf-8\")\n return output_str\n"
},
{
"path": "robyn/logger.py",
"content": "import logging\nfrom enum import Enum\nfrom typing import Optional\n\n\nclass Colors(Enum):\n BLUE = \"\\033[94m\"\n CYAN = \"\\033[96m\"\n GREEN = \"\\033[92m\"\n YELLOW = \"\\033[93m\"\n RED = \"\\033[91m\"\n\n\nclass Logger:\n HEADER = \"\\033[95m\"\n ENDC = \"\\033[0m\"\n BOLD = \"\\033[1m\"\n UNDERLINE = \"\\033[4m\"\n\n def __init__(self):\n self.logger = logging.getLogger(__name__)\n\n def _format_msg(\n self,\n msg: str,\n color: Optional[Colors],\n bold: bool,\n underline: bool,\n ):\n result = msg\n if color is not None:\n result = f\"{color.value}{result}{Logger.ENDC}\"\n if bold:\n result = f\"{Logger.BOLD}{result}\"\n if underline:\n result = f\"{Logger.UNDERLINE}{result}\"\n return result\n\n def error(\n self,\n msg: str,\n *args,\n color: Optional[Colors] = Colors.RED,\n bold: bool = False,\n underline: bool = False,\n ):\n self.logger.error(self._format_msg(msg, color, bold, underline), *args)\n\n def warn(\n self,\n msg: str,\n *args,\n color: Optional[Colors] = Colors.YELLOW,\n bold: bool = False,\n underline: bool = False,\n ):\n self.logger.warning(self._format_msg(msg, color, bold, underline), *args)\n\n def info(\n self,\n msg: str,\n *args,\n color: Optional[Colors] = Colors.GREEN,\n bold: bool = False,\n underline: bool = False,\n ):\n self.logger.info(self._format_msg(msg, color, bold, underline), *args)\n\n def debug(\n self,\n msg: str,\n *args,\n color: Colors = Colors.BLUE,\n bold: bool = False,\n underline: bool = False,\n ):\n self.logger.debug(self._format_msg(msg, color, bold, underline), *args)\n\n\nlogger = Logger()\n"
},
{
"path": "robyn/mcp.py",
"content": "\"\"\"\nModel Context Protocol (MCP) implementation for Robyn.\n\nThis module provides MCP server functionality following the JSON-RPC 2.0 specification.\nIt allows Robyn applications to serve as MCP servers, exposing resources, tools, and prompts\nto MCP clients like Claude Desktop or other AI applications.\n\"\"\"\n\nimport inspect\nimport json\nimport logging\nimport re\nfrom dataclasses import asdict, dataclass\nfrom typing import Any, Callable, Dict, List, Optional, Tuple, Union\n\nlogger = logging.getLogger(__name__)\n\n\ndef _extract_uri_params(uri: str) -> List[str]:\n \"\"\"Extract parameter names from URI template like 'echo://{message}'\"\"\"\n return re.findall(r\"\\{(\\w+)\\}\", uri)\n\n\ndef _generate_schema_from_function(func: Callable) -> Dict[str, Any]:\n \"\"\"Generate JSON schema from function signature\"\"\"\n sig = inspect.signature(func)\n properties = {}\n required = []\n\n for param_name, param in sig.parameters.items():\n # Skip 'self' parameter\n if param_name == \"self\":\n continue\n\n param_schema = {\"type\": \"string\"} # Default to string\n\n # Try to infer type from annotation\n if param.annotation != inspect.Parameter.empty:\n if param.annotation is str:\n param_schema[\"type\"] = \"string\"\n elif param.annotation is int:\n param_schema[\"type\"] = \"integer\"\n elif param.annotation is float:\n param_schema[\"type\"] = \"number\"\n elif param.annotation is bool:\n param_schema[\"type\"] = \"boolean\"\n elif hasattr(param.annotation, \"__origin__\"):\n # Handle generic types like List, Dict, etc.\n param_schema[\"type\"] = \"object\"\n\n properties[param_name] = param_schema\n\n # Add to required if no default value\n if param.default == inspect.Parameter.empty:\n required.append(param_name)\n\n return {\"type\": \"object\", \"properties\": properties, \"required\": required}\n\n\ndef _generate_prompt_args_from_function(func: Callable) -> List[Dict[str, Any]]:\n \"\"\"Generate prompt arguments from function signature\"\"\"\n sig = inspect.signature(func)\n arguments = []\n\n for param_name, param in sig.parameters.items():\n if param_name == \"self\":\n continue\n\n arg_def = {\"name\": param_name, \"description\": f\"Parameter {param_name}\", \"required\": param.default == inspect.Parameter.empty}\n arguments.append(arg_def)\n\n return arguments\n\n\n@dataclass\nclass MCPResource:\n \"\"\"Represents an MCP resource\"\"\"\n\n uri: str\n name: str\n description: Optional[str] = None\n mimeType: Optional[str] = None\n\n\n@dataclass\nclass MCPTool:\n \"\"\"Represents an MCP tool\"\"\"\n\n name: str\n description: str\n inputSchema: Dict[str, Any]\n\n\n@dataclass\nclass MCPPrompt:\n \"\"\"Represents an MCP prompt template\"\"\"\n\n name: str\n description: str\n arguments: Optional[List[Dict[str, Any]]] = None\n\n\n@dataclass\nclass MCPMessage:\n \"\"\"JSON-RPC 2.0 message structure\"\"\"\n\n jsonrpc: str = \"2.0\"\n id: Optional[Union[str, int]] = None\n method: Optional[str] = None\n params: Optional[Dict[str, Any]] = None\n result: Optional[Any] = None\n error: Optional[Dict[str, Any]] = None\n\n\nclass MCPError(Exception):\n \"\"\"MCP-specific error\"\"\"\n\n def __init__(self, code: int, message: str, data: Optional[Any] = None):\n self.code = code\n self.message = message\n self.data = data\n super().__init__(message)\n\n\nclass MCPHandler:\n \"\"\"Handles MCP protocol requests and responses\"\"\"\n\n def __init__(self):\n self.resources: Dict[str, Callable] = {}\n self.tools: Dict[str, Callable] = {}\n self.prompts: Dict[str, Callable] = {}\n self.resource_metadata: Dict[str, MCPResource] = {}\n self.tool_metadata: Dict[str, MCPTool] = {}\n self.prompt_metadata: Dict[str, MCPPrompt] = {}\n self.server_info = {\"name\": \"robyn-mcp-server\", \"version\": \"1.0.0\"}\n\n def register_resource(self, uri: str, name: str, handler: Callable, description: Optional[str] = None, mime_type: Optional[str] = None):\n \"\"\"Register a resource handler\"\"\"\n self.resources[uri] = handler\n self.resource_metadata[uri] = MCPResource(uri=uri, name=name, description=description, mimeType=mime_type)\n\n def register_tool(self, name: str, handler: Callable, description: str, input_schema: Dict[str, Any]):\n \"\"\"Register a tool handler\"\"\"\n self.tools[name] = handler\n self.tool_metadata[name] = MCPTool(name=name, description=description, inputSchema=input_schema)\n\n def register_prompt(self, name: str, handler: Callable, description: str, arguments: Optional[List[Dict[str, Any]]] = None):\n \"\"\"Register a prompt handler\"\"\"\n self.prompts[name] = handler\n self.prompt_metadata[name] = MCPPrompt(name=name, description=description, arguments=arguments)\n\n async def handle_request(self, request_data: Dict[str, Any]) -> Dict[str, Any]:\n \"\"\"Handle an MCP JSON-RPC request\"\"\"\n try:\n # Parse the request\n method = request_data.get(\"method\")\n params = request_data.get(\"params\", {})\n request_id = request_data.get(\"id\")\n\n # Handle different MCP methods\n if method == \"initialize\":\n result = await self._handle_initialize(params)\n elif method == \"resources/list\":\n result = await self._handle_list_resources(params)\n elif method == \"resources/read\":\n result = await self._handle_read_resource(params)\n elif method == \"tools/list\":\n result = await self._handle_list_tools(params)\n elif method == \"tools/call\":\n result = await self._handle_call_tool(params)\n elif method == \"prompts/list\":\n result = await self._handle_list_prompts(params)\n elif method == \"prompts/get\":\n result = await self._handle_get_prompt(params)\n else:\n raise MCPError(-32601, f\"Method not found: {method}\")\n\n # Return successful response\n return {\"jsonrpc\": \"2.0\", \"id\": request_id, \"result\": result}\n\n except MCPError as e:\n return {\"jsonrpc\": \"2.0\", \"id\": request_data.get(\"id\"), \"error\": {\"code\": e.code, \"message\": e.message, \"data\": e.data}}\n except Exception as e:\n logger.exception(\"Error handling MCP request\")\n return {\"jsonrpc\": \"2.0\", \"id\": request_data.get(\"id\"), \"error\": {\"code\": -32603, \"message\": \"Internal error\", \"data\": str(e)}}\n\n async def _handle_initialize(self, params: Dict[str, Any]) -> Dict[str, Any]:\n \"\"\"Handle MCP initialize request\"\"\"\n return {\n \"protocolVersion\": \"2024-11-05\",\n \"capabilities\": {\"resources\": {\"subscribe\": False, \"listChanged\": False}, \"tools\": {}, \"prompts\": {}},\n \"serverInfo\": self.server_info,\n }\n\n async def _handle_list_resources(self, params: Dict[str, Any]) -> Dict[str, Any]:\n \"\"\"Handle resources/list request\"\"\"\n resources = []\n for uri, metadata in self.resource_metadata.items():\n resources.append(asdict(metadata))\n return {\"resources\": resources}\n\n def _match_uri_template(self, requested_uri: str) -> Optional[Tuple[str, Dict[str, str]]]:\n \"\"\"Match requested URI against registered URI templates\"\"\"\n for template_uri in self.resources.keys():\n # Extract parameter names from template\n param_names = _extract_uri_params(template_uri)\n\n if not param_names:\n # Exact match for non-templated URIs\n if requested_uri == template_uri:\n return template_uri, {}\n continue\n\n # Create regex pattern from template\n pattern = template_uri\n for param_name in param_names:\n # Use (.+) to match any characters including slashes for paths\n # Use ([^/]+) for single segments\n if param_name in [\"path\", \"file_path\", \"directory\"]:\n pattern = pattern.replace(f\"{{{param_name}}}\", r\"(.+)\")\n else:\n pattern = pattern.replace(f\"{{{param_name}}}\", r\"([^/]+)\")\n\n match = re.match(f\"^{pattern}$\", requested_uri)\n if match:\n # Extract parameter values\n param_values = {}\n for i, param_name in enumerate(param_names):\n param_values[param_name] = match.group(i + 1)\n return template_uri, param_values\n\n return None\n\n async def _handle_read_resource(self, params: Dict[str, Any]) -> Dict[str, Any]:\n \"\"\"Handle resources/read request\"\"\"\n uri = params.get(\"uri\")\n if not uri:\n raise MCPError(-32602, \"URI is required\")\n\n # Try to match URI template\n match_result = self._match_uri_template(uri)\n if not match_result:\n raise MCPError(-32602, f\"Resource not found: {uri}\")\n\n template_uri, uri_params = match_result\n handler = self.resources[template_uri]\n\n # Call the handler with appropriate parameters based on its signature\n try:\n sig = inspect.signature(handler)\n handler_params = list(sig.parameters.keys())\n\n if inspect.iscoroutinefunction(handler):\n if uri_params:\n # Use URI parameters for templated resources\n content = await handler(**uri_params)\n elif handler_params:\n # Handler expects parameters, pass the full params dict\n content = await handler(params)\n else:\n # Handler expects no parameters\n content = await handler()\n else:\n if uri_params:\n # Use URI parameters for templated resources\n content = handler(**uri_params)\n elif handler_params:\n # Handler expects parameters, pass the full params dict\n content = handler(params)\n else:\n # Handler expects no parameters\n content = handler()\n except TypeError as e:\n # Handle parameter mismatch errors\n raise MCPError(-32603, f\"Handler parameter error: {str(e)}\")\n\n # Determine content type\n metadata = self.resource_metadata[template_uri]\n mime_type = metadata.mimeType or \"text/plain\"\n\n return {\"contents\": [{\"uri\": uri, \"mimeType\": mime_type, \"text\": str(content)}]}\n\n async def _handle_list_tools(self, params: Dict[str, Any]) -> Dict[str, Any]:\n \"\"\"Handle tools/list request\"\"\"\n tools = []\n for name, metadata in self.tool_metadata.items():\n tools.append(asdict(metadata))\n return {\"tools\": tools}\n\n async def _handle_call_tool(self, params: Dict[str, Any]) -> Dict[str, Any]:\n \"\"\"Handle tools/call request\"\"\"\n name = params.get(\"name\")\n arguments = params.get(\"arguments\", {})\n\n if not name or name not in self.tools:\n raise MCPError(-32602, f\"Tool not found: {name}\")\n\n handler = self.tools[name]\n\n # Call the tool handler\n if inspect.iscoroutinefunction(handler):\n result = await handler(**arguments)\n else:\n result = handler(**arguments)\n\n return {\"content\": [{\"type\": \"text\", \"text\": str(result)}]}\n\n async def _handle_list_prompts(self, params: Dict[str, Any]) -> Dict[str, Any]:\n \"\"\"Handle prompts/list request\"\"\"\n prompts = []\n for name, metadata in self.prompt_metadata.items():\n prompts.append(asdict(metadata))\n return {\"prompts\": prompts}\n\n async def _handle_get_prompt(self, params: Dict[str, Any]) -> Dict[str, Any]:\n \"\"\"Handle prompts/get request\"\"\"\n name = params.get(\"name\")\n arguments = params.get(\"arguments\", {})\n\n if not name or name not in self.prompts:\n raise MCPError(-32602, f\"Prompt not found: {name}\")\n\n handler = self.prompts[name]\n\n # Call the prompt handler\n if inspect.iscoroutinefunction(handler):\n result = await handler(**arguments)\n else:\n result = handler(**arguments)\n\n # Ensure result is in the expected format\n if isinstance(result, str):\n messages = [{\"role\": \"user\", \"content\": {\"type\": \"text\", \"text\": result}}]\n elif isinstance(result, list):\n messages = result\n else:\n messages = [{\"role\": \"user\", \"content\": {\"type\": \"text\", \"text\": str(result)}}]\n\n return {\"description\": self.prompt_metadata[name].description, \"messages\": messages}\n\n\nclass MCPApp:\n \"\"\"MCP application wrapper for Robyn\"\"\"\n\n def __init__(self, robyn_app):\n self.app = robyn_app\n self.handler = MCPHandler()\n self._setup_routes()\n\n def _setup_routes(self):\n \"\"\"Setup MCP routes on the Robyn app\"\"\"\n\n @self.app.post(\"/mcp\")\n async def handle_mcp_request(request):\n \"\"\"Handle MCP JSON-RPC requests\"\"\"\n try:\n # Parse JSON request - try multiple approaches\n try:\n request_data = request.json()\n except (ValueError, TypeError, AttributeError):\n # Fallback to parsing body as string\n body = request.body\n if isinstance(body, str):\n request_data = json.loads(body)\n else:\n request_data = json.loads(body.decode(\"utf-8\"))\n\n # Handle case where request.json() returns a string instead of dict\n if isinstance(request_data, str):\n request_data = json.loads(request_data)\n\n # Handle the request\n response = await self.handler.handle_request(request_data)\n\n return response\n\n except json.JSONDecodeError:\n return {\"jsonrpc\": \"2.0\", \"id\": None, \"error\": {\"code\": -32700, \"message\": \"Parse error\"}}\n except Exception as e:\n logger.exception(\"Error in MCP request handler\")\n return {\"jsonrpc\": \"2.0\", \"id\": None, \"error\": {\"code\": -32603, \"message\": \"Internal error\", \"data\": str(e)}}\n\n def resource(self, uri: str = None, name: str = None, description: Optional[str] = None, mime_type: Optional[str] = None):\n \"\"\"\n Decorator to register an MCP resource\n\n Args:\n uri: Resource URI template (e.g., \"echo://{message}\")\n name: Human-readable name (auto-generated if not provided)\n description: Resource description (auto-generated if not provided)\n mime_type: MIME type (defaults to \"text/plain\")\n\n Example:\n @app.mcp.resource(\"echo://{message}\")\n def echo_resource(message: str) -> str:\n return f\"Resource echo: {message}\"\n \"\"\"\n\n def decorator(func: Callable):\n # Auto-generate metadata if not provided\n actual_uri = uri or f\"function://{func.__name__}\"\n actual_name = name or func.__name__.replace(\"_\", \" \").title()\n actual_description = description or func.__doc__ or f\"Resource: {actual_name}\"\n actual_mime_type = mime_type or \"text/plain\"\n\n self.handler.register_resource(actual_uri, actual_name, func, actual_description, actual_mime_type)\n return func\n\n return decorator\n\n def tool(self, name: str = None, description: str = None, input_schema: Dict[str, Any] = None):\n \"\"\"\n Decorator to register an MCP tool\n\n Args:\n name: Tool name (defaults to function name)\n description: Tool description (auto-generated if not provided)\n input_schema: JSON schema for inputs (auto-generated if not provided)\n\n Example:\n @app.mcp.tool()\n def echo_tool(message: str) -> str:\n return f\"Tool echo: {message}\"\n \"\"\"\n\n def decorator(func: Callable):\n # Auto-generate metadata if not provided\n actual_name = name or func.__name__\n actual_description = description or func.__doc__ or f\"Tool: {func.__name__}\"\n actual_schema = input_schema or _generate_schema_from_function(func)\n\n self.handler.register_tool(actual_name, func, actual_description, actual_schema)\n return func\n\n return decorator\n\n def prompt(self, name: str = None, description: str = None, arguments: Optional[List[Dict[str, Any]]] = None):\n \"\"\"\n Decorator to register an MCP prompt\n\n Args:\n name: Prompt name (defaults to function name)\n description: Prompt description (auto-generated if not provided)\n arguments: Prompt arguments (auto-generated if not provided)\n\n Example:\n @app.mcp.prompt()\n def echo_prompt(message: str) -> str:\n return f\"Please process this message: {message}\"\n \"\"\"\n\n def decorator(func: Callable):\n # Auto-generate metadata if not provided\n actual_name = name or func.__name__\n actual_description = description or func.__doc__ or f\"Prompt: {func.__name__}\"\n actual_arguments = arguments or _generate_prompt_args_from_function(func)\n\n self.handler.register_prompt(actual_name, func, actual_description, actual_arguments)\n return func\n\n return decorator\n"
},
{
"path": "robyn/openapi.py",
"content": "import inspect\nimport json\nimport logging\nimport re\nimport typing\nfrom dataclasses import asdict, dataclass, field\nfrom importlib import resources\nfrom inspect import Signature\nfrom pathlib import Path\nfrom typing import Any, Callable, Dict, List, Optional, Tuple, TypedDict, is_typeddict\n\nfrom robyn.responses import html\nfrom robyn.robyn import QueryParams, Response\nfrom robyn.pydantic_support import get_pydantic_openapi_schema, is_pydantic_model\nfrom robyn.types import Body, JsonBody\n\n_logger = logging.getLogger(__name__)\n\n\nclass str_typed_dict(TypedDict):\n key: str\n value: str\n\n\n@dataclass\nclass Contact:\n \"\"\"\n The contact information for the exposed API.\n (https://swagger.io/specification/#contact-object)\n\n @param name: Optional[str] The identifying name of the contact person/organization.\n @param url: Optional[str] The URL pointing to the contact information. This MUST be in the form of a URL.\n @param email: Optional[str] The email address of the contact person/organization. This MUST be in the form of an email address.\n \"\"\"\n\n name: Optional[str] = None\n url: Optional[str] = None\n email: Optional[str] = None\n\n\n@dataclass\nclass License:\n \"\"\"\n The license information for the exposed API.\n (https://swagger.io/specification/#license-object)\n\n @param name: Optional[str] The license name used for the API.\n @param url: Optional[str] A URL to the license used for the API. This MUST be in the form of a URL.\n \"\"\"\n\n name: Optional[str] = None\n url: Optional[str] = None\n\n\n@dataclass\nclass Server:\n \"\"\"\n An array of Server Objects, which provide connectivity information to a target server. If the servers property is\n not provided, or is an empty array, the default value would be a Server Object with a url value of /.\n (https://swagger.io/specification/#server-object)\n\n @param url: str A URL to the target host. This URL supports Server Variables and MAY be relative,\n to indicate that the host location is relative to the location where the OpenAPI document is being served.\n Variable substitutions will be made when a variable is named in {brackets}.\n @param description: Optional[str] An optional string describing the host designated by the URL.\n \"\"\"\n\n url: str\n description: Optional[str] = None\n\n\n@dataclass\nclass ExternalDocumentation:\n \"\"\"\n Additional external documentation for this operation.\n (https://swagger.io/specification/#external-documentation-object)\n\n @param description: Optional[str] A description of the target documentation.\n @param url: Optional[str] The URL for the target documentation.\n \"\"\"\n\n description: Optional[str] = None\n url: Optional[str] = None\n\n\n@dataclass\nclass Components:\n \"\"\"\n Additional external documentation for this operation.\n (https://swagger.io/specification/#components-object)\n\n @param schemas: Optional[Dict[str, Dict]] An object to hold reusable Schema Objects.\n @param responses: Optional[Dict[str, Dict]] An object to hold reusable Response Objects.\n @param parameters: Optional[Dict[str, Dict]] An object to hold reusable Parameter Objects.\n @param examples: Optional[Dict[str, Dict]] An object to hold reusable Example Objects.\n @param requestBodies: Optional[Dict[str, Dict]] An object to hold reusable Request Body Objects.\n @param securitySchemes: Optional[Dict[str, Dict]] An object to hold reusable Security Scheme Objects.\n @param links: Optional[Dict[str, Dict]] An object to hold reusable Link Objects.\n @param callbacks: Optional[Dict[str, Dict]] An object to hold reusable Callback Objects.\n @param pathItems: Optional[Dict[str, Dict]] An object to hold reusable Callback Objects.\n \"\"\"\n\n schemas: Optional[Dict[str, Dict]] = field(default_factory=dict)\n responses: Optional[Dict[str, Dict]] = field(default_factory=dict)\n parameters: Optional[Dict[str, Dict]] = field(default_factory=dict)\n examples: Optional[Dict[str, Dict]] = field(default_factory=dict)\n requestBodies: Optional[Dict[str, Dict]] = field(default_factory=dict)\n securitySchemes: Optional[Dict[str, Dict]] = field(default_factory=dict)\n links: Optional[Dict[str, Dict]] = field(default_factory=dict)\n callbacks: Optional[Dict[str, Dict]] = field(default_factory=dict)\n pathItems: Optional[Dict[str, Dict]] = field(default_factory=dict)\n\n\n@dataclass\nclass OpenAPIInfo:\n \"\"\"\n Provides metadata about the API. The metadata MAY be used by tooling as required.\n (https://swagger.io/specification/#info-object)\n\n @param title: str The title of the API.\n @param version: str The version of the API.\n @param description: Optional[str] A description of the API.\n @param termsOfService: Optional[str] A URL to the Terms of Service for the API.\n @param contact: Contact The contact information for the exposed API.\n @param license: License The license information for the exposed API.\n @param servers: list[Server] An list of Server objects representing the servers.\n @param externalDocs: Optional[ExternalDocumentation] Additional external documentation.\n @param components: Components An element to hold various schemas for the document.\n \"\"\"\n\n title: str = \"Robyn API\"\n version: str = \"1.0.0\"\n description: Optional[str] = None\n termsOfService: Optional[str] = None\n contact: Contact = field(default_factory=Contact)\n license: License = field(default_factory=License)\n servers: List[Server] = field(default_factory=list)\n externalDocs: Optional[ExternalDocumentation] = field(default_factory=ExternalDocumentation)\n components: Components = field(default_factory=Components)\n\n\n@dataclass\nclass OpenAPI:\n \"\"\"\n This is the root object of the OpenAPI document.\n\n @param info: OpenAPIInfo Provides metadata about the API.\n @param openapi_spec: dict The content of openapi.json as a dict\n \"\"\"\n\n info: OpenAPIInfo = field(default_factory=OpenAPIInfo)\n openapi_spec: dict = field(init=False)\n openapi_file_override: bool = False # denotes whether there is an override or not.\n\n def __post_init__(self):\n \"\"\"\n Initializes the openapi_spec dict\n \"\"\"\n if self.openapi_file_override:\n return\n\n self.openapi_spec = {\n \"openapi\": \"3.1.0\",\n \"info\": asdict(self.info),\n \"paths\": {},\n \"components\": asdict(self.info.components),\n \"servers\": [asdict(server) for server in self.info.servers],\n \"externalDocs\": asdict(self.info.externalDocs) if self.info.externalDocs.url else None,\n }\n\n def add_openapi_path_obj(self, route_type: str, endpoint: str, openapi_name: str, openapi_tags: List[str], handler: Callable):\n \"\"\"\n Adds the given path to openapi spec\n\n @param route_type: str the http method as string (get, post ...)\n @param endpoint: str the endpoint to be added\n @param openapi_name: str the name of the endpoint\n @param openapi_tags: List[str] for grouping of endpoints\n @param handler: Callable the handler function for the endpoint\n \"\"\"\n\n if self.openapi_file_override:\n return\n\n query_params = None\n request_body = None\n return_annotation = None\n\n signature = inspect.signature(handler)\n openapi_description = inspect.getdoc(handler) or \"\"\n\n if signature:\n parameters = signature.parameters\n\n if \"query_params\" in parameters:\n query_params = parameters[\"query_params\"].default\n\n if query_params is Signature.empty:\n query_params = None\n\n if \"body\" in parameters:\n request_body = parameters[\"body\"].default\n\n if request_body is Signature.empty:\n request_body = None\n\n # priority to typing\n for parameter in parameters:\n param_annotation = parameters[parameter].annotation\n\n if inspect.isclass(param_annotation):\n if issubclass(param_annotation, JsonBody):\n request_body = param_annotation\n elif issubclass(param_annotation, Body):\n request_body = param_annotation\n elif issubclass(param_annotation, QueryParams):\n query_params = param_annotation\n elif is_pydantic_model(param_annotation):\n request_body = param_annotation\n elif is_typeddict(param_annotation):\n request_body = param_annotation\n\n if signature.return_annotation is not Signature.empty:\n return_annotation = signature.return_annotation\n\n modified_endpoint, path_obj = self.get_path_obj(\n endpoint, openapi_name, openapi_description, openapi_tags, query_params, request_body, return_annotation\n )\n\n if modified_endpoint not in self.openapi_spec[\"paths\"]:\n self.openapi_spec[\"paths\"][modified_endpoint] = {}\n self.openapi_spec[\"paths\"][modified_endpoint][route_type] = path_obj\n\n def _merge_component_schemas(self, incoming: dict):\n \"\"\"Merge incoming component schemas into the spec with collision detection.\n\n If an incoming schema name already exists and the schemas differ,\n a warning is logged. The incoming schema always wins so that the\n most-recently-registered route's models are used (matching the\n behaviour of path registration).\n \"\"\"\n existing = self.openapi_spec[\"components\"][\"schemas\"]\n for name, schema in incoming.items():\n if name in existing and existing[name] != schema:\n _logger.warning(\n \"OpenAPI component schema '%s' is defined by multiple models with different shapes — the later definition will be used\",\n name,\n )\n existing[name] = schema\n\n def add_subrouter_paths(self, subrouter_openapi: \"OpenAPI\"):\n \"\"\"\n Adds the subrouter paths and component schemas to main router's openapi specs.\n\n @param subrouter_openapi: OpenAPI the OpenAPI object of the current subrouter\n \"\"\"\n\n if self.openapi_file_override:\n return\n\n for path, path_obj in subrouter_openapi.openapi_spec[\"paths\"].items():\n self.openapi_spec[\"paths\"][path] = path_obj\n\n subrouter_schemas = subrouter_openapi.openapi_spec.get(\"components\", {}).get(\"schemas\", {})\n if subrouter_schemas:\n self._merge_component_schemas(subrouter_schemas)\n\n def get_path_obj(\n self,\n endpoint: str,\n name: str,\n description: str,\n tags: List[str],\n query_params: Optional[str_typed_dict],\n request_body: Optional[str_typed_dict],\n return_annotation: Optional[str_typed_dict],\n ) -> Tuple[str, dict]:\n \"\"\"\n Get the \"path\" openapi object according to spec\n\n @param endpoint: str the endpoint to be added\n @param name: str the name of the endpoint\n @param description: Optional[str] short description of the endpoint (to be fetched from the endpoint definition by default)\n @param tags: List[str] for grouping of endpoints\n @param query_params: Optional[TypedDict] query params for the function\n @param request_body: Optional[TypedDict] request body for the function\n @param return_annotation: Optional[TypedDict] return type of the endpoint handler\n\n @return: (str, dict) a tuple containing the endpoint with path params wrapped in braces and the \"path\" openapi object\n according to spec\n \"\"\"\n\n if not description:\n description = \"No description provided\"\n\n openapi_path_object: dict = {\n \"summary\": name,\n \"description\": description,\n \"parameters\": [],\n \"tags\": tags,\n }\n\n # robyn has paths like /:url/:etc whereas openapi requires path like /{url}/{path}\n # this function is used for converting path params to the required form\n # initialized with endpoint for handling endpoints without path params\n endpoint_with_path_params_wrapped_in_braces = endpoint\n\n path_param_names = re.findall(r\":(\\w+)\", endpoint)\n\n if path_param_names:\n # Convert param syntax to OpenAPI's {param} syntax\n # \\w+ matches word characters (letters, digits, underscores) and does not match '/',\n # so each :param is captured individually without swallowing intervening path segments.\n endpoint_with_path_params_wrapped_in_braces = re.sub(r\":(\\w+)\", r\"{\\1}\", endpoint)\n\n for name in path_param_names:\n openapi_path_object[\"parameters\"].append(\n {\n \"name\": name,\n \"in\": \"path\",\n \"required\": True,\n \"schema\": {\"type\": \"string\"},\n }\n )\n\n if query_params:\n query_param_annotations = query_params.__annotations__ if query_params is str_typed_dict else typing.get_type_hints(query_params)\n\n for query_param in query_param_annotations:\n query_param_type = self.get_openapi_type(query_param_annotations[query_param])\n\n openapi_path_object[\"parameters\"].append(\n {\n \"name\": query_param,\n \"in\": \"query\",\n \"required\": False,\n \"schema\": {\"type\": query_param_type},\n }\n )\n\n if request_body:\n if is_pydantic_model(request_body):\n schema, component_schemas = get_pydantic_openapi_schema(request_body)\n if component_schemas:\n self._merge_component_schemas(component_schemas)\n request_body_object = {\"content\": {\"application/json\": {\"schema\": schema}}}\n else:\n properties = {}\n request_body_annotations = request_body.__annotations__ if request_body is TypedDict else typing.get_type_hints(request_body)\n for body_item in request_body_annotations:\n properties[body_item] = self.get_schema_object(body_item, request_body_annotations[body_item])\n request_body_object = {\n \"content\": {\n \"application/json\": {\n \"schema\": {\n \"type\": \"object\",\n \"properties\": properties,\n }\n }\n }\n }\n\n openapi_path_object[\"requestBody\"] = request_body_object\n\n response_schema: dict = {}\n response_type = \"text/plain\"\n\n if return_annotation and return_annotation is not Response:\n response_type = \"application/json\"\n response_schema = self.get_schema_object(\"response object\", return_annotation)\n\n openapi_path_object[\"responses\"] = {\"200\": {\"description\": \"Successful Response\", \"content\": {response_type: {\"schema\": response_schema}}}}\n\n return endpoint_with_path_params_wrapped_in_braces, openapi_path_object\n\n def get_openapi_type(self, typed_dict: str_typed_dict) -> str:\n \"\"\"\n Get actual type from the TypedDict annotations\n\n @param typed_dict: TypedDict The TypedDict to be converted\n @return: str the type inferred\n \"\"\"\n type_mapping = {\n int: \"integer\",\n str: \"string\",\n bool: \"boolean\",\n float: \"number\",\n dict: \"object\",\n list: \"array\",\n }\n\n for type_name in type_mapping:\n if typed_dict is type_name:\n return type_mapping[type_name]\n\n # default to \"string\" if type is not found\n return \"string\"\n\n def get_schema_object(self, parameter: str, param_type: Any) -> dict:\n \"\"\"\n Get the schema object for request/response body\n\n @param parameter: name of the parameter\n @param param_type: Any the type to be inferred\n @return: dict the properties object\n \"\"\"\n\n properties: dict = {\n \"title\": parameter.capitalize(),\n }\n\n type_mapping: dict = {\n int: \"integer\",\n str: \"string\",\n bool: \"boolean\",\n float: \"number\",\n dict: \"object\",\n list: \"array\",\n }\n\n for type_name in type_mapping:\n if param_type is type_name:\n properties[\"type\"] = type_mapping[type_name]\n return properties\n\n # Check if it's a generic type (like List[Object])\n if hasattr(param_type, \"__origin__\"):\n if param_type.__origin__ is list or param_type.__origin__ is List:\n properties[\"type\"] = \"array\"\n # Handle the element type in the list\n if hasattr(param_type, \"__args__\") and param_type.__args__:\n item_type = param_type.__args__[0]\n properties[\"items\"] = self.get_schema_object(f\"{parameter}_item\", item_type)\n return properties\n\n # check for Pydantic models\n if is_pydantic_model(param_type):\n schema, component_schemas = get_pydantic_openapi_schema(param_type)\n if component_schemas:\n self._merge_component_schemas(component_schemas)\n return schema\n\n # check for Optional type\n if param_type.__module__ == \"typing\":\n properties[\"anyOf\"] = [{\"type\": self.get_openapi_type(param_type.__args__[0])}, {\"type\": \"null\"}]\n return properties\n # check for custom classes and TypedDicts\n elif inspect.isclass(param_type):\n properties[\"type\"] = \"object\"\n\n properties[\"properties\"] = {}\n\n for e in param_type.__annotations__:\n properties[\"properties\"][e] = self.get_schema_object(e, param_type.__annotations__[e])\n\n properties[\"type\"] = \"object\"\n\n return properties\n\n def override_openapi(self, openapi_json_spec_path: Path):\n \"\"\"\n Set a pre-configured OpenAPI spec\n @param openapi_json_spec_path: str the path to the json file\n \"\"\"\n with open(openapi_json_spec_path) as json_file:\n json_file_content = json.load(json_file)\n self.openapi_spec = dict(json_file_content)\n self.openapi_file_override = True\n\n def get_openapi_docs_page(self) -> Response:\n \"\"\"\n Handler to the swagger html page to be deployed to the endpoint `/docs`\n @return: FileResponse the swagger html page\n \"\"\"\n with resources.open_text(\"robyn\", \"swagger.html\") as path:\n html_file = path.read()\n return html(html_file)\n\n def get_openapi_config(self) -> dict:\n \"\"\"\n Returns the openapi spec as a dict\n @return: dict the openapi spec\n \"\"\"\n return self.openapi_spec\n"
},
{
"path": "robyn/processpool.py",
"content": "import asyncio\nimport signal\nimport sys\nimport webbrowser\nfrom typing import Dict, List, Optional\n\nfrom multiprocess import Process # type: ignore\n\nfrom robyn.events import Events\nfrom robyn.logger import logger\nfrom robyn.robyn import FunctionInfo, Headers, Server, SocketHeld\nfrom robyn.router import GlobalMiddleware, Route, RouteMiddleware\nfrom robyn.types import Directory\n\n\ndef run_processes(\n url: str,\n port: int,\n directories: List[Directory],\n request_headers: Headers,\n routes: List[Route],\n global_middlewares: List[GlobalMiddleware],\n route_middlewares: List[RouteMiddleware],\n web_sockets: Dict[str, dict],\n event_handlers: Dict[Events, FunctionInfo],\n workers: int,\n processes: int,\n response_headers: Headers,\n excluded_response_headers_paths: Optional[List[str]],\n open_browser: bool,\n client_timeout: int = 30,\n keep_alive_timeout: int = 20,\n) -> List[Process]:\n socket = SocketHeld(url, port)\n\n process_pool = init_processpool(\n directories,\n request_headers,\n routes,\n global_middlewares,\n route_middlewares,\n web_sockets,\n event_handlers,\n socket,\n workers,\n processes,\n response_headers,\n excluded_response_headers_paths,\n client_timeout,\n keep_alive_timeout,\n )\n\n def terminating_signal_handler(_sig, _frame):\n logger.info(\"Terminating server!!\", bold=True)\n for process in process_pool:\n process.kill()\n\n signal.signal(signal.SIGINT, terminating_signal_handler)\n signal.signal(signal.SIGTERM, terminating_signal_handler)\n\n if open_browser:\n logger.info(\"Opening browser...\")\n webbrowser.open_new_tab(f\"http://{url}:{port}/\")\n\n logger.info(\"Press Ctrl + C to stop \\n\")\n for process in process_pool:\n process.join()\n\n return process_pool\n\n\ndef init_processpool(\n directories: List[Directory],\n request_headers: Headers,\n routes: List[Route],\n global_middlewares: List[GlobalMiddleware],\n route_middlewares: List[RouteMiddleware],\n web_sockets: Dict[str, dict],\n event_handlers: Dict[Events, FunctionInfo],\n socket: SocketHeld,\n workers: int,\n processes: int,\n response_headers: Headers,\n excluded_response_headers_paths: Optional[List[str]],\n client_timeout: int = 30,\n keep_alive_timeout: int = 20,\n) -> List[Process]:\n process_pool: List = []\n if sys.platform.startswith(\"win32\") or processes == 1:\n spawn_process(\n directories,\n request_headers,\n routes,\n global_middlewares,\n route_middlewares,\n web_sockets,\n event_handlers,\n socket,\n workers,\n response_headers,\n excluded_response_headers_paths,\n client_timeout,\n keep_alive_timeout,\n )\n\n return process_pool\n\n for _ in range(processes):\n copied_socket = socket.try_clone()\n process = Process(\n target=spawn_process,\n args=(\n directories,\n request_headers,\n routes,\n global_middlewares,\n route_middlewares,\n web_sockets,\n event_handlers,\n copied_socket,\n workers,\n response_headers,\n excluded_response_headers_paths,\n client_timeout,\n keep_alive_timeout,\n ),\n )\n process.start()\n process_pool.append(process)\n\n return process_pool\n\n\ndef initialize_event_loop():\n if sys.platform.startswith(\"win32\") or sys.platform.startswith(\"linux-cross\"):\n loop = asyncio.new_event_loop()\n asyncio.set_event_loop(loop)\n return loop\n else:\n # uv loop doesn't support windows or arm machines at the moment\n # but uv loop is much faster than native asyncio\n import uvloop\n\n uvloop.install()\n loop = uvloop.new_event_loop()\n asyncio.set_event_loop(loop)\n return loop\n\n\ndef spawn_process(\n directories: List[Directory],\n request_headers: Headers,\n routes: List[Route],\n global_middlewares: List[GlobalMiddleware],\n route_middlewares: List[RouteMiddleware],\n web_sockets: Dict[str, dict],\n event_handlers: Dict[Events, FunctionInfo],\n socket: SocketHeld,\n workers: int,\n response_headers: Headers,\n excluded_response_headers_paths: Optional[List[str]],\n client_timeout: int = 30,\n keep_alive_timeout: int = 20,\n):\n \"\"\"\n This function is called by the main process handler to create a server runtime.\n This functions allows one runtime per process.\n\n :param directories List: the list of all the directories and related data\n :param headers tuple: All the global headers in a tuple\n :param routes Tuple[Route]: The routes tuple, containing the description about every route.\n :param middlewares Tuple[Route]: The middleware routes tuple, containing the description about every route.\n :param web_sockets list: This is a list of all the web socket routes\n :param event_handlers Dict: This is an event dict that contains the event handlers\n :param socket SocketHeld: This is the main tcp socket, which is being shared across multiple processes.\n :param process_name string: This is the name given to the process to identify the process\n :param workers int: This is the name given to the process to identify the process\n \"\"\"\n\n loop = initialize_event_loop()\n\n server = Server()\n\n # TODO: if we remove the dot access\n # the startup time will improve in the server\n for directory in directories:\n server.add_directory(*directory.as_list())\n\n server.apply_request_headers(request_headers)\n\n server.apply_response_headers(response_headers)\n\n server.set_response_headers_exclude_paths(excluded_response_headers_paths)\n\n for route in routes:\n route_type, endpoint, function, is_const, auth_required, openapi_name, openapi_tags = route\n server.add_route(route_type, endpoint, function, is_const)\n\n for middleware_type, middleware_function in global_middlewares:\n server.add_global_middleware(middleware_type, middleware_function)\n\n for middleware_type, endpoint, function, route_type in route_middlewares:\n server.add_middleware_route(middleware_type, endpoint, function, route_type)\n\n if Events.STARTUP in event_handlers:\n server.add_startup_handler(event_handlers[Events.STARTUP])\n\n if Events.SHUTDOWN in event_handlers:\n server.add_shutdown_handler(event_handlers[Events.SHUTDOWN])\n\n for endpoint in web_sockets:\n web_socket = web_sockets[endpoint]\n server.add_web_socket_route(\n endpoint,\n web_socket[\"connect\"],\n web_socket[\"close\"],\n web_socket[\"message\"],\n )\n\n try:\n server.start(socket, workers)\n loop = asyncio.get_event_loop()\n loop.run_forever()\n except KeyboardInterrupt:\n loop.close()\n"
},
{
"path": "robyn/py.typed",
"content": ""
},
{
"path": "robyn/pydantic_support.py",
"content": "\"\"\"\nOptional Pydantic integration for Robyn.\n\nAll pydantic imports are lazy: pydantic is only loaded on the first call\nto _ensure_pydantic(), so there is zero import-time overhead when pydantic\nis not installed or not used. The module itself is imported at the top\nlevel by router.py and openapi.py, but this is safe because it contains\nno pydantic imports at module scope.\n\"\"\"\n\nimport inspect\nfrom typing import Any, Optional, Tuple\n\nimport orjson\n\n__all__ = [\n \"is_pydantic_available\",\n \"is_pydantic_model\",\n \"detect_pydantic_params\",\n \"validate_pydantic_body\",\n \"get_pydantic_openapi_schema\",\n \"serialize_pydantic_response\",\n \"check_pydantic_installed_for_handler\",\n \"PydanticBodyValidationError\",\n \"PydanticNotInstalledError\",\n \"MultiplePydanticBodyError\",\n]\n\n_BaseModel = None\n_ValidationError = None\n_pydantic_checked = False\n\n\ndef _ensure_pydantic():\n \"\"\"Lazy-load pydantic classes. Called at most once.\"\"\"\n global _BaseModel, _ValidationError, _pydantic_checked\n if _pydantic_checked:\n return\n _pydantic_checked = True\n try:\n from pydantic import BaseModel, ValidationError\n\n _BaseModel = BaseModel\n _ValidationError = ValidationError\n except ImportError:\n _BaseModel = None\n _ValidationError = None\n\n\ndef is_pydantic_available() -> bool:\n _ensure_pydantic()\n return _BaseModel is not None\n\n\ndef is_pydantic_model(annotation) -> bool:\n \"\"\"Check if an annotation is a pydantic BaseModel subclass.\n Returns False if pydantic is not installed or annotation is not a class.\"\"\"\n _ensure_pydantic()\n if _BaseModel is None:\n return False\n return inspect.isclass(annotation) and issubclass(annotation, _BaseModel)\n\n\ndef detect_pydantic_params(handler_params) -> dict:\n \"\"\"Scan pre-computed handler parameters for Pydantic BaseModel annotations.\n\n Accepts the ``parameters`` OrderedDict from ``inspect.signature(handler)``.\n Returns a dict mapping param_name -> model_class for params annotated with\n a Pydantic BaseModel subclass. Returns empty dict if pydantic is not\n installed or no params use Pydantic models.\n \"\"\"\n _ensure_pydantic()\n if _BaseModel is None:\n return {}\n\n result = {}\n for name, param in handler_params.items():\n ann = param.annotation\n if ann is inspect.Parameter.empty:\n continue\n if inspect.isclass(ann) and issubclass(ann, _BaseModel):\n result[name] = ann\n return result\n\n\ndef _sanitize_errors(errors: list) -> list:\n \"\"\"Make pydantic error dicts JSON-serializable.\n\n Only copies dicts that actually contain non-serializable values.\n Pydantic v2 error dicts can contain bytes, tuples, and other\n non-JSON-serializable values in 'input', 'loc', and 'ctx' fields.\n \"\"\"\n sanitized = []\n for err in errors:\n needs_copy = False\n for key, val in err.items():\n if (key == \"input\" and isinstance(val, bytes)) or key == \"loc\" or (key == \"ctx\" and isinstance(val, dict)):\n needs_copy = True\n break\n\n if not needs_copy:\n sanitized.append(err)\n continue\n\n clean = dict(err)\n if \"input\" in clean and isinstance(clean[\"input\"], bytes):\n clean[\"input\"] = clean[\"input\"].decode(\"utf-8\", errors=\"replace\")\n if \"loc\" in clean:\n clean[\"loc\"] = list(clean[\"loc\"])\n if \"ctx\" in clean and isinstance(clean[\"ctx\"], dict):\n clean[\"ctx\"] = {k: str(v) for k, v in clean[\"ctx\"].items()}\n sanitized.append(clean)\n return sanitized\n\n\ndef validate_pydantic_body(model_class, body: Any) -> Tuple[Any, Optional[dict]]:\n \"\"\"Validate request body against a Pydantic model.\n\n Uses model_validate_json for maximum performance — single-pass\n parse+validate without an intermediate dict. model_validate_json\n accepts str, bytes, and bytearray natively.\n\n This function is only called from the request hot path *after*\n _ensure_pydantic() has already been called at registration time,\n so we skip the redundant check here.\n\n Returns:\n (validated_model_instance, None) on success\n (None, error_detail_dict) on failure\n \"\"\"\n try:\n return model_class.model_validate_json(body), None\n except _ValidationError as e:\n return None, {\n \"detail\": _sanitize_errors(e.errors()),\n \"error\": \"Validation Error\",\n }\n\n\ndef get_pydantic_openapi_schema(model_class) -> Tuple[dict, dict]:\n \"\"\"Get OpenAPI-compatible JSON Schema from a Pydantic model.\n\n Uses ref_template so nested model references point to\n #/components/schemas/{ModelName} in the OpenAPI spec.\n\n Returns:\n (schema, component_schemas) where:\n - schema: the model's JSON Schema (without $defs)\n - component_schemas: dict of model_name -> schema for components/schemas\n \"\"\"\n _ensure_pydantic()\n if _BaseModel is None or not (inspect.isclass(model_class) and issubclass(model_class, _BaseModel)):\n return {}, {}\n\n full_schema = model_class.model_json_schema(ref_template=\"#/components/schemas/{model}\")\n component_schemas = full_schema.pop(\"$defs\", {})\n return full_schema, component_schemas\n\n\ndef serialize_pydantic_response(res) -> Optional[str]:\n \"\"\"Serialize a Pydantic model (or list of models) to a JSON string.\n\n Returns None when *res* is not a Pydantic type so the caller can fall\n through to other serialisation paths.\n\n This function is only called from the response hot path *after*\n _ensure_pydantic() has already been called at registration time,\n so we skip the redundant check here.\n \"\"\"\n if _BaseModel is None:\n return None\n if isinstance(res, _BaseModel):\n return res.model_dump_json()\n if isinstance(res, list) and res and isinstance(res[0], _BaseModel):\n return orjson.dumps([item.model_dump(mode=\"python\") for item in res]).decode(\"utf-8\")\n return None\n\n\nclass PydanticBodyValidationError(Exception):\n \"\"\"Raised at request time when Pydantic body validation fails.\n Carries the serializable error dict for the 422 response.\"\"\"\n\n def __init__(self, error_detail: dict):\n self.error_detail = error_detail\n super().__init__(error_detail.get(\"error\", \"Validation Error\"))\n\n\nclass PydanticNotInstalledError(ImportError):\n \"\"\"Raised at route registration when a handler uses a Pydantic model\n but pydantic is not installed.\"\"\"\n\n def __init__(self, handler_name: str, param_name: str, model_name: str):\n super().__init__(\n f\"Handler '{handler_name}' has parameter '{param_name}' annotated with \"\n f\"Pydantic model '{model_name}', but pydantic is not installed. \"\n f'Install it with: pip install \"robyn[pydantic]\" or pip install \"robyn[all]\"'\n )\n\n\nclass MultiplePydanticBodyError(TypeError):\n \"\"\"Raised at route registration when a handler declares more than one\n Pydantic body parameter.\"\"\"\n\n def __init__(self, handler_name: str, param_names: list):\n super().__init__(\n f\"Handler '{handler_name}' has multiple Pydantic body parameters \"\n f\"{param_names}. Only one Pydantic body parameter per handler is \"\n f\"supported — the entire request body is parsed into that single model.\"\n )\n\n\ndef check_pydantic_installed_for_handler(handler, pydantic_params: dict):\n \"\"\"Validate Pydantic usage at startup.\n\n Raises PydanticNotInstalledError if pydantic isn't available.\n Raises MultiplePydanticBodyError if more than one body param is declared.\n \"\"\"\n if not pydantic_params:\n return\n if not is_pydantic_available():\n first_param = next(iter(pydantic_params))\n model = pydantic_params[first_param]\n raise PydanticNotInstalledError(handler.__name__, first_param, model.__name__)\n if len(pydantic_params) > 1:\n raise MultiplePydanticBodyError(handler.__name__, list(pydantic_params.keys()))\n"
},
{
"path": "robyn/reloader.py",
"content": "import glob\nimport os\nimport signal\nimport subprocess\nimport sys\nimport time\nfrom typing import List, Union\n\nfrom watchdog.events import FileSystemEventHandler\nfrom watchdog.observers import Observer\n\nfrom robyn.logger import Colors, logger\n\n\ndef compile_rust_files(directory_path: str) -> List[str]:\n rust_files = glob.glob(os.path.join(directory_path, \"**/*.rs\"), recursive=True)\n rust_binaries: list[str] = []\n\n for rust_file in rust_files:\n print(f\"Compiling rust file: {rust_file}\")\n\n result = subprocess.run(\n [sys.executable, \"-m\", \"rustimport\", \"build\", rust_file],\n stdout=subprocess.PIPE,\n stderr=subprocess.PIPE,\n start_new_session=False,\n )\n if result.returncode != 0:\n print(f\"Error compiling rust file: {rust_file} \\n {result.stderr.decode('utf-8')} \\n {result.stdout.decode('utf-8')}\")\n else:\n print(f\"Compiled rust file: {rust_file}\")\n rust_file_base = rust_file.removesuffix(\".rs\")\n\n # Define the search pattern for the binary file\n if sys.platform == \"win32\":\n binary_extension = \".dll\"\n elif sys.platform == \"darwin\":\n binary_extension = \".so\"\n elif sys.platform == \"linux\":\n binary_extension = \".so\"\n else:\n raise ValueError(f\"Unsupported platform: {sys.platform}\")\n\n search_pattern = f\"{rust_file_base}.*{binary_extension}\"\n # Use glob to find matching binary files\n matching_binaries = glob.glob(search_pattern)\n rust_binaries.extend(matching_binaries)\n\n return rust_binaries\n\n\ndef create_rust_file(file_name: str) -> None:\n if file_name.endswith(\".rs\"):\n file_name = file_name.removesuffix(\".rs\")\n\n rust_file = f\"{file_name}.rs\"\n\n result = subprocess.run(\n [sys.executable, \"-m\", \"rustimport\", \"new\", rust_file],\n stdout=subprocess.PIPE,\n stderr=subprocess.PIPE,\n start_new_session=False,\n )\n\n if result.returncode != 0:\n print(\n \"Error creating rust file : %s %s\",\n result.stderr.decode(\"utf-8\"),\n result.stdout.decode(\"utf-8\"),\n )\n else:\n print(\"Created rust file : %s\", rust_file)\n\n\ndef clean_rust_binaries(rust_binaries: List[str]) -> None:\n for file in rust_binaries:\n print(\"Cleaning rust file : %s\", file)\n os.remove(file)\n\n\ndef setup_reloader(directory_path: str, file_path: str) -> None:\n event_handler = EventHandler(file_path, directory_path)\n\n # sets the IS_RELOADER_RUNNING environment variable to True\n event_handler.reload()\n\n logger.info(\n \"Dev server initialized with the directory_path : %s\",\n directory_path,\n color=Colors.BLUE,\n )\n\n def terminating_signal_handler(_sig, _frame):\n event_handler.stop_server()\n logger.info(\"Terminating reloader\", bold=True)\n observer.stop()\n observer.join()\n\n signal.signal(signal.SIGINT, terminating_signal_handler)\n signal.signal(signal.SIGTERM, terminating_signal_handler)\n\n observer = Observer()\n observer.schedule(event_handler, path=directory_path, recursive=True)\n observer.start()\n\n try:\n while observer.is_alive():\n observer.join(1)\n finally:\n observer.stop()\n observer.join()\n event_handler.process.wait()\n\n\nclass EventHandler(FileSystemEventHandler):\n def __init__(self, file_path: str, directory_path: str) -> None:\n self.file_path = file_path\n self.directory_path = directory_path\n self.process: Union[subprocess.Popen[bytes], None] = None # Keep track of the subprocess\n self.built_rust_binaries: List = [] # Keep track of the built rust binaries\n\n self.last_reload = time.time() # Keep track of the last reload. EventHandler is initialized with the process.\n\n def stop_server(self) -> None:\n if self.process:\n os.kill(self.process.pid, signal.SIGTERM) # Stop the subprocess using os.kill()\n\n def reload(self) -> None:\n self.stop_server()\n print(\"Reloading the server\")\n\n new_env = os.environ.copy()\n new_env[\"IS_RELOADER_RUNNING\"] = \"True\" # This is used to check if a reloader is already running\n # IS_RELOADER_RUNNING is specifically used for IPC between the reloader and the server\n\n arguments = [arg for arg in sys.argv[1:] if not arg.startswith(\"--dev\")]\n\n clean_rust_binaries(self.built_rust_binaries)\n self.built_rust_binaries = compile_rust_files(self.directory_path)\n\n prev_process = self.process\n if prev_process:\n prev_process.kill()\n\n self.process = subprocess.Popen(\n [sys.executable, *arguments],\n env=new_env,\n )\n\n self.last_reload = time.time()\n\n def on_modified(self, event) -> None:\n \"\"\"\n This function is a callback that will start a new server on every even change\n\n :param event FSEvent: a data structure with info about the events\n \"\"\"\n\n # Avoid reloading multiple times when watchdog detects multiple events\n if time.time() - self.last_reload < 0.5:\n return\n\n time.sleep(0.2) # Wait for the file to be fully written\n self.reload()\n"
},
{
"path": "robyn/responses.py",
"content": "import asyncio\nimport mimetypes\nimport os\nfrom typing import AsyncGenerator, Generator, Optional, Union\n\nfrom robyn.robyn import Headers, Response\n\n\nclass FileResponse:\n def __init__(\n self,\n file_path: str,\n status_code: Optional[int] = None,\n headers: Optional[Headers] = None,\n ):\n self.file_path = file_path\n self.description = \"\"\n self.status_code = status_code or 200\n self.headers = headers or Headers({\"Content-Disposition\": \"attachment\"})\n\n\ndef html(html: str) -> Response:\n \"\"\"\n This function will help in serving a simple html string\n\n :param html str: html to serve as a response\n \"\"\"\n return Response(\n description=html,\n status_code=200,\n headers=Headers({\"Content-Type\": \"text/html\"}),\n )\n\n\ndef serve_html(file_path: str) -> FileResponse:\n \"\"\"\n This function will help in serving a single html file\n\n :param file_path str: file path to serve as a response\n \"\"\"\n\n return FileResponse(file_path, headers=Headers({\"Content-Type\": \"text/html\"}))\n\n\ndef serve_file(file_path: str, file_name: Optional[str] = None) -> FileResponse:\n \"\"\"\n This function will help in serving a file\n\n :param file_path str: file path to serve as a response\n :param file_name [str | None]: file name to serve as a response, defaults to None\n \"\"\"\n file_name = file_name or os.path.basename(file_path)\n\n mime_type = mimetypes.guess_type(file_name)[0]\n\n headers = Headers({\"Content-Type\": mime_type})\n headers.append(\"Content-Disposition\", f\"attachment; filename={file_name}\")\n\n return FileResponse(\n file_path,\n headers=headers,\n )\n\n\nclass AsyncGeneratorWrapper:\n \"\"\"Optimized true-streaming wrapper for async generators\"\"\"\n\n def __init__(self, async_gen: AsyncGenerator[str, None]):\n self.async_gen = async_gen\n self._loop = None\n self._iterator = None\n self._exhausted = False\n\n def __iter__(self):\n return self\n\n def __next__(self):\n if self._exhausted:\n raise StopIteration\n\n # Initialize the loop and iterator only once\n if self._iterator is None:\n self._init_async_iterator()\n\n try:\n # Get the next value from the async generator\n # This is the key optimization - we don't buffer, we get one value at a time\n return self._get_next_value()\n except StopIteration:\n self._exhausted = True\n raise\n\n def _init_async_iterator(self):\n \"\"\"Initialize the async iterator with proper loop handling\"\"\"\n try:\n # Try to get the running event loop\n self._loop = asyncio.get_running_loop()\n except RuntimeError:\n # No running loop, create a new one\n self._loop = asyncio.new_event_loop()\n asyncio.set_event_loop(self._loop)\n\n # Create the async iterator\n self._iterator = self.async_gen.__aiter__()\n\n def _get_next_value(self):\n \"\"\"Get the next value from async generator without buffering\"\"\"\n try:\n # Create a coroutine to get the next value\n async def get_next():\n return await self._iterator.__anext__()\n\n # Run the coroutine to get the next value\n return self._loop.run_until_complete(get_next())\n except StopAsyncIteration:\n # Convert StopAsyncIteration to StopIteration for sync generator protocol\n raise StopIteration\n except Exception as e:\n # Log error and stop iteration\n print(f\"Error in async generator: {e}\")\n raise StopIteration\n\n\nclass StreamingResponse:\n def __init__(\n self,\n content: Union[Generator[str, None, None], AsyncGenerator[str, None]],\n status_code: Optional[int] = None,\n headers: Optional[Headers] = None,\n media_type: str = \"text/event-stream\",\n ):\n # Convert async generator to sync generator if needed\n # The Rust implementation detects async generators but falls back to Python wrapper\n if hasattr(content, \"__anext__\"):\n # This is an async generator - wrap it with optimized wrapper\n self.content = AsyncGeneratorWrapper(content)\n else:\n # This is a sync generator - use as is\n self.content = content\n\n self.status_code = status_code or 200\n self.headers = headers or Headers({})\n self.media_type = media_type\n\n # Set default SSE headers\n if media_type == \"text/event-stream\":\n self.headers.set(\"Content-Type\", \"text/event-stream\")\n # Cache-Control and Connection headers are set by Rust layer with optimized headers\n\n\ndef SSEResponse(\n content: Union[Generator[str, None, None], AsyncGenerator[str, None]],\n status_code: Optional[int] = None,\n headers: Optional[Headers] = None,\n) -> StreamingResponse:\n \"\"\"\n Create a Server-Sent Events (SSE) streaming response.\n\n :param content: Generator or AsyncGenerator yielding SSE-formatted strings\n :param status_code: HTTP status code (default: 200)\n :param headers: Additional headers\n :return: StreamingResponse configured for SSE\n \"\"\"\n return StreamingResponse(content=content, status_code=status_code, headers=headers, media_type=\"text/event-stream\")\n\n\ndef SSEMessage(data: str, event: Optional[str] = None, id: Optional[str] = None, retry: Optional[int] = None) -> str:\n \"\"\"\n Optimized SSE message formatting with minimal allocations.\n\n :param data: The message data\n :param event: Optional event type\n :param id: Optional event ID\n :param retry: Optional retry time in milliseconds\n :return: SSE-formatted string\n \"\"\"\n # Pre-calculate size to avoid multiple string concatenations\n parts = []\n\n # Add optional fields first\n if event:\n parts.append(f\"event: {event}\\n\")\n if id:\n parts.append(f\"id: {id}\\n\")\n if retry:\n parts.append(f\"retry: {retry}\\n\")\n\n # Handle data with optimized multi-line processing\n if data:\n data_str = str(data)\n # Fast path for single-line data (most common case)\n if \"\\n\" not in data_str and \"\\r\" not in data_str:\n parts.append(f\"data: {data_str}\\n\")\n else:\n # Multi-line data handling\n normalized_data = data_str.replace(\"\\r\\n\", \"\\n\").replace(\"\\r\", \"\\n\")\n for line in normalized_data.split(\"\\n\"):\n parts.append(f\"data: {line}\\n\")\n else:\n parts.append(\"data: \\n\")\n\n # Add the required double newline terminator\n parts.append(\"\\n\")\n\n # Single join operation for optimal performance\n return \"\".join(parts)\n"
},
{
"path": "robyn/robyn.pyi",
"content": "from __future__ import annotations\n\nfrom dataclasses import dataclass\nfrom enum import Enum\nfrom typing import Callable, Optional, Union\n\ndef get_version() -> str:\n pass\n\nclass SocketHeld:\n def __init__(self, url: str, port: int):\n pass\n def try_clone(self) -> SocketHeld:\n pass\n\nclass MiddlewareType(Enum):\n \"\"\"\n The middleware types supported by Robyn.\n\n Attributes:\n BEFORE_REQUEST: str\n AFTER_REQUEST: str\n \"\"\"\n\n BEFORE_REQUEST: str\n AFTER_REQUEST: str\n\nclass HttpMethod(Enum):\n \"\"\"\n The HTTP methods supported by Robyn.\n\n Attributes:\n GET: str\n POST: str\n PUT: str\n DELETE: str\n PATCH: str\n OPTIONS: str\n HEAD: str\n TRACE: str\n CONNECT: str\n \"\"\"\n\n GET: str\n POST: str\n PUT: str\n DELETE: str\n PATCH: str\n OPTIONS: str\n HEAD: str\n TRACE: str\n CONNECT: str\n\n@dataclass\nclass FunctionInfo:\n \"\"\"\n The function info object passed to the route handler.\n\n Attributes:\n handler (Callable): The function to be called\n is_async (bool): Whether the function is async or not\n number_of_params (int): The number of parameters the function has\n args (dict): The arguments of the function\n kwargs (dict): The keyword arguments of the function\n \"\"\"\n\n handler: Callable\n is_async: bool\n number_of_params: int\n args: dict\n kwargs: dict\n\n@dataclass\nclass Url:\n \"\"\"\n The url object passed to the route handler.\n\n Attributes:\n scheme (str): The scheme of the url. e.g. http, https\n host (str): The host of the url. e.g. localhost,\n path (str): The path of the url. e.g. /user\n \"\"\"\n\n scheme: str\n host: str\n path: str\n\n@dataclass\nclass Identity:\n claims: dict[str, str]\n\nclass QueryParams:\n \"\"\"\n The query params object passed to the route handler.\n\n Attributes:\n queries (dict[str, list[str]]): The query parameters of the request. e.g. /user?id=123 -> {\"id\": \"123\"}\n \"\"\"\n\n def set(self, key: str, value: str) -> None:\n \"\"\"\n Sets the value of the query parameter with the given key.\n If the key already exists, the value will be appended to the list of values.\n\n Args:\n key (str): The key of the query parameter\n value (str): The value of the query parameter\n \"\"\"\n pass\n\n def get(self, key: str, default: Optional[str] = None) -> Optional[str]:\n \"\"\"\n Gets the last value of the query parameter with the given key.\n\n Args:\n key (str): The key of the query parameter\n default (Optional[str]): The default value if the key does not exist\n \"\"\"\n pass\n\n def empty(self) -> bool:\n \"\"\"\n Returns:\n True if the query params are empty, False otherwise\n \"\"\"\n pass\n\n def contains(self, key: str) -> bool:\n \"\"\"\n Returns:\n True if the query params contain the key, False otherwise\n\n Args:\n key (str): The key of the query parameter\n \"\"\"\n pass\n\n def get_first(self, key: str) -> Optional[str]:\n \"\"\"\n Gets the first value of the query parameter with the given key.\n\n Args:\n key (str): The key of the query parameter\n\n \"\"\"\n pass\n\n def get_all(self, key: str) -> Optional[list[str]]:\n \"\"\"\n Gets all the values of the query parameter with the given key.\n\n Args:\n key (str): The key of the query parameter\n \"\"\"\n pass\n\n def extend(self, other: QueryParams) -> None:\n \"\"\"\n Extends the query params with the other query params.\n\n Args:\n other (QueryParams): The other QueryParams object\n \"\"\"\n pass\n\n def to_dict(self) -> dict[str, list[str]]:\n \"\"\"\n Returns:\n The query params as a dictionary\n \"\"\"\n pass\n\n def __contains__(self, key: str) -> bool:\n pass\n\n def __repr__(self) -> str:\n pass\n\n@dataclass\nclass Cookie:\n \"\"\"\n A cookie with optional attributes following RFC 6265.\n\n Attributes:\n value (str): The cookie value\n path (Optional[str]): Cookie path (e.g. \"/\")\n domain (Optional[str]): Cookie domain\n max_age (Optional[int]): Max age in seconds\n expires (Optional[str]): Expiry date (deprecated, use max_age instead)\n secure (bool): Only send over HTTPS\n http_only (bool): Not accessible via JavaScript\n same_site (Optional[str]): \"Strict\", \"Lax\", or \"None\" (case-insensitive)\n \"\"\"\n\n value: str\n path: Optional[str] = None\n domain: Optional[str] = None\n max_age: Optional[int] = None\n expires: Optional[str] = None\n secure: bool = False\n http_only: bool = False\n same_site: Optional[str] = None\n\n @staticmethod\n def deleted() -> \"Cookie\":\n \"\"\"\n Create a cookie configured for deletion (expires immediately with max_age=0).\n\n Returns:\n Cookie: A cookie that will be deleted by the browser\n \"\"\"\n pass\n\nclass Cookies:\n \"\"\"A collection of cookies keyed by name.\"\"\"\n\n def __init__(self) -> None:\n pass\n\n def set(self, name: str, cookie: Cookie) -> None:\n \"\"\"\n Sets a cookie with the given name.\n\n Args:\n name (str): The name of the cookie\n cookie (Cookie): The cookie object\n \"\"\"\n pass\n\n def get(self, name: str) -> Optional[Cookie]:\n \"\"\"\n Gets the cookie with the given name.\n\n Args:\n name (str): The name of the cookie\n \"\"\"\n pass\n\n def remove(self, name: str) -> None:\n \"\"\"\n Removes the cookie from the collection (does not delete it from the browser).\n\n Args:\n name (str): The name of the cookie\n \"\"\"\n pass\n\n def delete(self, name: str) -> None:\n \"\"\"\n Mark a cookie for deletion by setting it to expire immediately.\n This sets max_age=0 which tells the browser to delete the cookie.\n\n Args:\n name (str): The name of the cookie to delete\n \"\"\"\n pass\n\n def is_empty(self) -> bool:\n \"\"\"\n Returns:\n True if there are no cookies, False otherwise\n \"\"\"\n pass\n\n def keys(self) -> list[str]:\n \"\"\"\n Returns:\n A list of all cookie names\n \"\"\"\n pass\n\n def __setitem__(self, name: str, cookie: Cookie) -> None:\n pass\n\n def __getitem__(self, name: str) -> Optional[Cookie]:\n pass\n\n def __contains__(self, name: str) -> bool:\n pass\n\n def __len__(self) -> int:\n pass\n\n def __iter__(self) -> \"CookiesIter\":\n pass\n\n def __repr__(self) -> str:\n pass\n\nclass CookiesIter:\n \"\"\"Iterator for Cookies collection.\"\"\"\n\n def __iter__(self) -> \"CookiesIter\":\n pass\n\n def __next__(self) -> str:\n pass\n\nclass Headers:\n def __init__(self, default_headers: Optional[dict]) -> None:\n pass\n\n def __getitem__(self, key: str) -> Optional[str]:\n pass\n\n def __setitem__(self, key: str, value: str) -> None:\n pass\n\n def set(self, key: str, value: str) -> None:\n \"\"\"\n Sets the value of the header with the given key.\n If the key already exists, the value will be appended to the list of values.\n\n Args:\n key (str): The key of the header\n value (str): The value of the header\n \"\"\"\n pass\n\n def get(self, key: str) -> Optional[str]:\n \"\"\"\n Gets the last value of the header with the given key.\n\n Args:\n key (str): The key of the header\n \"\"\"\n pass\n\n def populate_from_dict(self, headers: dict[str, str]) -> None:\n \"\"\"\n Populates the headers from a dictionary.\n\n Args:\n headers (dict[str, str]): The dictionary of headers\n \"\"\"\n pass\n\n def contains(self, key: str) -> bool:\n \"\"\"\n Returns:\n True if the headers contain the key, False otherwise\n\n Args:\n key (str): The key of the header\n \"\"\"\n pass\n\n def append(self, key: str, value: str) -> None:\n \"\"\"\n Appends the value to the header with the given key.\n\n Args:\n key (str): The key of the header\n value (str): The value of the header\n \"\"\"\n pass\n\n def is_empty(self) -> bool:\n \"\"\"\n Returns:\n True if the headers are empty, False otherwise\n \"\"\"\n pass\n\n@dataclass\nclass Request:\n \"\"\"\n The request object passed to the route handler.\n\n Attributes:\n query_params (QueryParams): The query parameters of the request. e.g. /user?id=123 -> {\"id\": \"123\"}\n headers Headers: The headers of the request. e.g. Headers({\"Content-Type\": \"application/json\"})\n path_params (dict[str, str]): The parameters of the request. e.g. /user/:id -> {\"id\": \"123\"}\n body (Union[str, bytes]): The body of the request. If the request is a JSON, it will be a dict.\n method (str): The method of the request. e.g. GET, POST, PUT etc.\n url (Url): The url of the request. e.g. https://localhost/user\n form_data (dict[str, str]): The form data of the request. e.g. {\"name\": \"John\"}\n files (dict[str, bytes]): The files of the request. e.g. {\"file\": b\"file\"}\n ip_addr (Optional[str]): The IP Address of the client\n identity (Optional[Identity]): The identity of the client\n \"\"\"\n\n query_params: QueryParams\n headers: Headers\n path_params: dict[str, str]\n body: Union[str, bytes]\n method: str\n url: Url\n form_data: dict[str, str]\n files: dict[str, bytes]\n ip_addr: Optional[str]\n identity: Optional[Identity]\n\n def json(self) -> Union[dict, list]:\n \"\"\"\n Parse the request body as JSON and return a Python dict or list with preserved types.\n\n JSON types are mapped to Python types as follows:\n - null -> None\n - bool -> bool\n - number -> int or float\n - string -> str\n - array -> list\n - object -> dict\n\n Nested structures are handled recursively up to a maximum depth of 128.\n\n Raises:\n ValueError: If the body is not valid JSON.\n \"\"\"\n pass\n\n@dataclass\nclass Response:\n \"\"\"\n The response object passed to the route handler.\n\n Attributes:\n status_code (int): The status code of the response. e.g. 200, 404, 500 etc.\n response_type (Optional[str]): The response type of the response. e.g. text, json, html, file etc.\n headers (Union[Headers, dict]): The headers of the response or Headers directly. e.g. {\"Content-Type\": \"application/json\"}\n description (Union[str, bytes]): The body of the response. If the response is a JSON, it will be a dict.\n file_path (Optional[str]): The file path of the response. e.g. /home/user/file.txt\n cookies (Cookies): The cookies to set in the response.\n \"\"\"\n\n status_code: int\n headers: Union[Headers, dict]\n description: Union[str, bytes]\n response_type: Optional[str] = None\n file_path: Optional[str] = None\n cookies: Cookies = None # Initialized automatically\n\n def set_cookie(\n self,\n key: str,\n value: str,\n path: Optional[str] = None,\n domain: Optional[str] = None,\n max_age: Optional[int] = None,\n expires: Optional[str] = None,\n secure: bool = False,\n http_only: bool = False,\n same_site: Optional[str] = None,\n ) -> None:\n \"\"\"\n Sets a cookie in the response. If a cookie with the same key exists,\n it will be overwritten.\n\n Args:\n key (str): The name of the cookie\n value (str): The value of the cookie\n path (Optional[str]): Cookie path (e.g. \"/\")\n domain (Optional[str]): Cookie domain\n max_age (Optional[int]): Max age in seconds\n expires (Optional[str]): Expiry date (RFC 7231 format)\n secure (bool): Only send over HTTPS\n http_only (bool): Not accessible via JavaScript\n same_site (Optional[str]): \"Strict\", \"Lax\", or \"None\"\n \"\"\"\n pass\n\nclass Server:\n \"\"\"\n The Server object used to create a Robyn server.\n\n This object is used to create a Robyn server and add routes, middlewares, etc.\n \"\"\"\n def __init__(self) -> None:\n pass\n def add_directory(\n self,\n route: str,\n directory_path: str,\n show_files_listing: bool,\n index_file: Optional[str],\n ) -> None:\n pass\n def apply_request_headers(self, headers: Headers) -> None:\n pass\n def apply_response_headers(self, headers: Headers) -> None:\n pass\n def set_response_headers_exclude_paths(self, excluded_response_headers_paths: Optional[list[str]] = None):\n pass\n\n def add_route(\n self,\n route_type: HttpMethod,\n route: str,\n function: FunctionInfo,\n is_const: bool,\n ) -> None:\n pass\n def add_global_middleware(self, middleware_type: MiddlewareType, function: FunctionInfo) -> None:\n pass\n def add_middleware_route(\n self,\n middleware_type: MiddlewareType,\n route: str,\n function: FunctionInfo,\n route_type: HttpMethod,\n ) -> None:\n pass\n def add_startup_handler(self, function: FunctionInfo) -> None:\n pass\n def add_shutdown_handler(self, function: FunctionInfo) -> None:\n pass\n def add_web_socket_route(\n self,\n route: str,\n connect_route: FunctionInfo,\n close_route: FunctionInfo,\n message_route: FunctionInfo,\n use_channel: bool,\n ) -> None:\n pass\n def start(self, socket: SocketHeld, workers: int, client_timeout: int, keep_alive_timeout: int) -> None:\n pass\n\nclass WebSocketConnector:\n \"\"\"\n The WebSocketConnector object passed to the route handler.\n\n Attributes:\n id (str): The id of the client\n query_params (QueryParams): The query parameters object\n\n async_broadcast (Callable): The function to broadcast a message to all clients\n async_send_to (Callable): The function to send a message to the client\n sync_broadcast (Callable): The function to broadcast a message to all clients\n sync_send_to (Callable): The function to send a message to the client\n \"\"\"\n\n id: str\n query_params: QueryParams\n\n async def async_broadcast(self, message: str) -> None:\n \"\"\"\n Broadcasts a message to all clients.\n\n Args:\n message (str): The message to broadcast\n \"\"\"\n pass\n async def async_send_to(self, sender_id: str, message: str) -> None:\n \"\"\"\n Sends a message to a specific client.\n\n Args:\n sender_id (str): The id of the sender\n message (str): The message to send\n \"\"\"\n pass\n def sync_broadcast(self, message: str) -> None:\n \"\"\"\n Broadcasts a message to all clients.\n\n Args:\n message (str): The message to broadcast\n \"\"\"\n pass\n def sync_send_to(self, sender_id: str, message: str) -> None:\n \"\"\"\n Sends a message to a specific client.\n\n Args:\n sender_id (str): The id of the sender\n message (str): The message to send\n \"\"\"\n pass\n def close(self) -> None:\n \"\"\"\n Closes the connection.\n \"\"\"\n pass\n"
},
{
"path": "robyn/router.py",
"content": "import inspect\nimport logging\nfrom abc import ABC, abstractmethod\nfrom functools import wraps\nfrom types import CoroutineType\nfrom typing import Callable, Dict, List, NamedTuple, Optional, Union, is_typeddict\n\nfrom robyn import status_codes\nfrom robyn._param_utils import QueryParamValidationError, parse_route_param_names, resolve_individual_params\nfrom robyn.authentication import AuthenticationHandler, AuthenticationNotConfiguredError\nfrom robyn.dependency_injection import DependencyMap\nfrom robyn.jsonify import jsonify\nfrom robyn.openapi import OpenAPI\nfrom robyn.pydantic_support import (\n PydanticBodyValidationError,\n check_pydantic_installed_for_handler,\n detect_pydantic_params,\n serialize_pydantic_response,\n validate_pydantic_body,\n)\nfrom robyn.responses import FileResponse, StreamingResponse\nfrom robyn.robyn import FunctionInfo, Headers, HttpMethod, Identity, MiddlewareType, QueryParams, Request, Response, Url\nfrom robyn.types import Body, Files, FormData, IPAddress, JsonBody, Method, PathParams\n\n_logger = logging.getLogger(__name__)\n\n\ndef lower_http_method(method: HttpMethod):\n return (str(method))[11:].lower()\n\n\nclass Route(NamedTuple):\n route_type: HttpMethod\n route: str\n function: FunctionInfo\n is_const: bool\n auth_required: bool\n openapi_name: str\n openapi_tags: List[str]\n\n\nclass RouteMiddleware(NamedTuple):\n middleware_type: MiddlewareType\n route: str\n function: FunctionInfo\n route_type: HttpMethod\n\n\nclass GlobalMiddleware(NamedTuple):\n middleware_type: MiddlewareType\n function: FunctionInfo\n\n\nclass BaseRouter(ABC):\n @abstractmethod\n def add_route(*args) -> Union[Callable, CoroutineType, Dict]: ...\n\n\nclass Router(BaseRouter):\n def __init__(self) -> None:\n super().__init__()\n self.routes: List[Route] = []\n\n def _format_tuple_response(self, res: tuple) -> Response:\n if len(res) != 3:\n raise ValueError(\"Tuple should have 3 elements\")\n\n description, headers, status_code = res\n description = self._format_response(description).description\n new_headers: Headers = Headers(headers)\n if new_headers.contains(\"Content-Type\"):\n headers.set(\"Content-Type\", new_headers.get(\"Content-Type\"))\n\n return Response(\n status_code=status_code,\n headers=headers,\n description=description,\n )\n\n def _format_response(\n self,\n res: Union[Dict, List, Response, StreamingResponse, bytes, tuple, str],\n ) -> Union[Response, StreamingResponse]:\n if isinstance(res, Response):\n return res\n\n if isinstance(res, StreamingResponse):\n return res\n\n pydantic_json = serialize_pydantic_response(res)\n if pydantic_json is not None:\n return Response(\n status_code=status_codes.HTTP_200_OK,\n headers=Headers({\"Content-Type\": \"application/json\"}),\n description=pydantic_json,\n )\n\n if isinstance(res, (dict, list)):\n return Response(\n status_code=status_codes.HTTP_200_OK,\n headers=Headers({\"Content-Type\": \"application/json\"}),\n description=jsonify(res),\n )\n\n if isinstance(res, FileResponse):\n response: Response = Response(\n status_code=res.status_code,\n headers=res.headers,\n description=res.file_path,\n )\n response.file_path = res.file_path\n return response\n\n if isinstance(res, bytes):\n return Response(\n status_code=status_codes.HTTP_200_OK,\n headers=Headers({\"Content-Type\": \"application/octet-stream\"}),\n description=res,\n )\n\n if isinstance(res, tuple):\n return self._format_tuple_response(tuple(res))\n\n return Response(\n status_code=status_codes.HTTP_200_OK,\n headers=Headers({\"Content-Type\": \"text/plain\"}),\n description=str(res).encode(\"utf-8\"),\n )\n\n def add_route( # type: ignore\n self,\n route_type: HttpMethod,\n endpoint: str,\n handler: Callable,\n is_const: bool,\n auth_required: bool,\n openapi_name: str,\n openapi_tags: List[str],\n exception_handler: Optional[Callable],\n injected_dependencies: dict,\n ) -> Union[Callable, CoroutineType]:\n # Pre-compute handler signature ONCE at registration time.\n # This avoids calling inspect.signature() on every request.\n route_param_names = parse_route_param_names(endpoint)\n handler_params = inspect.signature(handler).parameters\n handler_param_names = set(handler_params.keys())\n\n unused_route_params = route_param_names - handler_param_names\n if unused_route_params:\n _logger.warning(\n \"Route '%s' declares path params %s but handler '%s' doesn't use them\",\n endpoint,\n unused_route_params,\n handler.__name__,\n )\n\n # Detect Pydantic model params once at registration (zero cost if not used)\n pydantic_params = detect_pydantic_params(handler_params)\n check_pydantic_installed_for_handler(handler, pydantic_params)\n\n if pydantic_params and route_type in (HttpMethod.GET, HttpMethod.HEAD):\n _logger.warning(\n \"Handler '%s' on %s '%s' uses Pydantic body parameter(s) %s, but %s requests typically do not carry a request body\",\n handler.__name__,\n route_type.name,\n endpoint,\n list(pydantic_params.keys()),\n route_type.name,\n )\n\n def wrapped_handler(*args, **kwargs):\n request = next(filter(lambda it: isinstance(it, Request), args), None)\n\n if not request or (len(handler_params) == 1 and next(iter(handler_params)) is Request):\n return handler(*args, **kwargs)\n\n type_mapping = {\n \"request\": Request,\n \"query_params\": QueryParams,\n \"headers\": Headers,\n \"path_params\": PathParams,\n \"body\": Body,\n \"method\": Method,\n \"url\": Url,\n \"form_data\": FormData,\n \"files\": Files,\n \"ip_addr\": IPAddress,\n \"identity\": Identity,\n }\n\n # Phase 1: Type-annotated request components\n type_filtered_params = {}\n\n for handler_param in iter(handler_params):\n for type_name in type_mapping:\n handler_param_type = handler_params[handler_param].annotation\n handler_param_name = handler_params[handler_param].name\n if handler_param_type is Request:\n type_filtered_params[handler_param_name] = request\n elif handler_param_type is type_mapping[type_name]:\n type_filtered_params[handler_param_name] = getattr(request, type_name)\n elif inspect.isclass(handler_param_type):\n if issubclass(handler_param_type, JsonBody):\n try:\n type_filtered_params[handler_param_name] = request.json()\n except ValueError as e:\n return Response(\n status_code=status_codes.HTTP_400_BAD_REQUEST,\n headers=Headers({\"Content-Type\": \"application/json\"}),\n description=jsonify({\"error\": f\"Invalid JSON body: {e}\"}),\n )\n elif issubclass(handler_param_type, Body):\n type_filtered_params[handler_param_name] = getattr(request, \"body\")\n elif issubclass(handler_param_type, QueryParams):\n type_filtered_params[handler_param_name] = getattr(request, \"query_params\")\n elif is_typeddict(handler_param_type):\n try:\n type_filtered_params[handler_param_name] = request.json()\n except ValueError as e:\n return Response(\n status_code=status_codes.HTTP_400_BAD_REQUEST,\n headers=Headers({\"Content-Type\": \"application/json\"}),\n description=jsonify({\"error\": f\"Invalid JSON body: {e}\"}),\n )\n\n # Phase 1.5: Pydantic model body params (only runs if handler uses pydantic)\n if pydantic_params:\n for param_name, model_class in pydantic_params.items():\n if param_name in type_filtered_params:\n continue\n validated, error = validate_pydantic_body(model_class, request.body)\n if error is not None:\n raise PydanticBodyValidationError(error)\n type_filtered_params[param_name] = validated\n\n # Phase 2: Reserved-name request components\n request_components = {\n \"r\": request,\n \"req\": request,\n \"request\": request,\n \"query_params\": request.query_params,\n \"headers\": request.headers,\n \"path_params\": request.path_params,\n \"body\": request.body,\n \"method\": request.method,\n \"url\": request.url,\n \"ip_addr\": request.ip_addr,\n \"identity\": request.identity,\n \"form_data\": request.form_data,\n \"files\": request.files,\n \"router_dependencies\": injected_dependencies[\"router_dependencies\"],\n \"global_dependencies\": injected_dependencies[\"global_dependencies\"],\n **kwargs,\n }\n\n name_filtered_params = {k: v for k, v in request_components.items() if k in handler_params and k not in type_filtered_params}\n\n filtered_params = dict(**type_filtered_params, **name_filtered_params)\n\n # Phase 3: Individual path/query param resolution\n unresolved_names = set(handler_params) - set(filtered_params)\n if unresolved_names:\n unresolved = {name: handler_params[name] for name in unresolved_names}\n individual_params = resolve_individual_params(\n unresolved,\n request.query_params,\n request.path_params,\n route_param_names,\n )\n filtered_params.update(individual_params)\n\n return handler(**filtered_params)\n\n @wraps(handler)\n async def async_inner_handler(*args, **kwargs):\n try:\n response = self._format_response(\n await wrapped_handler(*args, **kwargs),\n )\n except QueryParamValidationError as err:\n response = Response(\n status_code=status_codes.HTTP_400_BAD_REQUEST,\n headers=Headers({\"Content-Type\": \"text/plain\"}),\n description=str(err),\n )\n except PydanticBodyValidationError as err:\n response = Response(\n status_code=status_codes.HTTP_422_UNPROCESSABLE_ENTITY,\n headers=Headers({\"Content-Type\": \"application/json\"}),\n description=jsonify(err.error_detail),\n )\n except Exception as err:\n if exception_handler is None:\n raise\n response = self._format_response(\n exception_handler(err),\n )\n return response\n\n @wraps(handler)\n def inner_handler(*args, **kwargs):\n try:\n response = self._format_response(\n wrapped_handler(*args, **kwargs),\n )\n except QueryParamValidationError as err:\n response = Response(\n status_code=status_codes.HTTP_400_BAD_REQUEST,\n headers=Headers({\"Content-Type\": \"text/plain\"}),\n description=str(err),\n )\n except PydanticBodyValidationError as err:\n response = Response(\n status_code=status_codes.HTTP_422_UNPROCESSABLE_ENTITY,\n headers=Headers({\"Content-Type\": \"application/json\"}),\n description=jsonify(err.error_detail),\n )\n except Exception as err:\n if exception_handler is None:\n raise\n response = self._format_response(\n exception_handler(err),\n )\n return response\n\n params = dict(handler_params)\n\n new_injected_dependencies = {}\n for dependency in injected_dependencies:\n if dependency in params:\n new_injected_dependencies[dependency] = injected_dependencies[dependency]\n else:\n _logger.debug(f\"Dependency {dependency} is not used in the handler {handler.__name__}\")\n\n if inspect.iscoroutinefunction(handler):\n function = FunctionInfo(\n async_inner_handler,\n True,\n len(params),\n params,\n new_injected_dependencies,\n )\n self.routes.append(Route(route_type, endpoint, function, is_const, auth_required, openapi_name, openapi_tags))\n return async_inner_handler\n else:\n function = FunctionInfo(\n inner_handler,\n False,\n len(params),\n params,\n new_injected_dependencies,\n )\n self.routes.append(Route(route_type, endpoint, function, is_const, auth_required, openapi_name, openapi_tags))\n return inner_handler\n\n def prepare_routes_openapi(self, openapi: OpenAPI, included_routers: List) -> None:\n for route in self.routes:\n openapi.add_openapi_path_obj(lower_http_method(route.route_type), route.route, route.openapi_name, route.openapi_tags, route.function.handler)\n\n # TODO! after include_routes does not immediately merge all the routes\n # for router in included_routers:\n # for route in router:\n # openapi.add_openapi_path_obj(lower_http_method(route.route_type), route.route, route.openapi_name, route.openapi_tags, route.function.handler)\n\n def get_routes(self) -> List[Route]:\n return self.routes\n\n\nclass MiddlewareRouter(BaseRouter):\n def __init__(self, dependencies: DependencyMap = DependencyMap()) -> None:\n super().__init__()\n self.global_middlewares: List[GlobalMiddleware] = []\n self.route_middlewares: List[RouteMiddleware] = []\n self.authentication_handler: Optional[AuthenticationHandler] = None\n self.dependencies = dependencies\n\n def set_authentication_handler(self, authentication_handler: AuthenticationHandler):\n self.authentication_handler = authentication_handler\n\n def add_route( # type: ignore\n self,\n middleware_type: MiddlewareType,\n endpoint: str,\n route_type: HttpMethod,\n handler: Callable,\n injected_dependencies: dict,\n ) -> Callable:\n params = dict(inspect.signature(handler).parameters)\n\n new_injected_dependencies = {}\n for dependency in injected_dependencies:\n if dependency in params:\n new_injected_dependencies[dependency] = injected_dependencies[dependency]\n else:\n _logger.debug(f\"Dependency {dependency} is not used in the middleware handler {handler.__name__}\")\n\n function = FunctionInfo(\n handler,\n inspect.iscoroutinefunction(handler),\n len(params),\n params,\n new_injected_dependencies,\n )\n self.route_middlewares.append(RouteMiddleware(middleware_type, endpoint, function, route_type))\n return handler\n\n def add_auth_middleware(self, endpoint: str, route_type: HttpMethod):\n \"\"\"\n This method adds an authentication middleware to the specified endpoint.\n \"\"\"\n\n injected_dependencies: dict = {}\n\n def decorator(handler):\n @wraps(handler)\n def inner_handler(request: Request, *args):\n if not self.authentication_handler:\n raise AuthenticationNotConfiguredError()\n identity = self.authentication_handler.authenticate(request)\n if identity is None:\n return self.authentication_handler.unauthorized_response\n request.identity = identity\n\n return request\n\n self.add_route(\n MiddlewareType.BEFORE_REQUEST,\n endpoint,\n route_type,\n inner_handler,\n injected_dependencies,\n )\n return inner_handler\n\n return decorator\n\n # These inner functions are basically a wrapper around the closure(decorator) being returned.\n # They take a handler, convert it into a closure and return the arguments.\n # Arguments are returned as they could be modified by the middlewares.\n def add_middleware(self, middleware_type: MiddlewareType, endpoint: Optional[str]) -> Callable[..., None]:\n \"\"\"\n This method adds a middleware to the router.\n\n Rules:\n If endpoint is None, the middleware is added as a global middleware.\n If endpoint is provided, the middleware is added to that specific endpoint.\n Only None is supported for global middleware, empty string is not supported.\n empty string or \"/\" is considered as root endpoint.\n\n Args:\n middleware_type: The type of middleware to add (before_request, after_request).\n endpoint: The endpoint to add the middleware to. If None, the middleware is added as a global middleware.\n\n Returns:\n A decorator that takes a handler and adds it as a middleware.\n \"\"\"\n # no dependency injection here\n injected_dependencies: dict = {}\n\n def inner(handler):\n @wraps(handler)\n async def async_inner_handler(*args, **kwargs):\n return await handler(*args, **kwargs)\n\n @wraps(handler)\n def inner_handler(*args, **kwargs):\n return handler(*args, **kwargs)\n\n if endpoint is not None:\n if inspect.iscoroutinefunction(handler):\n self.add_route(\n middleware_type,\n endpoint,\n HttpMethod.GET,\n async_inner_handler,\n injected_dependencies,\n )\n else:\n self.add_route(middleware_type, endpoint, HttpMethod.GET, inner_handler, injected_dependencies)\n else:\n params = dict(inspect.signature(handler).parameters)\n\n if inspect.iscoroutinefunction(handler):\n self.global_middlewares.append(\n GlobalMiddleware(\n middleware_type,\n FunctionInfo(\n async_inner_handler,\n True,\n len(params),\n params,\n injected_dependencies,\n ),\n )\n )\n else:\n self.global_middlewares.append(\n GlobalMiddleware(\n middleware_type,\n FunctionInfo(\n inner_handler,\n False,\n len(params),\n params,\n injected_dependencies,\n ),\n )\n )\n\n return inner\n\n def get_route_middlewares(self) -> List[RouteMiddleware]:\n return self.route_middlewares\n\n def get_global_middlewares(self) -> List[GlobalMiddleware]:\n return self.global_middlewares\n\n\nclass WebSocketRouter(BaseRouter):\n def __init__(self) -> None:\n super().__init__()\n self.routes: Dict[str, dict] = {}\n\n def add_route(self, endpoint: str, handlers: dict) -> None: # type: ignore\n self.routes[endpoint] = handlers\n\n def get_routes(self) -> Dict[str, dict]:\n return self.routes\n"
},
{
"path": "robyn/scaffold/mongo/Dockerfile",
"content": "FROM python:3.11-bookworm\n\nWORKDIR /workspace\n\nCOPY . .\n\nRUN pip install --no-cache-dir --upgrade -r requirements.txt\n\n\nEXPOSE 8080\n\nCMD [\"python3\", \"app.py\", \"--log-level=DEBUG\"]\n"
},
{
"path": "robyn/scaffold/mongo/app.py",
"content": "from pymongo import MongoClient\n\nfrom robyn import Robyn\n\napp = Robyn(__file__)\ndb = MongoClient(\"URL HERE\")\n\nusers = db.users # define a collection\n\n\n@app.get(\"/\")\ndef index():\n return \"Hello World!\"\n\n\n# create a route\n@app.get(\"/users\")\nasync def get_users():\n all_users = await users.find().to_list(length=None)\n return {\"users\": all_users}\n\n\n# create a route to add a new user\n@app.post(\"/users\")\nasync def add_user(request):\n user_data = await request.json()\n result = await users.insert_one(user_data)\n return {\"success\": True, \"inserted_id\": str(result.inserted_id)}\n\n\n# create a route to fetch a single user by ID\n@app.get(\"/users/{user_id}\")\nasync def get_user(request):\n user_id = request.path_params[\"user_id\"]\n user = await users.find_one({\"_id\": user_id})\n if user:\n return user\n else:\n return {\"error\": \"User not found\"}, 404\n\n\nif __name__ == \"__main__\":\n app.start(host=\"0.0.0.0\", port=8080)\n"
},
{
"path": "robyn/scaffold/mongo/requirements.txt",
"content": "robyn\npymongo\n"
},
{
"path": "robyn/scaffold/no-db/Dockerfile",
"content": "FROM python:3.11-bookworm\n\nWORKDIR /workspace\n\nCOPY . .\n\nRUN pip install --no-cache-dir --upgrade -r requirements.txt\n\n\nEXPOSE 8080\n\nCMD [\"python3\", \"app.py\", \"--log-level=DEBUG\"]\n"
},
{
"path": "robyn/scaffold/no-db/app.py",
"content": "from robyn import Robyn\n\napp = Robyn(__file__)\n\n\n@app.get(\"/\")\ndef index():\n return \"Hello World!\"\n\n\nif __name__ == \"__main__\":\n app.start(host=\"0.0.0.0\", port=8080)\n"
},
{
"path": "robyn/scaffold/no-db/requirements.txt",
"content": "robyn\n"
},
{
"path": "robyn/scaffold/postgres/Dockerfile",
"content": "# ---- Build the PostgreSQL Base ----\nFROM postgres:latest AS postgres-base\n\nENV POSTGRES_USER=postgres\nENV POSTGRES_PASSWORD=password\nENV POSTGRES_DB=postgresDB\n\n# ---- Build the Python App ----\nFROM python:3.11-bookworm\n\n# Install supervisor\nRUN apt-get update && apt-get install -y supervisor\n\nWORKDIR /workspace\n\nCOPY . .\n\nRUN pip install --no-cache-dir --upgrade -r requirements.txt\n\n\n# Copy PostgreSQL binaries from the first stage\nCOPY --from=postgres-base /usr/local/bin /usr/local/bin\nCOPY --from=postgres-base /usr/lib/postgresql /usr/lib/postgresql\nCOPY --from=postgres-base /usr/share/postgresql /usr/share/postgresql\nCOPY --from=postgres-base /var/lib/postgresql /var/lib/postgresql\n\n# Add supervisord config\nCOPY supervisord.conf /etc/supervisor/conf.d/supervisord.conf\n\nEXPOSE 8080 5455\n\nCMD [\"/usr/bin/supervisord\"]\n"
},
{
"path": "robyn/scaffold/postgres/app.py",
"content": "import psycopg2\n\nfrom robyn import Robyn\n\nDB_NAME = \"postgresDB\"\nDB_HOST = \"localhost\"\nDB_USER = \"postgres\"\nDB_PASS = \"password\"\nDB_PORT = \"5455\"\n\nconn = psycopg2.connect(database=DB_NAME, host=DB_HOST, user=DB_USER, password=DB_PASS, port=DB_PORT)\n\napp = Robyn(__file__)\n\n\n# create a route to fetch all users\n@app.get(\"/users\")\ndef get_users():\n cursor = conn.cursor()\n cursor.execute(\"SELECT * FROM users\")\n all_users = cursor.fetchall()\n return {\"users\": all_users}\n\n\n@app.get(\"/\")\ndef index():\n return \"Hello World!\"\n\n\nif __name__ == \"__main__\":\n app.start(host=\"0.0.0.0\", port=8080)\n"
},
{
"path": "robyn/scaffold/postgres/requirements.txt",
"content": "robyn\npsycopg2; platform_system==\"Windows\"\npsycopg2-binary; platform_system!=\"Windows\"\n"
},
{
"path": "robyn/scaffold/postgres/supervisord.conf",
"content": "[supervisord]\nnodaemon=true\n\n[program:python-app]\ncommand=python3 /workspace/app.py --log-level=DEBUG\nautostart=true\nautorestart=true\nredirect_stderr=true\n\n[program:postgres]\ncommand=postgres -c 'config_file=/etc/postgresql/postgresql.conf'\nautostart=true\nautorestart=true\nredirect_stderr=true\n"
},
{
"path": "robyn/scaffold/prisma/Dockerfile",
"content": "FROM python:3.11-bookworm\n\nWORKDIR /workspace\n\nCOPY . .\n\nRUN pip install --no-cache-dir --upgrade -r requirements.txt\n\n\nRUN python3 -m prisma generate\nRUN python3 -m prisma migrate dev --name init\n\nEXPOSE 8080\n\nCMD [\"python3\", \"app.py\", \"--log-level=DEBUG\"]\n"
},
{
"path": "robyn/scaffold/prisma/app.py",
"content": "from prisma import Prisma\nfrom prisma.models import User\n\nfrom robyn import Robyn\n\napp = Robyn(__file__)\nprisma = Prisma(auto_register=True)\n\n\n@app.startup_handler\nasync def startup_handler() -> None:\n await prisma.connect()\n\n\n@app.shutdown_handler\nasync def shutdown_handler() -> None:\n if prisma.is_connected():\n await prisma.disconnect()\n\n\n@app.get(\"/\")\nasync def h():\n user = await User.prisma().create(\n data={\n \"name\": \"Robert\",\n },\n )\n return user.json(indent=2)\n\n\nif __name__ == \"__main__\":\n app.start(host=\"0.0.0.0\", port=8080)\n"
},
{
"path": "robyn/scaffold/prisma/requirements.txt",
"content": "robyn\nprisma\n"
},
{
"path": "robyn/scaffold/prisma/schema.prisma",
"content": "datasource db {\n provider = \"sqlite\"\n url = \"file:dev.db\"\n}\n\ngenerator py {\n provider = \"prisma-client-py\"\n}\n\nmodel User {\n id String @id @default(cuid())\n name String\n}"
},
{
"path": "robyn/scaffold/sqlalchemy/Dockerfile",
"content": "FROM python:3.11-bookworm\n\nWORKDIR /workspace\n\nCOPY . .\n\nRUN pip install --no-cache-dir --upgrade -r requirements.txt\n\n\nEXPOSE 8080\n\nCMD [\"python3\", \"app.py\", \"--log-level=DEBUG\"]\n"
},
{
"path": "robyn/scaffold/sqlalchemy/__init__.py",
"content": ""
},
{
"path": "robyn/scaffold/sqlalchemy/app.py",
"content": "from robyn import Robyn\n\napp = Robyn(__file__)\n\n\n@app.get(\"/\")\ndef index():\n return \"Hello World!\"\n\n\nif __name__ == \"__main__\":\n # create a configured \"Session\" class\n app.start(host=\"0.0.0.0\", port=8080)\n"
},
{
"path": "robyn/scaffold/sqlalchemy/models.py",
"content": "from sqlalchemy import Boolean, Column, Integer, String, create_engine\nfrom sqlalchemy.orm import declarative_base, sessionmaker\n\nBase = declarative_base()\n\nengine = create_engine(\"sqlite+pysqlite:///:memory:\", echo=True)\nSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)\n\n\nclass User(Base):\n __tablename__ = \"users\"\n\n id = Column(Integer, primary_key=True, index=True)\n username = Column(String, unique=True, index=True)\n hashed_password = Column(String)\n is_active = Column(Boolean, default=True)\n is_superuser = Column(Boolean, default=False)\n\n\nif __name__ == \"__main__\":\n Base.metadata.create_all(bind=engine)\n"
},
{
"path": "robyn/scaffold/sqlalchemy/requirements.txt",
"content": "robyn\nSQLAlchemy\n"
},
{
"path": "robyn/scaffold/sqlite/Dockerfile",
"content": "FROM python:3.11-bookworm\n\nWORKDIR /workspace\n\nCOPY . .\n\nRUN pip install --no-cache-dir --upgrade -r requirements.txt\n\n\nEXPOSE 8080\n\nCMD [\"python3\", \"app.py\", \"--log-level=DEBUG\"]\n"
},
{
"path": "robyn/scaffold/sqlite/app.py",
"content": "import sqlite3\n\nfrom robyn import Robyn\n\napp = Robyn(__file__)\n\n\n@app.get(\"/\")\ndef index():\n # your db name\n conn = sqlite3.connect(\"example.db\")\n cur = conn.cursor()\n cur.execute(\"DROP TABLE IF EXISTS test\")\n cur.execute(\"CREATE TABLE test(column_1, column_2)\")\n res = cur.execute(\"SELECT name FROM sqlite_master\")\n th = res.fetchone()\n table_name = th[0]\n return f\"Hello World! {table_name}\"\n\n\nif __name__ == \"__main__\":\n app.start(host=\"0.0.0.0\", port=8080)\n"
},
{
"path": "robyn/scaffold/sqlite/requirements.txt",
"content": "robyn\n"
},
{
"path": "robyn/scaffold/sqlmodel/Dockerfile",
"content": "FROM python:3.11-bookworm\n\nWORKDIR /workspace\n\nCOPY . .\n\nRUN pip install --no-cache-dir --upgrade -r requirements.txt\n\nEXPOSE 8080\n\nCMD [\"python3\", \"app.py\", \"--log-level=DEBUG\"]"
},
{
"path": "robyn/scaffold/sqlmodel/app.py",
"content": "from models import Hero\nfrom sqlmodel import Session, SQLModel, create_engine, select\n\nfrom robyn import Robyn\n\napp = Robyn(__file__)\n\nengine = create_engine(\"sqlite:///database.db\", echo=True)\n\n\n@app.get(\"/\")\ndef index():\n return \"Hello World\"\n\n\n@app.get(\"/create\")\ndef create():\n SQLModel.metadata.create_all(bind=engine)\n return \"created tables\"\n\n\n@app.get(\"/insert\")\ndef insert():\n hero_1 = Hero(name=\"Deadpond\", secret_name=\"Dive Wilson\")\n hero_2 = Hero(name=\"Spider-Boy\", secret_name=\"Pedro Parqueador\")\n hero_3 = Hero(name=\"Rusty-Man\", secret_name=\"Tommy Sharp\", age=48)\n\n with Session(engine) as session:\n session.add(hero_1)\n session.add(hero_2)\n session.add(hero_3)\n session.commit()\n return \"inserted\"\n\n\n@app.get(\"/select\")\ndef get_data():\n with Session(engine) as session:\n statement = select(Hero).where(Hero.name == \"Spider-Boy\")\n hero = session.exec(statement).first()\n return hero\n\n\nif __name__ == \"__main__\":\n # create a configured \"Session\" class\n app.start(host=\"0.0.0.0\", port=8080)\n"
},
{
"path": "robyn/scaffold/sqlmodel/models.py",
"content": "from typing import Optional\n\nfrom sqlmodel import Field, SQLModel\n\n\nclass Hero(SQLModel, table=True):\n id: Optional[int] = Field(default=None, primary_key=True)\n name: str\n secret_name: str\n age: Optional[int] = None\n"
},
{
"path": "robyn/scaffold/sqlmodel/requirements.txt",
"content": "robyn\nsqlmodel"
},
{
"path": "robyn/status_codes.py",
"content": "\"\"\"\nHTTP codes\nSee HTTP Status Code Registry:\nhttps://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml\n\nAnd RFC 2324 - https://tools.ietf.org/html/rfc2324\n\"\"\"\n\n__all__ = (\n \"HTTP_100_CONTINUE\",\n \"HTTP_101_SWITCHING_PROTOCOLS\",\n \"HTTP_102_PROCESSING\",\n \"HTTP_103_EARLY_HINTS\",\n \"HTTP_200_OK\",\n \"HTTP_201_CREATED\",\n \"HTTP_202_ACCEPTED\",\n \"HTTP_203_NON_AUTHORITATIVE_INFORMATION\",\n \"HTTP_204_NO_CONTENT\",\n \"HTTP_205_RESET_CONTENT\",\n \"HTTP_206_PARTIAL_CONTENT\",\n \"HTTP_207_MULTI_STATUS\",\n \"HTTP_208_ALREADY_REPORTED\",\n \"HTTP_226_IM_USED\",\n \"HTTP_300_MULTIPLE_CHOICES\",\n \"HTTP_301_MOVED_PERMANENTLY\",\n \"HTTP_302_FOUND\",\n \"HTTP_303_SEE_OTHER\",\n \"HTTP_304_NOT_MODIFIED\",\n \"HTTP_305_USE_PROXY\",\n \"HTTP_306_RESERVED\",\n \"HTTP_307_TEMPORARY_REDIRECT\",\n \"HTTP_308_PERMANENT_REDIRECT\",\n \"HTTP_400_BAD_REQUEST\",\n \"HTTP_401_UNAUTHORIZED\",\n \"HTTP_402_PAYMENT_REQUIRED\",\n \"HTTP_403_FORBIDDEN\",\n \"HTTP_404_NOT_FOUND\",\n \"HTTP_405_METHOD_NOT_ALLOWED\",\n \"HTTP_406_NOT_ACCEPTABLE\",\n \"HTTP_407_PROXY_AUTHENTICATION_REQUIRED\",\n \"HTTP_408_REQUEST_TIMEOUT\",\n \"HTTP_409_CONFLICT\",\n \"HTTP_410_GONE\",\n \"HTTP_411_LENGTH_REQUIRED\",\n \"HTTP_412_PRECONDITION_FAILED\",\n \"HTTP_413_REQUEST_ENTITY_TOO_LARGE\",\n \"HTTP_414_REQUEST_URI_TOO_LONG\",\n \"HTTP_415_UNSUPPORTED_MEDIA_TYPE\",\n \"HTTP_416_REQUESTED_RANGE_NOT_SATISFIABLE\",\n \"HTTP_417_EXPECTATION_FAILED\",\n \"HTTP_418_IM_A_TEAPOT\",\n \"HTTP_421_MISDIRECTED_REQUEST\",\n \"HTTP_422_UNPROCESSABLE_ENTITY\",\n \"HTTP_423_LOCKED\",\n \"HTTP_424_FAILED_DEPENDENCY\",\n \"HTTP_425_TOO_EARLY\",\n \"HTTP_426_UPGRADE_REQUIRED\",\n \"HTTP_428_PRECONDITION_REQUIRED\",\n \"HTTP_429_TOO_MANY_REQUESTS\",\n \"HTTP_431_REQUEST_HEADER_FIELDS_TOO_LARGE\",\n \"HTTP_451_UNAVAILABLE_FOR_LEGAL_REASONS\",\n \"HTTP_500_INTERNAL_SERVER_ERROR\",\n \"HTTP_501_NOT_IMPLEMENTED\",\n \"HTTP_502_BAD_GATEWAY\",\n \"HTTP_503_SERVICE_UNAVAILABLE\",\n \"HTTP_504_GATEWAY_TIMEOUT\",\n \"HTTP_505_HTTP_VERSION_NOT_SUPPORTED\",\n \"HTTP_506_VARIANT_ALSO_NEGOTIATES\",\n \"HTTP_507_INSUFFICIENT_STORAGE\",\n \"HTTP_508_LOOP_DETECTED\",\n \"HTTP_510_NOT_EXTENDED\",\n \"HTTP_511_NETWORK_AUTHENTICATION_REQUIRED\",\n)\n\nHTTP_100_CONTINUE = 100\nHTTP_101_SWITCHING_PROTOCOLS = 101\nHTTP_102_PROCESSING = 102\nHTTP_103_EARLY_HINTS = 103\nHTTP_200_OK = 200\nHTTP_201_CREATED = 201\nHTTP_202_ACCEPTED = 202\nHTTP_203_NON_AUTHORITATIVE_INFORMATION = 203\nHTTP_204_NO_CONTENT = 204\nHTTP_205_RESET_CONTENT = 205\nHTTP_206_PARTIAL_CONTENT = 206\nHTTP_207_MULTI_STATUS = 207\nHTTP_208_ALREADY_REPORTED = 208\nHTTP_226_IM_USED = 226\nHTTP_300_MULTIPLE_CHOICES = 300\nHTTP_301_MOVED_PERMANENTLY = 301\nHTTP_302_FOUND = 302\nHTTP_303_SEE_OTHER = 303\nHTTP_304_NOT_MODIFIED = 304\nHTTP_305_USE_PROXY = 305\nHTTP_306_RESERVED = 306\nHTTP_307_TEMPORARY_REDIRECT = 307\nHTTP_308_PERMANENT_REDIRECT = 308\nHTTP_400_BAD_REQUEST = 400\nHTTP_401_UNAUTHORIZED = 401\nHTTP_402_PAYMENT_REQUIRED = 402\nHTTP_403_FORBIDDEN = 403\nHTTP_404_NOT_FOUND = 404\nHTTP_405_METHOD_NOT_ALLOWED = 405\nHTTP_406_NOT_ACCEPTABLE = 406\nHTTP_407_PROXY_AUTHENTICATION_REQUIRED = 407\nHTTP_408_REQUEST_TIMEOUT = 408\nHTTP_409_CONFLICT = 409\nHTTP_410_GONE = 410\nHTTP_411_LENGTH_REQUIRED = 411\nHTTP_412_PRECONDITION_FAILED = 412\nHTTP_413_REQUEST_ENTITY_TOO_LARGE = 413\nHTTP_414_REQUEST_URI_TOO_LONG = 414\nHTTP_415_UNSUPPORTED_MEDIA_TYPE = 415\nHTTP_416_REQUESTED_RANGE_NOT_SATISFIABLE = 416\nHTTP_417_EXPECTATION_FAILED = 417\nHTTP_418_IM_A_TEAPOT = 418\nHTTP_421_MISDIRECTED_REQUEST = 421\nHTTP_422_UNPROCESSABLE_ENTITY = 422\nHTTP_423_LOCKED = 423\nHTTP_424_FAILED_DEPENDENCY = 424\nHTTP_425_TOO_EARLY = 425\nHTTP_426_UPGRADE_REQUIRED = 426\nHTTP_428_PRECONDITION_REQUIRED = 428\nHTTP_429_TOO_MANY_REQUESTS = 429\nHTTP_431_REQUEST_HEADER_FIELDS_TOO_LARGE = 431\nHTTP_451_UNAVAILABLE_FOR_LEGAL_REASONS = 451\nHTTP_500_INTERNAL_SERVER_ERROR = 500\nHTTP_501_NOT_IMPLEMENTED = 501\nHTTP_502_BAD_GATEWAY = 502\nHTTP_503_SERVICE_UNAVAILABLE = 503\nHTTP_504_GATEWAY_TIMEOUT = 504\nHTTP_505_HTTP_VERSION_NOT_SUPPORTED = 505\nHTTP_506_VARIANT_ALSO_NEGOTIATES = 506\nHTTP_507_INSUFFICIENT_STORAGE = 507\nHTTP_508_LOOP_DETECTED = 508\nHTTP_510_NOT_EXTENDED = 510\nHTTP_511_NETWORK_AUTHENTICATION_REQUIRED = 511\n"
},
{
"path": "robyn/swagger.html",
"content": "\n\n \n Robyn OpenAPI Docs\n \n \n \n \n \n \n \n \n \n\n"
},
{
"path": "robyn/templating.py",
"content": "from abc import ABC, abstractmethod\n\nfrom jinja2 import Environment, FileSystemLoader\n\nfrom robyn import status_codes\n\nfrom .robyn import Headers, Response\n\n\nclass TemplateInterface(ABC):\n def __init__(self): ...\n\n @abstractmethod\n def render_template(self, *args, **kwargs) -> Response: ...\n\n\nclass JinjaTemplate(TemplateInterface):\n def __init__(self, directory, encoding=\"utf-8\", followlinks=False):\n self.env = Environment(loader=FileSystemLoader(searchpath=directory, encoding=encoding, followlinks=followlinks))\n\n def render_template(self, template_name, **kwargs) -> Response:\n rendered_template = self.env.get_template(template_name).render(**kwargs)\n return Response(\n status_code=status_codes.HTTP_200_OK,\n description=rendered_template,\n headers=Headers({\"Content-Type\": \"text/html; charset=utf-8\"}),\n )\n\n\n__all__ = [\"TemplateInterface\", \"JinjaTemplate\"]\n"
},
{
"path": "robyn/types.py",
"content": "from dataclasses import dataclass\nfrom typing import Dict, NewType, Optional, TypedDict\n\nfrom robyn._param_utils import QueryParamValidationError\n\n\n@dataclass\nclass Directory:\n route: str\n directory_path: str\n show_files_listing: bool\n index_file: Optional[str]\n\n def as_list(self):\n return [\n self.route,\n self.directory_path,\n self.show_files_listing,\n self.index_file,\n ]\n\n\nPathParams = NewType(\"PathParams\", Dict[str, str])\nMethod = NewType(\"Method\", str)\nFormData = NewType(\"FormData\", Dict[str, str])\nFiles = NewType(\"Files\", Dict[str, bytes])\nIPAddress = NewType(\"IPAddress\", Optional[str])\n\n\nclass JSONResponse(TypedDict):\n \"\"\"\n A type alias for openapi response bodies. This class should be inherited by the response class type definition.\n \"\"\"\n\n pass\n\n\nclass Body:\n \"\"\"\n A type alias for openapi request bodies. This class should be inherited by the request body class annotation.\n \"\"\"\n\n pass\n\n\nclass JsonBody:\n \"\"\"\n A type alias for JSON request bodies. When used as a parameter type annotation,\n the handler receives the parsed JSON (dict) from request.json() and the OpenAPI\n docs will show a generic JSON request body input.\n\n Can be subclassed with annotations to provide a typed schema in the OpenAPI docs:\n\n class MyBody(JsonBody):\n name: str\n age: int\n\n @app.post(\"/users\")\n def create_user(request: Request, data: MyBody):\n # data is the parsed JSON dict\n ...\n\n .. note::\n\n The JSON body is parsed via ``request.json()`` during parameter\n resolution, *before* the handler is invoked. If the request body is\n not valid JSON, a 400 Bad Request response is returned automatically\n with a JSON error message (e.g., ``{\"error\": \"Invalid JSON body: ...\"}``)\n and the handler is never called. Because parsing happens before\n handler invocation, the error **cannot** be caught with a try/except\n inside the handler.\n\n If you need custom error handling for malformed JSON, accept the raw\n body instead (e.g., ``body: Body``) and call ``request.json()``\n yourself inside a try/except block.\n \"\"\"\n\n pass\n\n\n__all__ = [\"JSONResponse\", \"Body\", \"JsonBody\", \"QueryParamValidationError\", \"Directory\", \"PathParams\", \"Method\", \"FormData\", \"Files\", \"IPAddress\"]\n"
},
{
"path": "robyn/ws.py",
"content": "from __future__ import annotations\n\nimport asyncio\nimport inspect\nimport logging\n\nimport orjson\n\nfrom robyn._param_utils import QueryParamValidationError, resolve_individual_params\nfrom robyn.robyn import FunctionInfo, QueryParams, WebSocketConnector\n\n_logger = logging.getLogger(__name__)\n\n\nclass WebSocketDisconnect(Exception):\n \"\"\"Exception raised when a WebSocket connection is disconnected.\"\"\"\n\n def __init__(self, code: int = 1000, reason: str = \"\"):\n self.code = code\n self.reason = reason\n super().__init__(f\"WebSocket disconnected with code {code}: {reason}\")\n\n\nclass WebSocketAdapter:\n \"\"\"\n Modern WebSocket interface backed by Rust channels.\n\n Wraps a WebSocketConnector and a Rust WebSocketChannel to provide\n a clean async API for WebSocket handlers.\n \"\"\"\n\n def __init__(self, websocket_connector: WebSocketConnector, channel=None):\n self._connector = websocket_connector\n self._channel = channel\n\n async def receive_text(self) -> str:\n \"\"\"Receive the next text message. Blocks until a message arrives.\n Raises WebSocketDisconnect when the connection is closed.\"\"\"\n if self._channel is None:\n raise WebSocketDisconnect(reason=\"No message channel available\")\n result = await self._channel.receive()\n if result is None:\n raise WebSocketDisconnect()\n return result\n\n async def receive_bytes(self) -> bytes:\n \"\"\"Receive binary data (decoded from text).\"\"\"\n text = await self.receive_text()\n return text.encode(\"utf-8\")\n\n async def receive_json(self):\n \"\"\"Receive and decode JSON data.\n Raises WebSocketDisconnect when the connection is closed.\"\"\"\n text = await self.receive_text()\n return orjson.loads(text)\n\n async def send_text(self, data: str):\n \"\"\"Send text data to this WebSocket client.\"\"\"\n await self._connector.async_send_to(self._connector.id, data)\n\n async def send_bytes(self, data: bytes):\n \"\"\"Send binary data (as text) to this WebSocket client.\"\"\"\n await self._connector.async_send_to(self._connector.id, data.decode(\"utf-8\"))\n\n async def send_json(self, data):\n \"\"\"Send JSON data to this WebSocket client.\"\"\"\n await self.send_text(orjson.dumps(data).decode())\n\n async def broadcast(self, data: str):\n \"\"\"Broadcast text data to all connected WebSocket clients on this endpoint.\"\"\"\n await self._connector.async_broadcast(data)\n\n async def close(self):\n \"\"\"Close the WebSocket connection.\"\"\"\n self._connector.close()\n\n @property\n def id(self) -> str:\n \"\"\"WebSocket connection ID.\"\"\"\n return self._connector.id\n\n @property\n def query_params(self):\n \"\"\"Access query parameters from the connection URL.\"\"\"\n return self._connector.query_params\n\n\n# Global storage for connection state (per-connection queues and tasks)\n_connection_tasks: dict[str, asyncio.Task] = {}\n\n\ndef create_websocket_decorator(app_instance):\n \"\"\"\n Factory function to create a websocket decorator for an app instance.\n Returns a decorator that registers a modern WebSocket endpoint\n backed by Rust channels.\n \"\"\"\n\n def websocket(endpoint: str):\n \"\"\"\n Modern WebSocket decorator.\n\n Usage:\n @app.websocket(\"/ws\")\n async def handler(websocket):\n while True:\n msg = await websocket.receive_text()\n await websocket.send_text(f\"Echo: {msg}\")\n\n @handler.on_connect\n def on_connect(websocket):\n return \"Welcome!\"\n\n @handler.on_close\n def on_close(websocket):\n return \"Goodbye\"\n \"\"\"\n\n def decorator(handler):\n _on_connect_fn = None\n _on_close_fn = None\n\n def _resolve_ws_params(func_params, adapter):\n \"\"\"\n Resolve all handler params beyond the first positional (websocket).\n\n Handles:\n - global_dependencies / router_dependencies (DI)\n - query_params (whole QueryParams object, by name or type annotation)\n - individual query params (everything else, with type coercion)\n \"\"\"\n injected = app_instance.dependencies.get_dependency_map(app_instance)\n resolved = {}\n unresolved = {}\n\n for idx, (param_name, param) in enumerate(func_params.items()):\n # Skip the websocket adapter (first positional arg, passed separately)\n if idx == 0 or param.annotation is WebSocketAdapter:\n continue\n\n # DI: global_dependencies\n if param_name == \"global_dependencies\":\n resolved[param_name] = injected.get(\"global_dependencies\", {})\n continue\n\n # DI: router_dependencies\n if param_name == \"router_dependencies\":\n resolved[param_name] = injected.get(\"router_dependencies\", {})\n continue\n\n # Whole QueryParams object (by type annotation or reserved name)\n if param.annotation is QueryParams or param_name == \"query_params\":\n resolved[param_name] = adapter.query_params\n continue\n\n # Everything else: individual query param\n unresolved[param_name] = param\n\n if unresolved:\n individual = resolve_individual_params(\n unresolved,\n adapter.query_params,\n path_params=None, # WebSocket has no path params yet\n route_param_names=set(),\n )\n resolved.update(individual)\n\n return resolved\n\n # --- Connect handler (called by Rust on connection open) ---\n async def connect_handler(ws):\n \"\"\"Internal connect handler called by Rust.\n Creates the adapter, starts the user's handler task,\n and calls the user's on_connect callback.\"\"\"\n conn_id = ws.id\n channel = ws.message_channel\n\n # Create the adapter with the Rust channel\n adapter = WebSocketAdapter(ws, channel)\n\n # Build resolved kwargs for the main handler\n try:\n handler_params = inspect.signature(handler).parameters\n handler_kwargs = _resolve_ws_params(handler_params, adapter)\n except QueryParamValidationError as e:\n _logger.warning(\"WebSocket connection rejected for %s: %s\", endpoint, e.detail)\n return f\"Error: {e.detail}\"\n\n # Start the user's handler as a long-running asyncio task\n async def _run_handler():\n try:\n await handler(adapter, **handler_kwargs)\n except WebSocketDisconnect:\n pass\n except ConnectionError:\n _logger.debug(\"Connection lost in WebSocket handler for %s\", endpoint, exc_info=True)\n except Exception:\n _logger.exception(\"Error in WebSocket handler for %s\", endpoint)\n finally:\n _connection_tasks.pop(conn_id, None)\n\n task = asyncio.create_task(_run_handler())\n _connection_tasks[conn_id] = task\n\n # Call user's on_connect if defined\n if _on_connect_fn is not None:\n connect_adapter = WebSocketAdapter(ws, channel)\n try:\n connect_params = inspect.signature(_on_connect_fn).parameters\n connect_kwargs = _resolve_ws_params(connect_params, connect_adapter)\n except QueryParamValidationError as e:\n _logger.warning(\"WebSocket on_connect rejected for %s: %s\", endpoint, e.detail)\n task = _connection_tasks.pop(conn_id, None)\n if task is not None and not task.done():\n task.cancel()\n return f\"Error: {e.detail}\"\n if asyncio.iscoroutinefunction(_on_connect_fn):\n result = await _on_connect_fn(connect_adapter, **connect_kwargs)\n else:\n result = _on_connect_fn(connect_adapter, **connect_kwargs)\n return result\n\n return None\n\n # --- Message handler (dummy for new-style; Rust pushes to channel instead) ---\n async def message_handler(ws, msg):\n \"\"\"Dummy message handler. In channel mode, Rust pushes messages\n directly to the channel and never calls this.\"\"\"\n return None\n\n # --- Close handler (called by Rust on connection close) ---\n async def close_handler(ws):\n \"\"\"Internal close handler called by Rust.\n Waits for the handler task to finish and calls on_close.\"\"\"\n conn_id = ws.id\n\n # Wait for the handler task to finish (it should exit because\n # the channel was closed by Rust, triggering WebSocketDisconnect)\n task = _connection_tasks.pop(conn_id, None)\n if task is not None:\n try:\n await asyncio.wait_for(task, timeout=5.0)\n except (asyncio.TimeoutError, asyncio.CancelledError):\n if not task.done():\n task.cancel()\n except Exception:\n _logger.debug(\"Unexpected error while awaiting handler task for %s\", conn_id, exc_info=True)\n if not task.done():\n task.cancel()\n\n # Call user's on_close if defined\n if _on_close_fn is not None:\n close_adapter = WebSocketAdapter(ws, None)\n try:\n close_params = inspect.signature(_on_close_fn).parameters\n close_kwargs = _resolve_ws_params(close_params, close_adapter)\n except QueryParamValidationError as e:\n _logger.warning(\"WebSocket on_close param error for %s: %s\", endpoint, e.detail)\n return None\n if asyncio.iscoroutinefunction(_on_close_fn):\n result = await _on_close_fn(close_adapter, **close_kwargs)\n else:\n result = _on_close_fn(close_adapter, **close_kwargs)\n return result\n\n return None\n\n # --- Build FunctionInfo objects for Rust ---\n handlers = {}\n\n # Connect handler FunctionInfo\n connect_params = dict(inspect.signature(connect_handler).parameters)\n handlers[\"connect\"] = FunctionInfo(\n connect_handler,\n True, # is_async\n len(connect_params),\n connect_params,\n {}, # no kwargs needed - DI handled in Python\n )\n\n # Message handler FunctionInfo (dummy, won't be called in channel mode)\n message_params = dict(inspect.signature(message_handler).parameters)\n handlers[\"message\"] = FunctionInfo(\n message_handler,\n True,\n len(message_params),\n message_params,\n {},\n )\n\n # Close handler FunctionInfo\n close_params = dict(inspect.signature(close_handler).parameters)\n handlers[\"close\"] = FunctionInfo(\n close_handler,\n True,\n len(close_params),\n close_params,\n {},\n )\n\n # --- Decorator methods for on_connect / on_close ---\n def add_on_connect(connect_fn):\n nonlocal _on_connect_fn\n _on_connect_fn = connect_fn\n return connect_fn\n\n def add_on_close(close_fn):\n nonlocal _on_close_fn\n _on_close_fn = close_fn\n return close_fn\n\n handler.on_connect = add_on_connect\n handler.on_close = add_on_close\n\n # Register with the app\n app_instance.add_web_socket(endpoint, handlers)\n\n return handler\n\n return decorator\n\n return websocket\n"
},
{
"path": "scripts/format.sh",
"content": "#!/bin/bash\n\nset -x\n\nruff format robyn integration_tests docs_src\n"
},
{
"path": "scripts/release.sh",
"content": "#!/bin/bash\n\nset -x\n\nmaturin develop\npoetry lock \n"
},
{
"path": "setup.py",
"content": "import sys\n\nsys.stderr.write(\n \"\"\"\n===============================\nUnsupported installation method\n===============================\nrobyn doesn't support installation with `python setup.py install`.\nPlease use `python -m pip install .` instead.\n\"\"\"\n)\nsys.exit(1)\n"
},
{
"path": "src/asyncio.rs",
"content": "use pyo3::{prelude::*, sync::PyOnceLock};\nuse std::convert::Into;\n\nstatic CONTEXTVARS: PyOnceLock> = PyOnceLock::new();\nstatic CONTEXT: PyOnceLock> = PyOnceLock::new();\n\nfn contextvars(py: Python<'_>) -> PyResult<&Bound<'_, PyAny>> {\n Ok(CONTEXTVARS\n .get_or_try_init(py, || py.import(\"contextvars\").map(Into::into))?\n .bind(py))\n}\n\n#[allow(dead_code)]\npub(crate) fn empty_context(py: Python<'_>) -> PyResult<&Bound<'_, PyAny>> {\n Ok(CONTEXT\n .get_or_try_init(py, || {\n contextvars(py)?\n .getattr(\"Context\")?\n .call0()\n .map(std::convert::Into::into)\n })?\n .bind(py))\n}\n\n#[inline(always)]\npub(crate) fn copy_context(py: Python) -> PyResult> {\n unsafe {\n let ptr = pyo3::ffi::PyContext_CopyCurrent();\n Ok(Bound::from_owned_ptr_or_err(py, ptr)?.unbind())\n }\n}\n"
},
{
"path": "src/blocking.rs",
"content": "use crossbeam_channel as channel;\nuse pyo3::prelude::*;\nuse std::{\n sync::{atomic, Arc},\n thread, time,\n};\n\npub(crate) struct BlockingTask {\n inner: Box,\n}\n\nimpl BlockingTask {\n #[inline]\n pub fn new(inner: T) -> BlockingTask\n where\n T: FnOnce(Python) + Send + 'static,\n {\n Self {\n inner: Box::new(inner),\n }\n }\n\n #[inline(always)]\n pub fn run(self, py: Python) {\n (self.inner)(py);\n }\n}\n\npub(crate) enum BlockingRunner {\n Empty,\n Mono(BlockingRunnerMono),\n Pool(BlockingRunnerPool),\n}\n\nimpl BlockingRunner {\n pub fn new(max_threads: usize, idle_timeout: u64) -> Self {\n match max_threads {\n 0 => Self::Empty,\n 1 => Self::Mono(BlockingRunnerMono::new()),\n _ => Self::Pool(BlockingRunnerPool::new(max_threads, idle_timeout)),\n }\n }\n\n #[inline]\n pub fn run(&self, task: T) -> Result<(), channel::SendError>\n where\n T: FnOnce(Python) + Send + 'static,\n {\n match self {\n Self::Mono(runner) => runner.run(task),\n Self::Pool(runner) => runner.run(task),\n Self::Empty => Ok(()),\n }\n }\n}\n\npub(crate) struct BlockingRunnerMono {\n queue: channel::Sender,\n}\n\nimpl BlockingRunnerMono {\n pub fn new() -> Self {\n let (qtx, qrx) = channel::unbounded();\n let ret = Self { queue: qtx };\n thread::spawn(move || blocking_worker(qrx));\n\n ret\n }\n\n #[inline]\n pub fn run(&self, task: T) -> Result<(), channel::SendError>\n where\n T: FnOnce(Python) + Send + 'static,\n {\n self.queue.send(BlockingTask::new(task))\n }\n}\n\npub(crate) struct BlockingRunnerPool {\n birth: time::Instant,\n queue: channel::Sender,\n tq: channel::Receiver,\n threads: Arc,\n tmax: usize,\n idle_timeout: time::Duration,\n spawning: atomic::AtomicBool,\n spawn_tick: atomic::AtomicU64,\n}\n\nimpl BlockingRunnerPool {\n pub fn new(max_threads: usize, idle_timeout: u64) -> Self {\n let (qtx, qrx) = channel::unbounded();\n let ret = Self {\n queue: qtx,\n tq: qrx.clone(),\n threads: Arc::new(1.into()),\n tmax: max_threads,\n birth: time::Instant::now(),\n spawning: false.into(),\n spawn_tick: 0.into(),\n idle_timeout: time::Duration::from_secs(idle_timeout),\n };\n\n // always spawn the first thread\n thread::spawn(move || blocking_worker(qrx));\n\n ret\n }\n\n #[inline(always)]\n fn spawn_thread(&self) {\n let tick = self.birth.elapsed().as_micros() as u64;\n if tick - self.spawn_tick.load(atomic::Ordering::Relaxed) < 350 {\n return;\n }\n if self\n .spawning\n .compare_exchange(\n false,\n true,\n atomic::Ordering::Relaxed,\n atomic::Ordering::Relaxed,\n )\n .is_err()\n {\n return;\n }\n\n let queue = self.tq.clone();\n let tcount = self.threads.clone();\n let timeout = self.idle_timeout;\n thread::spawn(move || {\n tcount.fetch_add(1, atomic::Ordering::Release);\n blocking_worker_idle(queue, timeout);\n tcount.fetch_sub(1, atomic::Ordering::Release);\n });\n\n self.spawn_tick.store(\n self.birth.elapsed().as_micros() as u64,\n atomic::Ordering::Relaxed,\n );\n self.spawning.store(false, atomic::Ordering::Relaxed);\n }\n\n #[inline]\n pub fn run(&self, task: T) -> Result<(), channel::SendError>\n where\n T: FnOnce(Python) + Send + 'static,\n {\n self.queue.send(BlockingTask::new(task))?;\n if self.queue.len() > 1 && self.threads.load(atomic::Ordering::Acquire) < self.tmax {\n self.spawn_thread();\n }\n Ok(())\n }\n}\n\nfn blocking_worker(queue: channel::Receiver) {\n Python::attach(|py| {\n while let Ok(task) = py.detach(|| queue.recv()) {\n task.run(py);\n }\n });\n}\n\nfn blocking_worker_idle(queue: channel::Receiver, timeout: time::Duration) {\n Python::attach(|py| {\n while let Ok(task) = py.detach(|| queue.recv_timeout(timeout)) {\n task.run(py);\n }\n });\n}\n"
},
{
"path": "src/callbacks.rs",
"content": "use pyo3::{exceptions::PyStopIteration, prelude::*, IntoPyObjectExt};\nuse std::sync::{atomic, Arc, OnceLock, RwLock};\nuse tokio::sync::Notify;\n\nuse crate::conversion::FutureResultToPy;\n\n#[pyclass(frozen, freelist = 128, module = \"robyn._robyn\")]\npub(crate) struct PyEmptyAwaitable;\n\n#[pymethods]\nimpl PyEmptyAwaitable {\n fn __await__(pyself: PyRef<'_, Self>) -> PyRef<'_, Self> {\n pyself\n }\n\n fn __iter__(pyself: PyRef<'_, Self>) -> PyRef<'_, Self> {\n pyself\n }\n\n fn __next__(&self) -> Option<()> {\n None\n }\n}\n\n#[pyclass(frozen, module = \"robyn._robyn\")]\npub(crate) struct PyDoneAwaitable {\n result: PyResult>,\n}\n\nimpl PyDoneAwaitable {\n pub(crate) fn new(result: PyResult>) -> Self {\n Self { result }\n }\n}\n\n#[pymethods]\nimpl PyDoneAwaitable {\n fn __await__(pyself: PyRef<'_, Self>) -> PyRef<'_, Self> {\n pyself\n }\n\n fn __iter__(pyself: PyRef<'_, Self>) -> PyRef<'_, Self> {\n pyself\n }\n\n fn __next__(&self, py: Python) -> PyResult> {\n self.result\n .as_ref()\n .map_err(|v| v.clone_ref(py))\n .map(|v| Err(PyStopIteration::new_err(v.clone_ref(py))))?\n }\n}\n\n#[pyclass(frozen, module = \"robyn._robyn\")]\npub(crate) struct PyErrAwaitable {\n err: PyErr,\n}\n\nimpl PyErrAwaitable {\n pub(crate) fn new(err: PyErr) -> Self {\n Self { err }\n }\n}\n\n#[pymethods]\nimpl PyErrAwaitable {\n fn __await__(pyself: PyRef<'_, Self>) -> PyRef<'_, Self> {\n pyself\n }\n\n fn __iter__(pyself: PyRef<'_, Self>) -> PyRef<'_, Self> {\n pyself\n }\n\n fn __next__(&self, py: Python) -> PyResult<()> {\n Err(self.err.clone_ref(py))\n }\n}\n\n#[pyclass(frozen, module = \"robyn._robyn\")]\npub(crate) struct PyIterAwaitable {\n result: OnceLock>>,\n}\n\nimpl PyIterAwaitable {\n pub(crate) fn new() -> Self {\n Self {\n result: OnceLock::new(),\n }\n }\n\n #[inline]\n pub(crate) fn set_result(pyself: Py, py: Python, result: FutureResultToPy) {\n _ = pyself\n .get()\n .result\n .set(result.into_pyobject(py).map(Bound::unbind));\n pyself.drop_ref(py);\n }\n}\n\n#[pymethods]\nimpl PyIterAwaitable {\n fn __await__(pyself: PyRef<'_, Self>) -> PyRef<'_, Self> {\n pyself\n }\n\n fn __iter__(pyself: PyRef<'_, Self>) -> PyRef<'_, Self> {\n pyself\n }\n\n fn __next__(&self, py: Python) -> PyResult>> {\n if let Some(res) = self.result.get() {\n return res\n .as_ref()\n .map_err(|err| err.clone_ref(py))\n .map(|v| Err(PyStopIteration::new_err(v.clone_ref(py))))?;\n }\n\n Ok(Some(py.None()))\n }\n}\n\n#[repr(u8)]\nenum PyFutureAwaitableState {\n Pending = 0,\n Completed = 1,\n Cancelled = 2,\n}\n\n#[pyclass(frozen, module = \"robyn._robyn\")]\npub(crate) struct PyFutureAwaitable {\n state: atomic::AtomicU8,\n result: OnceLock>>,\n event_loop: Py,\n cancel_tx: Arc,\n cancel_msg: OnceLock>,\n py_block: atomic::AtomicBool,\n ack: RwLock, Py)>>,\n}\n\nimpl PyFutureAwaitable {\n pub(crate) fn new(event_loop: Py) -> Self {\n Self {\n state: atomic::AtomicU8::new(PyFutureAwaitableState::Pending as u8),\n result: OnceLock::new(),\n event_loop,\n cancel_tx: Arc::new(Notify::new()),\n cancel_msg: OnceLock::new(),\n py_block: true.into(),\n ack: RwLock::new(None),\n }\n }\n\n pub fn to_spawn(self, py: Python) -> PyResult<(Py, Arc)> {\n let cancel_tx = self.cancel_tx.clone();\n Ok((Py::new(py, self)?, cancel_tx))\n }\n\n pub(crate) fn set_result(pyself: Py, py: Python, result: FutureResultToPy) {\n let rself = pyself.get();\n\n _ = rself\n .result\n .set(result.into_pyobject(py).map(Bound::unbind));\n if rself\n .state\n .compare_exchange(\n PyFutureAwaitableState::Pending as u8,\n PyFutureAwaitableState::Completed as u8,\n atomic::Ordering::Release,\n atomic::Ordering::Relaxed,\n )\n .is_err()\n {\n pyself.drop_ref(py);\n return;\n }\n\n {\n let ack = rself.ack.read().unwrap();\n if let Some((cb, ctx)) = &*ack {\n _ = rself.event_loop.clone_ref(py).call_method(\n py,\n pyo3::intern!(py, \"call_soon_threadsafe\"),\n (cb, pyself.clone_ref(py)),\n Some(ctx.bind(py)),\n );\n }\n }\n pyself.drop_ref(py);\n }\n}\n\n#[pymethods]\nimpl PyFutureAwaitable {\n fn __await__(pyself: PyRef<'_, Self>) -> PyRef<'_, Self> {\n pyself\n }\n fn __iter__(pyself: PyRef<'_, Self>) -> PyRef<'_, Self> {\n pyself\n }\n\n fn __next__(pyself: PyRef<'_, Self>) -> PyResult>> {\n if pyself.state.load(atomic::Ordering::Acquire) == PyFutureAwaitableState::Completed as u8 {\n let py = pyself.py();\n return pyself\n .result\n .get()\n .unwrap()\n .as_ref()\n .map_err(|err| err.clone_ref(py))\n .map(|v| Err(PyStopIteration::new_err(v.clone_ref(py))))?;\n }\n\n Ok(Some(pyself))\n }\n\n #[getter(_asyncio_future_blocking)]\n fn get_block(&self) -> bool {\n self.py_block.load(atomic::Ordering::Relaxed)\n }\n\n #[setter(_asyncio_future_blocking)]\n fn set_block(&self, val: bool) {\n self.py_block.store(val, atomic::Ordering::Relaxed);\n }\n\n fn get_loop(&self, py: Python) -> Py {\n self.event_loop.clone_ref(py)\n }\n\n /// Single-callback optimization: only the most recent callback is stored.\n /// This is intentional — this type is internal to the robyn runtime and in\n /// practice asyncio registers at most one done-callback per future.\n #[pyo3(signature = (cb, context=None))]\n fn add_done_callback(\n pyself: PyRef<'_, Self>,\n cb: Py,\n context: Option>,\n ) -> PyResult<()> {\n let py = pyself.py();\n let kwctx = pyo3::types::PyDict::new(py);\n kwctx.set_item(pyo3::intern!(py, \"context\"), context)?;\n\n let state = pyself.state.load(atomic::Ordering::Acquire);\n if state == PyFutureAwaitableState::Pending as u8 {\n let mut ack = pyself.ack.write().unwrap();\n *ack = Some((cb, kwctx.unbind()));\n } else {\n let event_loop = pyself.event_loop.clone_ref(py);\n event_loop.call_method(\n py,\n pyo3::intern!(py, \"call_soon\"),\n (cb, pyself),\n Some(&kwctx),\n )?;\n }\n\n Ok(())\n }\n\n /// Clears the single stored callback (see `add_done_callback`).\n /// The `cb` argument is accepted for asyncio protocol compatibility but\n /// is not used for matching — the sole stored callback is always removed.\n #[allow(unused)]\n fn remove_done_callback(&self, cb: Py) -> i32 {\n let mut ack = self.ack.write().unwrap();\n if ack.is_some() {\n *ack = None;\n 1\n } else {\n 0\n }\n }\n\n #[allow(unused)]\n #[pyo3(signature = (msg=None))]\n fn cancel(pyself: PyRef<'_, Self>, msg: Option>) -> bool {\n if pyself\n .state\n .compare_exchange(\n PyFutureAwaitableState::Pending as u8,\n PyFutureAwaitableState::Cancelled as u8,\n atomic::Ordering::Release,\n atomic::Ordering::Relaxed,\n )\n .is_err()\n {\n return false;\n }\n\n if let Some(cancel_msg) = msg {\n _ = pyself.cancel_msg.set(cancel_msg);\n }\n pyself.cancel_tx.notify_one();\n\n let ack = pyself.ack.read().unwrap();\n if let Some((cb, ctx)) = &*ack {\n let py = pyself.py();\n let event_loop = pyself.event_loop.clone_ref(py);\n let cb = cb.clone_ref(py);\n let ctx = ctx.clone_ref(py);\n drop(ack);\n\n let _ = event_loop.call_method(\n py,\n pyo3::intern!(py, \"call_soon\"),\n (cb, pyself),\n Some(ctx.bind(py)),\n );\n }\n\n true\n }\n\n fn done(&self) -> bool {\n self.state.load(atomic::Ordering::Acquire) != PyFutureAwaitableState::Pending as u8\n }\n\n fn result(&self, py: Python) -> PyResult> {\n let state = self.state.load(atomic::Ordering::Acquire);\n\n if state == PyFutureAwaitableState::Completed as u8 {\n return self\n .result\n .get()\n .unwrap()\n .as_ref()\n .map(|v| v.clone_ref(py))\n .map_err(|err| err.clone_ref(py));\n }\n if state == PyFutureAwaitableState::Cancelled as u8 {\n let msg = self\n .cancel_msg\n .get()\n .unwrap_or(&\"Future cancelled.\".into_py_any(py).unwrap())\n .clone_ref(py);\n return Err(pyo3::exceptions::asyncio::CancelledError::new_err(msg));\n }\n Err(pyo3::exceptions::asyncio::InvalidStateError::new_err(\n \"Result is not ready.\",\n ))\n }\n\n fn exception(&self, py: Python) -> PyResult> {\n let state = self.state.load(atomic::Ordering::Acquire);\n\n if state == PyFutureAwaitableState::Completed as u8 {\n return self\n .result\n .get()\n .unwrap()\n .as_ref()\n .map(|_| py.None())\n .map_err(|err| err.clone_ref(py));\n }\n if state == PyFutureAwaitableState::Cancelled as u8 {\n let msg = self\n .cancel_msg\n .get()\n .unwrap_or(&\"Future cancelled.\".into_py_any(py).unwrap())\n .clone_ref(py);\n return Err(pyo3::exceptions::asyncio::CancelledError::new_err(msg));\n }\n Err(pyo3::exceptions::asyncio::InvalidStateError::new_err(\n \"Exception is not set.\",\n ))\n }\n}\n\n#[pyclass(frozen)]\npub(crate) struct PyFutureDoneCallback {\n pub cancel_tx: Arc,\n}\n\n#[pymethods]\nimpl PyFutureDoneCallback {\n pub fn __call__(&self, fut: Bound) -> PyResult<()> {\n let py = fut.py();\n\n if {\n fut.getattr(pyo3::intern!(py, \"cancelled\"))?\n .call0()?\n .is_truthy()\n }\n .unwrap_or(false)\n {\n self.cancel_tx.notify_one();\n }\n\n Ok(())\n }\n}\n\n#[pyclass(frozen)]\npub(crate) struct PyFutureResultSetter;\n\n#[pymethods]\nimpl PyFutureResultSetter {\n pub fn __call__(&self, target: Bound, value: Bound) {\n let _ = target.call1((value,));\n }\n}\n"
},
{
"path": "src/conversion.rs",
"content": "use pyo3::prelude::*;\n\n// Adapted for robyn - returns Py directly\npub(crate) enum FutureResultToPy {\n None,\n Err(PyResult<()>),\n Value(Py),\n}\n\nimpl<'p> IntoPyObject<'p> for FutureResultToPy {\n type Target = PyAny;\n type Output = Bound<'p, Self::Target>;\n type Error = PyErr;\n\n fn into_pyobject(self, py: Python<'p>) -> Result {\n match self {\n Self::None => Ok(py.None().into_bound(py)),\n Self::Err(res) => Err(res.err().unwrap()),\n Self::Value(val) => {\n let bound = val.bind(py);\n Ok(bound.clone())\n }\n }\n }\n}\n"
},
{
"path": "src/executors/mod.rs",
"content": "#[deny(clippy::if_same_then_else)]\npub mod web_socket_executors;\n\nuse std::sync::Arc;\n\nuse anyhow::Result;\nuse pyo3::prelude::*;\nuse pyo3::{BoundObject, IntoPyObject};\nuse pyo3_async_runtimes::TaskLocals;\n\nuse crate::types::{\n function_info::FunctionInfo,\n request::Request,\n response::{Response, ResponseType, StreamingResponse},\n MiddlewareReturn,\n};\n\n#[inline]\nfn get_function_output<'a, T>(\n function: &'a FunctionInfo,\n py: Python<'a>,\n function_args: &T,\n) -> Result, PyErr>\nwhere\n T: Clone + for<'py> IntoPyObject<'py>,\n for<'py> >::Error: std::fmt::Debug,\n{\n let handler = function.handler.bind(py).downcast()?;\n\n // 0-param handlers: skip Request→Python conversion entirely\n if function.number_of_params == 0 {\n return handler.call0();\n }\n\n let kwargs = function.kwargs.bind(py);\n let function_args: Py = function_args\n .clone()\n .into_pyobject(py)\n .map_err(|e| {\n PyErr::new::(format!(\n \"Failed to convert args: {:?}\",\n e\n ))\n })?\n .into_any()\n .unbind();\n\n match function.number_of_params {\n 1 => {\n if pyo3::types::PyDictMethods::get_item(kwargs, \"global_dependencies\")\n .is_ok_and(|it| !it.is_none())\n || pyo3::types::PyDictMethods::get_item(kwargs, \"router_dependencies\")\n .is_ok_and(|it| !it.is_none())\n {\n handler.call((), Some(kwargs))\n } else {\n handler.call1((function_args,))\n }\n }\n _ => handler.call((function_args,), Some(kwargs)),\n }\n}\n\n// Execute the middleware function\n// type T can be either Request (before middleware) or Response (after middleware)\n// Return type can either be a Request or a Response, we wrap it inside an enum for easier handling\n#[inline]\npub async fn execute_middleware_function(\n input: &T,\n function: &FunctionInfo,\n) -> Result\nwhere\n T: Clone + for<'a, 'py> FromPyObject<'a, 'py> + for<'py> IntoPyObject<'py>,\n for<'py> >::Error: std::fmt::Debug,\n{\n if function.is_async {\n let output: Py = Python::with_gil(|py| {\n pyo3_async_runtimes::tokio::into_future(get_function_output(function, py, input)?)\n })?\n .await?;\n\n Python::with_gil(|py| -> Result {\n // Try response extraction first, then request\n match output.extract::(py) {\n Ok(response) => Ok(MiddlewareReturn::Response(response)),\n Err(_) => match output.extract::(py) {\n Ok(request) => Ok(MiddlewareReturn::Request(request)),\n Err(e) => Err(e.into()),\n },\n }\n })\n } else {\n Python::with_gil(|py| -> Result {\n let output = get_function_output(function, py, input)?;\n\n match output.extract::() {\n Ok(response) => Ok(MiddlewareReturn::Response(response)),\n Err(_) => match output.extract::() {\n Ok(request) => Ok(MiddlewareReturn::Request(request)),\n Err(e) => Err(e.into()),\n },\n }\n })\n }\n}\n\n// Execute the after_request middleware function with both request and response\n// This allows after_request callbacks to access the request object\n#[inline]\nfn get_function_output_with_two_args<'a, T, U>(\n function: &'a FunctionInfo,\n py: Python<'a>,\n first_arg: &T,\n second_arg: &U,\n) -> Result, PyErr>\nwhere\n T: Clone + for<'py> IntoPyObject<'py>,\n U: Clone + for<'py> IntoPyObject<'py>,\n for<'py> >::Error: std::fmt::Debug,\n for<'py> >::Error: std::fmt::Debug,\n{\n let handler = function.handler.bind(py).downcast()?;\n\n if function.number_of_params == 0 {\n return handler.call0();\n }\n\n let kwargs = function.kwargs.bind(py);\n let first_arg: Py = first_arg\n .clone()\n .into_pyobject(py)\n .map_err(|e| {\n PyErr::new::(format!(\n \"Failed to convert first arg: {:?}\",\n e\n ))\n })?\n .into_any()\n .unbind();\n let second_arg: Py = second_arg\n .clone()\n .into_pyobject(py)\n .map_err(|e| {\n PyErr::new::(format!(\n \"Failed to convert second arg: {:?}\",\n e\n ))\n })?\n .into_any()\n .unbind();\n\n match function.number_of_params {\n 1 => {\n if pyo3::types::PyDictMethods::get_item(kwargs, \"global_dependencies\")\n .is_ok_and(|it| !it.is_none())\n || pyo3::types::PyDictMethods::get_item(kwargs, \"router_dependencies\")\n .is_ok_and(|it| !it.is_none())\n {\n handler.call((), Some(kwargs))\n } else {\n handler.call1((second_arg,))\n }\n }\n 2 => {\n if pyo3::types::PyDictMethods::get_item(kwargs, \"global_dependencies\")\n .is_ok_and(|it| !it.is_none())\n || pyo3::types::PyDictMethods::get_item(kwargs, \"router_dependencies\")\n .is_ok_and(|it| !it.is_none())\n {\n handler.call((first_arg, second_arg), Some(kwargs))\n } else {\n handler.call1((first_arg, second_arg))\n }\n }\n _ => handler.call((first_arg, second_arg), Some(kwargs)),\n }\n}\n\n// Execute the after_request middleware function with both request and response\n#[inline]\npub async fn execute_after_middleware_function(\n request: &Request,\n response: &Response,\n function: &FunctionInfo,\n) -> Result {\n if function.is_async {\n let output: Py = Python::with_gil(|py| {\n pyo3_async_runtimes::tokio::into_future(get_function_output_with_two_args(\n function, py, request, response,\n )?)\n })?\n .await?;\n\n Python::with_gil(|py| -> Result {\n // Try response extraction first, then request\n match output.extract::(py) {\n Ok(response) => Ok(MiddlewareReturn::Response(response)),\n Err(_) => match output.extract::(py) {\n Ok(request) => Ok(MiddlewareReturn::Request(request)),\n Err(e) => Err(e.into()),\n },\n }\n })\n } else {\n Python::with_gil(|py| -> Result {\n let output = get_function_output_with_two_args(function, py, request, response)?;\n\n match output.extract::() {\n Ok(response) => Ok(MiddlewareReturn::Response(response)),\n Err(_) => match output.extract::() {\n Ok(request) => Ok(MiddlewareReturn::Request(request)),\n Err(e) => Err(e.into()),\n },\n }\n })\n }\n}\n\n#[inline]\npub async fn execute_http_function(\n request: &Request,\n function: &FunctionInfo,\n) -> PyResult {\n if function.is_async {\n let output = Python::with_gil(|py| {\n let function_output = get_function_output(function, py, request)?;\n pyo3_async_runtimes::tokio::into_future(function_output)\n })?\n .await?;\n\n Python::with_gil(|py| extract_response_type(output, py))\n } else {\n Python::with_gil(|py| {\n let output = get_function_output(function, py, request)?;\n extract_response_type_bound(output)\n })\n }\n}\n\n#[inline]\nfn extract_response_type(output: Py, py: Python) -> PyResult {\n // Try Response first (most common case), then StreamingResponse\n match output.extract::(py) {\n Ok(response) => Ok(ResponseType::Standard(response)),\n Err(_) => match output.extract::(py) {\n Ok(streaming_response) => Ok(ResponseType::Streaming(streaming_response)),\n Err(_) => Err(PyErr::new::(\n \"Function must return a Response or StreamingResponse\",\n )),\n },\n }\n}\n\n#[inline]\nfn extract_response_type_bound(output: pyo3::Bound<'_, pyo3::PyAny>) -> PyResult {\n match output.extract::() {\n Ok(response) => Ok(ResponseType::Standard(response)),\n Err(_) => match output.extract::() {\n Ok(streaming_response) => Ok(ResponseType::Streaming(streaming_response)),\n Err(_) => Err(PyErr::new::(\n \"Function must return a Response or StreamingResponse\",\n )),\n },\n }\n}\n\npub async fn execute_startup_handler(\n event_handler: Option>,\n task_locals: &TaskLocals,\n) -> Result<()> {\n if let Some(function) = event_handler {\n if function.is_async {\n Python::with_gil(|py| {\n pyo3_async_runtimes::into_future_with_locals(\n task_locals,\n function.handler.bind(py).call0()?,\n )\n })?\n .await?;\n } else {\n Python::with_gil(|py| function.handler.call0(py))?;\n }\n }\n Ok(())\n}\n"
},
{
"path": "src/executors/web_socket_executors.rs",
"content": "use actix::{ActorFutureExt, AsyncContext, WrapFuture};\nuse actix_web_actors::ws::WebsocketContext;\nuse pyo3::prelude::*;\nuse pyo3_async_runtimes::TaskLocals;\n\nuse crate::types::function_info::FunctionInfo;\nuse crate::websockets::WebSocketConnector;\n\npub fn execute_ws_function(\n function: &FunctionInfo,\n task_locals: &TaskLocals,\n ctx: &mut WebsocketContext,\n ws: &WebSocketConnector,\n) {\n if function.is_async {\n let fut = Python::with_gil(|py| {\n let handler = function.handler.bind(py).downcast().unwrap();\n pyo3_async_runtimes::into_future_with_locals(\n task_locals,\n handler.call1((ws.clone(),)).unwrap(),\n )\n .unwrap()\n });\n let f = async {\n let output = fut.await.unwrap();\n Python::with_gil(|py| output.extract::>(py).unwrap())\n }\n .into_actor(ws)\n .map(|res, _, ctx| {\n if let Some(msg) = res {\n ctx.text(msg);\n }\n });\n ctx.spawn(f);\n } else {\n Python::with_gil(|py| {\n let handler = function.handler.bind(py).downcast().unwrap();\n if let Some(op) = handler\n .call1((ws.clone(),))\n .unwrap()\n .extract::>()\n .unwrap()\n {\n ctx.text(op);\n }\n });\n }\n}\n"
},
{
"path": "src/io_helpers/mod.rs",
"content": "use std::fs::File;\nuse std::io::Read;\n\nuse actix_web::HttpResponseBuilder;\nuse anyhow::Result;\n\nuse crate::types::headers::Headers;\n\n// this should be something else\n// probably inside the submodule of the http router\n#[inline]\npub fn apply_hashmap_headers(response: &mut HttpResponseBuilder, headers: &Headers) {\n for iter in headers.headers.iter() {\n let (key, values) = iter.pair();\n for value in values {\n response.append_header((key.clone(), value.clone()));\n }\n }\n}\n\n/// A function to read lossy files and serve it as a html response\n///\n/// # Arguments\n///\n/// * `file_path` - The file path that we want the function to read\n///\n// ideally this should be async\npub fn read_file(file_path: &str) -> Result> {\n let mut file = File::open(file_path)?;\n let mut buf = vec![];\n file.read_to_end(&mut buf)?;\n Ok(buf)\n}\n"
},
{
"path": "src/lib.rs",
"content": "mod asyncio;\nmod blocking;\nmod callbacks;\nmod conversion;\nmod executors;\nmod io_helpers;\nmod routers;\nmod runtime;\nmod server;\nmod shared_socket;\nmod types;\nmod websockets;\n\nuse server::Server;\nuse shared_socket::SocketHeld;\n\n// pyO3 module\nuse pyo3::prelude::*;\nuse types::{\n cookie::{Cookie, Cookies, CookiesIter},\n function_info::{FunctionInfo, MiddlewareType},\n headers::Headers,\n identity::Identity,\n multimap::QueryParams,\n request::PyRequest,\n response::{PyResponse, PyStreamingResponse},\n HttpMethod, Url,\n};\n\nuse websockets::{registry::WebSocketRegistry, WebSocketChannel, WebSocketConnector};\n\n#[pyfunction]\nfn get_version() -> String {\n env!(\"CARGO_PKG_VERSION\").into()\n}\n\n#[pymodule]\npub fn robyn(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {\n // the pymodule class/function to make the rustPyFunctions available\n m.add_function(wrap_pyfunction!(get_version, m)?)?;\n\n m.add_class::()?;\n m.add_class::()?;\n m.add_class::()?;\n m.add_class::()?;\n m.add_class::()?;\n m.add_class::()?;\n m.add_class::()?;\n m.add_class::()?;\n m.add_class::()?;\n m.add_class::()?;\n m.add_class::()?;\n m.add_class::()?;\n m.add_class::()?;\n m.add_class::()?;\n m.add_class::()?;\n m.add_class::()?;\n m.add_class::()?;\n m.add_class::()?;\n\n // Register awaitable types\n m.add_class::()?;\n m.add_class::()?;\n m.add_class::()?;\n m.add_class::()?;\n m.add_class::()?;\n\n Ok(())\n}\n"
},
{
"path": "src/routers/const_router.rs",
"content": "use actix_http::StatusCode;\nuse actix_web::{web::Bytes, HttpResponse, HttpResponseBuilder};\nuse parking_lot::RwLock;\nuse std::collections::HashMap;\nuse std::sync::Arc;\n\nuse crate::executors::execute_http_function;\nuse crate::types::cookie::Cookies;\nuse crate::types::function_info::FunctionInfo;\nuse crate::types::headers::Headers;\nuse crate::types::request::Request;\nuse crate::types::response::Response;\nuse crate::types::HttpMethod;\nuse anyhow::Context;\nuse matchit::Router as MatchItRouter;\nuse pyo3::{Bound, PyErr, Python};\n\nuse anyhow::{Error, Result};\n\nuse crate::routers::Router;\n\n/// Pre-built response for const routes — zero per-request allocation.\n/// Headers (including global response headers) are baked in at startup.\n#[derive(Clone)]\npub struct CachedResponse {\n pub status: StatusCode,\n pub headers: Arc>,\n pub body: Bytes,\n route_header_count: usize,\n}\n\nimpl CachedResponse {\n fn from_response(response: &Response) -> Self {\n let mut headers = Vec::new();\n for entry in response.headers.headers.iter() {\n let (key, values) = entry.pair();\n for value in values {\n headers.push((key.clone(), value.clone()));\n }\n }\n for (name, cookie) in &response.cookies.cookies {\n if let Ok(header_value) = cookie.to_header_value(name) {\n headers.push((\"set-cookie\".to_string(), header_value));\n }\n }\n let route_header_count = headers.len();\n Self {\n status: StatusCode::from_u16(response.status_code)\n .unwrap_or(StatusCode::INTERNAL_SERVER_ERROR),\n headers: Arc::new(headers),\n body: Bytes::from(response.description.clone()),\n route_header_count,\n }\n }\n\n #[inline(always)]\n pub fn to_http_response(&self) -> HttpResponse {\n let mut builder = HttpResponseBuilder::new(self.status);\n for (k, v) in self.headers.as_ref() {\n builder.append_header((k.as_str(), v.as_str()));\n }\n builder.body(self.body.clone())\n }\n\n #[inline(always)]\n pub fn to_http_response_without_global_headers(&self) -> HttpResponse {\n let mut builder = HttpResponseBuilder::new(self.status);\n for (k, v) in self.headers.as_ref().iter().take(self.route_header_count) {\n builder.append_header((k.as_str(), v.as_str()));\n }\n builder.body(self.body.clone())\n }\n}\n\ntype RouteMap = RwLock>;\n\n/// Fast const-route lookup table: exact path → CachedResponse.\n/// Uses a simple HashMap (no regex, no path params, no RwLock per lookup).\ntype FastMap = RwLock>;\n\npub struct ConstRouter {\n routes: HashMap>,\n fast_routes: HashMap>,\n}\n\nimpl Router for ConstRouter {\n fn add_route<'py>(\n &self,\n _py: Python,\n route_type: &HttpMethod,\n route: &str,\n function: FunctionInfo,\n event_loop: Option>,\n ) -> Result<(), Error> {\n let table = Arc::clone(self.routes.get(route_type).context(\"No relevant map\")?);\n let fast_table = Arc::clone(\n self.fast_routes\n .get(route_type)\n .context(\"No relevant fast map\")?,\n );\n\n let route = route.to_string();\n let event_loop =\n event_loop.context(\"Event loop must be provided to add a route to the const router\")?;\n\n pyo3_async_runtimes::tokio::run_until_complete(event_loop, async move {\n let output = execute_http_function(&Request::default(), &function)\n .await\n .unwrap();\n match output {\n crate::types::response::ResponseType::Standard(response) => {\n let cached = CachedResponse::from_response(&response);\n table.write().insert(route.clone(), cached.clone()).unwrap();\n fast_table.write().insert(route, cached);\n }\n crate::types::response::ResponseType::Streaming(_) => {\n return Err(PyErr::new::(\n \"Streaming responses are not supported for const routes\",\n )\n .into());\n }\n }\n Ok(())\n })?;\n\n Ok(())\n }\n\n fn get_route(&self, route_method: &HttpMethod, route: &str) -> Option {\n let cached = self.get_cached_route(route_method, route)?;\n let mut resp = Response {\n status_code: cached.status.as_u16(),\n response_type: \"text\".to_string(),\n headers: Headers::new(None),\n description: cached.body.to_vec(),\n file_path: None,\n cookies: Cookies::new(),\n };\n for (k, v) in cached.headers.as_ref() {\n resp.headers.set(k.clone(), v.clone());\n }\n Some(resp)\n }\n}\n\nimpl ConstRouter {\n pub fn new() -> Self {\n let mut routes = HashMap::new();\n let mut fast_routes = HashMap::new();\n for method in [\n HttpMethod::GET,\n HttpMethod::POST,\n HttpMethod::PUT,\n HttpMethod::DELETE,\n HttpMethod::PATCH,\n HttpMethod::HEAD,\n HttpMethod::OPTIONS,\n HttpMethod::CONNECT,\n HttpMethod::TRACE,\n ] {\n routes.insert(method.clone(), Arc::new(RwLock::new(MatchItRouter::new())));\n fast_routes.insert(method, Arc::new(RwLock::new(HashMap::new())));\n }\n Self {\n routes,\n fast_routes,\n }\n }\n\n /// Bake global response headers into all cached responses.\n /// Called once at server start, after global headers are set.\n pub fn bake_global_headers(&self, global_headers: &Headers) {\n let mut extra_headers: Vec<(String, String)> = Vec::new();\n for entry in global_headers.headers.iter() {\n let (key, values) = entry.pair();\n for value in values {\n extra_headers.push((key.clone(), value.clone()));\n }\n }\n if extra_headers.is_empty() {\n return;\n }\n for (method, fast_table) in &self.fast_routes {\n let mut map = fast_table.write();\n for cached in map.values_mut() {\n let mut combined = cached.headers.as_ref().clone();\n combined.extend(extra_headers.iter().cloned());\n cached.headers = Arc::new(combined);\n }\n\n if let Some(route_table) = self.routes.get(method) {\n let mut new_router = MatchItRouter::new();\n for (route, cached) in map.iter() {\n let _ = new_router.insert(route.clone(), cached.clone());\n }\n *route_table.write() = new_router;\n }\n }\n }\n\n /// Fast lookup: tries exact HashMap first, falls back to matchit for parameterized/wildcard routes.\n #[inline(always)]\n pub fn get_cached_route(\n &self,\n route_method: &HttpMethod,\n route: &str,\n ) -> Option {\n let fast_table = self.fast_routes.get(route_method)?;\n {\n let map = fast_table.read();\n if let Some(cached) = map.get(route) {\n return Some(cached.clone());\n }\n }\n\n let route_table = self.routes.get(route_method)?;\n let router = route_table.read();\n router.at(route).ok().map(|matched| matched.value.clone())\n }\n}\n"
},
{
"path": "src/routers/http_router.rs",
"content": "use parking_lot::RwLock;\nuse pyo3::{Bound, Python};\nuse std::collections::HashMap;\n\nuse matchit::Router as MatchItRouter;\n\nuse anyhow::{Context, Result};\n\nuse crate::routers::Router;\nuse crate::types::function_info::FunctionInfo;\nuse crate::types::HttpMethod;\n\ntype RouteMap = RwLock>;\n\n/// Contains the thread safe hashmaps of different routes\npub struct HttpRouter {\n routes: HashMap,\n}\n\nimpl Router<(FunctionInfo, HashMap), HttpMethod> for HttpRouter {\n fn add_route<'py>(\n &self,\n _py: Python,\n route_type: &HttpMethod,\n route: &str,\n function: FunctionInfo,\n _event_loop: Option>,\n ) -> Result<()> {\n let table = self.routes.get(route_type).context(\"No relevant map\")?;\n\n // try removing unwrap here\n table.write().insert(route.to_string(), function)?;\n\n Ok(())\n }\n\n fn get_route(\n &self,\n route_method: &HttpMethod,\n route: &str,\n ) -> Option<(FunctionInfo, HashMap)> {\n let table = self.routes.get(route_method)?;\n\n let table_lock = table.read();\n\n // Trying route matching just once.\n if let Ok(res) = table_lock.at(route) {\n let mut route_params = HashMap::new();\n for (key, value) in res.params.iter() {\n route_params.insert(key.to_string(), value.to_string());\n }\n\n let function_info = Python::with_gil(|_| res.value.to_owned());\n return Some((function_info, route_params));\n }\n\n None\n }\n}\n\nimpl HttpRouter {\n pub fn new() -> Self {\n let mut routes = HashMap::new();\n routes.insert(HttpMethod::GET, RwLock::new(MatchItRouter::new()));\n routes.insert(HttpMethod::POST, RwLock::new(MatchItRouter::new()));\n routes.insert(HttpMethod::PUT, RwLock::new(MatchItRouter::new()));\n routes.insert(HttpMethod::DELETE, RwLock::new(MatchItRouter::new()));\n routes.insert(HttpMethod::PATCH, RwLock::new(MatchItRouter::new()));\n routes.insert(HttpMethod::HEAD, RwLock::new(MatchItRouter::new()));\n routes.insert(HttpMethod::OPTIONS, RwLock::new(MatchItRouter::new()));\n routes.insert(HttpMethod::CONNECT, RwLock::new(MatchItRouter::new()));\n routes.insert(HttpMethod::TRACE, RwLock::new(MatchItRouter::new()));\n Self { routes }\n }\n}\n"
},
{
"path": "src/routers/middleware_router.rs",
"content": "use std::collections::HashMap;\nuse std::sync::atomic::{AtomicBool, Ordering};\nuse std::sync::RwLock;\n\nuse anyhow::{Context, Error, Result};\nuse matchit::Router as MatchItRouter;\nuse pyo3::{Bound, Python};\n\nuse crate::routers::Router;\nuse crate::types::function_info::{FunctionInfo, MiddlewareType};\n\ntype RouteMap = RwLock>;\n\npub struct MiddlewareRouter {\n globals: HashMap>>,\n routes: HashMap,\n has_middleware: AtomicBool,\n}\n\nimpl Router<(FunctionInfo, HashMap), MiddlewareType> for MiddlewareRouter {\n fn add_route<'py>(\n &self,\n _py: Python,\n route_type: &MiddlewareType,\n route: &str,\n function: FunctionInfo,\n _event_loop: Option>,\n ) -> Result<(), Error> {\n let table = self.routes.get(route_type).context(\"No relevant map\")?;\n\n table.write().unwrap().insert(route.to_string(), function)?;\n self.has_middleware.store(true, Ordering::Release);\n\n Ok(())\n }\n\n fn get_route(\n &self,\n route_method: &MiddlewareType,\n route: &str,\n ) -> Option<(FunctionInfo, HashMap)> {\n let table = self.routes.get(route_method)?;\n\n let table_lock = table.read().ok()?;\n let res = table_lock.at(route).ok()?;\n let mut route_params = HashMap::new();\n for (key, value) in res.params.iter() {\n route_params.insert(key.to_string(), value.to_string());\n }\n\n let function_info = Python::with_gil(|_| res.value.to_owned());\n\n Some((function_info, route_params))\n }\n}\n\nimpl MiddlewareRouter {\n pub fn new() -> Self {\n let mut globals = HashMap::new();\n globals.insert(MiddlewareType::BeforeRequest, RwLock::new(vec![]));\n globals.insert(MiddlewareType::AfterRequest, RwLock::new(vec![]));\n let mut routes = HashMap::new();\n routes.insert(\n MiddlewareType::BeforeRequest,\n RwLock::new(MatchItRouter::new()),\n );\n routes.insert(\n MiddlewareType::AfterRequest,\n RwLock::new(MatchItRouter::new()),\n );\n Self {\n globals,\n routes,\n has_middleware: AtomicBool::new(false),\n }\n }\n\n pub fn add_global_middleware(\n &self,\n middleware_type: &MiddlewareType,\n function: FunctionInfo,\n ) -> Result<()> {\n self.globals\n .get(middleware_type)\n .context(\"No relevant map\")?\n .write()\n .unwrap()\n .push(function);\n self.has_middleware.store(true, Ordering::Release);\n Ok(())\n }\n\n pub fn get_global_middlewares(&self, middleware_type: &MiddlewareType) -> Vec {\n self.globals\n .get(middleware_type)\n .unwrap()\n .read()\n .unwrap()\n .to_vec()\n }\n\n pub fn has_any_middleware(&self) -> bool {\n self.has_middleware.load(Ordering::Acquire)\n }\n}\n"
},
{
"path": "src/routers/mod.rs",
"content": "use anyhow::Result;\nuse pyo3::{Bound, Python};\n\nuse crate::types::function_info::FunctionInfo;\n\npub mod const_router;\npub mod http_router;\npub mod middleware_router;\npub mod web_socket_router;\n\npub trait Router {\n /// Checks if the functions is an async function\n /// Inserts them in the router according to their nature(CoRoutine/SyncFunction)\n fn add_route<'py>(\n &self,\n py: Python,\n route_type: &U,\n route: &str,\n function: FunctionInfo,\n event_loop: Option>,\n ) -> Result<()>;\n\n /// Retrieve the correct function from the previously inserted routes\n fn get_route(&self, route_type: &U, route: &str) -> Option;\n}\n"
},
{
"path": "src/routers/web_socket_router.rs",
"content": "use parking_lot::RwLock;\nuse std::collections::HashMap;\n\nuse log::debug;\n\nuse crate::types::function_info::FunctionInfo;\n\n/// Contains the thread safe hashmaps of different routes\ntype WebSocketRoutes = RwLock>>;\n\npub struct WebSocketRouter {\n web_socket_routes: WebSocketRoutes,\n}\n\nimpl WebSocketRouter {\n pub fn new() -> Self {\n Self {\n web_socket_routes: RwLock::new(HashMap::new()),\n }\n }\n\n #[inline]\n pub fn get_web_socket_map(&self) -> &WebSocketRoutes {\n &self.web_socket_routes\n }\n\n pub fn add_websocket_route(\n &self,\n route: &str,\n connect_route: FunctionInfo,\n close_route: FunctionInfo,\n message_route: FunctionInfo,\n ) {\n let table = self.get_web_socket_map();\n\n let insert_in_router = |function: FunctionInfo, socket_type: &str| {\n debug!(\"socket type is {:?} {:?}\", table, route);\n\n table\n .write()\n .entry(route.to_string())\n .or_default()\n .insert(socket_type.to_string(), function)\n };\n\n insert_in_router(connect_route, \"connect\");\n insert_in_router(close_route, \"close\");\n insert_in_router(message_route, \"message\");\n }\n}\n"
},
{
"path": "src/runtime.rs",
"content": "use futures::FutureExt;\nuse pyo3::{prelude::*, IntoPyObjectExt};\nuse std::{future::Future, sync::Arc, sync::OnceLock};\nuse tokio::{runtime::Builder as RuntimeBuilder, task::JoinHandle};\n\n#[cfg(unix)]\nuse super::callbacks::PyFutureAwaitable;\n#[cfg(windows)]\nuse super::callbacks::{PyFutureDoneCallback, PyFutureResultSetter};\n\nuse super::blocking::BlockingRunner;\nuse super::callbacks::{PyDoneAwaitable, PyEmptyAwaitable, PyErrAwaitable, PyIterAwaitable};\nuse super::conversion::FutureResultToPy;\n\npub trait JoinError {\n #[allow(dead_code)]\n fn is_panic(&self) -> bool;\n}\n\npub trait Runtime: Send + 'static {\n type JoinError: JoinError + Send;\n type JoinHandle: Future
![](\"https://i.imgur.com/7wapvt2.png\")
![](\"https://hisham.hm/img/posts/github-comparepr.png\")
![](\"https://github.blog/wp-content/uploads/2019/02/draft-pull-requests.png?fit=1354%2C780\")
![](\"https://www.stevejgordon.co.uk/wp-content/uploads/2018/01/GitHubIssueTab.png\")
![](\"https://miro.medium.com/max/3696/1*8jiGiKhMdVQDycWSAbjB8A.png\")
![](\"https://i.imgur.com/xz2KAwU.png\")
![](\"https://i.imgur.com/XwjtGG1.png\")
![\"Robyn](\"https://user-images.githubusercontent.com/29942790/140995889-5d91dcff-3aa7-4cfb-8a90-2cddf1337dca.png\")
![](\"https://robyn.tech/architecture/architecture.png\")
\n\n"
},
{
"path": "docs_src/src/pages/documentation/en/community-resources.mdx",
"content": "export const description =\n 'On this page, we`ll take a look at some community resources contributed by our amazing members to help developers get started with Robyn.'\n\n\n## Talks\n- [EuroPython 2022](https://www.youtube.com/watch?v=AutugvJNVkY&)\n- [GeoPython 2022](https://www.youtube.com/watch?v=YCpbCQwbkd4)\n- [PyCon US 2022](https://youtu.be/1IiL31tUEVk?t=2101)\n- [PyCon Sweden 2021](https://www.youtube.com/watch?v=DK9teAs72Do)\n\n## Blogs\n- [Hello, Robyn!](https://www.sanskar.me/posts/hello-robyn)\n\n\n## Next Steps\n\nBatman was now interes\n\n- [Hosting](/documentation/hosting)\n\n"
},
{
"path": "docs_src/src/pages/documentation/en/example_app/authentication-middlewares.mdx",
"content": "export const description =\n 'Welcome to the Robyn API documentation. You will find comprehensive guides and documentation to help you start working with Robyn as quickly as possible, as well as support if you get stuck.'\n\n## Authentication and Authorization Middleware\nBatman added middleware to the Robyn application to verify the JWT tokens and to restrict access to certain endpoints based on the user's role.\n\n\n```python {{ title: 'Setting up Authentication Middlewares' }}\nfrom robyn.authentication import AuthenticationHandler, BearerGetter, Identity\n\n\nclass BasicAuthHandler(AuthenticationHandler):\n def authenticate(self, request: Request):\n token = self.token_getter.get_token(request)\n\n try:\n payload = crud.decode_access_token(token)\n username = payload[\"sub\"]\n except Exception:\n return\n\n with SessionLocal() as db:\n user = crud.get_user_by_username(db, username=username)\n\n return Identity(claims={\"user\": f\"{ user }\"})\n\n\napp.configure_authentication(BasicAuthHandler(token_getter=BearerGetter()))\n\n\n@app.get(\"/users/me\", auth_required=True)\nasync def get_current_user(request):\n user = request.identity.claims[\"user\"]\n return user\n\n\n```\n\nWith the web application in place, the Gotham City Police Department could now efficiently manage crime data and track criminal activities in real-time. Batman had successfully used the Robyn web framework to build a real-world application to help fight crime in Gotham City.\n\n\n\n\n\n \n\n\n"
},
{
"path": "docs_src/src/pages/documentation/en/example_app/authentication.mdx",
"content": "export const description =\n 'Welcome to the Robyn API documentation. You will find comprehensive guides and documentation to help you start working with Robyn as quickly as possible, as well as support if you get stuck.'\n\n## Authentication and Authorization\nTo restrict access to the crime data, Batman added authentication and authorization to the application. He decided to use JWT (JSON Web Token) for authentication. He created a new table for users and added an endpoint for user registration.\n\n\n## User Model\n\nBatman added a new User model to represent the users who can access the application.\n\n\n```python {{ title: 'Example request with basic auth' }}\n# models.py\nfrom sqlalchemy import Column, Integer, String, Boolean\n\nclass User(Base):\n __tablename__ = \"users\"\n\n id = Column(Integer, primary_key=True, index=True)\n username = Column(String, unique=True, index=True)\n hashed_password = Column(String)\n\n \n def __repr__(self):\n return \"\n \n\n"
},
{
"path": "docs_src/src/pages/documentation/en/example_app/deployment.mdx",
"content": "export const description =\n 'Welcome to the Robyn API documentation. You will find comprehensive guides and documentation to help you start working with Robyn as quickly as possible, as well as support if you get stuck.'\n\n\n## Deploying the Application\n\nAfter thoroughly testing the web application and ensuring that all features were working as expected, Batman decided it was time to deploy it to a production server. He chose to use a robust and scalable platform, ensuring that his application would be available and performant at all times.\n\n\n```python {{ title: 'Deploying the Application' }}\npython app.py --processes=n --workers=m\n```\n\nWith the web application deployed and running smoothly, Batman had a powerful new tool at his disposal. The Robyn framework had provided him with the flexibility, scalability, and performance needed to create an effective crime-fighting application, giving him a technological edge in his ongoing battle to protect Gotham City.\n\n\n\n \n\n\n\n"
},
{
"path": "docs_src/src/pages/documentation/en/example_app/index.mdx",
"content": "export const description =\n 'Welcome to the Robyn API documentation. You will find comprehensive guides and documentation to help you start working with Robyn as quickly as possible, as well as support if you get stuck.'\n\n# Real Life Web Apps with Robyn\n\nBatman was tasked with building a web application to manage the crime data in Gotham City. The application would allow the Gotham police department to store and retrieve data on criminal activities, suspects, and their locations. He decided to use the Robyn web framework to build this application efficiently and quickly.\n\nYou can find the source code for this application [here](https://github.com/sparckles/example_robyn_app).\n\n## Installing Robyn\n\nThe first step was to install Robyn. Batman created a virtual environment and installed Robyn using pip.\n\n```bash\n$ python3 -m venv venv\n$ source venv/bin/activate\n$ pip install robyn\n```\n\n## Creating a Robyn Application\n\nBatman wanted to create a Robyn app and was about to create an `src/app.py` before he was told that Robyn comes with a CLI tool to create a new application. He ran the following command to create a new Robyn application.\n\n```bash\n$ python -m robyn --create\n```\n\nThis, would result in the following output.\n\n```bash\n$ python3 -m robyn --create\n? Directory Path: .\n? Need Docker? (Y/N) Y\n? Please select project type (Mongo/Postgres/Sqlalchemy/Prisma):\n❯ No DB\n Sqlite\n Postgres\n MongoDB\n SqlAlchemy\n Prisma\n```\n\nand the following directory structure.\n\n\nBatman was asked a set of questions to configure the application. He chose to use the default values for most of the questions.\n\nAnd he was done! The Robyn CLI created a new application with the following structure.\n\n```bash\n\n├── src\n│ ├── app.py\n├── Dockerfile\n\n```\n\n\n\n \n\n"
},
{
"path": "docs_src/src/pages/documentation/en/example_app/modeling_routes.mdx",
"content": "export const description =\n 'Welcome to the Robyn API documentation. You will find comprehensive guides and documentation to help you start working with Robyn as quickly as possible, as well as support if you get stuck.'\n\n\n## Crime Data Model and Database Connection\n\nBatman designed a data model to represent crime data, including information about the crime, suspect, and location. He decided to use a SQLite database to store the data and used an ORM (Object Relational Mapping) library to interact with the database.\n\n\n```python\n# models.py\nfrom sqlalchemy import create_engine, Column, Integer, String, DateTime, Float\nfrom sqlalchemy.orm import declarative_base, sessionmaker\n\nDATABASE_URL = \"sqlite:///./gotham_crime_data.db\"\n\nengine = create_engine(DATABASE_URL)\nSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)\n\n\nBase = declarative_base()\n\nclass Crime(Base):\n __tablename__ = \"crimes\"\n\n id = Column(Integer, primary_key=True, index=True)\n type = Column(String, index=True)\n description = Column(String)\n location = Column(String)\n suspect_name = Column(String)\n date_time = Column(DateTime)\n latitude = Column(Float)\n longitude = Column(Float)\n\n```\n\n\n## Setting up the Robyn Application\n\nBatman set up a Robyn application and configured it to use the database session to access the SQLite database.\n\n\nBased on the Database model, Batman created a few helper methods to interact with the database. These methods would be used by the endpoints to perform CRUD operations on the database.\n\n```python {{ title: 'crud.py' }}\n# crud.py\nfrom sqlalchemy.orm import Session\nfrom .models import Crime\n\n\ndef get_crime(db: Session, crime_id: int):\n return db.query(Crime).filter(Crime.id == crime_id).first()\n\ndef get_crimes(db: Session, skip: int = 0, limit: int = 100):\n return db.query(Crime).offset(skip).limit(limit).all()\n\ndef create_crime(db: Session, crime):\n db_crime = Crime(**crime)\n db.add(db_crime)\n db.commit()\n db.refresh(db_crime)\n return db_crime\n\ndef update_crime(db: Session, crime_id: int, crime):\n db_crime = get_crime(db, crime_id)\n if db_crime is None:\n return None\n for key, value in crime.items():\n setattr(db_crime, key, value)\n db.commit()\n db.refresh(db_crime)\n return db_crime\n\ndef delete_crime(db: Session, crime_id: int):\n db_crime = get_crime(db, crime_id)\n if db_crime is None:\n return False\n db.delete(db_crime)\n db.commit()\n return True\n\n```\n\n\n## Crime Data Endpoints\n\nBatman created various endpoints to manage crime data. These endpoints allowed the Gotham City Police Department to add, update, and retrieve crime data.\n\n```python {{ title: 'Setting up Routes' }}\n# __main__.py\nfrom robyn import Robyn\nfrom robyn.robyn import Request, Response\nfrom sqlalchemy.orm import Session\n\napp = Robyn(__file__)\n\n@app.post(\"/crimes\")\nasync def add_crime(request):\n with SessionLocal() as db:\n crime = request.json()\n insertion = crud.create_crime(db, crime)\n\n if insertion is None:\n raise Exception(\"Crime not added\")\n\n return {\n \"description\": \"Crime added successfully\",\n \"status_code\": 200,\n }\n\n@app.get(\"/crimes\")\nasync def get_crimes(request):\n with SessionLocal() as db:\n skip = request.query_params.get(\"skip\", \"0\")\n limit = request.query_params.get(\"limit\", \"100\")\n crimes = crud.get_crimes(db, skip=skip, limit=limit)\n\n return crimes\n\n@app.get(\"/crimes/:crime_id\", auth_required=True)\nasync def get_crime(request):\n crime_id = int(request.path_params.get(\"crime_id\"))\n with SessionLocal() as db:\n crime = crud.get_crime(db, crime_id=crime_id)\n\n if crime is None:\n raise Exception(\"Crime not found\")\n\n return crime\n\n@app.put(\"/crimes/:crime_id\")\nasync def update_crime(request):\n crime = request.json()\n crime_id = int(request.path_params.get(\"crime_id\"))\n with SessionLocal() as db:\n updated_crime = crud.update_crime(db, crime_id=crime_id, crime=crime)\n if updated_crime is None:\n raise Exception(\"Crime not found\")\n return updated_crime\n\n@app.delete(\"/crimes/{crime_id}\")\nasync def delete_crime(request):\n crime_id = int(request.path_params.get(\"crime_id\"))\n with SessionLocal() as db:\n success = crud.delete_crime(db, crime_id=crime_id)\n if not success:\n raise Exception(\"Crime not found\")\n return {\"message\": \"Crime deleted successfully\"}\n\n\n```\n\n\n\n \n\n"
},
{
"path": "docs_src/src/pages/documentation/en/example_app/monitoring_and_logging.mdx",
"content": "\n## Monitoring and Logging\nTo keep an eye on the performance of his application and troubleshoot issues, Batman decided to implement monitoring and logging. He used a third-party library to integrate logging middleware, enabling him to track requests, errors, and performance metrics.\n\n```python {{ title: 'Monitoring and Logging' }}\nfrom robyn import Logger\n\nlogger = Logger(app)\n\n@app.before_request()\nasync def log_request(request: Request):\n logger.info(f\"Received request: %s\", request)\n\n@app.after_request()\nasync def log_response(response: Response):\n logger.info(f\"Sending response: %s\", response)\n```\n\nWith monitoring and logging in place, Batman could now easily detect issues and analyze the performance of his web application, ensuring that it was always running optimally and ready to assist him in his fight against crime.\n\n\n\n \n\n\n"
},
{
"path": "docs_src/src/pages/documentation/en/example_app/openapi.mdx",
"content": "export const description =\n 'Welcome to the Robyn API documentation. You will find comprehensive guides and documentation to help you start working with Robyn as quickly as possible, as well as support if you get stuck.'\n\n\n## OpenAPI Docs a.k.a Swagger\n\nAfter deploying the application, Batman got multiple queries from the users on how to use the endpoints. Robyn showed him how to generate OpenAPI specifications for his application.\n\nOut of the box, the following endpoints are setup for you:\n\n- `/docs` The Swagger UI\n- `/openapi.json` The JSON Specification\n\nHowever, if you don't want to generate the OpenAPI docs, you can disable it by passing `--disable-openapi` flag while starting the application.\n\nTo use a custom openapi configuration, you can:\n\n - Place the `openapi.json` config file in the root directory.\n - Or, pass the file path to the `openapi_file_path` parameter in the `Robyn()` constructor. (the parameter gets priority over the file).\n\n```bash\npython app.py --disable-openapi\n```\n\n## How to use?\n\n- Query Params: The typing for query params can be added as `def get(r: Request, query_params: GetRequestParams)` where `GetRequestParams` is a subclass of `QueryParams`\n- Path Params are defaulted to string type (ref: https://en.wikipedia.org/wiki/Query_string)\n\n\n \n\n\n\n"
},
{
"path": "docs_src/src/pages/documentation/en/example_app/real_time_notifications.mdx",
"content": "export const description =\n 'Welcome to the Robyn API documentation. You will find comprehensive guides and documentation to help you start working with Robyn as quickly as possible, as well as support if you get stuck.'\n\n## Real time notifications\nBatman decided to implement real-time notifications for police officers using WebSockets. This would allow officers to receive instant updates on criminal activities, as well as alerts when a new crime is reported.\n\n\n\n```python {{ title: 'Setting up Real-time Notifications' }}\nfrom robyn import WebSocketDisconnect\n\n@app.websocket(\"/notifications\")\nasync def notify_handler(websocket):\n try:\n while True:\n message = await websocket.receive_text()\n await websocket.send_text(f\"Received: {message}\")\n except WebSocketDisconnect:\n pass\n\n@notify_handler.on_connect\ndef notify_connect(websocket):\n return \"Connected to notifications\"\n\n@notify_handler.on_close\ndef notify_close(websocket):\n return \"Disconnected from notifications\"\n\n```\n\n## Advanced Search and Filtering \n\nTo make it easier for the police officers to search for specific crimes or criminals, Batman added advanced search and filtering options to the application. He implemented a new endpoint that allows users to search based on various criteria like crime type, date, location, and status.\n\n\n```python {{ title: 'Advanced Search and Filtering' }}\n@app.get(\"/crimes/search\")\nasync def search_crimes(request):\n crime_type = request.query_params.get(\"crime_type\")\n date = request.query_params.get(\"date\")\n location = request.query_params.get(\"location\")\n status = request.query_params.get(\"status\")\n\n crimes = crud.search_crimes(db, crime_type=crime_type, date=date, location=location, status=status)\n return crimes\n\n```\n\n\nWith the new features in place, the Gotham City Police Department was able to use the web application more effectively to track criminal activities and deploy resources efficiently. Batman's work on the Robyn web framework had a significant impact on Gotham City's crime-fighting efforts, making it a safer place for its citizens.\n\nAlthough Batman had achieved great success with the current implementation, he knew that there would always be room for improvement and new features to add. But for now, he could take a moment to appreciate his work and focus on his primary duty - protecting Gotham City as the Dark Knight.\n\n\n\n\n\n\n \n\n"
},
{
"path": "docs_src/src/pages/documentation/en/example_app/subrouters.mdx",
"content": "export const description =\n 'Welcome to the Robyn API documentation. You will find comprehensive guides and documentation to help you start working with Robyn as quickly as possible, as well as support if you get stuck.'\n\n## Code Organization with SubRouters\n\nAs the application grew, Batman needed a way to organize his routes better. He decided to use Robyn's SubRouter feature to group related routes together.\n\n```python\nfrom robyn import SubRouter\n\n# Create a subrouter for crime-related routes\ncrime_router = SubRouter(__file__, prefix=\"/crimes\")\n\n@crime_router.get(\"/list\")\ndef list_crimes():\n return {\"crimes\": get_all_crimes()}\n\n@crime_router.post(\"/report\")\ndef report_crime(request):\n crime_data = request.json()\n return {\"id\": create_crime_report(crime_data)}\n\n# Create a subrouter for suspect-related routes\nsuspect_router = SubRouter(__file__, prefix=\"/suspects\")\n\n@suspect_router.get(\"/list\")\ndef list_suspects():\n return {\"suspects\": get_all_suspects()}\n\n@suspect_router.get(\"/:id\")\ndef get_suspect(request, path_params):\n suspect_id = path_params.id\n return {\"suspect\": get_suspect_by_id(suspect_id)}\n\n# Include the subrouters in the main app\napp.include_router(crime_router)\napp.include_router(suspect_router)\n```\n\nSubRouters help organize related routes under a common prefix, making the code more maintainable and easier to understand. In this example:\n\n- All crime-related routes are under `/crimes`\n- All suspect-related routes are under `/suspects`\n\nThis organization makes it clear which routes handle what functionality and keeps related code together.\n\n\n\n\n\n\n\n"
},
{
"path": "docs_src/src/pages/documentation/en/example_app/templates.mdx",
"content": "export const description =\n 'Welcome to the Robyn API documentation. You will find comprehensive guides and documentation to help you start working with Robyn as quickly as possible, as well as support if you get stuck.'\n\n\n## Templates\n\nAfter implementing the backend, Batman decided to add a frontend to his application. He wanted to create a simple web page that would allow him to view the data he had collected. He also wanted to be able to add new data to the database and edit existing data.\n\nThis is when he was introduced to templates!\n\nTemplates are a powerful feature of the Robyn framework that allow you to create dynamic web pages using HTML and Python. They are a great way to add a frontend to your application without having to learn a new language or framework.\n\nRobyn supports Jinja2 templates by default but provides an easy way to add other templating engines as well.\n\n### Creating a Template\n\nTo create a template, you need to create a file with the `.html` extension in the a directory, usually it is convention to use the `templates` directory. For example, if you wanted to create a template called `index.html`, you would create a file called `index.html` in the `templates` directory.\n\nSo the folder structure would look like this:\n\n```bash\n├── app.py\n├── templates\n│ └── index.html\n├── Dockerfile\n└── requirements.txt\n\n```\n\n### Rendering a Template\n\nOnce you have created a template, you can render it by using the `render_template` function. This function takes the name of the template as its first argument and a dictionary of variables as its second argument.\n\nFor example, if you wanted to render the `index.html` template, you would use the following code:\n\n```python {{ title: 'Rendering a Template' }}\n\nimport os\nimport pathlib\nfrom robyn.templating import JinjaTemplate\n\n\ncurrent_file_path = pathlib.Path(__file__).parent.resolve()\njinja_template = JinjaTemplate(os.path.join(current_file_path, \"templates\"))\n\n@app.get(\"/frontend\")\nasync def get_frontend(request):\n context = {\"framework\": \"Robyn\", \"templating_engine\": \"Jinja2\"}\n return jinja_template.render_template(\"index.html\", **context)\n\napp.include_router(frontend)\n```\n\n\nNow Batman very happy that the application had come to completion. However, he was not satisfied with the current state of the application. He felt the code was all crammed in a single file and asked Robyn if there was a way to split the codebase in other parts.\n\nThis is Robyn introduced him to the concept of routers and views.\n\n\n \n\n\n\n\n"
},
{
"path": "docs_src/src/pages/documentation/en/example_app/zh/index.mdx",
"content": "export const description =\n '欢迎来到Robyn API文档。您将找到全面的指南和文档，帮助您尽快开始使用Robyn，并在遇到困难时获得支持。'\n\n# 使用Robyn构建实际应用\n\n蝙蝠侠被委托开发一个Web应用程序来管理哥谭市的犯罪数据。该应用程序将允许哥谭警察局存储和检索有关犯罪活动、嫌疑人及其位置的数据。他决定使用Robyn Web框架来高效快速地构建这个应用程序。\n\n您可以在[这里](https://github.com/sparckles/example_robyn_app)找到此应用程序的源代码。\n\n## 安装Robyn\n\n第一步是安装Robyn。蝙蝠侠创建了一个虚拟环境并使用pip安装了Robyn。\n\n```bash\n$ python3 -m venv venv\n$ source venv/bin/activate\n$ pip install robyn\n```\n\n## 创建Robyn应用程序\n\n蝙蝠侠正准备创建一个`src/app.py`文件，这时他得知Robyn提供了一个CLI工具来创建新应用程序。他运行以下命令来创建一个新的Robyn应用程序：\n\n```bash\n$ python -m robyn --create\n```\n\n这个示例应用程序将展示如何：\n\n- 设计和实现RESTful API\n- 处理身份验证和授权\n- 使用中间件进行请求处理\n- 实现实时通知\n- 设置监控和日志记录\n- 部署应用程序\n- 生成API文档\n- 组织和构建可维护的代码 "
},
{
"path": "docs_src/src/pages/documentation/en/example_app/zh/subrouters.mdx",
"content": "export const description =\n '欢迎来到Robyn API文档。您将找到全面的指南和文档，帮助您尽快开始使用Robyn，并在遇到困难时获得支持。'\n\n## 使用SubRouters组织代码\n\n随着应用程序的增长，蝙蝠侠需要一种更好的方式来组织他的路由。他决定使用Robyn的SubRouter功能来对相关路由进行分组。\n\n```python\nfrom robyn import SubRouter\n\n# 创建处理犯罪相关路由的子路由器\ncrime_router = SubRouter(__file__, prefix=\"/crimes\")\n\n@crime_router.get(\"/list\")\ndef list_crimes():\n return {\"crimes\": get_all_crimes()}\n\n@crime_router.post(\"/report\")\ndef report_crime(request):\n crime_data = request.json()\n return {\"id\": create_crime_report(crime_data)}\n\n# 创建处理嫌疑人相关路由的子路由器\nsuspect_router = SubRouter(__file__, prefix=\"/suspects\")\n\n@suspect_router.get(\"/list\")\ndef list_suspects():\n return {\"suspects\": get_all_suspects()}\n\n@suspect_router.get(\"/:id\")\ndef get_suspect(request, path_params):\n suspect_id = path_params.id\n return {\"suspect\": get_suspect_by_id(suspect_id)}\n\n# 将子路由器包含在主应用程序中\napp.include_router(crime_router)\napp.include_router(suspect_router)\n```\n\nSubRouters帮助在公共前缀下组织相关路由，使代码更易于维护和理解。在这个例子中：\n\n- 所有与犯罪相关的路由都在 `/crimes` 下\n- 所有与嫌疑人相关的路由都在 `/suspects` 下\n\n这种组织方式清晰地表明了哪些路由处理什么功能，并将相关代码保持在一起。 "
},
{
"path": "docs_src/src/pages/documentation/en/framework_performance_comparison.mdx",
"content": "export const description =\n 'On this page, we`ll understand the performance comparison across different frameworks.'\n\n\n# Performance comparison across different frameworks\n\n## Read this before you scroll down\n\nBefore delving into the details, it is imperative to note that this comparison doesn’t aim to discredit any developers or the frameworks listed below. Mentioning the names of the frameworks is solely for elucidating a clear comparison. My profound inclination towards the Python web ecosystem has been significantly influenced by all these frameworks, and my intention is not to cause offense to anyone by listing them here.\n\nMoreover, these tests were conducted on my development machine, and thus, the figures portrayed below are not absolute. The numbers only serve to indicate the relative performance of these frameworks under the specific testing conditions.\n\n\nThe [oha](https://github.com/hatoo/oha) tool was utilized to test 10,000 requests on the following frameworks, yielding the subsequent results:\n\n1. Flask(Gunicorn)\n\n```\nTotal: 5.5254 secs\nSlowest: 0.0784 secs\nFastest: 0.0028 secs\nAverage: 0.0275 secs\nRequests/sec: 1809.8082\n```\n\n1. FastAPI(Uvicorn)\n\n```\nTotal: 4.1314 secs\nSlowest: 0.0733 secs\nFastest: 0.0027 secs\nAverage: 0.0206 secs\nRequests/sec: 2420.4851\n```\n\n1. Django(Gunicorn)\n\n```\nTotal: 13.5070 secs\nSlowest: 0.3635 secs\nFastest: 0.0249 secs\nAverage: 0.0674 secs\nRequests/sec: 740.3558\n```\n\n1. Robyn(Doesn't need a *SGI)\n\n```\nTotal:\t1.8324 secs\nSlowest:\t0.0269 secs\nFastest:\t0.0024 secs\nAverage:\t0.0091 secs\nRequests/sec:\t5457.2339\n```\n\n1. Robyn (5 workers)\n\n```\nTotal:\t1.5592 secs\nSlowest:\t0.0211 secs\nFastest:\t0.0017 secs\nAverage:\t0.0078 secs\nRequests/sec:\t6413.6480\n```\n\nRobyn is able to serve the 10k requests in 1.8 seconds followed by Flask and FastAPI, which take around 5 seconds(using 5 workers on a dual-core machine). Finally, Django takes around 13.5070 seconds.\n\n## Verbose Logs\n\nFlask(Gunicorn)\n\n```\nSummary:\n Success rate: 1.0000\n Total: 5.5254 secs\n Slowest: 0.0784 secs\n Fastest: 0.0028 secs\n Average: 0.0275 secs\n Requests/sec: 1809.8082\n\n Total data: 126.95 KiB\n Size/request: 13 B\n Size/sec: 22.98 KiB\n\nResponse time histogram:\n 0.007 [55] |\n 0.014 [641] |■■■■■\n 0.021 [2413] |■■■■■■■■■■■■■■■■■■■■\n 0.027 [3771] |■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■\n 0.034 [1999] |■■■■■■■■■■■■■■■■\n 0.041 [737] |■■■■■■\n 0.048 [236] |■■\n 0.055 [75] |\n 0.062 [46] |\n 0.069 [24] |\n 0.076 [3] |\n\nLatency distribution:\n 10% in 0.0178 secs\n 25% in 0.0223 secs\n 50% in 0.0266 secs\n 75% in 0.0317 secs\n 90% in 0.0378 secs\n 95% in 0.0419 secs\n 99% in 0.0551 secs\n\nDetails (average, fastest, slowest):\n DNS+dialup: 0.0071 secs, 0.0001 secs, 0.0443 secs\n DNS-lookup: 0.0000 secs, 0.0000 secs, 0.0010 secs\n\nStatus code distribution:\n [200] 10000 responses\n```\n\nFastAPI(Uvicorn)\n\n```\nSummary:\n Success rate: 1.0000\n Total: 4.1314 secs\n Slowest: 0.0733 secs\n Fastest: 0.0027 secs\n Average: 0.0206 secs\n Requests/sec: 2420.4851\n\n Total data: 166.02 KiB\n Size/request: 17 B\n Size/sec: 40.18 KiB\n\nResponse time histogram:\n 0.005 [175] |■\n 0.011 [1541] |■■■■■■■■■■■■■■■■\n 0.016 [2942] |■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■\n 0.021 [2770] |■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■\n 0.027 [1479] |■■■■■■■■■■■■■■■■\n 0.032 [608] |■■■■■■\n 0.038 [217] |■■\n 0.043 [103] |■\n 0.048 [53] |\n 0.054 [54] |\n 0.059 [58] |\n\nLatency distribution:\n 10% in 0.0120 secs\n 25% in 0.0151 secs\n 50% in 0.0194 secs\n 75% in 0.0243 secs\n 90% in 0.0300 secs\n 95% in 0.0348 secs\n 99% in 0.0522 secs\n\nDetails (average, fastest, slowest):\n DNS+dialup: 0.0088 secs, 0.0073 secs, 0.0103 secs\n DNS-lookup: 0.0001 secs, 0.0000 secs, 0.0008 secs\n\nStatus code distribution:\n [200] 10000 responses\n```\n\nRobyn\n\n```\nSummary:\n Success rate:\t1.0000\n Total:\t1.8324 secs\n Slowest:\t0.0269 secs\n Fastest:\t0.0024 secs\n Average:\t0.0091 secs\n Requests/sec:\t5457.2339\n\n Total data:\t117.19 KiB\n Size/request:\t12 B\n Size/sec:\t63.95 KiB\n\nResponse time histogram:\n 0.002 [183] |■\n 0.004 [1669] |■■■■■■■■■■■■■■\n 0.007 [3724] |■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■\n 0.009 [2631] |■■■■■■■■■■■■■■■■■■■■■■\n 0.011 [1060] |■■■■■■■■■\n 0.013 [496] |■■■■\n 0.016 [188] |■\n 0.018 [34] |\n 0.020 [12] |\n 0.022 [2] |\n 0.025 [1] |\n\nLatency distribution:\n 10% in 0.0061 secs\n 25% in 0.0073 secs\n 50% in 0.0087 secs\n 75% in 0.0105 secs\n 90% in 0.0129 secs\n 95% in 0.0143 secs\n 99% in 0.0171 secs\n\nDetails (average, fastest, slowest):\n DNS+dialup:\t0.0049 secs, 0.0035 secs, 0.0065 secs\n DNS-lookup:\t0.0001 secs, 0.0000 secs, 0.0010 secs\n\nStatus code distribution:\n [200] 10000 responses\n```\n\nDjango(Gunicorn)\n\n```\nSummary:\n Success rate: 1.0000\n Total: 13.5070 secs\n Slowest: 0.3635 secs\n Fastest: 0.0249 secs\n Average: 0.0674 secs\n Requests/sec: 740.3558\n\n Total data: 102.01 MiB\n Size/request: 10.45 KiB\n Size/sec: 7.55 MiB\n\nResponse time histogram:\n 0.016 [283] |■\n 0.032 [2616] |■■■■■■■■■■■■■■■■■■\n 0.048 [4587] |■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■\n 0.064 [1829] |■■■■■■■■■■■■\n 0.081 [362] |■■\n 0.097 [98] |\n 0.113 [105] |\n 0.129 [20] |\n 0.145 [7] |\n 0.161 [28] |\n 0.177 [65] |\n\nLatency distribution:\n 10% in 0.0493 secs\n 25% in 0.0559 secs\n 50% in 0.0638 secs\n 75% in 0.0733 secs\n 90% in 0.0840 secs\n 95% in 0.0948 secs\n 99% in 0.1543 secs\n\nDetails (average, fastest, slowest):\n DNS+dialup: 0.0097 secs, 0.0001 secs, 0.0444 secs\n DNS-lookup: 0.0000 secs, 0.0000 secs, 0.0007 secs\n\nStatus code distribution:\n [200] 10000 responses\n```\n\nRobyn(with 5 workers)\n\n```\nSummary:\n Success rate:\t1.0000\n Total:\t1.5592 secs\n Slowest:\t0.0211 secs\n Fastest:\t0.0017 secs\n Average:\t0.0078 secs\n Requests/sec:\t6413.6480\n\n Total data:\t126.95 KiB\n Size/request:\t13 B\n Size/sec:\t81.42 KiB\n\nResponse time histogram:\n 0.002 [30] |\n 0.004 [599] |■■■■■\n 0.005 [3336] |■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■\n 0.007 [3309] |■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■\n 0.009 [1614] |■■■■■■■■■■■■■■■\n 0.011 [749] |■■■■■■■\n 0.012 [253] |■■\n 0.014 [94] |\n 0.016 [14] |\n 0.018 [1] |\n 0.019 [1] |\n\nLatency distribution:\n 10% in 0.0055 secs\n 25% in 0.0063 secs\n 50% in 0.0074 secs\n 75% in 0.0089 secs\n 90% in 0.0107 secs\n 95% in 0.0117 secs\n 99% in 0.0142 secs\n\nDetails (average, fastest, slowest):\n DNS+dialup:\t0.0022 secs, 0.0013 secs, 0.0028 secs\n DNS-lookup:\t0.0000 secs, 0.0000 secs, 0.0001 secs\n\nStatus code distribution:\n [200] 10000 responses\n```\n"
},
{
"path": "docs_src/src/pages/documentation/en/hosting.mdx",
"content": "export const description =\n 'On this page, we`ll understand how Robyn can be deployed on various cloud providers .'\n\nThe process of hosting a Robyn app on various cloud providers.\n\n\n## Railway\n\nWe will be deploying the app on `Railway`.\n\nA GitHub account is needed as a mandatory prerequisite.\n\nWe will deploy a sample \"Hello World,\" demonstrating a simple GET route and serving an HTML file.\n\nDirectory structure:\n\n ![](\"https://user-images.githubusercontent.com/70811425/202867604-10a09f87-ecb9-4a42-ae90-1359223049bc.png\")
\n\nThen, we press the \"New Project\" button and select \"Deploy from GitHub repo\".\n\n![](\"https://user-images.githubusercontent.com/70811425/202870632-4d3f46dc-1aa9-4603-9b0f-344ed87ec9d0.png\")
\n\nThen we select the repo we want to deploy. And click \"Deploy Now\".\n\n![](\"https://user-images.githubusercontent.com/70811425/202870837-16884fef-8900-4ab3-9794-0fb53c3ffd2e.png\")
\n![](\"https://user-images.githubusercontent.com/70811425/202871003-f79a1cef-9a5f-4166-be4f-527c60ec6c79.png\")
\n\nNow, we click on our project's card.\n\nSelect \"Variables\" and press the \"New Variable\" button to set the environments variables.\n\n![](\"https://user-images.githubusercontent.com/70811425/202870681-5c069475-a5d1-4069-8582-c5b549d27aad.png\")
\n\nThen, we go to the \"Settings\" tab and click on \"Generate Domain.\"\n\nWe can generate a temporary domain under the \"Domains\" tab.\n\n![](\"https://user-images.githubusercontent.com/70811425/202870735-6b955752-c5a6-48d5-acbc-1a4ea6fd7574.png\")
\n\nWe can go to our domain `\n# API Documentation\nWelcome to the Robyn API documentation. You'll find comprehensive guides and documentation to help you start working with Robyn as quickly as possible, as well as support if you get stuck. \n\nWe have divided the documentation into two parts: the [Example Application](#guides) and the [API Docs](#api_docs).\n\n\n\n \n \n\n\n## Getting started {{ anchor: false }}\n\nThe Example Application is a simple web application that demonstrates how to use the Robyn API. It is a great place to start if you are new to Robyn.\n\nThe API Reference contains detailed information about the Robyn API. It is a great place to start if you are already familiar with Robyn and want to learn more about the API.\n\n\n![\"Digital](\"https://web-platforms.sfo2.cdn.digitaloceanspaces.com/WWW/Badge%201.svg\")
\n ![\"AppWrite\"](\"https://avatars.githubusercontent.com/u/25003669?s=200&v=4\")
\n ![\"Shivay](\"https://avatars.githubusercontent.com/u/19529592?v=4\")
\n