Convert allowed state transitions / target states to lowercase.
12690
def _dict_lower(dictionary: dict):
        """"""
        return {key.lower(): [value.lower() for value in value]
                for key, value in dictionary.items()}
759191
def string_to_transition(s):
    """"""
    from .machines import Transition
    s = lexer(s)
    lhs = parse_multiple(s, parse_store)
    if s.pos < len(s) and s.cur == "->":
        s.pos += 1
        rhs = parse_multiple(s, parse_store)
    else:
        rhs = ()
    parse_end(s)
    return Transition(lhs, rhs)
662658
def lowercase(self):
        
        if len(self.children) > 0:
            for child in self.children:
                child.lowercase()
        else:
            self.text = self.text.lower()
1287949
def to_mixed_case(s):
    
    out = ''
    last_c = ''
    for c in s:
        if c == '_':
            pass
        elif last_c in ('', '_'):
            out += c.upper()
        else:
            out += c.lower()
        last_c = c
    return out
774519
private static Transition makeTransitionToJsStringLiteral(
      String literal, final HtmlContext state) {
    return new Transition(literal) {
      @Override
      Context computeNextContext(Context prior, Matcher matcher) {
        return prior
            .toBuilder()
            .withState(state)
            .withSlashType(Context.JsFollowingSlash.NONE)
            .withUriPart(UriPart.NONE)
            .build();
      }
    };
  }
1004119
def levels_to_accepting_states(self) -> dict:
        """"""

        res = {accepting_state: 0 for accepting_state in self._accepting_states}
        level = 0

        # least fixpoint
        z_current, z_next = set(), set()
        z_next = set(self._accepting_states)

        while z_current != z_next:
            level += 1
            z_current = z_next
            z_next = copy(z_current)
            for state in self._transition_function:
                for action in self._transition_function[state]:
                    if state in z_current:
                        continue
                    next_state = self._transition_function[state][action]
                    if next_state in z_current:
                        z_next.add(state)
                        res[state] = level
                        break

        z_current = z_next
        for failure_state in filter(lambda x: x not in z_current, self._states):
            res[failure_state] = -1

        return res
1300696
function ( target ) {
            target = String( target );
            return target.replace( /[A-Z]/g, function ( val ) {
                return '-' + val.toLowerCase();
            });
        }
920530
private function toLowerChars($s)
    {
        $lowerFilter = new \Zend\Filter\StringToLower;
        $lowerFilter->setEncoding('utf-8');
        return $lowerFilter->filter($s);
    }
893148
function lowercase(arr) {
  var ret = new Array(arr.length);

  for (var i = 0; i < arr.length; ++i) {
    ret[i] = String(arr[i]).toLowerCase();
  }

  return ret;
}
1232047
def normal_case(name):
    """"""
    s1 = re.sub(r'(.)([A-Z][a-z]+)', r'\1 \2', name)
    return re.sub(r'([a-z0-9])([A-Z])', r'\1 \2', s1).lower()
473846
def humanize(lower_case_and_underscored_word)
      result = lower_case_and_underscored_word.to_s.dup
      inflections.humans.each { |(rule, replacement)| break if result.sub!(rule, replacement) }
      result.gsub!(/_id$/, "")
      result.tr!('_', ' ')
      result.gsub(/([a-z\d]*)/i) { |match|
        "#{inflections.acronyms[match] || match.downcase}"
      }.gsub(/^\w/) { $&.upcase }
    end
363196
function lowercaseFirstLetter(options) {
  const string = options.fn(this);
  return string.charAt(0).toLowerCase() + string.slice(1);
}
31761
public static String lowerCaseInternal(String s) {
        if (isNullOrEmpty(s)) {
            return s;
        }
        return s.toLowerCase(LOCALE_INTERNAL);
    }
709318
def state_not_literal(self, value):
        """"""
        value = negate = chr(value)
        while value == negate:
            value = choice(self.literals)
        yield value
92457
def humanize(lower_case_and_underscored_word)
      result = lower_case_and_underscored_word.to_s.dup

      inflections.humans.each { |(rule, replacement)| break if result.gsub!(rule, replacement) }
      result.gsub(/_id$/, "").gsub(/_/, " ").capitalize
    end
1161825
def try_int_or_force_to_lower_case(input_str: str) -> Union[int, str]:
    
    try:
        return int(input_str)
    except ValueError:
        return norm_fold(input_str)
78301
def convert_attrs_to_lowercase(obj: Any, attrs: Iterable[str]) -> None:
    
    for a in attrs:
        value = getattr(obj, a)
        if value is None:
            continue
        setattr(obj, a, value.lower())