"""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