diskcache-community 5.8.2__tar.gz → 5.8.3__tar.gz

{diskcache_community-5.8.2/diskcache_community.egg-info → diskcache_community-5.8.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diskcache-community
-Version: 5.8.2
+Version: 5.8.3
 Summary: Disk Cache -- Disk and file backed persistent cache.
 Author: Grant Jenks
 Maintainer: diskcache-community contributors

{diskcache_community-5.8.2 → diskcache_community-5.8.3}/diskcache_community/__init__.py

@@ -72,8 +72,8 @@ except Exception:  # pylint: disable=broad-except  # pragma: no cover
 
 
 __title__ = 'diskcache-community'
-__version__ = '5.8.2'
-__build__ = 0x050802
+__version__ = '5.8.3'
+__build__ = 0x050803
 __author__ = 'Grant Jenks'
 __license__ = 'Apache 2.0'
 __copyright__ = 'Copyright 2016-2023 Grant Jenks'

{diskcache_community-5.8.2 → diskcache_community-5.8.3}/diskcache_community/_types.pyi

@@ -173,10 +173,18 @@ class BaseCache(Protocol):
         retry: bool = ...,
     ) -> bool: ...
     def incr(
-        self, key: Any, delta: int = ..., default: int = ..., retry: bool = ...
+        self,
+        key: Any,
+        delta: int = ...,
+        default: int | None = ...,
+        retry: bool = ...,
     ) -> int: ...
     def decr(
-        self, key: Any, delta: int = ..., default: int = ..., retry: bool = ...
+        self,
+        key: Any,
+        delta: int = ...,
+        default: int | None = ...,
+        retry: bool = ...,
     ) -> int: ...
     def get(  # noqa: PLR0913
         self,

{diskcache_community-5.8.2 → diskcache_community-5.8.3}/diskcache_community/arrays.py

@@ -93,7 +93,9 @@ def _pack_array(numpy, array):
     The buffer is the array's own memory, so pickle copies it once, into
     the row, as a bytearray. An array that is not contiguous or not
     writable is copied first, since pickle stores a read-only buffer as
-    bytes, which the reader refuses.
+    bytes, which the reader refuses. The buffer is a flat view of bytes,
+    since numpy exports no buffer for ``datetime64`` and ``timedelta64``
+    data; the dtype is in the header.
 
     """
     # pylint: disable=no-member
@@ -114,11 +116,16 @@ def _pack_array(numpy, array):
         header = buffer.getvalue()
         _read_header(numpy, header, array.nbytes)
     except (ValueError, pickle.UnpicklingError) as error:
-        raise TypeError(
-            'SafeDisk cannot store an array of dtype %s' % (array.dtype,)
-        ) from error
-
-    return header, pickle.PickleBuffer(array)
+        message = 'SafeDisk cannot store an array of dtype %s' % (array.dtype,)
+        if array.dtype.hasobject:
+            message += (
+                '; a pandas DataFrame holds its labels and text columns in'
+                ' such arrays, so store its records or columns instead'
+            )
+        raise TypeError(message) from error
+
+    data = array.reshape(-1, order='A').view(numpy.uint8)
+    return header, pickle.PickleBuffer(data)
 
 
 def _unpack_array(header, data):

{diskcache_community-5.8.2 → diskcache_community-5.8.3}/diskcache_community/core.py

@@ -557,9 +557,11 @@ SAFE_PICKLE_NAMES = {
     'uuid': frozenset({'UUID'}),
 }
 
-# Python types that SafeDisk accepts for writing: exactly the types that the
-# names above read back. Subclasses are rejected because pickle records the
-# subclass, which the reader would refuse.
+# Python types that SafeDisk accepts for writing without pickling them first:
+# exactly the types that the names above read back. Anything else is pickled
+# and accepted only if the reader resolves every name the pickle looks up, so
+# a subclass is refused, because pickle records the subclass, unless it
+# pickles as one of these types.
 
 SAFE_TYPES = frozenset(
     {
@@ -593,15 +595,35 @@ SAFE_TYPES = frozenset(
     }
 )
 
+# Classes that SafeDisk accepts as objects, such as the classes that
+# memoize(typed=True) puts into keys and the factory of a defaultdict: the
+# classes in SAFE_TYPES that pickle as a name the reader resolves. NoneType
+# pickles as a call to builtins.type, and bool as builtins.bool, which the
+# reader refuses.
+
+_SAFE_CLASSES = SAFE_TYPES - {type(None), bool}
+
 _SAFE_MAPPINGS = (dict, co.Counter, co.OrderedDict, co.defaultdict)
 _SAFE_SEQUENCES = (list, tuple, set, frozenset, co.deque)
 _SAFE_TZ_TYPES = (type(None), dt.timezone)
 
-# Packages whose classes SafeDisk.with_types refuses to allow. numpy restores
-# the internal flags of a dtype from its pickle without checking them, so a
-# crafted pickle can make an array read raw bytes as object pointers.
+# Packages whose classes SafeDisk.with_types refuses to allow, because a
+# crafted pickle of one can corrupt memory or run code. numpy restores the
+# internal flags of a dtype from its pickle without checking them, so a
+# crafted pickle can make an array read raw bytes as object pointers. scipy's
+# sparse matrices and pyahocorasick's automatons keep index data that their
+# compiled code trusts, bitstruct's compiled formats crash on state they did
+# not build, and torch builds some objects by compiling or running code.
+
+_UNSAFE_MODULES = ('numpy', 'ahocorasick', 'bitstruct', 'scipy', 'torch')
+
+
+def _unsafe_reason(package):
+    """Return why with_types refuses classes of the unsafe `package`."""
+    if package == 'numpy':
+        return '; use with_numpy() to store arrays'
+    return ': a crafted pickle of a %s object is not safe to read' % package
 
-_UNSAFE_MODULES = ('numpy',)
 
 _PICKLE_STRING_OPS = frozenset(
     {'BINUNICODE', 'BINUNICODE8', 'SHORT_BINUNICODE', 'UNICODE'}
@@ -838,10 +860,11 @@ class SafeDisk(Disk):
     ``FanoutCache(directory, disk=SafeDisk)``, ``Deque(disk=SafeDisk)``,
     ``Index(disk=SafeDisk)`` or the ``DISK`` option of the Django backend.
 
-    Objects outside the allowlist, such as instances of your own classes,
-    Django model instances and responses, and the ``type`` objects that
-    ``memoize(typed=True)`` puts into keys, need either the default
-    :class:`Disk` or a disk from :meth:`with_types` that allows them.
+    Objects outside the allowlist, such as instances of your own classes and
+    Django model instances and responses, need either the default
+    :class:`Disk` or a disk from :meth:`with_types` that allows them. The
+    allowed classes themselves can be stored too, so ``memoize(typed=True)``
+    works.
 
     """
 
@@ -868,7 +891,9 @@ class SafeDisk(Disk):
         do nothing beyond storing their fields, such as dataclasses, named
         tuples, enums and pydantic models. Reading looks classes up only in
         modules that are already imported, so import them before reading.
-        numpy classes are refused; use :meth:`with_numpy` to store arrays.
+        Classes of numpy, scipy, torch, bitstruct and pyahocorasick are
+        refused, because a crafted pickle of one can corrupt memory or run
+        code; use :meth:`with_numpy` to store arrays.
 
         >>> import collections
         >>> Point = collections.namedtuple('Point', 'x y')
@@ -882,17 +907,18 @@ class SafeDisk(Disk):
         :return: SafeDisk subclass to pass as ``disk=``
         :raises TypeError: if an entry of `types` is not a class
         :raises ValueError: if an entry of `modules` is not a module name, or
-            a type or module is numpy (arrays belong to :meth:`with_numpy`)
+            a type or module belongs to one of those packages
 
         """
         for entry in types:
             if not isinstance(entry, type):
                 raise TypeError('with_types takes classes, not %r' % (entry,))
-            if _in_modules(entry.__module__, _UNSAFE_MODULES):
-                raise ValueError(
-                    'with_types refuses the class %r; use with_numpy() to'
-                    ' store arrays' % (entry,)
-                )
+            for unsafe in _UNSAFE_MODULES:
+                if _in_modules(entry.__module__, (unsafe,)):
+                    raise ValueError(
+                        'with_types refuses the class %r%s'
+                        % (entry, _unsafe_reason(unsafe))
+                    )
 
         if isinstance(modules, str):
             modules = (modules,)
@@ -903,15 +929,14 @@ class SafeDisk(Disk):
                 part.isidentifier() for part in prefix.split('.')
             ):
                 raise ValueError('%r is not a module name' % (entry,))
-            if any(
-                _in_modules(prefix, (unsafe,))
-                or _in_modules(unsafe, (prefix,))
-                for unsafe in _UNSAFE_MODULES
-            ):
-                raise ValueError(
-                    'with_types refuses the module %r; use with_numpy() to'
-                    ' store arrays' % (entry,)
-                )
+            for unsafe in _UNSAFE_MODULES:
+                if _in_modules(prefix, (unsafe,)) or _in_modules(
+                    unsafe, (prefix,)
+                ):
+                    raise ValueError(
+                        'with_types refuses the module %r%s'
+                        % (entry, _unsafe_reason(unsafe))
+                    )
             prefixes.append(prefix)
 
         return _derive_disk(
@@ -933,7 +958,7 @@ class SafeDisk(Disk):
         value except in keys, and checks each header before it reads an
         array back. (Plain :class:`SafeDisk` refuses numpy pickles, because
         unpickling an array is not memory-safe.) numpy scalars keep their
-        type.
+        type, and arrays of ``datetime64`` and ``timedelta64`` are stored too.
         Object arrays, ``ndarray`` subclasses and other numpy scalars raise
         :exc:`TypeError` when written. It combines with :meth:`with_types`
         and :meth:`with_options` in any order.
@@ -966,22 +991,29 @@ class SafeDisk(Disk):
             return arrays.unpickler(self, file)
         return self._plain_unpickler(file)
 
-    def _extended(self):
-        return bool(self.safe_types or self.safe_modules)
-
     def _check_object(self, obj, what):
-        """Raise TypeError unless the reader would accept `obj` back."""
+        """Raise TypeError unless the reader would accept `obj` back.
+
+        Outside SAFE_TYPES, an object is accepted when its pickle looks up
+        only names the reader resolves, such as a dict subclass that pickles
+        as a plain dict, which is then what the reader builds.
+
+        """
         try:
             self._check(obj, what)
         except TypeError:
-            if not self._extended():
-                raise
+            pass
         else:
             return
 
-        self._check_pickle(
-            pickle.dumps(obj, protocol=self.pickle_protocol), obj, what
-        )
+        try:
+            data = pickle.dumps(obj, protocol=self.pickle_protocol)
+        except (pickle.PicklingError, AttributeError) as error:
+            raise TypeError(
+                'SafeDisk cannot store %s: %s' % (what, error)
+            ) from error
+
+        self._check_pickle(data, obj, what)
 
     def _check_pickle(self, data, obj, what):
         """Raise TypeError unless the reader would accept the pickle `data`."""
@@ -1002,17 +1034,38 @@ class SafeDisk(Disk):
             except pickle.UnpicklingError:
                 raise TypeError(
                     'SafeDisk cannot store %s of type %s.%s: it pickles'
-                    ' %s.%s, which the allowlist refuses; allow it with'
-                    ' SafeDisk.with_types()'
+                    ' %s.%s, which the allowlist refuses%s'
                     % (
                         what,
                         type(obj).__module__,
                         type(obj).__qualname__,
                         module,
                         name,
+                        self._refusal_hint(module, name),
                     )
                 ) from None
 
+    def _refusal_hint(self, module, name):
+        """Return how to store what pickles the refused `module`.`name`."""
+        if _in_modules(module, ('numpy',)):
+            if self.safe_numpy:
+                return '; with_numpy() stores only arrays and numpy scalars'
+            return '; store arrays with SafeDisk.with_numpy()'
+
+        for unsafe in _UNSAFE_MODULES:
+            if _in_modules(module, (unsafe,)):
+                return '; with_types() refuses %s classes' % unsafe
+
+        obj = sys.modules.get(module)
+        for part in name.split('.'):
+            obj = getattr(obj, part, None)
+
+        if not isinstance(obj, type):
+            return '; it is not a class, and with_types() allows only classes'
+        if module in ('builtins', '__builtin__'):
+            return ''
+        return '; allow it with SafeDisk.with_types()'
+
     def _check(self, obj, what):
         """Raise TypeError unless every object in `obj` is in SAFE_TYPES."""
         seen = set()
@@ -1023,6 +1076,8 @@ class SafeDisk(Disk):
             type_item = type(item)
 
             if type_item not in SAFE_TYPES:
+                if isinstance(item, type) and item in _SAFE_CLASSES:
+                    continue
                 raise TypeError(
                     'SafeDisk cannot store %s of type %s.%s'
                     % (what, type_item.__module__, type_item.__qualname__)
@@ -1034,7 +1089,7 @@ class SafeDisk(Disk):
                 seen.add(id(item))
                 if type_item is co.defaultdict:
                     factory = item.default_factory
-                    if factory is not None and factory not in SAFE_TYPES:
+                    if factory is not None and factory not in _SAFE_CLASSES:
                         raise TypeError(
                             'SafeDisk cannot store %s with defaultdict'
                             ' factory %r' % (what, factory)
@@ -1996,8 +2051,12 @@ class Cache:
         cur = getattr(self._local, 'cur', None)
 
         if cur is None:
-            self._connect()
-            cur = self._local.cur
+            # Through _con, so a subclass that overrides it, to open another
+            # database file say, gets a cursor on that connection.
+            con = self._con
+            cur = getattr(self._local, 'cur', None)
+            if cur is None or cur.connection is not con:
+                cur = self._local.cur = con.cursor()
 
         return cur
 

{diskcache_community-5.8.2 → diskcache_community-5.8.3}/diskcache_community/core.pyi

@@ -8,6 +8,7 @@ from typing import (
     Final,
     Generator,
     Generic,
+    Iterable,
     Literal,
     NoReturn,
     overload,
@@ -192,7 +193,7 @@ class SafeDisk(Disk):
     safe_numpy: bool
     @classmethod
     def with_types(
-        cls, *types: type, modules: tuple[str, ...] = ...
+        cls, *types: type, modules: str | Iterable[str] = ...
     ) -> type[Self]: ...
     @classmethod
     def with_numpy(cls) -> type[Self]: ...

{diskcache_community-5.8.2 → diskcache_community-5.8.3/diskcache_community.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diskcache-community
-Version: 5.8.2
+Version: 5.8.3
 Summary: Disk Cache -- Disk and file backed persistent cache.
 Author: Grant Jenks
 Maintainer: diskcache-community contributors

{diskcache_community-5.8.2 → diskcache_community-5.8.3}/tests/test_core.py

@@ -2319,6 +2319,50 @@ def test_get_after_close_uses_new_cursor(cache):
     assert cache._local.cur is not cur
 
 
+class OtherDatabaseCache(dc.Cache):
+    """Cache written against 5.6.3 that keeps its rows in other.db."""
+
+    @property
+    def _con(self):
+        con = getattr(self._local, 'con', None)
+        if con is None:
+            con = self._local.con = sqlite3.connect(
+                op.join(self._directory, 'other.db'),
+                timeout=self._timeout,
+                isolation_level=None,
+            )
+        return con
+
+
+def test_get_uses_cursor_of_overridden_con():
+    directory = tempfile.mkdtemp()
+    try:
+        with OtherDatabaseCache(directory) as cache:
+            cache.set('a', 1)
+            assert cache.get('a') == 1
+            assert cache._local.cur.connection is cache._con
+
+            other = []
+
+            def get_in_thread():
+                other.append(cache.get('a'))
+                cache.close()
+
+            thread = threading.Thread(target=get_in_thread)
+            thread.start()
+            thread.join()
+            assert other == [1]
+
+        with OtherDatabaseCache(directory) as cache:
+            assert cache.get('a') == 1
+            assert cache.get('b') is None
+
+        assert op.exists(op.join(directory, 'other.db'))
+        assert not op.exists(op.join(directory, 'cache.db'))
+    finally:
+        shutil.rmtree(directory, ignore_errors=True)
+
+
 def test_get_reads_only_value_columns_without_metadata(cache):
     cache.set('a', 1, tag='t')
     statements = []

{diskcache_community-5.8.2 → diskcache_community-5.8.3}/tests/test_safedisk.py

@@ -18,7 +18,12 @@ import zoneinfo
 import pytest
 
 import diskcache_community as dc
-from diskcache_community.core import MODE_BINARY, MODE_PICKLE, SafeUnpickler
+from diskcache_community.core import (
+    MODE_BINARY,
+    MODE_PICKLE,
+    SAFE_TYPES,
+    SafeUnpickler,
+)
 
 pytestmark = pytest.mark.filterwarnings('ignore', category=dc.EmptyDirWarning)
 
@@ -104,6 +109,10 @@ SAFE_VALUES = [
     decimal.Decimal('-1e100'),
     fractions.Fraction(1, 3),
     uuid.UUID('12345678-1234-5678-1234-567812345678'),
+    co.defaultdict(int, {'a': 1}),
+    # The classes themselves, as memoize(typed=True) puts them into keys.
+    *sorted(SAFE_TYPES - {type(None), bool}, key=repr),
+    ('f', 1, 'a', int, str),
 ]
 
 HASHABLE_VALUES = [
@@ -121,14 +130,18 @@ UNSAFE_VALUES = [
     (1, (2, (Custom(),))),
     co.deque([Custom()]),
     co.defaultdict(Custom),
+    co.defaultdict(bool),
     dt.datetime(2020, 1, 2, tzinfo=CustomTz()),
     dt.time(1, tzinfo=CustomTz()),
     dt.datetime(2020, 1, 2, tzinfo=zoneinfo.ZoneInfo('UTC')),
     type,
-    int,
+    type(None),
+    bool,
+    (1, type(None)),
+    Custom,
     len,
     Poison,
-    object(),
+    lambda: None,
     Exception('boom'),
 ]
 
@@ -330,21 +343,84 @@ def test_key_rejected(cache):
     assert len(cache) == 0
 
 
-def test_typed_memoize_rejected(cache):
-    @cache.memoize(typed=True)
-    def identity(value):
-        return value
+@pytest.mark.parametrize('disk', [dc.SafeDisk, dc.SafeDisk.with_types()])
+def test_typed_memoize(directory, disk):
+    with dc.Cache(directory, disk=disk) as cache:
 
-    with pytest.raises(TypeError, match='SafeDisk cannot store key'):
-        identity(1)
+        @cache.memoize(typed=True)
+        def identity(value):
+            return value
+
+        assert identity(1) == 1
+        assert identity(1.0) == 1.0
+        assert identity('a') == 'a'
+        assert identity(1) == 1
+        assert len(cache) == 3
+
+        with pytest.raises(TypeError, match='SafeDisk cannot store key'):
+            identity(None)
+
+        with pytest.raises(TypeError, match='SafeDisk cannot store key'):
+            identity(True)
+
+        assert len(cache) == 3
+
+    with dc.Cache(directory, disk=dc.SafeDisk) as cache:
+        assert sorted(key[-1].__name__ for key in cache) == [
+            'float',
+            'int',
+            'str',
+        ]
 
-    @cache.memoize()
-    def plain(value):
-        return value
 
-    assert plain(1) == 1
-    assert plain(1) == 1
-    assert len(cache) == 1
+class PlainDict(dict):
+    """A dict subclass that pickles as a dict, as DRF's ReturnDict does."""
+
+    def __reduce__(self):
+        return dict, (dict(self),)
+
+
+@pytest.mark.parametrize(
+    'disk',
+    [dc.SafeDisk, dc.SafeDisk.with_types(), dc.SafeDisk.with_types(Custom)],
+)
+def test_objects_that_pickle_as_allowed_names_are_stored(directory, disk):
+    with dc.Cache(directory, disk=disk) as cache:
+        cache['dict'] = PlainDict(a=1)
+        cache[PlainDict(b=2).get('b')] = [PlainDict(c=3)]
+        cache['object'] = object()
+
+        assert cache['dict'] == {'a': 1}
+        assert type(cache['dict']) is dict
+        assert type(cache[2][0]) is dict
+        assert type(cache['object']) is object
+
+
+def test_refusal_messages(cache):
+    def refusal(value):
+        with pytest.raises(TypeError, match='SafeDisk cannot store') as info:
+            cache['key'] = value
+        return str(info.value)
+
+    assert refusal(Custom()).endswith(
+        'it pickles %s.Custom, which the allowlist refuses; allow it with'
+        ' SafeDisk.with_types()' % __name__
+    )
+    assert refusal(_execute).endswith(
+        'it pickles %s._execute, which the allowlist refuses; it is not a'
+        ' class, and with_types() allows only classes' % __name__
+    )
+    assert refusal((1, type(None))).endswith(
+        'it pickles builtins.type, which the allowlist refuses'
+    )
+    assert refusal([bool]).endswith(
+        'it pickles builtins.bool, which the allowlist refuses'
+    )
+    assert refusal(co.defaultdict(bool)).endswith(
+        'it pickles builtins.bool, which the allowlist refuses'
+    )
+    assert refusal(lambda: None).startswith('SafeDisk cannot store value: ')
+    assert len(cache) == 0
 
 
 def test_read_values_untouched(cache):

{diskcache_community-5.8.2 → diskcache_community-5.8.3}/tests/test_safedisk_numpy.py

@@ -187,6 +187,13 @@ def raw(header, body=b''):
         np.zeros((0, 3)),
         np.arange(4.0).reshape(2, 2).T,
         np.arange(3, dtype='>i4'),
+        # numpy exports no buffer for these, so the data goes as bytes.
+        np.array(['2026-01-01T00:00', 'NaT'], dtype='datetime64[ns]'),
+        np.arange(6).astype('datetime64[D]').reshape(2, 3).T,
+        np.array(np.datetime64('2026-01-01')),
+        np.arange(3).astype('>m8[s]'),
+        np.array([(1, 2)], dtype=[('a', 'i4'), ('t', 'M8[us]')]),
+        np.zeros(0, dtype='m8[ns]'),
     ],
     ids=lambda array: '%s-%s' % (array.dtype, array.shape),
 )
