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})'