It would be great if something like this could be make to work. It is not clear to me how to implement convergence at the moment unless I use raw input and embed the name of the incoming edge that is 'ticking' into the payload.
import bonobo
from bonobo.config import Configurable
from bonobo.config import use_context
#use_context
class A(Configurable):
def __call__(self, context):
context.set_output_fields(['a'])
yield {'a': 'a'}
#use_context
class B(Configurable):
def __call__(self, context, a):
context.set_output_fields(['b'])
yield {'b': 'b'}
#use_context
class F(Configurable):
def __call__(self, context):
context.set_output_fields(['f'])
yield {'f': 'f'}
#use_context
class G(Configurable):
def __call__(self, context, f):
context.set_output_fields(['g'])
yield {'g': 'g'}
#use_context
class Normalize(Configurable):
def __call__(self, context, b, f):
context.set_output_fields(['n'])
yield {'n': 'n'}
if __name__ == '__main__':
n = Normalize()
graph = bonobo.Graph()
# Here we mark _input to None, so normalize won't get the "begin" impulsion.
graph.add_chain(n, _input=None)
# Add two different chains
graph.add_chain(A(), B(), _output=n)
graph.add_chain(F(), G(), _output=n)
bonobo.run(graph)
Currently this code will result in an error that is understandable, but unfortunate:
bonobo.errors.UnrecoverableTypeError Input of <__main__.Normalize object at 0x00000261F76EDD30> does not bind to the node signature.
Args: (<NodeExecutionContext(+Normalize) in=1>,)
Input: Bag(b={'b': 'b'})
Kwargs: {}
Signature: (context, b, f)
- A in=1 out=1 [done]
- B in=1 out=1 [done]
- F in=1 out=1 [done]
- G in=1 out=1 [done]
! Normalize in=1 err=1 [defunct]
Related
I have one function where I am calculating the CPU usage of a test case. The function works, but I would like to append the result of the subtraction in a list for the further usage.
For example, first I subtract 10 and 15, which is -5. At this point the list looks like [-5]. Next I subtract 20 and 30, which is -10. Now I want the list to look like [-5, -10]. My current code is (python 2.7):
import psutil
class CPU():
def __init__(self):
self.cpu_start()
def cpu_start(self):
global a
a= psutil.cpu_percent(interval=1, percpu=False)
print a
def cpu_end(self):
global b
b = psutil.cpu_percent(interval=1, percpu=False)
print b
def diff(self):
c= a-b
list = []
list.append(c)
print list
def main():
CPU()
if __name__ == '__main__':
main()
Just make the diff function return a-b, and append that to an array:
import psutil
class CPU:
def __init__(self):
self.cpu_start()
self.list = []
self.a = 0
self.b = 0
self.c = 0
def cpu_start(self):
self.a = psutil.cpu_percent(interval=1, percpu=False)
return self.a
def cpu_end(self):
self.b = psutil.cpu_percent(interval=1, percpu=False)
return self.b
def diff(self):
self.c = self.cpu_start() - self.cpu_start()
return self.c
def main():
cpu = CPU()
results = []
while True:
results.append(cpu.diff())
print results
if __name__ == '__main__':
main()
Remember that when you're using a class function, you need to create an object of that class, such as cpu = CPU() - I'm creating an object called cpu of class CPU, initialised with nothing. Then the __init__ function will create a and b(created as self.a and self.b, because they're local) and store them locally in that class. The diff() function, takes no arguments, but returns the difference of a and b which are stored locally in that class. Then I create a list called results with no elements. I run cpu.diff(), which gets the difference from cpu_start() and cpu_end(), and append the result to the results array. This is run in a loop, constantly appending to the array and printing it.
Hope this helps.
I have setup celery in my django project using official documentation at
http://docs.celeryproject.org/en/latest/django/first-steps-with-django.html#using-celery-with-django
So my MyApp/tasks.py have content
from celery import shared_task
class Someclass():
def __init__(self, x, y):
self.x = x
self.y = y
#shared_task(bind=True)
def func1(self):
'''This does not work'''
return self.x + self.y
#shared_task(bind=True)
def func2(self, a, b):
'''This works well'''
return a + b
When I run
In [9]: o = Someclass(3, 4)
In [10]: o.func1.delay()
Out[10]: <AsyncResult: afc6b151-d71c-4f46-a916-6917f98c681f>
I get the error
AttributeError: 'func1' object has no attribute 'x'
When I run
In [11]: o.func2.delay(3, 4)
Out[11]: <AsyncResult: 3b227f00-8d9c-472b-b7d8-8b4b6261f689>
This works perfectly
How can I make func1 working so that it can use instance variables e.g. x and y?
from celery import shared_task
#shared_task(bind=True)
def func(self, a, b):
return a + b
class Someclass():
def __init__(self, x, y):
self.x = x
self.y = y
def func1(self):
return func.delay(self.x, self.y)
I tried to run my program using Flask the file local from the Werkzeug file is not working. It has errors and I have no idea how to fix it so it works. Here is a copy of the code from the file. Does anyone know what the file is supposed to look like or knows how to correct it. It is the last step I need to get my program working. I tried to reinstall flask and it didn't work. File is still the same.
"""
werkzeug.local
~~~~~~~~~~~~~~
This module implements context-local objects.
:copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
:license: BSD, see LICENSE for more details.
"""
import copy
from functools import update_wrapper
from werkzeug.wsgi import ClosingIterator
from werkzeug._compat import PY2, implements_bool
# since each thread has its own greenlet we can just use those as identifiers
# for the context. If greenlets are not available we fall back to the
# current thread ident depending on where it is.
try:
from greenlet import getcurrent as get_ident
except ImportError:
try:
from thread import get_ident
except ImportError:
from _thread import get_ident
def release_local(local):
"""Releases the contents of the local for the current context.
This makes it possible to use locals without a manager.
Example::
>>> loc = Local()
>>> loc.foo = 42
>>> release_local(loc)
>>> hasattr(loc, 'foo')
False
With this function one can release :class:`Local` objects as well
as :class:`LocalStack` objects. However it is not possible to
release data held by proxies that way, one always has to retain
a reference to the underlying local object in order to be able
to release it.
.. versionadded:: 0.6.1
"""
local.__release_local__()
class Local(object):
__slots__ = ('__storage__', '__ident_func__')
def __init__(self):
object.__setattr__(self, '__storage__', {})
object.__setattr__(self, '__ident_func__', get_ident)
def __iter__(self):
return iter(self.__storage__.items())
def __call__(self, proxy):
"""Create a proxy for a name."""
return LocalProxy(self, proxy)
def __release_local__(self):
self.__storage__.pop(self.__ident_func__(), None)
def __getattr__(self, name):
try:
return self.__storage__[self.__ident_func__()][name]
except KeyError:
raise AttributeError(name)
def __setattr__(self, name, value):
ident = self.__ident_func__()
storage = self.__storage__
try:
storage[ident][name] = value
except KeyError:
storage[ident] = {name: value}
def __delattr__(self, name):
try:
del self.__storage__[self.__ident_func__()][name]
except KeyError:
raise AttributeError(name)
class LocalStack(object):
"""This class works similar to a :class:`Local` but keeps a stack
of objects instead. This is best explained with an example::
>>> ls = LocalStack()
>>> ls.push(42)
>>> ls.top
42
>>> ls.push(23)
>>> ls.top
23
>>> ls.pop()
23
>>> ls.top
42
They can be force released by using a :class:`LocalManager` or with
the :func:`release_local` function but the correct way is to pop the
item from the stack after using. When the stack is empty it will
no longer be bound to the current context (and as such released).
By calling the stack without arguments it returns a proxy that resolves to
the topmost item on the stack.
.. versionadded:: 0.6.1
"""
def __init__(self):
self._local = Local()
def __release_local__(self):
self._local.__release_local__()
def _get__ident_func__(self):
return self._local.__ident_func__
def _set__ident_func__(self, value):
object.__setattr__(self._local, '__ident_func__', value)
__ident_func__ = property(_get__ident_func__, _set__ident_func__)
del _get__ident_func__, _set__ident_func__
def __call__(self):
def _lookup():
rv = self.top
if rv is None:
raise RuntimeError('object unbound')
return rv
return LocalProxy(_lookup)
def push(self, obj):
"""Pushes a new item to the stack"""
rv = getattr(self._local, 'stack', None)
if rv is None:
self._local.stack = rv = []
rv.append(obj)
return rv
def pop(self):
"""Removes the topmost item from the stack, will return the
old value or `None` if the stack was already empty.
"""
stack = getattr(self._local, 'stack', None)
if stack is None:
return None
elif len(stack) == 1:
release_local(self._local)
return stack[-1]
else:
return stack.pop()
#property
def top(self):
"""The topmost item on the stack. If the stack is empty,
`None` is returned.
"""
try:
return self._local.stack[-1]
except (AttributeError, IndexError):
return None
class LocalManager(object):
"""Local objects cannot manage themselves. For that you need a local
manager. You can pass a local manager multiple locals or add them later
by appending them to `manager.locals`. Every time the manager cleans up,
it will clean up all the data left in the locals for this context.
The `ident_func` parameter can be added to override the default ident
function for the wrapped locals.
.. versionchanged:: 0.6.1
Instead of a manager the :func:`release_local` function can be used
as well.
.. versionchanged:: 0.7
`ident_func` was added.
"""
def __init__(self, locals=None, ident_func=None):
if locals is None:
self.locals = []
elif isinstance(locals, Local):
self.locals = [locals]
else:
self.locals = list(locals)
if ident_func is not None:
self.ident_func = ident_func
for local in self.locals:
object.__setattr__(local, '__ident_func__', ident_func)
else:
self.ident_func = get_ident
def get_ident(self):
"""Return the context identifier the local objects use internally for
this context. You cannot override this method to change the behavior
but use it to link other context local objects (such as SQLAlchemy's
scoped sessions) to the Werkzeug locals.
.. versionchanged:: 0.7
You can pass a different ident function to the local manager that
will then be propagated to all the locals passed to the
constructor.
"""
return self.ident_func()
def cleanup(self):
"""Manually clean up the data in the locals for this context. Call
this at the end of the request or use `make_middleware()`.
"""
for local in self.locals:
release_local(local)
def make_middleware(self, app):
"""Wrap a WSGI application so that cleaning up happens after
request end.
"""
def application(environ, start_response):
return ClosingIterator(app(environ, start_response), self.cleanup)
return application
def middleware(self, func):
"""Like `make_middleware` but for decorating functions.
Example usage::
#manager.middleware
def application(environ, start_response):
...
The difference to `make_middleware` is that the function passed
will have all the arguments copied from the inner application
(name, docstring, module).
"""
return update_wrapper(self.make_middleware(func), func)
def __repr__(self):
return '<%s storages: %d>' % (
self.__class__.__name__,
len(self.locals)
)
#implements_bool
import os
import time
import uuid
import logging
import subprocess
from distutils.spawn import find_executableclass LocalProxy(object):
"""Acts as a proxy for a werkzeug local. Forwards all operations to
a proxied object. The only operations not supported for forwarding
are right handed operands and any kind of assignment.
Example usage::
from werkzeug.local import Local
l = Local()
# these are proxies
request = l('request')
user = l('user')
from werkzeug.local import LocalStack
_response_local = LocalStack()
# this is a proxy
response = _response_local()
Whenever something is bound to l.user / l.request the proxy objects
will forward all operations. If no object is bound a :exc:`RuntimeError`
will be raised.
To create proxies to :class:`Local` or :class:`LocalStack` objects,
call the object as shown above. If you want to have a proxy to an
object looked up by a function, you can (as of Werkzeug 0.6.1) pass
a function to the :class:`LocalProxy` constructor::
session = LocalProxy(lambda: get_current_request().session)
.. versionchanged:: 0.6.1
The class can be instantiated with a callable as well now.
"""
__slots__ = ('__local', '__dict__', '__name__', '__wrapped__')
def __init__(self, local, name=None):
object.__setattr__(self, '_LocalProxy__local', local)
object.__setattr__(self, '__name__', name)
if callable(local) and not hasattr(local, '__release_local__'):
# "local" is a callable that is not an instance of Local or
# LocalManager: mark it as a wrapped function.
object.__setattr__(self, '__wrapped__', local)
def _get_current_object(self):
"""Return the current object. This is useful if you want the real
object behind the proxy at a time for performance reasons or because
you want to pass the object into a different context.
"""
if not hasattr(self.__local, '__release_local__'):
return self.__local()
try:
return getattr(self.__local, self.__name__)
except AttributeError:
raise RuntimeError('no object bound to %s' % self.__name__)
#property
def __dict__(self):
try:
return self._get_current_object().__dict__
except RuntimeError:
raise AttributeError('__dict__')
def __repr__(self):
try:
obj = self._get_current_object()
except RuntimeError:
return '<%s unbound>' % self.__class__.__name__
return repr(obj)
def __bool__(self):
try:
return bool(self._get_current_object())
except RuntimeError:
return False
def __unicode__(self):
try:
return unicode(self._get_current_object()) # noqa
except RuntimeError:
return repr(self)
def __dir__(self):
try:
return dir(self._get_current_object())
except RuntimeError:
return []
def __getattr__(self, name):
if name == '__members__':
return dir(self._get_current_object())
return getattr(self._get_current_object(), name)
def __setitem__(self, key, value):
self._get_current_object()[key] = value
def __delitem__(self, key):
del self._get_current_object()[key]
if PY2:
__getslice__ = lambda x, i, j: x._get_current_object()[i:j]
def __setslice__(self, i, j, seq):
self._get_current_object()[i:j] = seq
def __delslice__(self, i, j):
del self._get_current_object()[i:j]
__setattr__ = lambda x, n, v: setattr(x._get_current_object(), n, v)
__delattr__ = lambda x, n: delattr(x._get_current_object(), n)
__str__ = lambda x: str(x._get_current_object())
__lt__ = lambda x, o: x._get_current_object() < o
__le__ = lambda x, o: x._get_current_object() <= o
__eq__ = lambda x, o: x._get_current_object() == o
__ne__ = lambda x, o: x._get_current_object() != o
__gt__ = lambda x, o: x._get_current_object() > o
__ge__ = lambda x, o: x._get_current_object() >= o
__cmp__ = lambda x, o: cmp(x._get_current_object(), o) # noqa
__hash__ = lambda x: hash(x._get_current_object())
__call__ = lambda x, *a, **kw: x._get_current_object()(*a, **kw)
__len__ = lambda x: len(x._get_current_object())
__getitem__ = lambda x, i: x._get_current_object()[i]
__iter__ = lambda x: iter(x._get_current_object())
__contains__ = lambda x, i: i in x._get_current_object()
__add__ = lambda x, o: x._get_current_object() + o
__sub__ = lambda x, o: x._get_current_object() - o
__mul__ = lambda x, o: x._get_current_object() * o
__floordiv__ = lambda x, o: x._get_current_object() // o
__mod__ = lambda x, o: x._get_current_object() % o
__divmod__ = lambda x, o: x._get_current_object().__divmod__(o)
__pow__ = lambda x, o: x._get_current_object() ** o
__lshift__ = lambda x, o: x._get_current_object() << o
__rshift__ = lambda x, o: x._get_current_object() >> o
__and__ = lambda x, o: x._get_current_object() & o
__xor__ = lambda x, o: x._get_current_object() ^ o
__or__ = lambda x, o: x._get_current_object() | o
__div__ = lambda x, o: x._get_current_object().__div__(o)
__truediv__ = lambda x, o: x._get_current_object().__truediv__(o)
__neg__ = lambda x: -(x._get_current_object())
__pos__ = lambda x: +(x._get_current_object())
__abs__ = lambda x: abs(x._get_current_object())
__invert__ = lambda x: ~(x._get_current_object())
__complex__ = lambda x: complex(x._get_current_object())
__int__ = lambda x: int(x._get_current_object())
__long__ = lambda x: long(x._get_current_object()) # noqa
__float__ = lambda x: float(x._get_current_object())
__oct__ = lambda x: oct(x._get_current_object())
__hex__ = lambda x: hex(x._get_current_object())
__index__ = lambda x: x._get_current_object().__index__()
__coerce__ = lambda x, o: x._get_current_object().__coerce__(x, o)
__enter__ = lambda x: x._get_current_object().__enter__()
__exit__ = lambda x, *a, **kw: x._get_current_object().__exit__(*a, **kw)
__radd__ = lambda x, o: o + x._get_current_object()
__rsub__ = lambda x, o: o - x._get_current_object()
__rmul__ = lambda x, o: o * x._get_current_object()
__rdiv__ = lambda x, o: o / x._get_current_object()
if PY2:
__rtruediv__ = lambda x, o: x._get_current_object().__rtruediv__(o)
else:
__rtruediv__ = __rdiv__
__rfloordiv__ = lambda x, o: o // x._get_current_object()
__rmod__ = lambda x, o: o % x._get_current_object()
__rdivmod__ = lambda x, o: x._get_current_object().__rdivmod__(o)
__copy__ = lambda x: copy.copy(x._get_current_object())
__deepcopy__ = lambda x, memo: copy.deepcopy(x._get_current_object(), memo)
If I run the following code:
class A(object) :
def __init__(self, x, y, z=3.0):
self.x = x
self.y = y
self.z = z
class B(A):
def __init__(self, a, b, c="c", *args, **kwargs):
super(B, self).__init__(*args, **kwargs)
self.a = a
self.b = b
self.c = c
if __name__=="__main__":
thing = B("a", "b", 1, 2)
print thing.x # expect 1
print thing.y # expect 2
print thing.z # expect 3
print thing.a # expect a
print thing.b # expect b
print thing.c # expect c
Instead I get :
Traceback (most recent call last):
File "H:/Python/Random Scripts/python_inheritance.py", line 23, in <module>
thing = B(1,2,"a","b")
File "H:/Python/Random Scripts/python_inheritance.py", line 15, in __init__
super(B, self).__init__(*args, **kwargs)
TypeError: __init__() takes at least 3 arguments (2 given)
It seems like python is parsing the third argument "a" as the kwarg argment c instead of as an arg. How do I get the behaviour that I expect?
I can obviously do :
class B(A):
def __init__(self, a, b, *args, **kwargs):
self.c = kwargs.pop("c", "c")
super(B, self).__init__(*args, **kwargs)
self.a = a
self.b = b
but it seems in every way horrible.
Here are two lines from your code, aligned to show which value is assigned to each name:
def __init__(self, a, b, c="c", *args, **kwargs):
thing = B("a", "b", 1, 2)
As you can see, the 1 is assigned to c, leaving only one argument in the variadic args list. The problem is that there are not two "classes" of argument in the way that you assume: whereas you call c a "kwarg argument" it isn't really defined as such, any more than a is. Both could be addressed by calling B(b="b", **some_dict) assuming some_dict had both an 'a' and a 'c' entry. Instead of a definitional dichotomy between args and kwargs, there are just arguments that have specified default values, and arguments that do not.
I think you're right that kwargs.pop() is your best bet. My code is littered with such "horrible" examples.
I'm attempting to compose a class hierarchy using unittest.TestCase. These aren't strictly unit-tests I'm running here, I'm trying to instead test a bunch of string parsing functionality that is reliant on a few parameters (customer-name and missing-value for example). The general idea is to simply utilize some of unittest's conveniences and keep things DRY.
import unittest
import parsingfunc as i
class CustomerTestCase(unittest.TestCase):
"""Base class, most general functionality and test cases"""
def __init__(self, testname):
super(CustomerTestCase, self).__init__(testname)
# helpers
def mess_with_spaces():
...
def mess_with_case():
...
# tests
def test_case(self, value):
"""
Test that parsing function produces the same
value regardless of case of input
"""
self.assertEqual(self.func(value, missing=self.missing, customer=self.name),
self.func(self.mess_with_case(value), missing=self.missing, customer=self.name)))
...
def test_spaces(self, value):
"""
Test that parsing function produces the same
value regardless of spacing present in input
"""
...
class AisleValues(CustomerTestCase):
"""Base class for testing aisle values"""
def __init__(self, testname, customername=None, missing=None):
super(CustomerTestCase, self).__init__(testname)
self.name = customername
self.missing = missing
self.func = i.aisle_to_num
...
class PeacockAisles(AisleValues):
"""Peacock aisle parsing test cases"""
def __init__(self, testname):
super(AisleValues, self).__init__(testname, customername='peacock', missing='nan')
...
And now try to create instances of these classes
In [6]: a = i.CustomerTestCase('space_test')
In [7]: a.__dict__
Out[7]:
{'_cleanups': [],
'_resultForDoCleanups': None,
'_testMethodDoc': '\n Test that parsing function produces the same\n value regardless of spacing present in input\n ',
'_testMethodName': 'test_spaces',
'_type_equality_funcs': {list: 'assertListEqual',
dict: 'assertDictEqual',
set: 'assertSetEqual',
frozenset: 'assertSetEqual',
tuple: 'assertTupleEqual',
unicode: 'assertMultiLineEqual'}}
In [8]: b = i.AisleValues('test_spaces')
In [9]: b.__dict__
Out[9]:
{'_cleanups': [],
'_resultForDoCleanups': None,
'_testMethodDoc': '\n Test that parsing function produces the same\n value regardless of spacing present in input\n ',
'_testMethodName': 'test_spaces',
'_type_equality_funcs': {list: 'assertListEqual',
dict: 'assertDictEqual',
set: 'assertSetEqual',
frozenset: 'assertSetEqual',
tuple: 'assertTupleEqual',
unicode: 'assertMultiLineEqual'},
'func': <function integration.aisle_to_num>,
'missing': None,
'name': None}
In [10]: b = i.AisleValues('test_spaces', customername='peacock', missing='nan')
In [11]: b.__dict__
Out[12]:
{'_cleanups': [],
'_resultForDoCleanups': None,
'_testMethodDoc': '\n Test that parsing function produces the same\n value regardless of spacing present in input\n ',
'_testMethodName': 'test_spaces',
'_type_equality_funcs': {list: 'assertListEqual',
dict: 'assertDictEqual',
set: 'assertSetEqual',
frozenset: 'assertSetEqual',
tuple: 'assertTupleEqual',
unicode: 'assertMultiLineEqual'},
'func': <function integration.aisle_to_num>,
'missing': 'nan',
'name': 'peacock'}
In [13]: c = i.PeacockAisles('test_spaces')
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-12-d4bba181b94e> in <module>()
----> 1 c = i.PeacockAisles('test_spaces')
/path/to/python.py in __init__(self, testname)
89
90 def __init__(self, testname):
---> 91 super(AisleValues, self).__init__(testname, customername='peacock', missing='nan')
92 pprint(self.__dict__)
93
TypeError: __init__() got an unexpected keyword argument 'customername'
So what's the deal? Thanks!
You're not calling super correctly. When you name a class in the super call, it should be the current class, not a base class (unless you really know what you're doing and you want to skip the base class's implementation too, in favor of a "grandparent" class).
Your current code has AisleValues.__init__ calling unittest.TestCase.__init__, bypassing CustomerTestCase.__init__. It happens to work because CustomerTestCase.__init__ doesn't do anything useful (you could delete it with no effect), but that's just luck. When PeacockAisles.__init__ calls CustomerTestCase.__init__ (bypassing AisleValues.__init__), it fails because the grandparent class doesn't allow all the same arguments as its child.
You want:
class AisleValues(CustomerTestCase):
"""Base class for testing aisle values"""
def __init__(self, testname, customername=None, missing=None):
super(AisleValues, self).__init__(testname) # change the class named here
...
And:
class PeacockAisles(AisleValues):
"""Peacock aisle parsing test cases"""
def __init__(self, testname):
super(PeacockAisles, self).__init__(testname, customername='peacock', missing='nan')
... # and on the previous line