[HyukjinKwon]

What

I compared every line of upstream's cloudpickle/cloudpickle.py (commit 4af5936) with the Rust implementation. No function, branch or payload difference was missing. This PR fixes the behavior differences the comparison found.

Globals are read at call time, like upstream

Upstream's functions read their module's globals on every call: its state (_PICKLE_BY_VALUE_MODULES, the class trackers, _extract_code_globals_cache, …), its own functions, and the modules it imported. They also read the standard-library attributes they use (types.FunctionType, uuid.uuid4, sys.modules, pickle.PicklingError, warnings.warn, …). Replacing one of them, for example with monkeypatch, therefore changes upstream's behavior. The port bound them at import, so the same replacement had no effect.

Now each Rust function first checks that the globals the upstream function reads still hold their initial values, at one dictionary lookup each. If one was replaced, the call runs the upstream function itself. It is compiled on demand from a byte-identical copy of upstream's cloudpickle.py (src/upstream/cloudpickle.py), with the namespace of cloudpickle_rust.cloudpickle as its globals (src/fallback.rs). The per-function dependency lists come from upstream's bytecode.

_code_reduce reads a single global, types.CodeType, when it returns. It looks it up at that point instead of running upstream's code, so DYNAMIC_CODE_FILENAME (#2) applies in every case.

The functions are Python functions, like upstream's

The module's 65 functions and the Pickler methods are now Python functions that call their Rust implementation (src/functions.rs). They have upstream's signatures (now including _make_cell(value=_empty_cell_value)), docstrings, __qualname__, __module__ and __globals__. The docstrings are compiled by the running interpreter, so they also match Python 3.13's docstring dedenting. They come from src/upstream_docs.rs, which dev/generate_upstream_docs.py generates from the bundled source. As a result:

• isinstance(f, types.FunctionType) matches upstream. The pickler therefore routes the module's own reconstructors through _function_reduce, so Pickler subclasses and replaced _should_pickle_by_reference see the same calls as upstream.
• Warnings raised while pickling are attributed to the module, as upstream's are to cloudpickle.cloudpickle.

The exception is Pickler.reducer_override: the C pickler calls it for every object, so it stays a native method descriptor.

Other fixes

• _extract_code_globals_cache is a weakref.WeakKeyDictionary, and _empty_cell_value is an instance of a Python class, both like upstream's.
• Error messages match upstream's:
  • _getattribute on 3.12 and 3.13;
  • unpacking errors in _function_setstate and _class_setstate on 3.14;
  • _file_reduce for a non-string mode or name (% formatting);
  • register_pickle_by_value and unregister_pickle_by_value (format()).
• _walk_global_ops, _extract_code_globals and _find_imported_submodules accept the same non-code inputs as upstream. For example, _walk_global_ops(func) returns upstream's lazy generator.
• PyPy: the module's functions are saved by upstream's own save_function, and the extra reducer_override the port added is removed.
• Docs: the README compatibility section lists the remaining implementation differences, and LICENSE is updated. The CHANGES.md entries go in the 0.2.0 section, next to Add DYNAMIC_CODE_FILENAME to keep the filenames of the code pickled by value #2's. The README benchmark table is updated too: pickling functions is about 10% slower than in 0.1.0, which is the cost of these semantics, while instance-heavy data is unchanged.

Not ported: upstream's label-triggered downstream CI jobs (distributed, joblib, loky, ray). Its MANIFEST.in, .git-blame-ignore-revs and dev/make-distribution.sh aren't needed here.

Verification

Rebased on main after #2 was merged (conflicts resolved: module_global replaced by fallback::load_global).

• Ran the full suite locally on CPython 3.8–3.14, 3.13t and 3.14t. All 278 upstream tests have the same outcome as before, and every port-specific test passes.
• On PyPy 7.3.23 and 8.0.1, all upstream tests have the same outcome. The only change is test_walk_global_ops_matches_dis, which now passes on 7.3.23 where the old baseline failed.
• New differential tests compare against upstream cloudpickle on the same interpreter:
  • replacing each internal function with a counting spy gives the same call counts and payloads;
  • replacing each imported module with a recording proxy gives the same attribute-access sequence;
  • reassigning the module state behaves the same;
  • functions and methods have the same type, signature, docstring and globals;
  • the error messages and the bundled source are identical.
• pre-commit (all files), clippy -D warnings, and the sdist (which includes the new sources).

This pull request and its description were written by Isaac.