Returns a partial scope with current action-fluents.

        Args:
            action_fluents (Sequence[tf.Tensor]): The action fluents.

        Returns:
            A mapping from action fluent names to :obj:`rddl2tf.fluent.TensorFluent`.
975083
def action_scope(self, action_fluents: Sequence[tf.Tensor]) -> Dict[str, TensorFluent]:
        '''
        '''
        return dict(zip(self.rddl.domain.action_fluent_ordering, action_fluents))
959695
def get_action(self, parent, undo_stack: QUndoStack, sel_range, groups,
                   view: int) -> QUndoCommand:
        
        raise NotImplementedError("Abstract Method.")
83382
def action(callback=None, name=None, path=None, methods=Method.GET, resource=None, tags=None,
           summary=None, middleware=None):
    # type: (Callable, Path, Path, Methods, Type[Resource], Tags, str, List[Any]) -> Operation
    
    # Generate action path
    path = path or '{key_field}'
    if name:
        path += name

    def inner(c):
        return Operation(c, path, methods, resource, tags, summary, middleware)
    return inner(callback) if callback else inner
560368
def action_size(self) -> Sequence[Shape]:
        ''''''
        return self._sizes(self._compiler.rddl.action_size)
890067
def _get_action(trans):
    
    # TODO: VIQR-like convention
    mark_action = {
        '^': (_Action.ADD_MARK, Mark.HAT),
        '+': (_Action.ADD_MARK, Mark.BREVE),
        '*': (_Action.ADD_MARK, Mark.HORN),
        '-': (_Action.ADD_MARK, Mark.BAR),
    }

    accent_action = {
        '\\': (_Action.ADD_ACCENT, Accent.GRAVE),
        '/': (_Action.ADD_ACCENT, Accent.ACUTE),
        '?': (_Action.ADD_ACCENT, Accent.HOOK),
        '~': (_Action.ADD_ACCENT, Accent.TIDLE),
        '.': (_Action.ADD_ACCENT, Accent.DOT),
    }

    if trans[0] in ('<', '+'):
        return _Action.ADD_CHAR, trans[1]
    if trans[0] == "_":
        return _Action.UNDO, trans[1:]
    if len(trans) == 2:
        return mark_action[trans[1]]
    else:
        return accent_action[trans[0]]
1225105
def _fmadm_action_fmri(action, fmri):
    '''
    
    '''
    ret = {}
    fmadm = _check_fmadm()
    cmd = '{cmd} {action} {fmri}'.format(
        cmd=fmadm,
        action=action,
        fmri=fmri
    )
    res = __salt__['cmd.run_all'](cmd)
    retcode = res['retcode']
    result = {}
    if retcode != 0:
        result['Error'] = res['stderr']
    else:
        result = True

    return result
684576
def model_actions(self, model, **kwargs):
        
        check(model)
        ctype = ContentType.objects.get_for_model(model)
        return self.public(
            (Q(target_content_type=ctype) |
             Q(action_object_content_type=ctype) |
             Q(actor_content_type=ctype)),
            **kwargs
        )
541220
def state_fluents(self) -> Dict[str, PVariable]:
        ''''''
        return { str(pvar): pvar for pvar in self.pvariables if pvar.is_state_fluent() }
464938
def _get_action(self, action):
        

        # If we don't have an action named that, bail out
        if action not in self.wsgi_actions:
            return None

        # Generate an ActionDescriptor if necessary
        if action not in self.wsgi_descriptors:
            self.wsgi_descriptors[action] = actions.ActionDescriptor(
                self.wsgi_actions[action],
                self.wsgi_extensions.get(action, []),
                self.wsgi_resp_type)

        # OK, return the method descriptor
        return self.wsgi_descriptors[action]
1250359
def get_foreign_key_referential_action_sql(self, action):
        
        action = action.upper()
        if action not in [
            "CASCADE",
            "SET NULL",
            "NO ACTION",
            "RESTRICT",
            "SET DEFAULT",
        ]:
            raise DBALException("Invalid foreign key action: %s" % action)

        return action
1356592
function execAnySubFns(actions) {
  return actions.map(function (action) {
    return Object.keys(action).reduce(function (accum, key) {
      // if it is list of sub keys, and is a fn, then bind with tokens
      if (SUBSTITUTED_KEYS.indexOf(key) !== -1 && typeof action[key] === 'function') {
        accum[key] = action[key](); // exec fn to get value
      } else {
        accum[key] = action[key];
      }
      return accum;
    }, {});
  });
}
1017452
private JointParsingState.Action getAction(int l, int r, Target targets) {
		if (targets.getHead(l) == r && modifierNumOf(l, targets) == 0)
			return JointParsingState.Action.RIGHT;
		if (targets.getHead(r) == l && modifierNumOf(r, targets) == 0)
			return JointParsingState.Action.LEFT;
		return JointParsingState.Action.SHIFT;
	}
831011
def get_workflow_actions_for(brain_or_object):
    
    portal_type = api.get_portal_type(brain_or_object)
    actions = actions_by_type.get(portal_type, None)
    if actions:
        return actions

    # Retrieve the actions from the workflows this object is bound to
    actions = []
    wf_tool = api.get_tool("portal_workflow")
    for wf_id in get_workflow_ids_for(brain_or_object):
        workflow = wf_tool.getWorkflowById(wf_id)
        wf_actions = map(lambda action: action[0], workflow.transitions.items())
        actions.extend(wf_actions)

    actions = list(set(actions))
    actions_by_type[portal_type] = actions
    return actions
634121
def action_getattr():
    

    def action_getattr(_value, context, **_params):
        value = getattr(context["action"], context["key"])
        return _attr(value)

    return action_getattr
350979
def action_decorator(name):
    
    def decorator(cls):
        action_decorators.append((name, cls))
        return cls
    return decorator
1359028
def actions(self):
        
        r = self.session.query(models.Action).all()
        return [x.type_name for x in r]
1158446
def getActionHandle(self, pchActionName):
        """"""

        fn = self.function_table.getActionHandle
        pHandle = VRActionHandle_t()
        result = fn(pchActionName, byref(pHandle))
        return result, pHandle