def dec(func):
params, varargs, varkw, defaults = inspect.getargspec(func)
params = params[1:]
tag_name = name or func.__name__
class InlineCompileNode(library.TagHelperNode):
def __init__(self, nodelist, *args):
super(InlineCompileNode, self).__init__(*args)
self.nodelist = nodelist
def render(self, context):
args, kwargs = self.get_resolved_arguments(context)
return func(self.nodelist, *args, **kwargs)
def compile_func(parser, token):
takes_context = True
bits = token.split_contents()[1:]
args, kwargs = library.parse_bits(parser, bits, params, varargs,
varkw, defaults, takes_context,
tag_name)
nodelist = parser.parse(('end' + tag_name, ))
parser.delete_first_token()
try:
# Django<1.9
return InlineCompileNode(nodelist, takes_context, args, kwargs)
except TypeError:
# Django>=1.9
return InlineCompileNode(nodelist, func, takes_context, args,
kwargs)
register.tag(tag_name, compile_func)
return func
def dec(func):
params, varargs, varkw, defaults = getargspec(func)
function_name = (name or getattr(func, '_decorated_function',
func).__name__)
@functools.wraps(func)
def compile_func(parser, token):
bits = token.split_contents()[1:]
args, kwargs = parse_bits(
parser,
bits,
params,
varargs,
varkw,
defaults,
takes_context,
function_name,
)
return InclusionNode(
func,
takes_context,
args,
kwargs,
filename,
)
self.tag(function_name, compile_func)
return func
def dec(func):
params, varargs, varkw, defaults = inspect.getargspec(func)
params = params[1:]
tag_name = name or func.__name__
class InlineCompileNode(library.TagHelperNode):
def __init__(self, nodelist, *args):
super(InlineCompileNode, self).__init__(*args)
self.nodelist = nodelist
def render(self, context):
args, kwargs = self.get_resolved_arguments(context)
return func(self.nodelist, *args, **kwargs)
def compile_func(parser, token):
takes_context = True
bits = token.split_contents()[1:]
args, kwargs = library.parse_bits(parser, bits, params, varargs, varkw,
defaults, takes_context, tag_name)
nodelist = parser.parse(('end' + tag_name,))
parser.delete_first_token()
try:
# Django<1.9
return InlineCompileNode(nodelist, takes_context, args, kwargs)
except TypeError:
# Django>=1.9
return InlineCompileNode(nodelist, func, takes_context, args, kwargs)
register.tag(tag_name, compile_func)
return func
def __init__(self, *args, **kwargs):
supercls = super(MultiSelectFormField, self)
# remove TypedChoiceField extra args
supercls_init_args = getargspec(supercls.__init__)[0]
if supercls_init_args[0:0] == ['self']:
del supercls_init_args[0]
supercls.__init__(
*args,
**{key: val for (key, val) in kwargs.items()
if key in supercls_init_args}
)
def __delete__(self, obj):
if obj is None:
return
try:
value = obj.__dict__.pop(self.__name__)
except KeyError:
pass
else:
if self.fdel is not None:
fdel_args = [obj]
if len(getargspec(self.fdel)[0]) == 2:
fdel_args.append(value)
self.fdel(*fdel_args)
def get_args_kwargs(parser, token):
""" copied from
django.template.(base|library).Library.simple_tag.compile_func """
def to_limit(limit_name, **limit_kwargs):
pass
params, varargs, varkw, defaults = getargspec(to_limit)
function_name = 'djptlimit'
bits = token.split_contents()[1:]
takes_context = False
args, kwargs = parse_bits(parser, bits, params, varargs, varkw, defaults,
takes_context, function_name)
return args, kwargs
def args_check(name, func, provided):
provided = list(provided)
# First argument, filter input, is implied.
plen = len(provided) + 1
# Check to see if a decorator is providing the real function.
func = getattr(func, "_decorated_function", func)
args, _, _, defaults = getargspec(func)
alen = len(args)
dlen = len(defaults or [])
# Not enough OR Too many
if plen < (alen - dlen) or plen > alen:
raise TemplateSyntaxError("%s requires %d arguments, %d provided" % (name, alen - dlen, plen))
return True
def dec(func):
params, varargs, varkw, defaults = getargspec(func)
function_name = (name or getattr(func, '_decorated_function', func).__name__)
@functools.wraps(func)
def compile_func(parser, token):
bits = token.split_contents()[1:]
target_var = None
if len(bits) >= 2 and bits[-2] == 'as':
target_var = bits[-1]
bits = bits[:-2]
args, kwargs = parse_bits(parser, bits, params,
varargs, varkw, defaults, takes_context, function_name)
return SimpleNode(func, takes_context, args, kwargs, target_var)
self.tag(function_name, compile_func)
return func
def dec(func):
params, varargs, varkw, defaults = getargspec(func)
function_name = (name or getattr(func, '_decorated_function', func).__name__)
@functools.wraps(func)
def compile_func(parser, token):
bits = token.split_contents()[1:]
target_var = None
if len(bits) >= 2 and bits[-2] == 'as':
target_var = bits[-1]
bits = bits[:-2]
args, kwargs = parse_bits(parser, bits, params,
varargs, varkw, defaults, takes_context, function_name)
return SimpleNode(func, takes_context, args, kwargs, target_var)
self.tag(function_name, compile_func)
return func
def args_check(name, func, provided):
provided = list(provided)
# First argument, filter input, is implied.
plen = len(provided) + 1
# Check to see if a decorator is providing the real function.
func = getattr(func, '_decorated_function', func)
args, _, _, defaults = getargspec(func)
alen = len(args)
dlen = len(defaults or [])
# Not enough OR Too many
if plen < (alen - dlen) or plen > alen:
raise TemplateSyntaxError("%s requires %d arguments, %d provided" %
(name, alen - dlen, plen))
return True
def dec(func):
params, varargs, varkw, defaults = getargspec(func)
function_name = (name or getattr(func, '_decorated_function', func).__name__)
@functools.wraps(func)
def compile_func(parser, token):
bits = token.split_contents()[1:]
args, kwargs = parse_bits(
parser, bits, params, varargs, varkw, defaults,
takes_context, function_name,
)
return InclusionNode(
func, takes_context, args, kwargs, filename,
)
self.tag(function_name, compile_func)
return func
def __init__(self, func):
# Store the reference to the registered function
self.function = func
# @rpc_method decorator parameters
self._external_name = getattr(func, 'modernrpc_name', func.__name__)
self.entry_point = getattr(func, 'modernrpc_entry_point')
self.protocol = getattr(func, 'modernrpc_protocol')
self.str_standardization = getattr(func, 'str_standardization')
self.str_std_encoding = getattr(func, 'str_standardization_encoding')
# Authentication related attributes
self.predicates = getattr(func, 'modernrpc_auth_predicates', None)
self.predicates_params = getattr(func,
'modernrpc_auth_predicates_params',
())
# List method's positional arguments
# We can't use django.utils.inspect.get_func_args() with Python 2, because this function remove the first
# argument in returned list. This is supposed to remove the first 'self' argument, but doesn't fork well
# for global functions.
# For Python 2, we will prefer django.utils.inspect.getargspec(func)[0]. This will work as expected, even if
# the function has been removed in Django 2.0, since Django 2 doesn't work with Python 2
self.args = inspect.get_func_args(
func) if six.PY3 else inspect.getargspec(func)[0]
# Does the method accept additional kwargs dict?
self.accept_kwargs = inspect.func_accepts_kwargs(func)
# Contains the signature of the method, as returned by "system.methodSignature"
self.signature = []
# Contains the method's docstring, in HTML form
self.html_doc = ''
# Contains doc about arguments and their type. We store this in an ordered dict, so the args documentation
# keep the order defined in docstring
self.args_doc = collections.OrderedDict()
# Contains doc about return type and return value
self.return_doc = {}
# Docstring parsing
self.raw_docstring = self.parse_docstring(func.__doc__)
self.html_doc = self.raw_docstring_to_html(self.raw_docstring)
def delay_with_task_kwargs(cls, _task_kwargs, *args, **kwargs):
"""
:rtype robust.models.Task
"""
name = '{}.{}'.format(cls.__module__, cls.__name__)
if args:
fn_args, _, _, _ = getargspec(cls.fn)
if cls.bind:
fn_args = fn_args[1:]
if len(args) > len(fn_args):
raise TypeError('wrong args number passed for {}'.format(name))
positional = fn_args[:len(args)]
for key in positional:
if key in kwargs:
raise TypeError(
'{} used as positional argument for {}'.format(
key, name))
kwargs = dict(kwargs)
for key, value in zip(fn_args, args):
kwargs[key] = value
wrapped_kwargs = wrap_payload(kwargs)
if getattr(settings, 'ROBUST_ALWAYS_EAGER', False):
json.dumps(wrapped_kwargs) # checks kwargs is JSON serializable
kwargs = unwrap_payload(wrapped_kwargs)
if cls.bind:
return cls.fn(cls, **kwargs)
return cls.fn(**kwargs)
from .models import Task
_kwargs = {'tags': cls.tags, 'retries': cls.retries}
_kwargs.update(_task_kwargs)
return Task.objects.create(name=name,
payload=wrapped_kwargs,
**_kwargs)
def delay_with_task_kwargs(cls, _task_kwargs, *args, **kwargs):
"""
:rtype robust.models.Task
"""
name = '{}.{}'.format(cls.__module__, cls.__name__)
if args:
fn_args, _, _, _ = getargspec(cls.fn)
if cls.bind:
fn_args = fn_args[1:]
if len(args) > len(fn_args):
raise TypeError('wrong args number passed for {}'.format(name))
positional = fn_args[:len(args)]
for key in positional:
if key in kwargs:
raise TypeError('{} used as positional argument for {}'.format(key, name))
kwargs = dict(kwargs)
for key, value in zip(fn_args, args):
kwargs[key] = value
wrapped_kwargs = wrap_payload(kwargs)
if getattr(settings, 'ROBUST_ALWAYS_EAGER', False):
json.dumps(wrapped_kwargs) # checks kwargs is JSON serializable
kwargs = unwrap_payload(wrapped_kwargs)
if cls.bind:
return cls.fn(cls, **kwargs)
return cls.fn(**kwargs)
from .models import Task
_kwargs = {
'tags': cls.tags,
'retries': cls.retries
}
_kwargs.update(_task_kwargs)
return Task.objects.create(name=name, payload=wrapped_kwargs, **_kwargs)
def serialize(self):
imports = set()
name, args, kwargs = self.operation.deconstruct()
argspec = inspect.getargspec(self.operation.__init__)
normalized_kwargs = inspect.getcallargs(self.operation.__init__, *args, **kwargs)
self.feed('migrations.%s(' % name)
self.indent()
for arg_name in argspec.args[1:]:
arg_value = normalized_kwargs[arg_name]
if (arg_name in self.operation.serialization_expand_args and
isinstance(arg_value, (list, tuple, dict))):
if isinstance(arg_value, dict):
self.feed('%s={' % arg_name)
self.indent()
for key, value in arg_value.items():
arg_string, arg_imports = MigrationWriter.serialize(value)
self.feed('%s: %s,' % (repr(key), arg_string))
imports.update(arg_imports)
self.unindent()
self.feed('},')
else:
self.feed('%s=[' % arg_name)
self.indent()
for item in arg_value:
arg_string, arg_imports = MigrationWriter.serialize(item)
self.feed('%s,' % arg_string)
imports.update(arg_imports)
self.unindent()
self.feed('],')
else:
arg_string, arg_imports = MigrationWriter.serialize(arg_value)
self.feed('%s=%s,' % (arg_name, arg_string))
imports.update(arg_imports)
self.unindent()
self.feed('),')
return self.render(), imports
import functools
def filter_function(self, func, **flags):
name = getattr(func, "_decorated_function", func).__name__
return self.filter(name, func, **flags)
def simple_tag(self, func=None, takes_context=None, name=None):
"""
Register a callable as a compiled template tag. Example:
@register.simple_tag
def hello(*args, **kwargs):
return 'world'
"""
def dec(func):
<<<<<<< HEAD
params, varargs, varkw, defaults = getargspec(func)
=======
params, varargs, varkw, defaults, kwonly, kwonly_defaults, _ = getfullargspec(func)
>>>>>>> 37c99181c9a6b95433d60f8c8ef9af5731096435
function_name = (name or getattr(func, '_decorated_function', func).__name__)
@functools.wraps(func)
def compile_func(parser, token):
bits = token.split_contents()[1:]
target_var = None
if len(bits) >= 2 and bits[-2] == 'as':
target_var = bits[-1]
bits = bits[:-2]
args, kwargs = parse_bits(
parser, bits, params, varargs, varkw, defaults,
<<<<<<< HEAD
"""
def connect(self, receiver, sender=None, weak=True, dispatch_uid=None):
"""
Connect receiver to sender for signal.
Arguments:
receiver
A function or an instance method which is to receive signals.
Receivers must be hashable objects.
If weak is True, then receiver must be weak-referencable.
Receivers must be able to accept keyword arguments.
If receivers have a dispatch_uid attribute, the receiver will
not be added if another receiver already exists with that
dispatch_uid.
sender
The sender to which the receiver should respond. Must either be
of type Signal, or None to receive events from any sender.
weak
Whether to use weak references to the receiver. By default, the
module will attempt to use weak references to the receiver
objects. If this parameter is false, then strong references will
be used.
dispatch_uid
An identifier used to uniquely identify a particular instance of
a receiver. This will usually be a string, though it may be
anything hashable.
"""
from django.conf import settings
# If DEBUG is on, check that we got a good receiver
if settings.configured and settings.DEBUG:
from django.utils import inspect
assert callable(receiver), "Signal receivers must be callable."
# Check for **kwargs
# Not all callables are inspectable with getargspec, so we'll
# try a couple different ways but in the end fall back on assuming
# it is -- we don't want to prevent registration of valid but weird
# callables.
try:
argspec = inspect.getargspec(receiver)
except TypeError:
try:
argspec = inspect.getargspec(receiver.__call__)
except (TypeError, AttributeError, ValueError):
argspec = None
if argspec:
assert argspec[2] is not None, \
"Signal receivers must accept keyword arguments (**kwargs)."
if dispatch_uid:
lookup_key = (dispatch_uid, _make_id(sender))
else:
lookup_key = (_make_id(receiver), _make_id(sender))
if weak:
ref = weakref.ref
receiver_object = receiver
# Check for bound methods
if hasattr(receiver, '__self__') and hasattr(receiver, '__func__'):
ref = WeakMethod
receiver_object = receiver.__self__
if sys.version_info >= (3, 4):
receiver = ref(receiver)
weakref.finalize(receiver_object, self._remove_receiver)
else:
receiver = ref(receiver, self._remove_receiver)
with self.lock:
self._clear_dead_receivers()
for r_key, _ in self.receivers:
if r_key == lookup_key:
break
else:
self.receivers.append((lookup_key, receiver))
self.sender_receivers_cache.clear()
