trace_59709a02793c42c7a89a620cfa7d5fc7

     1	# Copyright 2026 Marimo. All rights reserved.
     2	from __future__ import annotations
     3	
     4	import asyncio
     5	import json
     6	import os
     7	import selectors
     8	import signal
     9	import struct
    10	import sys
    11	from pathlib import Path
    12	from typing import TYPE_CHECKING, Any, Callable, Literal, TypedDict

     1	# Copyright 2026 Marimo. All rights reserved.
     2	from __future__ import annotations
     3	
     4	import os
     5	import signal
     6	import sys
     7	import tempfile
     8	from pathlib import Path
     9	from typing import TYPE_CHECKING
    10	from unittest.mock import Mock, patch
    11	
    12	import pytest

109:    def enable_auth(self) -> bool:
110:        if hasattr(self.state, "enable_auth"):
111:            return self.state.enable_auth

     1	# Copyright 2026 Marimo. All rights reserved.
     2	from __future__ import annotations
     3	
     4	from typing import TYPE_CHECKING, Any, Optional, Union, cast
     5	
     6	from marimo import _loggers as loggers
     7	from marimo._cli.tips import CliTip
     8	from marimo._config.manager import MarimoConfigManager, ScriptConfigManager
     9	from marimo._server.config import StarletteServerState
    10	from marimo._server.session_manager import SessionManager
    11	from marimo._server.tokens import SkewProtectionToken
    12	from marimo._session.model import SessionMode

rg: invalid option -- 'r'

20:from starlette.authentication import (
21:    AuthCredentials,
22:    AuthenticationBackend,
40:from marimo._server.api.auth import TOKEN_QUERY_PARAM, validate_auth
85:class AuthBackend(AuthenticationBackend):
86:    def __init__(self, should_authenticate: bool = True) -> None:
87:        self.should_authenticate = should_authenticate
89:    async def authenticate(
91:    ) -> Optional[tuple[AuthCredentials, BaseUser]]:
92:        # We may not need to authenticate. This can be disabled
94:        # or authentication is handled by a layer above us
95:        if self.should_authenticate:

     1	# Copyright 2026 Marimo. All rights reserved.
     2	from __future__ import annotations
     3	
     4	import base64
     5	import hmac
     6	import secrets
     7	import typing
     8	from typing import TYPE_CHECKING, Any, Optional
     9	
    10	import starlette
    11	import starlette.status as status
    12	from starlette.datastructures import Secret

sed: /workspace/marimo/_server/middleware.py: No such file or directory

        return _handle_proxy_connection_error(error, path, custom_message)

    return handler


class AuthBackend(AuthenticationBackend):
    def __init__(self, should_authenticate: bool = True) -> None:
        self.should_authenticate = should_authenticate

    async def authenticate(
        self, conn: HTTPConnection
    ) -> Optional[tuple[AuthCredentials, BaseUser]]:

            if not valid:
                return None

        mode = AppStateBase(conn.app.state).session_manager.mode

        # User's get Read access in Run mode
        if mode == SessionMode.RUN:
            return AuthCredentials(["read"]), SimpleUser("user")

        # User's get Read and Edit access in Edit mode
        if mode == SessionMode.EDIT:
            return AuthCredentials(["read", "edit"]), SimpleUser("user")

22:    AuthenticationBackend,
85:class AuthBackend(AuthenticationBackend):

20:    AuthBackend,
83:                backend=AuthBackend(should_authenticate=enable_auth),

        *,
        path: str,
        directory: str,
        validate_callback: Optional[ValidateCallback] = None,
        middleware: Optional[list[MiddlewareFactory]] = None,
    ) -> ASGIAppBuilder:
        """
        Adds a dynamic directory to the ASGI app, allowing for dynamic loading of applications from the specified directory.

        Args:
            path (str): The URL path where the dynamic directory will be mounted.
            directory (str): The directory containing the applications.