This method retrieves ONLY the ROOT actions
961268
public List<Action> getRootActions() {
		final List<Action> rootActions = srcUpdTrees.stream().map(t -> originalActionsSrc.get(t))
				.collect(Collectors.toList());

		rootActions.addAll(srcDelTrees.stream() //
				.filter(t -> !srcDelTrees.contains(t.getParent()) && !srcUpdTrees.contains(t.getParent())) //
				.map(t -> originalActionsSrc.get(t)) //
				.collect(Collectors.toList()));

		rootActions.addAll(dstAddTrees.stream() //
				.filter(t -> !dstAddTrees.contains(t.getParent()) && !dstUpdTrees.contains(t.getParent())) //
				.map(t -> originalActionsDst.get(t)) //
				.collect(Collectors.toList()));

		rootActions.addAll(dstMvTrees.stream() //
				.filter(t -> !dstMvTrees.contains(t.getParent())) //
				.map(t -> originalActionsDst.get(t)) //
				.collect(Collectors.toList()));

		rootActions.removeAll(Collections.singleton(null));
		return rootActions;
	}
173535
def list_actions(self):
        

        actions = []
        for path, actionName, action in self:
            actions.append(self.__namespace_splitter.join(itertools.chain(path, (actionName,))))
        return sorted(actions)
3180
function getActions ( ) {

        // Determine the events to bind. IE11 implements pointerEvents without
        // a prefix, which breaks compatibility with the IE10 implementation.
        return window.navigator.pointerEnabled ? {
                start: 'pointerdown',
                move: 'pointermove',
                end: 'pointerup'
            } : window.navigator.msPointerEnabled ? {
                    start: 'MSPointerDown',
                    move: 'MSPointerMove',
                    end: 'MSPointerUp'
                } : {
                    start: 'mousedown touchstart',
                    move: 'mousemove touchmove',
                    end: 'mouseup touchend'
                };
    }
592594
def get_api_root_view(self, **kwargs):
        """"""
        class API(views.APIView):
            _ignore_model_permissions = True

            def get(self, request, *args, **kwargs):
                directory_list = get_directory(request)
                result = OrderedDict()
                for group_name, url, endpoints, _ in directory_list:
                    if url:
                        result[group_name] = url
                    else:
                        group = OrderedDict()
                        for endpoint_name, url, _, _ in endpoints:
                            group[endpoint_name] = url
                        result[group_name] = group
                return Response(result)

        return API.as_view()
1365158
def _get_roots(self):
        

        return (
            # OSS Scheme
            # - oss://<bucket>/<key>
            'oss://',

            # URL (With common aliyuncs.com endpoint):
            # - http://<bucket>.oss-<region>.aliyuncs.com/<key>
            # - https://<bucket>.oss-<region>.aliyuncs.com/<key>

            # Note: "oss-<region>.aliyuncs.com" may be replaced by another
            # endpoint

            _re.compile((r'https?://[\w-]+.%s' % self._endpoint.split(
                '//', 1)[1]).replace('.', r'\.')))
945577
def get_descendants(self):
        
        if self.is_leaf():
            return get_result_class(self.__class__).objects.none()
        return self.__class__.get_tree(self).exclude(pk=self.pk)
757167
def find_root(self):
        
        cmd = self
        while cmd.parent:
            cmd = cmd.parent
        return cmd
1247923
def get_root(self):
        """"""
        if self.is_root_node():
            return self

        return self.get_ancestors().order_by(
            "-%s__depth" % self._closure_parentref()
        )[0]
1066687
private List<Action> actionsOf(JsonNode actionNodes) {
        List<Action> actions = new LinkedList<Action>();

        if (actionNodes.isArray()) {
            for (JsonNode action : actionNodes) {
                actions.add(new NamedAction(action.asText()));
            }
        } else {
            actions.add(new NamedAction(actionNodes.asText()));
        }
        return actions;
    }
1211160
def setup_common_actions(self):
        """"""
        actions = super(ExplorerTreeWidget, self).setup_common_actions()
        if self.show_cd_only is None:
            # Enabling the 'show current directory only' option but do not
            # allow the user to disable it
            self.show_cd_only = True
        else:
            # Show current directory only
            cd_only_action = create_action(self,
                                           _("Show current directory only"),
                                           toggled=self.toggle_show_cd_only)
            cd_only_action.setChecked(self.show_cd_only)
            self.toggle_show_cd_only(self.show_cd_only)
            actions.append(cd_only_action)
        return actions
873789
def act(self):
        
        g = get_root(self).globals
        g.ipars.unfreeze()
        g.rpars.unfreeze()
        g.observe.load.enable()
        self.disable()
1197993
def root(self):
        

        if not self.parent:
            return self

        con = self.parent

        while con.parent:
            con = con.parent

        return con
383078
def get_descendants(self):
        
        return self.__class__.get_tree(self).exclude(pk=self.pk)
305160
def execs(root=None):
    '''
    
    '''
    ret = {}
    for service in get_all(root=root):
        data = show(service, root=root)
        if 'ExecStart' not in data:
            continue
        ret[service] = data['ExecStart']['path']
    return ret
771961
public Collection<? extends Action> getProjectActions() {
        // delegate to getJobAction (singular) for backward compatible behavior
        Action a = getProjectAction();
        if (a==null)    return Collections.emptyList();
        return Collections.singletonList(a);
    }
618993
def get_keys_to_action(self):
        """"""
        # get the old mapping of keys to actions
        old_keys_to_action = self.env.unwrapped.get_keys_to_action()
        # invert the keys to action mapping to lookup key combos by action
        action_to_keys = {v: k for k, v in old_keys_to_action.items()}
        # create a new mapping of keys to actions
        keys_to_action = {}
        # iterate over the actions and their byte values in this mapper
        for action, byte in self._action_map.items():
            # get the keys to press for the action
            keys = action_to_keys[byte]
            # set the keys value in the dictionary to the current discrete act
            keys_to_action[keys] = action

        return keys_to_action
791075
@RequestMapping(value = "actions", method = RequestMethod.GET)
    public Resources<Action> getAccountMgtActions() {
        return Resources.of(
                extensionManager.getExtensions(AccountMgtActionExtension.class).stream()
                        .map(this::resolveExtensionAction)
                        .filter(action -> action != null),
                uri(on(AccountController.class).getAccountMgtActions())
        );
    }