5iI4UdZddlmZddlZddlmZddlmZmZddl m Z erddl m Z e e Zded <d Zd ed <d Zd ed<eGddZddZddZ ddZddZddZddZ d d dZddgZy)!aApp discovery utilities for detecting ASGI app instances in scripts. This module provides functions to discover if a Python script contains an ASGI application instance (like st.App, FastAPI, or Starlette), enabling the CLI to auto-detect whether to run in traditional mode or ASGI mode. By design, this supports not only Streamlit's st.App but also other ASGI frameworks like FastAPI and Starlette. This allows `streamlit run` to serve as a unified entry point for any ASGI app, providing a consistent developer experience for projects that combine Streamlit with other frameworks or use ASGI apps directly. The detection uses AST (Abstract Syntax Tree) parsing to safely analyze the source code without executing it. ) annotationsN) dataclass) TYPE_CHECKINGFinal) get_logger)Pathr_LOGGER)app streamlit_appzFinal[tuple[str, ...]]_PREFERRED_APP_NAMES)zstreamlit.starlette.Appz"streamlit.web.server.starlette.Appz0streamlit.web.server.starlette.starlette_app.Appzfastapi.FastAPIzfastapi.applications.FastAPIz starlette.applications.Starlette_KNOWN_ASGI_APP_CLASSESc0eZdZUdZded<ded<ded<y)AppDiscoveryResulta#Result of ASGI app discovery. Attributes ---------- is_asgi_app True if the script contains an ASGI app instance. app_name The name of the app instance variable (e.g., "app"). import_string The import string for uvicorn (e.g., "module:app"). bool is_asgi_app str | Noneapp_name import_stringN)__name__ __module__ __qualname____doc____annotations__l/home/obispo/Crisostomo_bridge/mision_env/lib/python3.12/site-packages/streamlit/web/server/app_discovery.pyrrEs rrcj|j}g}t|tjrB|j |j |j }t|tjrBt|tjr/|j |jtt|Sy)aExtract the name parts from a Call node's func attribute. For example: - `App(...)` returns ("App",) - `st.App(...)` returns ("st", "App") - `streamlit.starlette.App(...)` returns ("streamlit", "starlette", "App") Parameters ---------- node An AST Call node. Returns ------- tuple[str, ...] | None A tuple of name parts, or None if the call target is not a simple name or attribute chain. N) func isinstanceast AttributeappendattrvalueNameidtuplereversed)noderpartss r_get_call_name_partsr+Xs{& 99DE T3== ) TYYzz T3== )$! TWWXe_%% rci}tj|D]}t|tjr;|jD]+}|j xs |j }|j ||<-Xt|tjss|js|jD]:}|j xs |j }|jd|j ||<<|S)u_Extract import mappings from an AST. Builds a mapping from local names to their fully qualified module paths. For example: - `from streamlit.starlette import App` → {"App": "streamlit.starlette.App"} - `from streamlit import starlette` → {"starlette": "streamlit.starlette"} - `import streamlit as st` → {"st": "streamlit"} - `import fastapi` → {"fastapi": "fastapi"} Parameters ---------- tree The parsed AST of a Python module. Returns ------- dict[str, str] A mapping from local names to their fully qualified module paths. .) r walkrImportnamesasnamename ImportFrommodule)treeimportsr)alias local_names r_extract_importsr9ys*!G D dCJJ ' 1"\\7UZZ &+jj # 1cnn -$++ D"\\7UZZ )- Quzzl&C # D D Nrc|sy|d}|dd}||vr||}|r|ddj|S|Sdj|S)uResolve a call's name parts to a fully qualified module path. Uses the import mapping to resolve the first part of the call chain, then appends any remaining parts. For example, with imports {"App": "streamlit.starlette.App"}: - ("App",) → "streamlit.starlette.App" With imports {"st": "streamlit"}: - ("st", "starlette", "App") → "streamlit.starlette.App" Parameters ---------- parts The name parts from a Call node (e.g., ("st", "App")). imports The import mapping from _extract_imports. Returns ------- str | None The fully qualified module path, or None if resolution fails. Nrr-)join)r*r6 first_partremaining_parts base_paths r_resolve_call_to_module_pathr@sd4 qJABiOWJ' [#((?";!<= = 88E?rcLt|}|yt||}|y|tvS)aCheck if a Call node represents a known ASGI app constructor. This function resolves the call to its fully qualified module path using the import mapping, then checks if it matches any known ASGI app class. Parameters ---------- node An AST Call node. imports The import mapping from _extract_imports. Returns ------- bool True if the call is a known ASGI app constructor. F)r+r@r )r)r6r* resolved_paths r_is_asgi_app_callrCs7& ! &E }0@M 3 33rc|j}|jr%|jdk(r|jjS|jS)aConvert a file path to a module import string. Since `streamlit run` adds the script's directory to sys.path via _fix_sys_path, the module string should just be the script's stem, not a fully qualified package path. Parameters ---------- path Path to the Python file. Returns ------- str The module string suitable for uvicorn (e.g., "myapp"). __init__)resolveis_filestemparent)pathresolveds r_get_module_string_from_pathrLsB"||~Hhmmz9### ==rcp tj|}t |}i}tj |D]K}t|tjrt|jtjr\t|j|rF|jD]6}t|tjs|j||j<8t|tj s|jst|jtjst|j|st|j"tjs)|j||j"j<N|S#t$r"}tj d|icYd}~Sd}~wwxYw)aFind all variable assignments to ASGI app constructors in source code. This function parses the source code, extracts import statements to understand the module context, then finds assignments to known ASGI app constructors. Parameters ---------- source Python source code to analyze. Returns ------- dict[str, int] A mapping of variable names to their line numbers where ASGI app instances are assigned. zFailed to parse source: %sN)r parse SyntaxErrorr debugr9r.rAssignr$CallrCtargetsr%linenor& AnnAssigntarget)sourcer5er6app_assignmentsr)rVs r_find_asgi_app_assignmentsrZs-$yy  t$G&(O: tSZZ (4::sxx0!$**g6,, =fchh/15OFII. = tS]] + 4::sxx0!$**g64;;1.2kkODKKNN +':* =  2A6 sF F5F0*F50F5c^|js$tjd|tdddS |j d}t|}|s$tjd|tdddSt|}|rV||vr.tjd ||||td ||d |Stjd |tdddStD]6}||vstjd ||||td ||d |cSt|jd}tjd||d|dtd |d|d |dS#t t f$r/}tjd||tdddcYd}~Sd}~wwxYw)aiDiscover if a Python file contains an ASGI app instance using AST parsing. This function safely analyzes the source code without executing it. It tracks import statements to verify that detected App classes actually come from known ASGI frameworks (streamlit, fastapi, starlette), preventing false positives from custom classes with the same name. Supported import patterns: - `from streamlit.starlette import App` - `import streamlit` (for `streamlit.starlette.App`) - `from fastapi import FastAPI` - `from starlette.applications import Starlette` The app variable can have any name (e.g., `app`, `my_dashboard`, `server`). Preferred names checked first: "app", "streamlit_app". Parameters ---------- path Path to the Python script to check. app_name Optional specific variable name to look for. If provided, only that name is checked. If not provided, checks preferred names first ("app", "streamlit_app"), then falls back to any discovered ASGI app. Returns ------- AppDiscoveryResult Discovery result indicating whether an ASGI app was found and how to import it. Examples -------- >>> result = discover_asgi_app(Path("streamlit_app.py")) >>> if result.is_asgi_app: ... print(f"Found ASGI app: {result.import_string}") zPath does not exist: %sFN)rrrzutf-8)encodingzFailed to read file %s: %sz#No ASGI app assignments found in %sz!Found ASGI app at %s:%s (line %d)T:z No ASGI app found with name '%s'z1Found ASGI app at %s:%s (preferred name, line %d)c |dS)Nr;r)xs rz#discover_asgi_app..s 1Q4r)keyz+Found ASGI app at %s:%s (fallback, line %d)rr;) existsr rPr read_textOSErrorUnicodeDecodeErrorrZrLr minitems)rJrrWrXrY module_strpreferred_name first_apps rdiscover_asgi_apprk:sT ;;= /6!edRVWWX1 18O  ;TB!edRVWW-d3J  & MM3)   & !!+ AhZ8   8(C!edRVWW/  _ , MMC/   & '!+ An-=>  O))+@I MM5! !  1# Ail^4 i ' (X 2D!<!edRVWWXsE..F,=$F'!F,'F,rk)r)ast.Callreturnztuple[str, ...] | None)r5zast.ASTrmdict[str, str])r*ztuple[str, ...]r6rnrmr)r)rlr6rnrmr)rJrrmstr)rWrormzdict[str, int])N)rJrrrrmr)r __future__rr dataclassesrtypingrrstreamlit.loggerrpathlibrrr rr r rr+r9r@rCrLrZrk__all__rrrrvs # !''H%%0H,G 3/   $B$N* *%3**Z4<42n h hhhV !4 5r