def test_same_url(self):
class TestSameUrlSpider(Spider):
name = 'test_same_url'
def __init__(self, *args, **kwargs):
super(TestSameUrlSpider, self).__init__(*args, **kwargs)
self.visited = 0
def start_requests(s):
return self.conman.from_spider(s, self.results)
def parse_first(self, response):
self.visited += 1
return TestItem()
def parse_second(self, response):
self.visited += 1
return TestItem()
with MockServer() as mockserver:
contract_doc = '@url {}'.format(mockserver.url('/status?n=200'))
get_unbound_function(TestSameUrlSpider.parse_first).__doc__ = contract_doc
get_unbound_function(TestSameUrlSpider.parse_second).__doc__ = contract_doc
crawler = CrawlerRunner().create_crawler(TestSameUrlSpider)
yield crawler.crawl()
self.assertEqual(crawler.spider.visited, 2)
def test_same_url(self):
class TestSameUrlSpider(Spider):
name = 'test_same_url'
def __init__(self, *args, **kwargs):
super(TestSameUrlSpider, self).__init__(*args, **kwargs)
self.visited = 0
def start_requests(s):
return self.conman.from_spider(s, self.results)
def parse_first(self, response):
self.visited += 1
return TestItem()
def parse_second(self, response):
self.visited += 1
return TestItem()
with MockServer() as mockserver:
contract_doc = '@url {}'.format(mockserver.url('/status?n=200'))
get_unbound_function(
TestSameUrlSpider.parse_first).__doc__ = contract_doc
get_unbound_function(
TestSameUrlSpider.parse_second).__doc__ = contract_doc
crawler = CrawlerRunner().create_crawler(TestSameUrlSpider)
yield crawler.crawl()
self.assertEqual(crawler.spider.visited, 2)
def wrapped(cls):
applies_to = set([])
classess_to_apply = [c for c in classess if not skip_classess or c not in skip_classess]
if add_classess:
classess_to_apply += [c for c in add_classess if not skip_classess or c not in skip_classess]
for autodoc_class in classess_to_apply:
applies_to |= set(autodoc_class.applies_to)
# Create facades for original methods - docstring of methods are immutable, so we need to change docstring of
# functions. But without shadowing the method.__func__ will point to the same function for classes that
# inherits them from the same parents.
for method_name in applies_to:
method = getattr(cls, method_name, None)
if method:
copy_method(cls, method_name, method)
# update docstrings
for autodoc_class in classess_to_apply:
for method_name in autodoc_class.applies_to:
method = getattr(cls, method_name, None)
if method:
six.get_unbound_function(method).__doc__ = \
autodoc_class.update_docstring(cls, base_doc, six.get_unbound_function(method).__doc__,
method_name)
return cls
class Helper(object):
"""Helper class."""
begin_goodjson = six.get_unbound_function(gj_doc.Helper.begin_goodjson)
__set_gj_flag_sub_field = six.get_unbound_function(
gj_doc.Helper.__set_gj_flag_sub_field)
__unset_gj_flag_sub_field = six.get_unbound_function(
gj_doc.Helper.__unset_gj_flag_sub_field)
def _parse(*a):
if a[0] in builtin_x:
x = getattr(A.X, a[0])
# Get the function out of unbound method.
# In Python 3, unbound methods don't exist, so this function
# just returns the function object unchanged.
return six.get_unbound_function(x)(*[A.Y._alias_field(f) for f in a[1:]]) if callable(x) else x
else:
return six.get_unbound_function(A.X._)(*a)
def getdefiningclass(m, owner_class):
"""Resolves the class (e.g. one of the superclasses) that defined a method."""
m = six.get_unbound_function(m)
last_defining = owner_class
for superclass in tf_inspect.getmro(owner_class):
if hasattr(superclass, m.__name__):
superclass_m = getattr(superclass, m.__name__)
if six.get_unbound_function(superclass_m) == m:
last_defining = superclass
return last_defining
def test_replace():
"""Replaced methods replace the original one, but are restored after the with."""
class SomethingElse(object):
def foo(self, n, y=None):
assert None, 'This should never be reached in this test'
# Case: bound method
s = SomethingElse()
def replacement(n, y=None):
return y
original_method = six.get_method_function(s.foo)
with replaced(s.foo, replacement):
assert s.foo(1, y='a') == 'a'
assert s.foo(2) == None
assert six.get_method_function(s.foo) is original_method
# Case: unbound method
"""Python 3 does not support the concept of unbound methods, they are
just plain functions without an im_class pointing back to their class.
See https://docs.python.org/3/whatsnew/3.0.html#operators-and-special-methods,
and https://mail.python.org/pipermail/python-dev/2005-January/050625.html
for the rationale.
To be able to support them under Python3, on= is mandatory.
"""
s = SomethingElse()
def replacement(self, n, y=None):
return y
original_method = six.get_unbound_function(SomethingElse.foo)
with replaced(SomethingElse.foo, replacement, on=SomethingElse):
assert s.foo(1, y='a') == 'a'
assert s.foo(2) == None
restored_method = six.get_unbound_function(SomethingElse.foo)
assert restored_method is original_method
# Case: unbound method (no on= given)
s = SomethingElse()
def replacement(self, n, y=None):
return y
with pytest.raises(
ValueError,
match='You have to supply a on= when stubbing an unbound method'):
with replaced(SomethingElse.foo, replacement):
pass
class TimerServiceMixin(object):
security = ClassSecurityInfo()
security.declareProtected(Permissions.AccessContentsInformation,
'isSubscribed')
def isSubscribed(self):
"""Return True if we are subscribed to TimerService, otherwise return False
"""
service = getTimerService(self)
return service and \
'/'.join(self.getPhysicalPath()) in service.lisSubscriptions()
security.declareProtected(Permissions.ManageProperties, 'subscribe')
def subscribe(self):
"""Subscribe to the global Timer Service"""
service = getTimerService(self)
if service:
service.subscribe(self)
return "Subscribed to Timer Service"
return "TimerService not available"
security.declareProtected(Permissions.ManageProperties, 'unsubscribe')
def unsubscribe(self):
"""Unsubscribe from the global Timer Service"""
service = getTimerService(self)
if service:
service.unsubscribe(self)
return "Usubscribed from Timer Service"
return "TimerService not available"
security.declarePrivate('manage_beforeDelete')
def manage_beforeDelete(self, *args, **kw):
self.unsubscribe()
super(TimerServiceMixin, self).manage_beforeDelete(*args, **kw)
security.declarePrivate('manage_afterAdd')
def manage_afterAdd(self, *args, **kw):
self.subscribe()
super(TimerServiceMixin, self).manage_afterAdd(*args, **kw)
security.declarePublic('getCurrentNode')
getCurrentNode = six.get_unbound_function(ActivityTool.getCurrentNode)
security.declarePublic('getServerAddress')
getServerAddress = six.get_unbound_function(ActivityTool.getServerAddress)
_isValidNodeName = six.get_unbound_function(ActivityTool._isValidNodeName)
def __new__(cls, obj, recursive=False):
self = object.__new__(cls)
obj = aq_base(obj)
connection = obj._p_jar
ObjectReader.__init__(self, connection, connection._cache,
connection._db.classFactory)
ObjectWriter.__init__(self, obj)
migrated_oid_set = set()
oid_set = {obj._p_oid}
while oid_set:
oid = oid_set.pop()
obj = ObjectReader.load_oid(self, oid)
obj._p_activate()
klass = obj.__class__
self.lazy = None
if not recursive:
_setOb = getattr(klass, '_setOb', None)
if _setOb:
if isinstance(_setOb, WorkflowMethod):
_setOb = _setOb._m
import six
if six.get_unbound_function(
_setOb) is six.get_unbound_function(
OFS_Folder._setOb):
self.lazy = Ghost
elif klass.__module__[:
7] == 'BTrees.' and klass.__name__ != 'Length':
self.lazy = LazyBTree()
self.oid_dict = {}
self.oid_set = set()
p, serial = self._conn._storage.load(oid, '')
unpickler = self._get_unpickler(p)
def find_global(*args):
self.do_migrate = args != (klass.__module__, klass.__name__) and \
not isOldBTree('%s.%s' % args)
unpickler.find_global = self._get_class
return self._get_class(*args)
unpickler.find_global = find_global
unpickler.load() # class
state = unpickler.load()
if isinstance(self.lazy, LazyPersistent):
self.oid_set.update(self.lazy.getOidList(state))
migrated_oid_set.add(oid)
oid_set |= self.oid_set - migrated_oid_set
self.oid_set = None
if self.do_migrate:
log.debug('PickleUpdater: migrate %r (%r)', obj, klass)
self.setGhostState(obj, self.serialize(obj))
obj._p_changed = 1
def _load_ui_into_display(uifile, display):
klass, _ = uic.loadUiType(uifile)
# Python 2.7 compatibility. More info at the following links:
# https://github.com/universe-proton/universe-topology/issues/3
# https://stackoverflow.com/questions/3296993/python-how-to-call-unbound-method-with-other-type-parameter
retranslateUi = six.get_unbound_function(klass.retranslateUi)
setupUi = six.get_unbound_function(klass.setupUi)
# Add retranslateUi to Display class
display.retranslateUi = functools.partial(retranslateUi, display)
setupUi(display, display)
display.ui = display
def can_validate_otp(self):
"""If the interface is able to validate OTP codes then this returns
`True`.
"""
return self.validate_otp.__func__ is not six.get_unbound_function(
AuthenticatorInterface.validate_otp
)
def monkey_mix(cls, mixin, methods=None):
"""
Mixes a mixin into existing class.
Does not use actual multi-inheritance mixins, just monkey patches methods.
Mixin methods can call copies of original ones stored in `_no_monkey` proxy:
class SomeMixin(object):
def do_smth(self, arg):
... do smth else before
self._no_monkey.do_smth(self, arg)
... do smth else after
"""
assert '_no_monkey' not in cls.__dict__, 'Multiple monkey mix not supported'
cls._no_monkey = MonkeyProxy(cls)
if methods is None:
# NOTE: there no such thing as unbound method in Python 3, it uses naked functions,
# so we use some six based altering here
isboundmethod = inspect.isfunction if six.PY3 else inspect.ismethod
methods = inspect.getmembers(mixin, isboundmethod)
else:
methods = [(m, getattr(mixin, m)) for m in methods]
for name, method in methods:
if hasattr(cls, name):
setattr(cls._no_monkey, name, getattr(cls, name))
# NOTE: remember, there is no bound methods in Python 3
setattr(cls, name, six.get_unbound_function(method))
class MappingProperty(AnnotationMixin, QueryableProperty):
"""
A property that translates values of an attribute into other values using
defined mappings.
"""
# Copy over Django's implementation to forcibly evaluate a lazy value.
_force_value = six.get_unbound_function(Field.get_prep_value)
def __init__(self,
attribute_path,
output_field,
mappings,
default=None,
**kwargs):
"""
Initialize a property that maps values from an attribute to other
values.
:param str attribute_path: The name of the attribute to compare
against. May also be a more complex path to
a related attribute using dot-notation (like
with :func:`operator.attrgetter`). If an
intermediate value on the path is None, it
will be treated as "no match" instead of
raising an exception. The behavior is the
same if an intermediate value raises an
``ObjectDoesNotExist`` error.
:param django.db.models.Field output_field: The field to represent the
mapped values in querysets.
:param mappings: An iterable containing 2-tuples that represent the
mappings to use (the first value of each tuple is
mapped to the second value).
:type mappings: collections.Iterable[(object, object)]
:param default: A default value to return/use in querysets when in case
none of the mappings match an encountered value.
Defaults to None.
"""
super(MappingProperty, self).__init__(**kwargs)
self.attribute_getter = ModelAttributeGetter(attribute_path)
self.output_field = output_field
self.mappings = mappings
self.default = default
def get_value(self, obj):
attibute_value = self.attribute_getter.get_value(obj)
for from_value, to_value in self.mappings:
if attibute_value == from_value:
return self._force_value(to_value)
return self._force_value(self.default)
def get_annotation(self, cls):
from django.db.models import Case, Value, When
cases = (When(self.attribute_getter.build_filter('exact', from_value),
then=Value(self._force_value(to_value)))
for from_value, to_value in self.mappings)
return Case(*cases,
default=Value(self._force_value(self.default)),
output_field=self.output_field)
def get_validator(self, name, **kwargs):
attr_name = '%s_validator' % name
attr = getattr(self.meta, attr_name)
if inspect.ismethod(attr):
return six.get_unbound_function(attr)(**kwargs)
else:
return attr(**kwargs)
def _is_known_loaded_type(f, module_name, entity_name):
"""Tests whether the function or method is an instance of a known type."""
if (module_name not in sys.modules or
not hasattr(sys.modules[module_name], entity_name)):
return False
type_entity = getattr(sys.modules[module_name], entity_name)
if isinstance(f, type_entity):
# The method if of this type. Example:
#
# o = ClassType()
# function(o.method)()
return True
if tf_inspect.ismethod(f):
f = six.get_unbound_function(f)
# The the unbound method if of this type. Example:
#
# class ClassType:
# @function
# def method(self):
# ...
# o = ClassType()
# o.method()
if isinstance(f, type_entity):
return True
return False
def _is_known_loaded_type(f, module_name, entity_name):
"""Tests whether the function or method is an instance of a known type."""
if (module_name not in sys.modules
or not hasattr(sys.modules[module_name], entity_name)):
return False
type_entity = getattr(sys.modules[module_name], entity_name)
if isinstance(f, type_entity):
# The method if of this type. Example:
#
# o = ClassType()
# function(o.method)()
return True
# Note: inspect is required here, to avoid unpacking tf.function decorators.
if inspect.ismethod(f):
f = six.get_unbound_function(f)
# The the unbound method if of this type. Example:
#
# class ClassType:
# @function
# def method(self):
# ...
# o = ClassType()
# o.method()
if isinstance(f, type_entity):
return True
return False
def _parse(*a):
if a[0] in builtin_y:
y = getattr(A.Y, a[0])
return six.get_unbound_function(y)(
*a[1:]) if callable(y) else y
else:
return a[0]
def monkey_mix(cls, mixin, methods=None):
"""
Mixes a mixin into existing class.
Does not use actual multi-inheritance mixins, just monkey patches methods.
Mixin methods can call copies of original ones stored in `_no_monkey` proxy:
class SomeMixin(object):
def do_smth(self, arg):
... do smth else before
self._no_monkey.do_smth(self, arg)
... do smth else after
"""
assert '_no_monkey' not in cls.__dict__, 'Multiple monkey mix not supported'
cls._no_monkey = MonkeyProxy(cls)
if methods is None:
# NOTE: there no such thing as unbound method in Python 3, it uses naked functions,
# so we use some six based altering here
isboundmethod = inspect.isfunction if six.PY3 else inspect.ismethod
methods = inspect.getmembers(mixin, isboundmethod)
else:
methods = [(m, getattr(mixin, m)) for m in methods]
for name, method in methods:
if hasattr(cls, name):
setattr(cls._no_monkey, name, getattr(cls, name))
# NOTE: remember, there is no bound methods in Python 3
setattr(cls, name, six.get_unbound_function(method))
def requires_activation(self):
"""If the interface has an activation method that needs to be
called this returns `True`.
"""
return self.activate.__func__ is not six.get_unbound_function(
AuthenticatorInterface.activate
)
def get_validator(self, name, **kwargs):
attr_name = '%s_validator' % name
attr = getattr(self.meta, attr_name)
if inspect.ismethod(attr):
return six.get_unbound_function(attr)(**kwargs)
else:
return attr(**kwargs)
class MysqlRefsContainer(RefsContainer):
"""RefsContainer backed by MySql.
This container does not support packed references.
"""
def __init__(self, repo):
super(MysqlRefsContainer, self).__init__()
self._repo = repo
get_packed_refs = get_unbound_function(DictRefsContainer.get_packed_refs)
def allkeys(self):
for ref in Refs.objects.filter(repo=self._repo).only('ref').iterator():
yield ref.ref
def read_loose_ref(self, name):
qs = Refs.objects.only('value')
if not get_autocommit(using=qs._db):
qs = qs.select_for_update()
try:
ref = qs.get(repo=self._repo, ref=name)
except Refs.DoesNotExist:
return None
else:
return ref.value
def set_symbolic_ref(self, name, other):
self._update_ref(name, SYMREF + other)
def set_if_equals(self, name, old_ref, new_ref):
if old_ref is not None and self.read_loose_ref(name) != old_ref:
return False
realnames, _ = self.follow(name)
for realname in realnames:
self._check_refname(realname)
self._update_ref(realname, new_ref)
return True
def add_if_new(self, name, ref):
if self.read_loose_ref(name):
return False
self._update_ref(name, ref)
return True
def remove_if_equals(self, name, old_ref):
if old_ref is not None and self.read_loose_ref(name) != old_ref:
return False
self._remove_ref(name)
return True
def _update_ref(self, name, value):
Refs.objects.update_or_create(repo=self._repo,
ref=name,
defaults={
'value': value,
})
def _remove_ref(self, name):
Refs.objects.filter(repo=self._repo, ref=name).delete()
def _update_class(oldclass, newclass):
"""Update a class object."""
# XXX What about __slots__?
olddict = oldclass.__dict__
newdict = newclass.__dict__
oldnames = set(olddict)
newnames = set(newdict)
for name in newnames - oldnames:
setattr(oldclass, name, newdict[name])
# Note: We do not delete attributes, because various ZCML directives,
# grokkers and other wiring add class attributes during startup that
# would get lost if we did this. Note that attributes will still be
# overwritten if they've changed.
#
# for name in oldnames - newnames:
# delattr(oldclass, name)
for name in oldnames & newnames - CLASS_STATICS:
try:
new = getattr(newclass, name)
old = getattr(oldclass, name, None)
if isinstance(new, (types.FunctionType, types.MethodType)):
if isinstance(old, property) and not isinstance(new, property):
# Removing a decorator
setattr(oldclass, name, six.get_unbound_function(new))
elif isinstance(new, types.FunctionType):
# Under Py3 there are only functions
_update_function(old, new)
elif isinstance(new, types.MethodType):
# Py2-only
_update_method(old, new)
else:
new2 = newdict.get(name)
if new is not new2:
# Do we have some sort of descriptor? Set the underlying
# descriptor and not the result of the descriptor call
setattr(oldclass, name, new2)
else:
# Fallback to just replace the item
setattr(oldclass, name, new)
except ClosureChanged:
# If the closure changed, we need to replace the entire function
setattr(oldclass, name, six.get_unbound_function(new))
return oldclass
def on_bound(cls, app):
# Set up celery beat entry after celery app initialization is done.
enabled = cls._enabled
if callable(enabled):
enabled = get_unbound_function(enabled)(app.app_config)
if enabled and cls._schedule:
app.conf.CELERYBEAT_SCHEDULE.update(cls.beat_config())
def _update_class(oldclass, newclass):
"""Update a class object."""
# XXX What about __slots__?
olddict = oldclass.__dict__
newdict = newclass.__dict__
oldnames = set(olddict)
newnames = set(newdict)
for name in newnames - oldnames:
setattr(oldclass, name, newdict[name])
# Note: We do not delete attributes, because various ZCML directives,
# grokkers and other wiring add class attributes during startup that
# would get lost if we did this. Note that attributes will still be
# overwritten if they've changed.
#
# for name in oldnames - newnames:
# delattr(oldclass, name)
for name in oldnames & newnames - CLASS_STATICS:
try:
new = getattr(newclass, name)
old = getattr(oldclass, name, None)
if isinstance(new, (types.FunctionType, types.MethodType)):
if isinstance(old, property) and not isinstance(new, property):
# Removing a decorator
setattr(oldclass, name, six.get_unbound_function(new))
elif isinstance(new, types.FunctionType):
# Under Py3 there are only functions
_update_function(old, new)
elif isinstance(new, types.MethodType):
# Py2-only
_update_method(old, new)
else:
new2 = newdict.get(name)
if new is not new2:
# Do we have some sort of descriptor? Set the underlying
# descriptor and not the result of the descriptor call
setattr(oldclass, name, new2)
else:
# Fallback to just replace the item
setattr(oldclass, name, new)
except ClosureChanged:
# If the closure changed, we need to replace the entire function
setattr(oldclass, name, six.get_unbound_function(new))
return oldclass
def test_namreply_no_channel(self):
"""
If channel is '*', _on_namreply should not crash.
Regression test for #22
"""
event = irc.client.Event(type=None, source=None, target=None, arguments=["*", "*", "nick"])
_on_namreply = six.get_unbound_function(irc.bot.SingleServerIRCBot._on_namreply)
_on_namreply(None, None, event)
def _instance_overrides_method(base, instance, method_name):
"""
Returns True if instance overrides a method (method_name)
inherited from base.
"""
bound_method = getattr(instance, method_name)
unbound_method = getattr(base, method_name)
return get_unbound_function(unbound_method) != get_method_function(
bound_method)
def patch():
import six
import traceback
from unittest import TextTestResult, TextTestRunner
TextTestResult_addError = six.get_unbound_function(TextTestResult.addError)
def addError(self, test, err):
if isinstance(err[1], SetupSiteError):
self.errors.append(None)
elif isinstance(err[1], SystemExit):
raise err
else:
TextTestResult_addError(self, test, err)
TextTestResult.addError = addError
def wasSuccessful(self):
"Tells whether or not this result was a success"
return not (self.failures or self.errors or self.unexpectedSuccesses)
TextTestResult.wasSuccessful = wasSuccessful
def printErrors(self):
if self.dots or self.showAll:
self.stream.writeln()
# 'None' correspond to redundant errors due to site creation errors,
# and we do not display them here.
self.printErrorList('ERROR', filter(None, self.errors))
self.printErrorList('FAIL', self.failures)
if self.unexpectedSuccesses:
self.stream.writeln(self.separator1)
for test in self.unexpectedSuccesses:
self.stream.writeln("SUCCESS: %s" % self.getDescription(test))
TextTestResult.printErrors = printErrors
TextTestRunner_run = six.get_unbound_function(TextTestRunner.run)
def run(self, test):
def t(result):
try:
test(result)
except (KeyboardInterrupt, SystemExit):
traceback.print_exc()
return TextTestRunner_run(self, t)
TextTestRunner.run = run
def test_namreply_no_channel(self):
"""
If channel is '*', _on_namreply should not crash.
Regression test for #22
"""
event = irc.client.Event(type=None, source=None, target=None,
arguments=['*', '*', 'nick'])
_on_namreply = six.get_unbound_function(
irc.bot.SingleServerIRCBot._on_namreply)
_on_namreply(None, None, event)
def update_docstrings(klass):
super_klass = super(klass, klass)
for property in dir(klass):
if property.startswith('t_'):
source = getattr(super_klass, property, None)
if callable(source):
destination = getattr(klass, property)
assert callable(destination)
destination = six.get_unbound_function(destination)
if destination.__doc__ is None:
destination.__doc__ = source.__doc__
def __new__(cls):
self = object.__new__(cls)
self._connection = os.getenv(
'erp5_sql_connection_string') or 'test test'
self.conv = None
parse_connection_string_function = six.get_unbound_function(
DB._parse_connection_string)
parse_connection_string_function(self)
return ''.join('-%s%s ' % (self.args_dict[k], v)
for k, v in six.iteritems(self._kw_args)
if k in self.args_dict) + self._kw_args['db']
def load_ui_file(uifile, macros=None):
"""
Load a .ui file, perform macro substitution, then return the resulting QWidget.
This is an internal method, users will usually want to use `open_file` instead.
Parameters
----------
uifile : str
The path to a .ui file to load.
macros : dict, optional
A dictionary of macro variables to supply to the file
to be opened.
Returns
-------
QWidget
"""
d = Display(macros=macros)
if macros:
f = macro.substitute_in_file(uifile, macros)
else:
f = uifile
klass, _ = uic.loadUiType(f)
# Python 2.7 compatibility. More info at the following links:
# https://github.com/universe-proton/universe-topology/issues/3
# https://stackoverflow.com/questions/3296993/python-how-to-call-unbound-method-with-other-type-parameter
retranslateUi = six.get_unbound_function(klass.retranslateUi)
setupUi = six.get_unbound_function(klass.setupUi)
# Add retranslateUi to Display class
d.retranslateUi = functools.partial(retranslateUi, d)
d._loaded_file = uifile
setupUi(d, d)
d.ui = d
return d
def test_getter(self, old_getter, init_kwargs, old_docstring,
new_docstring, kwargs):
original = queryable_property(old_getter, **init_kwargs)
if old_docstring is not None:
original.__doc__ = old_docstring
def func():
pass
func.__doc__ = new_docstring
clone = self.decorate_function(func, original.getter, kwargs)
changed_attrs = dict(kwargs or {},
get_value=func,
__doc__=new_docstring or old_docstring)
if init_kwargs.get('annotation_based', False):
changed_attrs['get_filter'] = six.create_bound_method(
six.get_unbound_function(AnnotationMixin.get_filter), clone)
changed_attrs['get_annotation'] = six.create_bound_method(
six.get_unbound_function(AnnotationMixin.get_annotation),
clone)
self.assert_cloned_property(original, clone, changed_attrs)
def test_taskset_inheritance(self):
def t1(l):
pass
class MyBaseTaskSet(TaskSet):
tasks = [t1]
host = ""
class MySubTaskSet(MyBaseTaskSet):
@task
def t2(self):
pass
l = MySubTaskSet(self.locust)
self.assertEqual(2, len(l.tasks))
self.assertEqual([t1, six.get_unbound_function(MySubTaskSet.t2)], l.tasks)
def test_taskset_inheritance(self):
def t1(l):
pass
class MyBaseTaskSet(TaskSet):
tasks = [t1]
host = ""
class MySubTaskSet(MyBaseTaskSet):
@task
def t2(self):
pass
l = MySubTaskSet(self.locust)
self.assertEqual(2, len(l.tasks))
self.assertEqual([t1, six.get_unbound_function(MySubTaskSet.t2)], l.tasks)
def plot_ratio(self, target_axes, error_contributions=('data',), **kwargs):
"""
Plot the data/model ratio to a specified ``matplotlib`` ``Axes`` object.
:param target_axes: ``matplotlib`` ``Axes`` object
:param kwargs: keyword arguments accepted by the ``matplotlib`` methods ``errorbar`` or ``plot``
:return: plot handle(s)
"""
return six.get_unbound_function(XYPlotAdapter.plot_ratio)(
self,
target_axes=target_axes,
error_contributions=error_contributions,
**kwargs
)
def __getattr__(self, name):
if name in (_[0] for _ in getmembers(UserEditable, predicate=isroutine)) and \
self.is_content_editable:
self._content_editable = True
setattr(
self, name,
six.create_bound_method(
six.get_unbound_function(getattr(UserEditable, name)),
self))
return getattr(self, name)
else:
raise AttributeError("Element '{}' has no attribute "
"'{}'".format(
self.__class__.__name__.capitalize(),
name))
def fetch_cls_init(cls):
"""Return reference to the class.__init__() method if it is defined.
:param cls: Class instance
:type cls: type
:return: Reference to the class.__init__() if any, or None otherwise.
:rtype: unbound method | None
"""
try:
cls_init = six.get_unbound_function(cls.__init__)
assert cls_init is not _OBJECT_INIT
except (AttributeError, AssertionError):
return None
else:
return cls_init
def _getFunction(self, reload=False):
import erp5.component.extension
component_module = erp5.component.extension.find_load_module(
self._module)
if component_module is None:
# Fall back on filesystem
if not reload:
from Globals import DevelopmentMode
if DevelopmentMode:
try:
last_read, path = self._v_fs
except AttributeError:
last_read = None
path = getPath('Extensions',
self._module,
suffixes=('', 'py', 'pyc'))
ts = os.stat(path)[stat.ST_MTIME]
if last_read != ts:
self._v_fs = ts, path
reload = True
f = getObject(self._module, self._function, reload)
else:
f = getattr(component_module, self._function)
try:
_f = self._v_f
if _f[0] is f:
return _f
except AttributeError:
pass
code = f.func_code
argument_object = getargs(code)
# reconstruct back the original names
arg_list = argument_object.args[:]
if argument_object.varargs:
arg_list.append('*' + argument_object.varargs)
if argument_object.keywords:
arg_list.append('**' + argument_object.keywords)
i = isinstance(f, MethodType)
ff = six.get_unbound_function(f) if i else f
has_self = len(arg_list) > i and arg_list[i] == 'self'
i += has_self
if i:
code = FuncCode(ff, i)
self._v_f = _f = (f, f.func_defaults, code, has_self, arg_list)
return _f
def __call__(self, wrapped):
if isinstance(wrapped, six.class_types):
cls = wrapped
try:
cls_init = six.get_unbound_function(cls.__init__)
assert cls_init is not OBJECT_INIT
except (AttributeError, AssertionError):
raise DiError('Class %s has no __init__ to inject' % cls)
cls.__init__ = self(cls_init)
return cls
if not any([self.args, self.kwargs]):
self.injectables = self.di.get_deps(wrapped)
else:
self.injectables = []
if self.args:
self.injectables.extend(self.args)
if self.kwargs:
self.injectables.extend(self.kwargs.values())
self.di.depends_on(*self.injectables)(wrapped)
return self.decorate(wrapped)
def __init__(self, doc_object):
self.doc_object = doc_object
self.description = dedent(self.doc_object.__doc__)
try:
if isinstance(self.doc_object, type):
func = six.get_unbound_function(self.doc_object.__init__)
elif (hasattr(self.doc_object, '__call__')
and not isinstance(self.doc_object, types.FunctionType)):
func = self.doc_object.__call__
else:
func = self.doc_object
if hasattr(func, '__paste_sig__'):
sig = func.__paste_sig__
else:
sig = inspect.getargspec(func)
sig = inspect.formatargspec(*sig)
except TypeError:
sig = None
if sig:
if self.description:
self.description = '%s\n\n%s' % (
sig, self.description)
else:
self.description = sig
def patch():
"""
Patch `bs4.Tag` to include new functionality.
:return:
"""
bs4.Tag._feature_hash = six.get_unbound_function(TagHash._feature_hash)
bs4.Tag._tag_hash = six.get_unbound_function(TagHash._tag_hash)
bs4.Tag.hash = six.get_unbound_function(TagHash._hash)
bs4.Tag.hash_compare = six.get_unbound_function(TagHash._tag_hash_compare)
bs4.Tag._recursive_structure_xpath = six.get_unbound_function(TagHash._recursive_structure_xpath)
bs4.Tag.structure_xpath = six.get_unbound_function(TagHash._structure_xpath)
bs4.Tag._tag_sibling_position = six.get_unbound_function(TagHash._tag_sibling_position)
bs4.Tag.identifying_xpath = six.get_unbound_function(TagHash._identifying_xpath)
bs4.Tag.relative_xpath = six.get_unbound_function(TagHash._relative_xpath)
bs4.Tag._recursive_count = six.get_unbound_function(TagHash._recursive_count)
bs4.Tag.count = six.get_unbound_function(TagHash._count)
bs4.Tag.lxml = TagHash._lxml
bs4.Tag.iterate = six.get_unbound_function(TagHash._iterate)
bs4.Tag.inner_text = TagHash._inner_text
bs4.Tag.level = TagHash._level
bs4.Tag.is_list = six.get_unbound_function(TagHash._is_list)
bs4.Tag.has_identical_parent = six.get_unbound_function(TagHash._has_identical_parent)
@security.protected(AddPortalFolders)
def manage_addPortalFolder(self, id, title='', REQUEST=None):
"""Add a new PortalFolder object with id *id*.
"""
ob = PortalFolder(id, title)
self._setObject(id, ob, suppress_events=True)
if REQUEST is not None:
return self.folder_contents( # XXX: ick!
self, REQUEST, portal_status_message='Folder added')
InitializeClass(PortalFolder)
PortalFolderFactory = Factory(PortalFolder)
manage_addPortalFolder = get_unbound_function(
PortalFolder.manage_addPortalFolder)
class ContentFilter:
"""Represent a predicate against a content object's metadata.
"""
MARKER = []
filterSubject = []
def __init__(self, Title=MARKER, Creator=MARKER, Subject=MARKER,
Description=MARKER, created=MARKER, created_usage='range:min',
modified=MARKER, modified_usage='range:min', Type=MARKER,
portal_type=MARKER, **Ignored):
def _get_object_init():
if six.PY3 or IS_PYPY:
return six.get_unbound_function(object.__init__)
def _update_method(oldmeth, newmeth):
"""Update a method object."""
# XXX What if im_func is not a function?
_update_function(six.get_unbound_function(oldmeth),
six.get_unbound_function(newmeth))
return oldmeth
def __init__(self, likelihood, Y, tolerance):
self.likelihood, self.Y, self.tolerance = likelihood, Y, tolerance
self.is_analytic = six.get_unbound_function(likelihood.predict_density) is not\
six.get_unbound_function(GPflow.likelihoods.Likelihood.predict_density)
import threading
import six
from dependency_injector.errors import Error
GLOBAL_LOCK = threading.RLock()
"""Dependency injector global reentrant lock.
:type: :py:class:`threading.RLock`
"""
_IS_PYPY = '__pypy__' in sys.builtin_module_names
if _IS_PYPY or six.PY3: # pragma: no cover
_OBJECT_INIT = six.get_unbound_function(object.__init__)
else: # pragma: no cover
_OBJECT_INIT = None
if six.PY2: # pragma: no cover
copy._deepcopy_dispatch[types.MethodType] = \
lambda obj, memo: type(obj)(obj.im_func,
copy.deepcopy(obj.im_self, memo),
obj.im_class)
def is_provider(instance):
"""Check if instance is provider instance.
:param instance: Instance to be checked.
:type instance: object
def test_get_unbound_function():
class X(object):
def m(self):
pass
assert six.get_unbound_function(X.m) is X.__dict__["m"]
