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 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 __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()