Python abc.Hashable方法代码示例

# 需要导入模块: from collections import abc [as 别名]
# 或者: from collections.abc import Hashable [as 别名]
def __contains__(self, key):  # pylint:disable=too-many-return-statements
        "In a winding way, figures out if a key is in the KeyDict"
        try:
            key, idx = self.parse_and_index(key)
        except KeyError:
            return False
        except ValueError:  # multiple keys correspond
            return True
        if not isinstance(key, Hashable):
            return False
        if super().__contains__(key):  # pylint: disable=no-member
            if idx:
                try:
                    value = super().__getitem__(key)[idx]  # pylint: disable=no-member
                    return True if is_sweepvar(value) else not isnan(value)
                except TypeError:
                    raise TypeError("%s has an idx, but its value in this"
                                    " KeyDict is the scalar %s."
                                    % (key, super().__getitem__(key)))  # pylint: disable=no-member
                except IndexError:
                    raise IndexError("key %s with idx %s is out of bounds"
                                     " for value %s" %
                                     (key, idx, super().__getitem__(key)))  # pylint: disable=no-member
            return True
        return key in self.keymap 

# 需要导入模块: from collections import abc [as 别名]
# 或者: from collections.abc import Hashable [as 别名]
def test_Hashable(self):
        # Check some non-hashables
        non_samples = [bytearray(), list(), set(), dict()]
        for x in non_samples:
            self.assertNotIsInstance(x, Hashable)
            self.assertFalse(issubclass(type(x), Hashable), repr(type(x)))
        # Check some hashables
        samples = [None,
                   int(), float(), complex(),
                   str(),
                   tuple(), frozenset(),
                   int, list, object, type, bytes()
                   ]
        for x in samples:
            self.assertIsInstance(x, Hashable)
            self.assertTrue(issubclass(type(x), Hashable), repr(type(x)))
        self.assertRaises(TypeError, Hashable)
        # Check direct subclassing
        class H(Hashable):
            def __hash__(self):
                return super().__hash__()
        self.assertEqual(hash(H()), 0)
        self.assertFalse(issubclass(int, H))
        self.validate_abstract_methods(Hashable, '__hash__')
        self.validate_isinstance(Hashable, '__hash__') 

# 需要导入模块: from collections import abc [as 别名]
# 或者: from collections.abc import Hashable [as 别名]
def __call__(self, *args, **kw):
        if not isinstance(args, Hashable):
            # Uncacheable, a list, for instance.
            # Better to not cache than blow up.
            return self.func(*args)
        obj = args[0]
        try:
            cache = obj.__cache_meth
        except AttributeError:
            cache = obj.__cache_meth = {}
        key = (self.func, args[1:], frozenset(kw.items()))
        try:
            res = cache[key]
        except KeyError:
            res = cache[key] = self.func(*args, **kw)
        return res 

# 需要导入模块: from collections import abc [as 别名]
# 或者: from collections.abc import Hashable [as 别名]
def _validate_excludes(self, excluded_fields, field, value):
        """Ignore 'None' for excluded fields.

        Hopefully Cerberus allows this at some point in the future, then
        we can remove this.

        The rule's arguments are validated against this schema:
        {'type': ('hashable', 'list'),
         'schema': {'type': 'hashable'}}
        """
        if isinstance(excluded_fields, Hashable):
            excluded_fields = [excluded_fields]

        # Remove None fields and unrequire them
        not_none = []
        for excluded in excluded_fields:
            if self.document.get(excluded) is None:
                self._unrequired_by_excludes.add(excluded)
            else:
                not_none.append(excluded)

        return super()._validate_excludes(not_none, field, value) 

# 需要导入模块: from collections import abc [as 别名]
# 或者: from collections.abc import Hashable [as 别名]
def construct_mapping(self, node, deep=False):
        if isinstance(node, MappingNode):
            self.flatten_mapping(node)
        if not isinstance(node, MappingNode):
            raise ConstructorError(None, None,
                                   "expected a mapping node, but found %s" % node.id,
                                   node.start_mark)
        mapping = OrderedDict()
        for key_node, value_node in node.value:
            key = self.construct_object(key_node, deep=deep)
            if not isinstance(key, Hashable):
                raise ConstructorError("while constructing a mapping", node.start_mark,
                                       "found unhashable key", key_node.start_mark)
            value = self.construct_object(value_node, deep=deep)
            mapping[key] = value
        return mapping 

# 需要导入模块: from collections import abc [as 别名]
# 或者: from collections.abc import Hashable [as 别名]
def _freeze_init_parameters(class_, args, kwargs):
        self_guard = object()
        init_signature = signature(class_.__init__)
        bound_signature = init_signature.bind(self_guard, *args, **kwargs)
        arguments = [('class_.__name__', class_.__name__)]
        for name, value in bound_signature.arguments.items():
            if value == self_guard:
                continue
            if isinstance(value, Hashable):
                arguments.append((name, type(value), value))
            else:
                arguments.append((name, type(value), repr(value)))
        return frozenset(arguments) 

# 需要导入模块: from collections import abc [as 别名]
# 或者: from collections.abc import Hashable [as 别名]
def test_direct_subclassing(self):
        for B in Hashable, Iterable, Iterator, Sized, Container, Callable:
            class C(B):
                pass
            self.assertTrue(issubclass(C, B))
            self.assertFalse(issubclass(int, C)) 

