915948437

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/zopefoundation/BTrees/commit/<a class=hub.com/zopefoundation/BTrees/commit/<a class="double-link" href="https://git"><a class=hub.com/zopefoundation/BTrees/commit/<a class="double-link" href="https://git"><a class=hub.com/zopefoundation/BTrees/commit/65572a9d8153216b5489bdf1ba9d658ee1ba5e1d">65572a9d8<a href="https://github.com/zopefoundation/BTrees/commit/65572a9d8153216b5489bdf1ba9d658ee1ba5e1d">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/zopefoundation/BTrees/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/zopefoundation/BTrees/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/zopefoundation/BTrees/commit/65572a9d8153216b5489bdf1ba9d658ee1ba5e1d&quot;&gt;65572a9d8&lt;/a&gt;&lt;a href=&quot;https://github.com/zopefoundation/BTrees/commit/65572a9d8153216b5489bdf1ba9d658ee1ba5e1d&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/zopefoundation/BTrees/commit/65572a9d8153216b5489bdf1ba9d658e&lt;/a&gt;e1ba5e1d&quot;>&quot;&gt;Merge &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/zopefoundation/BTrees/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/zopefoundation/BTrees/commit/<a class="double-link" href="https://github.com/zopefoundation/BTrees/commit/55ee25f315953686328e13f906dc3cb7467f001c">55ee25f31</a><a href="https://github.com/zopefoundation/BTrees/commit/65572a9d8153216b5489bdf1ba9d658ee1ba5e1d">&amp;quot;&amp;gt;55ee25f31&amp;lt;/a&amp;gt;&amp;quot;&amp;gt;55ee25f31&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/zopefoundation/BTrees/commit/65572a9d8153216b5489bdf1ba9d658ee1ba5&lt;/a&gt;e1d&quot;&gt; into &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/zopefoundation/BTrees/commit/<a class="double-link" href="https://github.com/zopefoundation/BTrees/commit/a59cb8c00">a59cb8c00">a59cb8c00</a>

Pull Request Pull Request #172: Fix issue 170

Run Details

681 of 686 new or added lines in 8 files covered. (99.27%)

8193 of 8275 relevant lines covered (99.01%)

5.9 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

93.36

/src/BTrees/_datatypes.py

##############################################################################
#
# Copyright Zope Foundation and Contributors.
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE.
#
##############################################################################
"""
Descriptions of the datatypes supported by this package.
"""
from __future__ import absolute_import

from operator import index as object_to_index
from struct import Struct
from struct import error as struct_error

try:
    from abc import ABC
except ImportError:
    # Python < 3.4 (specifically, Python 2)
    from abc import ABCMeta
    ABC = ABCMeta('ABC', (object,), {})

from ._compat import int_types
from .utils import Lazy


class DataType(object):
    """
    Describes a data type used as a value.

    Subclasses will be defined for each particular
    supported type.
    """

    # The name for this datatype as used in interface names.
    long_name = None

    # The prefix code for this data type. Usually a single letter.
    prefix_code = None

    # The multiplication identity for this data type. Used in
    # combining (merging) data types. Leave undefined if this is
    # not a valid operation.
    multiplication_identity = None

    # Does the data take up 64-bits? Currently only relevant for the
    # integer key types.
    using64bits = False

    def __init__(self):
        if not self.prefix_code:
            self.prefix_code = type(self).__name__

    def __call__(self, item):
        """
        Verify *item* is in the correct format (or "close" enough)
        and return the item or its suitable conversion.

        If this cannot be done, raise a :exc:`TypeError`.

        The definition of "close" varies according to the datatypes.
        For example, integer datatypes will accept anything that can
        be converted into an integer using normal python coercion
        rules (calling ``__index__``) and where the integer fits into
        the required native type size (e.g., 4 bytes).
        """
        raise NotImplementedError

    def coerce(self, item):
        """
        Coerce *item* into something that can be used with
        ``__call__`` and return it.

        The coercion rules will vary by datatype. This exists only
        for test cases. The default is to perform the same validation
        as ``__call__``.
        """
        return self(item)

    def apply_weight(self, item, weight): # pylint:disable=unused-argument
        """
        Apply a *weight* multiplier to *item*.

        Used when merging data structures. The *item* will be a
        value.
        """
        return item

    def as_value_type(self):
        # Because ``O'`` is used for both key and value,
        # we can override this to get the less restrictive value type.
        return self

    def supports_value_union(self):
        raise NotImplementedError

    def getTwoExamples(self):
        """
        Provide two distinct (non equal) examples acceptable to `__call__`.

        This is for testing.
        """
        return "object1", "object2"

    def get_lower_bound(self):
        """
        If there is a lower bound (inclusive) on the data type, return
        it. Otherwise, return ``None``.

        For integer types, this will only depend on whether it
        supports signed or unsigned values, and the answer will be 0
        or a negative number. For object types, ``None`` is always
        defined to sort as the lowest bound.

        This can be relevant for both key and value types.
        """
        return None

    def get_upper_bound(self):
        """
        If there is an upper bound (inclusive) on the data type,
        return it. Otherwise, return ``None``.

        Remarks are as for `get_lower_bound`.
        """
        return None

    def add_extra_methods(self, base_name, cls):
        """
        Called on the key type to add additional, non-standard methods, to
        a class.

        *base_name* will be a string with no prefix, such as 'Bucket' or 'BTree'.
        """


