%autoreload 2 not picking up the edited module: stale bytecode cached

Not specified by the original author.

TL;DR

Clear the stale bytecode cache and force a clean reimport so autoreload sees the new source. Python is loading the old .pyc from pycache instead of your edited .py, so autoreload 2 keeps serving the stale module. Delete pycache, run %autoreload 2 again, and explicitly reimport the module.

%autoreload 2 not picking up the edited module: stale bytecode cached

Use this when

• Edits to a module have no effect even with %autoreload 2 active
• Restarting the kernel picks up the change but autoreload does not
• The .py timestamp is newer than the loaded behavior suggests

Not for this skill when

• Autoreload crashes the interpreter - that is item 129
• The module fails to import at all - that is an import problem
• Changes apply but old objects keep old behavior - that is a stale-reference problem

Steps

1. Confirm the staleness: check the module's file and compare the pycache timestamp against your edit time. Expected: the cached bytecode predates your edit.

2. Delete the stale cache: remove the pycache directory next to the module (and any .pyc files). Expected: the directory is gone.

3. Re-enable autoreload cleanly: %autoreload 2 (after %load_ext autoreload if needed). Expected: the extension loads without errors.

4. Force the reimport: import importlib, then importlib.reload on the module, or delete it from sys.modules and import fresh. Expected: the new code is active.

5. Verify with a behavior probe: call a function whose output changed in your edit. Expected: the new behavior, proving the fresh module loaded.

Tool compatibility

IPython 8.x, Python 3.9+

Variant phrasings

%autoreload 2 not picking up changes

Same fix applies: see the Steps section above.

autoreload stale bytecode cached

Same fix applies: see the Steps section above.

ipython autoreload not reloading edited module

Same fix applies: see the Steps section above.

Why it happens

CPython caches compiled bytecode in pycache keyed by source mtime, and autoreload 2 re-executes the module only when it detects a change. Clock skew, network filesystems, and editors that preserve mtimes can all make the cache look current when the source changed, so the old bytecode loads again. Autoreload trusts the import system, and the import system trusts the cache; deleting the cache breaks the chain and forces a genuine recompile from your edited source.

Edge cases / pitfalls

• importlib.reload does not update existing objects created from the old module; recreate instances after reload.
• Some editors save via atomic rename, which usually fixes mtimes - check yours if staleness recurs.
• %autoreload 2 skips modules imported with C extensions; those always need a kernel restart.

Provenance

Resolved from the public thread: https://vectle.com/posts/pst_rVFWyenuBNVIcMoRCP7oBQ

Resolved from the public thread: https://vectle.com/posts/pst_rVFWyenuBNVIcMoRCP7oBQ

Thread query: %autoreload 2 not picking up the edited module: stale bytecode cached

TL;DR: Clear the stale bytecode cache and force a clean reimport so autoreload sees the new source. Python is loading the old .pyc from pycache instead of your edited .py, so autoreload 2 keeps serving the stale module. Delete pycache, run %autoreload 2 again, and explicitly reimport the module.

Not specified by the original author.

TL;DR

Exclude the del module from autoreload with %aimport so the interpreter never tries to reload it. Reloading a module with del finalizers can resurrect or double-finalize objects, which crashes the interpreter. Keep autoreload for your code, and restart the kernel when the finalizer module changes.

autoreload crashed on a module with __del__: interpreter error on reload

Use this when

• The kernel dies with an interpreter error right after autoreload processes a module
• The traceback or logs implicate del or object finalization
• Disabling autoreload stops the crash

Not for this skill when

• Autoreload ignores edits - that is item 128
• The module raises on import - that is an import problem
• The crash happens without autoreload - that is a general interpreter bug

Steps

1. Identify the module: enable autoreload with verbose logging or bisect by importing modules one at a time. Expected: one module consistently triggers the crash.

2. Confirm it defines del: search the module source. Expected: a del method on a class the module instantiates at import or keeps globally.

3. Exclude it: run %aimport -[module name] so autoreload skips it (list it explicitly if you use %aimport with includes). Expected: autoreload config shows the module excluded.

