coretrace-python-analyzer 0.15.0__py3-none-any.whl → 0.16.0__py3-none-any.whl

coretrace_python/__init__.py

@@ -1,4 +1,4 @@
 """CoreTrace's Python static analysis frontend."""
 
-__version__ = "0.15.0"
+__version__ = "0.16.0"
 

coretrace_python/bundled/dependency/reachable_vulnerability/reachable_vulnerability.py

@@ -1,5 +1,6 @@
 """Calls, anywhere in the project, to an API affected by a vulnerable requirement, and
-reads of an affected attribute whose getter runs the vulnerable code."""
+reads of an affected attribute whose getter runs the vulnerable code. A filter a project
+template applies is a call to the function behind it, at the template's line."""
 
 from __future__ import annotations
 
@@ -56,6 +57,10 @@ class ReachableVulnerabilityPlugin(ProjectPlugin):
                             reported.add((advisory, symbol))
                             check = check_conditions(entry, None)
                             findings.append(_reached(advisory, symbol, read.location, function, check))
+        for call in ctx.templates.calls:
+            for advisory in affected.get(call.symbol, ()):
+                check = check_conditions(advisory.entry_point(call.symbol), None)
+                findings.append(_reached(advisory, call.symbol, call.span, None, check))
         return findings
 
 
@@ -67,7 +72,9 @@ def _read_through(symbol: SymbolId) -> Iterator[SymbolId]:
         yield SymbolId(".".join(components[:end]))
 
 
