NOT REQUIRED, EXISTS AS OPPOSITE OF not_right()
12444
def not_left(self, num):
        
        if num == None:
            return FlatList([_get_list(self)[-1]])
        if num <= 0:
            return self

        return FlatList(_get_list(self)[num::])
121242
public static <D> Predicate notIn(Expression<D> left, SubQueryExpression<? extends D> right) {
        return predicate(Ops.NOT_IN, left, right);
    }
53853
def Not(a: Bool) -> Bool:
    
    return Bool(z3.Not(a.raw), a.annotations)
668464
def logical_not(f):  # function factory
    '''
    '''
    def f_not(arr):
        return np.logical_not(f(arr))
    f_not.__name__ = "not_" + f.__name__
    return f_not
847875
def otherwise(first, second)
      first = first.to_s
      first.empty? ? second : first
    end
1164161
def not_implemented(self, func_name):
        '''
        
        '''
        msg = '%s is not overridden by %s' % (func_name, type(self).__name__)
        self.logger.error(msg)
        raise NotImplementedError(msg)
792922
def logical_not(f):  # function factory
    '''
    '''
    def f(value):
        return np.logical_not(f(value))
    f.__name__ = "not_" + f.__name__
    return f
1189294
def ok(no_exit, func, *args, **kwargs):
    """"""
    ret = func(*args, **kwargs)
    if no_exit or ret >= 0:
        return ret
    reason = errmsg[abs(ret)]
    error('{0}() returned {1} ({2})'.format(func.__name__, ret, reason))
481299
def assert_gt(left, right, message=None, extra=None):
    """"""
    assert left > right, _assert_fail_message(message, left, right, "<=", extra)
147310
def right(ctx, text, num_chars):
    
    num_chars = conversions.to_integer(num_chars, ctx)
    if num_chars < 0:
        raise ValueError("Number of chars can't be negative")
    elif num_chars == 0:
        return ''
    else:
        return conversions.to_string(text, ctx)[-num_chars:]
621663
def excepts(cls):
        
        if cls._excepts is None:
            cls._excepts = tuple(cls.translations.keys())
        return cls._excepts
558247
def bsp_right(node: tcod.bsp.BSP) -> Optional[tcod.bsp.BSP]:
    
    return None if not node.children else node.children[1]
622075
def _notin(expr, values):
    

    if isinstance(expr, SequenceExpr):
        return NotIn(_input=expr, _values=values, _data_type=types.boolean)
    elif isinstance(expr, Scalar):
        return NotIn(_input=expr, _values=values, _value_type=types.boolean)
1173442
public static <D> Predicate notIn(Expression<D> left, Collection<? extends D> right) {
        if (right.size() == 1) {
            return neConst(left, right.iterator().next());
        } else {
            return predicate(Ops.NOT_IN, left, ConstantImpl.create(right));
        }
    }
391404
def contained_by(self, *args):
        
        self.op = '<@'
        self.negate_op = None
        self.value = self._array_value(args)
        return self
1362373
def trim_nones_from_right(xs):
    
    # Find the first element that does not contain none.
    for i, item in enumerate(reversed(xs)):
        if item is not None:
            break

    return xs[:-i]
1349433
def iterright(self):
        '''
        
        '''
        offs = 1
        while True:

            sibl = self.sibling(offs)
            if sibl is None:
                break

            yield sibl
            offs += 1