class KeyDataType(DataType):
    """
    Describes a data type that has additional restrictions allowing it
    to be used as a key.
    """

    # When used as the key, this number determines the
    # max_internal_size.
    tree_size = 500

    default_bucket_size = 120

    def __call__(self, item):
        raise NotImplementedError

    def bucket_size_for_value(self, value_type):
        """
        What should the bucket (``max_leaf_size``) be when
        this data type is used with the given *value_type*?
        """
        if isinstance(value_type, Any):
            return self.default_bucket_size // 2
        return self.default_bucket_size


class Any(DataType):
    """
    Arbitrary Python objects.
    """
    prefix_code = 'O'
    long_name = 'Object'

    def __call__(self, item):
        return item

    def supports_value_union(self):
        return False



class _HasDefaultComparison(ABC):
    """
    An `ABC <https://docs.python.org/3/library/abc.html>_` for
    checking whether an item has default comparison.

    All we have to do is override ``__subclasshook__`` to implement an
    algorithm determining whether a class has default comparison.
    Python and the ABC machinery will take care of translating
    ``isinstance(thing, _HasDefaultComparison)`` into something like
    ``_HasDefaultComparison.__subclasshook__(type(thing))``. The ABC
    handles caching the answer (based on exact classes, no MRO), and
    getting the type from ``thing`` (including mostly dealing with
    old-style) classes on Python 2.
    """

    # Comparisons only use special methods defined on the
    # type, not instance variables.

    # On CPython 2, every subclass of object inherits __lt__
    # (unless it overrides), and it has ``__objclass__`` of ``type``
    # (of course it is also the same object as ``_object_lt`` at
    # that point). Also, interestingly, CPython 2 classes inherit
    # ``__lt__`` from ``type``, but *instances* do not.
    #
    # On CPython 3, classes inherit __lt__ with ``__objclass__`` of ``object``.
    # On PyPy2, classes don't inherit any __lt__.
    # On PyPy3, they do.
    #
    # Test these conditions at runtime and define the method variant
    # appropriately.
    #
    # Remember the method is checking if the object has default comparison
    assert '__lt__' not in DataType.__dict__
    if hasattr(DataType, '__lt__'):
        # CPython 2 or CPython 3 or PyPy3
        if getattr(DataType.__lt__, '__objclass__', None) is object:
            # CPython 3
            @classmethod
            def __subclasshook__(cls, C, _NoneType=type(None)):
                if C is _NoneType:
                    return False
                defining_class = getattr(C.__lt__, '__objclass__', None)
                if defining_class is None:
                    # Implemented in Python
                    return False
                return C.__lt__.__objclass__ is object
        elif getattr(DataType.__lt__, '__objclass__', None) is type:
            # CPython 2
            @classmethod
            def __subclasshook__(cls, C, _NoneType=type(None)):
                if C is _NoneType:
                    return False
                # If C is an old-style class, it may not even have __lt__
                if isinstance(C, type):
                    lt = C.__lt__
                else:
                    lt = getattr(C, '__lt__', None)
                if lt is not None:
                    defining_class = getattr(lt, '__objclass__', None)
                    if defining_class is None:
                        # Implemented in Python
                        return False
                    if defining_class is not type:
                        return False
                return not hasattr(C, '__cmp__')
        else:
            # PyPy3
            @classmethod
            def __subclasshook__(cls, C, _object_lt=object.__lt__, _NoneType=type(None)):
                if C is _NoneType:
                    return False
                return C.__lt__ is _object_lt
    else:
        # PyPy2
        @classmethod
        def __subclasshook__(cls, C, _NoneType=type(None)):
            if C is _NoneType:
                return False
            return not hasattr(C, '__lt__') and not hasattr(C, '__cmp__')


