def default_quota(cls, user, provider):
     """
     Load each Default Quota Plugin and call `plugin.get_default_quota(user, provider)`
     """
     _default_quota = None
     for DefaultQuotaPlugin in cls.load_plugins(cls.list_of_classes):
         plugin = DefaultQuotaPlugin()
         try:
             inspect.getcallargs(
                 getattr(plugin, 'get_default_quota'),
                 user=user,
                 provider=provider
             )
         except AttributeError:
             logger.info(
                 "Validation plugin %s missing method 'get_default_quota'" %
                 DefaultQuotaPlugin
             )
         except TypeError:
             logger.info(
                 "Validation plugin %s does not accept kwargs `user` & `provider`"
                 % DefaultQuotaPlugin
             )
         _default_quota = plugin.get_default_quota(
             user=user, provider=provider
         )
         if _default_quota:
             return _default_quota
     return _default_quota
    def is_expired(cls, user):
        """
        Load each ExpirationPlugin and call `plugin.is_expired(user)`
        """
        _is_expired = False
        for ExpirationPlugin in cls.load_plugins(cls.list_of_classes):
            plugin = ExpirationPlugin()
            try:
                inspect.getcallargs(getattr(plugin, 'is_expired'), user=user)
            except AttributeError:
                logger.info(
                    "Expiration plugin %s does not have a 'is_expired' method" %
                    ExpirationPlugin
                )
            except TypeError:
                logger.info(
                    "Expiration plugin %s does not accept kwarg `user`" %
                    ExpirationPlugin
                )
            try:
                # TODO: Set a reasonable timeout but don't let it hold this indefinitely
                _is_expired = plugin.is_expired(user=user)
            except Exception as exc:
                logger.info(
                    "Expiration plugin %s encountered an error: %s" %
                    (ExpirationPlugin, exc)
                )
                _is_expired = True

            if _is_expired:
                return True
        return _is_expired
Example #3
0
    def run(self, image, output):
        with image.get_willow_image() as willow:
            original_format = willow.format_name

            # Fix orientation of image
            willow = willow.auto_orient()

            env = {
                'original-format': original_format,
            }
            for operation in self.operations:
                # Check that the operation can take the "env" argument
                try:
                    inspect.getcallargs(operation.run, willow, image, env)
                    accepts_env = True
                except TypeError:
                    # Check that the paramters fit the old style, so we don't
                    # raise a warning if there is a coding error
                    inspect.getcallargs(operation.run, willow, image)
                    accepts_env = False
                    warnings.warn("ImageOperation run methods should take 4 "
                                  "arguments. %d.run only takes 3.",
                                  RemovedInWagtail19Warning)

                # Call operation
                if accepts_env:
                    willow = operation.run(willow, image, env) or willow
                else:
                    willow = operation.run(willow, image) or willow

            # Find the output format to use
            if 'output-format' in env:
                # Developer specified an output format
                output_format = env['output-format']
            else:
                # Default to outputting in original format
                output_format = original_format

                # Convert BMP files to PNG
                if original_format == 'bmp':
                    output_format = 'png'

                # Convert unanimated GIFs to PNG as well
                if original_format == 'gif' and not willow.has_animation():
                    output_format = 'png'

            if output_format == 'jpeg':
                # Allow changing of JPEG compression quality
                if 'jpeg-quality' in env:
                    quality = env['jpeg-quality']
                elif hasattr(settings, 'WAGTAILIMAGES_JPEG_QUALITY'):
                    quality = settings.WAGTAILIMAGES_JPEG_QUALITY
                else:
                    quality = 85

                return willow.save_as_jpeg(output, quality=quality, progressive=True, optimize=True)
            elif output_format == 'png':
                return willow.save_as_png(output)
            elif output_format == 'gif':
                return willow.save_as_gif(output)
Example #4
0
File: node.py Project: MAHIS/PyNDN2
    def onReceivedElement(self, element):
        """
        This is called by the transport's ElementReader to process an
        entire received Data or Interest element.

        :param element: The bytes of the incoming element.
        :type element: An array type with int elements
        """
        # First, decode as Interest or Data.
        interest = None
        data = None
        decoder = TlvDecoder(element)
        if decoder.peekType(Tlv.Interest, len(element)):
            interest = Interest()
            interest.wireDecode(element, TlvWireFormat.get())
        elif decoder.peekType(Tlv.Data, len(element)):
            data = Data()
            data.wireDecode(element, TlvWireFormat.get())

        # Now process as Interest or Data.
        if interest != None:
            # Call all interest filter callbacks which match.
            for i in range(len(self._interestFilterTable)):
                entry = self._interestFilterTable[i]
                if entry.getFilter().doesMatch(interest.getName()):
                    includeFilter = True
                    # Use getcallargs to test if onInterest accepts 5 args.
                    try:
                        inspect.getcallargs(entry.getOnInterest(),
                          None, None, None, None, None)
                    except TypeError:
                        # Assume onInterest is old-style with 4 arguments.
                        includeFilter = False

                    if includeFilter:
                        try:
                            entry.getOnInterest()(
                              entry.getFilter().getPrefix(), interest,
                              entry.getFace(), entry.getInterestFilterId(),
                              entry.getFilter())
                        except:
                            logging.exception("Error in onInterest")
                    else:
                        # Old-style onInterest without the filter argument. We
                        # still pass a Face instead of Transport since Face also
                        # has a send method.
                        try:
                            entry.getOnInterest()(
                              entry.getFilter().getPrefix(), interest,
                              entry.getFace(), entry.getInterestFilterId())
                        except:
                            logging.exception("Error in onInterest")
        elif data != None:
            pendingInterests = self._extractEntriesForExpressedInterest(
              data.getName())
            for pendingInterest in pendingInterests:
                try:
                    pendingInterest.getOnData()(pendingInterest.getInterest(), data)
                except:
                    logging.exception("Error in onData")
 def _wrap_callback(self, fn):
     if fn is None:
         return None
     elif not callable(fn):
         raise InputDeviceError('value must be None or a callable')
     elif inspect.isbuiltin(fn):
         # We can't introspect the prototype of builtins. In this case we
         # assume that the builtin has no (mandatory) parameters; this is
         # the most reasonable assumption on the basis that pre-existing
         # builtins have no knowledge of gpiozero, and the sole parameter
         # we would pass is a gpiozero object
         return fn
     else:
         # Try binding ourselves to the argspec of the provided callable.
         # If this works, assume the function is capable of accepting no
         # parameters
         try:
             inspect.getcallargs(fn)
             return fn
         except TypeError:
             try:
                 # If the above fails, try binding with a single parameter
                 # (ourselves). If this works, wrap the specified callback
                 inspect.getcallargs(fn, self)
                 @wraps(fn)
                 def wrapper():
                     return fn(self)
                 return wrapper
             except TypeError:
                 raise InputDeviceError(
                     'value must be a callable which accepts up to one '
                     'mandatory parameter')
Example #6
0
def authenticate(djsqla_sessions, **credentials):
    """
    If the given credentials are valid, return a User object.
    """
    for backend, backend_path in _get_backends(return_tuples=True):
        # assert False, backend
        try:
            inspect.getcallargs(backend.authenticate, **credentials)
        except TypeError:
            # This backend doesn't accept these credentials as arguments. Try the next one.
            continue

        if isinstance(backend, SQLAlchemyUserBackend):
            backend_db = backend.get_db_name()
            if hasattr(djsqla_sessions, backend_db):
                session = getattr(djsqla_sessions, backend_db)
                setattr(backend, "djsqla_session", session)

        try:
            user = backend.authenticate(**credentials)
        except PermissionDenied:
            # This backend says to stop in our tracks - this user should not be allowed in at all.
            return None
        if user is None:
            continue
        # Annotate the user object with the path of the backend.
        user.backend = backend_path
        return user

    # The credentials supplied are invalid to all backends, fire signal
    user_login_failed.send(sender=__name__, credentials=_clean_credentials(credentials))
Example #7
0
 def _wrap_callback(self, fn):
     if fn is None:
         return None
     elif not callable(fn):
         raise InputDeviceError('value must be None or a callable')
     else:
         # Try binding ourselves to the argspec of the provided callable.
         # If this works, assume the function is capable of accepting no
         # parameters
         try:
             inspect.getcallargs(fn)
             return fn
         except TypeError:
             try:
                 # If the above fails, try binding with a single parameter
                 # (ourselves). If this works, wrap the specified callback
                 inspect.getcallargs(fn, self)
                 @wraps(fn)
                 def wrapper():
                     return fn(self)
                 return wrapper
             except TypeError:
                 raise InputDeviceError(
                     'value must be a callable which accepts up to one '
                     'mandatory parameter')
