def short(self) -> str:
result = short(self.datum)
if self.args:
result += ' ' + short(self.args)
if self.tags:
result += ' ' + short(self.tags)
return result
def short(self):
ss: List[str] = []
for step in self.steps:
if step is None:
ss.append('[]')
else:
ss.append(short(step))
return ''.join(ss)
def __str__(self) -> str:
sio = StringIO()
print(file=sio)
print(short(self.rmem), file=sio)
#pr(self.tspec.kwargs, file=sio)
print(self.initial_canvases_f, file=sio) # type: ignore[misc]
print(self.cue_maker, file=sio) # type: ignore[misc]
print(self.nstr(), file=sio)
return sio.getvalue().rstrip()
def __str__(self) -> str:
ls: List[str] = []
if self.t is not None:
ls.append(f't={self.t}')
if self.label is not None:
ls.append(short(self.label))
else:
cl = self.__class__.__name__
ls.append(f'{cl}/{self.num_nodes()}')
return ' '.join(ls)
def short(self) -> str:
delta = short(self.last_delta) if self.last_delta else ''
avs = ' '.join(str(a) for a in as_iter(self.avails))
ls: List = []
if delta:
ls.append(delta)
if avs:
ls.append(avs)
inside = '; '.join(ls)
return f'[{inside}]'
def log(self, f: Indenting, deltas=Sequence[Delta], **kwargs) -> None:
print(self.name, file=f)
with indent(f):
if not deltas:
print('No Deltas.', file=f)
else:
amts: List[float] = []
for delta in sorted(deltas, key=attrgetter('amt')):
print(short(delta), file=f)
amts.append(delta.amt)
print(
f'mean={mean(amts):1.8f} hmean={harmonic_mean(amts):1.8f} gmean={geometric_mean(amts):1.8f} median={median(amts):1.8f}',
file=f)
def wrapper(*args, **kwargs) -> None:
argstring = ''
if args:
#argstring += ', '.join(repr(a) for a in args)
argstring += ', '.join(short(a) for a in args)
if kwargs:
if argstring:
argstring += ', '
argstring += ', '.join(f'{name}={value}'
for name, value in kwargs.items())
with logging(None, f'{func.__name__}({argstring})'):
result = func(*args, **kwargs)
lo(f'-> {result}')
return result
def mk_func_args(cls, func: Callable, args: Args) -> Dict[str, Any]:
d: Dict[str, Any] = {}
args = as_argsmap(args)
for param_name, param_type in cls.params_of(func):
value = args.get(param_name, None)
if not is_type_instance(value, param_type):
# TODO Distinguish between missing argument and argument of
# wrong type?
lo('WRONGTYPE', param_name, param_type, value)
print('???')
lo('ARGS', type(args), short(args))
raise NotImplementedError # TODO MissingArgument
else:
d[param_name] = value
return d
def test_snag_leads_to_variant_maker(self) -> None:
#lenable(Codelet, Fizzle, LogPulse, Built)
fm = FARGModel(seed=1, slipnet=Slipnet(desnag_graph))
ca = fm.build(self.pons_start_canvas())
cr0 = fm.build(CellRef(ca, 0))
cr1 = fm.build(CellRef(ca, 1))
ag1 = fm.build(Consumer(
operator=plus,
operands=(4, 4),
source=cr0
))
fm.run_agent(ag1, num=2)
vm = fm.the(VariantMakerFromAvails)
self.assertTrue(fm.the(VariantMakerFromAvails))
self.assertEqual(
fm.the(VariantMakerFromAvails),
VariantMakerFromAvails(
agent=ag1,
cellref=cr0,
avails=(4, None),
unavails=(None, 4)
)
)
#lenable(Agent, Codelet, Fizzle, LogPulse, Built)
fm.do_timestep(num=3)
#pr(fm)
#print()
#print(short(cr1.value))
self.assertTrue(
short(cr1.value) == '[4 + 5; 6 9]'
or
short(cr1.value) == '[4 + 6; 5 10]'
)
def __str__(self):
try:
nodestr = self.node.__name__
except AttributeError:
nodestr = short(self.node)
return f'{nodestr:20s} {self.a:2.5f}'
def lo(*args, **kwargs) -> None:
'''Prints args to log file, at current indentation level.'''
print(*(short(a) for a in args),
dict_str(kwargs, xform=short),
file=logfile())
def mk_short(self, operands: Sequence[Value]) -> str:
if operands:
nm = f' {self.name} '
return nm.join(short(o) for o in operands)
else:
return f'_{self.name}_'
def short(self) -> str:
if self.values:
return ' '.join(short(v) for v in self.values)
else:
return '(no avails)'
def plot(self) -> None:
plt.plot(self.aa.keys(), self.aa.values(), label=short(self.node))
def short(self) -> str:
if self.contents is None:
s = '(empty cell)'
else:
s = short(self.contents)
return f'[ {s} ]'
def short(self) -> str:
if not self._cells:
return '(empty seqcanvas)'
else:
return ''.join(short(c) for c in self._cells)
def __str__(self) -> str:
return short(self)
def name_of(o: Any):
try:
return o.__name__
except AttributeError:
return short(o)
def __str__(self) -> str:
items = ' '.join(short(x) for x in self.contents)
citems = ' '.join(short(c) for c in self.clarities)
return f'[{items}]'
def short(self) -> str:
if is_iter(self.before):
operand = f' {short(self.how)} '
return operand.join(str(b) for b in self.before)
else:
return short(self.how) + short(self.before)
def run_gset(canvas: List, gset: GSet, niters: int=20) -> List:
for i in range(niters):
gen = choose_runnable_generator(canvas, gset)
run_generator(canvas, gen)
print(canvas, ' ', short(gen))
return canvas
def short(self) -> str:
cl = self.__class__.__name__
s = short(self.operator).join(short(o) for o in as_iter(self.operands))
return f'{cl}({s})'