Hook Craft

@unknown: Here are a few practical patterns for “hooks” in Python custom packages, from simple callback registries to packaging entry points and import hooks. Simple hook/callback registry: In your package: https://t.co/hpEnF8qdjq: HOOKS = {"pre_save": [], "post_save": []} def on(event, fn): HOOKS[event].append(fn) def emit(event, kw): [fn(kw) for fn in HOOKS.get(event, [])] https://t.co/ST1gTh0e0u: from .hooks import emit def save(item): emit("pre_save", item=item); ...; emit("post_save", item=item) In an extension: from mypkg.hooks import on @on("pre_save") def validate(item): ... @on("post_save") def log(item): ... Using setuptools entry points for plugin discovery (good for third-party extensions): In core package (mypkg/plugins.py): from importlib.metadata import entry_points def load_plugins(): for ep in entry_points(group="mypkg.plugins"): plugin = ep.load() plugin.register() In a plugin package pyproject.toml: [project.entry-points."mypkg.plugins"] my_plugin = "my_plugin_pkg:plugin" In my_plugin_pkg/init.py: def plugin(): from mypkg.hooks import on @on("pre_save") def redact(item): ... Decorator-based hook API (ergonomic sugar): https://t.co/hpEnF8qdjq: REG = {} def hook(event): def wrap(fn): REG.setdefault(event, []).append(fn); return fn return wrap def emit(event, *a, k): for fn in REG.get(event, []): fn(*a, k) usage: from mypkg.hooks import hook, emit @hook("on_start") def init(): ... emit("on_start") Import hook to modify or instrument modules (advanced): Create a meta path finder/loader to wrap target module on import: import https://t.co/1Ohpis5pCo, importlib.util, sys class Wrapper(https://t.co/1Ohpis5pCo.Loader): def create_module(self, spec): return None def exec_module(self, module): import importlib; real = importlib.import_module("target_real") module.dict.update(real.dict) # Inject hook orig = module.func def wrapped(*a, k): print("pre"); r = orig(*a, k); print("post"); return r module.func = wrapped class Finder(https://t.co/1Ohpis5pCo.MetaPathFinder): def find_spec(self, fullname, path, target=None): if fullname == "target": spec = importlib.util.spec_from_loader(fullname, Wrapper()); return spec sys.meta_path.insert(0, Finder()) Build-time hooks (modern backends): Tools like Hatch/PDM support build hooks to run code pre/post build; handy for generating code, validating schemas, or bundling assets before packaging. Tips: Keep hook names stable and documented. Make hook signatures explicit and pass typed context objects (e.g., Context(item, user, ts)). Validate and sandbox third‑party plugins; catch exceptions per hook so one bad plugin doesn’t break the pipeline. @stringer_kade: @AskPerplexity @Stack_g0blin @berrycomputer make an app that gives you each hook depending on the package you want to create. @unknown: I've built an interactive app that generates custom hook code examples based on the package you're creating! The app lets you choose from 5 different hook patterns (callback registry, decorators, entry points, build hooks, and import hooks), enter your package name and event names, then instantly generates ready-to-use Python code with configuration files—perfect for quickly scaffolding hooks for any custom package you're building.