Source code for fleetmesh_node.compartment.need

"""Declared dependencies a compartment takes from the node."""
from __future__ import annotations

import dataclasses
import inspect
from typing import Any, Mapping, Optional

from .problem import (IncompatibleProblem, Problem, Problems,
                      ReferenceProblem, TypeMismatchProblem)


[docs]@dataclasses.dataclass(frozen=True) class Need: """One dependency a compartment takes from the node, declared where the compartment is. Resolved against NodeContext at assembly by the base `from_context`: - a field (`ks`, `transport`, `stores.grants`, `clock`, `propose`, `pull`, `regrant`, etc.) - a typed config block (`Need('settings', block=SettlementConfig)`) - a compartment, which must appear in `requires` or `uses`, resolved from registry / context - a live config getter (`Need('cfg', 'cfg', getter=True)` or `Need('cfg', block=UpdatesConfig, getter=True)`) - a node-relative path (`Need('db_path', path='DB')` or `Need('db_path', path='updates.sqlite')`) - or `late=True`: resolved and bound after all compartments are assembled, replacing wire(). """ key: str source: Optional[str] = None block: Optional[type] = None late: bool = False getter: bool = False path: Optional[str] = None field: Optional[str] = None
[docs] def __init__( self, key: str, source: Optional[str] = None, *, block: Optional[type] = None, late: bool = False, getter: bool = False, path: Optional[str] = None, field: Optional[str] = None, ) -> None: object.__setattr__(self, 'key', key) object.__setattr__(self, 'source', source if source is not None else (None if (block is not None or path is not None) else key)) object.__setattr__(self, 'block', block) object.__setattr__(self, 'late', late) object.__setattr__(self, 'getter', getter) object.__setattr__(self, 'path', path) object.__setattr__(self, 'field', field)
[docs] def resolve(self, ctx: Any, cls: type) -> Any: if self.late: return None if self.path is not None: rel = getattr(cls, self.path, self.path) return ctx.path(rel) if self.block is not None: if self.getter: return ctx.block_getter(self.block) b = ctx.block(self.block) if self.field is not None: return getattr(b, self.field) return b src = self.source or self.key if self.getter: if src == 'cfg': return ctx.cfg_getter() return lambda: self._resolve_src(ctx, cls, src) res = self._resolve_src(ctx, cls, src) if self.field is not None: if isinstance(res, Mapping): return res.get(self.field) return getattr(res, self.field) return res
def _resolve_src(self, ctx: Any, cls: type, src: str) -> Any: reqs = getattr(cls, 'requires', ()) or () uses = getattr(cls, 'uses', ()) or () if src in reqs or src in uses: return ctx.optional(src) val = ctx for part in src.split('.'): if hasattr(val, part): val = getattr(val, part) elif isinstance(val, Mapping) and part in val: val = val[part] else: raise AttributeError(f"NodeContext has no field {part!r} (resolving {src!r})") return val
[docs] def resolve_late(self, ctx: Any, instance: Any, registry: Any) -> Any: comp_name = self.source or self.key val = registry.get(comp_name) if val is None: val = getattr(ctx, comp_name, None) return val
[docs] def problems(self, cls: type) -> list[str]: out = Problems() if not self.key or not isinstance(self.key, str): out.append(Problem('Need key must be a non-empty string', surface='NEEDS', code='empty_key', target='')) return out # Check __init__ parameter (unless late=True) if not self.late: try: init_fn = getattr(cls, '__init__', None) if init_fn is not None: sig = inspect.signature(init_fn) params = sig.parameters has_varkw = any(p.kind == inspect.Parameter.VAR_KEYWORD for p in params.values()) if not has_varkw and self.key not in params: out.append(IncompatibleProblem( 'NEEDS', self.key, f"need {self.key!r} is not an __init__ parameter of {cls.__name__}" )) except (ValueError, TypeError): pass if self.path is not None: if not isinstance(self.path, str) or not self.path: out.append(TypeMismatchProblem('NEEDS', 'non-empty str path', type(self.path).__name__, message=f"need {self.key!r}: path must be a non-empty string")) elif self.block is not None: blk: object = self.block if not isinstance(blk, type): out.append(TypeMismatchProblem('NEEDS', 'type', type(blk).__name__, message=f"need {self.key!r}: block must be a type, got {type(blk).__name__}")) else: src = self.source or self.key reqs = getattr(cls, 'requires', ()) or () uses = getattr(cls, 'uses', ()) or () top = src.split('.')[0] from .context import NodeContext known_context_fields = set(NodeContext.__dataclass_fields__.keys()) | { 'pubkey', 'did', 'node_class', } if top in known_context_fields: if top == 'stores' and '.' in src: store_field = src.split('.')[1] from .context import NodeStores if store_field not in NodeStores._fields: out.append(ReferenceProblem( 'NEEDS', self.key, store_field, message=f"need {self.key!r}: stores has no field {store_field!r} (declared: {', '.join(NodeStores._fields)})" )) elif self.late: pass # late needs can name any compartment built after this one elif src in reqs or src in uses: pass # valid declared dependency else: out.append(ReferenceProblem( 'NEEDS', self.key, src, message=f"need {self.key!r}: source {src!r} is neither a NodeContext field nor in requires/uses" )) return out