-def _reached(advisory: Advisory, symbol: SymbolId, span: SourceSpan, function: str, check: ConditionCheck) -> Finding:
+def _reached(
+    advisory: Advisory, symbol: SymbolId, span: SourceSpan, function: str | None, check: ConditionCheck
+) -> Finding:
     return Finding(
         rule_id="reachable-vulnerability",
         message=(

coretrace_python/bundled/models/django/django_models.py

@@ -139,7 +139,10 @@ class DjangoModels(ModelPlugin):
         Sink(_sym("django.http.HttpResponseRedirect"), TaintKind.REDIRECT, _TARGET_ONLY),
         Sink(_sym("django.http.HttpResponsePermanentRedirect"), TaintKind.REDIRECT, _TARGET_ONLY),
         Sanitizer(_sym("django.utils.html.escape"), TaintKind.HTML),
-        TemplateRender(_sym("django.template.loader.render_to_string")),
+        TemplateRender(_sym("django.template.loader.render_to_string"), request=2),
+        TemplateRender(_sym("django.shortcuts.render"), 1, context=2, request=0),
+        TemplateRender(_sym("django.template.response.TemplateResponse"), 1, "template", 2, 0),
+        TemplateRender(_sym("django.template.response.SimpleTemplateResponse"), 0, "template"),
         Sanitizer(_sym("django.utils.html.conditional_escape"), TaintKind.HTML),
         # The masked CSRF secret: ASCII letters and digits only, a malformed cookie is
         # replaced before it is used.

coretrace_python/dependency/vex.py

@@ -7,7 +7,8 @@ subcomponent of the project:
   exploitable finding, whatever the policy or a suppression did with it;
 - ``not_affected``, as ``vulnerable_code_not_in_execute_path``, only when the advisory is
   curated (it names entry points), no code of the project reaches them, every file and
-  function was analysed, and a lock file shows that no other package requires the
+  function was analysed, every template the project names was read when a template
+  filter can reach them, and a lock file shows that no other package requires the
   vulnerable one, since the code of installed packages is not analysed;
 - ``under_investigation`` otherwise, with the reason in its notes.
 """
@@ -25,6 +26,7 @@ from coretrace_python.dependency.graph import Advisory, DependencyGraph, Require
 from coretrace_python.dependency.sbom import purl
 from coretrace_python.findings import Component, Finding
 from coretrace_python.findings.coverage import Coverage
+from coretrace_python.taint import FILTER_FUNCTIONS
 
 CONTEXT = "https://openvex.dev/ns/v0.2.0"
 # OpenVEX's shared namespace for documents without an IRI of their own, and the author
@@ -33,6 +35,8 @@ NAMESPACE = "https://openvex.dev/docs/public/vex-"
 AUTHOR = "Unknown Author"
 # Evidence levels that put the vulnerable code in the project's execution path, lowest first.
 REACHED = ("reachable", "exploitable")
+# What a template calls: a template the engine cannot read may reach these.
+_TEMPLATE_CALLS = frozenset(FILTER_FUNCTIONS.values())
 
 
 def render_vex(
@@ -140,6 +144,11 @@ def _status(
             f"No analysed code reaches {entries}, but {', '.join(partial)} could not be fully "
             f"analysed.{ruled}"
         )
+    if coverage.unread_templates and _TEMPLATE_CALLS.intersection(advisory.reachable_symbols):
+        return _investigating(
+            f"No analysed code reaches {entries}, but a template can reach them, and the engine could "
+            f"not read every template the project names: {'; '.join(coverage.unread_templates)}.{ruled}"
+        )
     required_by = dependencies.required_by(package)
     if required_by is None:
         return _investigating(

coretrace_python/engine.py

@@ -83,6 +83,8 @@ from coretrace_python.interprocedural import (
     SummaryAnalysis,
     SummaryIndex,
     SymbolRead,
+    TemplateCalls,
+    TemplateCallsAnalysis,
     build_module_graph,
     discover_sources,
     project_symbol,
@@ -124,7 +126,10 @@ from coretrace_python.taint import (
     TaintAnalysis,
     TaintKind,
     escaped_templates,
+    project_templates,
     registered_routes,
+    request_processor,
+    unread_renders,
 )
 from coretrace_python.taint.urls import flow_url
 
@@ -158,6 +163,7 @@ ALL_ANALYSES: tuple[AnyAnalysis, ...] = (
     RegisteredRoutes,
     EscapedTemplates,
     ClearingAnalysis,
+    TemplateCallsAnalysis,
 )
 
 
@@ -198,6 +204,7 @@ class ResultsEvicted(TransformationPass):
             RegisteredRoutes,
             EscapedTemplates,
             ClearingAnalysis,
+            TemplateCallsAnalysis,
         }
     )
 
@@ -431,13 +438,20 @@ def analyze_project(
         for symbol, registered in _routes_of(analysable[name]).items():
             routes.setdefault(symbol, registered)
     escaped = escaped_templates(root)
+    templates = project_templates(root)
     clearing = models.clearing(escaped)
+    template_calls = models.template_calls(
+        templates.filters, request_processor(modules[name] for name in sorted(analysable))
+    )
     for manager in analysable.values():
         manager.provide(RegisteredRoutes, routes)
         manager.provide(EscapedTemplates, escaped)
         manager.provide(ClearingAnalysis, clearing)
+        manager.provide(TemplateCallsAnalysis, template_calls)
 
-    configuration = _configuration_key(components, plugins, models, advisories, dependencies, routes, escaped)
+    configuration = _configuration_key(
+        components, plugins, models, advisories, dependencies, routes, escaped, template_calls
+    )
     keys = module_keys(
         graph,
         {name: fingerprint(configuration, str(files[name].source_id), name, files[name].text) for name in analysable},
@@ -479,6 +493,7 @@ def analyze_project(
                             advisory_paths,
                             _encode_routes(routes),
                             tuple(sorted(escaped)),
+                            template_calls,
                         ),
                     )
                     for component in pending
@@ -516,7 +531,9 @@ def analyze_project(
             frozenset(),
             reads={f: tuple(r) for f, r in reads.items()},
         )
-    context = ProjectContext(graph, dependencies, advisories, analysable, call_graphs, policy, root, functions)
+    context = ProjectContext(
+        graph, dependencies, advisories, analysable, call_graphs, policy, root, functions, templates
+    )
     for plugin in all_plugins:
         if isinstance(plugin, ProjectPlugin):
             findings.extend(plugin.analyze_project(context))
@@ -526,6 +543,9 @@ def analyze_project(
     findings = [_sourced(finding, origins) for finding in findings]
     accepted = tuple(f for f in findings if policy.accepts(f))
     kept, suppressed = partition(apply_policy(policy, findings), _text_of(sources))
+    unread = list(templates.unread)
+    for name in sorted(call_graphs):
+        unread.extend(unread_renders(name, call_graphs[name], models, templates.names))
     return ProjectAnalysis(
         graph,
         index,
@@ -534,7 +554,7 @@ def analyze_project(
         MappingProxyType(keys),
         reused,
         advisories,
-        Coverage(tuple(sorted(coverage, key=lambda c: c.path))),
+        Coverage(tuple(sorted(coverage, key=lambda c: c.path)), tuple(unread)),
         suppressed,
         accepted,
         components,
@@ -686,6 +706,7 @@ class _Batch:
     advisory_paths: tuple[Path, ...] = ()
     routes: tuple[tuple[str, str, str, int], ...] = ()
     escaped: tuple[str, ...] = ()
+    template_calls: TemplateCalls = field(default_factory=TemplateCalls)
 
 
 def _analyse_batch(batch: _Batch) -> dict[str, dict[str, Any]]:
@@ -713,6 +734,7 @@ def _analyse_batch(batch: _Batch) -> dict[str, dict[str, Any]]:
         manager.provide(RegisteredRoutes, routes)
         manager.provide(EscapedTemplates, escaped)
         manager.provide(ClearingAnalysis, models.clearing(escaped))
+        manager.provide(TemplateCallsAnalysis, batch.template_calls)
     module_plugins = tuple(p for p in all_plugins if not isinstance(p, ProjectPlugin))
     results = _analyse_managers(managers, decode_index(batch.seed), module_plugins, affected)
     return {name: encode(entry) for name, entry in results.items()}
@@ -741,6 +763,7 @@ def _configuration_key(
     dependencies: DependencyGraph,
     routes: Routes | None = None,
     escaped: frozenset[str] = frozenset(),
+    template_calls: TemplateCalls | None = None,
 ) -> str:
     """Everything a module's results depend on besides the project sources (§11)."""
 
@@ -758,6 +781,7 @@ def _configuration_key(
         repr(dependencies.errors),
         repr(_encode_routes(routes or {})),
         repr(sorted(escaped)),
+        repr(template_calls),
     )
 
 

coretrace_python/findings/coverage.py

@@ -2,7 +2,9 @@
 
 "No findings" only means something when the reader knows what was analysed. Each file
 is ``analysed``, a ``syntax-error`` (the frontend rejected it) or ``unreadable`` (it could
-not be decoded); analysed files count their functions and how many lowered.
+not be decoded); analysed files count their functions and how many lowered. The
+templates the project names but the run could not read are listed, each where the
+project names it: they may call any template filter.
 """
 
 from __future__ import annotations
@@ -21,6 +23,7 @@ class FileCoverage:
 @dataclass(frozen=True)
 class Coverage:
     details: tuple[FileCoverage, ...] = ()
+    unread_templates: tuple[str, ...] = ()
 
     @property
     def files(self) -> int:

coretrace_python/interprocedural/__init__.py

@@ -20,6 +20,7 @@ from coretrace_python.interprocedural.modulegraph import (
     project_symbol,
 )
 from coretrace_python.interprocedural.summaries import (
+    FILTER_ARGUMENTS,
     Cleared,
     Clearing,
     ClearingAnalysis,
@@ -31,10 +32,14 @@ from coretrace_python.interprocedural.summaries import (
     SummaryAnalysis,
     SummaryIndex,
     SummaryTable,
+    TemplateCalls,
+    TemplateCallsAnalysis,
+    TemplateFilter,
     cleared_by,
 )
 
 __all__ = [
+    "FILTER_ARGUMENTS",
     "Arguments",
     "CallGraph",
     "CallGraphAnalysis",
@@ -56,6 +61,9 @@ __all__ = [
     "SummaryTable",
     "SymbolRead",
     "Target",
+    "TemplateCalls",
+    "TemplateCallsAnalysis",
+    "TemplateFilter",
     "UnknownTarget",
     "build_module_graph",
     "cleared_by",

coretrace_python/interprocedural/summaries.py

@@ -7,14 +7,17 @@ over the call graph, so recursion converges to the least solution. Summaries car
 security knowledge of their own: the taint engine decides which external symbols
 matter. They only keep, per parameter, the bits a ``Clearing`` the engine provides says
 the calls on the way cleared, on every path, so a caller's data reaches a sink or comes
-back without the kinds a sanitizer inside the function removed.
+back without the kinds a sanitizer inside the function removed. A call rendering a
+template makes the filter calls ``TemplateCalls`` says the template makes, with the
+values of the context entries it reads.
 """
 
 from __future__ import annotations
 
 import dataclasses
-from collections.abc import Iterable, Mapping
+from collections.abc import Iterable, Iterator, Mapping
 from dataclasses import dataclass
+from functools import cached_property
 from types import MappingProxyType
 from typing import ClassVar, TypeVar
 
@@ -38,6 +41,7 @@ from coretrace_python.interprocedural.callgraph import (
     UnknownTarget,
     _is_staticmethod,
 )
+from coretrace_python.ir.defuse import DefUse, def_use
 from coretrace_python.ir.model import (
     BasicBlock,
     Branch,
@@ -145,6 +149,131 @@ class Clearing:
         return bits
 
 
+@dataclass(frozen=True)
+class TemplateFilter:
+    """A filter call rendering a template makes: the function behind the filter, where
+    it is applied, in the template named ``template``, and the variables of the render,
+    each with its first attribute (``bio``, ``request.GET``), whose values reach its value
+    and its argument. They are sorted: the calls are part of the cache key."""
+
+    symbol: SymbolId
+    location: SourceSpan
+    template: str
+    value: tuple[str, ...] = ()
+    argument: tuple[str, ...] = ()
+
+
+# What the analysis knows of the arguments of a filter call: nothing, so no condition on
+# them is decided.
+FILTER_ARGUMENTS = Arguments(unpacked=True)
+
+
+@dataclass(frozen=True)
+class Rendering:
+    """What a render call gives the template: the filter calls it makes, the context
+    ``entries`` by key, and the ``request`` the request context processor adds, if it
+    certainly does. An entry of that name shadows the request."""
+
+    filters: tuple[TemplateFilter, ...]
+    entries: Mapping[str, Value]
+    request: Value | None = None
+
+    def values(self, names: tuple[str, ...]) -> Iterator[tuple[Value, str | None]]:
+        """The values reaching a filter through ``names``, each a variable with its first
+        attribute: a context entry, or the request with the attribute read from it."""
+
+        for name in names:
+            variable, _, attribute = name.partition(".")
+            if variable in self.entries:
+                yield self.entries[variable], None
+            elif variable == REQUEST and self.request is not None and attribute:
+                yield self.request, attribute
+
+
+# The variable the request context processor adds.
+REQUEST = "request"
+
+
+@dataclass(frozen=True)
+class TemplateCalls:
+    """The filter calls a render makes, provided by the engine from the project's
+    templates: ``renders`` gives, for each render symbol, the position and keyword of
+    the template's name, the position of its ``context`` and that of its ``request``
+    (None when it takes none); ``filters`` the calls rendering each template makes, by
+    its name the way call sites record a constant; ``request`` says the request context
+    processor certainly runs for every template."""
+
+    renders: Mapping[SymbolId, tuple[int, str, int, int | None]] = dataclasses.field(default_factory=dict)
+    filters: Mapping[str, tuple[TemplateFilter, ...]] = dataclasses.field(default_factory=dict)
+    request: bool = False
+
+    def rendering(
+        self, symbol: SymbolId, call: Call, arguments: Arguments, defs: Mapping[Value, Instruction], uses: DefUse
+    ) -> Rendering | None:
+        """What ``call`` gives the template it names, when it renders one whose filter
+        calls are known. None unless the context is certain: absent, or a dict literal
+        with constant keys that ``call`` alone uses; any other context may hold other
+        values, or a ``request`` entry, by the time the template reads it."""
+
+        render = self.renders.get(symbol)
+        if render is None:
+            return None
+        position, keyword, context, request = render
+        named = arguments.given(keyword, position)
+        filters = self.filters.get(named[1] or "", ()) if named is not None and named[0] else ()
+        passed = _passed(call, context, "context") if filters else None
+        entries = _literal_entries(passed[1], defs, uses) if passed is not None and passed[0] else None
+        if entries is None:
+            return None
+        given = _passed(call, request, REQUEST) if self.request and request is not None else None
+        return Rendering(filters, entries, given[1] if given is not None and given[0] else None)
+
+
+def _passed(call: Call, position: int, keyword: str) -> tuple[bool, Value | None]:
+    """Whether what ``call`` passes at ``position`` or as ``keyword`` is certain, and
+    that value: None when the call passes none."""
+
+    if call.starred or any(name is None for name, _ in call.keywords):
+        return False, None
+    if position < len(call.arguments):
+        return True, call.arguments[position]
+    return True, next((value for name, value in call.keywords if name == keyword), None)
+
+
+def _is_none(value: Value | None, defs: Mapping[Value, Instruction]) -> bool:
+    constant = defs.get(value) if value is not None else None
+    return value is None or (isinstance(constant, Constant) and constant.value is None)
+
+
+def _literal_entries(value: Value | None, defs: Mapping[Value, Instruction], uses: DefUse) -> Mapping[str, Value] | None:
+    """The entries of a context, by key: none for an absent context, None unless it is a
+    dict literal with constant keys that nothing else uses."""
+
+    if _is_none(value, defs):
+        return {}
+    built = defs.get(value) if value is not None else None
+    if value is None or not isinstance(built, BuildDict) or built.unpacked or len(uses.uses(value)) != 1:
+        return None
+    entries: dict[str, Value] = {}
+    for key, item in built.items:
+        constant = defs.get(key)
+        if not isinstance(constant, Constant) or not isinstance(constant.value, str):
+            return None
+        entries[constant.value] = item
+    return entries
+
+
+class TemplateCallsAnalysis(Analysis[TemplateCalls]):
+    """The filter calls renders make, provided by the engine for a project; none on its
+    own."""
+
+    name: ClassVar[str] = "interprocedural.template_calls"
+
+    @classmethod
+    def compute(cls, ctx: AnalysisContext) -> TemplateCalls:
+        return TemplateCalls()
+
+
 class ClearingAnalysis(Analysis[Clearing]):
     """What calls clear, provided by the engine from the security models; nothing on its
     own, so a summary then keeps every kind."""
@@ -278,6 +407,7 @@ class _DependenceProblem(DataflowProblem[State]):
         project: Mapping[SymbolId, FunctionSummary] | None = None,
         heap: HeapFacts | None = None,
         clearing: Clearing | None = None,
+        templates: TemplateCalls | None = None,
     ) -> None:
         self.name = name
         self.function = function
@@ -286,6 +416,7 @@ class _DependenceProblem(DataflowProblem[State]):
         self.project = project or {}
         self.heap = heap or HeapFacts({})
         self.clearing = clearing or Clearing()
+        self.templates = templates or TemplateCalls()
         self.blocks = {block.id: block for block in function.blocks}
         self.defs: dict[Value, Instruction] = {
             i.result: i for block in function.blocks for i in block.instructions if i.result
@@ -428,6 +559,7 @@ class _DependenceProblem(DataflowProblem[State]):
                 return self.known(project, arguments, keywords, everything, call, state, bound)
             given = self.graph.arguments_at(self.name, call.location)
             self.record(target.symbol, arguments, named, call.location, None, given)
+            self.record_filters(target.symbol, call, given, state)
             cleared = everything.clearing(self.clearing.clears(target.symbol, given))
             return cleared | Dep(externals=frozenset({target.symbol}))
         if isinstance(target, KnownFunction):
@@ -521,6 +653,31 @@ class _DependenceProblem(DataflowProblem[State]):
                 self.store(state, values[mutation.parameter], mutation.field, deps)
         return mapped(callee.return_dependencies, callee.return_cleared) | Dep(externals=callee.return_externals)
 
+    @cached_property
+    def uses(self) -> DefUse:
+        return def_use(self.function)
+
+    def record_filters(self, symbol: SymbolId, call: Call, given: Arguments, state: Mapping[Key, Dep]) -> None:
+        """The filter calls a render makes, each at the filter in its template, with what
+        the context entries reaching its value and its argument depend on. The request the
+        request context processor adds is not followed through a project function."""
+
+        rendering = self.templates.rendering(symbol, call, given, self.defs, self.uses)
+        if rendering is None:
+            return
+        for template_filter in rendering.filters:
+            passed: list[Dep] = []
+            for names in (template_filter.value, template_filter.argument):
+                deps = EMPTY
+                for value, attribute in rendering.values(names):
+                    # Only the kinds of a request object say which of its attributes the
+                    # user controls, and a dependency carries no kinds.
+                    if attribute is None:
+                        deps |= self.deep(value, state)
+                passed.append(deps)
+            if any(deps.parameters for deps in passed):
+                self.record(template_filter.symbol, tuple(passed), (), template_filter.location, None, FILTER_ARGUMENTS)
+
     def record(
         self,
         symbol: SymbolId,
@@ -570,8 +727,9 @@ def summarize(
     heap: HeapFacts | None = None,
     static: bool = False,
     clearing: Clearing | None = None,
+    templates: TemplateCalls | None = None,
 ) -> FunctionSummary:
-    problem = _DependenceProblem(name, function, graph, table, project, heap, clearing)
+    problem = _DependenceProblem(name, function, graph, table, project, heap, clearing, templates)
     solution = solve(problem, cfg)
     problem.external = {}
     problem.returns = EMPTY
@@ -610,7 +768,15 @@ def summarize(
 class SummaryAnalysis(Analysis[SummaryTable]):
     name: ClassVar[str] = "interprocedural.summaries"
     requires: ClassVar[frozenset[AnyAnalysis]] = frozenset(
-        {CallGraphAnalysis, SSAAnalysis, CFGAnalysis, ProjectSummaries, HeapAnalysis, ClearingAnalysis}
+        {
+            CallGraphAnalysis,
+            SSAAnalysis,
+            CFGAnalysis,
+            ProjectSummaries,
+            HeapAnalysis,
+            ClearingAnalysis,
+            TemplateCallsAnalysis,
+        }
     )
 
     @classmethod
@@ -618,6 +784,7 @@ class SummaryAnalysis(Analysis[SummaryTable]):
         graph = ctx.get(CallGraphAnalysis)
         project = ctx.get(ProjectSummaries).summaries
         clearing = ctx.get(ClearingAnalysis)
+        templates = ctx.get(TemplateCallsAnalysis)
         table: dict[str, FunctionSummary] = {}
         supported: dict[str, tuple[FunctionIR, CFG, HeapFacts]] = {}
         for name, function in graph.definitions.items():
@@ -635,9 +802,8 @@ class SummaryAnalysis(Analysis[SummaryTable]):
         while changed:
             changed = False
             for name, (ssa, cfg, heap) in supported.items():
-                updated = summarize(
-                    name, ssa, cfg, graph, table, project, heap, _is_staticmethod(graph.definitions[name]), clearing
-                )
+                static = _is_staticmethod(graph.definitions[name])
+                updated = summarize(name, ssa, cfg, graph, table, project, heap, static, clearing, templates)
                 if updated != table[name]:
                     table[name] = updated
                     changed = True

coretrace_python/plugins/api.py

@@ -33,7 +33,7 @@ from coretrace_python.interprocedural import (
 )
 from coretrace_python.ir.lowering import analyzable_functions
 from coretrace_python.semantic.imports import ImportAnalysis, ImportTable
-from coretrace_python.taint import EntryPointAnalysis, Model
+from coretrace_python.taint import EntryPointAnalysis, Model, ProjectTemplates
 
 PLUGIN_API_VERSION = 1
 
@@ -69,9 +69,10 @@ class ModelPlugin(Plugin):
 
 class ProjectContext:
     """What a project-scoped plugin sees: the module graph, the dependency graph, the
-    advisories every plugin and advisory file contributed, the dependency policy, and
-    each module's imports, call graph and functions. The engine passes the call graphs
-    and functions of modules it served from its cache."""
+    advisories every plugin and advisory file contributed, the dependency policy, each
+    module's imports, call graph and functions, and the project's templates with the
+    filters they call. The engine passes the call graphs and functions of modules it
+    served from its cache."""
 
     def __init__(
         self,
@@ -83,8 +84,10 @@ class ProjectContext:
         policy: Policy | None = None,
         root: Path | None = None,
         functions: Mapping[str, tuple[ModuleFunction, ...]] | None = None,
+        templates: ProjectTemplates | None = None,
     ) -> None:
         self.root = root
+        self.templates = templates or ProjectTemplates()
         self.graph = graph
         self.dependencies = dependencies
         self.advisories = advisories

coretrace_python/taint/__init__.py

@@ -32,19 +32,31 @@ from coretrace_python.taint.models import (
     Validator,
 )
 from coretrace_python.taint.routes import RegisteredRoutes, Routes, registered_routes
-from coretrace_python.taint.templates import EscapedTemplates, escaped_templates
+from coretrace_python.taint.templates import (
+    FILTER_FUNCTIONS,
+    EscapedTemplates,
+    FilterCall,
+    ProjectTemplates,
+    escaped_templates,
+    project_templates,
+    request_processor,
+    unread_renders,
+)
 
 __all__ = [
+    "FILTER_FUNCTIONS",
     "TEXT_KINDS",
     "AuthorizationGuard",
     "EntryPoint",
     "EntryPointAnalysis",
     "EscapedTemplates",
+    "FilterCall",
     "Members",
     "Model",
     "ModelError",
     "ModelTable",
     "NamedParameter",
+    "ProjectTemplates",
     "RegisteredRoutes",
     "RequestObject",
     "RouteRegistrar",
@@ -65,6 +77,9 @@ __all__ = [
     "TypedParameter",
     "Validator",
     "escaped_templates",
+    "project_templates",
     "propagate_taint",
     "registered_routes",
+    "request_processor",
+    "unread_renders",
 ]