|coro|

        Gets the operators index from the operator definitions dict

        Returns
        -------
        str
            the operator index
966713
def get_operator_index(self, name):
        """"""
        opdefs = yield from self.get_operator_definitions()

        name = name.lower()
        if name not in opdefs:
            return None

        return opdefs[name]["index"]
1026500
def _match_operator(self, p, value):
        
        if p[0] == '!':
            return self._OPERATOR_MAP[p[0]](self._match(p[1], value))
        elif p[0] == '^':
            return self._OPERATOR_MAP[p[0]](self._match(p[1][0], value), self._match(p[1][1], value))
        else:
            return self._OPERATOR_MAP[p[0]]([self._match(operator_or_filter, value) for operator_or_filter in p[1]])
645373
def unary_operator(op):
    
    # Only negate is currently supported.
    valid_ops = {'-'}
    if op not in valid_ops:
        raise ValueError("Invalid unary operator %s." % op)

    @with_doc("Unary Operator: '%s'" % op)
    @with_name(unary_op_name(op))
    def unary_operator(self):
        if self.dtype != float64_dtype:
            raise TypeError(
                "Can't apply unary operator {op!r} to instance of "
                "{typename!r} with dtype {dtypename!r}.\n"
                "{op!r} is only supported for Factors of dtype "
                "'float64'.".format(
                    op=op,
                    typename=type(self).__name__,
                    dtypename=self.dtype.name,
                )
            )

        # This can't be hoisted up a scope because the types returned by
        # unary_op_return_type aren't defined when the top-level function is
        # invoked.
        if isinstance(self, NumericalExpression):
            return NumExprFactor(
                "{op}({expr})".format(op=op, expr=self._expr),
                self.inputs,
                dtype=float64_dtype,
            )
        else:
            return NumExprFactor(
                "{op}x_0".format(op=op),
                (self,),
                dtype=float64_dtype,
            )
    return unary_operator
699146
def one_symbol_ops_str(self) -> str:
        """"""
        return re.escape(''.join((key for key in self.ops.keys() if len(key) == 1)))
533402
def dict(self):
    ''''''
    d = dict()
    d['key'] = str(self.key)

    if self.limit is not None:
      d['limit'] = self.limit
    if self.offset > 0:
      d['offset'] = self.offset
    if self.offset_key:
      d['offset_key'] = str(self.offset_key)
    if len(self.filters) > 0:
      d['filter'] = [[f.field, f.op, f.value] for f in self.filters]
    if len(self.orders) > 0:
      d['order'] = [str(o) for o in self.orders]

    return d
328250
def get(self, using=None, **kwargs):
        
        return self._get_connection(using).indices.get(index=self._name, **kwargs)
417123
def get_indices():
    
    doc = BeautifulSoup(urlopen(BASEURL))

    divs = doc.select('.indices_txt')
    if not divs:
        return None

    sibling = divs[1].nextSibling
    if not sibling:
        return None

    data = sibling.nextSibling
    if not data:
        return None

    # the indices are in an HTML comment
    data = BeautifulSoup(data)

    divs = data.select('.selected')
    return map(lambda d: int(d.text), divs)
685445
def get_op_symbol(obj, fmt='%s', symbol_data=symbol_data, type=type):
    
    return fmt % symbol_data[type(obj)]
845686
def to_dict(self):
        """"""
        raw_conditions = []
        for condition in self.conditions:
            if isinstance(condition, (Condition, Group)):
                raw_conditions.append(condition.to_dict())
            else:
                raw_conditions.append(condition)
        return {self.operator: raw_conditions}
1307722
def _get_index(self):
        
        glyph = self.glyph
        if glyph is None:
            return None
        return glyph.anchors.index(self)
1128634
def index_of_lowest_precedence(operators,associativity=:left)
    lowest = lowest_precedence = nil
    operators.each_with_index do |operator,i|
      operator_string = operator.to_s
      precedence = operator_precedence(operator_string)
      right_associative = @right_operators_regexp && operator_string[@right_operators_regexp]
      if !lowest || (right_associative ? precedence < lowest_precedence : precedence <= lowest_precedence)
        lowest = i
        lowest_precedence = precedence
      end
    end
    lowest
  end
1187827
def operator(self, operatorType, value):
        
        if value is None:
            if 'is none' in self._operatorMap and operatorType == Query.Op.Is:
                return 'is none'
            elif 'is not none' in self._operatorMap:
                return 'is not none'
            
        for op, data in self._operatorMap.items():
            if data.op == operatorType:
                return op
        return ''
155903
function processOperators (ops) {
    if (!ops) return {};
    var operators = {};
    for (var i=0,k,prec;prec=ops[i]; i++) {
        for (k=1;k < prec.length;k++) {
            operators[prec[k]] = {precedence: i+1, assoc: prec[0]};
        }
    }
    return operators;
}
1144641
def as_dict(self):
        
        return {self.FLD_OP: self._op.name,
                self.FLD_MARK: self._pos,
                self.FLD_FLD: self._fld}
678982
def inverse(self):
        
        return OperatorComp(self.right.inverse, self.left.inverse,
                            self.__tmp)
330730
def getIndexedValue(self, index):
        
        actions = self._actions

        if (type (actions) is list):
            dict = actions[index]
        else:
            dict = actions
        return dict.get('value', 'NoValue')
1364612
def get_dict(cls):
        
        mdt = cls.get()

        if not mdt:
            return {}

        return conspectus.subs_by_mdt.get(mdt, {})