Example #8
0
def authenticate(request=None, **credentials):
    """
    If the given credentials are valid, return a User object.
    """
    for backend, backend_path in _get_backends(return_tuples=True):
        args = (request,)
        try:
            inspect.getcallargs(backend.authenticate, request, **credentials)
        except TypeError:
            try:
                inspect.getcallargs(backend.authenticate, **credentials)
            except TypeError:
                # This backend doesn't accept these credentials as arguments. Try the next one.
                continue
            else:
                args = ()
                warnings.warn(
                    "Update authentication backend %s to accept a "
                    "positional `request` argument." % backend_path,
                    RemovedInDjango21Warning
                )
        try:
            user = backend.authenticate(*args, **credentials)
        except PermissionDenied:
            # This backend says to stop in our tracks - this user should not be allowed in at all.
            break
        if user is None:
            continue
        # Annotate the user object with the path of the backend.
        user.backend = backend_path
        return user

    # The credentials supplied are invalid to all backends, fire signal
    user_login_failed.send(sender=__name__, credentials=_clean_credentials(credentials), request=request)
Example #9
0
 def new_f(*args, **kwargs):
     try:
         inspect.getcallargs(f, *args, **kwargs)
     except TypeError as t:
         raise JSONRPCInvalidParamsError(t)
     else:
         return f(*args, **kwargs)
Example #10
0
def _valid_formatter(f):
    """Return whether an object is a valid formatter
    
    Cases checked:
    
    - bound methods             OK
    - unbound methods           NO
    - callable with zero args   OK
    """
    if f is None:
        return False
    elif isinstance(f, type(str.find)):
        # unbound methods on compiled classes have type method_descriptor
        return False
    elif isinstance(f, types.BuiltinFunctionType):
        # bound methods on compiled classes have type builtin_function
        return True
    elif callable(f):
        # anything that works with zero args should be okay
        try:
            inspect.getcallargs(f)
        except Exception:
            return False
        else:
            return True
    return False
Example #11
0
    def __init__(self, func, pattern, argument_mappings=None, return_mapping=None, doc=None):
        if not callable(func):
            raise RuntimeError('Can not construct a Func-object from a non callable object.')

        self.func = func

        if isinstance(pattern, string_types):
            pattern = regex(pattern)

        self.matcher = pattern

        if argument_mappings is None:
            argument_mappings = self.matcher.argument_mappings or None

        try:
            inspect.getcallargs(func, *[None] * self.matcher.arg_count)
        except TypeError:
            raise RuntimeError(
                'The number of arguments for function \'{}\' matched by pattern '
                '\'{}\' is not compatible with number of defined '
                'groups in pattern ({}).'.format(
                    getattr(func, '__name__', repr(func)), self.matcher.pattern,
                    self.matcher.arg_count
                ))

        if argument_mappings is not None and (self.matcher.arg_count != len(argument_mappings)):
            raise RuntimeError(
                'Supplied argument mappings for function matched by pattern \'{}\' specify {} '
                'argument(s), but the function has {} arguments.'.format(
                    self.matcher, len(argument_mappings), self.matcher.arg_count))

        self.argument_mappings = argument_mappings
        self.return_mapping = return_mapping
        self.doc = doc or (inspect.getdoc(self.func) if callable(self.func) else None)
Example #12
0
def authenticate(**credentials):
    """
    If the given credentials are valid, return a User object.
    """
    for backend, backend_path in _get_backends(return_tuples=True):
        try:
            inspect.getcallargs(backend.authenticate, **credentials)
        except TypeError:
            # This backend doesn't accept these credentials as arguments. Try the next one.
            continue

        try:
            user = backend.authenticate(**credentials)
        except PermissionDenied:
            # This backend says to stop in our tracks - this user should not be allowed in at all.
            return None
        if user is None:
            continue
        # Annotate the user object with the path of the backend.
        user.backend = backend_path
        return user

    # The credentials supplied are invalid to all backends, fire signal
    user_login_failed.send(sender=__name__,
            credentials=_clean_credentials(credentials))
Example #13
0
    def _wrap_callback(self, fn):
        # Shamelessley nicked (with some variation) from GPIO Zero :)
        @wraps(fn)
        def wrapper(event):
            return fn()

        if fn is None:
            return None
        elif not callable(fn):
            raise ValueError('value must be None or a callable')
        elif inspect.isbuiltin(fn):
            # We can't introspect the prototype of builtins. In this case we
            # assume that the builtin has no (mandatory) parameters; this is
            # the most reasonable assumption on the basis that pre-existing
            # builtins have no knowledge of InputEvent, and the sole parameter
            # we would pass is an InputEvent
            return wrapper
        else:
            # Try binding ourselves to the argspec of the provided callable.
            # If this works, assume the function is capable of accepting no
            # parameters and that we have to wrap it to ignore the event
            # parameter
            try:
                inspect.getcallargs(fn)
                return wrapper
            except TypeError:
                try:
                    # If the above fails, try binding with a single tuple
                    # parameter. If this works, return the callback as is
                    inspect.getcallargs(fn, ())
                    return fn
                except TypeError:
                    raise ValueError(
                        'value must be a callable which accepts up to one '
                        'mandatory parameter')
Example #14
0
    def ensure_user_allocation_sources(cls, user, provider=None):
        """Load each Allocation Source Plugin and call `plugin.ensure_user_allocation_source(user)`

        Depending on the plugin this may create allocation sources if they don't already exist.
        :param user: The user to check
        :type user: core.models.AtmosphereUser
        :param provider: The provider (optional, not used by all plugins)
        :type provider: core.models.Provider
        :return: Whether the user has valid allocation sources
        :rtype: bool
        """
        _has_valid_allocation_sources = False
        for AllocationSourcePlugin in cls.load_plugins(cls.list_of_classes):
            plugin = AllocationSourcePlugin()
            try:
                inspect.getcallargs(
                    getattr(plugin, 'ensure_user_allocation_source'),
                    user=user, provider=provider)
            except AttributeError:
                logger.info(
                    "Allocation Source plugin %s missing method 'ensure_user_allocation_source'",
                    AllocationSourcePlugin)
            except TypeError:
                logger.info(
                    "Allocation Source plugin %s does not accept kwargs `user` & `provider`",
                    AllocationSourcePlugin)
            _has_valid_allocation_sources = plugin.ensure_user_allocation_source(user=user, provider=provider)
            if _has_valid_allocation_sources:
                return _has_valid_allocation_sources
        return _has_valid_allocation_sources
Example #15
0
    def verifyData(self, data, onVerified, onValidationFailed, stepCount = 0):
        """
        Check the signature on the Data object and call either onVerify or
        onValidationFailed. We use callback functions because verify may fetch
        information to check the signature.

        :param Data data: The Data object with the signature to check.
        :param onVerified: If the signature is verified, this calls
          onVerified(data).
          NOTE: The library will log any exceptions raised by this callback, but
          for better error handling the callback should catch and properly
          handle any exceptions.
        :type onVerified: function object
        :param onValidationFailed: If the signature check fails or can't find
          the public key, this calls onValidationFailed(data, reason) with the
          Data object and reason string. This also supports the deprecated
          callback onValidationFailed(data) but you should use the callback with
          the reason string.
          NOTE: The library will log any exceptions raised by this callback, but
          for better error handling the callback should catch and properly
          handle any exceptions.
        :type onValidationFailed: function object
        :param int stepCount: (optional) The number of verification steps that
          have been done. If omitted, use 0.
        """
        # If onValidationFailed is not a function nor a method assumes it is a
        # calleable object
        if (not inspect.isfunction(onValidationFailed) and
            not inspect.ismethod(onValidationFailed)):
            onValidationFailed = onValidationFailed.__call__
        # Use getcallargs to test if onValidationFailed accepts 2 args.
        try:
            inspect.getcallargs(onValidationFailed, None, None)
        except TypeError:
            # Assume onValidationFailed is old-style with 1 argument. Wrap it
            # with a function that takes and ignores the reason string.
            oldValidationFailed = onValidationFailed
            onValidationFailed = lambda d, reason: oldValidationFailed(d)

        if self._policyManager.requireVerify(data):
            nextStep = self._policyManager.checkVerificationPolicy(
              data, stepCount, onVerified, onValidationFailed)
            if nextStep != None:
                self._face.expressInterest(
                  nextStep.interest, self._makeOnCertificateData(nextStep),
                  self._makeOnCertificateInterestTimeout(
                    nextStep.retry, onValidationFailed, data, nextStep))
        elif self._policyManager.skipVerifyAndTrust(data):
            try:
                onVerified(data)
            except:
                logging.exception("Error in onVerified")
        else:
            try:
                onValidationFailed(
                  data,
                  "The packet has no verify rule but skipVerifyAndTrust is false")
            except:
                logging.exception("Error in onValidationFailed")
