def __init__(self, method): super().__init__( 'Call to abstract method {class_name}.{method_name}(...): missing implementation.'.format( class_name=get_name(method.__self__), method_name=get_name(method), ) )
def __init__(self, method): super().__init__( 'Call to abstract method {class_name}.{method_name}(...): missing implementation.' .format( class_name=get_name(method.__self__), method_name=get_name(method), ))
def register_group(self, *args, check=None): check = set(check) if check else None for attr in args: self.register(attr) if check: check.remove(get_name(attr)) assert not (check and len(check))
def print_tree(self, i, level=0): g = self.graph node = g[i] name = get_name(node) indent = ' ' * level print(f'{indent}{name}') for j in g.outputs_of(i): self.print_tree(j, level=level + 1)
def run_node(self, i, input, level=0): g = self.graph node = g[i] name = get_name(node) self.tick_in(i, name, level) indent = ' ' * level services = {k: v for k, v in self.service_bindings[i] if v is not None} for k in self.runtime_bindings[i]: s = getattr(node, k) services[k] = self.services[s] if services: # print(f'*** binding services: {services}') node = partial(node, **services) # if services: # print(f'{indent}{name} {services.keys()}') # else: # print(f'{indent}{name}') try: # print(f'calling {node!r}({input})') start = time.time() if input is None: result = node() else: result = node(input) end = time.time() elapsed = end - start self.timers[(i, level, name)] += elapsed if result == NOT_MODIFIED: result = input if isinstance(result, types.GeneratorType): #print('RESULT IS A GENERATOR') for r in result: self.tick_out(i, name, level) #print(f'[{name}] =gen=> {r}') for j in g.outputs_of(i): self.run_node(j, r, level=level + 1) else: self.tick_out(i, name, level) #print(f'RESULT IS {result}') #print(f'[{name}] =ret=> {result}') for j in g.outputs_of(i): self.run_node(j, result, level=level + 1) except Exception as e: print(f'**** ERROR running {node}: {e!r}') traceback.print_exc()
def graphviz(self): try: return self._graphviz except AttributeError: g = Digraph() g.attr(rankdir='LR') g.node('BEGIN', shape='point') for i in self.outputs_of(BEGIN): g.edge('BEGIN', str(i)) for ix in self.topologically_sorted_indexes: g.node(str(ix), label=get_name(self[ix])) for iy in self.outputs_of(ix): g.edge(str(ix), str(iy)) self._graphviz = g return self._graphviz
def register(self, x, graph=False): """Register a function as being part of an API, then returns the original function.""" if graph: # This function must comply to the "graph" API interface, meaning it can bahave like bonobo.run. from inspect import signature parameters = list(signature(x).parameters) required_parameters = {'plugins', 'services', 'strategy'} assert len(parameters) > 0 and parameters[ 0] == 'graph', 'First parameter of a graph api function must be "graph".' assert required_parameters.intersection( parameters ) == required_parameters, 'Graph api functions must define the following parameters: ' + ', '.join( sorted(required_parameters)) self.__all__.append(get_name(x)) return x
def register(self, x, graph=False): """Register a function as being part of an API, then returns the original function.""" if graph: # This function must comply to the "graph" API interface, meaning it can bahave like bonobo.run. from inspect import signature parameters = list(signature(x).parameters) required_parameters = {'plugins', 'services', 'strategy'} assert len(parameters ) > 0 and parameters[0] == 'graph', 'First parameter of a graph api function must be "graph".' assert required_parameters.intersection( parameters ) == required_parameters, 'Graph api functions must define the following parameters: ' + ', '.join( sorted(required_parameters) ) self.__all__.append(get_name(x)) return x
def __init__(cls, what, bases=None, dict=None): super().__init__(what, bases, dict) cls.__processors = sortedlist() cls.__processors_cache = None cls.__methods = sortedlist() cls.__options = sortedlist() cls.__names = set() # cls.__kwoptions = [] for typ in cls.__mro__: for name, value in filter(lambda x: isoption(x[1]), typ.__dict__.items()): if iscontextprocessor(value): cls.__processors.insort((value._creation_counter, value)) continue if not value.name: value.name = name if not name in cls.__names: cls.__names.add(name) cls.__options.insort((not value.positional, value._creation_counter, name, value)) # Docstring formating _options_doc = [] for _positional, _counter, _name, _value in cls.__options: _param = _name if _value.type: _param = get_name(_value.type) + ' ' + _param prefix = ':param {}: '.format(_param) for lineno, line in enumerate((_value.__doc__ or '').split('\n')): _options_doc.append((' ' * len(prefix) if lineno else prefix) + line) cls.__doc__ = '\n\n'.join( map( str.strip, filter(None, ( cls.__doc__, '\n'.join(_options_doc) )) ) )
def register_api(x, __all__=__all__): __all__.append(get_name(x)) return x
def _get_graphviz_node_id(graph, i): escaped_index = str(i) escaped_name = json.dumps(get_name(graph[i])) return '{{{} [label={}]}}'.format(escaped_index, escaped_name)
def do_handle(self, graph, **options): if not self.handler: raise RuntimeError("{} has no handler defined.".format(get_name(self))) return self.handler(graph, **options)
def logger(self): try: return self._logger except AttributeError: self._logger = logging.getLogger(get_name(self)) return self._logger
def __name__(self): return get_name(self.func)
def test_create_container_empty_values(services): c = create_container(services) assert len(c) == 2 assert 'fs' in c and get_name(c['fs']) == 'OSFS' assert 'http' in c and get_name(c['http']) == 'requests'
def do_handle(self, graph, **options): if not self.handler: raise RuntimeError('{} has no handler defined.'.format(get_name(self))) return self.handler(graph, **options)
def test_create_container_empty_values(services): c = create_container(services) assert len(c) == 2 assert "fs" in c and get_name(c["fs"]) == "OSFS" assert "http" in c and get_name(c["http"]) == "requests"
def __repr__(self): name, type_name = get_name(self), get_name(type(self)) return '<{}({}{}){}>'.format(type_name, self.status, name, self.get_statistics_as_string(prefix=' '))
def __init__(self, GraphExecutionContextType=None): if not settings.ALPHA.get(): raise NotImplementedError( "{} is experimental, you need to explicitely activate it using ALPHA=True in system env." .format(get_name(self))) super().__init__(GraphExecutionContextType)