@@ -910,6 +917,34 @@ def test_safedisk_still_refuses_numpy(directory):
         assert len(cache) == 0
 
 
+@pytest.mark.parametrize(
+    'disk', [dc.SafeDisk, dc.SafeDisk.with_types(co.UserDict)]
+)
+def test_numpy_refusals_point_to_with_numpy(directory, disk):
+    with dc.Cache(directory, disk=disk) as cache:
+        for value in (np.arange(2.0), np.dtype('f8'), [np.float64(1.5)]):
+            with pytest.raises(TypeError) as info:
+                cache['key'] = value
+            assert str(info.value).endswith(
+                'store arrays with SafeDisk.with_numpy()'
+            )
+
+
+def test_with_numpy_refusal_of_other_numpy_objects(directory):
+    with dc.Cache(directory, disk=ArrayDisk) as cache:
+        with pytest.raises(TypeError) as info:
+            cache['key'] = {'dtype': np.dtype('f8')}
+    assert str(info.value).endswith(
+        'with_numpy() stores only arrays and numpy scalars'
+    )
+
+
+def test_object_array_refusal_mentions_dataframes(directory):
+    with dc.Cache(directory, disk=ArrayDisk) as cache:
+        with pytest.raises(TypeError, match='DataFrame .* records'):
+            cache['key'] = np.array(['a', None], dtype=object)
+
+
 def test_safejsondisk_refuses_with_numpy():
     with pytest.raises(TypeError, match='SafeJSONDisk'):
         dc.SafeJSONDisk.with_numpy()