Example #16
0
 def check_signature(self, args, kwargs):
     service_cls = self.container.service_cls
     fn = getattr(service_cls, self.method_name)
     try:
         service_instance = None  # fn is unbound
         inspect.getcallargs(fn, service_instance, *args, **kwargs)
     except TypeError as exc:
         raise IncorrectSignature(str(exc))
Example #17
0
def mangle(fname, f, args, kwargs):
    # We uniquely identify functions by their list of arguments
    # as resolved by the function definition.
    print(fname, f, args, kwargs)
    print(getcallargs)
    print(json.dumps(sorted(getcallargs(f, *args, **kwargs).items(), key=lambda x: x[0])))

    return "@" + fname + "_" + json.dumps(getcallargs(f, *args, **kwargs))
Example #18
0
def _check_callable(cls, method, *args, **kwargs):
    if hasattr(inspect, 'getcallargs'):
        # for Python 2.7 or later.
        inspect.getcallargs(getattr(cls, method), cls, *args, **kwargs)
    else:
        # for Python 2.6 or earlier.
        if not hasattr(cls, method):
            raise AttributeError, 'This class has not attr: ' + method
Example #19
0
    def _resolve_lookup(self, context):
        """
        Performs resolution of a real variable (i.e. not a literal) against the
        given context.

        As indicated by the method's name, this method is an implementation
        detail and shouldn't be called by external code. Use Variable.resolve()
        instead.
        """
        current = context
        try:  # catch-all for silent variable failures
            for bit in self.lookups:
                try:  # dictionary lookup
                    current = current[bit]
                    # ValueError/IndexError are for numpy.array lookup on
                    # numpy < 1.9 and 1.9+ respectively
                except (TypeError, AttributeError, KeyError, ValueError, IndexError):
                    try:  # attribute lookup
                        # Don't return class attributes if the class is the context:
                        if isinstance(current, BaseContext) and getattr(type(current), bit):
                            raise AttributeError
                        current = getattr(current, bit)
                    except (TypeError, AttributeError) as e:
                        # Reraise an AttributeError raised by a @property
                        if (isinstance(e, AttributeError) and
                                not isinstance(current, BaseContext) and bit in dir(current)):
                            raise
                        try:  # list-index lookup
                            current = current[int(bit)]
                        except (IndexError,  # list index out of range
                                ValueError,  # invalid literal for int()
                                KeyError,    # current is a dict without `int(bit)` key
                                TypeError):  # unsubscriptable object
                            raise VariableDoesNotExist("Failed lookup for key "
                                                       "[%s] in %r",
                                                       (bit, current))  # missing attribute
                if callable(current):
                    if getattr(current, 'do_not_call_in_templates', False):
                        pass
                    elif getattr(current, 'alters_data', False):
                        current = context.engine.string_if_invalid
                    else:
                        try:  # method call (assuming no args required)
                            current = current()
                        except TypeError:
                            try:
                                getcallargs(current)
                            except TypeError:  # arguments *were* required
                                current = context.engine.string_if_invalid  # invalid method call
                            else:
                                raise
        except Exception as e:
            if getattr(e, 'silent_variable_failure', False):
                current = context.engine.string_if_invalid
            else:
                raise

        return current
Example #20
0
    def __init__(self, __interact_f, __options={}, **kwargs):
        VBox.__init__(self, _dom_classes=['widget-interact'])
        self.result = None
        self.args = []
        self.kwargs = {}

        self.f = f = __interact_f
        self.clear_output = kwargs.pop('clear_output', True)
        self.manual = __options.get("manual", False)
        self.manual_name = __options.get("manual_name", "Run Interact")
        self.auto_display = __options.get("auto_display", False)

        new_kwargs = self.find_abbreviations(kwargs)
        # Before we proceed, let's make sure that the user has passed a set of args+kwargs
        # that will lead to a valid call of the function. This protects against unspecified
        # and doubly-specified arguments.
        try:
            check_argspec(f)
        except TypeError:
            # if we can't inspect, we can't validate
            pass
        else:
            getcallargs(f, **{n:v for n,v,_ in new_kwargs})
        # Now build the widgets from the abbreviations.
        self.kwargs_widgets = self.widgets_from_abbreviations(new_kwargs)

        # This has to be done as an assignment, not using self.children.append,
        # so that traitlets notices the update. We skip any objects (such as fixed) that
        # are not DOMWidgets.
        c = [w for w in self.kwargs_widgets if isinstance(w, DOMWidget)]

        # If we are only to run the function on demand, add a button to request this.
        if self.manual:
            self.manual_button = Button(description=self.manual_name)
            c.append(self.manual_button)

        self.out = Output()
        c.append(self.out)
        self.children = c

        # Wire up the widgets
        # If we are doing manual running, the callback is only triggered by the button
        # Otherwise, it is triggered for every trait change received
        # On-demand running also suppresses running the function with the initial parameters
        if self.manual:
            self.manual_button.on_click(self.update)

            # Also register input handlers on text areas, so the user can hit return to
            # invoke execution.
            for w in self.kwargs_widgets:
                if isinstance(w, Text):
                    w.on_submit(self.update)
        else:
            for widget in self.kwargs_widgets:
                widget.observe(self.update, names='value')

            self.on_displayed(self.update)
Example #21
0
            def wrapper(*args, **kwargs):
                provider_instance = args[0]
                if provider_instance.is_first_day_of_month():
                    provider_instance.request_limit_reached = False

                if not provider_instance.request_limit_reached:
                    return func(*args, **kwargs)
                else:
                    getcallargs(func, *args)["logger"].warning("%s API limit was exceeded. Rate won't be requested.", provider_instance.name)
                    return return_value
Example #22
0
 def _caller(self, method, args, kwargs):
     # custom dispatcher called by RPCDispatcher._dispatch()
     # when provided with the address of a custom dispatcher.
     # Used to generate a customized error message when the
     # function signature doesn't match the parameter list.
     try:
         inspect.getcallargs(method, *args, **kwargs)
     except TypeError:
         raise JSONRPCInvalidParamsError()
     else:
         return method(*args, **kwargs)
    def authenticate(self, request, remote_user, shib_meta):
        """
        The username passed as ``remote_user`` is considered trusted.  This
        method simply returns the ``User`` object with the given username,
        creating a new ``User`` object if ``create_unknown_user`` is ``True``.

        Returns None if ``create_unknown_user`` is ``False`` and a ``User``
        object with the given username is not found in the database.
        """
        if not remote_user:
            return
        User = get_user_model()
        username = self.clean_username(remote_user)
        field_names = [x.name for x in User._meta.get_fields()]
        shib_user_params = dict([(k, shib_meta[k]) for k in field_names if k in shib_meta])
        # Note that this could be accomplished in one try-except clause, but
        # instead we use get_or_create when creating unknown users since it has
        # built-in safeguards for multiple threads.
        if self.create_unknown_user:
            user, created = User.objects.get_or_create(username=username, defaults=shib_user_params)
            if created:
                """
                @note: setting password for user needs on initial creation of user instead of after auth.login() of middleware.
                because get_session_auth_hash() returns the salted_hmac value of salt and password.
                If it remains after the auth.login() it will return a different auth_hash
                than what's stored in session "request.session[HASH_SESSION_KEY]".
                Also we don't need to update the user's password everytime he logs in.
                """
                user.set_unusable_password()
                user.save()
                args = (request, user)
                try:
                    inspect.signature(self.configure_user).bind(request, user)
                except AttributeError:
                    # getcallargs required for Python 2.7 support, deprecated after 3.5
                    try:
                        inspect.getcallargs(self.configure_user, request, user)
                    except TypeError:
                        args = (user,)
                except TypeError:
                    args = (user,)
                user = self.configure_user(*args)
        else:
            try:
                user = User.objects.get(username=username)
            except User.DoesNotExist:
                return
        # After receiving a valid user, we update the the user attributes according to the shibboleth
        # parameters. Otherwise the parameters (like mail address, sure_name or last_name) will always
        # be the initial values from the first login. Only save user object if there are any changes.
        if not min([getattr(user, k) == v for k, v in shib_user_params.items()]):
            user.__dict__.update(**shib_user_params)
            user.save()
        return user if self.user_can_authenticate(user) else None
