# Static Analysis
URL: /kida/docs/advanced/analysis/
Section: advanced
Description: Analyze templates for dependencies, purity, and caching potential
---
> For a complete page index, fetch /kida/llms.txt.
Kida can statically analyze compiled templates to extract dependency information,
determine output purity, and recommend caching strategies — all without rendering.
No other Python template engine provides this capability.
## What Analysis Provides
Every compiled template exposes these analysis results:
| Capability | Method | Returns |
|---|---|---|
| **Context dependencies** | `template.required_context()` | Top-level variable names the template accesses |
| **Full dependency paths** | `template.depends_on()` | Dotted paths like `page.title`, `site.pages` |
| **Block metadata** | `template.block_metadata()` | Per-block purity, dependencies, cache scope |
| **Full metadata** | `template.template_metadata()` | Complete analysis including inheritance info |
| **Cache check** | `template.is_cacheable("nav")` | Whether a block can be safely cached |
| **Context validation** | `template.validate_context(ctx)` | Missing variable names before rendering |
## Quick Start
```python
from kida import Environment, DictLoader
env = Environment(loader=DictLoader({
"page.html": """
{% extends "base.html" %}
{% block title %}{{ page.title }}{% end %}
{% block nav %}
{% end %}
{% block content %}{{ page.content }}{% end %}
""",
"base.html": """
{% block title %}{% end %}
{% block nav %}{% end %}{% block content %}{% end %}
""",
}))
template = env.get_template("page.html")
```
### Check What Variables a Template Needs
```python
>>> template.required_context()
frozenset({'page', 'site'})
```
### Validate Context Before Rendering
```python
>>> template.validate_context({"page": page_obj})
['site'] # 'site' is missing
>>> template.validate_context({"page": page_obj, "site": site_obj})
[] # all required variables present
```
### Inspect Block-Level Metadata
```python
>>> meta = template.block_metadata()
>>> nav = meta["nav"]
>>> nav.depends_on
frozenset({'site.menu'})
>>> nav.is_pure
'pure'
>>> nav.cache_scope
'site'
>>> nav.is_cacheable()
True
```
### Determine Caching Strategy
```python
>>> template.is_cacheable("nav") # site-wide cache
True
>>> template.is_cacheable("content") # page-specific, still cacheable
True
>>> template.is_cacheable() # all blocks cacheable?
True
```
## Analysis Concepts
### Dependencies
The dependency walker extracts every context variable path a template accesses.
Results are *conservative*: they may include paths not taken at runtime (e.g.,
both branches of an `{% if %}`) but never miss a path that is used.
```python
>>> template.depends_on()
frozenset({'page.title', 'page.content', 'site.menu'})
```
`required_context()` extracts just the top-level names:
```python
>>> template.required_context()
frozenset({'page', 'site'})
```
### Purity
A block is **pure** if its output is deterministic given the same inputs.
Pure blocks can be cached safely. Impure blocks (using `random`, `shuffle`,
or similar) must be re-rendered each time.
| Purity | Meaning | Cacheable? |
|---|---|---|
| `"pure"` | Deterministic output | Yes |
| `"impure"` | Uses non-deterministic functions | No |
| `"unknown"` | Cannot determine statically | Treat as impure |
### Cache Scope
Cache scope tells you *how broadly* a block's output can be reused:
| Scope | Meaning | Example |
|---|---|---|
| `"site"` | Same output for every page | Navigation, footer |
| `"page"` | Varies per page but stable for a given page | Content, title |
| `"none"` | Cannot cache (impure block) | Random quotes |
| `"unknown"` | Cannot determine | Mixed dependencies |
### Landmarks
Kida detects HTML5 landmark elements (`