[{"data":1,"prerenderedAt":1367},["ShallowReactive",2],{"navigation":3,"api-navigation":184,"docyard:\u002Fapi\u002Flanguage\u002Fconfigurable":206,"api-content:\u002Fapi\u002Flanguage\u002Fconfigurable":1365,"docyard:crossref-index":1366},[4,8,155,174,180],{"title":5,"path":6,"stem":7},"Getting Started","\u002Fgetting-started","1.getting-started",{"title":9,"path":10,"stem":11,"children":12},"Learn","\u002Flearn","2.learn",[13,15,66,99,133],{"title":9,"path":10,"stem":14},"2.learn\u002Findex",{"title":16,"path":17,"stem":18,"children":19},"Tutorials","\u002Flearn\u002Ftutorials","2.learn\u002F1.tutorials\u002Findex",[20,21,26,30,34,38,42,46,50,54,58,62],{"title":16,"path":17,"stem":18},{"title":22,"path":23,"stem":24,"icon":25},"Why Laco?","\u002Flearn\u002Ftutorials\u002Fwhy-laco","2.learn\u002F1.tutorials\u002F01.why-laco","i-lucide-notebook",{"title":27,"path":28,"stem":29,"icon":25},"First Steps with Laco","\u002Flearn\u002Ftutorials\u002Ffirst-steps","2.learn\u002F1.tutorials\u002F02.first-steps",{"title":31,"path":32,"stem":33,"icon":25},"Lazy Call and Partial","\u002Flearn\u002Ftutorials\u002Flazy-call-and-partial","2.learn\u002F1.tutorials\u002F03.lazy-call-and-partial",{"title":35,"path":36,"stem":37,"icon":25},"Hyperparameters and Interpolation","\u002Flearn\u002Ftutorials\u002Fhyperparameters-and-interpolation","2.learn\u002F1.tutorials\u002F04.hyperparameters-and-interpolation",{"title":39,"path":40,"stem":41,"icon":25},"Loading, Saving, and the CLI","\u002Flearn\u002Ftutorials\u002Floading-saving-cli","2.learn\u002F1.tutorials\u002F05.loading-saving-cli",{"title":43,"path":44,"stem":45,"icon":25},"Nested Configs and Containers","\u002Flearn\u002Ftutorials\u002Fnested-configs-and-containers","2.learn\u002F1.tutorials\u002F06.nested-configs-and-containers",{"title":47,"path":48,"stem":49,"icon":25},"Typed Groups and Schemas","\u002Flearn\u002Ftutorials\u002Ftyped-groups-and-schemas","2.learn\u002F1.tutorials\u002F07.typed-groups-and-schemas",{"title":51,"path":52,"stem":53,"icon":25},"Pipeline Configs","\u002Flearn\u002Ftutorials\u002Fpipeline-configs","2.learn\u002F1.tutorials\u002F08.pipeline-configs",{"title":55,"path":56,"stem":57,"icon":25},"Tasks and the App Loop","\u002Flearn\u002Ftutorials\u002Ftasks-and-app-loop","2.learn\u002F1.tutorials\u002F09.tasks-and-app-loop",{"title":59,"path":60,"stem":61,"icon":25},"Tracing","\u002Flearn\u002Ftutorials\u002Ftracing","2.learn\u002F1.tutorials\u002F10.tracing",{"title":63,"path":64,"stem":65,"icon":25},"Production Patterns","\u002Flearn\u002Ftutorials\u002Fproduction-patterns","2.learn\u002F1.tutorials\u002F11.production-patterns",{"title":67,"path":68,"stem":69,"children":70},"Concepts","\u002Flearn\u002Fconcepts","2.learn\u002F2.concepts\u002Findex",[71,72,76,80,84,88,92,95],{"title":67,"path":68,"stem":69},{"title":73,"path":74,"stem":75},"Config as Python","\u002Flearn\u002Fconcepts\u002Fconfig-as-python","2.learn\u002F2.concepts\u002F1.config-as-python",{"title":77,"path":78,"stem":79},"Lazy Construction","\u002Flearn\u002Fconcepts\u002Flazy-construction","2.learn\u002F2.concepts\u002F2.lazy-construction",{"title":81,"path":82,"stem":83},"Lie-Typing","\u002Flearn\u002Fconcepts\u002Flie-typing","2.learn\u002F2.concepts\u002F3.lie-typing",{"title":85,"path":86,"stem":87},"Interpolation","\u002Flearn\u002Fconcepts\u002Finterpolation","2.learn\u002F2.concepts\u002F4.interpolation",{"title":89,"path":90,"stem":91},"Typed Groups","\u002Flearn\u002Fconcepts\u002Ftyped-groups","2.learn\u002F2.concepts\u002F5.typed-groups",{"title":59,"path":93,"stem":94},"\u002Flearn\u002Fconcepts\u002Ftracing","2.learn\u002F2.concepts\u002F6.tracing",{"title":96,"path":97,"stem":98},"App Loop","\u002Flearn\u002Fconcepts\u002Fapp-loop","2.learn\u002F2.concepts\u002F7.app-loop",{"title":100,"path":101,"stem":102,"children":103},"How-To Guides","\u002Flearn\u002Fhow-to","2.learn\u002F3.how-to\u002Findex",[104,105,109,113,117,121,125,129],{"title":100,"path":101,"stem":102},{"title":106,"path":107,"stem":108},"Override Configs","\u002Flearn\u002Fhow-to\u002Foverride-configs","2.learn\u002F3.how-to\u002F1.override-configs",{"title":110,"path":111,"stem":112},"Safe Loading","\u002Flearn\u002Fhow-to\u002Fsafe-loading","2.learn\u002F3.how-to\u002F2.safe-loading",{"title":114,"path":115,"stem":116},"Custom Resolvers","\u002Flearn\u002Fhow-to\u002Fcustom-resolvers","2.learn\u002F3.how-to\u002F3.custom-resolvers",{"title":118,"path":119,"stem":120},"Lint and Strict Mode","\u002Flearn\u002Fhow-to\u002Flint-and-strict","2.learn\u002F3.how-to\u002F4.lint-and-strict",{"title":122,"path":123,"stem":124},"Publishing a reproducible app with laco app","\u002Flearn\u002Fhow-to\u002Flaco-app","2.learn\u002F3.how-to\u002F5.laco-app",{"title":126,"path":127,"stem":128},"Reproduce an Experiment","\u002Flearn\u002Fhow-to\u002Freproduce-experiment","2.learn\u002F3.how-to\u002F6.reproduce-experiment",{"title":130,"path":131,"stem":132},"Migrate from argparse","\u002Flearn\u002Fhow-to\u002Fmigrate-from-argparse","2.learn\u002F3.how-to\u002F7.migrate-from-argparse",{"title":134,"path":135,"stem":136,"children":137},"Examples Curriculum","\u002Flearn\u002Fexamples","2.learn\u002F4.examples\u002Findex",[138,139,143,147,151],{"title":134,"path":135,"stem":136},{"title":140,"path":141,"stem":142},"Foundation Examples","\u002Flearn\u002Fexamples\u002Ffoundations","2.learn\u002F4.examples\u002F1.foundations",{"title":144,"path":145,"stem":146},"Building Blocks","\u002Flearn\u002Fexamples\u002Fbuilding-blocks","2.learn\u002F4.examples\u002F2.building-blocks",{"title":148,"path":149,"stem":150},"Typed-Group Variants","\u002Flearn\u002Fexamples\u002Ftyped-variants","2.learn\u002F4.examples\u002F3.typed-variants",{"title":152,"path":153,"stem":154},"End-to-End Pipelines","\u002Flearn\u002Fexamples\u002Fpipelines","2.learn\u002F4.examples\u002F4.pipelines",{"title":156,"path":157,"stem":158,"children":159},"Resources","\u002Fresources","3.resources",[160,162,166,170],{"title":156,"path":157,"stem":161},"3.resources\u002Findex",{"title":163,"path":164,"stem":165},"Integrations","\u002Fresources\u002Fintegrations","3.resources\u002F1.integrations",{"title":167,"path":168,"stem":169},"Migration guide: Laco 0.x → 1.0","\u002Fresources\u002Fmigration-0.x-to-1.0","3.resources\u002F2.migration-0.x-to-1.0",{"title":171,"path":172,"stem":173},"Laco vs hydra-zen","\u002Fresources\u002Flaco-vs-hydra-zen","3.resources\u002F3.laco-vs-hydra-zen",{"title":175,"path":176,"stem":177,"children":178},"API Reference","\u002Fapi","4.api\u002Findex",[179],{"title":175,"path":176,"stem":177},{"title":181,"path":182,"stem":183},"Lazy Configuration for Python","\u002F","index",[185,188,191,194,197,200,203],{"title":186,"path":187},"cli","\u002Fapi\u002Fcli",{"title":189,"path":190},"compat","\u002Fapi\u002Fcompat",{"title":192,"path":193},"handler","\u002Fapi\u002Fhandler",{"title":195,"path":196},"keys","\u002Fapi\u002Fkeys",{"title":198,"path":199},"language","\u002Fapi\u002Flanguage",{"title":201,"path":202},"ops","\u002Fapi\u002Fops",{"title":204,"path":205},"utils","\u002Fapi\u002Futils",{"docyard":207,"language":208,"name":209,"version":210,"items":211},"1","python","laco","unknown",[212,221,251,261,267,275,282,288,295,303,309,316,324,330,337,344,351,358,365,372,378,385,392,399,406,413,420,427,434,441,448,454,461,467,475,483,491,499,508,514,563,571,578,587,596,604,613,621,647,652,659,668,674,682,688,696,701,710,716,725,731,740,746,753,767,786,793,799,806,827,836,845,854,860,867,874,881,888,895,921,932,938,945,952,958,969,975,982,987,1002,1008,1015,1021,1036,1053,1061,1078,1086,1093,1099,1105,1111,1117,1123,1129,1136,1145,1154,1159,1166,1173,1182,1190,1198,1206,1214,1222,1251,1273,1281,1289,1295,1314,1324,1330,1335,1347],{"id":209,"kind":213,"path":214,"signature":215,"summary":216,"description":217,"source":218},"module",[209],"module laco","Laco ========","LAzy COnfiguration (LACO) system, inspired by and based on Detectron2 and Hydra.",{"file":219,"line":220},"laco\u002F__init__.py",1,{"id":222,"kind":223,"path":224,"signature":226,"summary":227,"description":228,"params":229,"source":248,"parent":209},"laco.main","function",[209,225],"main","def main(fn: Callable | None = None, config_name: str = 'config', config_path: str | None = None, version_base: str | None = None) -> Callable","Hydra app entry-point decorator (task **B7**).","Combines ``@hydra.main`` with :func:`laco.language.task` semantics:\nHydra composes the config from the defaults list and CLI overrides;\n:func:`~laco.language.task` then instantiates each config field whose\nname matches a declared parameter and calls the function with those\nkwargs.\n\nUsage::\n\n    @laco.main(config_name=\"train\", config_path=\"configs\")\n    @L.task\n    def run(model: nn.Module, optimizer: functools.partial, epochs: int = 10): ...\n\n\n    # Or rely on implicit @L.task wrapping:\n    @laco.main(config_name=\"train\")\n    def run(model: nn.Module, epochs: int = 10): ...\n\n\n    if __name__ == \"__main__\":\n        run()",[230,235,240,245],{"name":231,"type":232,"default":233,"doc":234},"fn","callable","None","When used as ``@laco.main`` (bare), the task function. When called\nwith keyword arguments (``@laco.main(config_name=...)``), ``fn`` is\n``None`` and a decorator factory is returned.",{"name":236,"type":237,"default":238,"doc":239},"config_name","str","``\"config\"``","Forwarded to ``@hydra.main``. The name of the top-level config (without\n``.yaml`` extension).",{"name":241,"type":242,"default":243,"doc":244},"config_path","str or None","``None``","Forwarded to ``@hydra.main``. Path to the config directory. ``None``\ndelegates path resolution to Hydra's default search path.",{"name":246,"type":242,"default":243,"doc":247},"version_base","Forwarded to ``@hydra.main``. ``None`` defers to Hydra's default\n(currently ``\"1.1\"`` in Hydra 1.3).",{"file":249,"line":250},"laco\u002F_app.py",18,{"id":252,"kind":223,"path":253,"signature":255,"summary":256,"description":257,"source":258,"parent":209},"laco.register_resolvers",[209,254],"register_resolvers","def register_resolvers(replace: bool = False) -> None","Register Laco's bundled OmegaConf resolvers.","Idempotent at the Laco level: a second call from inside this process is a\nno-op unless ``replace=True`` is passed. At the OmegaConf layer the\nregistration always uses ``replace=True`` so we never trip over a\npre-existing resolver registered by another package or by a previous\nprocess state in long-running interpreters. Safe to call from user code\nand from Hydra plugin hooks.",{"file":259,"line":260},"laco\u002F_resolvers.py",32,{"id":262,"kind":213,"path":263,"signature":264,"source":265,"parent":209},"laco.ops",[209,201],"module laco.ops",{"file":266,"line":220},"laco\u002Fops.py",{"id":268,"kind":223,"path":269,"signature":271,"summary":272,"source":273,"parent":262},"laco.ops.identity",[209,201,270],"identity","def identity(value: T) -> T","Return *value* unchanged. Used as the ``_target_`` for ``L.just`` nodes.",{"file":266,"line":274},4,{"id":276,"kind":223,"path":277,"signature":279,"source":280,"parent":262},"laco.ops.repeat",[209,201,278],"repeat","def repeat(num: int, src: O) -> list[O]",{"file":266,"line":281},9,{"id":283,"kind":213,"path":284,"signature":285,"source":286,"parent":209},"laco.handler",[209,192],"module laco.handler",{"file":287,"line":220},"laco\u002Fhandler.py",{"id":289,"kind":290,"path":291,"signature":293,"source":294,"parent":283},"laco.handler.ConfigsPathHandler","type",[209,192,292],"ConfigsPathHandler","class ConfigsPathHandler(metahandlers.EntryPointsPathHandler):",{"file":287,"line":274},{"id":296,"kind":297,"path":298,"signature":300,"source":301,"parent":289},"laco.handler.ConfigsPathHandler.__init__","method",[209,192,292,299],"__init__","def __init__(self)",{"file":287,"line":302},5,{"id":304,"kind":213,"path":305,"signature":306,"source":307,"parent":209},"laco.keys",[209,195],"module laco.keys",{"file":308,"line":220},"laco\u002Fkeys.py",{"id":310,"kind":290,"path":311,"signature":313,"source":314,"parent":304},"laco.keys.LazyKey",[209,195,312],"LazyKey","class LazyKey(enum.StrEnum):",{"file":308,"line":315},6,{"id":317,"kind":318,"path":319,"signature":321,"source":322,"parent":310},"laco.keys.LazyKey.CALL","constant",[209,195,312,320],"CALL","CALL = '_target_'",{"file":308,"line":323},8,{"id":325,"kind":318,"path":326,"signature":328,"source":329,"parent":310},"laco.keys.LazyKey.ARGS",[209,195,312,327],"ARGS","ARGS = '_args_'",{"file":308,"line":281},{"id":331,"kind":318,"path":332,"signature":334,"source":335,"parent":310},"laco.keys.LazyKey.PARTIAL",[209,195,312,333],"PARTIAL","PARTIAL = '_partial_'",{"file":308,"line":336},10,{"id":338,"kind":318,"path":339,"signature":341,"source":342,"parent":310},"laco.keys.LazyKey.CONVERT",[209,195,312,340],"CONVERT","CONVERT = '_convert_'",{"file":308,"line":343},11,{"id":345,"kind":318,"path":346,"signature":348,"source":349,"parent":310},"laco.keys.LazyKey.RECURSIVE",[209,195,312,347],"RECURSIVE","RECURSIVE = '_recursive_'",{"file":308,"line":350},12,{"id":352,"kind":318,"path":353,"signature":355,"source":356,"parent":310},"laco.keys.LazyKey.WRAPPERS",[209,195,312,354],"WRAPPERS","WRAPPERS = '_zen_wrappers_'",{"file":308,"line":357},13,{"id":359,"kind":318,"path":360,"signature":362,"source":363,"parent":310},"laco.keys.LazyKey.META",[209,195,312,361],"META","META = '_zen_meta_'",{"file":308,"line":364},14,{"id":366,"kind":318,"path":367,"signature":369,"source":370,"parent":304},"laco.keys.LAZY_CALL",[209,195,368],"LAZY_CALL","LAZY_CALL: typing.Final[str] = LazyKey.CALL.value",{"file":308,"line":371},17,{"id":373,"kind":318,"path":374,"signature":376,"source":377,"parent":304},"laco.keys.LAZY_ARGS",[209,195,375],"LAZY_ARGS","LAZY_ARGS: typing.Final[str] = LazyKey.ARGS.value",{"file":308,"line":250},{"id":379,"kind":318,"path":380,"signature":382,"source":383,"parent":304},"laco.keys.LAZY_PART",[209,195,381],"LAZY_PART","LAZY_PART: typing.Final[str] = LazyKey.PARTIAL.value",{"file":308,"line":384},19,{"id":386,"kind":318,"path":387,"signature":389,"source":390,"parent":304},"laco.keys.LAZY_CONVERT",[209,195,388],"LAZY_CONVERT","LAZY_CONVERT: typing.Final[str] = LazyKey.CONVERT.value",{"file":308,"line":391},20,{"id":393,"kind":318,"path":394,"signature":396,"source":397,"parent":304},"laco.keys.LAZY_RECURSIVE",[209,195,395],"LAZY_RECURSIVE","LAZY_RECURSIVE: typing.Final[str] = LazyKey.RECURSIVE.value",{"file":308,"line":398},21,{"id":400,"kind":318,"path":401,"signature":403,"source":404,"parent":304},"laco.keys.LAZY_WRAPPERS",[209,195,402],"LAZY_WRAPPERS","LAZY_WRAPPERS: typing.Final[str] = LazyKey.WRAPPERS.value",{"file":308,"line":405},22,{"id":407,"kind":318,"path":408,"signature":410,"source":411,"parent":304},"laco.keys.LAZY_META",[209,195,409],"LAZY_META","LAZY_META: typing.Final[str] = LazyKey.META.value",{"file":308,"line":412},23,{"id":414,"kind":318,"path":415,"signature":417,"source":418,"parent":304},"laco.keys.CONFIG_VERSION",[209,195,416],"CONFIG_VERSION","CONFIG_VERSION: typing.Final[str] = 'version'",{"file":308,"line":419},26,{"id":421,"kind":318,"path":422,"signature":424,"source":425,"parent":304},"laco.keys.CONFIG_NAME",[209,195,423],"CONFIG_NAME","CONFIG_NAME: typing.Final[str] = 'name'",{"file":308,"line":426},27,{"id":428,"kind":318,"path":429,"signature":431,"source":432,"parent":304},"laco.keys.CONFIG_DEFAULTS",[209,195,430],"CONFIG_DEFAULTS","CONFIG_DEFAULTS: typing.Final[str] = 'defaults'",{"file":308,"line":433},28,{"id":435,"kind":318,"path":436,"signature":438,"source":439,"parent":304},"laco.keys.CONFIG_HYDRA",[209,195,437],"CONFIG_HYDRA","CONFIG_HYDRA: typing.Final[str] = 'hydra'",{"file":308,"line":440},29,{"id":442,"kind":318,"path":443,"signature":445,"source":446,"parent":304},"laco.keys.CONFIG_LACO_SCHEMA",[209,195,444],"CONFIG_LACO_SCHEMA","CONFIG_LACO_SCHEMA: typing.Final[str] = '_laco_'",{"file":308,"line":447},31,{"id":449,"kind":318,"path":450,"signature":452,"source":453,"parent":304},"laco.keys.LACO_SCHEMA_VERSION",[209,195,451],"LACO_SCHEMA_VERSION","LACO_SCHEMA_VERSION: typing.Final[int] = 1",{"file":308,"line":260},{"id":455,"kind":213,"path":456,"signature":457,"summary":458,"source":459,"parent":209},"laco.cli",[209,186],"module laco.cli","Laco command-line interface.",{"file":460,"line":220},"laco\u002Fcli.py",{"id":462,"kind":223,"path":463,"signature":464,"source":465,"parent":455},"laco.cli.main",[209,186,225],"def main()",{"file":460,"line":466},863,{"id":468,"kind":213,"path":469,"signature":470,"summary":471,"description":472,"source":473,"parent":209},"laco.compat",[209,189],"module laco.compat","Backward-compatibility shim for 0.x Laco configs (task G32a).","Importing this module installs a :func:`migrate_target` hook that rewrites\nlegacy ``_target_: laco.ops.partial`` nodes to the canonical\n``_partial_: true`` Hydra representation.",{"file":474,"line":220},"laco\u002Fcompat.py",{"id":476,"kind":223,"path":477,"signature":479,"summary":480,"source":481,"parent":468},"laco.compat.install",[209,189,478],"install","def install() -> None","Install the 0.x → v1 ``migrate_target`` hook into :mod:`laco._lazy`.",{"file":474,"line":482},39,{"id":484,"kind":223,"path":485,"signature":487,"summary":488,"source":489,"parent":468},"laco.compat.uninstall",[209,189,486],"uninstall","def uninstall() -> None","Remove the compat hook, restoring the identity migrate_target.",{"file":474,"line":490},46,{"id":492,"kind":213,"path":493,"signature":494,"summary":495,"description":496,"source":497,"parent":209},"laco.language",[209,198],"module laco.language","Configuration language — the lie-typing scaffolding ====================================================","This module exposes the user-facing DSL used to author Laco configuration\nfiles: :func:`call`, :func:`partial`, :func:`node`, :func:`ref`, the typed\ncontainer macros (:class:`Dict`, :class:`List`, :class:`Tuple`, :class:`Set`,\n:class:`OrderedDict`), the :func:`params` decorator, and the tracing API\n(:func:`configurable`, :func:`trace`).",{"file":498,"line":220},"laco\u002Flanguage.py",{"id":500,"kind":290,"path":501,"signature":503,"summary":504,"description":505,"source":506,"parent":492},"laco.language.LazyCallIntrospectionWarning",[209,198,502],"LazyCallIntrospectionWarning","class LazyCallIntrospectionWarning(UserWarning):","Emitted once per ``L.call`` decoration when ``inspect.signature`` cannot describe the target (e.g. C-extension callables like :class:`range`).","A target that cannot be introspected silently degrades to the\n``strict=False`` behaviour — kwargs are not validated at config-construction\ntime. This warning surfaces the gap so authors can either pass ``strict=False``\nexplicitly (suppressing the warning) or wrap the target in a thin Python\nshim that exposes a signature.",{"file":498,"line":507},165,{"id":509,"kind":290,"path":510,"signature":511,"source":512,"parent":492},"laco.language.ConvertMode",[209,198,511],"ConvertMode",{"file":498,"line":513},301,{"id":515,"kind":223,"path":516,"signature":518,"summary":519,"description":520,"params":521,"source":561,"parent":492},"laco.language.call",[209,198,517],"call","def call(target: Callable[P, L], reserved_ok: typing.Collection[str] = (), expand_args: bool = False, include_defaults: bool = False, convert: ConvertMode = 'all', recursive: bool | None = None, wrappers: typing.Sequence[typing.Any] | None = None, meta: typing.Mapping[str, typing.Any] | None = None, strict: bool = True, root: bool = False) -> Callable[P, L] | Callable[P, omegaconf.DictConfig]","Perform a lazy call to a function or class.","This is fiction #1 in the lie-typing contract — see the module docstring\nsection \"The five fictions\" for the table. The returned callable claims\nto return ``_L`` (the static return type of ``target``); at runtime it\nproduces an :class:`omegaconf.DictConfig` node that\n:func:`laco.instantiate` later materialises.",[522,525,530,535,538,543,546,550,554,558],{"name":523,"type":232,"doc":524},"target","The target function or class to call.",{"name":526,"type":527,"default":528,"doc":529},"reserved_ok","collection of str","()","A collection of reserved keys that are allowed in the kwargs.",{"name":531,"type":532,"default":533,"doc":534},"expand_args","bool","False","Whether to expand the first positional argument as *args. If True, only one\npositional argument is allowed, and it will be expanded as *args. If False, the\nfirst and second positional arguments are passed as *args.",{"name":536,"type":532,"default":533,"doc":537},"include_defaults","Whether to include default values of the target function into the configuration.\nParameters with no default value are emitted as :data:`omegaconf.MISSING`,\nso that downstream :func:`laco.instantiate` raises a precise\n``MissingMandatoryValue`` rather than an opaque constructor ``TypeError``.\nCovers ``POSITIONAL_ONLY``, ``POSITIONAL_OR_KEYWORD`` and ``KEYWORD_ONLY``\nparameters; ``*args`` \u002F ``**kwargs`` are skipped.",{"name":539,"type":540,"default":541,"doc":542},"convert","(none, partial, object, all)","\"none\"","Hydra ``_convert_`` strategy emitted onto the node. Defaults to ``\"all\"`` so\nthat vanilla ``hydra.utils.instantiate`` preserves Laco's historical recursive\ncontainer-conversion semantics on round-tripped YAML. All four modes are\nhonoured at instantiate-time (``laco.instantiate`` delegates to\n``hydra.utils.instantiate``).",{"name":544,"type":532,"default":233,"doc":545},"recursive","Hydra ``_recursive_`` knob. When provided, emitted into the node. ``None``\nleaves the key off the node, falling back to the consumer's default.",{"name":547,"type":548,"default":233,"doc":549},"wrappers","sequence of callables","List of post-processing wrappers emitted as ``_zen_wrappers_`` onto the\nnode (hydra-zen parity). ``laco.instantiate`` does **not** process this\nkey — it is forwarded as-is to ``hydra.utils.instantiate``, which will\npass it as a keyword argument to the target and raise ``TypeError`` for\nany target without ``**kwargs``. Consume via hydra-zen's ``instantiate``\nor a custom instantiation backend. Must be a sequence (not a bare string).",{"name":551,"type":552,"default":233,"doc":553},"meta","mapping","Metadata dict emitted as ``_zen_meta_`` onto the node (hydra-zen parity).\nSame forwarding caveat as ``wrappers``.",{"name":555,"type":532,"default":556,"doc":557},"strict","``True``","When ``True`` and ``target`` is a callable whose signature can be\nintrospected via :func:`inspect.signature`, the kwargs passed to the\nreturned wrapper are validated at config-construction time: any kwarg\nthat is not a declared parameter (and the target does not accept\n``**kwargs``) raises :class:`TypeError` with the target name and the\noffending kwarg(s). Reserved Laco keys (``_target_``, ``_args_``, ...)\nand any keys opted in via ``reserved_ok`` are exempt. When the target's\nsignature cannot be introspected (e.g. a C-extension callable), a\n:class:`LazyCallIntrospectionWarning` is emitted once and validation is\nskipped — equivalent to ``strict=False``. Set ``strict=False``\nexplicitly to opt out for dynamic targets (and to suppress the warning).",{"name":559,"type":532,"default":533,"doc":560},"root","If True, the returned callable will be typed as returning a `DictConfig`, which\nis useful for defining the root of a configuration tree.",{"file":498,"line":562},336,{"id":564,"kind":223,"path":565,"signature":567,"summary":568,"source":569,"parent":492},"laco.language.pairs",[209,198,566],"pairs","def pairs(node: DictConfig | typing.Mapping) -> typing.Iterator[tuple[str, typing.Any]]","Key-value pairs from a configuration node, where special keys are ignored.",{"file":498,"line":570},525,{"id":572,"kind":290,"path":573,"signature":575,"source":576,"parent":492},"laco.language.NodeSpec",[209,198,574],"NodeSpec","class NodeSpec:",{"file":498,"line":577},543,{"id":579,"kind":223,"path":580,"signature":582,"summary":583,"description":584,"source":585,"parent":492},"laco.language.node",[209,198,581],"node","def node(_: type[T]) -> type[T]","Uses a template :class:`ConfigNode` to define an OmegaConf node that has the same fields as the template.","The type checker will treat the resulting object as a :class:`ConfigNode`, but\nat runtime the resulting object is a regular OmegaConf node based on the fields\nof the template — see the module docstring for the lie-typing contract.",{"file":498,"line":586},548,{"id":588,"kind":223,"path":589,"signature":591,"summary":592,"description":593,"source":594,"parent":492},"laco.language.ref",[209,198,590],"ref","def ref(target: str) -> R","Reference to another variable in the configuration using an OmegaConf interpolation string.","The type checker pretends the reference resolves to ``_R``; at runtime it\nis the raw ``${...}`` interpolation string that OmegaConf resolves later.",{"file":498,"line":595},568,{"id":597,"kind":598,"path":599,"signature":601,"source":602,"parent":492},"laco.language.required","property",[209,198,600],"required","required: _Required = _Required()",{"file":498,"line":603},593,{"id":605,"kind":223,"path":606,"signature":608,"summary":609,"description":610,"source":611,"parent":492},"laco.language.just",[209,198,607],"just","def just(value: T) -> T","Wrap an arbitrary value in a config node (task **C27a**).","``L.just(obj)`` is the third lie in the lie-typing contract — see the\nmodule docstring section \"The five fictions\". The returned node carries\n``_target_: laco.ops.identity`` and ``value: obj``; instantiation returns\n``obj`` unchanged.\n\nUse this when you need to embed a primitive Python value inside a config\ntree for in-memory composition — e.g. a pre-computed constant or a simple\nobject that OmegaConf can represent natively. Note that non-primitive\nvalues stored via ``just`` will not survive YAML serialization through\nHydra's config store.",{"file":498,"line":612},601,{"id":614,"kind":223,"path":615,"signature":617,"summary":618,"source":619,"parent":492},"laco.language.wrap_on_result",[209,198,616],"wrap_on_result","def wrap_on_result(func_wrap, func_next, **kwargs_next = {})","Run a function on the result of another function. Useful in configuration files when you want to wrap a function on the result of another function, without having to change the keys of the configuration file.",{"file":498,"line":620},621,{"id":622,"kind":223,"path":623,"signature":625,"summary":626,"description":627,"params":628,"returns":642,"source":645,"parent":492},"laco.language.partial",[209,198,624],"partial","def partial(func: Callable[P, R], convert: ConvertMode = 'all', recursive: bool | None = None, wrappers: typing.Sequence[typing.Any] | None = None, meta: typing.Mapping[str, typing.Any] | None = None, strict: bool = True) -> Callable[P, functools.partial[R]]","Partially apply a function with keyword arguments.","Emits a node in the canonical Hydra wire format: ``{_target_: \u003Cfunc path>,\n_partial_: true, ...}``. At instantiation time the node is materialised\nas ``functools.partial(func, **kwargs)``.\n\nThis is fiction #2 in the lie-typing contract — see the module docstring\nsection \"The five fictions\" for the table.\n\n.. note::\n   All kwargs supplied to the returned callable are bound *now* — this\n   surface deliberately offers no deferral, so positional arguments\n   are not part of the contract even though the static ``ParamSpec``\n   admits them. The runtime ``wrapper`` is keyword-only and will\n   reject positionals at call time; the pyright suite under\n   ``tests\u002Ftest_language_typing.py`` locks in the kwargs-only\n   reading.",[629,632,635,636,639,640],{"name":630,"type":232,"doc":631},"func","The function to partially apply.",{"name":539,"type":511,"default":633,"doc":634},"'all'","Hydra ``_convert_`` \u002F ``_recursive_`` knobs. See :func:`call`.",{"name":544,"type":511,"default":633,"doc":634},{"name":547,"type":637,"default":233,"doc":638},"typing.Sequence[typing.Any] | None","Forwarded to the underlying :func:`call`. See :func:`call` for the\nfull documentation; the same limitations apply (``laco.instantiate``\ndoes not process these keys).",{"name":551,"type":637,"default":233,"doc":638},{"name":555,"type":532,"default":556,"doc":641},"Forwarded to the underlying :func:`call`. When ``True`` (the default),\nunknown kwargs are rejected at config-construction time. Pass\n``strict=False`` to opt out for dynamic targets.",{"type":643,"doc":644},"Callable[_P, functools.partial[_R]]","A lazy callable that, when invoked with kwargs matching ``func``'s\n``ParamSpec`` ``_P``, statically yields a ``functools.partial[_R]``\nover ``func``'s return type ``_R``. At runtime the callable emits\na :class:`DictConfig` with ``_partial_: true`` that\n:func:`laco.instantiate` later materialises into a real\n``functools.partial(func, **kwargs)``. Positional arguments are\nnot part of the contract: pyright will type-check them via ``_P``\nbut the runtime ``wrapper`` rejects them.",{"file":498,"line":646},634,{"id":648,"kind":223,"path":649,"signature":279,"source":650,"parent":492},"laco.language.repeat",[209,198,278],{"file":498,"line":651},725,{"id":653,"kind":318,"path":654,"signature":656,"source":657,"parent":492},"laco.language.PATTERN_CONFIG_KEY_STRICT",[209,198,655],"PATTERN_CONFIG_KEY_STRICT","PATTERN_CONFIG_KEY_STRICT = '^[a-zA-Z_][a-zA-Z0-9_]*$'",{"file":498,"line":658},733,{"id":660,"kind":290,"path":661,"signature":663,"summary":664,"description":665,"source":666,"parent":492},"laco.language.Dict",[209,198,662],"Dict","class Dict(_KeywordMacro[dict[str, T]]):","Typed mapping macro — see module docstring fiction #5.","``L.Dict[T](**kwargs: T)`` is statically typed as ``dict[str, T]``; at\nruntime the value is a :class:`DictConfig`.",{"file":498,"line":667},797,{"id":669,"kind":297,"path":670,"signature":671,"source":672,"parent":660},"laco.language.Dict.target",[209,198,662,523],"@classmethod\ndef target(cls, **kwargs: T = {})",{"file":498,"line":673},810,{"id":675,"kind":290,"path":676,"signature":678,"summary":679,"source":680,"parent":492},"laco.language.OrderedDict",[209,198,677],"OrderedDict","class OrderedDict(_PositionalMacro[collections.OrderedDict[str, T]]):","Typed ordered-mapping macro — see module docstring fiction #5.",{"file":498,"line":681},816,{"id":683,"kind":297,"path":684,"signature":685,"source":686,"parent":675},"laco.language.OrderedDict.target",[209,198,677,523],"@classmethod\ndef target(cls, items: list[tuple[str, T]])",{"file":498,"line":687},819,{"id":689,"kind":290,"path":690,"signature":692,"summary":693,"source":694,"parent":492},"laco.language.DictFromItems",[209,198,691],"DictFromItems","class DictFromItems(_PositionalMacro[dict[str, T]]):","Typed mapping-from-items macro — see module docstring fiction #5.",{"file":498,"line":695},825,{"id":697,"kind":297,"path":698,"signature":685,"source":699,"parent":689},"laco.language.DictFromItems.target",[209,198,691,523],{"file":498,"line":700},828,{"id":702,"kind":290,"path":703,"signature":705,"summary":706,"description":707,"source":708,"parent":492},"laco.language.Set",[209,198,704],"Set","class Set(_PositionalMacro[set[T]]):","Typed set macro — see module docstring fiction #5.","``L.Set[T](*args: T)`` is statically typed as ``set[T]``; at runtime the\nvalue is a :class:`DictConfig`.",{"file":498,"line":709},834,{"id":711,"kind":297,"path":712,"signature":713,"source":714,"parent":702},"laco.language.Set.target",[209,198,704,523],"@classmethod\ndef target(cls, items: list[T])",{"file":498,"line":715},845,{"id":717,"kind":290,"path":718,"signature":720,"summary":721,"description":722,"source":723,"parent":492},"laco.language.Tuple",[209,198,719],"Tuple","class Tuple:","Typed heterogeneous tuple macro — see module docstring fiction #5.","Uses :pep:`646` ``TypeVarTuple`` so ``L.Tuple(1, \"a\", 1.0)`` is statically\ntyped as ``tuple[int, str, float]``; at runtime the value is a\n:class:`DictConfig`.",{"file":498,"line":724},854,{"id":726,"kind":297,"path":727,"signature":728,"source":729,"parent":717},"laco.language.Tuple.target",[209,198,719,523],"@classmethod\ndef target(cls, items: typing.Any) -> tuple",{"file":498,"line":730},866,{"id":732,"kind":290,"path":733,"signature":735,"summary":736,"description":737,"source":738,"parent":492},"laco.language.List",[209,198,734],"List","class List(_PositionalMacro[list[T]]):","Typed homogeneous list macro — see module docstring fiction #5.","``L.List[T](*args: T)`` is statically typed as ``list[T]``; at runtime the\nvalue is a :class:`DictConfig`.",{"file":498,"line":739},876,{"id":741,"kind":297,"path":742,"signature":743,"source":744,"parent":732},"laco.language.List.target",[209,198,734,523],"@classmethod\ndef target(cls, items: typing.Any) -> list",{"file":498,"line":745},887,{"id":747,"kind":598,"path":748,"signature":750,"source":751,"parent":492},"laco.language.r",[209,198,749],"r","r: _ResolverNamespace = _ResolverNamespace()",{"file":498,"line":752},1008,{"id":754,"kind":223,"path":755,"signature":757,"summary":758,"description":759,"params":760,"source":765,"parent":492},"laco.language.configurable",[209,198,756],"configurable","def configurable(target: typing.Any = None, strict: bool = True) -> typing.Any","Mark a callable as a configuration boundary for :func:`trace`.","**Outside a trace** the decorated callable executes normally — it is a\ntransparent pass-through. **Inside a trace** it intercepts the call,\nconverts positional arguments to named ones via\n:func:`inspect.Signature.bind` + :meth:`~inspect.BoundArguments.apply_defaults`,\nand emits an equivalent ``L.call`` node without running the target body.\n\nUsage as a bare decorator::\n\n    @L.configurable\n    class Encoder:\n        def __init__(self, depth: int): ...\n\nUsage as a factory (pass options)::\n\n    @L.configurable(strict=False)\n    class Encoder:\n        def __init__(self, depth: int): ...",[761,763],{"name":523,"type":232,"default":233,"doc":762},"When used as ``@L.configurable`` (no parentheses), the wrapped\ncallable is passed here. When used as ``@L.configurable(…)``,\n``target`` is ``None`` and a decorator factory is returned.",{"name":555,"type":532,"default":556,"doc":764},"Forwarded to the underlying :func:`call` during tracing. When\n``True``, unknown kwargs are validated against the target's signature\nat config-construction time. This knob is independent of the\n:func:`trace` ``strict`` flag, which governs the root-value check.",{"file":498,"line":766},1085,{"id":768,"kind":223,"path":769,"signature":771,"summary":772,"description":773,"params":774,"returns":781,"source":784,"parent":492},"laco.language.trace",[209,198,770],"trace","def trace(thunk: typing.Any, strict: bool = False) -> typing.Any","Execute a thunk inside a tracing scope and return the captured config tree.","Within the scope every :func:`configurable`-decorated callable emits a\n``DictConfig`` node instead of running its body. The thunk's return value\nbecomes the root of the captured tree.\n\nThe scope is delimited by the thunk (a zero-argument callable) rather\nthan a ``with`` block so enable\u002Fdisable can never straddle uncontrolled\nevaluation — the ``try\u002Ffinally`` bracket is leak-safe even on exceptions,\nand nesting composes via :class:`~contextvars.ContextVar` tokens::\n\n    cfg = L.trace(lambda: Model(encoder=Encoder(depth=24), dim=768))\n    model = L.instantiate(cfg)",[775,778],{"name":776,"type":232,"doc":777},"thunk","A zero-argument callable whose body describes the configuration.\nSide effects inside the thunk run during tracing — keep bodies\npure-ish.",{"name":555,"type":532,"default":779,"doc":780},"``False``","When ``True`` (or ``False``, in the current implementation), raises\nif the root result is not a config node or OmegaConf primitive. A\nfuture release will add ``L.just``-wrapping for the ``strict=False``\npath once the classifier's third tier is stable.",{"type":782,"doc":783},"DictConfig","Statically typed as ``R`` (the thunk's static return type) — the\nlie-typing contract keeps nested composition tractable. At runtime\nalways a ``DictConfig`` (or OmegaConf primitive, for a\nno-op\u002Fidentity thunk).",{"file":498,"line":785},1205,{"id":787,"kind":290,"path":788,"signature":790,"source":791,"parent":492},"laco.language.ParamsWrapper",[209,198,789],"ParamsWrapper","class ParamsWrapper:",{"file":498,"line":792},1262,{"id":794,"kind":297,"path":795,"signature":796,"source":797,"parent":787},"laco.language.ParamsWrapper.__init__",[209,198,789,299],"def __init__(self, cls: type[T], prefix: str = '', exclude: bool = False, hidden: typing.Iterable[str] | None = None)",{"file":498,"line":798},1265,{"id":800,"kind":297,"path":801,"signature":803,"source":804,"parent":787},"laco.language.ParamsWrapper.__call__",[209,198,789,802],"__call__","def __call__(self) -> dict[str, typing.Any]",{"file":498,"line":805},1305,{"id":807,"kind":223,"path":808,"signature":810,"summary":811,"description":812,"params":813,"source":825,"parent":492},"laco.language.params",[209,198,809],"params","def params(cls: type[T] | None = None, prefix: str = '', exclude: bool = False, hidden: typing.Iterable[str] | None = None) -> type[T]","Create a class that represents a set of hyperparameters.","Accessing an attribute returns an interpolation reference; calling the\nwrapper returns a plain ``dict`` of the declared values.\n\nDecorated classes type-check as dataclasses thanks to :pep:`681`\n``dataclass_transform``: annotated fields (``foo: int = 1``) are treated\nas real dataclass fields by pyright.  At runtime the decoration returns a\n:class:`ParamsWrapper` that emits interpolation references on attribute\naccess.",[814,818,821],{"name":815,"type":237,"default":816,"doc":817},"prefix","``\"\"``","CLI flag prefix for ``laco app``.  ``\"\"`` (default) exposes fields\nflat (``--lr``).  ``None`` uses the class variable name as prefix\n(``--hps-lr``).  Any other string is used verbatim (``--train-lr``).",{"name":819,"type":532,"default":779,"doc":820},"exclude","When ``True`` the entire block is hidden from ``laco app``.",{"name":822,"type":823,"default":233,"doc":824},"hidden","iterable of str","Individual field names to hide from ``laco app`` while keeping them\nin the config.  An alternative to :class:`Hidden` annotations.",{"file":498,"line":826},1309,{"id":828,"kind":290,"path":829,"signature":831,"summary":832,"description":833,"source":834,"parent":492},"laco.language.Hidden",[209,198,830],"Hidden","class Hidden:","Type annotation that hides a ``@L.params`` field from ``laco app``.","Usage::\n\n    @L.params\n    class hps:\n        lr: float = 0.001\n        _internal: L.Hidden[float] = 1.0  # not exposed in laco app",{"file":498,"line":835},1368,{"id":837,"kind":290,"path":838,"signature":840,"summary":841,"description":842,"source":843,"parent":492},"laco.language.Param",[209,198,839],"Param","class Param:","Type annotation marking a module-level variable as a ``laco app`` param.","Shorthand for :func:`param` when no extra metadata is needed; help text\nis parsed from the module or class docstring.\n\nUsage::\n\n    seed: L.Param[int] = 42",{"file":498,"line":844},1380,{"id":846,"kind":290,"path":847,"signature":849,"summary":850,"description":851,"source":852,"parent":492},"laco.language.LacoParam",[209,198,848],"LacoParam","class LacoParam:","Runtime wrapper produced by :func:`param`.","Carries the default value plus optional CLI metadata (help, name,\nchoices, validator).  ``laco app`` reads these to build argparse flags;\n``laco.load`` unwraps the instance to its :attr:`default` in the\n:class:`~omegaconf.DictConfig`.",{"file":498,"line":853},1392,{"id":855,"kind":297,"path":856,"signature":857,"source":858,"parent":846},"laco.language.LacoParam.__init__",[209,198,848,299],"def __init__(self, default: typing.Any, help: str | None = None, name: str | None = None, choices: list[typing.Any] | None = None, validator: typing.Callable[[typing.Any], typing.Any] | None = None) -> None",{"file":498,"line":859},1403,{"id":861,"kind":598,"path":862,"signature":864,"source":865,"parent":846},"laco.language.LacoParam.default",[209,198,848,863],"default","default = default",{"file":498,"line":866},1412,{"id":868,"kind":598,"path":869,"signature":871,"source":872,"parent":846},"laco.language.LacoParam.help",[209,198,848,870],"help","help = help",{"file":498,"line":873},1413,{"id":875,"kind":598,"path":876,"signature":878,"source":879,"parent":846},"laco.language.LacoParam.name",[209,198,848,877],"name","name = name",{"file":498,"line":880},1414,{"id":882,"kind":598,"path":883,"signature":885,"source":886,"parent":846},"laco.language.LacoParam.choices",[209,198,848,884],"choices","choices = choices",{"file":498,"line":887},1415,{"id":889,"kind":598,"path":890,"signature":892,"source":893,"parent":846},"laco.language.LacoParam.validator",[209,198,848,891],"validator","validator = validator",{"file":498,"line":894},1416,{"id":896,"kind":223,"path":897,"signature":899,"summary":900,"description":901,"params":902,"examples":917,"source":919,"parent":492},"laco.language.param",[209,198,898],"param","def param(default: typing.Any, help: str | None = None, name: str | None = None, choices: list[typing.Any] | None = None, validator: typing.Callable[[typing.Any], typing.Any] | None = None) -> typing.Any","Declare a one-off ``laco app`` hyperparameter outside a ``@L.params`` block.","The return value is a :class:`LacoParam` at runtime; ``laco.load``\nunwraps it to *default* in the resulting :class:`~omegaconf.DictConfig`.",[903,906,909,911,914],{"name":863,"type":904,"doc":905},"typing.Any","Default value (also determines the CLI flag type).",{"name":870,"type":907,"default":233,"doc":908},"str | None","Short description shown in ``laco app \u003Cdist> \u003Centry> --help``.",{"name":877,"type":907,"default":233,"doc":910},"Custom CLI flag name.  Defaults to the variable name.",{"name":884,"type":912,"default":233,"doc":913},"list[typing.Any] | None","Restrict valid values.  Validated at parse time.",{"name":891,"type":915,"default":233,"doc":916},"typing.Callable[[typing.Any], typing.Any] | None","Callable (e.g. :class:`Range`, :class:`Choices`) applied after type\nconversion.  Raises :class:`ValueError` on failure.",[918],"::\n\n    seed = L.param(42, help=\"Random seed for reproducibility\")\n    lr = L.param(1e-3, help=\"Learning rate\", validator=L.Range(1e-6, 1.0))\n    opt = L.param(\"adam\", choices=[\"adam\", \"sgd\", \"adamw\"])",{"file":498,"line":920},1419,{"id":922,"kind":290,"path":923,"signature":925,"summary":926,"description":927,"examples":928,"source":930,"parent":492},"laco.language.Range",[209,198,924],"Range","class Range:","Validator: value must lie within ``[min, max]``.","Pass to :func:`param`'s ``validator=`` kwarg.  Both bounds are optional.",[929],"::\n\n    lr = L.param(1e-3, validator=L.Range(1e-6, 1.0))",{"file":498,"line":931},1459,{"id":933,"kind":297,"path":934,"signature":935,"source":936,"parent":922},"laco.language.Range.__init__",[209,198,924,299],"def __init__(self, min: float | None = None, max: float | None = None) -> None",{"file":498,"line":937},1471,{"id":939,"kind":598,"path":940,"signature":942,"source":943,"parent":922},"laco.language.Range.min",[209,198,924,941],"min","min = min",{"file":498,"line":944},1476,{"id":946,"kind":598,"path":947,"signature":949,"source":950,"parent":922},"laco.language.Range.max",[209,198,924,948],"max","max = max",{"file":498,"line":951},1477,{"id":953,"kind":297,"path":954,"signature":955,"source":956,"parent":922},"laco.language.Range.__call__",[209,198,924,802],"def __call__(self, value: typing.Any) -> typing.Any",{"file":498,"line":957},1479,{"id":959,"kind":290,"path":960,"signature":962,"summary":963,"description":964,"examples":965,"source":967,"parent":492},"laco.language.Choices",[209,198,961],"Choices","class Choices:","Validator: value must be one of the given options.","Pass to :func:`param`'s ``validator=`` kwarg.  Prefer the ``choices=``\nkwarg on :func:`param` for a single source of truth.",[966],"::\n\n    opt = L.param(\"adam\", validator=L.Choices(\"adam\", \"sgd\", \"adamw\"))",{"file":498,"line":968},1489,{"id":970,"kind":297,"path":971,"signature":972,"source":973,"parent":959},"laco.language.Choices.__init__",[209,198,961,299],"def __init__(self, *options: typing.Any = ()) -> None",{"file":498,"line":974},1502,{"id":976,"kind":598,"path":977,"signature":979,"source":980,"parent":959},"laco.language.Choices.options",[209,198,961,978],"options","options = list(options)",{"file":498,"line":981},1503,{"id":983,"kind":297,"path":984,"signature":955,"source":985,"parent":959},"laco.language.Choices.__call__",[209,198,961,802],{"file":498,"line":986},1505,{"id":988,"kind":223,"path":989,"signature":991,"summary":992,"description":993,"params":994,"source":1000,"parent":492},"laco.language.task",[209,198,990],"task","def task(fn: typing.Any = None, schema: type | None = None) -> typing.Any","Hydra app task decorator (task **B8**).","Marks a callable as a *task function*: a function that accepts a resolved\n:class:`~omegaconf.DictConfig` and receives its configuration fields as\ntype-instantiated keyword arguments. Only the fields whose names match\ndeclared parameters are extracted and instantiated; the rest are ignored.\n\nThis is the inverse of :func:`laco.language.call` — instead of building\na config node from a callable, it unpacks a config node back into a\ncallable invocation.\n\nUsage::\n\n    @L.task\n    def train(model: nn.Module, optimizer: functools.partial, epochs: int = 10):\n        for _ in range(epochs):\n            ...\n\n    # Combine with laco.main:\n    @laco.main(config_name=\"train\")\n    @L.task\n    def train(...): ...",[995,997],{"name":231,"type":232,"default":233,"doc":996},"When used as ``@L.task`` (bare), the decorated callable is passed here.\nWhen used as ``@L.task(schema=MySchema)``, ``fn`` is ``None`` and a\ndecorator factory is returned.",{"name":998,"type":290,"default":233,"doc":999},"schema","Static annotation for the config schema type. Not enforced at runtime;\nused only for type-checker hints.",{"file":498,"line":1001},1532,{"id":1003,"kind":213,"path":1004,"signature":1005,"source":1006,"parent":209},"laco.utils",[209,204],"module laco.utils",{"file":1007,"line":220},"laco\u002Futils.py",{"id":1009,"kind":223,"path":1010,"signature":1012,"summary":1013,"source":1014,"parent":1003},"laco.utils.check_syntax",[209,204,1011],"check_syntax","def check_syntax(path: expath.PathType)","Validate the syntax of a Python-based configuration file.",{"file":1007,"line":384},{"id":1016,"kind":223,"path":1017,"signature":1019,"source":1020,"parent":1003},"laco.utils.as_omegadict",[209,204,1018],"as_omegadict","def as_omegadict(obj: dict | DictConfig) -> DictConfig",{"file":1007,"line":447},{"id":1022,"kind":223,"path":1023,"signature":1025,"summary":1026,"description":1027,"params":1028,"returns":1032,"source":1034,"parent":1003},"laco.utils.generate_path",[209,204,1024],"generate_path","def generate_path(obj: typing.Any) -> str","Inverse of ``locate()``. Generates the fully qualified name of an object. Handles cases where the object is not directly importable, e.g. due to nested classes or private modules.","The generated path is simplified by removing redundant module parts, e.g.\n``module.submodule._impl.class`` may become ``module.submodule.class`` if\nthe later also resolves to the same object.\n\nBound methods are supported by inspecting the ``__self__`` attribute.",[1029],{"name":1030,"type":904,"doc":1031},"obj","The object to generate the path for.",{"type":237,"doc":1033},"The fully qualified name of the object.",{"file":1007,"line":1035},37,{"id":1037,"kind":223,"path":1038,"signature":1040,"summary":1041,"params":1042,"returns":1045,"raises":1047,"source":1051,"parent":1003},"laco.utils.locate_object",[209,204,1039],"locate_object","def locate_object(path: str) -> typing.Any","Dynamically locates and returns an object by its fully qualified name.",[1043],{"name":877,"doc":1044},"The fully qualified name of the object to locate.",{"type":904,"doc":1046},"The located object.",[1048],{"type":1049,"doc":1050},"ImportError","If the object cannot be located.",{"file":1007,"line":1052},99,{"id":1054,"kind":223,"path":1055,"signature":1057,"summary":1058,"source":1059,"parent":1003},"laco.utils.apply_recursive",[209,204,1056],"apply_recursive","def apply_recursive(cfg: C, func: Callable[[C], None]) -> None","Apply func recursively to all DictConfig in cfg.",{"file":1007,"line":1060},177,{"id":1062,"kind":223,"path":1063,"signature":1065,"summary":1066,"params":1067,"returns":1074,"source":1076,"parent":1003},"laco.utils.check_lazy",[209,204,1064],"check_lazy","def check_lazy(obj: typing.Any, checks: typing.Iterable[Callable] | Callable) -> bool","Check if an object is a lazy call to a target callable.",[1068,1071],{"name":1030,"type":1069,"doc":1070},"any","The object to check.",{"name":523,"type":1072,"doc":1073},"callable or str","The target callable to check against.",{"type":532,"doc":1075},"Whether the object is a lazy call to the target callable.",{"file":1007,"line":1077},192,{"id":1079,"kind":290,"path":1080,"signature":1082,"source":1083,"parent":209},"laco.EnvFilter",[209,1081],"EnvFilter","class EnvFilter(enum.StrEnum):",{"file":1084,"line":1085},"laco\u002F_env.py",15,{"id":1087,"kind":318,"path":1088,"signature":1090,"source":1091,"parent":1079},"laco.EnvFilter.STRING",[209,1081,1089],"STRING","STRING = enum.auto()",{"file":1084,"line":1092},16,{"id":1094,"kind":318,"path":1095,"signature":1097,"source":1098,"parent":1079},"laco.EnvFilter.TRUTHY",[209,1081,1096],"TRUTHY","TRUTHY = enum.auto()",{"file":1084,"line":371},{"id":1100,"kind":318,"path":1101,"signature":1103,"source":1104,"parent":1079},"laco.EnvFilter.FALSY",[209,1081,1102],"FALSY","FALSY = enum.auto()",{"file":1084,"line":250},{"id":1106,"kind":318,"path":1107,"signature":1109,"source":1110,"parent":1079},"laco.EnvFilter.POSITIVE",[209,1081,1108],"POSITIVE","POSITIVE = enum.auto()",{"file":1084,"line":384},{"id":1112,"kind":318,"path":1113,"signature":1115,"source":1116,"parent":1079},"laco.EnvFilter.NEGATIVE",[209,1081,1114],"NEGATIVE","NEGATIVE = enum.auto()",{"file":1084,"line":391},{"id":1118,"kind":318,"path":1119,"signature":1121,"source":1122,"parent":1079},"laco.EnvFilter.NONNEGATIVE",[209,1081,1120],"NONNEGATIVE","NONNEGATIVE = enum.auto()",{"file":1084,"line":398},{"id":1124,"kind":318,"path":1125,"signature":1127,"source":1128,"parent":1079},"laco.EnvFilter.NONPOSITIVE",[209,1081,1126],"NONPOSITIVE","NONPOSITIVE = enum.auto()",{"file":1084,"line":405},{"id":1130,"kind":297,"path":1131,"signature":1133,"source":1134,"parent":1079},"laco.EnvFilter.apply",[209,1081,1132],"apply","@staticmethod\ndef apply(f: EnvFilter | str | None, v: typing.Any) -> bool",{"file":1084,"line":1135},24,{"id":1137,"kind":223,"path":1138,"signature":1140,"summary":1141,"description":1142,"source":1143,"parent":209},"laco.get_env",[209,1139],"get_env","def get_env(__type: type, *keys: str = (), default: typing.Any = None, filter: EnvFilter | None = None) -> typing.Any","Read an environment variable. If the variable is not set, return the default value.","If no default is given, an error is raised if the variable is not set.",{"file":1084,"line":1144},73,{"id":1146,"kind":290,"path":1147,"signature":1149,"summary":1150,"source":1151,"parent":209},"laco.LacoLoadError",[209,1148],"LacoLoadError","class LacoLoadError(RuntimeError):","Raised when :func:`load` cannot parse or execute a config file.",{"file":1152,"line":1153},"laco\u002F_io.py",35,{"id":1155,"kind":297,"path":1156,"signature":1157,"source":1158,"parent":1146},"laco.LacoLoadError.__init__",[209,1148,299],"def __init__(self, path: str, cause: Exception) -> None",{"file":1152,"line":490},{"id":1160,"kind":598,"path":1161,"signature":1163,"source":1164,"parent":1146},"laco.LacoLoadError.path",[209,1148,1162],"path","path = path",{"file":1152,"line":1165},47,{"id":1167,"kind":598,"path":1168,"signature":1170,"source":1171,"parent":1146},"laco.LacoLoadError.cause",[209,1148,1169],"cause","cause = cause",{"file":1152,"line":1172},48,{"id":1174,"kind":318,"path":1175,"signature":1177,"summary":1178,"description":1179,"source":1180,"parent":209},"laco.DEFAULT_SAFE_ALLOWED_MODULES",[209,1176],"DEFAULT_SAFE_ALLOWED_MODULES","DEFAULT_SAFE_ALLOWED_MODULES: typing.Final[tuple[str, ...]] = ('laco', 'omegaconf', 'torch', 'torch.nn')","Default top-level modules a config file may import under :attr:`LoadMode.SAFE`.","A module name *N* is allowed if ``N == e`` or ``N.startswith(e + \".\")`` for any\nentry *e* in the allowlist. Pass ``allowed_modules=`` to :func:`load` to widen\nor narrow this set.",{"file":1152,"line":1181},54,{"id":1183,"kind":290,"path":1184,"signature":1186,"summary":1187,"source":1188,"parent":209},"laco.LoadMode",[209,1185],"LoadMode","class LoadMode(enum.IntFlag):","Flags to control the behavior of the load function.",{"file":1152,"line":1189},387,{"id":1191,"kind":318,"path":1192,"signature":1194,"summary":1195,"source":1196,"parent":1183},"laco.LoadMode.NO_CHECK",[209,1185,1193],"NO_CHECK","NO_CHECK = enum.auto()","Do not check the syntax of the file before loading it.",{"file":1152,"line":1197},390,{"id":1199,"kind":318,"path":1200,"signature":1202,"summary":1203,"source":1204,"parent":1183},"laco.LoadMode.NO_PARSE",[209,1185,1201],"NO_PARSE","NO_PARSE = enum.auto()","Do not parse the path as a URL (overrides and fragment).",{"file":1152,"line":1205},393,{"id":1207,"kind":318,"path":1208,"signature":1210,"summary":1211,"source":1212,"parent":1183},"laco.LoadMode.SAFE",[209,1185,1209],"SAFE","SAFE = enum.auto()","Restrict ``.py`` config exec: enforce an import allowlist and drop dangerous builtins (``open``, ``eval``, ``exec``, ``compile``, ``globals``, ``locals``, ``breakpoint``) from the config file's namespace. The default allowlist is :data:`DEFAULT_SAFE_ALLOWED_MODULES`; pass ``allowed_modules=`` to :func:`load` to widen or narrow it. Without this flag (the default :attr:`DEFAULT`), :func:`load` trusts the config file and executes it with full Python privileges.",{"file":1152,"line":1213},396,{"id":1215,"kind":318,"path":1216,"signature":1218,"summary":1219,"source":1220,"parent":1183},"laco.LoadMode.DEFAULT",[209,1185,1217],"DEFAULT","DEFAULT = 0","Default behavior: trusts the config file.",{"file":1152,"line":1221},405,{"id":1223,"kind":223,"path":1224,"signature":1226,"summary":1227,"params":1228,"returns":1247,"source":1249,"parent":209},"laco.load",[209,1225],"load","def load(path: str | pathlib.Path | os.PathLike, *args: str = (), key: str | None = None, mode: LoadMode | int = LoadMode.DEFAULT, allowed_modules: typing.Sequence[str] | None = None) -> DictConfig","Loads a configuration from a local source.",[1229,1232,1235,1238,1243],{"name":1162,"type":1230,"doc":1231},"str | pathlib.Path | os.PathLike","The path to the configuration file. If it is a string, then it will first\nbe parsed as an URL, where the query is used as overrides and the fragment\nis a nested key to select from the loaded config.",{"name":1233,"type":237,"default":528,"doc":1234},"*args","A list of overrides to apply after loading the config, or a dictionary of\nstrings to strings representing the key-value pairs of overrides.",{"name":1236,"type":907,"default":233,"doc":1237},"key","Key to select from the loaded config after applying overrides.\nIf None, the entire config is returned.",{"name":1239,"type":1240,"default":1241,"doc":1242},"mode","LoadMode | int","LoadMode.DEFAULT","Flags to control the behavior of the function. See :class:`LoadMode` for\nmore details.",{"name":1244,"type":1245,"default":233,"doc":1246},"allowed_modules","typing.Sequence[str] | None","Module-name prefixes a ``.py`` config may import under\n:attr:`LoadMode.SAFE`. ``None`` means use\n:data:`DEFAULT_SAFE_ALLOWED_MODULES`. Ignored when ``SAFE`` is not set.",{"type":782,"doc":1248},"The loaded configuration as a DictConfig object.",{"file":1152,"line":1250},409,{"id":1252,"kind":223,"path":1253,"signature":1255,"summary":1256,"params":1257,"returns":1269,"source":1271,"parent":209},"laco.dump",[209,1254],"dump","def dump(cfg: object, fh: io.StringIO | None = None, with_metadata: bool = False) -> str | None","Dump configuration file to YAML format.",[1258,1262,1266],{"name":1259,"type":1260,"doc":1261},"cfg","object","An omegaconf config object.",{"name":1263,"type":1264,"default":233,"doc":1265},"fh","io.StringIO | None","A file handle to write the config to. If None, a string will be returned.",{"name":1267,"type":532,"default":533,"doc":1268},"with_metadata","If False (the default), Laco-specific provenance keys (``name``,\n``version``) are stripped from the dumped output so it is byte-compatible\nwith canonical Hydra YAML. Only the top-level entries are stripped —\nidentically-named nested keys are treated as user-domain values and\nsurvive untouched. Set to True to preserve top-level metadata.",{"type":237,"doc":1270},"The dumped config file in YAML format.",{"file":1152,"line":1272},605,{"id":1274,"kind":290,"path":1275,"signature":1277,"summary":1278,"source":1279,"parent":209},"laco.SaveMode",[209,1276],"SaveMode","class SaveMode(enum.IntFlag):","Flags to control the behavior of the save function.",{"file":1152,"line":1280},712,{"id":1282,"kind":318,"path":1283,"signature":1285,"summary":1286,"source":1287,"parent":1274},"laco.SaveMode.NO_RELOAD",[209,1276,1284],"NO_RELOAD","NO_RELOAD = enum.auto()","Do not reload the file after saving.",{"file":1152,"line":1288},715,{"id":1290,"kind":318,"path":1291,"signature":1218,"summary":1292,"source":1293,"parent":1274},"laco.SaveMode.DEFAULT",[209,1276,1217],"Default behavior.",{"file":1152,"line":1294},718,{"id":1296,"kind":223,"path":1297,"signature":1299,"summary":1300,"params":1301,"returns":1305,"raises":1308,"source":1312,"parent":209},"laco.save",[209,1298],"save","def save(config: ConfigType, path: str | pathlib.Path | os.PathLike, mode: SaveMode | int = SaveMode.DEFAULT) -> ConfigType | DictConfig","Save a config object to a yaml file.",[1302,1303],{"name":1259,"doc":1261},{"name":1162,"type":1230,"doc":1304},"The file path to save the config file.",{"type":1306,"doc":1307},"ConfigType","The saved config object. If `reload` is True, the reloaded config object is\nreturned.",[1309],{"type":1310,"doc":1311},"AssertionError","If the config cannot be dumped or the post-save check fails.",{"file":1152,"line":1313},722,{"id":1315,"kind":290,"path":1316,"signature":1318,"summary":1319,"description":1320,"source":1321,"parent":209},"laco.LacoCycleError",[209,1317],"LacoCycleError","class LacoCycleError(RuntimeError):","Raised when :func:`instantiate` detects a cyclic configuration graph.","Two distinct failure modes converge here:\n\n* a pre-walk visited-set guard fires when the same container node is\n  re-entered while still on the active recursion path\n  (object-identity cycle);\n* OmegaConf surfaces a structural cycle (``ConfigCycleDetectedException``)\n  or a recursive interpolation cycle (``InterpolationResolutionError``\n  with the \"Recursive interpolation detected\" payload) from below the\n  delegation boundary.\n\nThe exception carries the dotted ``path`` traversed up to the offending\nnode so callers can pin-point the cycle without re-walking the tree.",{"file":1322,"line":1323},"laco\u002F_lazy.py",34,{"id":1325,"kind":297,"path":1326,"signature":1327,"source":1328,"parent":1315},"laco.LacoCycleError.__init__",[209,1317,299],"def __init__(self, message: str, path: str = '') -> None",{"file":1322,"line":1329},51,{"id":1331,"kind":598,"path":1332,"signature":1163,"source":1333,"parent":1315},"laco.LacoCycleError.path",[209,1317,1162],{"file":1322,"line":1334},53,{"id":1336,"kind":223,"path":1337,"signature":1339,"summary":1340,"description":1341,"returns":1342,"source":1345,"parent":209},"laco.instantiate",[209,1338],"instantiate","def instantiate(cfg)","Recursively instantiate a configuration tree.","Delegates to :func:`hydra.utils.instantiate`; honours every Hydra\nknob (``_target_``, ``_args_``, ``_partial_``, ``_convert_``,\n``_recursive_``). Top-level primitives are returned unchanged so\ncallers can pass a leaf without first checking its type.",{"type":1343,"doc":1344},"_L","Statically the same type as ``cfg``: the ``instantiate[_L](cfg:\n_L, \u002F) -> _L`` generic plus the ``LazyObject[_L] -> _L``\noverload form the identity partner to :func:`laco.language.call`\nand friends (issue #8, task 23b). The declared identity holds at\nthe type-checker boundary; at runtime ``DictConfig`` \u002F\n``ListConfig`` inputs are materialised by Hydra and primitive\nleaves listed in ``_PASSTHROUGH_TYPES`` are returned unchanged.",{"file":1322,"line":1346},206,{"id":1348,"kind":223,"path":1349,"signature":1351,"summary":1352,"description":1353,"params":1354,"returns":1361,"source":1363,"parent":209},"laco.apply_overrides",[209,1350],"apply_overrides","def apply_overrides(cfg: DictConfig, overrides: typing.Iterable[str]) -> DictConfig","In-place override contents of cfg.","When the target slot carries a declared structured type (i.e. *cfg* or a\nsub-node was built from a dataclass \u002F Hydra structured-config registration,\nor is a typed container element), the override RHS is type-checked: a\nmismatch raises :class:`TypeError` naming the dotted field path, the\nexpected type, and the received value.\n\nPlain (untyped) ``DictConfig`` nodes keep their permissive behaviour: the\nRHS overwrites whatever was there, matching ``OmegaConf.update(merge=True)``.\nConfigs built via ``@L.params`` currently flow through this permissive\npath — :class:`laco.language.ParamsWrapper` materialises a plain ``dict``\nthat ``laco.utils.as_omegadict`` lifts to an ``AnyNode``-only\n``DictConfig`` without ``ref_type`` metadata.\n\nOn error mid-list, earlier overrides have already been applied; the call\ndoes not roll back.",[1355,1357],{"name":1259,"type":782,"doc":1356},"An omegaconf config object",{"name":1358,"type":1359,"doc":1360},"overrides","typing.Iterable[str]","List of strings in the format of \"a=b\" to override configs.\nSee: https:\u002F\u002Fhydra.cc\u002Fdocs\u002Fnext\u002Fadvanced\u002Foverride_grammar\u002Fbasic\u002F",{"type":782,"doc":1362},"Lazy configuration object",{"file":1364,"line":1346},"laco\u002F_overrides.py",null,{},1785687298737]