Example #24
0
    def _resolve_lookup(self, context):
        """
        Performs resolution of a real variable (i.e. not a literal) against the
        given context.

        As indicated by the method's name, this method is an implementation
        detail and shouldn't be called by external code. Use Variable.resolve()
        instead.
        """
        current = context
        try:  # catch-all for silent variable failures
            for bit in self.lookups:
                try:  # dictionary lookup
                    current = current[bit]
                except (TypeError, AttributeError, KeyError, ValueError):
                    try:  # attribute lookup
                        # Don't return class attributes if the class is the context:
                        if isinstance(current, BaseContext) and getattr(type(current), bit):
                            raise AttributeError
                        current = getattr(current, bit)
                    except (TypeError, AttributeError):
                        try:  # list-index lookup
                            current = current[int(bit)]
                        except (
                            IndexError,  # list index out of range
                            ValueError,  # invalid literal for int()
                            KeyError,  # current is a dict without `int(bit)` key
                            TypeError,
                        ):  # unsubscriptable object
                            raise VariableDoesNotExist(
                                "Failed lookup for key " "[%s] in %r", (bit, current)
                            )  # missing attribute
                if callable(current):
                    if getattr(current, "do_not_call_in_templates", False):
                        pass
                    elif getattr(current, "alters_data", False):
                        current = settings.TEMPLATE_STRING_IF_INVALID
                    else:
                        try:  # method call (assuming no args required)
                            current = current()
                        except TypeError:
                            try:
                                getcallargs(current)
                            except TypeError:  # arguments *were* required
                                current = settings.TEMPLATE_STRING_IF_INVALID  # invalid method call
                            else:
                                raise
        except Exception as e:
            if getattr(e, "silent_variable_failure", False):
                current = settings.TEMPLATE_STRING_IF_INVALID
            else:
                raise

        return current
Example #25
0
 def caller(*args, **kwargs):
     try:
         for key in kwargs:
             if key in k:
                 raise KeywordRepeatedTypeError(
                     "TypeError: %s() got multiple values " "for keyword argument '%s'" % (f.func_name, key)
                 )
         kwargs.update(k)
         args, kwargs = insert_keyword_first(f, a + args, kwargs)
         getcallargs(f, *args, **kwargs)
     except KeywordRepeatedTypeError, e:
         raise TypeError(e)
Example #26
0
def _verify_arguments(method, method_name, args, kwargs):
    try:
        getcallargs(method, *args, **kwargs)
    except TypeError as e:
        if not _is_python_function(method):
            raise VerifyingBuiltinDoubleArgumentError(str(e))
        raise VerifyingDoubleArgumentError(str(e))
    except IndexError as e:
        if _is_python_33():
            _raise_doubles_error_from_index_error(method_name)
        else:
            raise e
Example #27
0
File: Task.py Project: etabard/puke
    def __call__(self, *args, **kw):
        #try:
        try:
             getcallargs(self.__func, *args)
        except TypeError as e:
           printHelp(self.name)
           console.fail("%s" % e)
           raise
       

        retval = self.__func(*args)
        return retval
Example #28
0
 def arg_checker(func, *args, **kwargs):
     # getcallargs doesn't support partials, hence this workaround
     if isinstance(func, partial):
         args += func.args
         if func.keywords:
             kwargs.update(func.keywords)
         func = func.func
     try:
         getcallargs(func, *args, **kwargs)
     except TypeError:
         return False
     else:
         return True
Example #29
0
 def wrapper(*args, **kwargs):
     config = get_config()
     for i, argname in enumerate(func_args):
         if len(args) > i or argname in kwargs:
             continue
         elif argname in config:
             kwargs[argname] = config[argname]
     try:
         getcallargs(func, *args, **kwargs)
     except TypeError as exc:
         msg = "{}\n{}".format(exc.args[0], PALLADIUM_CONFIG_ERROR)
         exc.args = (msg,)
         raise exc
     return func(*args, **kwargs)
Example #30
0
def interactive(__interact_f, **kwargs):
    """Build a group of widgets to interact with a function."""
    f = __interact_f
    co = kwargs.pop('clear_output', True)
    kwargs_widgets = []
    container = ContainerWidget()
    container.result = None
    container.args = []
    container.kwargs = dict()
    kwargs = kwargs.copy()

    new_kwargs = _find_abbreviations(f, kwargs)
    # Before we proceed, let's make sure that the user has passed a set of args+kwargs
    # that will lead to a valid call of the function. This protects against unspecified
    # and doubly-specified arguments.
    getcallargs(f, **{n:v for n,v in new_kwargs})
    # Now build the widgets from the abbreviations.
    kwargs_widgets.extend(_widgets_from_abbreviations(new_kwargs))
    kwargs_widgets.extend(_widgets_from_abbreviations(sorted(kwargs.items(), key = lambda x: x[0])))

    # This has to be done as an assignment, not using container.children.append,
    # so that traitlets notices the update. We skip any objects (such as fixed) that
    # are not DOMWidgets.
    c = [w for w in kwargs_widgets if isinstance(w, DOMWidget)]
    container.children = c

    # Build the callback
    def call_f(name, old, new):
        container.kwargs = {}
        for widget in kwargs_widgets:
            value = widget.value
            container.kwargs[widget.description] = value
        if co:
            clear_output(wait=True)
        try:
            container.result = f(**container.kwargs)
        except Exception as e:
            ip = get_ipython()
            if ip is None:
                container.log.warn("Exception in interact callback: %s", e, exc_info=True)
            else:
                ip.showtraceback()

    # Wire up the widgets
    for widget in kwargs_widgets:
        widget.on_trait_change(call_f, 'value')

    container.on_displayed(lambda _: call_f(None, None, None))

    return container
Example #31
0
    def print_out(self):
        print(self.multiply())


def get_user_attributes(cls):
    boring = dir(type('dummy', (object, ), {}))
    return [item for item in inspect.getmembers(cls) if item[0] not in boring]


if __name__ == "__main__":
    #    print(inspect.getargspec(A.multiply))
    #    t = A(1)
    print("isFunc ", inspect.isfunction(B))
    print("GetArgSpec ", inspect.getargspec(B))
    print("CallArgs ", inspect.getcallargs(B, 1, 2, 3))
    print("GetArgs ", inspect.getcallargs(B, 1, 2, 3))
    print("GetValues ", inspect.ArgInfo(B, "a", "b", "c"))
    print("GetMembers ", inspect.getmembers(A, inspect.isfunction))
    print(" ", inspect.ArgInfo(B, 1, 2, 3))
    print(inspect.getsourcelines(B))
    print(inspect.getsourcelines(A))
    print(inspect.getsourcelines(array))
#    print(" ", inspect.CO_VARARGS(B))

#    print(inspect.getmembers(A,inspect.isfunction))
#    for ob in inspect.getmembers(A,inspect.isfunction):
#        print(ob[0])
#        print(inspect.getfullargspec(ob[1]))
#    print(inspect.getmembers(array,inspect.isfunction))
#    for ob in inspect.getmembers(array,inspect.isfunction):
Example #32
0
 def method(self, *a, **kw):
     callargs = inspect.getcallargs(getattr(BaseTSDB, key), self, *a, **kw)
     backend = selector_func(key, callargs)[0]
     return getattr(getattr(self, backend), key)(*a, **kw)
 def wrapper(*args, **kwargs):
     func_args = inspect.getcallargs(func, *args, **kwargs)
     if func_args.get('username') != 'admin':
         raise Exception("This user is not allowed to put/get elem")
     return f(*args, **kwargs)