class O(KeyDataType):
    """
    Arbitrary (sortable) Python objects.
    """
    long_name = 'Object'
    tree_size = 250
    default_bucket_size = 60

    def as_value_type(self):
        return Any()

    def supports_value_union(self):
        return False

    def __call__(self, item):
        if isinstance(item, _HasDefaultComparison):
            raise TypeError("Object of class %s has default comparison" % (type(item).__name__,))
        return item


class _AbstractNativeDataType(KeyDataType):
    """
    Uses `struct.Struct` to verify that the data can fit into a native
    type.
    """

    _struct_format = None
    _as_python_type = NotImplementedError
    _required_python_type = object
    _error_description = None
    _as_packable = object_to_index # obj.__index__ -> produce integer

    @Lazy
    def _check_native(self):
        return Struct(self._struct_format).pack

    def __call__(self, item):
        try:
            self._check_native(self._as_packable(item)) # pylint:disable=too-many-function-args
        except (struct_error, TypeError, ValueError):
            # PyPy can raise ValueError converting a negative number to a
            # unsigned value.
            if isinstance(item, int_types):
                raise TypeError("Value out of range", item)
            raise TypeError(self._error_description)

        return self._as_python_type(item)

    def apply_weight(self, item, weight):
        return item * weight

    def supports_value_union(self):
        return True

class _AbstractIntDataType(_AbstractNativeDataType):
    _as_python_type = int
    _required_python_type = int_types
    multiplication_identity = 1
    long_name = "Integer"

    def getTwoExamples(self):
        return 1, 2

    # On Python 2, it's important for these values to be actual `int`
    # values, not `long` when they fit; passing a value that's too big
    # to `int` will still result in it being a `long`. For some reason
    # on Windows, even the 32-bit values somehow wind up as longs
    # unless we do the conversion.
    def get_lower_bound(self):
        exp = 64 if self.using64bits else 32
        exp -= 1
        return int(-(2 ** exp))

    def get_upper_bound(self):
        exp = 64 if self.using64bits else 32
        exp -= 1
        return int(2 ** exp - 1)


class _AbstractUIntDataType(_AbstractIntDataType):
    long_name = 'Unsigned'

    def get_lower_bound(self):
        return 0

    def get_upper_bound(self):
        exp = 64 if self.using64bits else 32
        return int(2 ** exp - 1)


class I(_AbstractIntDataType):
    _struct_format = 'i'
    _error_description = "32-bit integer expected"


class U(_AbstractUIntDataType):
    _struct_format = 'I'
    _error_description = 'non-negative 32-bit integer expected'


class F(_AbstractNativeDataType):
    _struct_format = 'f'
    _as_python_type = float
    _error_description = 'float expected'
    _as_packable = lambda self, k: k # identity
    multiplication_identity = 1.0
    long_name = 'Float'

    def getTwoExamples(self):
        return 0.5, 1.5

class L(_AbstractIntDataType):
    _struct_format = 'q'
    _error_description = '64-bit integer expected'
    using64bits = True


class Q(_AbstractUIntDataType):
    _struct_format = 'Q'
    _error_description = 'non-negative 64-bit integer expected'
    using64bits = True


