def process_create_ex(self, executable, arguments, environment_changes, flags, timeout_ms, priority, affinity):
        """Creates a new process running in the guest with the extended options
        for setting the process priority and affinity.
        
        See :py:func:`IGuestSession.process_create`  for more information.

        in executable of type str
            Full path to the file to execute in the guest.  The file has to
            exists in the guest VM with executable right to the session user in
            order to succeed.  If empty/null, the first entry in the
            @a arguments array will be used instead (i.e. argv[0]).

        in arguments of type str
            Array of arguments passed to the new process.
            
            Starting with VirtualBox 5.0 this array starts with argument 0
            instead of argument 1 as in previous versions.  Whether the zeroth
            argument can be passed to the guest depends on the VBoxService
            version running there.  If you depend on this, check that the
            :py:func:`IGuestSession.protocol_version`  is 3 or higher.

        in environment_changes of type str
            Set of environment changes to complement
            :py:func:`IGuestSession.environment_changes` .  Takes precedence
            over the session ones.  The changes are in putenv format, i.e.
            "VAR=VALUE" for setting and "VAR" for unsetting.
            
            The changes are applied to the base environment of the impersonated
            guest user (:py:func:`IGuestSession.environment_base` ) when
            creating the process.  (This is done on the guest side of things in
            order to be compatible with older guest additions.  That is one of
            the motivations for not passing in the whole environment here.)

        in flags of type :class:`ProcessCreateFlag`
            Process creation flags, see :py:class:`ProcessCreateFlag`  for
            detailed description of available flags.

        in timeout_ms of type int
            Timeout (in ms) for limiting the guest process' running time.
            Pass 0 for an infinite timeout. On timeout the guest process will be
            killed and its status will be put to an appropriate value. See
            :py:class:`ProcessStatus`  for more information.

        in priority of type :class:`ProcessPriority`
            Process priority to use for execution, see :py:class:`ProcessPriority` 
            for available priority levels.
            This is silently ignored if not supported by guest additions.

        in affinity of type int
            Processor affinity to set for the new process.  This is a list of
            guest CPU numbers the process is allowed to run on.
            
            This is silently ignored if the guest does not support setting the
            affinity of processes, or if the guest additions does not implemet
            this feature.

        return guest_process of type :class:`IGuestProcess`
            Guest process object of the newly created process.

        """
        if not isinstance(executable, basestring):
            raise TypeError("executable can only be an instance of type basestring")
        if not isinstance(arguments, list):
            raise TypeError("arguments can only be an instance of type list")
        for a in arguments[:10]:
            if not isinstance(a, basestring):
                raise TypeError(
                        "array can only contain objects of type basestring")
        if not isinstance(environment_changes, list):
            raise TypeError("environment_changes can only be an instance of type list")
        for a in environment_changes[:10]:
            if not isinstance(a, basestring):
                raise TypeError(
                        "array can only contain objects of type basestring")
        if not isinstance(flags, list):
            raise TypeError("flags can only be an instance of type list")
        for a in flags[:10]:
            if not isinstance(a, ProcessCreateFlag):
                raise TypeError(
                        "array can only contain objects of type ProcessCreateFlag")
        if not isinstance(timeout_ms, baseinteger):
            raise TypeError("timeout_ms can only be an instance of type baseinteger")
        if not isinstance(priority, ProcessPriority):
            raise TypeError("priority can only be an instance of type ProcessPriority")
        if not isinstance(affinity, list):
            raise TypeError("affinity can only be an instance of type list")
        for a in affinity[:10]:
            if not isinstance(a, baseinteger):
                raise TypeError(
                        "array can only contain objects of type baseinteger")
        guest_process = self._call("processCreateEx",
                     in_p=[executable, arguments, environment_changes, flags, timeout_ms, priority, affinity])
        guest_process = IGuestProcess(guest_process)
        return guest_process