Example #34
0
    def _add_action(self, name, *args, **kwargs):
        """Process action calls in plans.

        :param name: action name
        :type name: str
        :param args: positional arguments of the action call
        :type args: list
        :param kwargs: keyword arguments of the action call
        :type kwargs: dict
        """
        if self.ignore_disabled and not self.env.enabled:
            return

        plan_line = 'unknown filename:unknown lineno'
        # Retrieve the plan line
        try:
            caller_frames = inspect.getouterframes(
                frame=inspect.currentframe())
            caller_frame = None
            for frame in caller_frames:
                if isinstance(frame, tuple):  # py2-only
                    frame_filename = frame[1]
                else:  # py3-only
                    frame_filename = frame.filename
                if frame_filename.endswith(self.plan.plan_ext):
                    caller_frame = frame
        except Exception:  # defensive code
            # do not crash when inspect frames fails
            pass
        else:
            if caller_frame is None:  # defensive code
                # No information ?
                pass
            elif isinstance(caller_frame, tuple):  # py2-only
                plan_line = '{}:{}'.format(caller_frame[1], caller_frame[2])
            else:  # py3-only
                plan_line = '{}:{}'.format(caller_frame.filename,
                                           caller_frame.lineno)

        # First create our initial object based on current scope env
        result = self.env.copy()

        # Process arguments
        call_args = inspect.getcallargs(self.actions[name], *args, **kwargs)

        # Push function arguments into the result object. If an arg value
        # is None then environment is not updated (handling of defaults
        # coming from environment). For the build, host and target arguments
        # a special processing is done to make the corresponding set_env
        # call on the result BaseEnv object
        platform = {'build': None, 'host': None, 'target': None}

        # Likewise board argument is used to change only the machine name
        # of the target. ??? change name ???
        board = None

        for k, v in call_args.iteritems():
            if k in platform:
                platform[k] = v
            elif k == 'board':
                board = v
            elif v is not None or not hasattr(result, k):
                setattr(result, k, v)

        # Handle propagation of environment from the context
        if platform['host'] is None and result.is_canadian:
            platform['host'] = 'host'
        if platform['target'] is None and result.is_cross:
            platform['target'] = 'target'
        if platform['target'] == result.host.platform:
            # ??? This special case is temporary ???
            # the goal is avoid cross from a -> a which are
            # not current supported.
            # Plans should be updated to use target='host'
            # instead of target=env.host.platform
            platform['target'] = 'host'

        result.set_env(**platform)

        # If necessary adjust target machine name
        if board is not None:
            result.set_target(result.target.platform, result.target.os.version,
                              board, result.target.os.mode)

        # Set action attribute (with action name)
        result.action = name
        result.plan_line = plan_line
        result.plan_args = result.to_dict()
        result.plan_call_args = call_args

        # Push the action in the current list
        self.action_list.append(result)
Example #35
0
# -*- coding: utf-8 -*-

import inspect


class Foo:

    pass


def bar(id_, data, commit=True):
    pass


if __name__ == "__main__":
    foo = Foo()
    module = inspect.getmodule(foo)
    print(f"{module.__name__}.{type(foo).__name__}")

    callargs = inspect.getcallargs(bar, 1, {})
    print(f"{callargs}")

    signature = inspect.signature(bar)
    default_args = {
        k: v.default
        for k, v in signature.parameters.items()
        if v.default is not inspect.Parameter.empty
    }
    print(f"{default_args}")
Example #36
0
 def __call__(self, *args, **kwargs):
     callargs = inspect.getcallargs(self._func, *args, **kwargs)
     frame = self._vm.make_frame(
         self.func_code, callargs, self.func_globals, {}
     )
     return self._vm.run_fr(frame)
Example #37
0
def get_call_args(func, args, kwargs, traceback=None):
    try:
        return inspect.getcallargs(unwrapper(func), *args, **kwargs)
    except TypeError as e:
        six.reraise(RQTypeError, RQTypeError(*e.args), traceback)
Example #38
0
def _get_parameter(function, func_args, func_kargs, argname):
    """Get the parameter passed as argname to function."""
    args_binding = inspect.getcallargs(function, *func_args, **func_kargs)
    return args_binding.get(argname) or args_binding.get("kargs").get(argname)
Example #39
0
    def run(self, image, output):
        with image.get_willow_image() as willow:
            original_format = willow.format_name

            # Fix orientation of image
            willow = willow.auto_orient()

            env = {
                'original-format': original_format,
            }
            for operation in self.operations:
                # Check that the operation can take the "env" argument
                try:
                    inspect.getcallargs(operation.run, willow, image, env)
                    accepts_env = True
                except TypeError:
                    # Check that the paramters fit the old style, so we don't
                    # raise a warning if there is a coding error
                    inspect.getcallargs(operation.run, willow, image)
                    accepts_env = False
                    warnings.warn(
                        "ImageOperation run methods should take 4 "
                        "arguments. %d.run only takes 3.",
                        RemovedInWagtail19Warning)

                # Call operation
                if accepts_env:
                    willow = operation.run(willow, image, env) or willow
                else:
                    willow = operation.run(willow, image) or willow

            # Find the output format to use
            if 'output-format' in env:
                # Developer specified an output format
                output_format = env['output-format']
            else:
                # Default to outputting in original format
                output_format = original_format

                # Convert BMP files to PNG
                if original_format == 'bmp':
                    output_format = 'png'

                # Convert unanimated GIFs to PNG as well
                if original_format == 'gif' and not willow.has_animation():
                    output_format = 'png'

            if output_format == 'jpeg':
                # Allow changing of JPEG compression quality
                if 'jpeg-quality' in env:
                    quality = env['jpeg-quality']
                elif hasattr(settings, 'WAGTAILIMAGES_JPEG_QUALITY'):
                    quality = settings.WAGTAILIMAGES_JPEG_QUALITY
                else:
                    quality = 85

                return willow.save_as_jpeg(output,
                                           quality=quality,
                                           progressive=True,
                                           optimize=True)
            elif output_format == 'png':
                return willow.save_as_png(output)
            elif output_format == 'gif':
                return willow.save_as_gif(output)
Example #40
0
        def wrapper(wrapped_self, role_id, *args, **kwargs):
            """Send a notification if the wrapped callable is successful.

            NOTE(stevemar): The reason we go through checking kwargs
            and args for possible target and actor values is because the
            create_grant() (and delete_grant()) method are called
            differently in various tests.
            Using named arguments, i.e.::

                create_grant(user_id=user['id'], domain_id=domain['id'],
                             role_id=role['id'])

            Or, using positional arguments, i.e.::

                create_grant(role_id['id'], user['id'], None,
                             domain_id=domain['id'], None)

            Or, both, i.e.::

                create_grant(role_id['id'], user_id=user['id'],
                             domain_id=domain['id'])

            Checking the values for kwargs is easy enough, since it comes
            in as a dictionary

            The actual method signature is

            ::

                create_grant(role_id, user_id=None, group_id=None,
                             domain_id=None, project_id=None,
                             inherited_to_projects=False)

            So, if the values of actor or target are still None after
            checking kwargs, we can check the positional arguments,
            based on the method signature.
            """
            call_args = inspect.getcallargs(f, wrapped_self, role_id, *args,
                                            **kwargs)
            inherited = call_args['inherited_to_projects']
            initiator = call_args.get('initiator', None)
            target = resource.Resource(typeURI=taxonomy.ACCOUNT_USER)

            audit_kwargs = {}
            if call_args['project_id']:
                audit_kwargs['project'] = call_args['project_id']
            elif call_args['domain_id']:
                audit_kwargs['domain'] = call_args['domain_id']

            if call_args['user_id']:
                audit_kwargs['user'] = call_args['user_id']
            elif call_args['group_id']:
                audit_kwargs['group'] = call_args['group_id']

            audit_kwargs['inherited_to_projects'] = inherited
            audit_kwargs['role'] = role_id

            try:
                result = f(wrapped_self, role_id, *args, **kwargs)
            except Exception:
                _send_audit_notification(self.action, initiator,
                                         taxonomy.OUTCOME_FAILURE, target,
                                         self.event_type, **audit_kwargs)
                raise
            else:
                _send_audit_notification(self.action, initiator,
                                         taxonomy.OUTCOME_SUCCESS, target,
                                         self.event_type, **audit_kwargs)
                return result
        def wrapper(wrapped_self, role_id, *args, **kwargs):
            """Send a notification if the wrapped callable is successful."""

            """ NOTE(stevemar): The reason we go through checking kwargs
            and args for possible target and actor values is because the
            create_grant() (and delete_grant()) method are called
            differently in various tests.
            Using named arguments, i.e.:
                create_grant(user_id=user['id'], domain_id=domain['id'],
                             role_id=role['id'])

            Or, using positional arguments, i.e.:
                create_grant(role_id['id'], user['id'], None,
                             domain_id=domain['id'], None)

            Or, both, i.e.:
                create_grant(role_id['id'], user_id=user['id'],
                             domain_id=domain['id'])

            Checking the values for kwargs is easy enough, since it comes
            in as a dictionary

            The actual method signature is
                create_grant(role_id, user_id=None, group_id=None,
                             domain_id=None, project_id=None,
                             inherited_to_projects=False)

            So, if the values of actor or target are still None after
            checking kwargs, we can check the positional arguments,
            based on the method signature.
            """
            call_args = inspect.getcallargs(
                f, wrapped_self, role_id, *args, **kwargs)
            inherited = call_args['inherited_to_projects']
            context = call_args['context']

            initiator = _get_request_audit_info(context)
            target = resource.Resource(typeURI=taxonomy.ACCOUNT_USER)

            audit_kwargs = {}
            if call_args['project_id']:
                audit_kwargs['project'] = call_args['project_id']
            elif call_args['domain_id']:
                audit_kwargs['domain'] = call_args['domain_id']

            if call_args['user_id']:
                audit_kwargs['user'] = call_args['user_id']
            elif call_args['group_id']:
                audit_kwargs['group'] = call_args['group_id']

            audit_kwargs['inherited_to_projects'] = inherited
            audit_kwargs['role'] = role_id

            # For backward compatibility, send both old and new event_type.
            # Deprecate old format and remove it in the next release.
            event_types = [self.deprecated_event_type, self.event_type]
            versionutils.deprecated(
                as_of=versionutils.deprecated.KILO,
                remove_in=+1,
                what=('sending duplicate %s notification event type' %
                      self.deprecated_event_type),
                in_favor_of='%s notification event type' % self.event_type)
            try:
                result = f(wrapped_self, role_id, *args, **kwargs)
            except Exception:
                for event_type in event_types:
                    _send_audit_notification(self.action, initiator,
                                             taxonomy.OUTCOME_FAILURE,
                                             target, event_type,
                                             **audit_kwargs)
                raise
            else:
                for event_type in event_types:
                    _send_audit_notification(self.action, initiator,
                                             taxonomy.OUTCOME_SUCCESS,
                                             target, event_type,
                                             **audit_kwargs)
                return result