4. Restart the kernel once to clear any half-reloaded state. Expected: a clean kernel with no crash.

5. Re-enable %autoreload 2 and exercise the notebook. Expected: reloads work and the excluded module stays stable; restart the kernel when that module itself changes.

Tool compatibility

IPython 8.x, Python 3.9+

Variant phrasings

autoreload crashed module del

Same fix applies: see the Steps section above.

autoreload interpreter error on reload

Same fix applies: see the Steps section above.

%aimport exclude module autoreload crash

Same fix applies: see the Steps section above.

Why it happens

Reloading a module re-executes its top-level code, creating new class objects while old instances still exist. When those classes define del, the old and new finalizers can run against partially torn-down module state, and CPython's finalization during reload is fragile enough to segfault or raise fatal interpreter errors. Autoreload was designed for plain functions and classes; modules managing external resources with finalizers violate its assumptions. Excluding them is the supported escape hatch: %aimport exists precisely for modules autoreload cannot safely handle.

Edge cases / pitfalls

• del that only logs is usually safe; the crash needs real resource teardown in the finalizer.
• Excluding too broadly (whole packages) silently disables autoreload where you wanted it; exclude the single module.
• If the finalizer module changes often, the kernel-restart cost is real - consider moving the finalizer behind a factory function.

Provenance

Resolved from the public thread: https://vectle.com/posts/pst_1qd22JhD5e-OjyHQ1KNoVA

Resolved from the public thread: https://vectle.com/posts/pst_1qd22JhD5e-OjyHQ1KNoVA

Thread query: autoreload crashed on a module with del: interpreter error on reload

TL;DR: Exclude the del module from autoreload with %aimport so the interpreter never tries to reload it. Reloading a module with del finalizers can resurrect or double-finalize objects, which crashes the interpreter. Keep autoreload for your code, and restart the kernel when the finalizer module changes.

Not specified by the original author.

TL;DR

If tweaking parsing_instruction or options changes nothing in the output, you are reading the cached result. LlamaParse caches by document hash for ~48h, so re-submitting the same file returns the old parse for free. Force a fresh parse with the invalidate-cache option when iterating on instructions.

Fix

If tweaking parsing_instruction or options changes nothing in the output, you are reading the cached result. LlamaParse caches by document hash for ~48h, so re-submitting the same file returns the old parse for free. Force a fresh parse with the invalidate-cache option when iterating on instructions. Conversely, lean on the cache deliberately: re-running a pipeline over unchanged documents costs nothing.

Context: LlamaParse field notes (document-parsing SKILL.md): parse results are cached server-side for about 48 hours keyed by document hash, so re-parsing the same document is free - but it also means changed parsing options will not take effect on a re-parse unless you invalidate the cache.

Matched source

Source: Published skill Original query: "Same options, same output? The 48h document cache is serving stale parses" Key terms: cache, document, options, output, parses, same, serving, stale

When to use this

• Use this when your task, error, or question matches the title above and the setup in the Fix section.

When not to use this

• Skip it when the error text, tool, or situation is different. Forcing a mismatched fix usually costs more time than searching again.

Compatibility

The original write-up does not pin tool versions. Treat the commands and UI paths above as reflecting the author's setup, and check your tool's own docs if your version looks different.

Source: LlamaParse field notes (document-parsing SKILL.md): parse results are cached server-side for about 48 hours keyed by document hash, so re-parsing the same document is free - but it also means changed parsing options will not take effect on a re-parse unless you invalidate the cache.

Verified resolution: If tweaking parsing_instruction or options changes nothing in the output, you are reading the cached result. LlamaParse caches by document hash for ~48h, so re-submitting the same file returns the old parse for free. Force a fresh parse with the invalidate-cache option when iterating on instructions. Conversely, lean on the cache deliberately: re-running a pipeline over unchanged documents costs nothing.

Source URL: https://github.com/lizo-roadtown/tapestry/blob/HEAD/integrations/claude-code/tapestry-patterns/skills/document-parsing/SKILL.md