Soft assert for whether the is not an instance of cls

        :params obj: the object instance
        :params cls: the class to compare against
        :params msg: (Optional) msg explaining the difference
779779
def verify_is_not_instance(self, obj, cls, msg=""):
        
        try:
            self.assert_is_not_instance(obj, cls, msg)
        except AssertionError, e:
            if msg:
                m = "%s:\n%s" % (msg, str(e))
            else:
                m = str(e)
            self.verification_erorrs.append(m)
363812
def Instance(expected, message="Not an instance of {}"):
    
    @wraps(Instance)
    def built(value):
        if not isinstance(value, expected):
            raise Error(message.format(expected.__name__))
        return value
    return built
1080035
function isInstanceOf(value, expectedInstance, message, id) {
    if (message === void 0) { message = ''; }
    if (id === void 0) { id = ''; }
    if (this.enabled && !(value instanceof expectedInstance)) {
        throw ValueException.unexpectedValue(assertionTypes.INSTANCE_OF, value, expectedInstance, message, id);
    }
}
125170
def isseq(obj):
  '''
  
  '''
  return \
    not isstr(obj) \
    and not isdict(obj) \
    and ( isinstance(obj, (list, tuple)) \
          or callable(getattr(obj, '__iter__', None)))
494441
def is_module(obj):
    
    return True if obj and isinstance(obj, ModuleType) or inspect.isclass(obj) else False
860522
def get_is_notification(self, obj):
        
        try:
            o = compat_serializer_attr(self, obj)
            return o.is_notification
        except Exception:
            return False
57036
public boolean isInstanceOf(Object obj, Class<?> clz) {
        if (obj == null || clz == null) {
            if (log.isLoggable(Level.FINEST)) {
                log.finest("isInstanceOf error: obj=" + obj + " clz=" + clz);
            }
            return false;
        }
        return clz.isInstance(obj);
    }
79984
def is_iterable_but_not_string(obj):
    
    return hasattr(obj, '__iter__') and not isinstance(obj, str) and not isinstance(obj, bytes)
712770
def call_orig(self, *args, **kwargs):
        '''
        
        '''
        if hasattr(self._obj, '__self__') and \
                inspect.isclass(self._obj.__self__) and \
                self._obj.__self__ is self._instance:
            return self._obj.__func__(self._instance, *args, **kwargs)
        elif hasattr(self._obj, 'im_self') and \
                inspect.isclass(self._obj.im_self) and \
                self._obj.im_self is self._instance:
            return self._obj.im_func(self._instance, *args, **kwargs)
        else:
            return self._obj(*args, **kwargs)
206677
async def message(self, msg, msg_type=None, obj=None):
        
        elem_type = msg_type if msg_type is not None else msg.__class__
        obj = collections.OrderedDict() if not x.has_elem(obj) else x.get_elem(obj)

        if hasattr(elem_type, 'kv_serialize'):
            msg = elem_type() if msg is None else msg
            return await msg.kv_serialize(self, obj=obj)

        fields = elem_type.f_specs()
        for field in fields:
            await self.message_field(msg=msg, field=field, obj=obj)

        return obj if self.writing else msg
1291454
def difference(self, *args):
        
        setobj = set(self.obj)
        for i, v in enumerate(args):
            setobj = setobj - set(args[i])
        return self._wrap(self._clean._toOriginal(setobj))
877212
def is_simple_callable(obj):
    
    function = inspect.isfunction(obj)
    method = inspect.ismethod(obj)

    if not (function or method):
        return False

    args, _, _, defaults = inspect.getargspec(obj)
    len_args = len(args) if function else len(args) - 1
    len_defaults = len(defaults) if defaults else 0
    return len_args <= len_defaults
1294492
def as_pseudo(cls, obj):
        
        return obj if isinstance(obj, cls) else cls.from_file(obj)
1352903
def isdict(obj):
  '''
  
  '''
  return \
    not isstr(obj) \
    and ( isinstance(obj, dict) \
          or ( callable(getattr(obj, 'keys', None)) \
               and callable(getattr(obj, 'values', None)) \
               and callable(getattr(obj, 'items', None)) ))
650054
def validate(self, obj):
        
        if not isinstance(obj, self.internal_type):
            raise ValidationError(obj, self.internal_type)
        return True
611002
def object_isinstance(node, class_or_seq, context=None):
    
    obj_type = object_type(node, context)
    if obj_type is util.Uninferable:
        return util.Uninferable
    return _object_type_is_subclass(obj_type, class_or_seq, context=context)
127133
def is_text(obj, name=None):
    
    try:  # python2
        ans = isinstance(obj, basestring)
    except NameError:  # python3
        ans = isinstance(obj, str)
    if name:
        print("is_text: (%s) %s = %s" % (ans, name, obj.__class__),
              file=sys.stderr)
    return ans