Example #42
0
        def execute(*args, **kwargs):
            context = type(self).__state.context

            # If there is no context object already set in the thread local
            # state, we are entering the delegator for the first time and need
            # to create a new context.
            if context is None:
                from sentry.app import env  # avoids a circular import

                context = Context(env.request, {})

            # If this thread already has an active backend for this base class,
            # we can safely call that backend synchronously without delegating.
            if self.__backend_base in context.backends:
                backend = context.backends[self.__backend_base]
                return getattr(backend, attribute_name)(*args, **kwargs)

            # Binding the call arguments to named arguments has two benefits:
            # 1. These values always be passed in the same form to the selector
            #    function and callback, regardless of how they were passed to
            #    the method itself (as positional arguments, keyword arguments,
            #    etc.)
            # 2. This ensures that the given arguments are those supported by
            #    the base backend itself, which should be a common subset of
            #    arguments that are supported by all backends.
            callargs = inspect.getcallargs(base_value, None, *args, **kwargs)

            selected_backend_names = list(
                self.__selector_func(context, attribute_name, callargs))
            if not len(selected_backend_names) > 0:
                raise self.InvalidBackend("No backends returned by selector!")

            # Ensure that the primary backend is actually registered -- we
            # don't want to schedule any work on the secondaries if the primary
            # request is going to fail anyway.
            if selected_backend_names[0] not in self.__backends:
                raise self.InvalidBackend(
                    "{!r} is not a registered backend.".format(
                        selected_backend_names[0]))

            def call_backend_method(context, backend, is_primary):
                # Update the thread local state in the executor to the provided
                # context object. This allows the context to be propagated
                # across different threads.
                assert type(self).__state.context is None
                type(self).__state.context = context

                # Ensure that we haven't somehow accidentally entered a context
                # where the backend we're calling has already been marked as
                # active (or worse, some other backend is already active.)
                base = self.__backend_base
                assert base not in context.backends

                # Mark the backend as active.
                context.backends[base] = backend
                try:
                    return getattr(backend, attribute_name)(*args, **kwargs)
                except Exception as e:
                    # If this isn't the primary backend, we log any unexpected
                    # exceptions so that they don't pass by unnoticed. (Any
                    # exceptions raised by the primary backend aren't logged
                    # here, since it's assumed that the caller will log them
                    # from the calling thread.)
                    if not is_primary:
                        expected_raises = getattr(base_value, "__raises__", [])
                        if not expected_raises or not isinstance(
                                e, tuple(expected_raises)):
                            logger.warning(
                                "%s caught in executor while calling %r on %s.",
                                type(e).__name__,
                                attribute_name,
                                type(backend).__name__,
                                exc_info=True,
                            )
                    raise
                finally:
                    type(self).__state.context = None

            # Enqueue all of the secondary backend requests first since these
            # are non-blocking queue insertions. (Since the primary backend
            # executor queue insertion can block, if that queue was full the
            # secondary requests would have to wait unnecessarily to be queued
            # until the after the primary request can be enqueued.)
            # NOTE: If the same backend is both the primary backend *and* in
            # the secondary backend list -- this is unlikely, but possible --
            # this means that one of the secondary requests will be queued and
            # executed before the primary request is queued.  This is such a
            # strange usage pattern that I don't think it's worth optimizing
            # for.)
            results = [None] * len(selected_backend_names)
            for i, backend_name in enumerate(selected_backend_names[1:], 1):
                try:
                    backend, executor = self.__backends[backend_name]
                except KeyError:
                    logger.warning(
                        "%r is not a registered backend and will be ignored.",
                        backend_name,
                        exc_info=True,
                    )
                else:
                    results[i] = executor.submit(
                        functools.partial(call_backend_method,
                                          context.copy(),
                                          backend,
                                          is_primary=False),
                        priority=1,
                        block=False,
                    )

            # The primary backend is scheduled last since it may block the
            # calling thread. (We don't have to protect this from ``KeyError``
            # since we already ensured that the primary backend exists.)
            backend, executor = self.__backends[selected_backend_names[0]]
            results[0] = executor.submit(
                functools.partial(call_backend_method,
                                  context.copy(),
                                  backend,
                                  is_primary=True),
                priority=0,
                block=True,
            )

            if self.__callback_func is not None:
                FutureSet([
                    _f for _f in results if _f
                ]).add_done_callback(lambda *a, **k: self.__callback_func(
                    context, attribute_name, callargs, selected_backend_names,
                    results))

            return results[0].result()
Example #43
0
def interactive(__interact_f, **kwargs):
    """
    Builds a group of interactive widgets tied to a function and places the
    group into a Box container.

    Returns
    -------
    container : a Box instance containing multiple widgets

    Parameters
    ----------
    __interact_f : function
        The function to which the interactive widgets are tied. The `**kwargs`
        should match the function signature.
    **kwargs : various, optional
        An interactive widget is created for each keyword argument that is a
        valid widget abbreviation.
    """
    f = __interact_f
    co = kwargs.pop('clear_output', True)
    manual = kwargs.pop('__manual', False)
    kwargs_widgets = []
    container = Box(_dom_classes=['widget-interact'])
    container.result = None
    container.args = []
    container.kwargs = dict()
    kwargs = kwargs.copy()

    new_kwargs = _find_abbreviations(f, kwargs)
    # Before we proceed, let's make sure that the user has passed a set of args+kwargs
    # that will lead to a valid call of the function. This protects against unspecified
    # and doubly-specified arguments.
    getcallargs(f, **{n: v for n, v, _ in new_kwargs})
    # Now build the widgets from the abbreviations.
    kwargs_widgets.extend(_widgets_from_abbreviations(new_kwargs))

    # This has to be done as an assignment, not using container.children.append,
    # so that traitlets notices the update. We skip any objects (such as fixed) that
    # are not DOMWidgets.
    c = [w for w in kwargs_widgets if isinstance(w, DOMWidget)]

    # If we are only to run the function on demand, add a button to request this
    if manual:
        manual_button = Button(description="Run %s" % f.__name__)
        c.append(manual_button)
    container.children = c

    # Build the callback
    def call_f(name=None, old=None, new=None):
        container.kwargs = {}
        for widget in kwargs_widgets:
            value = widget.value
            container.kwargs[widget._kwarg] = value
        if co:
            clear_output(wait=True)
        if manual:
            manual_button.disabled = True
        try:
            container.result = f(**container.kwargs)
        except Exception as e:
            ip = get_ipython()
            if ip is None:
                container.log.warn("Exception in interact callback: %s",
                                   e,
                                   exc_info=True)
            else:
                ip.showtraceback()
        finally:
            if manual:
                manual_button.disabled = False

    # Wire up the widgets
    # If we are doing manual running, the callback is only triggered by the button
    # Otherwise, it is triggered for every trait change received
    # On-demand running also suppresses running the function with the initial parameters
    if manual:
        manual_button.on_click(call_f)
    else:
        for widget in kwargs_widgets:
            widget.on_trait_change(call_f, 'value')

        container.on_displayed(lambda _: call_f(None, None, None))

    return container