class _AbstractBytes(KeyDataType):
    """
    An exact-length byte string type.

    This must be subclassed to provide the actual byte length.
    """
    __slots__ = ()
    tree_size = 500
    default_bucket_size = 500

    def __init__(self, length):
        super(_AbstractBytes, self).__init__()
        self._length = length

    def __call__(self, item):
        if not isinstance(item, bytes) or len(item) != self._length:
            raise TypeError("%s-byte array expected, not %r" % (self._length, item))
        return item

    def supports_value_union(self):
        return False


class f(_AbstractBytes):
    """
    The key type for an ``fs`` tree.

    This is a two-byte prefix of an overall 8-byte value
    like a ZODB object ID or transaction ID.
    """

    # Our keys are treated like integers; the module
    # implements IIntegerObjectBTreeModule
    long_name = 'Integer'
    prefix_code = 'f'

    def __init__(self):
        _AbstractBytes.__init__(self, 2)

    def supports_value_union(self):
        # We don't implement 'multiunion' for fsBTree.
        return False

    # Check it can be converted to a two-byte
    # value. Note that even though we allow negative values
    # that can break test assumptions: -1 < 0 < 1, but the byte
    # values for those are \xff\xff > \x00\x00 < \x00\x01.
    _as_2_bytes = Struct('>h').pack

    def coerce(self, item):
        try:
            return self(item)
        except TypeError:
            try:
                return self._as_2_bytes(object_to_index(item))
            except struct_error as e:
                raise TypeError(e)

    def make_toString(self):
        def toString(self):
            return b''.join(self._keys) + b''.join(self._values)
        return toString

    def make_fromString(self):
        def fromString(self, v):
            length = len(v)
            if length % 8 != 0:
                raise ValueError()
            count = length // 8
            keys, values = v[:count*2], v[count*2:]
            self.clear()
            while keys and values:
                key, keys = keys[:2], keys[2:]
                value, values = values[:6], values[6:]
                self._keys.append(key)
                self._values.append(value)
            return self
        return fromString

    def add_extra_methods(self, base_name, cls):
        if base_name == 'Bucket':
            cls.toString = self.make_toString()
            cls.fromString = self.make_fromString()

class s(_AbstractBytes):
    """
    The value type for an ``fs`` tree.

    This is a 6-byte suffix of an overall 8-byte value
    like a ZODB object ID or transaction ID.
    """

    # Our values are treated like objects; the
    # module implements IIntegerObjectBTreeModule
    long_name = 'Object'
    prefix_code = 's'


    def __init__(self):
        _AbstractBytes.__init__(self, 6)

    def supports_value_union(self):
        return False

    def get_lower_bound(self):
        # Negative values have the high bit set, which is incompatible
        # with our transformation.
        return 0

    # To coerce an integer, as used in tests, first convert to 8 bytes
    # in big-endian order, then ensure the first two
    # are 0 and cut them off.
    _as_8_bytes = Struct('>q').pack

    def coerce(self, item):
        try:
            return self(item)
        except TypeError:
            try:
                as_bytes = self._as_8_bytes(object_to_index(item))
            except struct_error as e:
                raise TypeError(e)

            if as_bytes[:2] != b'\x00\x00':
                raise TypeError("Cannot convert %r to 6 bytes (%r)" % (item, as_bytes))
            return as_bytes[2:]