# 需要导入模块: from collections import abc [as 别名]
# 或者: from collections.abc import Hashable [as 别名]
def test_registration(self):
        for B in Hashable, Iterable, Iterator, Sized, Container, Callable:
            class C:
                __hash__ = None  # Make sure it isn't hashable by default
            self.assertFalse(issubclass(C, B), B.__name__)
            B.register(C)
            self.assertTrue(issubclass(C, B)) 

# 需要导入模块: from collections import abc [as 别名]
# 或者: from collections.abc import Hashable [as 别名]
def __call__(self, func):
        def wrapper(*args, **kwargs):
            """

            :param *args:
            """
            key = self.key_mapper(*args) or args
            obj = args[0]

            if not hasattr(obj, '__memoized__'):
                try:
                    obj.__memoized__ = {}
                    instance_cache = obj.__memoized__
                except AttributeError:
                    if not hasattr(wrapper, '__memoized__'):
                        wrapper.__memoized__ = {}
                    instance_cache = wrapper.__memoized__
            else:
                try:
                    instance_cache = obj.__memoized__
                except AttributeError:
                    instance_cache = wrapper.__memoized__

            instance_cache[id(func)] = instance_cache.get(id(func), {})

            if not isinstance(key, collections.Hashable):
                # uncacheable. a list, for instance.
                # better to not cache than blow up.
                return func(*args)

            val = (instance_cache[id(func)][key]
                   if key in instance_cache[id(func)]
                   else func(*args))
            instance_cache[id(func)][key] = val
            return val

        return wrapper 

# 需要导入模块: from collections import abc [as 别名]
# 或者: from collections.abc import Hashable [as 别名]
def test_issubclass_hashable(bi_cls):
    """All hashable bidict types should implement :class:`collections.abc.Hashable`."""
    assert issubclass(bi_cls, Hashable) 

# 需要导入模块: from collections import abc [as 别名]
# 或者: from collections.abc import Hashable [as 别名]
def add(self, prop, values, cleaned=False, quiet=False):
        """Add the given value(s) to the property if they are not empty."""
        prop = self._get_prop(prop, quiet=quiet)
        if prop is None:
            return

        # Don't allow setting the reverse properties:
        if prop.stub:
            if quiet:
                return
            msg = gettext("Stub property (%s): %s")
            raise InvalidData(msg % (self.schema, prop))

        for value in ensure_list(values):
            if not cleaned:
                value = prop.type.clean(value, countries=self.countries)
            if value is None or not isinstance(value, Hashable):
                continue
            if prop.type == registry.entity and value == self.id:
                msg = gettext("Self-relationship (%s): %s")
                raise InvalidData(msg % (self.schema, prop))

            # Somewhat hacky: limit the maximum size of any particular
            # field to avoid overloading upstream aleph/elasticsearch.
            value_size = prop.type.values_size(value)
            if prop.type.max_size is not None:
                if self._size + value_size > prop.type.max_size:
                    # msg = "[%s] too large. Rejecting additional values."
                    # log.warning(msg, prop.name)
                    continue
            self._size += value_size

            if prop not in self._properties:
                self._properties[prop] = OrderedSet()
            self._properties[prop].add(value) 

# 需要导入模块: from collections import abc [as 别名]
# 或者: from collections.abc import Hashable [as 别名]
def __init__(self, *args, **kwargs):
        """Initialize."""

        arg = args[0] if args else kwargs
        is_dict = isinstance(arg, dict)
        if (
            is_dict and not all([isinstance(v, Hashable) for v in arg.values()]) or
            not is_dict and not all([isinstance(k, Hashable) and isinstance(v, Hashable) for k, v in arg])
        ):
            raise TypeError('All values must be hashable')

        self._d = dict(*args, **kwargs)
        self._hash = hash(tuple([(type(x), x, type(y), y) for x, y in sorted(self._d.items())])) 

# 需要导入模块: from collections import abc [as 别名]
# 或者: from collections.abc import Hashable [as 别名]
def get_cmdcls(self, cmdname, interface='ACTIVE', exclusive=False):
        """
        Resolve command name `cmdname` to command class

        If `interface` is 'ACTIVE', return command class from
        `active_commands`.

        If `interface` is 'ANY', return command class from `all_commands`.

        If `interface` is anything else, it must be an existing interface and
        only a command that supports it is returned.

        If `exclusive` evaluates to True, the returned command class does not
        support any other interfaces.

        Returns None if no matching command class is registered.
        """
        if interface == 'ACTIVE':
            cmdpool = self.active_commands
        elif interface == 'ANY':
            cmdpool = self.all_commands
        elif isinstance(interface, abc.Hashable):
            try:
                cmdpool = tuple(self._cmds[interface].values())
            except KeyError:
                raise ValueError('Unknown interface: {!r}'.format(interface))
        else:
            raise RuntimeError('Interface type must be hashable: {!r}'.format(interface))

        for cmd in cmdpool:
            if cmdname in cmd.names:
                if not exclusive:
                    return cmd
                elif cmd.provides == (interface,):
                    return cmd 

# 需要导入模块: from collections import abc [as 别名]
# 或者: from collections.abc import Hashable [as 别名]
def map_values(mapping, path, key, old_parent, new_parent, new_items):
    ret = default_exit(path, key, old_parent, new_parent, new_items)
    for k, v in ret.items():
        if isinstance(v, Hashable) and v in mapping:
            ret[k] = mapping[v]
    return ret 

# 需要导入模块: from collections import abc [as 别名]
# 或者: from collections.abc import Hashable [as 别名]
def __hash__(self):
        if isinstance(self._mapping, Hashable):
            return hash(self._mapping)
        else:
            return hash(frozenset(self._mapping.keys()))