Example #44
0
 def wrapper(*args, **kwargs):
     bound_args = inspect.getcallargs(func, *args, **kwargs)
     for n, v in bound_args.items():
         if v is not defaults.get(n, _SENTINEL) and n in validators:
             validators[n](args and args[0] or None, v)
     return func(*args, **kwargs)
Example #45
0
 def bind(self, *pos, **kw):
     inspect.getcallargs(self.func, *pos, **kw)
Example #46
0
 def _get_key(args, kwargs):
     return f.__module__, f.__name__, make_hashable(
         getcallargs(f, *args, **kwargs))
Example #47
0
        def wrapped(*args, **kwargs):
            # If we're passed a cache_context then we'll want to call its invalidate()
            # whenever we are invalidated
            invalidate_callback = kwargs.pop("on_invalidate", None)

            arg_dict = inspect.getcallargs(self.orig, obj, *args, **kwargs)
            keyargs = [arg_dict[arg_nm] for arg_nm in self.arg_names]
            list_args = arg_dict[self.list_name]

            # cached is a dict arg -> deferred, where deferred results in a
            # 2-tuple (`arg`, `result`)
            results = {}
            cached_defers = {}
            missing = []
            for arg in list_args:
                key = list(keyargs)
                key[self.list_pos] = arg

                try:
                    res = cache.get(tuple(key), callback=invalidate_callback)
                    if not res.has_succeeded():
                        res = res.observe()
                        res.addCallback(lambda r, arg: (arg, r), arg)
                        cached_defers[arg] = res
                    else:
                        results[arg] = res.get_result()
                except KeyError:
                    missing.append(arg)

            if missing:
                sequence = cache.sequence
                args_to_call = dict(arg_dict)
                args_to_call[self.list_name] = missing

                ret_d = defer.maybeDeferred(
                    preserve_context_over_fn,
                    self.function_to_call,
                    **args_to_call
                )

                ret_d = ObservableDeferred(ret_d)

                # We need to create deferreds for each arg in the list so that
                # we can insert the new deferred into the cache.
                for arg in missing:
                    with PreserveLoggingContext():
                        observer = ret_d.observe()
                    observer.addCallback(lambda r, arg: r.get(arg, None), arg)

                    observer = ObservableDeferred(observer)

                    key = list(keyargs)
                    key[self.list_pos] = arg
                    cache.update(
                        sequence, tuple(key), observer,
                        callback=invalidate_callback
                    )

                    def invalidate(f, key):
                        cache.invalidate(key)
                        return f
                    observer.addErrback(invalidate, tuple(key))

                    res = observer.observe()
                    res.addCallback(lambda r, arg: (arg, r), arg)

                    cached_defers[arg] = res

            if cached_defers:
                def update_results_dict(res):
                    results.update(res)
                    return results

                return preserve_context_over_deferred(defer.gatherResults(
                    cached_defers.values(),
                    consumeErrors=True,
                ).addCallback(update_results_dict).addErrback(
                    unwrapFirstError
                ))
            else:
                return results
Example #48
0
def evaluate(fn: t.Callable[..., t.Any],
             *,
             _globals=None,
             **_locals: t.Any) -> None:
    sig = inspect.signature(fn)
    for k, p in sig.parameters.items():
        if k in _locals:
            continue
        if p.default == p.empty:
            continue
        _locals[k] = p.default
    inspect.getcallargs(fn, **_locals)

    # dis.dis(fn)

    if _globals is None:
        _globals = ChainMap(globals(), sys.modules["builtins"].__dict__)

    pos = []
    stack = []
    pos.append(stack)

    for lineno, inst in iter_instructions(fn):
        opname = inst.opname
        logger.debug("%s %s", inst.opname, inst.argrepr)
        if opname == "LOAD_GLOBAL":
            stack.append(_globals[inst.argval])
        elif opname == "LOAD_FAST":
            stack.append(_locals[inst.argval])
        elif opname == "LOAD_CONST":
            stack.append(inst.argval)
        elif opname == "STORE_FAST":
            # remove from stack? or not?
            _locals[inst.argval] = stack.pop()
        elif opname == "POP_TOP":
            stack.pop()
        elif opname == "RETURN_VALUE":
            # NG??
            assert len(stack) == 1, stack
            return stack[-1]
        elif opname == "BINARY_ADD":
            rv = stack.pop()
            lv = stack.pop()
            stack.append(lv + rv)
        elif opname == "BUILD_TUPLE":
            args = reversed([stack.pop() for _ in range(inst.arg)])
            stack.append(tuple(args))
        elif opname == "CALL_FUNCTION":
            args = reversed([stack.pop() for _ in range(inst.arg)])
            fn = stack.pop()
            stack.append(fn(*args))
        elif opname == "CALL_FUNCTION_KW":
            kwargs = {k: stack.pop() for k in stack.pop()}
            arglen = inst.arg - len(kwargs)
            args = ()
            if arglen > 0:
                args = reversed(
                    [stack.pop() for _ in range(inst.arg - len(kwargs))])
            fn = stack.pop()
            if fn.__module__ == __name__ and isinstance(fn, type):
                fn = get_dataclass_factory(fn)
            stack.append(fn(*args, **kwargs))
        else:
            # TODO: traceback
            raise RuntimeError(
                f"unsupported opcode: {inst.opname} {inst.argrepr}, in line {lineno}\n stack(len={len(stack)})={stack!r}"
            )
Example #49
0
        def wrapped(*args, **kwargs):
            # If we're passed a cache_context then we'll want to call its
            # invalidate() whenever we are invalidated
            invalidate_callback = kwargs.pop("on_invalidate", None)

            arg_dict = inspect.getcallargs(self.orig, obj, *args, **kwargs)
            keyargs = [arg_dict[arg_nm] for arg_nm in self.arg_names]
            list_args = arg_dict[self.list_name]

            results = {}

            def update_results_dict(res, arg):
                results[arg] = res

            # list of deferreds to wait for
            cached_defers = []

            missing = set()

            # If the cache takes a single arg then that is used as the key,
            # otherwise a tuple is used.
            if num_args == 1:

                def arg_to_cache_key(arg):
                    return arg
            else:
                keylist = list(keyargs)

                def arg_to_cache_key(arg):
                    keylist[self.list_pos] = arg
                    return tuple(keylist)

            for arg in list_args:
                try:
                    res = cache.get(arg_to_cache_key(arg),
                                    callback=invalidate_callback)
                    if not isinstance(res, ObservableDeferred):
                        results[arg] = res
                    elif not res.has_succeeded():
                        res = res.observe()
                        res.addCallback(update_results_dict, arg)
                        cached_defers.append(res)
                    else:
                        results[arg] = res.get_result()
                except KeyError:
                    missing.add(arg)

            if missing:
                # we need an observable deferred for each entry in the list,
                # which we put in the cache. Each deferred resolves with the
                # relevant result for that key.
                deferreds_map = {}
                for arg in missing:
                    deferred = defer.Deferred()
                    deferreds_map[arg] = deferred
                    key = arg_to_cache_key(arg)
                    observable = ObservableDeferred(deferred)
                    cache.set(key, observable, callback=invalidate_callback)

                def complete_all(res):
                    # the wrapped function has completed. It returns a
                    # a dict. We can now resolve the observable deferreds in
                    # the cache and update our own result map.
                    for e in missing:
                        val = res.get(e, None)
                        deferreds_map[e].callback(val)
                        results[e] = val

                def errback(f):
                    # the wrapped function has failed. Invalidate any cache
                    # entries we're supposed to be populating, and fail
                    # their deferreds.
                    for e in missing:
                        key = arg_to_cache_key(e)
                        cache.invalidate(key)
                        deferreds_map[e].errback(f)

                    # return the failure, to propagate to our caller.
                    return f

                args_to_call = dict(arg_dict)
                args_to_call[self.list_name] = list(missing)

                cached_defers.append(
                    defer.maybeDeferred(
                        logcontext.preserve_fn(self.function_to_call),
                        **args_to_call).addCallbacks(complete_all, errback))

            if cached_defers:
                d = defer.gatherResults(
                    cached_defers,
                    consumeErrors=True,
                ).addCallbacks(lambda _: results, unwrapFirstError)
                return logcontext.make_deferred_yieldable(d)
            else:
                return results