1	##############################################################################
2	#
3	# Copyright Zope Foundation and Contributors.
4	# All Rights Reserved.
5	#
6	# This software is subject to the provisions of the Zope Public License,
7	# Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution.
8	# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
9	# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
10	# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
11	# FOR A PARTICULAR PURPOSE.
12	#
13	##############################################################################
14	"""	6✔
15	Descriptions of the datatypes supported by this package.
16	"""
17	from __future__ import absolute_import	6✔
18
19	from operator import index as object_to_index	6✔
20	from struct import Struct	6✔
21	from struct import error as struct_error	6✔
22
23	try:	6✔
24	from abc import ABC	6✔
25	except ImportError:	1✔
26	# Python < 3.4 (specifically, Python 2)
27	from abc import ABCMeta	1✔
28	ABC = ABCMeta('ABC', (object,), {})	1✔
29
30	from ._compat import int_types	6✔
31	from .utils import Lazy	6✔
32
33
34	class DataType(object):	6✔
35	"""
36	Describes a data type used as a value.
37
38	Subclasses will be defined for each particular
39	supported type.
40	"""
41
42	# The name for this datatype as used in interface names.
43	long_name = None	6✔
44
45	# The prefix code for this data type. Usually a single letter.
46	prefix_code = None	6✔
47
48	# The multiplication identity for this data type. Used in
49	# combining (merging) data types. Leave undefined if this is
50	# not a valid operation.
51	multiplication_identity = None	6✔
52
53	# Does the data take up 64-bits? Currently only relevant for the
54	# integer key types.
55	using64bits = False	6✔
56
57	def __init__(self):	6✔
58	if not self.prefix_code:	6✔
59	self.prefix_code = type(self).__name__	6✔
60
61	def __call__(self, item):	6✔
62	"""
63	Verify item is in the correct format (or "close" enough)
64	and return the item or its suitable conversion.
65
66	If this cannot be done, raise a :exc:`TypeError`.
67
68	The definition of "close" varies according to the datatypes.
69	For example, integer datatypes will accept anything that can
70	be converted into an integer using normal python coercion
71	rules (calling ``__index__``) and where the integer fits into
72	the required native type size (e.g., 4 bytes).
73	"""
74	raise NotImplementedError	×
75
76	def coerce(self, item):	6✔
77	"""
78	Coerce item into something that can be used with
79	``__call__`` and return it.
80
81	The coercion rules will vary by datatype. This exists only
82	for test cases. The default is to perform the same validation
83	as ``__call__``.
84	"""
85	return self(item)	6✔
86
87	def apply_weight(self, item, weight): # pylint:disable=unused-argument	6✔
88	"""
89	Apply a weight multiplier to item.
90
91	Used when merging data structures. The item will be a
92	value.
93	"""
94	return item	×
95
96	def as_value_type(self):	6✔
97	# Because ``O'`` is used for both key and value,
98	# we can override this to get the less restrictive value type.
99	return self	6✔
100
101	def supports_value_union(self):	6✔
102	raise NotImplementedError	×
103
104	def getTwoExamples(self):	6✔
105	"""
106	Provide two distinct (non equal) examples acceptable to `__call__`.
107
108	This is for testing.
109	"""
110	return "object1", "object2"	6✔
111
112	def get_lower_bound(self):	6✔
113	"""
114	If there is a lower bound (inclusive) on the data type, return
115	it. Otherwise, return ``None``.
116
117	For integer types, this will only depend on whether it
118	supports signed or unsigned values, and the answer will be 0
119	or a negative number. For object types, ``None`` is always
120	defined to sort as the lowest bound.
121
122	This can be relevant for both key and value types.
123	"""
124	return None	6✔
125
126	def get_upper_bound(self):	6✔
127	"""
128	If there is an upper bound (inclusive) on the data type,
129	return it. Otherwise, return ``None``.
130
131	Remarks are as for `get_lower_bound`.
132	"""
133	return None	6✔
134
135	def add_extra_methods(self, base_name, cls):	6✔
136	"""
137	Called on the key type to add additional, non-standard methods, to
138	a class.
139
140	base_name will be a string with no prefix, such as 'Bucket' or 'BTree'.
141	"""
142
143
144	class KeyDataType(DataType):	6✔
145	"""
146	Describes a data type that has additional restrictions allowing it
147	to be used as a key.
148	"""
149
150	# When used as the key, this number determines the
151	# max_internal_size.
152	tree_size = 500	6✔
153
154	default_bucket_size = 120	6✔
155
156	def __call__(self, item):	6✔
157	raise NotImplementedError	×
158
159	def bucket_size_for_value(self, value_type):	6✔
160	"""
161	What should the bucket (``max_leaf_size``) be when
162	this data type is used with the given value_type?
163	"""
164	if isinstance(value_type, Any):	6✔
165	return self.default_bucket_size // 2	6✔
166	return self.default_bucket_size	6✔
167
168
169	class Any(DataType):	6✔
170	"""
171	Arbitrary Python objects.
172	"""
173	prefix_code = 'O'	6✔
174	long_name = 'Object'	6✔
175
176	def __call__(self, item):	6✔
177	return item	6✔
178
179	def supports_value_union(self):	6✔
180	return False	6✔
181
182
183
184	class _HasDefaultComparison(ABC):	6✔
185	"""
186	An `ABC <https://docs.python.org/3/library/abc.html>_` for
187	checking whether an item has default comparison.
188
189	All we have to do is override ``__subclasshook__`` to implement an
190	algorithm determining whether a class has default comparison.
191	Python and the ABC machinery will take care of translating
192	``isinstance(thing, _HasDefaultComparison)`` into something like
193	``_HasDefaultComparison.__subclasshook__(type(thing))``. The ABC
194	handles caching the answer (based on exact classes, no MRO), and
195	getting the type from ``thing`` (including mostly dealing with
196	old-style) classes on Python 2.
197	"""
198
199	# Comparisons only use special methods defined on the
200	# type, not instance variables.
201
202	# On CPython 2, every subclass of object inherits __lt__
203	# (unless it overrides), and it has ``__objclass__`` of ``type``
204	# (of course it is also the same object as ``_object_lt`` at
205	# that point). Also, interestingly, CPython 2 classes inherit
206	# ``__lt__`` from ``type``, but instances do not.
207	#
208	# On CPython 3, classes inherit __lt__ with ``__objclass__`` of ``object``.
209	# On PyPy2, classes don't inherit any __lt__.
210	# On PyPy3, they do.
211	#
212	# Test these conditions at runtime and define the method variant
213	# appropriately.
214	#
215	# Remember the method is checking if the object has default comparison
216	assert '__lt__' not in DataType.__dict__	6✔
217	if hasattr(DataType, '__lt__'):	6✔
218	# CPython 2 or CPython 3 or PyPy3
219	if getattr(DataType.__lt__, '__objclass__', None) is object:	6✔
220	# CPython 3
221	@classmethod	5✔
222	def __subclasshook__(cls, C, _NoneType=type(None)):	5✔
223	if C is _NoneType:	5✔
224	return False	5✔
225	defining_class = getattr(C.__lt__, '__objclass__', None)	5✔
226	if defining_class is None:	5✔
227	# Implemented in Python
228	return False	5✔
229	return C.__lt__.__objclass__ is object	5✔
230	elif getattr(DataType.__lt__, '__objclass__', None) is type:	1✔
231	# CPython 2
232	@classmethod	1✔
233	def __subclasshook__(cls, C, _NoneType=type(None)):	1✔
234	if C is _NoneType:	1✔
235	return False	1✔
236	# If C is an old-style class, it may not even have __lt__
237	if isinstance(C, type):	1✔
238	lt = C.__lt__	1✔
239	else:
240	lt = getattr(C, '__lt__', None)	1✔
241	if lt is not None:	1✔
242	defining_class = getattr(lt, '__objclass__', None)	1✔
243	if defining_class is None:	1✔
244	# Implemented in Python
245	return False	1✔
246	if defining_class is not type:	1✔
247	return False	1✔
248	return not hasattr(C, '__cmp__')	1✔
249	else:
250	# PyPy3
251	@classmethod	×
252	def __subclasshook__(cls, C, _object_lt=object.__lt__, _NoneType=type(None)):	×
253	if C is _NoneType:	×
254	return False	×
255	return C.__lt__ is _object_lt	×
256	else:
257	# PyPy2
258	@classmethod	×
259	def __subclasshook__(cls, C, _NoneType=type(None)):	×
260	if C is _NoneType:	×
261	return False	×
262	return not hasattr(C, '__lt__') and not hasattr(C, '__cmp__')	×
263
264
265	class O(KeyDataType):	6✔
266	"""
267	Arbitrary (sortable) Python objects.
268	"""
269	long_name = 'Object'	6✔
270	tree_size = 250	6✔
271	default_bucket_size = 60	6✔
272
273	def as_value_type(self):	6✔
274	return Any()	6✔
275
276	def supports_value_union(self):	6✔
277	return False	6✔
278
279	def __call__(self, item):	6✔
280	if isinstance(item, _HasDefaultComparison):	6✔
281	raise TypeError("Object of class %s has default comparison" % (type(item).__name__,))	6✔
282	return item	6✔
283
284
285	class _AbstractNativeDataType(KeyDataType):	6✔
286	"""
287	Uses `struct.Struct` to verify that the data can fit into a native
288	type.
289	"""
290
291	_struct_format = None	6✔
292	_as_python_type = NotImplementedError	6✔
293	_required_python_type = object	6✔
294	_error_description = None	6✔
295	_as_packable = object_to_index # obj.__index__ -> produce integer	6✔
296
297	@Lazy	6✔
298	def _check_native(self):	2✔
299	return Struct(self._struct_format).pack	6✔
300
301	def __call__(self, item):	6✔
302	try:	6✔
303	self._check_native(self._as_packable(item)) # pylint:disable=too-many-function-args	6✔
304	except (struct_error, TypeError, ValueError):	6✔
305	# PyPy can raise ValueError converting a negative number to a
306	# unsigned value.
307	if isinstance(item, int_types):	6✔
308	raise TypeError("Value out of range", item)	6✔
309	raise TypeError(self._error_description)	6✔
310
311	return self._as_python_type(item)	6✔
312
313	def apply_weight(self, item, weight):	6✔
314	return item * weight	6✔
315
316	def supports_value_union(self):	6✔
317	return True	6✔
318
319	class _AbstractIntDataType(_AbstractNativeDataType):	6✔
320	_as_python_type = int	6✔
321	_required_python_type = int_types	6✔
322	multiplication_identity = 1	6✔
323	long_name = "Integer"	6✔
324
325	def getTwoExamples(self):	6✔
326	return 1, 2	6✔
327
328	# On Python 2, it's important for these values to be actual `int`
329	# values, not `long` when they fit; passing a value that's too big
330	# to `int` will still result in it being a `long`. For some reason
331	# on Windows, even the 32-bit values somehow wind up as longs
332	# unless we do the conversion.
333	def get_lower_bound(self):	6✔
334	exp = 64 if self.using64bits else 32	6✔
335	exp -= 1	6✔
336	return int(-(2 ** exp))	6✔
337
338	def get_upper_bound(self):	6✔
339	exp = 64 if self.using64bits else 32	6✔
340	exp -= 1	6✔
341	return int(2 ** exp - 1)	6✔
342
343
344	class _AbstractUIntDataType(_AbstractIntDataType):	6✔
345	long_name = 'Unsigned'	6✔
346
347	def get_lower_bound(self):	6✔
348	return 0	6✔
349
350	def get_upper_bound(self):	6✔
351	exp = 64 if self.using64bits else 32	6✔
352	return int(2 ** exp - 1)	6✔
353
354
355	class I(_AbstractIntDataType):	6✔
356	_struct_format = 'i'	6✔
357	_error_description = "32-bit integer expected"	6✔
358
359
360	class U(_AbstractUIntDataType):	6✔
361	_struct_format = 'I'	6✔
362	_error_description = 'non-negative 32-bit integer expected'	6✔
363
364
365	class F(_AbstractNativeDataType):	6✔
366	_struct_format = 'f'	6✔
367	_as_python_type = float	6✔
368	_error_description = 'float expected'	6✔
369	_as_packable = lambda self, k: k # identity	6✔
370	multiplication_identity = 1.0	6✔
371	long_name = 'Float'	6✔
372
373	def getTwoExamples(self):	6✔
374	return 0.5, 1.5	6✔
375
376	class L(_AbstractIntDataType):	6✔
377	_struct_format = 'q'	6✔
378	_error_description = '64-bit integer expected'	6✔
379	using64bits = True	6✔
380
381
382	class Q(_AbstractUIntDataType):	6✔
383	_struct_format = 'Q'	6✔
384	_error_description = 'non-negative 64-bit integer expected'	6✔
385	using64bits = True	6✔
386
387
388	class _AbstractBytes(KeyDataType):	6✔
389	"""
390	An exact-length byte string type.
391
392	This must be subclassed to provide the actual byte length.
393	"""
394	__slots__ = ()	6✔
395	tree_size = 500	6✔
396	default_bucket_size = 500	6✔
397
398	def __init__(self, length):	6✔
399	super(_AbstractBytes, self).__init__()	6✔
400	self._length = length	6✔
401
402	def __call__(self, item):	6✔
403	if not isinstance(item, bytes) or len(item) != self._length:	6✔
404	raise TypeError("%s-byte array expected, not %r" % (self._length, item))	6✔
405	return item	6✔
406
407	def supports_value_union(self):	6✔
408	return False	×
409
410
411	class f(_AbstractBytes):	6✔
412	"""
413	The key type for an ``fs`` tree.
414
415	This is a two-byte prefix of an overall 8-byte value
416	like a ZODB object ID or transaction ID.
417	"""
418
419	# Our keys are treated like integers; the module
420	# implements IIntegerObjectBTreeModule
421	long_name = 'Integer'	6✔
422	prefix_code = 'f'	6✔
423
424	def __init__(self):	6✔
425	_AbstractBytes.__init__(self, 2)	6✔
426
427	def supports_value_union(self):	6✔
428	# We don't implement 'multiunion' for fsBTree.
429	return False	6✔
430
431	# Check it can be converted to a two-byte
432	# value. Note that even though we allow negative values
433	# that can break test assumptions: -1 < 0 < 1, but the byte
434	# values for those are \xff\xff > \x00\x00 < \x00\x01.
435	_as_2_bytes = Struct('>h').pack	6✔
436
437	def coerce(self, item):	6✔
438	try:	6✔
439	return self(item)	6✔
440	except TypeError:	6✔
441	try:	6✔
442	return self._as_2_bytes(object_to_index(item))	6✔
443	except struct_error as e:	6✔
444	raise TypeError(e)	6✔
445
446	def make_toString(self):	6✔
447	def toString(self):	6✔
448	return b''.join(self._keys) + b''.join(self._values)	6✔
449	return toString	6✔
450
451	def make_fromString(self):	6✔
452	def fromString(self, v):	6✔
453	length = len(v)	6✔
454	if length % 8 != 0:	6✔
455	raise ValueError()	6✔
456	count = length // 8	6✔
457	keys, values = v[:count2], v[count2:]	6✔
458	self.clear()	6✔
459	while keys and values:	6✔
460	key, keys = keys[:2], keys[2:]	6✔
461	value, values = values[:6], values[6:]	6✔
462	self._keys.append(key)	6✔
463	self._values.append(value)	6✔
464	return self	6✔
465	return fromString	6✔
466
467	def add_extra_methods(self, base_name, cls):	6✔
468	if base_name == 'Bucket':	6✔
469	cls.toString = self.make_toString()	6✔
470	cls.fromString = self.make_fromString()	6✔
471
472	class s(_AbstractBytes):	6✔
473	"""
474	The value type for an ``fs`` tree.
475
476	This is a 6-byte suffix of an overall 8-byte value
477	like a ZODB object ID or transaction ID.
478	"""
479
480	# Our values are treated like objects; the
481	# module implements IIntegerObjectBTreeModule
482	long_name = 'Object'	6✔
483	prefix_code = 's'	6✔
484
485
486	def __init__(self):	6✔
487	_AbstractBytes.__init__(self, 6)	6✔
488
489	def supports_value_union(self):	6✔
490	return False	6✔
491
492	def get_lower_bound(self):	6✔
493	# Negative values have the high bit set, which is incompatible
494	# with our transformation.
495	return 0	6✔
496
497	# To coerce an integer, as used in tests, first convert to 8 bytes
498	# in big-endian order, then ensure the first two
499	# are 0 and cut them off.
500	_as_8_bytes = Struct('>q').pack	6✔
501
502	def coerce(self, item):	6✔
503	try:	6✔
504	return self(item)	6✔
505	except TypeError:	6✔
506	try:	6✔
507	as_bytes = self._as_8_bytes(object_to_index(item))	6✔
508	except struct_error as e:	6✔
NEW 509	raise TypeError(e)	×
510
511	if as_bytes[:2] != b'\x00\x00':	6✔
512	raise TypeError("Cannot convert %r to 6 bytes (%r)" % (item, as_bytes))	6✔
513	return as_bytes[2:]	6✔

zopefoundation / BTrees / 915948437

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous