߲jJUdZddlmZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl mZddlmZddlmZddlmZmZmZmZmZmZmZmZddlmZmZmZdd l m!Z!dd l"m#Z#m$Z$dd l%m&Z&m'Z'm(Z(m)Z)dd l*m+Z+erdd l,m-Z-m.Z.ej^dZ0dZ1e jdZ3iZ4de5d<dZ6dZ7dZ8gZ9de5d<e jtZ;e jxZ=Gdde>Z?d$dZ@d%dZAd&dZBd'dZCd(dZDdZEed)dZFd*d ZGd+d!ZHGd"d#ZIy),uzPlugin loading: directory/entry-point module import, deferred bundled platforms, portable packages, dependency/config-schema warnings. Mixed into :class:`hermes_cli.plugins.PluginManager`. Origin-internal names (``PluginContext``, ``LoadedPlugin``, ``_PLUGINS_DEBUG`` …) are imported lazily through ``hermes_cli.plugins`` so tests that patch them on the origin keep working. ) annotationsN)contextmanagerwraps)Path) TYPE_CHECKINGAnyCallableDictListMappingOptionalUnion)get_hermes_homereset_hermes_home_overrideset_hermes_home_override)replacement_coordinator)ENTRY_POINTS_GROUP_select_entry_point_group)PluginManifest manifest_keyportable_mcp_server_namevalidate_config_schema)_plugin_settings_entry) LoadedPlugin PluginContextzhermes_cli.pluginshermes_pluginszDict[str, str]_BARE_MODULE_SCOPEg$@g@zList[threading.Thread]_ABANDONED_LOADERSceZdZdZy)PluginLoadTimeoutzZRaised on the loading thread when a plugin's import + ``register()`` overran its deadline.N)__name__ __module__ __qualname____doc__>/home/ubuntu/.hermes/hermes-agent/hermes_cli/plugins_loader.pyr"r"4sdr(r"c6tttddS)zcTrue on a deadline worker thread; re-entrant discovery from there must not block on its own parent.activeF)boolgetattr_IN_PLUGIN_LOADr'r(r)in_plugin_load_workerr/8s 59 ::r(ct} ddlm}|xsijd}t |t r|jd|St |d}|dkrtjd|||S|tkDr!tjd|ttS|S#ttf$rtjd||cYSt$r|cYSwxYw)zEffective per-plugin load deadline from ``plugins.load_timeout_seconds`` (default 10s; ``0`` runs loads inline with no deadline; clamped to ``_MAX_LOAD_TIMEOUT_SECS``).r)load_config_readonlypluginsload_timeout_secondsz?plugins.load_timeout_seconds is not a number; using default %gsz>plugins.load_timeout_seconds=%g is negative; using default %gsz9plugins.load_timeout_seconds=%g exceeds max %gs; clamping) _LOAD_TIMEOUT_SECShermes_cli.configr1get isinstancedictfloat TypeError ValueErrorloggerwarning Exception_MAX_LOAD_TIMEOUT_SECS)defaultr1 plugins_cfgtimeouts r)_resolve_plugin_load_timeoutrC=s!G :+-388C +t, @V0W0_N $:;< {WY`bij''RT[- /%% N z "XZab sAB# B##'C CCct5tDcgc]}|js|c}tddtttkr dddy dddt dtdcc}w#1swY!xYw)zDrop finished abandoned loaders; refuse the load once the live cap is reached. Refusing beats loading inline: at the cap the process already holds several hung loaders, so an inline load is the exact startup hang this deadline exists to prevent.Nz not loaded: zl abandoned plugin loader thread(s) are still running (plugins.load_timeout_seconds); restart Hermes to retry)_ABANDONED_LOADERS_LOCKr is_alivelen_MAX_ABANDONED_LOADERSr")ts r)_reserve_abandoned_loader_slotrJVs !,> Oq!**, O1 ! "%; ;  ;  -./B C !Ps A5A0A0!A50A55A>ct}|dkrStggd fd }tjt j j |fd|d}|j|j||jrD|jt5tj|dddtd|dd rddS#1swY%xYw) aRun ``fn`` (a plugin's import + ``register()``) under the per-plugin deadline. The worker inherits the caller's context (the Hermes-home override is a ContextVar). On timeout the worker is abandoned as a daemon, ``ctx`` is marked so any registration it still attempts is ignored, and :class:`PluginLoadTimeout` is raised on the calling thread so the usual failure path records the reason and disposes whatever was registered before the hang. rcdt_ jy#t$r}j|Yd}~yd}~wwxYw)NT)r.r+append BaseException)excfailurefnoutcomes r)_workerz'run_with_load_deadline.._workerss=!% NN24  NN3   s% A AA z plugin-load:T)targetargsnamedaemonNzload timed out after gz&s (import + register() never returned)returnNone)rCrJ threadingThread contextvars copy_contextrunstartjoinrF _abandon_loadrEr rMr") plugin_keyctxrQrBrSworkerrPrRs ` @@r)run_with_load_deadlinergds+,G!|t "$G#%G   '')--WJ|T^S_E`imF LLN KK   $ .  % %f - ."7{Bh ijjaj 1:  . .s 0C**C3c|d}tjDcgc]}||k(s|j|s|c}D]}tj|=ycc}w)zPDrop ``module_name`` and every ``module_name.*`` submodule from ``sys.modules``..N)sysmodules startswith) module_nameprefixnrVs r)_evict_modulesrpsM}A FKKTq1 +;q||F?ST KK Ts AAc.tfd}|S)uDMake snapshot → write → lease attachment one atomic transaction.chtj5|i|cdddS#1swYyxYwN)r transaction)rUkwargsmethods r)wrappedz(_serialized_replacement..wrappeds1 $ 0 0 2 +4*6* + + +s(1r)rvrws` r)_serialized_replacementrxs  6]++ Nr(c#bKt|} dt|y#t|wxYww)zBBind discovery and loading to the manager's immutable Hermes home.N)rr)hometokens r)_plugin_home_scoper|s+ %T *E* "5)"5)s / / ,/cXt|trd|jdSt|S)z_Human-readable load failure; ``sys.exit(0)`` has an empty ``str()`` so name the class and code.z SystemExit(z!) raised during import/register())r7 SystemExitcodestr)rOs r)_load_error_textrs)#z"SXXL(IJJ s8Or(ctjd|ddj}|sy tjj |y#tjj $rYyt$rYywxYw)z[Best-effort presence probe on a requirement's distribution name; ``None`` when unprobeable.z [<>=!~\[;\s])maxsplitrNTF)resplitstrip importlibmetadataversionPackageNotFoundErrorr>)reqdists r)_dist_installedrsm 88OS1 5a 8 > > @D ""4(    2 2 sAA8-A87A8ceZdZddZddZeddZddZeddZ ddZ ddZ ddZ dd Z dd Zdd Z dd Zdd ZddZddZdd ddZddZy)PluginLoaderMixinc~ts td|jjdfd }|S)uSubscribe to "a discovery sweep loaded plugins this process did not have": fires from INSIDE :meth:`discover_and_load` (never emitted by an install RPC) with one ``{name, key, activated_now, deferred}`` summary per NEWLY loaded plugin — every plugin at boot, just the newcomer after a mid-run ``hermes plugins install/enable``, Desktop / dashboard / ``plugins.manage`` install-enable-update, a tool-triggered force re-discovery or the gateway's ``reload-plugins`` verb (all of which run ``discover_plugins(force=True)``; a non-forced call short-circuits on ``_discovered`` and never fires). See :func:`hermes_cli.plugins_activation.plugin_activation_summary` for the payload: ``activated_now`` (gateway commands/transforms/hooks/callbacks, live at once) vs ``deferred`` (``tools``/``prompt`` until the next session, ``mcp_servers`` — the plugin's mcp.json server names — until ``mcp.reload``). Listeners belong to the process (gateway runner, TUI server), not to a plugin, so ``unload()`` never clears them. Returns an unsubscribe callable. Fires on the discovering thread with the discovery lock released; marshal onto your own loop.z$on_plugin_loaded requires a callablecH jy#t$rYywxYwrs)remover;)callback listenerssr) _unsubscribez8PluginLoaderMixin.on_plugin_loaded.._unsubscribes(   *  s  !!rY)callabler;_plugin_loaded_listenersrM)selfrrrs ` @r)on_plugin_loadedz"PluginLoaderMixin.on_plugin_loadeds?!CD D11 "  r(c|jsyddlm}||Dcgc] }|d|vs |}}|syt|jD] } || ycc}w#t$rt j d|dY7wxYw)zFire every :meth:`on_plugin_loaded` listener for the plugins this sweep added over ``loaded_before``; nothing new = no event. One raising listener never starves the rest.Nr)activation_summarieskeyz plugin-loaded listener %r raisedTexc_info)rhermes_cli.plugins_activationrlistr>r<r=)r loaded_beforers summariesrs r)_notify_plugin_loadedz'PluginLoaderMixin._notify_plugin_loadeds,, F 4T :\1ahm>[Q\ \ T::; \H \# \]  \A8VZ[ \s AA A!BBc|jxsd}|jdr|dtd S|jrt |jjS|S)zDerive the platform name without importing the adapter: strip a trailing ``-platform`` from the manifest name, else the directory basename (the bundled convention).z -platformN)rVendswithrGpathr)manifestrVs r)_platform_name_from_manifestz.PluginLoaderMixin._platform_name_from_manifestsT}}" == %+3{++, ,+3==tHMM"''BdBr(cddlm}t|}||dd}||j|<|j ||s|j |y|j ||y)zRegister a lazy loader for a bundled platform: the adapter imports only when the ``platform_registry`` is first asked for it; a placeholder ``LoadedPlugin`` keeps it visible in ``hermes plugins list`` until then.r)rT)renableddeferredN)hermes_cli.pluginsrr_plugins_lease_deferred_platform _load_plugin!_register_deferred_platform_tools)rrr lookup_keyloadeds r)_register_deferred_platformz-PluginLoaderMixin._register_deferred_platforms` 4!(+ xM$* j!,,XzB   h '  ..x@r(c j| ddlmj|fdfd }j }j |j }|d>|d|ur7j jj|d||fdtjd |y #t$rtjd |d Yy wxYw)zXPublish the deferred loader as a ledger-owned lease; False when the registry refused it.r)platform_registrycj5tj5jr ddddddyj |ddddddy#1swYxYw#1swYyxYwNscope)_discovery_lockr| home_pathis_deferred_load_cancelled_load_plugin_scoped) _manifest platform_namerrrs r)_loaderz;PluginLoaderMixin._lease_deferred_platform.._loadersz))8+=dnn+M8(CCMY^C_888,,Y7888888s-A8A,A8 A,A8,A5 1A88Brrplatformc&jSrs) _remove_platform_name_if_unowned)rrsr)z.sT%J%J=%Yr()finalizez3Registered deferred platform loader: %s (plugin=%s)z=Deferred platform registration failed for '%s'; eager-loadingTrF)rrrZr[) rgateway.platform_registryr scope_keysnapshot_registrationregister_deferred_plugin_platform_namesadd_track_scoped_registrationr<debugr>) rrrrpreviouscurrentrrrs ` @@@r)rz*PluginLoaderMixin._lease_deferred_platforms 99(C   CNNE4< 8 8)>>}TY>ZH  / / we / T'==mSX=YGqz!gajG&;++// >//j-9JGU]Y0 LLNP]_i j    LLOQ[fj  l sB1C !C-,C-c ddlm}m}|jsyt |t |j}|j rt|j nd}||dz jstjd|ytjdfd } j|}|_|j<t!j"|j$d} t'| dd} | tjd |y| |||} tj)d t+| | y#t,t.f$rk} |t+|}} t+| |k\}| sd |d n|rd |d ndt+| d|d }tjd|| |rdnd|Yd} ~ yd} ~ wwxYw)uRRegister a deferred platform's *client* tools without its adapter. Deferring the plugin would otherwise defer its outbound tools too, so CLI/TUI processes (which never materialize platforms) would miss them in ``hermes tools`` / ``platform_toolsets``. Opt-in is explicit via ``provides_tools``; tools live in a ``tools`` submodule so ``__init__`` stays import-light. A platform plugin can ship two independent things: an inbound adapter (heavy — it imports the platform SDK) and outbound client tools the agent calls like any other tool. Deferring the plugin defers both, so in a CLI/TUI process the client tools never register at all: ``resolve_toolset()`` returns ``[]``, the toolset is missing from the ``hermes tools`` checklist, and even an explicit ``platform_toolsets`` entry is dropped because the key is unknown. The same tools work in gateway/web processes only because those materialize every platform at startup (issue #78050). Opting in is explicit: the manifest must declare ``provides_tools`` (the field the plugin list and web server already read to name a plugin's tools, per #78538). Keying off the mere presence of a ``tools.py`` would opt a plugin in by accident — a platform is free to put internal helpers there — and would leave the contract invisible to anyone reading the manifest. ``tools.py`` remains where the code is imported from; ``provides_tools`` is what asks for it. A platform that does not declare the field is untouched and stays fully deferred. r)r_PLUGINS_DEBUGNztools.pyzrPlugin '%s' declares provides_tools %s but has no tools.py; those tools will not be available in CLI/TUI sessions.c~jDcgc] }|vs| }}|r|_|j<|Scc}w)z@Attribute every tool registered since ``before`` to this plugin.)_plugin_tool_namestools_registered_predeclared_tools)rI registeredbeforerrrs r)_creditzDPluginLoaderMixin._register_deferred_platform_tools.._creditFsI%)%<%<P!PJP*4'6@'' 3  Qs ::z.toolsregister_toolszPlugin '%s' declares provides_tools %s but its tools.py has no register_tools(ctx); those tools will not be available in CLI/TUI sessions.z;Deferred platform '%s': pre-registered %d client tool(s) %szbefore registering any of its z declared tool(s)zafter registering all zafter registering z of z;Plugin '%s': client-tool pre-registration failed %s (%s).%srz5 The remainder will be missing from CLI/TUI sessions.r)rZ List[str])rrrprovides_toolsrrrris_filer<r=setr_load_directory_modulemodule_predeclared_modulesr import_moduler#r-rrGr>r~)rrrrrdeclared plugin_dirrr tools_modulerrrOpartialtotalcompleterrrs` ` @@r)rz3PluginLoaderMixin._register_deferred_platform_toolss& E&& !(+ //0,4MMT(--(t  j:&=%F%F%H NNIJTV^   T,,-  $ 00:F#FM4:D % %j 1$22foo5Ff3MNL$\3CTJN%56@(  =48 9 J LLMz[^_i[j :& %YH UG7|u,HQX07HIJR-eW4EF)#g,tE7BST  NNMz[`be$['    s )A/E7EG  A!GG c J|j}|syt|}|Dcgc]}t|dus|}}|r?tj d|dj ||dj d|Dytj d|dj |ycc}w)u0Warn about declared pip dependencies missing at load time. Installing happens at ``hermes plugins install``/``enable`` and after ``hermes update`` (``hermes_cli.plugin_python_deps``) under core constraints; the loader itself never installs — import time is not a consent point. NFzPlugin %s declares Python dependencies that are not installed: %s. Run `hermes plugins enable %s` to install them, or install them yourself: pip install %sz,  c3(K|] }d|d yw)'Nr').0ms r) z>PluginLoaderMixin._warn_python_dependencies..s6QA1#Qx6Qsz+Plugin %s python_dependencies satisfied: %s)python_dependenciesrrr<r=rbr)rrdepsrrmissings r)_warn_python_dependenciesz+PluginLoaderMixin._warn_python_dependenciests ++ 8$"&H3/#*>%*G3HH  NN;TYYw'chh6Q6Q.Q   LLFTYYW[_ ]Is B B c|jsyt|}i} ddlm}t |xsi|xsi}|j d}t |ts|j d}t |tr|ni}t||j|D]}tjd||y#t$ri}YAwxYw)zmWarn (never block) on plugins.entries. settings that violate config_schema. See #64165. Nr) load_configsettingsconfigzPlugin %s config: %s) config_schemarr5rrr6r7r r>rr<r=)rr plugin_idrrentryrawr=s r)_validate_plugin_config_schemaz0PluginLoaderMixin._validate_plugin_config_schemas %%  * &(  5*;=+>B JPbE))J'Cc7+ii)(g6sBH.i9O9OQYZ GG NN19g F G H sA%B55 CCc|j5t|j5|j|ddddddy#1swYxYw#1swYyxYw)z?Import a plugin module and call its ``register(ctx)`` function.N)rr|rr)rrs r)rzPluginLoaderMixin._load_pluginsO  ! ! /#5dnn#E /  $ $X . / / / / / /s!AAAA AAc2ddlm}m}m}|t t j djjjjrjyddl m }|}|r.|_t jd|j <yddlm}|}|r8|_t jd j&|j <yt)j*}j-j/|dfd } t1| rLj3|d _dd lm} j;| j&j<j4sjLjOdj <y#t>t@f$r} j*D cgc]} | jBk(s| ncc} w} } jE| jG| tI| _jKt jd j&tI| |Yd} ~ d} ~ wwxYw)z9Load one plugin with the manager's home bound as current.r)rrr)rz1Loading plugin '%s' (source=%s, kind=%s, path=%s)N)requires_hermes_errorzPlugin '%s' skipped: %s)disable_reasonzPlugin '%s' not loaded: %scjjd}|"jdvrj}n|j }d}|Qt |t js7t|r,|}tjjt|dd}|_ | t|dd}|(d_tj!dj"y |y ) uTImport + register() — the part a plugin controls, so the part the deadline covers.N>userbundledprojectrmr$rregisterzno register() functionz&Plugin '%s' has no register() functionFT)rpopsourcer_load_entrypoint_moduler7types ModuleTyperrjrkr6r-rerrorr<r=rV)r register_fnrerrrmrdrs r)_import_and_registerzCPluginLoaderMixin._load_plugin_scoped.._import_and_registers..22:tDF~(//5S"S44X;4W55h?K!*VU=M=M*NS[\bSc% lB)OP"FM"%fj$? "7 GW  r(T)_hook_source_ofzFailed to load plugin '%s': %srrZr,)(rrrrrr<rr kindrportable_load_portable_pluginhermes_cli.plugins_manifestrrr=rhermes_cli.plugin_compatrrVrG_registration_order_policy_module_name_track_tool_override_policyrg_attribute_registrationsrhermes_cli.plugins_ledgerr_drop_fallback_hooksrr>r~rd_dispose_registrations_forget_registrationsr_remove_plugin_subscriptionsrr )rrrrrrreasonrregistration_startrrrOrownedrerrmrds`` @@@@r)rz%PluginLoaderMixin._load_plugin_scopeds6RRx0!(+  ?        & &x 8 E&x0 !FL NN4j& I(.DMM* %  <) !FL NN7 O(.DMM* %  !9!9:..x8  ((;?Hd+  2 |%j#7KL--fjBTU!%E))/(--*WX&~~  # # ' ' D 9$* j!):& | !% 8 8W1ALLJ.s!I,T,TE-U-r()rrrestoreN) rrtools.registryr'rrrtsnapshot_plugin_override_policyregister_plugin_override_policy_tool_override_allowedacquire_track_registrationdispose) rrrmrprevious_policy policy_leaser,r-rs ` @@@r)rz-PluginLoaderMixin._track_tool_override_policys48 $ 0 0 2 j'GG [`GaO&FF]8T:QQRTU]bGN3::' B88Cc  |j|dDcgc]}|j|k(r|jr|!c} d fd |jj |gDcgc]}||j vs|}}|dDcgc] }||vs| c}z|_d|_d|_d|_ tjdt|j t|jt|jt|jtfd|jDycc}wcc}wcc}w) zUFill ``loaded.*_registered`` from the ledger slice this plugin's register() produced.NcbDcgc]}|j|k(s|j c}Scc}wrs)rr)rr# registrationss r)_keysz9PluginLoaderMixin._attribute_registrations.._keyss%#0CaAFFdNAEEC CCs,,toolhook middlewarecommandz[ registered: %d tool(s), %d hook(s), %d middleware, %d slash command(s), %d CLI command(s)c38K|]}|dvsdyw) cli_commandrNr')rcr;s r)rz=PluginLoaderMixin._attribute_registrations..$sKaeM6J1JKs)rrrZr)rrdr+rr rrhooks_registeredmiddleware_registeredcommands_registeredr<rrGsum _cli_commands) rrrdr"r#rI predeclaredkr;r:s @@r)rz*PluginLoaderMixin._attribute_registrations s, //0B0CD ||z)ahh   D #'"9"9"="=j""MnQQRVZVmVmQmqn n"-E&M0bqQVaMa0b"b"'-',\':$%*9%5" i '' (#f.E.E*F ,, -s63M3M/N K4--K K   o0bs$EE 3E  EEc "ddlm}t|} ddlm}|t |j tdz |jz }||}|jD].}tjd||j|j0|jD]?} |j| j | j"| j$| j&Addlmm} dd lmg} |j2j5D]\} }t7|| }|j8vr3tjd ||j:j=|d St?|j8|<|j:|<|j@j=| }|/jC||j0| ||jD| jG|| D] }|fdfd }jI|d ||"d|_% |jX|<y#t($r-} tjd|| j | Yd} ~ d} ~ wwxYw#tL$rZ| D]S}j8jO|dj:jO|djQ||UwxYw#t(tRf$r;} tU| |_+tjd||jVYd} ~ d} ~ wwxYw)zALoad validated portable components without importing Python code.rr&)load_agent_pluginz plugin-datazAgent Plugin '%s' [%s]: %sz(Agent Plugin '%s' skill '%s' skipped: %sN)_clear_liveness _set_liveness) declarationz_Agent Plugin '%s' MCP server '%s' skipped: name already taken by plugin '%s'; rename one server?cjj|djj|dj||yrs)_portable_mcp_serversr _portable_mcp_server_plugins unregister)rVrLrNrs r)releasez8PluginLoaderMixin._load_portable_plugin..releaseIsE2266tTB99==dDI#..t4'-r( portable_mcpTzAgent Plugin '%s' disabled: %s)rVrrZr[)-rrrhermes_cli.agent_pluginsrKrrrskill_namespace diagnosticsr<r=rmessageskillsregister_skillrVskill_md description frontmatterr>rLrMhermes_platformrN mcp_serversitemsrrQrRr6r8server_declarationsrlivenessrMr4rrNr rSr~rrr)rrrrrrKpackagere diagnosticskillrOrMr server_namer internal_name server_declrTrLrNs` @@r)rz'PluginLoaderMixin._load_portable_plugin's4!(+ / W B'X]]#_%6%FIaIa%acG$/C%11 o ;ZIYIY[e[m[mn o  ll&&uzz5>>5CTCTV[VgVgh l P 3$&J +2+>+>+D+D+F 5'K$`` for the first scope that claims it, a ``__home_`` suffix for any other scope./__-_riNzutf-8 __home_) rreplace _NS_PARENT_MODULE_NAMESPACE_LOCKr setdefaultrhashlibsha256encode hexdigest)rrslug bare_namedigests r)_directory_module_namez(PluginLoaderMixin._directory_module_name]sH%--c48@@cJ!l!D6* # 1!,,YG4>>Y  1 1^^DNN$9$9'$BCMMOPSQSTF[x0  1 1 1s/C6ACCc|jdk(rE|jr9t|jjddj }|r|S|j |S)z?Return the module prefix whose callbacks inherit plugin policy. entrypoint:r)r rr partitionrr|)rrrms r)rz%PluginLoaderMixin._policy_module_namehsU ??l *x}}hmm,66s;A>DDFK""**844r(Nrct|j}|dz }|jstd|tt j vrBtjt}g|_ t|_ |t j t<|xs|j|}t|tjj||t!|g}| |j"t%d|tjj'|}||_ t!|g|_ |t j |< |j"j)||S#t*$r t|wxYw)zImport a directory plugin as ``hermes_plugins.`` (slug from ``manifest.key`` so ``image_gen/openai`` cannot collide with ``tts/openai``).z __init__.pyzNo __init__.py in )submodule_search_locationszCannot create module spec for )rrexistsFileNotFoundErrorrrrjrkr r __path__ __package__r|rprutilspec_from_file_locationrloader ImportErrormodule_from_spec exec_modulerN)rrrmr init_filens_pkgspecrs r)rz(PluginLoaderMixin._load_directory_modulepsP (--( . !#&8 $EF F S[[ (%%j1F FO!+F &,CKK #!JT%@%@%J {#~~55 J?P6R <4;;. >ykJK K006(z?+#) K   KK # #F +    ; '   s E!!E7cttjjtD]-}|j |j k(s|j cStd|j dtd)zLoad a pip-installed plugin via its entry-point reference: the module for a bare ``module`` target, the referenced attribute (normally ``register``) for the ``module:function`` form.z Entry point 'z' not found in group 'r)rrr entry_pointsrrVloadr)rreps r)r z)PluginLoaderMixin._load_entrypoint_modulesj,I,>,>,K,K,MOab !Bww(--'wwy  !M(--8NOaNbbcdeer()rz%Callable[[List[Dict[str, Any]]], Any]rZzCallable[[], None])r frozensetrZr[)rrrZr)rrrZr[)rrrrrZr,)rrrrrZr[)rrrmrrZr[)rrrdrr"intrZr[)rrrmz Optional[str]rZztypes.ModuleType)rrrZz+Union[types.ModuleType, Callable[..., Any]])r#r$r%rr staticmethodrrrxrrrrrrrrrr|rrr r'r(r)rrs4 \CCA >Vp^(G*/ V+pj& " 03 IL  44+l 15IM#&#8E# #Jfr(rr)rZr9rY)rdrrez'PluginContext'rQzCallable[[], Any]rZr )rmrrZr[)rzr)rOrNrZr)rrrZzOptional[bool])Jr& __future__rr^rurimportlib.metadataimportlib.utilloggingrrjr\r  contextlibr functoolsrpathlibrtypingrr r r r r rrhermes_constantsrrrregistration_lifecyclerhermes_cli.plugins_discoveryrrrrrrrhermes_cli.plugins_staterrrr getLoggerr<rrRLockrsr__annotations__r4r?rHr LockrElocalr.r>r"r/rCrJrgrprxr|rrrr'r(r)rs"#  %UUUbb:Vvv;>   / 0  (*%'N' -/*/()..*!)//#e e; 2 "J** bfbfr(