Example #50
0
    def _add_action(self, name: str, *args: Any, **kwargs: Any) -> None:
        """Process action calls in plans.

        :param name: action name
        :param args: positional arguments of the action call
        :param kwargs: keyword arguments of the action call
        """
        if self.ignore_disabled and not self.env.enabled:
            return

        if TYPE_CHECKING:
            assert self.plan is not None

        # ??? sometimes to understand the context it would be better to have
        # several lines of plan, e.g. when an action is created by calling
        # a function defined in a plan. Include all these lines separated
        # by ';'. A better fix would be to change plan_line to plan_lines
        # containing a tuple of plan_line.
        plan_line = "unknown filename:unknown lineno"
        # Retrieve the plan line
        try:
            caller_frames = inspect.getouterframes(frame=inspect.currentframe())
            caller_frames_in_plan = []
            for frame in caller_frames:
                frame_filename = frame.filename
                if frame_filename.endswith(self.plan.plan_ext):
                    caller_frames_in_plan.append(frame)
        except Exception:  # defensive code
            # do not crash when inspect frames fails
            pass
        else:
            if not caller_frames_in_plan:
                # No information ?
                pass
            else:
                plan_line = ";".join(
                    f"{caller_frame.filename}:{caller_frame.lineno}"
                    for caller_frame in caller_frames_in_plan
                )

        # First create our initial object based on current scope env
        result = self.env.copy()

        # Process arguments
        call_args = inspect.getcallargs(self.actions[name], *args, **kwargs)

        # Push function arguments into the result object. If an arg value
        # is None then environment is not updated (handling of defaults
        # coming from environment). For the build, host and target arguments
        # a special processing is done to make the corresponding set_env
        # call on the result BaseEnv object
        platform: Dict[str, Optional[str]] = {
            "build": None,
            "host": None,
            "target": None,
        }

        # Likewise board argument is used to change only the machine name
        # of the target. ??? change name ???
        board = None

        for k, v in call_args.items():
            if k in platform:
                platform[k] = v
            elif k == "board":
                board = v
            elif v is not None or not hasattr(result, k):
                setattr(result, k, v)

        # Handle propagation of environment from the context
        if platform["host"] is None and result.is_canadian:
            platform["host"] = "host"
        if platform["target"] is None and result.is_cross:
            platform["target"] = "target"
        if platform["target"] == result.host.platform:
            # ??? This special case is temporary ???
            # the goal is avoid cross from a -> a which are
            # not current supported.
            # Plans should be updated to use target='host'
            # instead of target=env.host.platform
            platform["target"] = "host"

        result.set_env(**platform)

        # If necessary adjust target machine name
        if board is not None:
            result.set_target(
                result.target.platform,
                result.target.os.version,
                board,
                result.target.os.mode,
            )

        # Set action attribute (with action name)
        result.action = name
        result.plan_line = plan_line
        result.plan_args = result.to_dict()
        result.plan_call_args = call_args

        # Push the action in the current list
        self.action_list.append(result)
Example #51
0
 def _singleton(*args, **kwargs):
     key = frozenset(
         inspect.getcallargs(cls.__init__, *args, **kwargs).items())
     if key not in instances:
         instances[key] = cls(*args, **kwargs)
     return instances[key]
Example #52
0
 def _wrapper(*args, **kwargs):
     _log.info('DRY RUN: calling %s with arguments %s', function.__name__,
               inspect.getcallargs(function, *args, **kwargs))
Example #53
0
 def wrapper(*args, **kwargs):
     argmap = inspect.getcallargs(func, *args, **kwargs)
     for k, map_func in six.iteritems(maps):
         if k in argmap:
             argmap[k] = map_func(argmap[k])
     return func(**argmap)
Example #54
0
    def _resolve_lookup(self, context):
        """
        Performs resolution of a real variable (i.e. not a literal) against the
        given context.

        As indicated by the method's name, this method is an implementation
        detail and shouldn't be called by external code. Use Variable.resolve()
        instead.
        """
        current = context
        try:  # catch-all for silent variable failures
            for bit in self.lookups:
                try:  # dictionary lookup
                    current = current[bit]
                    # ValueError/IndexError are for numpy.array lookup on
                    # numpy < 1.9 and 1.9+ respectively
                except (TypeError, AttributeError, KeyError, ValueError,
                        IndexError):
                    try:  # attribute lookup
                        # Don't return class attributes if the class is the context:
                        if isinstance(current, BaseContext) and getattr(
                                type(current), bit):
                            raise AttributeError
                        current = getattr(current, bit)
                    except (TypeError, AttributeError):
                        # Reraise if the exception was raised by a @property
                        if not isinstance(current,
                                          BaseContext) and bit in dir(current):
                            raise
                        try:  # list-index lookup
                            current = current[int(bit)]
                        except (
                                IndexError,  # list index out of range
                                ValueError,  # invalid literal for int()
                                KeyError,  # current is a dict without `int(bit)` key
                                TypeError):  # unsubscriptable object
                            raise VariableDoesNotExist(
                                "Failed lookup for key "
                                "[%s] in %r",
                                (bit, current))  # missing attribute
                if callable(current):
                    if getattr(current, 'do_not_call_in_templates', False):
                        pass
                    elif getattr(current, 'alters_data', False):
                        current = context.template.engine.string_if_invalid
                    else:
                        try:  # method call (assuming no args required)
                            current = current()
                        except TypeError:
                            try:
                                inspect.getcallargs(current)
                            except TypeError:  # arguments *were* required
                                current = context.template.engine.string_if_invalid  # invalid method call
                            else:
                                raise
        except Exception as e:
            template_name = getattr(context, 'template_name',
                                    None) or 'unknown'
            logger.debug(
                "Exception while resolving variable '%s' in template '%s'.",
                bit,
                template_name,
                exc_info=True,
            )

            if getattr(e, 'silent_variable_failure', False):
                current = context.template.engine.string_if_invalid
            else:
                raise

        return current
Example #55
0
 def wrapper(*args, **kwargs):
     callargs = inspect.getcallargs(f, *args, **kwargs)
     for name in argnames:
         callargs[name] = make_iterable(callargs[name])
     return f(**callargs)
Example #56
0
def get_mock_call_args(pattern_func, mock_func):
    """ Return the arguments the mock function was called with interpreted
    by the pattern functions argument list.
    """
    invoked_args, invoked_kargs = mock_func.call_args
    return getcallargs(pattern_func, *invoked_args, **invoked_kargs)
Example #57
0
 def _fn(*args, **kwargs):
     binding = inspect.getcallargs(fn, *args, **kwargs)
     binding_str = ", ".join("%s=%s" % item for item in binding.iteritems())
     signature = fn.__name__ + "(%s)" % binding_str
     print(signature, file=sys.stderr)
     return fn(*args, **kwargs)
Example #58
0
 def generate_key(base, args, kwargs):
     argsmap = inspect.getcallargs(function, *args, **kwargs)
     argvals_as_strings = [str(argsmap[argname]) for argname in argnames]
     argstr = '_{}'.format('_'.join(argvals_as_strings)) if argnames else ''
     return '{}{}'.format(base, argstr)
Example #59
0
 def func_wrapper(self, *args, **kwargs):
     d = inspect.getcallargs(func, self, *args, **kwargs)
     d['args'].update({"studyID": self.studyID})
     return func(**d)
Example #60
0
 def __call__(self, *args, **kwds):
     all = getcallargs(self._f, *args, **kwds)
     return cython_inline(self._body,
                          locals=self._f.func_globals,
                          globals=self._f.func_globals,
                          **all)