Get all of the rule details associated with this function.
357257
def get_event_rules_for_lambda(self, lambda_arn):
        
        rule_names = self.get_event_rule_names_for_lambda(lambda_arn=lambda_arn)
        return [self.events_client.describe_rule(Name=r) for r in rule_names]
723054
function findAfterChecks(rule) {
	'use strict';

	return axe.utils
		.getAllChecks(rule)
		.map(function(c) {
			var check = rule._audit.checks[c.id || c];
			return check && typeof check.after === 'function' ? check : null;
		})
		.filter(Boolean);
}
932218
public static List<ResolverRule> getResolverRules() {
		return Arrays.asList(
			ResolverRules.LOOKUP_CALL_BY_NAME,
			ResolverRules.FLATTEN_STAR_REFERENCE,
			ResolverRules.EXPAND_COLUMN_FUNCTIONS,
			ResolverRules.OVER_WINDOWS,
			ResolverRules.FIELD_RESOLVE,
			ResolverRules.FLATTEN_CALL,
			ResolverRules.RESOLVE_CALL_BY_ARGUMENTS,
			ResolverRules.VERIFY_NO_MORE_UNRESOLVED_EXPRESSIONS);
	}
1187209
private function extractRules()
    {
        // Keep in mind we don't support recursive directories (or cache the results)
        $possibleModels = glob(Strata::getSRCPath() . "Model" . DIRECTORY_SEPARATOR . "*.php");
        $this->batchModelFileRegistrationAttempt((array)$possibleModels);

        $possibleTaxonomies = glob(Strata::getSRCPath() . "Model" . DIRECTORY_SEPARATOR . "Taxonomy" . DIRECTORY_SEPARATOR . "*.php");
        $this->batchTaxonomyFileRegistrationAttempt((array)$possibleTaxonomies);
    }
1278532
def get(self):
        """"""
        output = ''
        for f in self.functions:
            output += self.underline(f) + '\n\n'
            if f in self.synopsises and isinstance(self.synopsises[f], str):
                output += self.format(self.synopsises[f]) + '\n'
            if f in self.descriptions and isinstance(
                self.descriptions[f], str
            ):
                output += self.format(self.descriptions[f], indent=8) + '\n'
            if f in self.examples and isinstance(self.examples[f], str):
                output += self.format(self.examples[f], indent=8) + '\n'
            output += '\n'
        return output
65412
public function rules(): array
    {
        $input = array_keys($this->request->all());

        return Parameter::whereIn('id', $input)
            ->get()
            ->mapWithKeys(function ($item) {
                return [$item['id'] => $item->rules];
            })->all();
    }
1331273
def list_firewall_rules(self, retrieve_all=True, **_params):
        """"""
        # Pass filters in "params" argument to do_request

        return self.list('firewall_rules', self.firewall_rules_path,
                         retrieve_all, **_params)
1131815
function getBasicInfo() {
    const result = {};
    for (const key in info) {
        if (info.hasOwnProperty(key)) {
            result[key] = info[key]();
        }
    }
    return result;
}
304228
def get_filter_rules(self, way='in'):
        
        try:
            if way == 'in':
                filters = self.request(
                    'GetFilterRules')['filterRules']['filterRule']
            elif way == 'out':
                filters = self.request(
                    'GetOutgoingFilterRules')['filterRules']['filterRule']

            # Zimbra return a dict if there is only one instance
            if isinstance(filters, dict):
                filters = [filters]

            return [zobjects.FilterRule.from_dict(f) for f in filters]
        except KeyError:
            return []
219295
List<Object> getSortedRules() {
        List<Object> result = new ArrayList<Object>();
        for (RuleEntry entry : getSortedEntries()) {
            result.add(entry.rule);
        }
        return result;
    }
1049050
List<Rule> getRules() {
        List<Rule> rulesToReturn = new ArrayList<>(this.rules);
        new DeletedProposition().toRules(rulesToReturn);
        return rulesToReturn;
    }
104497
private void extractRules(RuleSource ruleSource, Collection<?> blocks, RuleSetBuilder builder) throws RuleException {
        for (Object element : blocks) {
            if (element instanceof AbstractBlock) {
                AbstractBlock block = (AbstractBlock) element;
                if (EXECUTABLE_RULE_TYPES.contains(block.getRole())) {
                    extractExecutableRule(ruleSource, block, builder);
                } else if (GROUP.equals(block.getRole())) {
                    extractGroup(ruleSource, block, builder);
                }
                extractRules(ruleSource, block.getBlocks(), builder);
            } else if (element instanceof Collection<?>) {
                extractRules(ruleSource, (Collection<?>) element, builder);
            }
        }
    }
1304878
public function getRules(): array
    {
        if (count($this->large) === 0) {
            $this->large = $this->apriori();
        }

        if (count($this->rules) > 0) {
            return $this->rules;
        }

        $this->rules = [];

        $this->generateAllRules();

        return $this->rules;
    }
1080139
def get_rules(license):
  """"""

  can = []
  cannot = []
  must = []
  req = requests.get("{base_url}/licenses/{license}".format(
                     base_url=BASE_URL, license=license), headers=_HEADERS)

  if req.status_code == requests.codes.ok:
    data = req.json()
    can = data["permitted"]
    cannot = data["forbidden"]
    must = data["required"]

  return can, cannot, must
844242
def get_function_help(function: str, bel_spec: BELSpec):
    

    function_long = bel_spec["functions"]["to_long"].get(function)
    function_help = []

    if function_long:
        for signature in bel_spec["functions"]["signatures"][function_long]["signatures"]:
            function_help.append(
                {
                    "function_summary": signature["argument_summary"],
                    "argument_help": signature["argument_help_listing"],
                    "description": bel_spec["functions"]["info"][function_long]["description"],
                }
            )

    return function_help
688670
public function getDescriptionRules()
    {
        $rules = [];
        if (is_string($this->descriptionAttribute) && !empty($this->descriptionAttribute)) {
            $rules[] = [
                [$this->descriptionAttribute],
                'string'
            ];
            $rules[] = [
                [$this->descriptionAttribute],
                'default',
                'value' => $this->initDescription,
            ];
        }
        return $rules;
    }
1198746
def get_workflow_info(func_list):
    """"""
    funcs = []
    for item in func_list:
        if item is None:
            continue
        if isinstance(item, list):
            funcs.append(get_workflow_info(item))
        else:
            funcs.append(get_func_info(item))
    return funcs