{diskcache_community-5.8.2 → diskcache_community-5.8.3}/tests/test_safedisk_types.py

@@ -11,6 +11,7 @@ import struct
 import sys
 import tempfile
 import tracemalloc
+import types
 
 import pytest
 
@@ -443,6 +444,44 @@ def test_numpy_is_refused(directory):
                 cache['value'] = value
 
 
+@pytest.mark.parametrize(
+    'package, module',
+    [
+        ('ahocorasick', 'ahocorasick'),
+        ('bitstruct', 'bitstruct.c'),
+        ('scipy', 'scipy.sparse._csr'),
+        ('torch', 'torch.fx.graph_module'),
+    ],
+)
+def test_unsafe_packages_are_refused(package, module):
+    entry = type('Thing', (), {'__module__': module})
+
+    with pytest.raises(ValueError, match='refuses the class .*not safe'):
+        dc.SafeDisk.with_types(entry)
+
+    for prefix in (package, module, package + '.'):
+        with pytest.raises(ValueError, match='refuses the module .*not safe'):
+            dc.SafeDisk.with_types(modules=prefix)
+
+    # A package whose name only starts with the same letters is allowed.
+    dc.SafeDisk.with_types(modules=package + 'x')
+
+
+def test_refusal_names_an_unsafe_package(directory, monkeypatch):
+    module = types.ModuleType('bitstruct')
+    module.Format = type('Format', (), {'__module__': 'bitstruct'})
+    monkeypatch.setitem(sys.modules, 'bitstruct', module)
+
+    with dc.Cache(directory, disk=dc.SafeDisk) as cache:
+        with pytest.raises(TypeError) as info:
+            cache['value'] = [module.Format()]
+
+    assert str(info.value).endswith(
+        'it pickles bitstruct.Format, which the allowlist refuses;'
+        ' with_types() refuses bitstruct classes'
+    )
+
+
 def test_modules_are_never_imported_by_a_read():
     name = 'tests.safedisk_models.side_effect'
     data = stack_global(name, 'Thing')