bubble-analysis 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

bubble/detectors.py

@@ -13,6 +13,7 @@ from bubble.integrations.cli_scripts.detector import (
 from bubble.integrations.django.detector import (
     DjangoExceptionHandlerVisitor,
     DjangoViewVisitor,
+    detect_django_entrypoints,
 )
 from bubble.integrations.django.semantics import (
     EXCEPTION_RESPONSES as DJANGO_EXCEPTION_RESPONSES,
@@ -26,7 +27,9 @@ from bubble.integrations.fastapi.semantics import (
 )
 from bubble.integrations.flask.detector import (
     FlaskErrorHandlerVisitor,
+    FlaskRESTfulVisitor,
     FlaskRouteVisitor,
+    detect_flask_entrypoints,
 )
 from bubble.integrations.flask.semantics import (
     EXCEPTION_RESPONSES as FLASK_EXCEPTION_RESPONSES,
@@ -53,13 +56,13 @@ FRAMEWORK_EXCEPTION_RESPONSES: dict[str, dict[str, str]] = {
 def detect_entrypoints(source: str, file_path: str) -> list[Entrypoint]:
     """Detect entrypoints in a Python source file (HTTP routes and CLI scripts).
 
-    Uses the generic detector with Flask, FastAPI, and Django configurations,
-    plus CLI script detection.
+    Uses framework-specific detectors for Flask and Django (with HTTP method detection),
+    the generic detector for FastAPI, plus CLI script detection.
     """
     entrypoints: list[Entrypoint] = []
-    entrypoints.extend(generic_detect_entrypoints(source, file_path, FLASK_CONFIG))
+    entrypoints.extend(detect_flask_entrypoints(source, file_path))
     entrypoints.extend(generic_detect_entrypoints(source, file_path, FASTAPI_CONFIG))
-    entrypoints.extend(generic_detect_entrypoints(source, file_path, DJANGO_CONFIG))
+    entrypoints.extend(detect_django_entrypoints(source, file_path))
     entrypoints.extend(detect_cli_entrypoints(source, file_path))
     return entrypoints
 

bubble/extractor.py

@@ -13,6 +13,7 @@ if TYPE_CHECKING:
     pass
 
 from bubble.detectors import detect_entrypoints, detect_global_handlers
+from bubble.integrations.flask import correlate_flask_restful_entrypoints
 from bubble.enums import ResolutionKind
 from bubble.loader import load_detectors
 from bubble.models import (
@@ -440,13 +441,19 @@ class CodeExtractor(cst.CSTVisitor):
         return True
 
     def _get_current_qualified_name(self) -> str:
-        """Get the fully qualified name of the current context."""
-        parts = [self.relative_path]
+        """Get the fully qualified name of the current context.
+
+        Returns format: file.py::Class.method (matches canonical format from CLAUDE.md)
+        """
         if self._class_stack:
-            parts.append(".".join(self._class_stack))
-        if self._function_stack:
-            parts.append(self._function_stack[-1])
-        return "::".join(parts) if len(parts) > 1 else parts[0]
+            if self._function_stack:
+                qualified = ".".join(self._class_stack + [self._function_stack[-1]])
+            else:
+                qualified = ".".join(self._class_stack)
+            return f"{self.relative_path}::{qualified}"
+        elif self._function_stack:
+            return f"{self.relative_path}::{self._function_stack[-1]}"
+        return self.relative_path
 
     def _extract_depends_calls(
         self,
@@ -615,13 +622,14 @@ def extract_from_file(file_path: Path, relative_path: str | None = None) -> File
     result.return_types = extractor.return_types
     result.detected_frameworks = extractor.detected_frameworks
 
+    detection_path = relative_path if relative_path else str(file_path)
     try:
-        result.entrypoints = detect_entrypoints(source, str(file_path))
+        result.entrypoints = detect_entrypoints(source, detection_path)
     except Exception:
         pass
 
     try:
-        result.global_handlers = detect_global_handlers(source, str(file_path))
+        result.global_handlers = detect_global_handlers(source, detection_path)
     except Exception:
         pass
 
@@ -664,6 +672,10 @@ def _inject_drf_dispatch_calls(model: ProgramModel) -> None:
     When a DRF view class is detected as an entrypoint, this creates CallSite
     entries from the view class to each HTTP method handler (get, post, etc.)
     that exists on the class.
+
+    Handles both:
+    - Class-level entrypoints: "UserAPIView" -> creates edges to get, post, etc.
+    - Method-level entrypoints: "UserAPIView.get" -> creates edge to that method
     """
     drf_view_entrypoints = [
         ep
@@ -671,18 +683,32 @@ def _inject_drf_dispatch_calls(model: ProgramModel) -> None:
         if ep.metadata.get("framework") == "django" and ep.metadata.get("view_type") == "class"
     ]
 
+    seen_edges: set[tuple[str, str]] = set()
+
     for entrypoint in drf_view_entrypoints:
-        view_class = entrypoint.function
+        view_function = entrypoint.function
         view_file = entrypoint.file
         view_line = entrypoint.line
 
+        if "." in view_function:
+            view_class, method_name = view_function.rsplit(".", 1)
+            methods_to_inject = [method_name] if method_name in DRF_DISPATCH_METHODS else []
+        else:
+            view_class = view_function
+            methods_to_inject = list(DRF_DISPATCH_METHODS)
+
         for _func_key, func_def in model.functions.items():
             if not func_def.is_method:
                 continue
             if func_def.class_name != view_class:
                 continue
-            if func_def.name not in DRF_DISPATCH_METHODS:
+            if func_def.name not in methods_to_inject:
+                continue
+
+            edge_key = (view_class, func_def.name)
+            if edge_key in seen_edges:
                 continue
+            seen_edges.add(edge_key)
 
             relative_file = view_file
             if "/" in relative_file or "\\" in relative_file:
@@ -824,6 +850,7 @@ def extract_from_directory(
     if cache:
         cache.close()
 
+    model.entrypoints = correlate_flask_restful_entrypoints(model.entrypoints)
     _inject_drf_dispatch_calls(model)
 
     return model

bubble/formatters.py

@@ -694,7 +694,13 @@ def catches(
 
     total = len(result.local_catches) + len(result.global_handlers)
     if total == 0:
-        console.print(f"[yellow]No catch sites found for {result.exception_type}[/yellow]")
+        if result.raise_site_count == 0:
+            console.print(
+                f"[yellow]No catch sites found for {result.exception_type}[/yellow]\n"
+                f"[dim]  (this exception is not raised anywhere in the codebase)[/dim]"
+            )
+        else:
+            console.print(f"[yellow]No catch sites found for {result.exception_type}[/yellow]")
         return
 
     subclass_note = " (and subclasses)" if result.include_subclasses else ""

bubble/integrations/django/cli.py

@@ -40,8 +40,28 @@ def _get_django_entrypoints_and_handlers(model: ProgramModel) -> tuple[list, lis
     return entrypoints, handlers
 
 
+def _filter_entrypoints(
+    entrypoints: list, filter_arg: str | None, directory: Path
+) -> list:
+    """Filter entrypoints by file path or route path."""
+    if not filter_arg:
+        return entrypoints
+
+    if filter_arg.startswith("/"):
+        return [e for e in entrypoints if e.metadata.get("http_path") == filter_arg]
+
+    filter_path = Path(filter_arg)
+    if not filter_path.is_absolute():
+        filter_path = directory / filter_path
+
+    return [e for e in entrypoints if Path(directory / e.file).resolve() == filter_path.resolve()]
+
+
 @app.command()
 def audit(
+    filter_arg: Annotated[
+        str | None, typer.Argument(help="Filter by file path or route (e.g., /users)")
+    ] = None,
     directory: Annotated[
         Path, typer.Option("--directory", "-d", help="Directory to analyze")
     ] = Path("."),
@@ -50,22 +70,35 @@ def audit(
 ) -> None:
     """Check Django views for escaping exceptions.
 
-    Scans every Django view (APIView, ViewSet, @api_view), reports which have uncaught exceptions.
+    Scans Django views (APIView, ViewSet, @api_view) and reports which have uncaught exceptions.
 
-    Example:
-        flow django audit
-        flow django audit -d /path/to/project
+    Examples:
+        bubble django audit                          # All views
+        bubble django audit /users                   # Views matching /users
+        bubble django audit views/users.py           # Views in specific file
     """
     directory = directory.resolve()
     config = load_config(directory)
     model = _build_model(directory, use_cache=not no_cache)
     entrypoints, handlers = _get_django_entrypoints_and_handlers(model)
+    entrypoints = _filter_entrypoints(entrypoints, filter_arg, directory)
+
+    if filter_arg and not entrypoints:
+        if filter_arg.startswith("/"):
+            console.print(f"[yellow]No Django views found matching {filter_arg}[/yellow]")
+        else:
+            console.print(f"[yellow]No Django views found in {filter_arg}[/yellow]")
+        return
+
     result = audit_integration(model, integration, entrypoints, handlers, config=config)
     formatters.audit(result, output_format, directory, console)
 
 
 @app.command(name="entrypoints")
 def list_views(
+    filter_arg: Annotated[
+        str | None, typer.Argument(help="Filter by file path or route (e.g., /users)")
+    ] = None,
     directory: Annotated[
         Path, typer.Option("--directory", "-d", help="Directory to analyze")
     ] = Path("."),
@@ -74,12 +107,15 @@ def list_views(
 ) -> None:
     """List Django views (APIView, ViewSet, @api_view).
 
-    Example:
-        flow django entrypoints
+    Examples:
+        bubble django entrypoints                    # All views
+        bubble django entrypoints /users             # Views matching /users
+        bubble django entrypoints views/users.py     # Views in specific file
     """
     directory = directory.resolve()
     model = _build_model(directory, use_cache=not no_cache)
     entrypoints, _ = _get_django_entrypoints_and_handlers(model)
+    entrypoints = _filter_entrypoints(entrypoints, filter_arg, directory)
     result = list_integration_entrypoints(integration, entrypoints)
     formatters.entrypoints(result, output_format, directory, console)
 

bubble/integrations/django/detector.py

@@ -23,6 +23,17 @@ DRF_BASE_CLASSES = {
     "RetrieveUpdateDestroyAPIView",
 }
 
+DRF_HTTP_METHODS = {"get", "post", "put", "patch", "delete", "head", "options"}
+DRF_ACTION_METHODS = {"list", "create", "retrieve", "update", "partial_update", "destroy"}
+DRF_METHOD_TO_HTTP = {
+    "list": "GET",
+    "create": "POST",
+    "retrieve": "GET",
+    "update": "PUT",
+    "partial_update": "PATCH",
+    "destroy": "DELETE",
+}
+
 DRF_GENERICS_QUALIFIERS = {
     "generics",
     "rest_framework.generics",
@@ -51,31 +62,65 @@ class DjangoViewVisitor(cst.CSTVisitor):
         self._in_class: str | None = None
         self._class_is_view = False
         self._class_line: int = 0
+        self._class_methods: dict[str, int] = {}
 
     def visit_ClassDef(self, node: cst.ClassDef) -> bool:
         self._in_class = node.name.value
         self._class_is_view = self._is_view_class(node)
+        self._class_methods = {}
         if self._class_is_view:
             pos = self.get_metadata(PositionProvider, node)
             self._class_line = pos.start.line
-            self.entrypoints.append(
-                Entrypoint(
-                    file=self.file_path,
-                    function=node.name.value,
-                    line=self._class_line,
-                    kind="http_route",
-                    metadata={
-                        "framework": "django",
-                        "view_type": "class",
-                    },
-                )
-            )
+        return True
+
+    def visit_FunctionDef(self, node: cst.FunctionDef) -> bool:
+        if self._class_is_view and self._in_class:
+            method_name = node.name.value.lower()
+            if method_name in DRF_HTTP_METHODS or method_name in DRF_ACTION_METHODS:
+                pos = self.get_metadata(PositionProvider, node)
+                self._class_methods[method_name] = pos.start.line
         return True
 
     def leave_ClassDef(self, node: cst.ClassDef) -> None:
+        if self._class_is_view and self._in_class:
+            class_name = self._in_class
+            if self._class_methods:
+                for method_name, line in self._class_methods.items():
+                    http_method = DRF_METHOD_TO_HTTP.get(method_name, method_name.upper())
+                    self.entrypoints.append(
+                        Entrypoint(
+                            file=self.file_path,
+                            function=f"{class_name}.{method_name}",
+                            line=line,
+                            kind="http_route",
+                            metadata={
+                                "framework": "django",
+                                "view_type": "class",
+                                "http_method": http_method,
+                                "http_path": f"<drf:{class_name}>",
+                            },
+                        )
+                    )
+            else:
+                self.entrypoints.append(
+                    Entrypoint(
+                        file=self.file_path,
+                        function=class_name,
+                        line=self._class_line,
+                        kind="http_route",
+                        metadata={
+                            "framework": "django",
+                            "view_type": "class",
+                            "http_method": "ANY",
+                            "http_path": f"<drf:{class_name}>",
+                        },
+                    )
+                )
+
         self._in_class = None
         self._class_is_view = False
         self._class_line = 0
+        self._class_methods = {}
 
     def _is_view_class(self, node: cst.ClassDef) -> bool:
         """Check if a class inherits from a Django/DRF view base class."""

bubble/integrations/fastapi/cli.py

@@ -40,8 +40,28 @@ def _get_fastapi_entrypoints_and_handlers(model: ProgramModel) -> tuple[list, li
     return entrypoints, handlers
 
 
+def _filter_entrypoints(
+    entrypoints: list, filter_arg: str | None, directory: Path
+) -> list:
+    """Filter entrypoints by file path or route path."""
+    if not filter_arg:
+        return entrypoints
+
+    if filter_arg.startswith("/"):
+        return [e for e in entrypoints if e.metadata.get("http_path") == filter_arg]
+
+    filter_path = Path(filter_arg)
+    if not filter_path.is_absolute():
+        filter_path = directory / filter_path
+
+    return [e for e in entrypoints if Path(directory / e.file).resolve() == filter_path.resolve()]
+
+
 @app.command()
 def audit(
+    filter_arg: Annotated[
+        str | None, typer.Argument(help="Filter by file path or route (e.g., /users)")
+    ] = None,
     directory: Annotated[
         Path, typer.Option("--directory", "-d", help="Directory to analyze")
     ] = Path("."),
@@ -50,21 +70,34 @@ def audit(
 ) -> None:
     """Check FastAPI routes for escaping exceptions.
 
-    Scans every FastAPI HTTP route, reports which have uncaught exceptions.
+    Scans FastAPI HTTP routes and reports which have uncaught exceptions.
 
-    Example:
-        flow fastapi audit
-        flow fastapi audit -d /path/to/project
+    Examples:
+        bubble fastapi audit                         # All routes
+        bubble fastapi audit /users                  # Routes matching /users
+        bubble fastapi audit routers/users.py        # Routes in specific file
     """
     directory = directory.resolve()
     model = _build_model(directory, use_cache=not no_cache)
     entrypoints, handlers = _get_fastapi_entrypoints_and_handlers(model)
+    entrypoints = _filter_entrypoints(entrypoints, filter_arg, directory)
+
+    if filter_arg and not entrypoints:
+        if filter_arg.startswith("/"):
+            console.print(f"[yellow]No FastAPI routes found matching {filter_arg}[/yellow]")
+        else:
+            console.print(f"[yellow]No FastAPI routes found in {filter_arg}[/yellow]")
+        return
+
     result = audit_integration(model, integration, entrypoints, handlers)
     formatters.audit(result, OutputFormat(output_format), directory, console)
 
 
 @app.command(name="entrypoints")
 def list_routes(
+    filter_arg: Annotated[
+        str | None, typer.Argument(help="Filter by file path or route (e.g., /users)")
+    ] = None,
     directory: Annotated[
         Path, typer.Option("--directory", "-d", help="Directory to analyze")
     ] = Path("."),
@@ -73,12 +106,15 @@ def list_routes(
 ) -> None:
     """List FastAPI HTTP routes.
 
-    Example:
-        flow fastapi entrypoints
+    Examples:
+        bubble fastapi entrypoints                   # All routes
+        bubble fastapi entrypoints /users            # Routes matching /users
+        bubble fastapi entrypoints routers/users.py  # Routes in specific file
     """
     directory = directory.resolve()
     model = _build_model(directory, use_cache=not no_cache)
     entrypoints, _ = _get_fastapi_entrypoints_and_handlers(model)
+    entrypoints = _filter_entrypoints(entrypoints, filter_arg, directory)
     result = list_integration_entrypoints(integration, entrypoints)
     formatters.entrypoints(result, OutputFormat(output_format), directory, console)
 

bubble/integrations/flask/__init__.py

@@ -5,7 +5,9 @@ import typer
 from bubble.integrations.base import Entrypoint, GlobalHandler
 from bubble.integrations.flask.detector import (
     FlaskErrorHandlerVisitor,
+    FlaskRESTfulVisitor,
     FlaskRouteVisitor,
+    correlate_flask_restful_entrypoints,
     detect_flask_entrypoints,
     detect_flask_global_handlers,
 )
@@ -50,8 +52,10 @@ class FlaskIntegration:
 __all__ = [
     "FlaskIntegration",
     "FlaskRouteVisitor",
+    "FlaskRESTfulVisitor",
     "FlaskErrorHandlerVisitor",
     "EXCEPTION_RESPONSES",
+    "correlate_flask_restful_entrypoints",
     "detect_flask_entrypoints",
     "detect_flask_global_handlers",
 ]

bubble/integrations/flask/cli.py

@@ -40,8 +40,28 @@ def _get_flask_entrypoints_and_handlers(model: ProgramModel) -> tuple[list, list
     return entrypoints, handlers
 
 
+def _filter_entrypoints(
+    entrypoints: list, filter_arg: str | None, directory: Path
+) -> list:
+    """Filter entrypoints by file path or route path."""
+    if not filter_arg:
+        return entrypoints
+
+    if filter_arg.startswith("/"):
+        return [e for e in entrypoints if e.metadata.get("http_path") == filter_arg]
+
+    filter_path = Path(filter_arg)
+    if not filter_path.is_absolute():
+        filter_path = directory / filter_path
+
+    return [e for e in entrypoints if Path(directory / e.file).resolve() == filter_path.resolve()]
+
+
 @app.command()
 def audit(
+    filter_arg: Annotated[
+        str | None, typer.Argument(help="Filter by file path or route (e.g., /balance)")
+    ] = None,
     directory: Annotated[
         Path, typer.Option("--directory", "-d", help="Directory to analyze")
     ] = Path("."),
@@ -50,21 +70,34 @@ def audit(
 ) -> None:
     """Check Flask routes for escaping exceptions.
 
-    Scans every Flask HTTP route, reports which have uncaught exceptions.
+    Scans Flask HTTP routes and reports which have uncaught exceptions.
 
-    Example:
-        flow flask audit
-        flow flask audit -d /path/to/project
+    Examples:
+        bubble flask audit                           # All routes
+        bubble flask audit /balance                  # Routes matching /balance
+        bubble flask audit blueprints/api.py         # Routes in specific file
     """
     directory = directory.resolve()
     model = _build_model(directory, use_cache=not no_cache)
     entrypoints, handlers = _get_flask_entrypoints_and_handlers(model)
+    entrypoints = _filter_entrypoints(entrypoints, filter_arg, directory)
+
+    if filter_arg and not entrypoints:
+        if filter_arg.startswith("/"):
+            console.print(f"[yellow]No Flask routes found matching {filter_arg}[/yellow]")
+        else:
+            console.print(f"[yellow]No Flask routes found in {filter_arg}[/yellow]")
+        return
+
     result = audit_integration(model, integration, entrypoints, handlers)
     formatters.audit(result, OutputFormat(output_format), directory, console)
 
 
 @app.command(name="entrypoints")
 def list_routes(
+    filter_arg: Annotated[
+        str | None, typer.Argument(help="Filter by file path or route (e.g., /balance)")
+    ] = None,
     directory: Annotated[
         Path, typer.Option("--directory", "-d", help="Directory to analyze")
     ] = Path("."),
@@ -73,12 +106,15 @@ def list_routes(
 ) -> None:
     """List Flask HTTP routes.
 
-    Example:
-        flow flask entrypoints
+    Examples:
+        bubble flask entrypoints                     # All routes
+        bubble flask entrypoints /users              # Routes matching /users
+        bubble flask entrypoints blueprints/api.py   # Routes in specific file
     """
     directory = directory.resolve()
     model = _build_model(directory, use_cache=not no_cache)
     entrypoints, _ = _get_flask_entrypoints_and_handlers(model)
+    entrypoints = _filter_entrypoints(entrypoints, filter_arg, directory)
     result = list_integration_entrypoints(integration, entrypoints)
     formatters.entrypoints(result, OutputFormat(output_format), directory, console)
 

bubble/integrations/flask/detector.py

@@ -6,6 +6,8 @@ from libcst.metadata import MetadataWrapper, PositionProvider
 from bubble.enums import EntrypointKind, Framework
 from bubble.integrations.base import Entrypoint, GlobalHandler
 
+HTTP_METHODS = {"get", "post", "put", "delete", "patch", "head", "options"}
+
 
 class FlaskRouteVisitor(cst.CSTVisitor):
     """
@@ -157,21 +159,185 @@ class FlaskErrorHandlerVisitor(cst.CSTVisitor):
         return ""
 
 
+class FlaskRESTfulVisitor(cst.CSTVisitor):
+    """
+    Detects Flask-RESTful Resource classes and add_resource() registrations.
+
+    Supports:
+    - api.add_resource(ResourceClass, "/path")
+    - api.add_resource(ResourceClass, "/path1", "/path2")
+    - Custom methods like api.add_org_resource()
+    """
+
+    METADATA_DEPENDENCIES = (PositionProvider,)
+
+    ADD_RESOURCE_METHODS = {"add_resource", "add_org_resource"}
+
+    def __init__(self, file_path: str) -> None:
+        self.file_path = file_path
+        self.entrypoints: list[Entrypoint] = []
+        self.resource_classes: dict[str, dict[str, int]] = {}
+        self.resource_registrations: list[tuple[str, list[str], int]] = []
+
+    def visit_ClassDef(self, node: cst.ClassDef) -> bool:
+        methods_found: dict[str, int] = {}
+        for item in node.body.body:
+            if isinstance(item, cst.FunctionDef):
+                method_name = item.name.value.lower()
+                if method_name in HTTP_METHODS and not self._has_route_decorator(item):
+                    pos = self.get_metadata(PositionProvider, item)
+                    methods_found[method_name.upper()] = pos.start.line
+
+        if methods_found:
+            self.resource_classes[node.name.value] = methods_found
+
+        return True
+
+    def _has_route_decorator(self, node: cst.FunctionDef) -> bool:
+        """Check if a function has a route decorator like @expose, @route."""
+        for decorator in node.decorators:
+            dec = decorator.decorator
+            if isinstance(dec, cst.Call):
+                if isinstance(dec.func, cst.Attribute):
+                    if dec.func.attr.value in ("route", "expose"):
+                        return True
+                elif isinstance(dec.func, cst.Name):
+                    if dec.func.value in ("route", "expose"):
+                        return True
+            elif isinstance(dec, cst.Attribute):
+                if dec.attr.value in ("route", "expose"):
+                    return True
+            elif isinstance(dec, cst.Name):
+                if dec.value in ("route", "expose"):
+                    return True
+        return False
+
+    def visit_Call(self, node: cst.Call) -> bool:
+        if not isinstance(node.func, cst.Attribute):
+            return True
+
+        method_name = node.func.attr.value
+        if method_name not in self.ADD_RESOURCE_METHODS:
+            return True
+
+        if len(node.args) < 2:
+            return True
+
+        first_arg = node.args[0].value
+        resource_name = self._get_name_from_expr(first_arg)
+        if not resource_name:
+            return True
+
+        urls: list[str] = []
+        for arg in node.args[1:]:
+            if arg.keyword is not None:
+                continue
+            url = self._extract_string(arg.value)
+            if url:
+                urls.append(url)
+
+        if urls:
+            pos = self.get_metadata(PositionProvider, node)
+            self.resource_registrations.append((resource_name, urls, pos.start.line))
+
+        return True
+
+    def leave_Module(self, original_node: cst.Module) -> None:
+        registered_classes: set[str] = set()
+
+        for resource_name, urls, reg_line in self.resource_registrations:
+            registered_classes.add(resource_name)
+            methods = self.resource_classes.get(resource_name, {})
+            if not methods:
+                methods = {"GET": reg_line}
+
+            for url in urls:
+                for method, method_line in methods.items():
+                    self.entrypoints.append(
+                        Entrypoint(
+                            file=self.file_path,
+                            function=f"{resource_name}.{method.lower()}",
+                            line=method_line,
+                            kind=EntrypointKind.HTTP_ROUTE,
+                            metadata={
+                                "http_method": method,
+                                "http_path": url,
+                                "framework": Framework.FLASK,
+                                "flask_restful": True,
+                            },
+                        )
+                    )
+
+        for class_name, methods in self.resource_classes.items():
+            if class_name in registered_classes:
+                continue
+
+            for method, method_line in methods.items():
+                self.entrypoints.append(
+                    Entrypoint(
+                        file=self.file_path,
+                        function=f"{class_name}.{method.lower()}",
+                        line=method_line,
+                        kind=EntrypointKind.HTTP_ROUTE,
+                        metadata={
+                            "http_method": method,
+                            "http_path": f"<flask-restful:{class_name}>",
+                            "framework": Framework.FLASK,
+                            "flask_restful": True,
+                        },
+                    )
+                )
+
+    def _get_name_from_expr(self, expr: cst.BaseExpression) -> str:
+        if isinstance(expr, cst.Name):
+            return expr.value
+        elif isinstance(expr, cst.Attribute):
+            return expr.attr.value
+        return ""
+
+    def _extract_string(self, node: cst.BaseExpression) -> str | None:
+        if isinstance(node, cst.SimpleString):
+            return node.evaluated_value
+        elif isinstance(node, cst.ConcatenatedString):
+            parts = []
+            for part in (node.left, node.right):
+                if isinstance(part, cst.SimpleString):
+                    val = part.evaluated_value
+                    if val:
+                        parts.append(val)
+            return "".join(parts) if parts else None
+        return None
+
+
 def detect_flask_entrypoints(source: str, file_path: str) -> list[Entrypoint]:
-    """Detect Flask route entrypoints in a Python source file."""
+    """Detect Flask route entrypoints in a Python source file.
+
+    Detects both decorator-based routes (@app.route) and
+    Flask-RESTful call-based routes (api.add_resource).
+    """
     try:
         module = cst.parse_module(source)
     except Exception:
         return []
 
+    entrypoints: list[Entrypoint] = []
     wrapper = MetadataWrapper(module)
-    visitor = FlaskRouteVisitor(file_path)
 
+    route_visitor = FlaskRouteVisitor(file_path)
     try:
-        wrapper.visit(visitor)
-        return visitor.entrypoints
+        wrapper.visit(route_visitor)
+        entrypoints.extend(route_visitor.entrypoints)
     except Exception:
-        return []
+        pass
+
+    restful_visitor = FlaskRESTfulVisitor(file_path)
+    try:
+        wrapper.visit(restful_visitor)
+        entrypoints.extend(restful_visitor.entrypoints)
+    except Exception:
+        pass
+
+    return entrypoints
 
 
 def detect_flask_global_handlers(source: str, file_path: str) -> list[GlobalHandler]:
@@ -189,3 +355,75 @@ def detect_flask_global_handlers(source: str, file_path: str) -> list[GlobalHand
         return visitor.handlers
     except Exception:
         return []
+
+
+def correlate_flask_restful_entrypoints(entrypoints: list[Entrypoint]) -> list[Entrypoint]:
+    """Correlate Flask-RESTful entrypoints across files.
+
+    Flask-RESTful apps often define Resource classes in one file and register
+    them with api.add_resource() in another. This function merges information
+    from both sources:
+    - Class definitions have correct methods but placeholder paths
+    - Registrations have correct paths but fallback methods
+
+    Same-file cases (already fully resolved) are passed through unchanged.
+    Only placeholder entries trigger cross-file correlation.
+
+    Returns a new list with correlated entrypoints.
+    """
+    placeholder_classes: dict[str, list[Entrypoint]] = {}
+    real_path_entries: dict[str, list[Entrypoint]] = {}
+    non_flask_restful: list[Entrypoint] = []
+
+    for ep in entrypoints:
+        if not ep.metadata.get("flask_restful"):
+            non_flask_restful.append(ep)
+            continue
+
+        path = ep.metadata.get("http_path", "")
+
+        if path.startswith("<flask-restful:") and path.endswith(">"):
+            class_name = path[15:-1]
+            if class_name not in placeholder_classes:
+                placeholder_classes[class_name] = []
+            placeholder_classes[class_name].append(ep)
+        else:
+            parts = ep.function.rsplit(".", 1)
+            if len(parts) == 2:
+                class_name = parts[0]
+                if class_name not in real_path_entries:
+                    real_path_entries[class_name] = []
+                real_path_entries[class_name].append(ep)
+            else:
+                non_flask_restful.append(ep)
+
+    result: list[Entrypoint] = list(non_flask_restful)
+
+    for class_name, class_eps in placeholder_classes.items():
+        if class_name in real_path_entries:
+            reg_eps = real_path_entries[class_name]
+            paths_from_registrations = list({ep.metadata.get("http_path") for ep in reg_eps})
+
+            for class_ep in class_eps:
+                for reg_path in paths_from_registrations:
+                    result.append(
+                        Entrypoint(
+                            file=class_ep.file,
+                            function=class_ep.function,
+                            line=class_ep.line,
+                            kind=class_ep.kind,
+                            metadata={
+                                **class_ep.metadata,
+                                "http_path": reg_path,
+                            },
+                        )
+                    )
+
+            del real_path_entries[class_name]
+        else:
+            result.extend(class_eps)
+
+    for class_name, eps in real_path_entries.items():
+        result.extend(eps)
+
+    return result

bubble/integrations/formatters.py

@@ -53,6 +53,13 @@ def audit(
                         ]
                         for exc_type, raises_list in issue.caught_by_generic.items()
                     },
+                    "caught_by_remote": {
+                        exc_type: [
+                            {"file": r.file, "line": r.line, "function": r.function}
+                            for r in raises_list
+                        ]
+                        for exc_type, raises_list in issue.caught_by_remote.items()
+                    },
                 }
                 for issue in result.issues
             ],
@@ -104,6 +111,17 @@ def audit(
                 if len(raise_sites) > 2:
                     console.print(f"    [dim]...and {len(raise_sites) - 2} more[/dim]")
 
+            for exc_type, raise_sites in issue.caught_by_remote.items():
+                exc_simple = exc_type.split(".")[-1]
+                for rs in raise_sites[:2]:
+                    rel = _rel_path(rs.file, directory)
+                    console.print(
+                        f"    [blue]{exc_simple}[/blue] [dim]({rel}:{rs.line}) "
+                        f"- caught by handler in different file[/dim]"
+                    )
+                if len(raise_sites) > 2:
+                    console.print(f"    [dim]...and {len(raise_sites) - 2} more[/dim]")
+
             console.print()
     else:
         console.print("[green bold]All entrypoints have specific exception handlers[/green bold]\n")

bubble/integrations/models.py

@@ -22,11 +22,19 @@ class IntegrationData:
 
 @dataclass
 class AuditIssue:
-    """An entrypoint with uncaught or poorly-handled exceptions."""
+    """An entrypoint with uncaught or poorly-handled exceptions.
+
+    Fields:
+    - uncaught: Exceptions with no handler at all
+    - caught_by_generic: Caught by generic handler (@errorhandler(Exception))
+    - caught_by_remote: Caught by a handler in a different file (may indicate missing local handler)
+    - caught: Caught by a handler in the same file
+    """
 
     entrypoint: Entrypoint
     uncaught: dict[str, list["RaiseSite"]]
     caught_by_generic: dict[str, list["RaiseSite"]]
+    caught_by_remote: dict[str, list["RaiseSite"]]
     caught: dict[str, list["RaiseSite"]]
 
 

bubble/integrations/queries.py

@@ -51,6 +51,7 @@ def _compute_exception_flow_for_integration(
     forward_graph: dict[str, set[str]] | None = None,
     name_to_qualified: dict[str, list[str]] | None = None,
     config: FlowConfig | None = None,
+    entrypoint_file: str | None = None,
 ) -> ExceptionFlow:
     """Compute exception flow for a function with integration-specific handling.
 
@@ -134,9 +135,17 @@ def _compute_exception_flow_for_integration(
                     flow.caught_by_generic[exc_type] = []
                 flow.caught_by_generic[exc_type].extend(raise_sites)
             else:
-                if exc_type not in flow.caught_by_global:
-                    flow.caught_by_global[exc_type] = []
-                flow.caught_by_global[exc_type].extend(raise_sites)
+                is_same_file = (
+                    entrypoint_file is not None and caught_by_handler.file == entrypoint_file
+                )
+                if is_same_file:
+                    if exc_type not in flow.caught_by_global:
+                        flow.caught_by_global[exc_type] = []
+                    flow.caught_by_global[exc_type].extend(raise_sites)
+                else:
+                    if exc_type not in flow.caught_by_remote_global:
+                        flow.caught_by_remote_global[exc_type] = []
+                    flow.caught_by_remote_global[exc_type].extend(raise_sites)
             continue
 
         framework_response = integration.get_exception_response(exc_type)
@@ -218,19 +227,24 @@ def audit_integration(
             forward_graph,
             name_to_qualified,
             config,
+            entrypoint_file=entrypoint.file,
         )
 
         real_uncaught = {k: v for k, v in flow.uncaught.items() if k not in reraise_patterns}
         real_generic = {
             k: v for k, v in flow.caught_by_generic.items() if k not in reraise_patterns
         }
+        real_remote = {
+            k: v for k, v in flow.caught_by_remote_global.items() if k not in reraise_patterns
+        }
 
-        if real_uncaught or real_generic:
+        if real_uncaught or real_generic or real_remote:
             issues.append(
                 AuditIssue(
                     entrypoint=entrypoint,
                     uncaught=real_uncaught,
                     caught_by_generic=real_generic,
+                    caught_by_remote=real_remote,
                     caught=flow.caught_by_global,
                 )
             )
@@ -399,10 +413,14 @@ def _trace_to_entrypoints(
             return
         visited.add(current)
 
-        current_simple = current.split("::")[-1] if "::" in current else current
-        current_simple = current_simple.split(".")[-1]
+        current_qualified = current.split("::")[-1] if "::" in current else current
+        current_simple = current_qualified.split(".")[-1]
 
-        if current in entrypoint_functions or current_simple in entrypoint_functions:
+        if (
+            current in entrypoint_functions
+            or current_qualified in entrypoint_functions
+            or current_simple in entrypoint_functions
+        ):
             paths.append(list(path))
             return
 
@@ -411,13 +429,11 @@ def _trace_to_entrypoints(
             if len(paths) >= max_paths:
                 return
             if reachable_from_entrypoints is not None:
-                caller_simple = (
-                    caller.split("::")[-1].split(".")[-1]
-                    if "::" in caller
-                    else caller.split(".")[-1]
-                )
+                caller_qualified = caller.split("::")[-1] if "::" in caller else caller
+                caller_simple = caller_qualified.split(".")[-1]
                 if (
                     caller not in reachable_from_entrypoints
+                    and caller_qualified not in reachable_from_entrypoints
                     and caller_simple not in reachable_from_entrypoints
                 ):
                     continue
@@ -460,7 +476,9 @@ def trace_routes_to_exception(
                 endpoint = path[-1]
                 entrypoints_reached.add(endpoint)
                 if "::" in endpoint:
-                    entrypoints_reached.add(endpoint.split("::")[-1].split(".")[-1])
+                    qualified_part = endpoint.split("::")[-1]
+                    entrypoints_reached.add(qualified_part)
+                    entrypoints_reached.add(qualified_part.split(".")[-1])
 
         matching_entrypoints = [e for e in entrypoints if e.function in entrypoints_reached]
 

bubble/propagation.py

@@ -39,10 +39,20 @@ class PropagatedRaise:
 
 @dataclass
 class ExceptionFlow:
-    """The computed exception flow for a function or entrypoint."""
+    """The computed exception flow for a function or entrypoint.
+
+    Categories:
+    - caught_locally: Caught by try/except in the function
+    - caught_by_global: Caught by a global handler in the same file as the entrypoint
+    - caught_by_remote_global: Caught by a global handler in a different file
+    - caught_by_generic: Caught by a generic handler (@errorhandler(Exception))
+    - uncaught: No handler found
+    - framework_handled: Converted to HTTP response by framework (e.g., HTTPException)
+    """
 
     caught_locally: dict[str, list[RaiseSite]] = field(default_factory=dict)
     caught_by_global: dict[str, list[RaiseSite]] = field(default_factory=dict)
+    caught_by_remote_global: dict[str, list[RaiseSite]] = field(default_factory=dict)
     caught_by_generic: dict[str, list[RaiseSite]] = field(default_factory=dict)
     uncaught: dict[str, list[RaiseSite]] = field(default_factory=dict)
     framework_handled: dict[str, list[tuple[RaiseSite, str]]] = field(default_factory=dict)
@@ -61,6 +71,34 @@ class PropagationResult:
     )
 
 
+def _normalize_callee_to_file_format(
+    callee_qualified: str, model: ProgramModel
+) -> str:
+    """Normalize a module-dot callee to file::function format.
+
+    Converts: blueprints.orchestrators.CallbackOrchestrators.BalanceCallbackOrchestrator.run
+    To:       blueprints/orchestrators/CallbackOrchestrators.py::BalanceCallbackOrchestrator.run
+    """
+    if "::" in callee_qualified:
+        return callee_qualified
+
+    parts = callee_qualified.split(".")
+    for i in range(len(parts) - 1, 0, -1):
+        module_path = "/".join(parts[:i]) + ".py"
+        func_name = ".".join(parts[i:])
+        candidate_key = f"{module_path}::{func_name}"
+
+        if candidate_key in model.functions:
+            return candidate_key
+
+        for key in model.functions:
+            if key.endswith(f"::{func_name}") or key.endswith(f":{func_name}"):
+                if module_path.replace("/", ".").replace(".py", "") in key.replace("/", "."):
+                    return f"{key.split(':')[0]}::{func_name}"
+
+    return callee_qualified
+
+
 def build_forward_call_graph(model: ProgramModel) -> dict[str, set[str]]:
     """Build a map from caller to callees."""
     graph: dict[str, set[str]] = {}
@@ -69,6 +107,9 @@ def build_forward_call_graph(model: ProgramModel) -> dict[str, set[str]]:
         caller = call_site.caller_qualified or f"{call_site.file}::{call_site.caller_function}"
         callee = call_site.callee_qualified or call_site.callee_name
 
+        if call_site.callee_qualified and "::" not in call_site.callee_qualified:
+            callee = _normalize_callee_to_file_format(call_site.callee_qualified, model)
+
         if caller not in graph:
             graph[caller] = set()
         graph[caller].add(callee)
@@ -218,6 +259,23 @@ def _build_call_site_lookup(
     return lookup
 
 
+def _build_is_method_lookup(model: ProgramModel) -> dict[tuple[str, str], bool]:
+    """Build a lookup for is_method_call by (caller, callee) pairs.
+
+    This is always needed for correct fallback resolution, even when
+    skip_evidence=True. When a call is in the form obj.method(), we
+    should prefer matching methods over standalone functions.
+    """
+    lookup: dict[tuple[str, str], bool] = {}
+    for cs in model.call_sites:
+        caller = cs.caller_qualified or f"{cs.file}::{cs.caller_function}"
+        callee = cs.callee_qualified or cs.callee_name
+        key = (caller, callee)
+        if key not in lookup:
+            lookup[key] = cs.is_method_call
+    return lookup
+
+
 def _build_raise_site_lookup(
     model: ProgramModel,
 ) -> dict[tuple[str, str, int], RaiseSite]:
@@ -278,9 +336,7 @@ def _scoped_fallback_lookup(
     candidates = name_to_qualified.get(fallback_key, [])
 
     if not candidates:
-        result = ([], "none")
-        _fallback_cache[cache_key] = result
-        return result
+        return ([], "none")
 
     same_file = [c for c in candidates if c.startswith(f"{caller_file}::")]
     if same_file:
@@ -347,6 +403,7 @@ def propagate_exceptions(
         catches_by_function = compute_catches_by_function(model)
         forward_graph = build_forward_call_graph(model)
         call_site_lookup = _build_call_site_lookup(model) if not skip_evidence else {}
+        is_method_lookup = _build_is_method_lookup(model)
 
     propagated: dict[str, set[str]] = {}
     propagated_evidence: dict[str, dict[tuple[str, str, int], PropagatedRaise]] = {}
@@ -418,7 +475,7 @@ def propagate_exceptions(
                                 if "::" in expanded_callee
                                 else expanded_callee.split(".")[-1]
                             )
-                            is_method = call_site.is_method_call if call_site else False
+                            is_method = is_method_lookup.get((caller, callee), False)
                             caller_file = caller.split("::")[0] if "::" in caller else caller
                             import_map = model.import_maps.get(caller_file, {})
 

bubble/queries.py

@@ -7,7 +7,7 @@ and returns a typed result dataclass. No formatting here.
 from difflib import get_close_matches
 
 from bubble.enums import EntrypointKind, Framework, ResolutionMode
-from bubble.models import Entrypoint, ProgramModel
+from bubble.models import CatchSite, ClassHierarchy, Entrypoint, ProgramModel, RaiseSite
 from bubble.propagation import (
     build_forward_call_graph,
     build_reverse_call_graph,
@@ -320,28 +320,110 @@ def find_escapes(
     )
 
 
+def _compute_reverse_reachability(
+    raise_sites: list[RaiseSite],
+    qualified_graph: dict[str, set[str]],
+    name_graph: dict[str, set[str]],
+) -> set[str]:
+    """Compute all functions that can transitively call the raise site functions."""
+    reachable: set[str] = set()
+
+    for raise_site in raise_sites:
+        func_key = f"{raise_site.file}::{raise_site.function}"
+        worklist = [func_key]
+        visited: set[str] = set()
+
+        while worklist:
+            current = worklist.pop()
+            if current in visited:
+                continue
+            visited.add(current)
+            reachable.add(current)
+
+            simple_name = (
+                current.split("::")[-1].split(".")[-1]
+                if "::" in current
+                else current.split(".")[-1]
+            )
+            reachable.add(simple_name)
+
+            for caller in qualified_graph.get(current, set()):
+                if caller not in visited:
+                    worklist.append(caller)
+
+            for caller in name_graph.get(simple_name, set()):
+                if caller not in visited:
+                    worklist.append(caller)
+
+    return reachable
+
+
+def _catch_site_catches_exception(
+    catch_site: CatchSite,
+    types_to_find: set[str],
+    hierarchy: ClassHierarchy,
+) -> bool:
+    """Check if a catch site would catch the given exception type."""
+    if catch_site.has_bare_except:
+        return True
+
+    for caught_type in catch_site.caught_types:
+        caught_simple = caught_type.split(".")[-1]
+
+        if caught_type in types_to_find or caught_simple in types_to_find:
+            return True
+
+        if caught_simple in ("Exception", "BaseException"):
+            return True
+
+        for t in types_to_find:
+            t_simple = t.split(".")[-1]
+            if hierarchy.is_subclass_of(t_simple, caught_simple):
+                return True
+
+    return False
+
+
 def find_catches(
     model: ProgramModel,
     exception_type: str,
     include_subclasses: bool = False,
 ) -> CatchesResult:
-    """Find all places where an exception is caught."""
+    """Find catch sites that are in the call path from where the exception is raised."""
     types_to_find: set[str] = {exception_type}
     if include_subclasses:
         subclasses = model.exception_hierarchy.get_subclasses(exception_type)
         types_to_find.update(subclasses)
 
-    matching_catches = []
+    raises_result = find_raises(model, exception_type, include_subclasses)
+
+    if not raises_result.matches:
+        return CatchesResult(
+            exception_type=exception_type,
+            include_subclasses=include_subclasses,
+            types_searched=types_to_find,
+            local_catches=[],
+            global_handlers=[],
+            raise_site_count=0,
+        )
+
+    qualified_graph, name_graph = build_reverse_call_graph(model)
+    reachable_functions = _compute_reverse_reachability(
+        raises_result.matches, qualified_graph, name_graph
+    )
+
+    matching_catches: list[CatchSite] = []
     for catch_site in model.catch_sites:
-        for caught_type in catch_site.caught_types:
-            caught_simple = caught_type.split(".")[-1]
-            if caught_type in types_to_find or caught_simple in types_to_find:
-                matching_catches.append(catch_site)
-                break
-            for t in types_to_find:
-                if model.exception_hierarchy.is_subclass_of(t, caught_simple):
-                    matching_catches.append(catch_site)
-                    break
+        catch_func_key = f"{catch_site.file}::{catch_site.function}"
+        catch_func_simple = catch_site.function.split(".")[-1]
+
+        if catch_func_key not in reachable_functions and catch_func_simple not in reachable_functions:
+            continue
+
+        if _catch_site_catches_exception(
+            catch_site, types_to_find, model.exception_hierarchy
+        ):
+            matching_catches.append(catch_site)
 
     global_handlers = [
         h
@@ -360,6 +442,7 @@ def find_catches(
         types_searched=types_to_find,
         local_catches=matching_catches,
         global_handlers=global_handlers,
+        raise_site_count=len(raises_result.matches),
     )
 
 

bubble/results.py

@@ -118,6 +118,7 @@ class CatchesResult:
     types_searched: set[str]
     local_catches: list[CatchSite]
     global_handlers: list[GlobalHandler]
+    raise_site_count: int = 0
 
 
 @dataclass

{bubble_analysis-0.2.0.dist-info → bubble_analysis-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bubble-analysis
-Version: 0.2.0
+Version: 0.3.0
 Summary: Static analysis tool for tracing exception flow through Python codebases
 Author-email: Ian McLaughlin <ianm199@github.com>
 License-Expression: MIT

{bubble_analysis-0.2.0.dist-info → bubble_analysis-0.3.0.dist-info}/RECORD

@@ -2,45 +2,45 @@ bubble/__init__.py,sha256=1xAFxCucbe8Id65q6ReTBn1ipRs5Yn8sRjkREJEu1U8,83
 bubble/cache.py,sha256=-cqvtjmc8w_7ozJSXtqxxI1eKaYryuHeb5Vd9mk1kko,7418
 bubble/cli.py,sha256=76Yj7mvczncJEX7ajtiOUjl8-R10n6bUWQBoSigxhnc,17293
 bubble/config.py,sha256=SUwXeHKRkuHOl06JDcoTAe1o5wNIW7kIcBSCxIns3j4,1668
-bubble/detectors.py,sha256=YtRbTECmQvs07375vDhh3XlpVGWCTtH1S_Pj2QcBNCA,3146
+bubble/detectors.py,sha256=5MgziIsOGOoUHPQZznN7pb72sAkKd4yXVE5LR8kfeKI,3245
 bubble/enums.py,sha256=GuPbw2nr076fcnBQpOlKLrEc7rrf2Vnk8XjT2O37CfQ,1516
-bubble/extractor.py,sha256=ji8EG88bzkpZ1nbRA-PxGHWOxEXU8STUG_Hye52rRsU,29453
-bubble/formatters.py,sha256=x2jGJsGU9RsF9evs55B3NWitw66ePFzwsVc-K1t7Qiw,34031
+bubble/extractor.py,sha256=IdwJMXdVBBowYfGgNES-RFI7y_mzTrqzWnKT4fqovpg,30615
+bubble/formatters.py,sha256=tjcG2EfTNws953vzFc-uDf1XDh1XdgK91rySTkTctZw,34306
 bubble/loader.py,sha256=-KepjgS9EVk0JjCyGrX2xr6ihbbWyGDrVE61IhlFEJE,4217
 bubble/models.py,sha256=_v4k3Wf2ZBQC6pZkBLU_cbcm0PldrwQ-CsryD5TbiAE,12315
-bubble/propagation.py,sha256=DzADHu-ka7bkiDUamwvCpEipk7V_38lo47eRX2dOw0Y,27880
+bubble/propagation.py,sha256=V9iw1DiNbIhixAgcs1RLHOB-C-quDa4wrlCIJ5nQ3Xs,30293
 bubble/protocols.py,sha256=ER05yyvNDAcOpbgo3SFDHcccn2tFbp7SFGGVq9-kG48,3443
-bubble/queries.py,sha256=cSStEuxZsrKJyyUicxIBc1QbmxqFuoFYtQVJsOBcyvc,20381
-bubble/results.py,sha256=lAipfj04uTS-QeKhRcq5un3xf-sOoQUV2NxsJ-2a72A,4130
+bubble/queries.py,sha256=WvxBRep_E_lUGTfpSmDQK6_NZs3QP-MduH5P6OwxW_Q,22961
+bubble/results.py,sha256=xTI4a5re_e9OCvu9jkvf811P3weI-fsOPeDfRzxocnQ,4160
 bubble/stubs.py,sha256=jfM_Ji4ZrTM4UWrfB-lZtzHXbqbx4uFDF_kQOZtPvUA,2786
 bubble/timing.py,sha256=COoo50IfYhyvC5xXWS2L8vj9ZOoSk_SyC9v0Kt_rt6M,3828
 bubble/integrations/__init__.py,sha256=v5nUEGJJgJzpSljakQdAR2qKpheAugprBqrYb1GF7xc,2602
 bubble/integrations/base.py,sha256=veDox95mLw5MOTb0_9XogahEf-1GKyV1K0G7MnV-R-I,2853
-bubble/integrations/formatters.py,sha256=It1Ma4jcL5taVU63dBdN_yvLI98AuVtVXPeUsMzZTaY,10041
-bubble/integrations/models.py,sha256=2dioXNhpdLnz9er2xycDeVH23H45CZv-Xf-BE1uEV8Q,1605
-bubble/integrations/queries.py,sha256=I_ydltY4dDYybLfkfKZj4jBo2XatQlmFcqtQkCCw9II,16786
+bubble/integrations/formatters.py,sha256=-zd-hO5W7haWfQejkbXXsjyuSQ2JrEiJN4zJoyyGVVk,10950
+bubble/integrations/models.py,sha256=Ufg8YnzMUIOXnvAwDIvzYali9GD2pL0Gujl-TIftLlk,1954
+bubble/integrations/queries.py,sha256=gs8sgGRWINjowV1aI6ZVe2zJZI3Tk_5YUQzwG7UFzUk,17736
 bubble/integrations/cli_scripts/__init__.py,sha256=4YEoXXapVwz6tbnhTAcpLkC8C9lST7TsQ0XvKbeBG2E,1320
 bubble/integrations/cli_scripts/cli.py,sha256=Kjw02axBGNPpsesgSb9V3DdtG8s-iCcYTJZnaT6KBPA,3930
 bubble/integrations/cli_scripts/detector.py,sha256=mvev_ApKRv0i5WZ3NMbp9HWHA5sndLMpLhgsd5svc7A,4499
 bubble/integrations/django/__init__.py,sha256=KsIzlw8gcMLDEfM54azxciWJaLJrzUyHQbYxs6HuwQU,2037
-bubble/integrations/django/cli.py,sha256=pmg2yGKNUBkWd_jZpgdMMzuswH3HMyZEkzIrV4Q1ix4,4140
-bubble/integrations/django/detector.py,sha256=hxXsZk14WYlSpWmaD9TWPa4LeV2DM_T3GmOVbeADvrA,11370
+bubble/integrations/django/cli.py,sha256=y_di9LBTVlEWlJ58Lp62hNFo6yXiIrIenNE6mTQOnwA,5714
+bubble/integrations/django/detector.py,sha256=wZ6MNUBQ7c2SNRDJt-iAEsAYvqQW-KTXyAogsyM2r58,13327
 bubble/integrations/django/semantics.py,sha256=qdO6UC2U7brzc8SRrARLU9ivOGEQ59pN_TMXFpugYDk,1761
 bubble/integrations/fastapi/__init__.py,sha256=aIV3eWhX9Z_8od6e_EaTU9LCS2BvezgWlQasWTXTjKU,1867
-bubble/integrations/fastapi/cli.py,sha256=odJwIehPKSLfUqxkLi8SWwmWmV02mSCyd2OiZssh4L8,4129
+bubble/integrations/fastapi/cli.py,sha256=HB5_3mDcJVkWOK40gHJBS0WV9gBPk1Hl-pCCBHrlqBQ,5710
 bubble/integrations/fastapi/detector.py,sha256=6LoCdomsHA33wPRpXz6tWCzSFKTmul9NOoChAFSjaWo,5767
 bubble/integrations/fastapi/semantics.py,sha256=xtHs8HUFMzpRMvE1a4uqCflWiGY1-5_v3ACCz0BBnUg,499
-bubble/integrations/flask/__init__.py,sha256=IaWU0TxLicbLsk0KdyYL8-VAjaujdZpjE6tvD5iu1Ws,1823
-bubble/integrations/flask/cli.py,sha256=Iz0J9C2Kb4zg3P30sI1iJ0Ey320lpMLN74MeRw0K2F8,4083
-bubble/integrations/flask/detector.py,sha256=3RUYmzDRbYFttrcVVwu5xGQk7BRekfYvk0AzNfCAJ0M,6511
+bubble/integrations/flask/__init__.py,sha256=1fmMcxLOzIjU3aToF1vGnxeo-UwAVaKlPopnV2KPgnw,1959
+bubble/integrations/flask/cli.py,sha256=Xkmg_QgLz6kMU7MS1staARBl4tCr0efvd7fzoZqgJtw,5672
+bubble/integrations/flask/detector.py,sha256=gVg6pUUC3e3NPps2ZlLZfpGDO9Sn32AtJy171oSKSHE,15447
 bubble/integrations/flask/semantics.py,sha256=gf95XfpaztI1ASQfen38wyjbbLVIH_H2Xc6YwScCBV4,675
 bubble/integrations/generic/__init__.py,sha256=daDOwBkgmyA6mHOi6JbznZfSkIJx_6TMoy30wrKOPHE,321
 bubble/integrations/generic/config.py,sha256=61mKh9xRKPPo0sfI_SFQnIvoEMaUNFrbE21215LM1gc,3236
 bubble/integrations/generic/detector.py,sha256=Z0PSRLVF96CJ-FN473M8Txj28etMeEJS0fmaPV1Ev6M,12460
 bubble/integrations/generic/frameworks.py,sha256=s8fpdPD_71ZJvIbPv4VVvplLnp7cAb5W418fg5hu0uM,4060
-bubble_analysis-0.2.0.dist-info/licenses/LICENSE,sha256=dUhuoK-TCRQMpuLEAdfme-qPSJI0TlcH9jlNxeg9_EQ,1056
-bubble_analysis-0.2.0.dist-info/METADATA,sha256=XmSVfFbo8r4ts0Ak92w94EGI2OqLiDDaaZPcREp01P0,9040
-bubble_analysis-0.2.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-bubble_analysis-0.2.0.dist-info/entry_points.txt,sha256=IsRFTKJQI7FCzniBdLSC4lebLcfyAvPnI9x1gpYFL3c,42
-bubble_analysis-0.2.0.dist-info/top_level.txt,sha256=PI9j20Ka7CoFSwoBiRcLAg9xm-BhUQujkDOn8ykeIjU,7
-bubble_analysis-0.2.0.dist-info/RECORD,,
+bubble_analysis-0.3.0.dist-info/licenses/LICENSE,sha256=dUhuoK-TCRQMpuLEAdfme-qPSJI0TlcH9jlNxeg9_EQ,1056
+bubble_analysis-0.3.0.dist-info/METADATA,sha256=C7qAa7iPLYcxyvrGXXT-2stTVm0nzM6pL9FeXmQWQlk,9040
+bubble_analysis-0.3.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+bubble_analysis-0.3.0.dist-info/entry_points.txt,sha256=IsRFTKJQI7FCzniBdLSC4lebLcfyAvPnI9x1gpYFL3c,42
+bubble_analysis-0.3.0.dist-info/top_level.txt,sha256=PI9j20Ka7CoFSwoBiRcLAg9xm-BhUQujkDOn8ykeIjU,7
+bubble_analysis-0.3.0.dist-info/RECORD,,