From 36b46c80f4a716c3b0522af3c7ade7c254c54391 Mon Sep 17 00:00:00 2001 From: Tobias Wrigstad Date: Thu, 19 Jun 2025 13:23:57 +0900 Subject: [PATCH 1/8] PEP 795 --- .github/CODEOWNERS | 1 + peps/pep-0795.rst | 1245 ++++++++++++++++++++++++++++++++++++ peps/pep-0795/sharing1.png | Bin 0 -> 142215 bytes 3 files changed, 1246 insertions(+) create mode 100644 peps/pep-0795.rst create mode 100644 peps/pep-0795/sharing1.png diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS index e000d3934b1..cbdb45c582f 100644 --- a/.github/CODEOWNERS +++ b/.github/CODEOWNERS @@ -672,6 +672,7 @@ peps/pep-0791.rst @vstinner peps/pep-0792.rst @dstufft peps/pep-0793.rst @encukou peps/pep-0794.rst @brettcannon +peps/pep-0795.rst @mdboom # ... peps/pep-0801.rst @warsaw # ... diff --git a/peps/pep-0795.rst b/peps/pep-0795.rst new file mode 100644 index 00000000000..cdc6921930e --- /dev/null +++ b/peps/pep-0795.rst @@ -0,0 +1,1245 @@ +PEP: 795 +Title: Deep Immutability in Python +Author: Matthew Johnson , + Matthew Parkinson , + Sylvan Clebsch , + Fridtjof Peer Stoldt , + Tobias Wrigstad +Sponsor: Michael Droettboom +Discussions-To: Pending +Status: Draft +Type: Standards Track +Created: 19-Jun-2025 +Python-Version: 3.15 +Post-History: + + +Abstract +======== + +This PEP proposes adding a mechanism for deep immutability to +Python. The mechanism requires some changes to the core language, +but user-facing functions are delivered in a module called +``immutable``. This module provides the following functions and types: + +1. The function ``freeze(obj)`` -- turns ``obj`` deeply immutable + +2. The function ``isfrozen(obj)`` -- returns ``True`` if ``obj`` is immutable + +4. The type ``NotFreezable`` which is an empty type which cannot be made immutable and can be used as a super class to classes whose instances should not be possible to freeze + +5. The type ``NotFreezableError`` which is raised on an attempt to mutate an immutable object + +6. The function ``register_freezable(type)`` -- which is used to whitelist types implemented as C extensions, permitting their instances to be made immutable + +Making an object *deeply* immutable recursively renders the object +*and all objects it references* immutable. (Just +making the first object immutable is called *shallow* +immutability.) + +Deep immutability provides strong guarantees against +unintended modifications, thereby improving correctness, security, and +parallel execution safety. + +Immutable objects are managed with reference counting plus cycle +detection just like normal mutable objects, and can be made +immortal. In this PEP, we rely on the GIL to ensure the +correctness of reference counts of immutable objects, but we have +several planned memory management extensions, including support +for atomic reference counting on immutable objects. These are +outlined at the end of this document. + +Immutability in action: + +.. code-block:: python + + from immutable import freeze, isfrozen + + class Foo: + pass + + f = Foo() + g = Foo() + h = Foo() + + f.f = g + g.f = h + h.f = g # cycles are OK! + del g # Remove local ref to g, so g's RC = 1 + del h # Remove local reg to h, so h's RC = 1 + + g.x = "African Swallow" # OK + freeze(f) # Makes, f, g and h immutable + g.x = "European Swallow" # Throws an exception "g is immutable" + isfrozen(h) # returns True + h = None # Cycle detector will eventually find and collect the cycle + + +Motivation +========== + +Ensuring Data Integrity +----------------------- + +Python programs frequently manipulate large, interconnected data +structures such as dictionaries, lists, and user-defined objects. +Unintentional mutations can introduce subtle and +difficult-to-debug errors. By allowing developers to explicitly +freeze objects and their transitive dependencies, Python can +provide stronger correctness guarantees for data processing +pipelines, functional programming paradigms, and API boundaries +where immutability is beneficial. + + +Immutable Objects can be Freely Shared Without Risk of Data Races +----------------------------------------------------------------- + +Python’s Global Interpreter Lock (GIL) mitigates many data race +issues, but as Python evolves towards improved multi-threading and +parallel execution (e.g., subinterpreters and the free-threaded Python +efforts), data races on shared mutable objects become a more +pressing concern. A deep immutability mechanism ensures that +shared objects are not modified concurrently, enabling safer +multi-threaded and parallel computation. Safe sharing of immutable +objects across multiple threads require deep immutability. +Consider the following example: + +.. code-block:: python + + import threading + + data = [1, 2, 4, 8] + length = len(data) + pair = (data, length) + + threading.Thread(target=print, args=(pair,)).start() + + del data[2] + +The shallow immutability of the ``pair`` tuple prevents the +``data`` list from being swapped for another list, but the list +itself is not immutable. Thus, the ``print`` function in the newly +spawned thread will be racing with the deletion. In Python 3.12, +this is not a problem as the GIL prevents this race. To ensure +container thread-safety, :pep:`703` +proposes per-object locks instead. If ``pair`` is immutable, the +deletion would have caused an error. + +The following image illustrates that as soon as an object *a* +is reachable by two threads, then all other objects that +*a* can reach are also reachable by both threads. The dashed +red references to *c* and *d* are not possible because then +*c* and *d* would not be in areas where only a single thread +could reach them. + +To map the code example above to the figure -- ``pair`` is *a* and ``list`` is *b*. + +.. image:: pep-0795/sharing1.png + :width: 50% + :alt: An image showing two overlapping "regions of memory", + local to each thread, and what is private to each thread + and what is shared. + +See also the discussion about extensions further down in this +document. + +Deep immutability can be implemented efficiently. An alternative approach +would be to detect data-races using a read-barrier based approach, however, +this cannot be implemented as efficiently. We discuss this in the alternatives +section. As highlighted above, immutability also has value in single-threaded +application, i.e. where there is no fear of data races. + + +Optimisations and Caching Benefits +---------------------------------- + +Immutable objects provide opportunities for optimisation, such as +structural sharing, memoization, and just-in-time (JIT) +compilation techniques (specialising for immutable data, e.g. +fixed shape, fewer barriers, inlining, etc.). Freezing objects can +allow Python to implement more efficient caching mechanisms and +enable compiler optimisations that rely on immutability +assumptions. This PEP will permit such opportunities to go +beyond today's immutable objects (like ``int``, ``string``) and +*shallow* immutable objects (``tuple``, ``frozenset``). + + +Specification +============= + +Note: our current prototype implementation was authored on-top of +Python 3.12. To avoid blocking on rebasing on 3.14 to force +decisions about changes to implementation detail, we are +circulating this document to discuss the design ideas, +and some of the unaffected aspects of the implementation. + +An outline of the changes that we anticipate are required for +Python 3.14 is can be found at the `end of the document `_. + + +Changes to Python Objects +------------------------- + +Every Python object will have a flag that keeps track of its +immutability status. Details about the default value of +this flag is discussed further down in this document. + +The flag can be added without extending the size of the +Python object header. + + +Implementation of Immutability +------------------------------ + +Immutability is enforced through run-time checking. The macro +``Py_CHECKWRITE(op)`` is inserted on all paths that are guaranteed +to end up in a write to ``op``. The macro inspects the immutability +flag in the header of ``op`` and signals an error if the immutability +flag is set. + +A typical use of this check looks like this: + +.. code-block:: c + + if (!Py_CHECKWRITE(op)) { // perform the check + PyErr_WriteToImmutable(op); // raise the error if the check fails + return NULL; // abort the write + } + ... // code that performs the write + + +Writes are common in the CPython code base and the writes lack a +common "code path" that they pass. To this end, the PEP requires a +``Py_CHECKWRITE`` call to be inserted and there are several places +in the CPython code base that are changed as a consequence of this +PEP. So far we have identified around 70 places in core Python which +needed a ``Py_CHECKWRITE`` check. Modules in the standard library +have required somewhere between 5 and 15 checks per module. + + +Backwards Compatibility +======================= + +This proposal intends to be fully backward compatible, as no existing Python +code will be affected unless it explicitly calls ``freeze(obj)``. +Immutable objects will raise errors only when mutation is attempted. + + +Opt-In vs. Opt-Out +------------------ + +All pure Python objects can be made immutable, provided all their members +and their base classes can be made immutable. However, for types which +are partially or completely implemented in C, support for +immutability requires some work on both exposing objects to +freezing, and to enforce immutability in mutating C-functions. + +From a backwards compatibility perspective, an opt-in model keeps +things simple: all existing code keeps working, and only code that +wishes to support immutability needs updating. The downside of the +opt-in model is that a large part of all Python libraries cannot +be (even nominally) made immutable (out-of-the-box). + + +Strictness +---------- + +A strict interpretation of deep immutability does not permit an +immutable object to reference a mutable object. This model is both +easy to explain and understand, and an object's immutability can +be "trusted" --- it is not possible for an immutable object to +change through some nested mutable state [#RC]_. At the same time +it limits the utility of freezing as many Python objects contain +types outside of the standard library defined in C, which must +opt-in immutability before they can be frozen. + +This PEP proposes immutability to be strict. + + +Dealing with Failure During Freezing +------------------------------------ + +Regardless whether support for freezing is opt-in or opt-out some +types will not be freezable. (Example such types include IO types +like file handles, and caches -- as opposed to the cached +objects.) This raises the question how to handle failure to freeze +an object graph. Consider the object graph ``o1 --> o2 --> o3`` +where ``o1`` and ``o3`` can be made immutable, but ``o2`` cannot. +What are the possible behaviours of ``freeze(o1)``? + +1. Freeze fails partially. All subgraphs which could be made + immutable entirely remain immutable. Remaining objects remain + mutable. In our example, ``o3`` remains immutable but ``o1`` and + ``o2`` remain mutable. This preserves strict immutability. The + exception thrown by the failing ``freeze(o1)`` call will + contain ``o2`` (the place that caused freezing to fail) and + ``o1`` (the object in the graph that holds on to the failing + object) to facilitate debugging. + +2. **Rejected alternative**: Freeze fails completely. In the strict + interpretation of deep immutability, freezing ``o1`` is not + possible because ``o1`` contains a reference to an un-freezable + object ``o2``. In this scenario, the object graph ``o1 --> o2 + --> o3`` remains mutable and ``freeze(o1)`` raises an exception + when the object graph traversal encounters ``o2``. + +3. **Rejected alternative**: Freeze succeeds by altering the + graph. In this example removing ``o2`` from the graph or + swapping out ``o2`` for a placeholder object to be able to + freeze the graph. This alternative becomes complicated both to + reason about from a user's perspective, and to implement when + ``o2`` is referenced multiple times. + +4. **Rejected alternative**: Permit the user to choose between + alternatives 1) and 3) at use-site. In this case, the + ``freeze`` function takes an optional 2nd argument ``strict`` + which must either be ``True`` or ``False``. In the first case, + ``freeze`` behaves as in alternative 1), in the second case, + it behaves as in alternative 2). We could further track whether + an object is strictly immutable or not in order to prevent + non-strictly immutable objects to participate in operations + which require strictness. This adds additional complexity to + the implementation, and also for the user. + +This PEP proposes following alternative 1, where freezing either +succeeds or fails partially. + + +New Obligations on C Extensions +------------------------------- + +Due to the opt-in decision, there are no *obligations* for C +extensions that do not want to add support for immutability. + +Because our implementation builds on information available to the CPython +cycle detector, types defined through C code will support immutability +"out of the box" as long as they use Python standard types to store +data and uses the built-in functions of these types to modify the data. + +To make its instances freezable, a type that uses C extensions +that adds new functionality implemented in C must register +themselves using ``register_freezable(type)``. Example: + +.. code-block:: Python + + PyObject *register_freezable = _PyImport_GetModuleAttrString("immutable", "register_freezable"); + if(register_freezable != NULL) + { + PyObject* result = PyObject_CallOneArg(register_freezable, (PyObject *)st->Element_Type); + if(result == NULL){ + goto error; + } + + Py_DECREF(register_freezable); + } + +If you construct a C type using freezable metaclasses it will itself be freezable, +without need for explicit registration. + +To properly support immutability, C extensions that directly write +to data which can be made immutable should add the +``Py_CHECKWRITE`` macro shown above on all paths in the code that +lead to writes to that data. Notably, if C extensions manage their +data through Python objects, no changes are needed. + +**Rejected alternative**: Python objects may define a +``__freeze__`` method which will be called **after** an object has +been made immutable. This hook can be used to freeze or otherwise +manage any other state on the side that is introduced through a +C-extension. + +C extensions that define data that is outside of the heap traced +by the CPython cycle detector should either manually implement +freezing by using ``Py_CHECKWRITE`` or ensure that all accesses to +this data is *thread-safe*. There are cases where too strict +adherence to immutability is undesirable (as exemplified by our +mutable reference counts), but ideally, it should not be able to +directly observe these effects. (For example, taking the reference +count of an immutable object is not supported to prevent code from +branching on a value that can change non-deterministically by +actions taken in parallel threads.) + + +Examples of Uses of CHECKWRITE +------------------------------ + +Inspiration and examples can be found by looking at existing +uses of ``Py_CHECKWRITE`` in the CPython codebase. Two good +starting places are ``object.c`` `[1]`_ and ``dictobject.c`` `[2]`_. + +.. _[1]: https://github.com/mjp41/cpython/pull/51/files#diff-ba56d44ce0dd731d979970b966fde9d8dd15d12a82f727a052a8ad48d4a49363 +.. _[2]: https://github.com/mjp41/cpython/pull/51/files#diff-b08a47ddc5bc20b2e99ac2e5aa199ca24a56b994e7bc64e918513356088c20ae + + +Expected Usage of Immutability +------------------------------ + +The main motivation for adding immutability in this PEP is to +facilitate concurrent programming in Python. This is not something +that Python's type system currently supports -- developers have to +rely on other (i.e. not type-driven) methods to communicate around +thread-safety and locking protocols. We expect that the same +methodology works for immutable objects with the added benefit +that mistakes lead to exceptions rather than incorrectness bugs or +crashes. As the Python community adopts immutability, we expect to +learn about the patterns that arise and this can inform e.g. how +to develop tools, documentation, and types for facilitating +programming with immutable objects in Python. + +We expect that libraries that for example want to provide intended +constants may adopt immutability as a way to guard against someone +say re-defining pi. Freezing a module's state can be made optional +(opt-in or opt-out) so that the option of re-defining pi can be +retained. + +If immutability is adopted widely, we would expect libraries to +contain a section that detail what types etc. that it provides +that can be made immutable or not. If Python's type system adds +support for (say) distinguishing between must-be-mutable, +must-be-immutability, and may-be-immutable, such annotations can +be added to the documentation of a library's public API. + +If a library relies on user-provided data to be immutable, we +expect the appropriate pattern is to check that the data is +immutable and if not raising an exception rather than to make the +data immutable inside the library code. This pushes the obligation +to the user in a way that will not lead to surprises due to data +becoming immutable under foot. + +We expect programmers to use immutability to facilitate safe +communication between threads, and for safe sharing of data +between threads. In both cases, we believe it is convenient to be +able to freeze a data structure in-place and share it, and we +expect programmers to have constructed these data structures with +this use case in mind. + + +Deep Freezing Semantics +======================= + +Following the outcomes of the design decisions discussed just +above, the ``freeze(obj)`` function works as follows: + +1. It recursively marks ``obj`` and all objects reachable from ``obj`` + immutable. + +2. If ``obj`` is already immutable (e.g., an integer, string, or a + previously frozen object), the recursion terminates. If ``obj`` cannot + be made immutable, the entire freeze operation is aborted without making any + object immutable. + +3. The freeze operation follows object references (relying on ``tp_traverse`` + in the type structs of the objects involved), including: + + * Object attributes (``__dict__`` for user-defined objects, + ``tp_dict`` for built-in types). + + * Container elements (e.g., lists, tuples, dictionaries, + sets). + + * The ``__class__`` attribute of an object (which makes freezing + instances of user-defined classes also freeze their class + and its attributes). + + * The ``__bases__`` chain in classes (freezing a class freezes its + base classes). + +5. Attempting to mutate an immutable object raises a type error + with a self-explanatory message. + + +Illustration of the Deep Freezing Semantics +------------------------------------------- + +Consider the following code: + +.. code-block:: python + + class Foo: + pass + + x = Foo() + x.f = 42 + + +The ``Foo`` instance pointed to by ``x`` consists of several +objects: its fields are stored in a dictionary object, and the +assignment ``x.f = 42`` adds two objects to the dictionary in the +form of a string key ``"f"`` and its associated value ``42``. +These objects each have pointers to the ``string`` and ``int`` +type objects respectively. Similarly, the ``foo`` instance has a +pointer to the ``Foo`` type object. Finally, all type objects have +pointers to the same meta class object (``type``). + +Calling ``freeze(x)`` will freeze **all** of these objects. + + +Default (Im)Mutabiliy +--------------------- + +Except for the type object for ``NotFreezable``, no objects are +immutable by default. + +**Rejected alternative**: Interned strings, numbers in the small +integer cache, and tuples of immutable objects could be made +immutable in this PEP. This is either consistent with current +Python semantics or backwards-compatible. We have rejected this +for now as we have not seen a strong need to do so. (A reasonable +such design would make *all* numbers immutable, not just those in +the small integer cache. This should be properly investigated.) + + +Consequences of Deep Freezing +============================= + +* The most obvious consequence of deep freezing is that it can lead + to surprising results when programmers fail to reason correctly + about the object structures in memory and how the objects reference + each other. For example, consider ``freeze(x)`` followed by + ``y.f = 42``. If the object in ``x`` can reach the same object that + ``y`` points to, then, the assignment will fail. **Mitigation:** To + facilitate debugging, exceptions due to attempting to mutate immutable + objects will include information about on what line an object was made + immutable. + +* Class Freezing: Freezing an instance of a user-defined class + will also freeze its class. Otherwise, sharing an immutable object + across threads would lead to sharing its *mutable* type object. Thus, + freezing an object also freezes the type type object of its super + classes. This means that any metaprogramming or changes to a class + must happen before a class is made immutable. **Mitigation:** An immutable class + can be extended and its behaviour overridden through normal object-oriented + means. If neccessary, it is possible to add an option to make a mutable + copy of immutable objects and classes, which could then be changed. + Mutable instances of an immutable class can have their classes changed + to the mutable copy by reassigning ``__class__``. + +* Metaclass Freezing: Since class objects have metaclasses, + freezing a class may propagate upwards through the metaclass + hierarchy. This means that the ``type`` object will be made immutable + at the first call of ``freeze``. **Mitigation:** We have not explored + mitigation for this, and we are also not aware of major problems + stemming from this design. + +* Global State Impact: Although we have not seen this during our + later stages of testing, it is possible that freezing an object that references + global state (e.g., ``sys.modules``, built-ins) could + inadvertently freeze critical parts of the interpreter. + **Mitigation:** Avoiding accidental freezing is possible by + inheriting from (or storing a pointer to) the ``NotFreezable`` + class. Also, when the Python interpreter is exiting, we make all + immutable objects mutable to facilitate a clean exit of the + interpreter. Also note that it is not possible to effectively + disable module imports by freezing. + +As the above list shows, a side-effect of freezing an object is +that its type becomes immutable too. Consider the following program, +which is not legal in this PEP because it modifies the type of an +immutable object: + +.. code-block:: python + + from immutable import freeze + + class Counter: + def __init__(self, initial_value): + self.value = initial_value + def inc(self): + self.value += 1 + def dec(self): + self.value -= 1 + def get(self): + return self.value + + c = Counter(0) + c.get() # returns 0 + freeze(c) # (*) -- this locks the value of the counter to 0 + ... + Counter.get = lambda self: 42 # throws exception because Counter is immutable + c.get() # would have returned 42 unless the line above had been "stopped" + +With this PEP, the code above throws an exception on +Line (*) because the type object for the ``Counter`` type +is immutable. Our freeze algorithm takes care of this as +it follows the class reference from ``c``. If we did not +freeze the ``Counter`` type object, the above code would +work and the counter will effectively be mutable because +of the change to its class. + +The dangers of not freezing the type is apparent when considering +avoiding data races in a concurrent program. If an immutable counter +is shared between two threads, the threads are still able to +race on the ``Counter`` class type object. + +As types are immutable, this problem is avoided. Note that +freezing a class needs to freeze its superclasses as well. + + +Subclassing Immutable Classes +----------------------------- + +CPython classes hold references to their subclasses. If +immutability it taken literally, it would not be permitted to +create a subclass of an immutable type. Because this reference +does not get exposed to the programmer in any dangerous way, we +permit immutable classes to be subclassed (by mutable classes). C.f. +`Sharing Immutable Data Across Subinterpreters`_. + + +Freezing Function Objects +------------------------- + +Function objects can be thought of as regular objects whose fields +are its local variables -- some of which may be captured from +enclosing scopes. Thus, freezing function objects and lambdas is +surprisingly involved. + +Consider the following scenario: + +.. code-block:: python + + from immutable import freeze + + def example1(): + x = 0 + + def foo(): + return x + + freeze(foo) + ... # some code, e.g. pass foo to another thread + x = 1 + foo() + + example1() + +In the code above, the ``foo`` function object captures the ``x`` +variable from its enclosing scope. While ``x`` happens to point to +an immutable object, the variable itself (the frame of the function object) +is mutable. Unless something is done to prevent it (see below!), passing +``foo`` to another thread will make the assignment ``x = 1`` a potential +data race. + +We consider freezing of a function to freeze that function's +meaning at that point in time. In the code above, that means that +``foo`` gets its own copy of ``x`` which will have value of the enclosing +``x`` at the time of freezing, in this case 0. + +Thus, the assignment ``x = 1`` is still permitted as it will not affect +``foo``, and it may therefore not contribute to a data race. Furthermore, +the result of calling ``foo()`` will be 0 -- not 1! + +This is implemented by having ``x`` in ``foo`` point to a fresh +cell and then freezing the cell (and similar for global capture). +Note that this also prevents ``x`` from being reassigned. + +We believe that this design is a sweet-spot that is intuitive and +permissive. Note that we will treat freezing functions that +capture enclosing state in the same way regardless of whether the +enclosing state is another function or the top-level (i.e., the +enclosing scope is ``globals()``). + +(A **rejected alternative** is to freeze ``x`` in the +enclosing scope. This is problematic when a captured variable is +in ``globals()`` and also rejects more programs.) + +Now consider freezing the following function: + +.. code-block:: python + + from immutable import freeze + + def example2(): + x = 0 + def foo(a = False): + nonlocal x + if a: + a = a + 1 # Note: updating local variables work, even in a frozen function + return a + else: + x = x + 1 + return x + + freeze(foo) + foo(41) # OK, returns 42 + foo() # Throws NotWriteableError + + example2() + +This example illustrates two things. The first call to ``foo(41)`` +shows that local variables on the frame of a call to an immutable +function objects are mutable. The second call shows that captured +variables are not. Note that the default value of ``a`` will be +made immutable when ``foo`` is frozen. Thus, the problem of +side-effects on default values on parameters is avoided. + +Immutable function objects that access globals, e.g. through an +explicit call to ``globals()``, will throw an exception when +called. + + +Implementation Details +====================== + +1. Add the ``immutable`` module, the ``NotWriteableError`` type, and + the ``NotFreezable`` type. + +2. Add the ``freeze(obj)`` function to the ``immutable`` module and + ensure that it traverses object references safely, including + cycle detection, and marks objects appropriately, and backs + out on failure, possibly partially freezing the object graph. + +3. Add the ``register_freezable(type)`` function that is used to + whitelist types implemented as C extensions, permitting their + instances to be made immutable. + +4. Add the ``isfrozen(obj)`` function to the ``immutable`` module + that checks whether or not an object is immutable. The status + is accessible through ``_Py_ISIMMUTABLE`` in the C API and in + Python code through the ``isfrozen(obj)`` function. + +5. Modify object mutation operations (``PyObject_SetAttr``, + ``PyDict_SetItem``, ``PyList_SetItem``, etc.) to check the + flag and raise an error when appropriate. + +6. Modify mutation operations in modules in the standard library. + + + +Changes to the C ABI +-------------------- + +* ``Py_CHECKWRITE`` + +* ``_Py_IsImmutable`` + +* ``PyErr_WriteToImmutable`` + +Changes to the internal API +--------------------------- + +* ``_PyType_HasExtensionSlots(PyTypeObject*)`` -- determines whether a TypeObject adds novel functionality in C + +* ``_PyNotFreezable_Type`` + +* ``_PyImmutability_Freeze`` + +* ``_RegisterFreezable`` + +* ``_PyImmutability_IsFreezable`` + + +Performance Implications +======================== + +The cost of checking for immutability violations is +an extra dereference of checking the flag on writes. +There are implementation-specific issues, such as +various changes based on how and where the bit is stolen. + + +More Rejected Alternatives +========================== + +1. Shallow Freezing: Only mark the top-level object as immutable. + This would be less effective for ensuring true immutability + across references. In particular, this would not make it safe + to share the results of ``freeze(obj)`` across threads without risking + data-race errors. Shallow immutability is not strong enough to support + sharing immutable objects across subinterpreters (see extensions). + +2. Copy-on-Write Immutability: Instead of raising errors on + mutation, create a modified copy. However, this changes object + identity semantics and is less predictable. Support for copy-on-write + may be added later, if a suitable design can be found, but not as + an alternative to what this PEP proposes. + +3. Immutable Subclasses: Introduce ``ImmutableDict``, ``ImmutableList``, + etc., instead of freezing existing objects. However, this does + not generalize well to arbitrary objects and adds considerable + complexity to all code bases. + +4. Deep freezing immutable copies as proposed in :pep:`351` The + freeze protocol. That PEP + is the spiritual ancestor to this PEP which tackles the + problems of the ancestor PEP and more (e.g. meaning of + immutability when types are mutable, immortality, etc). + +5. Deep freezing replaces data races with exceptions on attempts to + mutate immutable objects. Another alternative would be to keep + objects mutable and build a data-race detector that catches read--write + and write--write races. This alternative was rejected for two main + reasons: + + 1. It is expensive to implement: it needs a read-barrier to + detect what objects are being read by threads to capture + read--write races. + + 2. While more permissive, the model suffers from non-determinism. + Data races can be hidden in corner cases that require complex + logic and/or temporal interactions which can be hard to + test and reproduce. + +Another rejected idea was to provide a function ``isfreezable(obj)`` which +returns ``True`` if all objects reachable from ``obj`` can be made +immutable. This was rejected because free-threaded Python permits +data-races during freezing. This means that the result of the check +can be non-deterministic. A better way is to simply try to make +an object immutable and catch the exception if the object could not +be frozen. + + +A Note on Modularisation +======================== + +While the ``freeze(obj)`` function is available to Python programmers +in the ``immutable`` module, the actual freezing code has to live +inside core Python. This is for three reasons: + +1. The core object type needs to be able to freeze just-in-time + dictionaries created by its accessors when the object itself is + immutable. + +2. The managed buffer type needs to be immutable when the object it + is created from is immutable. + +3. Teardown of strongly connected components of immutable objects + (see `Simplified Garbage Collection for Immutable Object + Graphs`_) must be hooked into ``Py_DECREF``. + +As such, we implement a function which is not in the limited API +(and thus not part of the stable C ABI) called ``_PyImmutability_Freeze`` +which performs the freezing logic. This is used internally as a C +Python implementation detail, and then exposed to Python through +the ``freeze(obj)`` function in the ``immutable`` module. + + +Weak References +=============== + +Weak references are turned into strong references during freezing. +Thus, an immutable object cannot be effectively mutated by a +weakly referenced nested object being garbage collected. If a weak +reference loses its object during freezing, we treat this as a +failure to freeze since the program is effectively racing with the +garbage collector. + +A **rejected alternative** is to nullify the weak reference during +freezing. This avoid the promotion to a strong reference while +ensures that the immutable object stays the same throughout its +lifetime, but probably has the unwanted semantics of pruning the +object graph while freezing it. (Imagine a hash table with weak +references for its keys -- if freezing it removes all its keys, +the hash table is essentially useless.) + +Another **rejected alternative** is to simply leave weak references +as is. This was rejected as it makes immutable objects effectively +mutable and access to shared immutable objects can race on accesses +to weak references. + + +Hashing +======= + +Deep immutability opens up the possibility of any freezable object being +hashable, due to the fixed state of the object graph making it possible to compute +stable hash values over the graph as is the case with ``tuple`` and ``frozenset`` . However, +there are several complications (listed below) which should be kept in mind for any future +PEPs which build on this work at add hashability for frozen objects: + + +Instance versus Type Hashability +-------------------------------- + +At the moment, the test for +`hashability `__ +is based upon the presence (or absence) of a ``__hash__`` method and an +``__eq__`` method. Places where ``PyObject_HashNotImplemented`` is currently +used would need to be modified as appropriate to have a contextual logic +which provides a default implementation that uses ``id()`` if the object +instance has been frozen, and throws a type error if not. + +This causes issues with type checks, however. The check of +``isinstance(x, Hashable)`` would need to become contextual, and +``issubclass(type(x), Hashable)`` would become underdetermined for +many types. Handling this in a way that is not surprising will require +careful design considerations. + + +Equality of Immutable Objects +----------------------------- + +One consideration with the naive approach (*i.e.*, hash via ``id()``) is +that it can result in confusing outcomes. For example, if there were +to be two lists: + +.. code-block:: python + + a = [1, 2, 3, 4] + b = [1, 2, 3, 4] + assert(hash(a) == hash(b)) + +There would be a reasonable expectation that this assertion would be true, +as it is for two identically defined tuples. However, without a careful +implementation of ``__hash__`` and ``__eq__`` this would not be the case. +Our opinion is that an approach like that used in ``tuplehash`` is +recommended in order to avoid this behavior. + + +Decorators of Immutable Functions +================================= + +One natural issue that arises from deeply immutable functions is the +state of various objects which are attached to them, such as decorators. +In particular, the case of ``lru_cache`` is worth investigating. If the cache +is made immutable, then freezing the function has essentially disabled the +functionality of the decorator. This might be the correct and desirable +functionality, from a thread safety perspective! In practice, we see three +potential approaches: + +1. The cache is frozen in its state at the point when freeze is called. + Cache misses will result in an immutability exception. + +2. Access to the cache is protected by a lock to ensure thread safety + +3. There is one version of the cache per interpreter (*i.e.*, the cache is thread local) + +There are arguments in favor of each. Of them, (3) would +require additional class to be added (*e.g.*, via the ``immutable`` module) +which provides "interpreter local" dictionary variable that can be safely +accessed by whichever interpreter is currently calling the immutable function. +We have chosen (1) in order to provide clear feedback to the programmer that +they likely do not want to freeze a function which has a (necessarily) mutable +decorator or other object attached to it. It is likely not possible to make +all decorators work via a general mechanism, but providing some tools to +provide library authors with the means to provide a better experience for +immutable decorators is in scope for a future PEP building on this work. + + +Deferred Ideas +============== + +Copy-on-Write +------------- + +It *may* be possible to enforce immutability through copy-on-write. +Such a system would not raise an exception on ``x.f = y`` when +``x`` points to an immutable object, but rather copy the contents +of ``x`` under the hood. Essentially, ``x.f = y`` turns into ``x = +deep_copy(x); x.f = y``. While it is nice to avoid the error, this +can also have surprising results (e.g. loss of identity of ``x``), +is less predictable (suddenly the time needed to execute ``x.f = y`` +becomes proportional to the object graph rooted in ``x``) and may +make code harder to reason about. + + +Typing +------ + +Support for immutability in the type system is worth exploring in +the future. Especially if Python adopts an ownership model that +enables reasoning about aliasing, see `Data-Race Free Python`_ +below. + +Currently in Python, ``x: Foo`` does not give very strong +guarantees about whether ``x.bar(42)`` will work or not, because +of Python's strong reflection support that permits changing a +class at run-time, or even changing the type of an object. +Making objects immutable in-place exacerbates this situation as +``x.bar(42)`` may now fail because ``x`` has been made immutable. +However, in contrast to failures due to reflective changes of +a class, a ``NotFreezableError`` will point to the place in the +code where the object was frozen. This should facilitate debugging. + +In short: the possibility of making objects immutable in-place +does not weaken type-based reasoning in Python on a fundamental +level. However, if immutability becomes very frequently used, it +may lead to the unsoundness which already exists in Python's current +typing story surfacing more frequently. As alluded to in the +future work on `Data-Race Free Python`_, this can be mitigated by +using region-based ownership. + +There are several challenges when adding immutability to a type +system for an object-oriented programming language. First, self +typing becomes more important as some methods require that self is +mutable, some require that self is immutable (e.g. to be +thread-safe), and some methods can operate on either self type. +The latter subtly needs to preserve the invariants of immutability +but also cannot rely on immutability. We would need a way of +expressing this in the type system. This could probably be done by +annotating the self type in the three different ways above -- +mutable, immutable, and works either way. + +A possibility would be to express the immutable version of a type +``T`` as the intersection type ``immutable & T`` and a type that +must preserve immutability but may not rely on it as the union +of the immutable intersection type with its mutable type +``(immutable & T) | T``. + +Furthermore, deep immutability requires some form of "view-point +adaption", which means that when ``x`` is immutable, ``x.f`` is +also immutable, regardless of the declared type of ``f``. +View-point adaptation is crucial for ensuring that immutable +objects treat themselves correctly internally and is not part of +standard type systems (but well-researched in academia). + +Making ``freeze`` a soft keyword as opposed to a function `has +been proposed +`_ +to facilitate flow typing. We believe this is an excellent +proposal to consider for the future in conjunction with work on +typing immutability. + + +Naming +====== + +We propose to call deep immutability simply "immutability". This +is simple, standard, and sufficiently distinguishable from other +concepts like frozen modules. + +We also propose to call the act of making something immutable +"freezing", and the function that does so ``freeze()``. This is +the same as used in JavaScript and Ruby and is considerably +snappier than ``make_immutable()`` which we suspect would be +immediately shortened in the community lingo. The major concern +with the freeze verb is that immutable objects risk being referred +to as "frozen" which then comes close to frozen modules (bad link) +and types like ``frozenset`` (good link). + +While naming is obviously important, the names we picked initially +in this PEP are not important and can be replaced. A good short +verb for the action seems reasonable. Because the term immutable +is so standard, we should think twice about replacing it with +something else. + +Qualifying immutability and freezing with an additional "deep" (as +proposed `here +`_) +seems like adding extra hassle for unclear gains. + + +Future Extensions +================= + +This PEP is the first in a series of PEPs with the goal of delivering +a Data-Race Free Python that is theoretically compatible with, but +notably not contigent on :pep:`703`. + +This work has three different components which we intend to +package into two discrete PEPs (called A and B below): + +1. Support for identifying and freeing cyclic immutable garbage + using reference counting. (PEP A) + +2. Support for sharing immutable data across subinterpreters using + atomic reference counting of immutable objects to permit + concurrent increments and decrements on shared object RC's. (PEP A) + +3. Support for sharing mutable data across subinterpreters, with + dynamic ownership protecting against data races. (PEP B) + +Together these components deliver "Data-Race Free Python". +Note that "PEP A" has value even if "PEP B" would not materialise +for whatever reason. + + +Simplified Garbage Collection for Immutable Object Graphs +--------------------------------------------------------- + +In `previous work `_, +we have identified that objects that make up cyclic immutable +garbage will always have the same lifetime. This means that a +single reference count could be used to track the lifetimes of +all the objects in such a strongly connected component (SCC). + +We plan to extend the freeze logic with a SCC analysis that +creates a designated (atomic) reference count for the entire +SCC, such that reference count manipulations on any object in +the SCC will be "forwarded" to that shared reference count. +This can be done without bloating objects by repurposing the +existing reference counter data to be used as a pointer to +the shared counter. + +This technique permits handling cyclic garbage using plain +reference counting, and because of the single reference count +for an entire SCC, we will detect when all the objects in the +SCC expire at once. + +This approach requires a second bit. Our `reference implementation`_ +already steals this bit in preparation for this extension. + + +Support for Atomic Reference Counting +------------------------------------- + +As a necessary requirement for the extension `Sharing Immutable Data Across Subinterpreters`_, +we will add support for atomic reference counting for immutable objects. This +will complement work in `Simplified Garbage Collection for Immutable Object Graphs`_, +which aims to make memory management of immutable data more efficient. + +When immutable data is shared across threads we must ensure that +concurrent reference count manipulations are correct, which in turns +requires atomic increments and decrements. Note that since we are only +planning to share immutable objects across different GIL's, it is +*not* possible for two threads to read--write or write--write race +on a single field. Thus we only need to protect the reference counter +manipulations, avoiding most of the complexity of :pep:`703`. + + +Sharing Immutable Data Across Subinterpreters +--------------------------------------------- + +We plan to extend the functionality of multiple subinterpreters in :pep:`734` +to *share* immutable data without copying. This is safe and +efficient as it avoids the copying or serialisation when +objects are transmitted across subinterpreters. + +This change will require reference counts to be atomic (as +discussed above) and the subclass list of a type object to +be made thread-safe. Additionally, we will need to change +the API for getting a class' subclasses in order to avoid +data races. + +This change requires modules loaded in one subinterpreter to be +accessible from another. + + +Data-Race Free Python +--------------------- + +While useful on their own, all the changes above are building +blocks of Data-Race Free Python. Data-Race Free Python will +borrow concepts from ownership (namely region-based ownership, +see e.g. `Cyclone `_) to make Python programs data-race free +by construction. Which will permit multiple subinterpreters to +share *mutable* state, although only one subinterpreter at a time +will be able to access (read or write) to that state. +This work is also compatible with free-theaded Python (:pep:`703`). + +A description of the ownership model can be found in a paper accepted +for PLDI 2025 (an academic conference on design and implementation of +programming languages): `Dynamic Region Ownership for Concurrency +Safety `_. + +It is important to point out that Data-Race Free Python is different +from :pep:`703`, but aims to be fully compatible with that PEP, and +we believe that both PEPs can benefit from each other. In essence +:pep:`703` focuses on making the CPython run-time resilient against +data races in Python programs: a poorly synchronized Python program +should not be able to corrupt reference counts, or other parts of +the Python interpreter. The complementary goal pursued by this PEP +is to make it impossible for Python programs to have data races. +Support for deeply immutable data is the first important step +towards this goal. + +The region-based ownership that we propose can be used to restrict +freezing to only be permitted on regions which are isolated. If +such a restriction is built into the system, then there will be a +guarantee that freezing objects will not turn affect references +elsewhere in the system (they cannot exist when the region is +isolated). Such a design can also be used to track immutability +better in a type system and would be able to deliver a guarantee +that a reference of a mutable type never points to an immutable +object, and conversely. These points will be unpacked and made +more clear in the PEP for the ownership model. + + + +Reference Implementation +======================== + +`Available here `_. + +There are some discrepancies between this PEP and the reference +implementation, including: + +- The ``NotFreezable`` type is currently freezable (but inheriting + from it stops instances of the inheriting class from being made immutable). + + +Rebasing on Python 3.14 +======================= + +We have found two areas that need to be addressed to integrate this work with "free-threaded Python": data-representation and data-races during freeze. + +Data-representation for immutability +------------------------------------ + +With free-threaded Python the representation of the reference +count has been changed. We could either borrow a bit to represent +if an object is immutable, or alternatively, we could use the new +``ob_tid`` field to have a special value for immutable state. Using +``ob_tid`` would allow for standard mutable thread local objects to +remain the fast path, and is our preferred alternative. + +The extensions use use SCC calculations to detect cycles in +immutable graphs, would require additional state. Repurposing +``ob_tid`` and ``ob_ref_shared`` would allow sufficient space for the +necessary calculation. + +Data-races during freeze +------------------------ + +We consider the following races + +- Freezing some objects concurrently with another thread checking if a graph is immutable. + +- Freezing some objects concurrently with another thread mutating those objects. + +- Freezing some objects concurrently with another thread freezing those objects. + +To address the first race, we need to consider strictness of deep +immutability. We need to ensure that querying an object graph for +immutability only says yes if it is deeply immutable. This +requires a two step immutable state: immutable but not strict, and +then immutable and strict. On a DFS traversal of the object graph +items are marked as immutable but not strict on the pre-order +step, and then immutable and strict on the post-order step. To +query if a graph is immutable, we will require the "immutable and +strict" state. + +Handling mutation during freeze can use the mutex added by +free-threading. There are some cases where mutation does not +require the acquisition of a mutex, which would no longer allowed +with this feature. Freezing would be required to lock the object, +marks it as immutable, release the lock, and then read all its +fields. + +The final case is the most complex detecting parallel freezing of +an object graph. We will consider this an error. This error can be +detected as follows. If we encounter an object that is "immutable +but not strict", then this should be on the path to the current +object from the starting point of the freeze. If this is not the +case, then we must be observing another thread freezing an object +graph. The algorithm should back out the pending aspects of +freeze, and raise an exception to the user. This can naturally be +integrated with the SCC algorithm. + + +References +========== + +* :pep:`703` Making the Global Interpreter Lock Optional in CPython + +* :pep:`351` The freeze protocol + +* :pep:`734` Multiple Interpreters in the Stdlib + +* :pep:`683` Immortal Objects, Using a Fixed Refcount + + +.. rubric:: Footnotes + +.. [#RC] Note that the same logic does not apply to e.g. an + object's reference count. The reference count is + metadata about an object that is stored in the object + for purely pragmatic reasons, but this data really + belongs to the memory management logic of the + interpreter, not the object itself. + +Copyright +========= + +This document is placed in the public domain or under the +CC0-1.0-Universal license, whichever is more permissive. diff --git a/peps/pep-0795/sharing1.png b/peps/pep-0795/sharing1.png new file mode 100644 index 0000000000000000000000000000000000000000..d8484a3bf24fe856fc4b53da613eb73e7b96ff35 GIT binary patch literal 142215 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 z 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
    ma*!mlZ1{2G{)|Hd#qePvD3jmCO79 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%0A!L5ry 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 z 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 WZHRo3%(w^sk$fpDS}3CX@&5oVA-ul; literal 0 HcmV?d00001 From fa34d5ae8c2c22d3424f58073aeb95307ba993b4 Mon Sep 17 00:00:00 2001 From: Tobias Wrigstad Date: Thu, 19 Jun 2025 18:34:37 +0900 Subject: [PATCH 2/8] Fixed a broken list numbering --- peps/pep-0795.rst | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/peps/pep-0795.rst b/peps/pep-0795.rst index cdc6921930e..1a1a14f5352 100644 --- a/peps/pep-0795.rst +++ b/peps/pep-0795.rst @@ -26,11 +26,11 @@ but user-facing functions are delivered in a module called 2. The function ``isfrozen(obj)`` -- returns ``True`` if ``obj`` is immutable -4. The type ``NotFreezable`` which is an empty type which cannot be made immutable and can be used as a super class to classes whose instances should not be possible to freeze +3. The type ``NotFreezable`` which is an empty type which cannot be made immutable and can be used as a super class to classes whose instances should not be possible to freeze -5. The type ``NotFreezableError`` which is raised on an attempt to mutate an immutable object +4. The type ``NotFreezableError`` which is raised on an attempt to mutate an immutable object -6. The function ``register_freezable(type)`` -- which is used to whitelist types implemented as C extensions, permitting their instances to be made immutable +5. The function ``register_freezable(type)`` -- which is used to whitelist types implemented as C extensions, permitting their instances to be made immutable Making an object *deeply* immutable recursively renders the object *and all objects it references* immutable. (Just From 8c9677530058e6ac9be08651e5cccf6c9dda36dc Mon Sep 17 00:00:00 2001 From: Tobias Wrigstad Date: Thu, 19 Jun 2025 18:46:26 +0900 Subject: [PATCH 3/8] Added link to DPO --- peps/pep-0795.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/peps/pep-0795.rst b/peps/pep-0795.rst index 1a1a14f5352..a85722f19da 100644 --- a/peps/pep-0795.rst +++ b/peps/pep-0795.rst @@ -6,7 +6,7 @@ Author: Matthew Johnson , Fridtjof Peer Stoldt , Tobias Wrigstad Sponsor: Michael Droettboom -Discussions-To: Pending +Discussions-To: https://discuss.python.org/t/96014 Status: Draft Type: Standards Track Created: 19-Jun-2025 From 269ff9c01e082f0486237aff7debdb41ed687afe Mon Sep 17 00:00:00 2001 From: Adam Turner <9087854+AA-Turner@users.noreply.github.com> Date: Thu, 19 Jun 2025 13:45:29 +0100 Subject: [PATCH 4/8] New email for Michael Droettboom Co-authored-by: Michael Droettboom --- peps/pep-0795.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/peps/pep-0795.rst b/peps/pep-0795.rst index a85722f19da..e84b5f960f5 100644 --- a/peps/pep-0795.rst +++ b/peps/pep-0795.rst @@ -5,7 +5,7 @@ Author: Matthew Johnson , Sylvan Clebsch , Fridtjof Peer Stoldt , Tobias Wrigstad -Sponsor: Michael Droettboom +Sponsor: Michael Droettboom Discussions-To: https://discuss.python.org/t/96014 Status: Draft Type: Standards Track From 5f59e375e771b05f7da3ac094b95d3e83dae283a Mon Sep 17 00:00:00 2001 From: Matthew Parkinson Date: Fri, 19 Dec 2025 11:05:30 +0000 Subject: [PATCH 5/8] Revamp based on DPO (#15) See "Changes from the previous draft" for details. -- Co-authored-by: Tobias Wrigstad Co-authored-by: Fridtjof Stoldt Co-authored-by: Matthew Johnson --- peps/pep-0795.rst | 3134 +++++++++++++++++++++++----------- peps/pep-0795/diagram_1.mmd | 24 + peps/pep-0795/diagram_1.svg | 1 + peps/pep-0795/diagram_10.mmd | 29 + peps/pep-0795/diagram_10.svg | 1 + peps/pep-0795/diagram_11.mmd | 33 + peps/pep-0795/diagram_11.svg | 1 + peps/pep-0795/diagram_12.mmd | 50 + peps/pep-0795/diagram_12.svg | 1 + peps/pep-0795/diagram_2.mmd | 19 + peps/pep-0795/diagram_2.svg | 1 + peps/pep-0795/diagram_3.mmd | 8 + peps/pep-0795/diagram_3.svg | 1 + peps/pep-0795/diagram_4.mmd | 14 + peps/pep-0795/diagram_4.svg | 1 + peps/pep-0795/diagram_4a.svg | 102 ++ peps/pep-0795/diagram_4b.svg | 102 ++ peps/pep-0795/diagram_4c.svg | 102 ++ peps/pep-0795/diagram_5.mmd | 14 + peps/pep-0795/diagram_5.svg | 1 + peps/pep-0795/diagram_6.mmd | 9 + peps/pep-0795/diagram_6.svg | 1 + peps/pep-0795/diagram_7.mmd | 10 + peps/pep-0795/diagram_7.svg | 1 + peps/pep-0795/diagram_8.mmd | 44 + peps/pep-0795/diagram_8.svg | 1 + peps/pep-0795/diagram_9.mmd | 59 + peps/pep-0795/diagram_9.svg | 1 + peps/pep-0795/scaling.png | Bin 0 -> 62551 bytes peps/pep-0795/table.png | Bin 0 -> 61111 bytes 30 files changed, 2743 insertions(+), 1022 deletions(-) create mode 100644 peps/pep-0795/diagram_1.mmd create mode 100644 peps/pep-0795/diagram_1.svg create mode 100644 peps/pep-0795/diagram_10.mmd create mode 100644 peps/pep-0795/diagram_10.svg create mode 100644 peps/pep-0795/diagram_11.mmd create mode 100644 peps/pep-0795/diagram_11.svg create mode 100644 peps/pep-0795/diagram_12.mmd create mode 100644 peps/pep-0795/diagram_12.svg create mode 100644 peps/pep-0795/diagram_2.mmd create mode 100644 peps/pep-0795/diagram_2.svg create mode 100644 peps/pep-0795/diagram_3.mmd create mode 100644 peps/pep-0795/diagram_3.svg create mode 100644 peps/pep-0795/diagram_4.mmd create mode 100644 peps/pep-0795/diagram_4.svg create mode 100644 peps/pep-0795/diagram_4a.svg create mode 100644 peps/pep-0795/diagram_4b.svg create mode 100644 peps/pep-0795/diagram_4c.svg create mode 100644 peps/pep-0795/diagram_5.mmd create mode 100644 peps/pep-0795/diagram_5.svg create mode 100644 peps/pep-0795/diagram_6.mmd create mode 100644 peps/pep-0795/diagram_6.svg create mode 100644 peps/pep-0795/diagram_7.mmd create mode 100644 peps/pep-0795/diagram_7.svg create mode 100644 peps/pep-0795/diagram_8.mmd create mode 100644 peps/pep-0795/diagram_8.svg create mode 100644 peps/pep-0795/diagram_9.mmd create mode 100644 peps/pep-0795/diagram_9.svg create mode 100644 peps/pep-0795/scaling.png create mode 100644 peps/pep-0795/table.png diff --git a/peps/pep-0795.rst b/peps/pep-0795.rst index e84b5f960f5..d779d9345a6 100644 --- a/peps/pep-0795.rst +++ b/peps/pep-0795.rst @@ -1,1245 +1,2335 @@ PEP: 795 -Title: Deep Immutability in Python -Author: Matthew Johnson , - Matthew Parkinson , - Sylvan Clebsch , - Fridtjof Peer Stoldt , - Tobias Wrigstad -Sponsor: Michael Droettboom -Discussions-To: https://discuss.python.org/t/96014 +Title: Deep Immutability for Efficient Sharing and Concurrency Safety +Author: Matthew Johnson , Matthew Parkinson , Sylvan Clebsch , Fridtjof Stoldt , Tobias Wrigstad +Sponsor: Michael Droettboom +Discussions-To: TBD Status: Draft Type: Standards Track +Content-Type: text/x-rst Created: 19-Jun-2025 Python-Version: 3.15 Post-History: +Resolution: Abstract -======== +######## + +This PEP proposes support for deeply immutable objects in Python. +It partitions all objects into two categories: **mutable** +and **deeply immutable**. Mutable objects can be updated and +reference both mutable and deeply immutable objects. Deeply +immutable objects cannot be updated, and may only point to other +deeply immutable objects. If a mutable object is **freezable**, +it can be turned into an immutable object. We refer to the act of +making a freezable object immutable as "freezing it", and we will +often say "freezable object" to mean a mutable object that is also +freezable. + +There is no way to make an immutable object mutable. +However, one can make a mutable copy of an immutable object +using standard Python concepts. + +From now on, we will use immutable to mean deeply immutable, and +use **shallow immutability** to mean the protection offered by +tuples and frozen sets in Python 3.14. For example, ``(42, +("Spam", None))`` is deeply immutable, but ``(42, ["Spam", +None])`` is shallowly immutable, because the list constructor +creates a mutable object, so while the tuple cannot be updated, +its list sub-object can. + +The main motivation for **deep** immutability is to enable direct +sharing of immutable objects across sub-interpreters without the +need of pickling. + +All functionality is exposed via a new built-in +module called ``immutable``. This allows each Python implementation +to decide if it wants to provide immutability or not. We have a +working implementation of this PEP for CPython which we aim to adjust +based on feedback and upstream on acceptance. + +Changes from the previous draft +=============================== + +This PEP is a complete rewrite of the original PEP after `discussions on +DPO`_ and elsewhere. Based on feedback from DPO this rewrite: + +.. _discussions on DPO: + +- Focuses more on programming model, not just implementation details +- Aims to be clearer about what the costs are for different parts of + the design, both in terms of complexity for programmers and + implementers of this PEP +- Aims to make the semantics of freezing clearer, and provide more + examples of how freezing propagates +- Adds a new design that provides control over freeze propagation +- Adds escape hatches and clearly points out who implements them +- Motivates the design by linking it clearer to sharing objects across + sub-interpreters +- Aims to be clearer about the semantics of immutable functions (and why + they are unavoidable) +- Discusses the role of types and future plans for types +- Includes direct sharing of immutable objects across sub-interpreters, + rather than making a separate PEP for this +- Removes a lot of the rejected alternatives from the original PEP; + this is motivated by this PEP already being very long, and because + the inclusion of direct sharing across sub-interpreters motivate many + of the design decisions + +We are very grateful to the many comments and threads on DPO that have +contributed to this PEP. -This PEP proposes adding a mechanism for deep immutability to -Python. The mechanism requires some changes to the core language, -but user-facing functions are delivered in a module called -``immutable``. This module provides the following functions and types: -1. The function ``freeze(obj)`` -- turns ``obj`` deeply immutable +Motivation +########## + +The motivation for immutability is four-fold: + +1. With the semantics of immutability that this PEP proposes, immutable + objects can be shared directly by reference across sub-interpreters. + This is a big performance boost for sub-interpreters as Python + currently requires objects to be transferred across sub-interpreters + by pickling. This also simplifies programming with sub-interpreters. + To make sharing safe, some changes are necessary with respect to how a + Python interpreter manages the memory of immutable objects. + (Sharing objects across sub-interpreters is not possible without *deep* + immutability.) +2. Since immutable objects are safe from data races, it is possible to + avoid some of the overhead surrounding field access that is needed + for correct reference counting in free-threaded Python. +3. Memory for immutable objects can be managed in a leak-safe manner + without the need for cycle detection, even when there are cycles in the + immutable objects. This is key to sharing objects + between sub-interpreters without needing substantial changes to cycle + detection. + The algorithm we use to perform this assumes that freezing an object + does not occur in parallel with concurrent mutation. (This will always + hold for sub-interpreters.) +4. Immutability is a very useful concept in programming that simplifies + reasoning about state. In particular immutable objects are safe to + share between concurrent threads without any synchronisation in the + program. + +In this PEP, we strive to create a semantics for immutable +objects that is consistent across both the per-interpreter GIL and +free-threaded concurrency paradigms. + +In a future PEP, we will propose a scheme for sharing *mutable* objects +by reference across sub-interpreters, using region-based ownership to +enforce the invariants necessary for safety. There is a +short note about this at the end of this document. + +Towards the end of this document we also discuss performance of our prototype +implementation. As shown in Figure 1 below, sharing objects +directly by reference across sub-interpreters is considerably faster than +by pickling and unpickling. (See `Performance of immutability`_ for +more details of what this figure actually means.) + +.. figure:: pep-0795/scaling.png + + **Figure 1:** Effect on performance from direct + sharing of immutable objects. This plot shows the scaling + properties of sub-interpreters using immutability for user + classes vs pickling. Mean values over ten trials are shown. + One standard deviation is depicted as a vertical line. The + throughput of a single process for the task is shown for + comparison. + + +Design considerations due to sub-interpreters +============================================= + +This PEP will enhance sub-interpreters so that immutable +objects can be shared directly by reference between sub-interpreters. This is possible because +immutability permits an object to safely forego isolation and +be accessed outside of the protection offered by a single +GIL, and having its memory managed safely using atomic reference +counting, even for cyclic garbage. This is not the case for +mutable objects, and if a mutable object could be accessed +by multiple sub-interpreters, the Python VM could crash or +be susceptible to use-after-free bugs that could corrupt +data silently. If immutability could be circumvented, the +same would be true for immutable objects. This motivates +a strict interpretation of immutability, where the +mutable and immutable “worlds” are kept apart. (Although see +`Escape hatches`_.) + +Immutability is important to allow safe sharing between sub-interpreters. +To illustrate this point, let's assume that it would be possible to +share a mutable object O across two sub-interpreters (Sub 1 and +Sub 2) each with their own GIL. Because each sub-interpreter is +only synchronising with its own GIL, they are not synchronising +*with each other*. Sharing an *immutable* object avoids the need +for synchronisation (except for reference counts, which we will +return to later) -- however, if an immutable object has a mutable +sub object, then sharing the immutable object indirectly also +shares the mutable sub objets, which leads to the problems above. +As we cannot prevent the sub object from being accessed, this +motivates *deep* immutability. + +The picture below shows the situation above pictorially – the boxes +labelled Sub 1 and Sub 2 show the heaps of sub-interpreters 1 and 2. +Objects A and D are mutable and reside in the heap of Sub 1. Object B is +mutable and resides in the heap of Sub 2. A and B both point to a +immutable shared object C that (illegally in this PEP) references the +mutable object D. Note that object C does not belong to either +sub-interpreter, which is why it is drawn outside of their heaps. + +.. figure:: pep-0795/diagram_1.svg + + **Figure 2:** Illegal reference from immutable to + mutable object. The immutable object C is shared between two + sub-interpreters, and keeps an illegal reference to a mutable + object on the heap of one of the sub-interpreters. + +A sub-interpreter assumes that accesses to the objects reachable +from its heap are protected by its GIL. **Note that the reference +from C to D is not legal in this PEP, and this example shows what +happens if it was allowed.** The colours on the dashed arrows show which +sub-interpreter is using a reference to access an object. We annotate +the accesses with what GIL is used to synchronise actions on the object. +Because of the reference from C to D, it is possible to have two +accesses relying on different GILs for correctness, meaning +these accesses do not synchronise. Attempts to modify object D from +different sub-interpreters may lead them to overwrite each other and +silently corrupt or crash the Python VM. Even just reading the reference +to D could cause a problem, since the reference count of D is not atomic, +which could lead to incorrect reference count updates, followed by +use-after-free bugs. + +Immutable objects avoid these problems: their reference count is managed +though atomic increments and decrements, and since its fields are immutable, +they are not subject to data races. -2. The function ``isfrozen(obj)`` -- returns ``True`` if ``obj`` is immutable -3. The type ``NotFreezable`` which is an empty type which cannot be made immutable and can be used as a super class to classes whose instances should not be possible to freeze +Specification +############# + +This PEP describes immutability support in Python. It first +discusses adding support for built-in types before tackling the +challenges of dealing with user-defined types. +Permitting more objects to be made immutable requires more changes to +the Python interpreter, and additionally comes with design +considerations at the language level. The separation of the PEP +into these two aspects is prompted by discussions at DPO in order +to clarify the “return on investment” for various aspects of this PEP, +and also to permit this feature to be rolled out across multiple +releases to give the Python community more time to get accustomed +to immutability. In summary: + +1. **Part 1: Inherently Immutable Objects**. + Objects and types which are `de-facto immutable`_ in Python 3.14 are + immutable according to this PEP. Examples include tuples that only + contain immutable objects, strings, numbers, booleans, and `None`. + More information on current Python immutability can be found + in the `data model documentation`_. +2. **Part 2: Supporting User-Defined Types**. + Extend immutability to dicts, lists, sets and user-defined types + and their instances. Objects of these types will be freezable, + meaning they will be mutable at creation but may be made immutable. + Classes are freezable as well. This permits monkey-patching, i.e. + adding and removing methods in a class before freezing it, which is + important for many libraries, e.g. dataclasses. + +.. _de-facto immutable: https://docs.python.org/3/glossary.html#term-immutable +.. _data model documentation: https://docs.python.org/3/reference/datamodel.html + + +Semantics of immutability +========================= + +This PEP partitions objects into the categories **mutable** and +**immutable**. Mutable objects can be updated and reference both +mutable and immutable objects. Immutable objects cannot be +updated, and may only point to other immutable objects. Mutable +objects can also be **freezable** meaning they can be turned into +immutable objects. + +Sometimes it may be necessary for an immutable object to point to +mutable data or support some limited form of mutation. This will be +supported through `escape hatches`_. + + +Support for Inherently Immutable Objects +---------------------------------------- + +As a first step, we align the deep immutability of this PEP with the shallow +immutability in Python. All types that are immutable in Python 3.14 are +also deeply immutable in the sense of this PEP. Further, all instances +of ``int``, ``float``, ``str``, ``complex``, and ``bool`` and the +``None`` constant are deeply immutable. Instances of +**shallowly immutable** composite types like ``tuple``, +``namedtuple``, ``frozenset``, ``range`` and ``slice`` +are deeply immutable if their nested objects are deeply +immutable. + +So far, immutability is always established at the point of +creation, which means that there is no need for an operation that takes +a mutable object and makes it immutable (this becomes necessary when +dealing with user-defined types later). The function ``is_frozen()`` +can be used to test if an object is deeply immutable, e.g. before +sharing it with another sub-interpreter. -4. The type ``NotFreezableError`` which is raised on an attempt to mutate an immutable object -5. The function ``register_freezable(type)`` -- which is used to whitelist types implemented as C extensions, permitting their instances to be made immutable +.. code-block:: python + :caption: **Listing 1:** Creating immutable (and one mutable) objects. + + # is_frozen(obj) returns True if obj is deeply immutable + from immutable import is_frozen + + # Creates immutable object -- all sub-objects are immutable + p = ("this", 15, "an", "ex parrot") + is_frozen(p) # True + + # Does not create an immutable object -- dict is mutable so n is shallow immutable + n = ({'x' : 'parrot'}, None) + is_frozen(n) # False + + from collections import namedtuple + Person = namedtuple('Person', ['name']) + + # Create deeply immutable tuple of named tuples + monty = (Person("Eric"), Person("Graham"), Person("Terry")) + is_frozen(monty) # returns True -- all sub-objects are immutable + +For clarity, while all of the objects above except for the dictionary +are de-facto immutable today in Python, they cannot be safely shared +across sub-interpreters without the changes proposed by this PEP. The +``n`` tuple contains a mutable dictionary and is, therefore, **not** +deeply immutable and therefore not safe to share between sub-interpreters. + + +Sharing of Types +~~~~~~~~~~~~~~~~ + +To share an object it has to be deeply immutable. Recall that this means +that all objects reachable from it has to be deeply immutable too -- including the +type object stored in its ``__class__`` attribute. All types of the +currently de-facto immutable objects are immutable (*i.e.*, the type has +the ``Py_TPFLAGS_IMMUTABLE_TYPE`` flag set) and can therefore +be made safe to share across sub-interpreters while being consistent with +the definition of deep immutability and not breaking existing code. + +.. figure:: pep-0795/diagram_2.svg + + **Figure 3:** An immutable instance C and its immutable type D being + shared across two sub-interpreters. + +The figure above introduces our drawing notation. The boxes “Sub 1” and +“Sub 2” are the heaps of the sub-interpreters. A and B are mutable +objects living in the isolated heaps. C and D are immutable objects +living outside the sub-interpreter heaps, and are accessible by all. +Arrows are references. + + +Dealing with cycles +~~~~~~~~~~~~~~~~~~~ + +Because each sub-interpreter assumes exclusive access to objects while +it performs cycle detection, immutable objects cannot be part of cycle +detection. The per sub-interpreter cycle detection avoids the need to +stop all interpreters to perform cycle detection. However, this means +that immutable objects accessible from multiple interpreters have to be +handled differently. To this end, we "removed" all immutable objects from +the work-list of the cycle detector. + +When objects are immutable at creation, immutable object graphs +cannot contain cycles. These can therefore be removed from cycle +detection without any risk of creating memory leaks. +There are a handful of types that contain cycles in the CPython +implementation, such as ``tuple``, ``type``, and ``object``. These +cycles are part of the static initialization of the interpreters +and are immortal, so they do not need to be managed by the cycle +detector either. + +Adding support for turning mutable objects of user-defined +types immutable permits creation of immutable cycles. For these +we introduce a :ref:`different technique to handle cycles ` +later in this PEP. Thus, the parallel garbage collection ability +of Python's sub-intepreters model is kept intact by this PEP. + + +Register immutable types through C +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +The function ``register_shallow_immutable(typ)`` allows modules +that have immutable types implemented through C to register them +as such, so that they can be shared across sub-interpreters. A +type may be registered as shallow immutable if it does not contain +any mutable fields. An ``is_frozen`` check on a type which has +been registered as shallow immutable will return ``True`` if all +fields reference deeply immutable objects, else ``False``. This check +is done on a call to ``is_frozen`` on an object. This means that +there is no checking cost until immutability is actually used. + +Note that checking whether a C type's fields are mutable or not is +beyond the possibilities of ``register_shallow_immutable(typ)``. The +function simply accepts this assertion from the programmer. If a type +was incorrectly registered as shallow immutable, it can lead to +undefined behaviour, including crashes and memory corruption, when +using the type across sub-interpreters. This function also requires that +the module itself is freezable (See: `freezable`_), since all +C-types have a reference to the module that defined them. + + +Traversing objects +~~~~~~~~~~~~~~~~~~ + +The changes proposed by this PEP require a way to find all objects +which are reachable from a given object. The existing mechanisms, namely +``dir()`` and ``tp_traverse``, are not sufficient since they are not +guaranteed to discover all reachable objects. For this a new +function ``tp_reachable`` is added to C-types. This function needs to be +implemented by a type to support immutability. It has the same +function signature as ``tp_traverse`` which allows easy migration +for existing C-types that already visit all reachable fields in +``tp_traverse`` by simply reusing the existing ``tp_traverse``. + +.. _summary-1: + +Summary -- so far +~~~~~~~~~~~~~~~~~ + +- A deeply immutable object may only point to other immutable objects + (modulo `escape hatches`_), including its class object +- Deeply immutable objects can be created from objects which are + already immutable in Python today -- note that for tuples, named + tuples and frozen sets, this requires that their constituent parts are + deeply immutable too +- Immutable objects are always immutable at the point of creation +- Immutable object graphs are tree shaped + + +Supporting user-defined types and freezing mutable isolated subgraphs +--------------------------------------------------------------------- + +Below we describe the support for making instances of user-defined types +immutable. This requires support for making user-defined *types* +immutable, along with their *functions*. + +Now the notion of *freezable* becomes important: + + A freezable object is mutable but can be made immutable. + +A freezable object is made immutable through an explicit call to +the function ``freeze()``. A call to ``freeze(o)`` will make the +object referenced by ``o`` immutable, along with all other objects +reachable from fields in ``o`` (and so on) -- including types which +are reachable from the ``__class__`` field. We refer to this as +*freeze propagation*. To make an object immutable at construction +time, simply wrap its construction inside a freeze call. The freeze +function takes a variable number of arguments which allows it to +freeze many things at once. + +Types are freezable by default but must be frozen *explicitly*, +as illustrated by Listing 2. This means that the object must be +frozen by directly passing its reference to freeze (e.g. ``freeze(o)`` +freezes ``o`` explicitly and ``o.__class__`` by freeze propagation; +whereas ``freeze(o, o.__class__)`` freezes both ``o`` and its class +explicitly, and at the same time). -Making an object *deeply* immutable recursively renders the object -*and all objects it references* immutable. (Just -making the first object immutable is called *shallow* -immutability.) +.. code-block:: python + :caption: **Listing 2.a:** By default, types must be frozen explicitly. + + class Foo: + pass + + f = Foo() + f.g = Foo() + freeze(f) # Will fail because Foo is not immutable + freeze(Foo) # OK because the type is frozen explicitly -- not by freeze propagation + freeze(f) # OK because Foo is immutable + is_frozen(f) # True + is_frozen(Foo) # True + if_frozen(f.g) # True (by propagation) + +To permit ``freeze(f)`` to propagate to and implicitly freeze the +``Foo`` type, we can use the decorator ``@freezable`` on the class +declaration. Non type objects are implicitly freezable, but +note that freezing an object will fail unless its type is +freezable (or already made immutable). The standard types +``list``, ``dict``, and ``set`` are also freezable, meaning lists, +dicts and sets are mutable on creation but can be made immutable +later. + +To make a type immutable immediately at creation time, a decorator +``@frozen`` can be used. The decorators, the ``freeze()`` function, +along with other utilities described later in this document are in +a module called ``immutable``. The listing below revisits the listing +above and uses the ``@frozen`` decorator on ``Foo``. -Deep immutability provides strong guarantees against -unintended modifications, thereby improving correctness, security, and -parallel execution safety. +.. code-block:: python + :caption: **Listing 2.b:** By default, types must be frozen explicitly. + + from immutable import freeze, is_frozen, frozen + + @frozen + class Foo: + pass + + is_frozen(Foo) # True + f = Foo() + f.g = Foo() + freeze(f) # OK because Foo is immutable + is_frozen(f) # True + if_frozen(f.g) # True (by propagation) + +An immutable type may not reference mutable state, and +additionally does not permit adding, removing or changing +functions. Immutable types *may not* inherit from mutable types, +but *may have* mutable subtypes. The ``object`` class and the +``type`` meta class are immutable by default as described above. + +This PEP includes `escape hatches`_ that relax the restrictions on +capturing mutable state in functions and types. + +As pointer out above, +with freezable objects, ``freeze()`` and ``@frozen`` come the +issue of *freeze propagation*, meaning what freezable objects can +be made immutable as a side-effect of making something else +immutable. For example, consider the figure below, ``freeze(x)`` +will make ``A``, ``B`` and ``C`` immutable. Because ``y`` +points to ``C``, ``freeze(x)`` becomes visible through ``y``. +An attempt at mutating ``C`` through ``y`` will result in +“TypeError: object of type T is immutable”. + +.. figure:: pep-0795/diagram_3.svg + + **Figure 4:** A first look at freeze propagation. Freezing ``x`` will affect objects ``A``, ``B`` and ``C``. + +Freeze propagation is similar to how static annotations such +as ``const`` from C or C++ propagate through a code base, except +at run-time instead of compile-time. This PEP limits or manages freeze +propagation by making user-defined types explicitly freezable, +providing a way to hook into the freeze mechanism, and by +allowing opting out of freezing altogether or for some limited +duration. + + +Pre-freeze hook +~~~~~~~~~~~~~~~ + +Sometimes it is necessary to run some code just before an object +is frozen. This can be done by calling ``set_pre_freeze_hook`` +with a callable that will be invoked just before freezing the +object. The callable will be passed the object that is about to be +frozen as its only argument. The callable may perform +operations on this object, or its contained objects e.g. to +affect whether freezing will succeed or not. (It can also take +some mutable state and wrap it in an escape hatch etc. We use +this hook mechanism internally to handle functions and modules, +as will be described later.) + +On user defined types, the definition can directly define a +``__pre_freeze__`` method that will be called as the pre-freeze +hook. + +The listing below shows the pre-freeze hook which errors if the value +field is not filled and populates a cache. -Immutable objects are managed with reference counting plus cycle -detection just like normal mutable objects, and can be made -immortal. In this PEP, we rely on the GIL to ensure the -correctness of reference counts of immutable objects, but we have -several planned memory management extensions, including support -for atomic reference counting on immutable objects. These are -outlined at the end of this document. +.. code-block:: python + :caption: **Listing 7:** Freezing propagates. + + @freezable + class Foo: + def __init__(self, field): + self.field = field + def __pre_freeze__(self): + # Dynamically fail freezing based on field content + if self.field is None: + raise RuntimeError("Attempted to freeze empty foo") + # Precompute some values + self.cache = hash(field) + + f = Foo() + freeze(f) + +Note that if a freeze fails because at least one object is not +allowed to be frozen, then the system will ensure none of the +objects are frozen. *However, the effects of the pre-freeze hook +will not be undone.* + + +Immutable functions +~~~~~~~~~~~~~~~~~~~ + +An immutable function is a normal function that can be passed both +mutable and immutable arguments. It is free to mutate newly +created objects or any mutable arguments -- but it may not capture or +store a reference to mutable state as part of the function object. +Really, an immutable function is more of a "sharable function". +Making a function immutable does not prevent optimisations +which rely on mutating the code object. However, such optimisations +will need to be carried out in a way that is thread-safe without +relying on a single GIL. + +(While we did not discuss immutable functions much when we limited +ourselves to built-in types, they were already there as part of the +immutable type objects.) + +The major challenge with immutable functions can be illustrated +through an example. What if the following program was legal? -Immutability in action: +.. code-block:: python + :caption: **Listing 3:** The problem with sharing functions across sub-interpreters + + import random + + x = [0, 1, 2] + y = [0, 1, 2, 3, 4] + + def die_roll(): + return x[random.randint(0, 2)] # captures external random and x objects + + freeze_and_send_to_other_sub_interpreter(die_roll) # Problem + # The lines below are discussed below in the text + # freeze(die_roll) + # x = [5, 6, 7] + # x.append(8) + +The ``die_roll()`` function above captures the ``random`` module +object of its defining sub-interpreter and the local variable ``x``. +If we pass the ``die_roll`` function object to another sub-interpreter, +we have successfully recreated the problematic situation in Figure 1 where +C is ``die_roll`` and D is ``random`` or the list in ``x``. +(Actually, the situation is +technically worse as each function object has a reference to the +globals dictionary of its defining sub-interpreter, so +``die_roll.__globals__["y"].append(5)`` will add to the list in +``y``.) Since types consist mostly of functions, and we need to +share types to share objects, we need a notion of immutable +functions in this PEP as well. + +As explained above, that a function is immutable means that it is +safe to share across sub-interpreters. This means that the +function may not capture a direct reference to mutable state. The +function may be passed mutable state, and may get access to the +current interpreter's mutable state through module imports, but it +may not make one sub-interpreter's mutable state accessible to +another sub-interpreter. + +A function can be made immutable either implicitly (*e.g.,* +because the type containing it is frozen) or explicitly (*e.g.,* +through a ``@frozen`` decorator or an explicit ``freeze()`` call). +When a function is frozen, we *decouple* it from its defining +context in two ways. This logic is handled transparently in the +pre-freeze hook of the function type object: + +1. We re-point its captured globals to point to a copy that contains + only the values that the function captured. (So ``random`` and ``x`` + in our example above, but not ``y``.) The copy is shallow. +2. We freeze the globals copy which freezes the *values* which + are shared between the globals dictionaries, but keeps the + variables in the defining context's globals dictionary mutable. + Thus, ``x = [5, 6, 7]`` is permissable, and because that updates + the sender's ``x`` to point to a mutable object, the subsequent + append is permitted. + +If a nested function captures values from a stack frame of another +function call, we handle those in the same way: we make a shallow +copy of the cell objects and freeze the copies. In the code below, +you can witness how freezing the ``foo`` function effectively +gives ``foo`` its own copy of the ``x`` *variable*, which +initially shares its *value* with the enclosing ``x``: .. code-block:: python + :caption: **Listing 4:** Freezing a function locks and freezes the current values of its captured variables, but enclosing scopes can still reassign the variables. + + x = 42 + @frozen + def foo(): + return x + + is_frozen(foo) # True + foo() # returns 42 + x = 4711 # OK + print(x) # prints 4711 + foo() # returns 42 + + +An Immutable Die +~~~~~~~~~~~~~~~~ + +Listing 5 below creates a ``Die`` type which is immutable at +creation. (An alternative to the ``@frozen`` decorator is to make +the type ``@freezable`` allowing ``freeze(d)`` to also freeze the +the class declaration.) As neither the +``Die`` class nor its functions capture any external mutable +state, freezing it will not lead to any external state being +frozen. The import inside of ``roll()`` illustrates the major +difference between the function importing the current +sub-interpreter’s ``random`` module on each call and a function +capturing and always calling into a specific sub-interpreter’s +random module. The default ``sides`` argument in ``__init__`` is +supported since the value is immutable. - from immutable import freeze, isfrozen +.. code-block:: python + :caption: **Listing 5:** A valid immutable class. - class Foo: - pass + from immutable import freeze, is_frozen, frozen - f = Foo() - g = Foo() - h = Foo() + # @frozen -- could have frozen die immediately after creation + class Die: + def __init__(self, sides=6): + self.set_sides(sides) + def set_sides(self, sides): + self.sides = sides + def roll(self): + # Importing a mutable module is OK + import random + return random.randint(1, self.sides) - f.f = g - g.f = h - h.f = g # cycles are OK! - del g # Remove local ref to g, so g's RC = 1 - del h # Remove local reg to h, so h's RC = 1 + d = Die(6) + is_frozen(d) # False + d.roll() # will return a number in [1,6] + d.set_sides(12) # OK - g.x = "African Swallow" # OK - freeze(f) # Makes, f, g and h immutable - g.x = "European Swallow" # Throws an exception "g is immutable" - isfrozen(h) # returns True - h = None # Cycle detector will eventually find and collect the cycle + # freeze(d) -- will fail unless Die is @frozen or @freezable + freeze(Die) + is_frozen(Die) # True + is_frozen(Die.roll) # True -Motivation -========== + freeze(d) # turns the object d points to deeply immutable + is_frozen(d) # True + d.roll() # will return a number in [1,12] + d.set_sides(6) # will raise an exception -Ensuring Data Integrity ------------------------ +Right before ``freeze(Die)``, we have the following object graph (with +some simplifications to reduce clutter -- recall that immutable objects +can only reference other immutable objects). -Python programs frequently manipulate large, interconnected data -structures such as dictionaries, lists, and user-defined objects. -Unintentional mutations can introduce subtle and -difficult-to-debug errors. By allowing developers to explicitly -freeze objects and their transitive dependencies, Python can -provide stronger correctness guarantees for data processing -pipelines, functional programming paradigms, and API boundaries -where immutability is beneficial. - - -Immutable Objects can be Freely Shared Without Risk of Data Races ------------------------------------------------------------------ - -Python’s Global Interpreter Lock (GIL) mitigates many data race -issues, but as Python evolves towards improved multi-threading and -parallel execution (e.g., subinterpreters and the free-threaded Python -efforts), data races on shared mutable objects become a more -pressing concern. A deep immutability mechanism ensures that -shared objects are not modified concurrently, enabling safer -multi-threaded and parallel computation. Safe sharing of immutable -objects across multiple threads require deep immutability. -Consider the following example: +.. figure:: pep-0795/diagram_4a.svg -.. code-block:: python + **Figure 5:** Before freezing ``Die`` – immutable objects drawn in “ice + blue” with dashed borders and references from immutable objects drawn + with lighter blue lines. - import threading +Freezing the class also freezes its functions. - data = [1, 2, 4, 8] - length = len(data) - pair = (data, length) +.. figure:: pep-0795/diagram_4b.svg - threading.Thread(target=print, args=(pair,)).start() + **Figure 6:** Before freezing ``d`` – immutable objects drawn in “ice + blue” with dashed borders and references from immutable objects drawn + with lighter blue lines. - del data[2] +Note that the instance of ``Die`` pointed to by ``d`` is still a normal +mutable Python object. Thus we would be allowed to change the number of sides +back to 6 from 12. However, after we freeze the object, an attempt to change +its sides will raise an exception, since the object is immutable. Note +that freezing ``d`` will not prevent the value stored in the ``d`` +variable to change. However, as indicated by the blue reference arrow, +``sides`` inside the immutable ``Die`` instance is fixed for life. -The shallow immutability of the ``pair`` tuple prevents the -``data`` list from being swapped for another list, but the list -itself is not immutable. Thus, the ``print`` function in the newly -spawned thread will be racing with the deletion. In Python 3.12, -this is not a problem as the GIL prevents this race. To ensure -container thread-safety, :pep:`703` -proposes per-object locks instead. If ``pair`` is immutable, the -deletion would have caused an error. +.. figure:: pep-0795/diagram_4c.svg -The following image illustrates that as soon as an object *a* -is reachable by two threads, then all other objects that -*a* can reach are also reachable by both threads. The dashed -red references to *c* and *d* are not possible because then -*c* and *d* would not be in areas where only a single thread -could reach them. + **Figure 7:** Right after freezing ``d`` – immutable objects drawn in “ice + blue” with dashed borders and references from immutable objects drawn + with lighter blue lines. -To map the code example above to the figure -- ``pair`` is *a* and ``list`` is *b*. +Note that freezing is *in-place*; ``freeze(obj)`` freezes ``obj``, not a copy. +(For convenience, ``freeze(obj)`` also returns a reference to ``obj``.) -.. image:: pep-0795/sharing1.png - :width: 50% - :alt: An image showing two overlapping "regions of memory", - local to each thread, and what is private to each thread - and what is shared. +.. _freezable: -See also the discussion about extensions further down in this -document. +Freezability - Unfreezable and explicitly freezable objects +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -Deep immutability can be implemented efficiently. An alternative approach -would be to detect data-races using a read-barrier based approach, however, -this cannot be implemented as efficiently. We discuss this in the alternatives -section. As highlighted above, immutability also has value in single-threaded -application, i.e. where there is no fear of data races. +The immutable module provides the function ``set_freezable(obj, status=Yes)`` +which controls if and how an object is freezable. Most +objects are freezable by default, meaning that freezing can propagate +to them. However, functions and types are explicitly freezable by +default (``set_freezable(obj, Explicit)``) meaning that freezing +will never propagate to them and they can only be frozen when they +are explicitly passed in to ``freeze()``. Objects can also be marked as +unfreezable (``set_freezable(obj, No)``) which will result in an error +when someone attempts to freeze the object. The values for ``Yes``, +``No`` and ``Explicit`` are defined in the immutable module. +The listing below shows the effects of freezability: +.. code-block:: python + :caption: **Listing 6:** Examples of freezability -Optimisations and Caching Benefits ----------------------------------- + class Cell: + def __init__(self, value): + self.value = value -Immutable objects provide opportunities for optimisation, such as -structural sharing, memoization, and just-in-time (JIT) -compilation techniques (specialising for immutable data, e.g. -fixed shape, fewer barriers, inlining, etc.). Freezing objects can -allow Python to implement more efficient caching mechanisms and -enable compiler optimisations that rely on immutability -assumptions. This PEP will permit such opportunities to go -beyond today's immutable objects (like ``int``, ``string``) and -*shallow* immutable objects (``tuple``, ``frozenset``). + val1 = {"1": "One"} + c = Cell(val1) + freeze(c) # 💥 Fails since the Cell class must be frozen explicitly -Specification -============= + freeze(Cell) + freeze(c) # Succeeds since Cell was explicitly frozen + is_frozen(val1) # Val is now frozen as well -Note: our current prototype implementation was authored on-top of -Python 3.12. To avoid blocking on rebasing on 3.14 to force -decisions about changes to implementation detail, we are -circulating this document to discuss the design ideas, -and some of the unaffected aspects of the implementation. + val2 = {"2": "Two"} + set_freezable(val2, Explicit) + c = Cell(val2) -An outline of the changes that we anticipate are required for -Python 3.14 is can be found at the `end of the document `_. + freeze(c) # 💥 Fails because c references val2 which needs explicit freezing + freeze(val2) # Succeeds -- explicitly freezes val2 + freeze(c) # Works since val2 is already frozen -Changes to Python Objects -------------------------- + val3 = {"3": "Three"} + set_freezable(val3, No) + c = Cell(val3) -Every Python object will have a flag that keeps track of its -immutability status. Details about the default value of -this flag is discussed further down in this document. + freeze(c) # 💥 Fails because val3 is not freezable + freeze(val3) # 💥 Fails because val3 is not freezable -The flag can be added without extending the size of the -Python object header. +By default, types must be frozen explicitly. Notably, this prevents +instances of the type from becoming immutable too, until the type has been +frozen. +Modules are unfreezable by default and require the authors to opt-in +to immutability. Modules are discussed further in :ref:`modules` -Implementation of Immutability ------------------------------- +The ``immutable`` module provides decorators to easily change +freezability and act as documentation on the function or type. These +decorators are: -Immutability is enforced through run-time checking. The macro -``Py_CHECKWRITE(op)`` is inserted on all paths that are guaranteed -to end up in a write to ``op``. The macro inspects the immutability -flag in the header of ``op`` and signals an error if the immutability -flag is set. +- ``@frozen``: Freezes the function/type after creation +- ``@freezable``: Allows freezing to propagate to the type +- ``@unfreezable``: Prevents the type/function from being frozen -A typical use of this check looks like this: +Here is a sketch of how the decorators may be implemented: -.. code-block:: c +.. code-block:: python + :caption: **Listing 7:** Sketch implementation of decorators. - if (!Py_CHECKWRITE(op)) { // perform the check - PyErr_WriteToImmutable(op); // raise the error if the check fails - return NULL; // abort the write - } - ... // code that performs the write - - -Writes are common in the CPython code base and the writes lack a -common "code path" that they pass. To this end, the PEP requires a -``Py_CHECKWRITE`` call to be inserted and there are several places -in the CPython code base that are changed as a consequence of this -PEP. So far we have identified around 70 places in core Python which -needed a ``Py_CHECKWRITE`` check. Modules in the standard library -have required somewhere between 5 and 15 checks per module. - - -Backwards Compatibility -======================= - -This proposal intends to be fully backward compatible, as no existing Python -code will be affected unless it explicitly calls ``freeze(obj)``. -Immutable objects will raise errors only when mutation is attempted. - - -Opt-In vs. Opt-Out ------------------- - -All pure Python objects can be made immutable, provided all their members -and their base classes can be made immutable. However, for types which -are partially or completely implemented in C, support for -immutability requires some work on both exposing objects to -freezing, and to enforce immutability in mutating C-functions. - -From a backwards compatibility perspective, an opt-in model keeps -things simple: all existing code keeps working, and only code that -wishes to support immutability needs updating. The downside of the -opt-in model is that a large part of all Python libraries cannot -be (even nominally) made immutable (out-of-the-box). - - -Strictness ----------- - -A strict interpretation of deep immutability does not permit an -immutable object to reference a mutable object. This model is both -easy to explain and understand, and an object's immutability can -be "trusted" --- it is not possible for an immutable object to -change through some nested mutable state [#RC]_. At the same time -it limits the utility of freezing as many Python objects contain -types outside of the standard library defined in C, which must -opt-in immutability before they can be frozen. - -This PEP proposes immutability to be strict. - - -Dealing with Failure During Freezing ------------------------------------- - -Regardless whether support for freezing is opt-in or opt-out some -types will not be freezable. (Example such types include IO types -like file handles, and caches -- as opposed to the cached -objects.) This raises the question how to handle failure to freeze -an object graph. Consider the object graph ``o1 --> o2 --> o3`` -where ``o1`` and ``o3`` can be made immutable, but ``o2`` cannot. -What are the possible behaviours of ``freeze(o1)``? - -1. Freeze fails partially. All subgraphs which could be made - immutable entirely remain immutable. Remaining objects remain - mutable. In our example, ``o3`` remains immutable but ``o1`` and - ``o2`` remain mutable. This preserves strict immutability. The - exception thrown by the failing ``freeze(o1)`` call will - contain ``o2`` (the place that caused freezing to fail) and - ``o1`` (the object in the graph that holds on to the failing - object) to facilitate debugging. - -2. **Rejected alternative**: Freeze fails completely. In the strict - interpretation of deep immutability, freezing ``o1`` is not - possible because ``o1`` contains a reference to an un-freezable - object ``o2``. In this scenario, the object graph ``o1 --> o2 - --> o3`` remains mutable and ``freeze(o1)`` raises an exception - when the object graph traversal encounters ``o2``. - -3. **Rejected alternative**: Freeze succeeds by altering the - graph. In this example removing ``o2`` from the graph or - swapping out ``o2`` for a placeholder object to be able to - freeze the graph. This alternative becomes complicated both to - reason about from a user's perspective, and to implement when - ``o2`` is referenced multiple times. - -4. **Rejected alternative**: Permit the user to choose between - alternatives 1) and 3) at use-site. In this case, the - ``freeze`` function takes an optional 2nd argument ``strict`` - which must either be ``True`` or ``False``. In the first case, - ``freeze`` behaves as in alternative 1), in the second case, - it behaves as in alternative 2). We could further track whether - an object is strictly immutable or not in order to prevent - non-strictly immutable objects to participate in operations - which require strictness. This adds additional complexity to - the implementation, and also for the user. - -This PEP proposes following alternative 1, where freezing either -succeeds or fails partially. + def unfreezable(obj): + set_freezable(obj, No) + return obj + def freezable(obj): + set_freezable(obj, Yes) + return obj -New Obligations on C Extensions -------------------------------- + def frozen(obj): + set_freezable(obj, Yes) # Explicit would also have worked + freeze(obj) + return obj -Due to the opt-in decision, there are no *obligations* for C -extensions that do not want to add support for immutability. - -Because our implementation builds on information available to the CPython -cycle detector, types defined through C code will support immutability -"out of the box" as long as they use Python standard types to store -data and uses the built-in functions of these types to modify the data. - -To make its instances freezable, a type that uses C extensions -that adds new functionality implemented in C must register -themselves using ``register_freezable(type)``. Example: - -.. code-block:: Python - - PyObject *register_freezable = _PyImport_GetModuleAttrString("immutable", "register_freezable"); - if(register_freezable != NULL) - { - PyObject* result = PyObject_CallOneArg(register_freezable, (PyObject *)st->Element_Type); - if(result == NULL){ - goto error; - } - - Py_DECREF(register_freezable); - } - -If you construct a C type using freezable metaclasses it will itself be freezable, -without need for explicit registration. - -To properly support immutability, C extensions that directly write -to data which can be made immutable should add the -``Py_CHECKWRITE`` macro shown above on all paths in the code that -lead to writes to that data. Notably, if C extensions manage their -data through Python objects, no changes are needed. - -**Rejected alternative**: Python objects may define a -``__freeze__`` method which will be called **after** an object has -been made immutable. This hook can be used to freeze or otherwise -manage any other state on the side that is introduced through a -C-extension. - -C extensions that define data that is outside of the heap traced -by the CPython cycle detector should either manually implement -freezing by using ``Py_CHECKWRITE`` or ensure that all accesses to -this data is *thread-safe*. There are cases where too strict -adherence to immutability is undesirable (as exemplified by our -mutable reference counts), but ideally, it should not be able to -directly observe these effects. (For example, taking the reference -count of an immutable object is not supported to prevent code from -branching on a value that can change non-deterministically by -actions taken in parallel threads.) - - -Examples of Uses of CHECKWRITE ------------------------------- - -Inspiration and examples can be found by looking at existing -uses of ``Py_CHECKWRITE`` in the CPython codebase. Two good -starting places are ``object.c`` `[1]`_ and ``dictobject.c`` `[2]`_. - -.. _[1]: https://github.com/mjp41/cpython/pull/51/files#diff-ba56d44ce0dd731d979970b966fde9d8dd15d12a82f727a052a8ad48d4a49363 -.. _[2]: https://github.com/mjp41/cpython/pull/51/files#diff-b08a47ddc5bc20b2e99ac2e5aa199ca24a56b994e7bc64e918513356088c20ae - - -Expected Usage of Immutability ------------------------------- - -The main motivation for adding immutability in this PEP is to -facilitate concurrent programming in Python. This is not something -that Python's type system currently supports -- developers have to -rely on other (i.e. not type-driven) methods to communicate around -thread-safety and locking protocols. We expect that the same -methodology works for immutable objects with the added benefit -that mistakes lead to exceptions rather than incorrectness bugs or -crashes. As the Python community adopts immutability, we expect to -learn about the patterns that arise and this can inform e.g. how -to develop tools, documentation, and types for facilitating -programming with immutable objects in Python. - -We expect that libraries that for example want to provide intended -constants may adopt immutability as a way to guard against someone -say re-defining pi. Freezing a module's state can be made optional -(opt-in or opt-out) so that the option of re-defining pi can be -retained. - -If immutability is adopted widely, we would expect libraries to -contain a section that detail what types etc. that it provides -that can be made immutable or not. If Python's type system adds -support for (say) distinguishing between must-be-mutable, -must-be-immutability, and may-be-immutable, such annotations can -be added to the documentation of a library's public API. - -If a library relies on user-provided data to be immutable, we -expect the appropriate pattern is to check that the data is -immutable and if not raising an exception rather than to make the -data immutable inside the library code. This pushes the obligation -to the user in a way that will not lead to surprises due to data -becoming immutable under foot. - -We expect programmers to use immutability to facilitate safe -communication between threads, and for safe sharing of data -between threads. In both cases, we believe it is convenient to be -able to freeze a data structure in-place and share it, and we -expect programmers to have constructed these data structures with -this use case in mind. - - -Deep Freezing Semantics -======================= - -Following the outcomes of the design decisions discussed just -above, the ``freeze(obj)`` function works as follows: - -1. It recursively marks ``obj`` and all objects reachable from ``obj`` - immutable. +.. _modules: -2. If ``obj`` is already immutable (e.g., an integer, string, or a - previously frozen object), the recursion terminates. If ``obj`` cannot - be made immutable, the entire freeze operation is aborted without making any - object immutable. +Frozen functions capturing module state +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -3. The freeze operation follows object references (relying on ``tp_traverse`` - in the type structs of the objects involved), including: +As we have seen above, a function that imports module state can be +frozen. When that function is executed, it will get a reference to +the mutable module object of its current sub-interpreter. The +listing below shows this. - * Object attributes (``__dict__`` for user-defined objects, - ``tp_dict`` for built-in types). +.. code-block:: python + :caption: **Listing 9:** A frozen function performing an import + + @frozen + def roll(): + import random + return random.random() + + roll() # OK! + roll() # OK! (returns different number with high probability) + +This behaviour is different from a function that captures a +module object imported in the outer scope. Recall that modules +are unfreezable by default. If we allowed freezing to propagate +to module objects by default, freezing would in many cases +incapacitate modules captured by the functions. + +An author can allow freezing of their module by setting its +freezability during module initialisation using the +``set_freezable()`` function. Modules that opt-in to freezing +can easily be shared across sub-interpreters like other +immutable objects. `Escape hatches`_ can be used to retain some +mutable state in an otherwise frozen module. + +Some modules may support multiple sub-interpreters but not +freezing the module state. This PEP introduces an alternative +to freezing modules which supports these cases by turning the +modules into proxy objects that import the module on demand +very similar to the one behaviour proposed by `PEP 810`_ for +lazy imports. This behaviour is enabled by calling +``set_freezable(module, Proxy)`` on the module in question. + +.. _PEP 810: https://peps.python.org/pep-0810/ + +Before showing how ``set_freezable(module, Proxy)`` works, let's +first look at what could happen if the random module with its state +would be frozen without any internal changes to support this: - * Container elements (e.g., lists, tuples, dictionaries, - sets). +.. code-block:: python + :caption: **Listing 10:** Freezing a module object can incapacitate the module. + + import immutable + import random + + # This is pretty uncivilised to call on someone else's module + immutable.set_freezable(random, immutable.Yes) + + @frozen + def roll(): + return random.random() + + roll() # fails because the random module has been frozen! + +In the code above, the programmer makes the random module +freezable by an explicit call to ``set_freezable()``. However, +the top-level ``random()`` function requires the module state +to be mutable. Any future calls to random would fail, as the +internal state can no longer be mutated. + +To get around this, a module can use `escape hatches`_ for its mutable state or +use the ``Proxy`` mode. This mode allows the module object to be +frozen but keeps the underlying module state mutable. Any accesses +to the frozen module object will be delegated to the (mutable) +module state of the current sub-interpreter. An expression like +``module.function()`` will then be semantically equivalent to +``__import__(module.__name__).function()``. This will retrieve the +mutable module state of the sub-interpreter and import the module +on demand if this is the first usage of the module on the given +sub-interpreter. + +Thus, the proxy mode logically turns the ``roll()`` function from +**Listing 10** into the ``roll()`` function from **Listing 9** +that moved the import statement into the function. In this way +it is basically the same as the behaviour from `PEP 810`_ for +lazy imports. + +The proxy mode will work by installing a pre-freeze hook on the module +that turns the module object in to a proxy object before freezing it. +The proxy object is decoupled from the module, so freezing the proxy +has no effect on the module. + +**This is what a module object's pre-freeze hook does on freeze +to accomplish this:** +Before it freezes a module object *m* with name *n* it first makes a +copy *m'* of *m* and stores that copy in a new ``mut_modules`` +dictionary in the ``sys`` module. It then removes all module state +from *m* and turns *m* into a proxy object that transparently +delegates all accesses to *m'* via ``sys.mut_modules[n]`` on the +*current interpreter*. The proxy *m* will also import the module if +it is missing from the interpreter it is being accessed from. *m* +can now be frozen without effecting the mutable state stored in +*m'* since there is no direct reference from *m* to *m'*. This is +transparent to Python code interacting with the module and +subsequent sharing of *m* is easy as it is deeply immutable. + +To set its own freezing status, a module can simply operate on +itself during initialisation. - * The ``__class__`` attribute of an object (which makes freezing - instances of user-defined classes also freeze their class - and its attributes). +.. code-block:: python - * The ``__bases__`` chain in classes (freezing a class freezes its - base classes). + # in the init part of the module + current_module = sys.modules[__name__] + set_freezable(current_module, immutable.Proxy) + +.. _summary-2: + +Summary +~~~~~~~ + +In addition to the immutability support for built-in types: + +- Mutable, freezable objects can be made immutable if all the state + reachable from them can be made immutable. +- Immutable types and function may not capture references to mutable state. +- Making an object immutable blocks subsequent mutation of the object. +- Types require an explicit call to ``freeze()`` by default to be made immutable. +- The ``@frozen`` decorator can be used to freeze a function or type directly + after creation. +- The ``@freezable`` decorator can be used to allow implicit freezing of types. +- The ``@unfreezable`` decorator can be used to prevent + freezing under all circumstances. +- An immutable type’s functions are all immutable, and methods cannot + be added, removed, or changed. +- Instances of immutable types are mutable at creation but can be + made immutable (unless they have been made unfreezable). +- Certain types are frozen by default such as ``dict``, ``list``, ``function``, etc. +- Any object can have a pre-freeze hook that can be used to run + code just before an object is frozen or fail freezing. +- Modules are unfreezable by default but can opt-in to freezing. +- Modules support a special proxy mode which will delegate any + accesses to the mutable module on the current sub-interpreter. + + +Escape hatches +============== -5. Attempting to mutate an immutable object raises a type error - with a self-explanatory message. +Deep immutability can sometimes be too strict. (Examples of this has +come up in DPO discussions -- for example, a class might use a mutable +cache internally, even though all its instances are technically +immutable.) To this end, we provide two escape hatches, both in the form +of a field that stays mutable even when the object containing the field +is immutable: + +1. **Shared fields** which can only hold immutable objects. +2. **Interpreter-local fields**, which may hold both mutable and + immutable objects. + +A shared field’s value is visible to all sub-interpreters that read the +field. Since only immutable objects can be shared across +sub-interpreters, that means that shared fields can only contain +immutable objects. This is checked by the field on assignment, and +attempts to store a mutable objects in a shared field throws an +exception. The field takes care of synchronisation if multiple +sub-interpreters read or write the field at the same time, and ensures +that reference count manipulations are correctly handled. + +An interpreter-local field transparently behaves as multiple +fields, one per sub-interpreter in the program, and each +sub-interpreter will only ever read or write “it's field”. This +ensures that two sub-interpreters accessing the same field +concurrently will not race on the value in the field, since they +are accessing different objects. When a mutable value is stored in +an interpreter-local field, it will only be accessible to the +sub-interpreter that stored it. Thus, supporting mutable values is +safe. + + +Shared fields +------------- +Shared fields are implemented as an object indirection. The ``shared`` object +is part of the ``immutable`` module that this PEP provides. Here is an +example that shows what programming with a shared field might look like. +The example shows a class maintaining a mutable instance counter, that +keeps working even after the class is made immutable. -Illustration of the Deep Freezing Semantics -------------------------------------------- +.. code-block:: python + :caption: **Listing 11:** Cell implemented using a shared field. + + import immutable # library this PEP provides + + class Cell: + counter = immutable.shared_field(0) + + def __init__(self, a): + self.value = a + while True: + old = self.__class__.counter.get() + new = old + 1 + immutable.freeze(new) # shared fields can only hold immutable objects + if self.__class__.counter.set(old, new): # stores new in counter if counter's value is old + self.id = new + return # break out of loop on success + + def __repr__(self): + return f"Cell({self.value}) instance number {self.id})" + + c = Cell(42) + immutable.freeze(c) # Note: freezes Cell + immutable.is_frozen(Cell) # returns True + print(c) # prints Cell(42) instance number 1 + d = Cell(4711) + print(d) # prints Cell(4711) instance number 2 + +Note that in free-threaded Python, it would be technically safe to +permit a shared field to store *mutable* objects, as the problem with +multiple sub-interpreters accessing a mutable value under different GILs +does not exist. However, we believe in keeping the programming model the +same regardless of whether sub-interpreters or free-theading is used. +(Programming with immutable objects is also less prone to subtle +errors.) + +Let’s use the same diagrams as when explaining the problem with having a +reference to mutable state from immutable state above, to show how the +shared field is different. Let us again use two sub-interpreters that +both have a reference to a shared immutable counter declared as above: + +.. figure:: pep-0795/diagram_10.svg + + **Figure 8:** Shared field. + +Notably, there are no references from immutable state to mutable state +inside a sub-interpreter, which we have seen causes problems. While the +shared field object poses as an immutable object in the system, it is +really mutable, which is why it is drawn in gray. As it uses its own +synchronisation internally, and only manipulates immutable objects, it +is not a problem that concurrent accesses do not synchronise with each +other (which they don’t since they use different GILs to synchronise). + + +Interpreter-local fields +------------------------ -Consider the following code: +Interpreter-local fields are analogous to ``threading.local()`` in +Python, but keeps one value per interpreter, as opposed to one value per +thread. Thus, if two different sub-interpreters read the same field, +they may read different values; two threads in the same sub-interpreter +will always read the same value (provided there has been no interleaving +mutation). -.. code-block:: python +Interpreter-local fields can store both mutable and immutable objects. +In the case of a mutable object, this object is guaranteed to live +on the heap of the only sub-interpreter that can access it through the field. It is +therefore safe to store mutable objects in such a field. - class Foo: - pass - - x = Foo() - x.f = 42 - - -The ``Foo`` instance pointed to by ``x`` consists of several -objects: its fields are stored in a dictionary object, and the -assignment ``x.f = 42`` adds two objects to the dictionary in the -form of a string key ``"f"`` and its associated value ``42``. -These objects each have pointers to the ``string`` and ``int`` -type objects respectively. Similarly, the ``foo`` instance has a -pointer to the ``Foo`` type object. Finally, all type objects have -pointers to the same meta class object (``type``). - -Calling ``freeze(x)`` will freeze **all** of these objects. - - -Default (Im)Mutabiliy ---------------------- - -Except for the type object for ``NotFreezable``, no objects are -immutable by default. - -**Rejected alternative**: Interned strings, numbers in the small -integer cache, and tuples of immutable objects could be made -immutable in this PEP. This is either consistent with current -Python semantics or backwards-compatible. We have rejected this -for now as we have not seen a strong need to do so. (A reasonable -such design would make *all* numbers immutable, not just those in -the small integer cache. This should be properly investigated.) - - -Consequences of Deep Freezing -============================= - -* The most obvious consequence of deep freezing is that it can lead - to surprising results when programmers fail to reason correctly - about the object structures in memory and how the objects reference - each other. For example, consider ``freeze(x)`` followed by - ``y.f = 42``. If the object in ``x`` can reach the same object that - ``y`` points to, then, the assignment will fail. **Mitigation:** To - facilitate debugging, exceptions due to attempting to mutate immutable - objects will include information about on what line an object was made - immutable. - -* Class Freezing: Freezing an instance of a user-defined class - will also freeze its class. Otherwise, sharing an immutable object - across threads would lead to sharing its *mutable* type object. Thus, - freezing an object also freezes the type type object of its super - classes. This means that any metaprogramming or changes to a class - must happen before a class is made immutable. **Mitigation:** An immutable class - can be extended and its behaviour overridden through normal object-oriented - means. If neccessary, it is possible to add an option to make a mutable - copy of immutable objects and classes, which could then be changed. - Mutable instances of an immutable class can have their classes changed - to the mutable copy by reassigning ``__class__``. - -* Metaclass Freezing: Since class objects have metaclasses, - freezing a class may propagate upwards through the metaclass - hierarchy. This means that the ``type`` object will be made immutable - at the first call of ``freeze``. **Mitigation:** We have not explored - mitigation for this, and we are also not aware of major problems - stemming from this design. - -* Global State Impact: Although we have not seen this during our - later stages of testing, it is possible that freezing an object that references - global state (e.g., ``sys.modules``, built-ins) could - inadvertently freeze critical parts of the interpreter. - **Mitigation:** Avoiding accidental freezing is possible by - inheriting from (or storing a pointer to) the ``NotFreezable`` - class. Also, when the Python interpreter is exiting, we make all - immutable objects mutable to facilitate a clean exit of the - interpreter. Also note that it is not possible to effectively - disable module imports by freezing. - -As the above list shows, a side-effect of freezing an object is -that its type becomes immutable too. Consider the following program, -which is not legal in this PEP because it modifies the type of an -immutable object: +The ``immutable`` module contains the class for interpreter-local +fields. Here is what programming with such a field might look like: .. code-block:: python + :caption: **Listing 12:** Cache in prime factoriser implemented using an interpreter-local field. + + import immutable # library this PEP provides + + class PrimeFactoriser: + def __init__(self): + self.cache = immutable.local(freeze(lambda: { 2: [2], 3: [3], 4: [2, 2] })) + def factorise(self, number): + if self.cache.has_key(number): + return self.cache[number] + else: + factors = ... # perform calculation + self.cache[number] = factors + return factors + + pf = PrimeFactoriser() + immutable.freeze(pf) + pf.factorise(7) # will update the cache as side-effect (on the current interpreter) + +The example above maintains a mutable dictionary as part of a cache. +Despite ``pf`` being immutable, we can still mutate the cache, but the +mutations and the cache are only visible on the current interpreter. +Another interpreter trying to factorise 7 will have to redo the +calculations and populate its own cache. (The immutable lambda function is +used to initialise the local storage on each sub-interpreter on first +access.) + +While interpreter-local fields cannot be used to implement a global +instance counter, we can use a shared field to implement the caching. +Since a shared field cannot hold mutable objects, we would have to +freeze the dictionary before storage, and to update the cache we would +have to first make a mutable copy of the current cache, add to it, and +then freeze it again before storing it back into the field. On the other +hand, we only need to cache prime factors once as opposed to +once-per-interpreter, as the cache is global. + +We can illustrate the difference between the interpreter-local escape +hatch and shared fields pictorally: + +.. figure:: pep-0795/diagram_11.svg + + **Figure 9:** Interpreter-local field. + +The interpreter-local field ensures that accesses from Sub 1 yield the +reference to E, whereas accesses from Sub 2 yield the reference to F. +Thus, all accesses to a mutable object on one interpreter’s heap is +always synchronising on the same GIL. + +As one more example of how shared fields and interpreter-local fields +complement each other, we revisit the list of references from a +superclass object to its subclasses that we are not freezing. We can +implement this using a shared field in combination with an +interpreter-local field. Consider the immutable class A, to which we +want to add a new *immutable* subclass B and a new *mutable* subclass C. +Since immutable subclasses are shared, we add a shared field with an +immutable list of references to immutable subclasses. Every time we add +to that list, we create a new list from the old, add the new reference, +freeze the new list and stick it back into the shared field. In contrast +to B, the mutable subclass C should only be visible to the +sub-interpreter that defined it. Thus, we use an interpreter-local field +to keep a (mutable) list of the mutable subclasses of A. Together, these +two lists store the subclasses of a class. + + +Initialisation of interpreter-local fields +------------------------------------------ + +Interpreter-local fields can hold mutable objects which can only be +initialised from the interpreter to which the field belongs. To permit +the interpreter that defines the field to control the initialisation of +the field, the constructor ``local`` accepts an immutable function object as +input. The function is called by each sub-interpreter on first access of +the field to install its default value. Here is an example: - from immutable import freeze - - class Counter: - def __init__(self, initial_value): - self.value = initial_value - def inc(self): - self.value += 1 - def dec(self): - self.value -= 1 - def get(self): - return self.value - - c = Counter(0) - c.get() # returns 0 - freeze(c) # (*) -- this locks the value of the counter to 0 - ... - Counter.get = lambda self: 42 # throws exception because Counter is immutable - c.get() # would have returned 42 unless the line above had been "stopped" - -With this PEP, the code above throws an exception on -Line (*) because the type object for the ``Counter`` type -is immutable. Our freeze algorithm takes care of this as -it follows the class reference from ``c``. If we did not -freeze the ``Counter`` type object, the above code would -work and the counter will effectively be mutable because -of the change to its class. - -The dangers of not freezing the type is apparent when considering -avoiding data races in a concurrent program. If an immutable counter -is shared between two threads, the threads are still able to -race on the ``Counter`` class type object. - -As types are immutable, this problem is avoided. Note that -freezing a class needs to freeze its superclasses as well. - - -Subclassing Immutable Classes ------------------------------ +.. code-block:: python + :caption: **Listing 13:** Initialising an interpreter-local field. -CPython classes hold references to their subclasses. If -immutability it taken literally, it would not be permitted to -create a subclass of an immutable type. Because this reference -does not get exposed to the programmer in any dangerous way, we -permit immutable classes to be subclassed (by mutable classes). C.f. -`Sharing Immutable Data Across Subinterpreters`_. + from immutable import local + sharable_field = local(freeze(lambda: 0)) +The first time the sharable field is loaded by a sub-interpreter, that +sub-interpreter will call the lambda function and store its result in +the value of the local field for that sub-interpreter. (If the initial +value is an immutable object, one could also consider passing in the +object straight, rather than a function that returns it.) -Freezing Function Objects -------------------------- -Function objects can be thought of as regular objects whose fields -are its local variables -- some of which may be captured from -enclosing scopes. Thus, freezing function objects and lambdas is -surprisingly involved. +Cycles involving escape hatches +--------------------------------- -Consider the following scenario: +Cycles that involve escape hatches will not be collected +unless they are manually broken. This is because the cycle detector +is per interpreter, and thus without adding a stop all sub-interpreters +collector it is not possible to find cycles that involve either shared +fields or interpreter-local fields. -.. code-block:: python +In the free-threaded build, the new stop the world cycle detector +will find cycles involving shared fields, but not interpreter-local fields. - from immutable import freeze - def example1(): - x = 0 +Controlling the propagation of freezing +======================================= - def foo(): - return x +A recurring theme when discussing this proposal on DPO has been concerns +that freezing an object will propagate beyond the programmers intention, and cause +objects to be made immutable accidentally. Immutability propagation is an inherent effect in +immutability systems as witnessed by e.g. ``const`` in C and C++. +Annotating a variable or function with ``const`` typically propagates in +the source code, forcing the addition of additional ``const`` +annotations, and potentially changes to the code. In C and C++, this +happens at compile-time, which helps understanding the propagation. (See +also the section on static typing for immutability later in this +document. - freeze(foo) - ... # some code, e.g. pass foo to another thread - x = 1 - foo() +Freeze propagation is not possible to escape unless one +wants to limit immutability to something that happens only +at creation. This is not compatible with Python patterns like +monkey patching and cyclic structures. (Or how types are defined.) - example1() +By making classes *explicitly freezable* we avoid freezing one +object propagating to all objects of the same type at the same +time as we stop careless freezing of objects. To make a class +freezable, code must explicitly make it so, through an +``@frozen`` (at definition-time), ``@freezable`` opting in to +being frozen as a side-effect of freezing an instance, or through +an explicit call to ``freeze()`` on the type object itself. This +serves as documentation similar to the ``const`` propagation +above, even though -- as Python is a dynamically checked language -- +this ``const``-like propagation will be driven by run-time errors +rather than compile-time. -In the code above, the ``foo`` function object captures the ``x`` -variable from its enclosing scope. While ``x`` happens to point to -an immutable object, the variable itself (the frame of the function object) -is mutable. Unless something is done to prevent it (see below!), passing -``foo`` to another thread will make the assignment ``x = 1`` a potential -data race. -We consider freezing of a function to freeze that function's -meaning at that point in time. In the code above, that means that -``foo`` gets its own copy of ``x`` which will have value of the enclosing -``x`` at the time of freezing, in this case 0. +Immutable Built-in Objects +-------------------------- -Thus, the assignment ``x = 1`` is still permitted as it will not affect -``foo``, and it may therefore not contribute to a data race. Furthermore, -the result of calling ``foo()`` will be 0 -- not 1! +Initially we discussed support for immutable objects +which are constructed from de-facto immutable objects in Python 3.14. As +objects can only be immutable at creation-time, there is no freeze +propagation. Object graphs must be constructed inside out from immutable +building blocks. This can be cumbersome, but the result is never +surprising. -This is implemented by having ``x`` in ``foo`` point to a fresh -cell and then freezing the cell (and similar for global capture). -Note that this also prevents ``x`` from being reassigned. +This will allow sub-interpreters to immutably share things like strings, +integers, tuples, named tuples etc. This is expressive enough to for +example express JSON-like structures, but notably does not support +sharing arbitrary objects of user-defined type, and not arbitrary +functions. -We believe that this design is a sweet-spot that is intuitive and -permissive. Note that we will treat freezing functions that -capture enclosing state in the same way regardless of whether the -enclosing state is another function or the top-level (i.e., the -enclosing scope is ``globals()``). +**Propagation rules:** -(A **rejected alternative** is to freeze ``x`` in the -enclosing scope. This is problematic when a captured variable is -in ``globals()`` and also rejects more programs.) +- There is no such thing as freeze propagation. Objects are immutable from + the leaves up, at construction-time. There is no need for the ``freeze()`` + function for these objects. -Now consider freezing the following function: +**Freezing rules:** -.. code-block:: python +- An object which is an instance of a type that is de-facto immutable + in Python 3.14 is immutable at creation; unless it references data + that are mutable. Notable exception: instances of ``type`` are + mutable; only the *type objects* we have explicitly + listed are immutable. (Plus types registered as shallow immutable.) - from immutable import freeze +**Immutability invariant:** - def example2(): - x = 0 - def foo(a = False): - nonlocal x - if a: - a = a + 1 # Note: updating local variables work, even in a frozen function - return a - else: - x = x + 1 - return x +- An immutable object only references other immutable objects. - freeze(foo) - foo(41) # OK, returns 42 - foo() # Throws NotWriteableError - example2() +Objects of User-Defined Type +----------------------------- -This example illustrates two things. The first call to ``foo(41)`` -shows that local variables on the frame of a call to an immutable -function objects are mutable. The second call shows that captured -variables are not. Note that the default value of ``a`` will be -made immutable when ``foo`` is frozen. Thus, the problem of -side-effects on default values on parameters is avoided. +This PEP goes beyond built-in typed to support user-defined immutable +types and functions, plus dicts, lists, and sets. These types and +instances of these types are *freezable* meaning they are mutable +objects that can be made immutable. An immutable object cannot be made +mutable, but it is possible to create a mutable copy. -Immutable function objects that access globals, e.g. through an -explicit call to ``globals()``, will throw an exception when -called. +To this end, we introduced freeze propagation through a +``freeze()`` function or a ``@frozen`` decorator to make +mutable objects, types, and functions immutable right after +creation. A pre-freeze +hook can be used for fine-grained control over freezing behaviour. +We used the pre-freeze hook both to implement immutable functions +and a proxy mode for modules. -Implementation Details -====================== +**Propagation rules:** -1. Add the ``immutable`` module, the ``NotWriteableError`` type, and - the ``NotFreezable`` type. +- Freezing an object propagates to other objects that it can reach, + directly or indirectly. This notably includes the type of the object, + the functions in the type, and any objects referenced from the object. +- By default, types only support freezing *directly*, meaning freezing + an object fails to not propagate to its type (causing the freezing + of the object to fail as well). A type can opt-out of requiring + explicit freezing, *e.g.,* through the ``@freezable`` decorator. -2. Add the ``freeze(obj)`` function to the ``immutable`` module and - ensure that it traverses object references safely, including - cycle detection, and marks objects appropriately, and backs - out on failure, possibly partially freezing the object graph. +**Freezing rules:** -3. Add the ``register_freezable(type)`` function that is used to - whitelist types implemented as C extensions, permitting their - instances to be made immutable. +- Objects which are explicitly freezable (this includes all type + objects) must be frozen explicitly -- not indirectly + via freeze propagation. (Other attempts fail.) +- Freezing an object graph fails if it contains objects that cannot be frozen. +- An individual object can be made impossible to freeze by setting + ``set_freezable(obj, No)``. A convenience decorator ``@unfreezable`` + is also available. +- Right before freezing propagates to an object, its ``__pre_freeze__`` + method will be called if it exists. If freezing fails, effects in + the pre-freeze hook persists. +- Modules are by default not freezable, but they have a special freezability + called ``Proxy`` that forwards all accesses to the sub-interpreter + local state and imports the module on demand. -4. Add the ``isfrozen(obj)`` function to the ``immutable`` module - that checks whether or not an object is immutable. The status - is accessible through ``_Py_ISIMMUTABLE`` in the C API and in - Python code through the ``isfrozen(obj)`` function. +**Immutability invariant:** -5. Modify object mutation operations (``PyObject_SetAttr``, - ``PyDict_SetItem``, ``PyList_SetItem``, etc.) to check the - flag and raise an error when appropriate. +- An immutable object only references other immutable objects, with the + exception of mutable objects that preserve sub-interpreter isolation + but are nevertheless marked as immutable in the system. (For example + `escape hatches`_.) -6. Modify mutation operations in modules in the standard library. +Details and discussion +---------------------- +Freezing objects +~~~~~~~~~~~~~~~~ -Changes to the C ABI --------------------- +An object can become immutable if it satisfies *all* of the +constraints below: -* ``Py_CHECKWRITE`` +- It is not unfreezable. +- All the objects reachable from the object can become immutable (or are + permitted to be frozen), including classes and functions in classes. -* ``_Py_IsImmutable`` +Failing to satisfy any of the above constraints will cause +freezing to fail, leaving all objects in their original state. +(Note that effects in pre-freeze hooks are not undone.) -* ``PyErr_WriteToImmutable`` -Changes to the internal API ---------------------------- +Freezing functions +~~~~~~~~~~~~~~~~~~ -* ``_PyType_HasExtensionSlots(PyTypeObject*)`` -- determines whether a TypeObject adds novel functionality in C +A function can become immutable if it satisfies *all* of the constraints below: -* ``_PyNotFreezable_Type`` +- All the constraints on freezing objects above. +- If the function has default arguments, these can be (and will become) frozen. -* ``_PyImmutability_Freeze`` +For example, each of the following functions can be made immutable by a simple +call to ``freeze``: -* ``_RegisterFreezable`` +.. code-block:: python + :caption: **Listing 14:** Examples of freezable functions. -* ``_PyImmutability_IsFreezable`` + # pure function -- freezing will not propagate + def function1(a, b): + return a + b + # freezing will propagate to function1 + def function2(a, b): + return function1(a, b) -Performance Implications -======================== + freeze(x) + # only captures immutable state -- freezing will not propagate + def function3(a): + a.append(x) -The cost of checking for immutability violations is -an extra dereference of checking the flag on writes. -There are implementation-specific issues, such as -various changes based on how and where the bit is stolen. + # freezing will propagate to y + def function4(a): + y.append(a) # Note -- will throw exception always when called +The final example shows that freeze propagation can make a function +unusable. -More Rejected Alternatives -========================== +If class ``Foo`` defines an instance method ``bar`` or a static method +``bar``, then ``Foo.bar`` is a function object. Thus, the following +succeeds: -1. Shallow Freezing: Only mark the top-level object as immutable. - This would be less effective for ensuring true immutability - across references. In particular, this would not make it safe - to share the results of ``freeze(obj)`` across threads without risking - data-race errors. Shallow immutability is not strong enough to support - sharing immutable objects across subinterpreters (see extensions). +.. code-block:: python + :caption: **Listing 15:** Freezing a function object directly. -2. Copy-on-Write Immutability: Instead of raising errors on - mutation, create a modified copy. However, this changes object - identity semantics and is less predictable. Support for copy-on-write - may be added later, if a suitable design can be found, but not as - an alternative to what this PEP proposes. + # showcase different way of supporting freezing + @freezable + class Foo: + def bar(self): + self.variable = 42 + return self.variable -3. Immutable Subclasses: Introduce ``ImmutableDict``, ``ImmutableList``, - etc., instead of freezing existing objects. However, this does - not generalize well to arbitrary objects and adds considerable - complexity to all code bases. + freeze(Foo.bar) # succeeds + foo = Foo() + foo.bar() # OK, returns 42 -4. Deep freezing immutable copies as proposed in :pep:`351` The - freeze protocol. That PEP - is the spiritual ancestor to this PEP which tackles the - problems of the ancestor PEP and more (e.g. meaning of - immutability when types are mutable, immortality, etc). +Note that ``freeze(foo)`` would subsequently cause ``foo.bar()`` to fail +because ``self`` inside ``foo`` would now be immutable. -5. Deep freezing replaces data races with exceptions on attempts to - mutate immutable objects. Another alternative would be to keep - objects mutable and build a data-race detector that catches read--write - and write--write races. This alternative was rejected for two main - reasons: +If an immutable function object is bound to a method object, the method +object is mutable, and the “self” object can be mutable too. - 1. It is expensive to implement: it needs a read-barrier to - detect what objects are being read by threads to capture - read--write races. - 2. While more permissive, the model suffers from non-determinism. - Data races can be hidden in corner cases that require complex - logic and/or temporal interactions which can be hard to - test and reproduce. +Freezing methods +~~~~~~~~~~~~~~~~ -Another rejected idea was to provide a function ``isfreezable(obj)`` which -returns ``True`` if all objects reachable from ``obj`` can be made -immutable. This was rejected because free-threaded Python permits -data-races during freezing. This means that the result of the check -can be non-deterministic. A better way is to simply try to make -an object immutable and catch the exception if the object could not -be frozen. +Method objects are wrappers for function objects and the object to which +the method is bound, the “self”. Freezing a method object will propagate +to its function and self object. -A Note on Modularisation -======================== +Freezing types +~~~~~~~~~~~~~~ -While the ``freeze(obj)`` function is available to Python programmers -in the ``immutable`` module, the actual freezing code has to live -inside core Python. This is for three reasons: +A type can become immutable if it satisfies *all* of the constraints below: -1. The core object type needs to be able to freeze just-in-time - dictionaries created by its accessors when the object itself is - immutable. +- It is not unfreezable. +- All its supertypes are immutable or freezable. +- Its meta class either is or can become immutable. (We will expand on this at a later date -- currently most meta classes cannot be frozen out of the box because of mutable state.) +- All the reachable objects from the type (function objects, class variables) can be frozen. -2. The managed buffer type needs to be immutable when the object it - is created from is immutable. +Note the absence of a requirement that all functions defined in the +class must be able to become immutable. **If a function fails to freeze, it will not be +possible to call that function on the immutable type.** This alternative is +preferrable to failing to freeze a type if not all its functions can become +immutable and can be used to mimic statically checkable systems where it is +not possible to call e.g. "non-const methods on const receivers", which will +be checked dynamically and give a clearer error message than simply a failure +to mutate. -3. Teardown of strongly connected components of immutable objects - (see `Simplified Garbage Collection for Immutable Object - Graphs`_) must be hooked into ``Py_DECREF``. +Thus, in the example below, ``Foo`` can become immutable, but ``Foo.method1`` +cannot be called from that point on, because the function failed to +freeze. -As such, we implement a function which is not in the limited API -(and thus not part of the stable C ABI) called ``_PyImmutability_Freeze`` -which performs the freezing logic. This is used internally as a C -Python implementation detail, and then exposed to Python through -the ``freeze(obj)`` function in the ``immutable`` module. +.. code-block:: python + :caption: **Listing 16:** When methods fail to freeze. + def function1(a): + return a -Weak References -=============== + x = [] + def function2(a): + x.append(a) -Weak references are turned into strong references during freezing. -Thus, an immutable object cannot be effectively mutated by a -weakly referenced nested object being garbage collected. If a weak -reference loses its object during freezing, we treat this as a -failure to freeze since the program is effectively racing with the -garbage collector. + class Foo(object): + def __init__(self, a): + self.a = function1(a) + @unfreezable + def method1(self): + function2(self.a) -A **rejected alternative** is to nullify the weak reference during -freezing. This avoid the promotion to a strong reference while -ensures that the immutable object stays the same throughout its -lifetime, but probably has the unwanted semantics of pruning the -object graph while freezing it. (Imagine a hash table with weak -references for its keys -- if freezing it removes all its keys, -the hash table is essentially useless.) + freeze(Foo) # OK + foo = Foo() # OK + foo.method1() # raises exception -- "method1 not safe to call when Foo is immutable" -Another **rejected alternative** is to simply leave weak references -as is. This was rejected as it makes immutable objects effectively -mutable and access to shared immutable objects can race on accesses -to weak references. +Dealing with cyclic dependencies +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -Hashing -======= +Objects that are explicitly freezable can be in a cyclic +dependency. -Deep immutability opens up the possibility of any freezable object being -hashable, due to the fixed state of the object graph making it possible to compute -stable hash values over the graph as is the case with ``tuple`` and ``frozenset`` . However, -there are several complications (listed below) which should be kept in mind for any future -PEPs which build on this work at add hashability for frozen objects: +.. code-block:: python + :caption: **Listing 17:** Freezing with cyclic dependencies. + + class A: + def foo(self): + self.value = B() + + class B: + def bar(self): + self.value = A() + +Notably, freezing ``A`` freezes ``A.foo`` which captures ``B``. +However, since ``B`` is explicitly freezable, freezing ``A.foo`` +will fail. Trying to first freeze ``B`` does not solve the +problem, as ``B.bar`` fails to freeze ``A`` which is also +explicitly freezable. The solution to this problem is to let +``freeze`` take multiple arguments which can be used to resolve +these kinds of situations: ``freeze(A, B)`` will permit ``A.foo`` +to capture ``B`` because it sees that ``B`` is in the list of +things which will be made immutable. (And if ``B`` would fail for +some other reason, the effects of the entire call will be made +undone.) + +For the same reason, we cannot mark ``A`` and ``B`` with ``@frozen``. +Dealing with cyclic dependencies requires freezing to happen after +all classes involved have been constructed. *This can be solved by +making freezing slightly more complicated.* + + +Preventing a freezable instance from becoming immutable +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +To prevent a freezable object from becoming immutable we can set +``set_freezable(obj, No)``. The ``immutable`` module that this PEP +provides contains a context manager that one can use to manipulate +this status at the start of a block, and restore it at the end: + +.. code-block:: python + :caption: **Listing 18:** Making objects temporarily unfreezable. + with immutable.disabled(obj): + # old = get_freezable(obj) + # set_freezable(obj, immutable.No) + ... + call_into_some_library(obj) + ... + # implicitly does set_freezable(obj, old) -Instance versus Type Hashability + +Immutability out-of-the-box +--------------------------- + +This PEP proposes that all types which have the ``Py_TPFLAGS_IMMUTABLETYPE`` flag +and which are considered immutable for hashability will be automatically made PEP795-immutable, +either in all cases or if constructed from PEP795-immutable objects. In the +case of the core language and standard library, these types consist of the following: + +- ``int`` +- ``float`` +- ``True``, ``False`` +- ``complex`` +- ``str``, +- ``bytes`` +- ``memoryview`` +- ``range`` +- ``slice`` +- ``None`` +- ``decimal.Decimal`` + +And if constructed from PEP795-immutable objects: + +- ``tuple``, +- ``namedtuple`` +- ``frozenset`` +- ``dict`` +- ``list`` +- ``set`` +- ``collections.defaultdict`` +- ``collections.deque`` +- ``array.array`` +- ``ctypes`` (existing and programmer derived) +- ``xml.etree.ElementTree.Element`` +- ``fraction.Fraction`` +- ``ipaddress.IPv4Address``, ``ipaddress.IPv4Interface``, ``ipaddress.IPv6Address``, ``ipaddress.IPv6interface`` +- ``uuid.UUID`` + +Whereas some of these will be like the types above and simply immutable at creation (*e.g.*, ``decimal.Decimal``) +others will require object instances to be marked as immutable (*e.g.*, all the collections). + +No additional work is required on the part of the programmer to take advantage of +the immutability of these objects, our immutability simply extends the properties of +these objects to allow sharing across sub-interpreters without need for pickling or +copying. + + +The ``immutable`` library +========================= + +In this section we describe the ``immutable`` library that contains the +user-facing functions of this PEP. Note that this PEP relies on checking +an object’s immutability status before writes, which requires many +changes to core Python. + + +The ``freeze`` function +----------------------- + +The ``freeze`` function is arguably the most important function +in this PEP. A call to ``freeze(obj, ...)`` will traverse the +object graph starting in ``obj``. For each object it will check +the freezability of the object, if the object is freezable, the +pre-freeze hook of the object will be called. The function accepts +multiple objects as arguments, all object given to the function are +considered to be explicitly frozen, meaning that they can be frozen +even if their freezability is ``Explicit``. + +If freezing fails, meaning ``obj`` can't fulfil the *immutable invariant*, +all objects will be left in the mutability state they were right +before the call. Changes made by the pre-freeze hook will not be +undone. + +When freezing succeeds, we set the bit in its header that is used +to track the immutability status. All writes to fields in objects are +expected to check the status of this bit, and raise an +exception instead of carrying out the field write when the bit is set. + +As part of freezing, we perform an analysis of the object graph that +finds the strongly connected components in the graph that becomes immutable. +A strongly connected component is essentially a cycle where every object +can directly or indirectly reach all other objects in the component. +This means that all objects in a strongly connected component will have +exactly the same lifetime. This in turns mean that we can use a single +reference count to manage the lifetime of all the objects in the +component. This means that no cycle detection is needed for immutable +objects. + +With respect to the implementation, we select one object in the +component to hold the reference count, and turn remaining reference +counters into pointers to that object. That means that reference count +manipulations on immutable objects will need one more indirection to +find the actual counter (in the general case). + + +The ``is_frozen`` function +-------------------------- + +The ``is_frozen`` function inspects the bit in the object header +set by the ``freeze`` function and returns ``True`` if this bit is +set. If called on a shallow immutable object, and the bit is not +set, ``is_frozen`` will inspect the sub-objects and return true if +their ``is_frozen`` check succeeds. + + +The ``set_freezable`` function and the ``Yes``, ``No``, ``Explicit``, and ``Proxy`` constants +---------------------------------------------------------------------------------------------- + +Sets the freezable status of an object to either ``Yes``, ``No``, +or ``Explicit`` (default is ``Yes``). Module objects can also have +the status ``Proxy``. + + +The ``disabled`` context manager -------------------------------- -At the moment, the test for -`hashability `__ -is based upon the presence (or absence) of a ``__hash__`` method and an -``__eq__`` method. Places where ``PyObject_HashNotImplemented`` is currently -used would need to be modified as appropriate to have a contextual logic -which provides a default implementation that uses ``id()`` if the object -instance has been frozen, and throws a type error if not. +This is a very simple context manager that calls +``set_freezable(o, No)`` on the object ``o`` at the start of the +block (meaning the object is not freezable), and restores the +original value at the end of the block, *e.g.,* ``set_freezable(o, +Yes)``. -This causes issues with type checks, however. The check of -``isinstance(x, Hashable)`` would need to become contextual, and -``issubclass(type(x), Hashable)`` would become underdetermined for -many types. Handling this in a way that is not surprising will require -careful design considerations. +.. _frozen: -Equality of Immutable Objects ------------------------------ -One consideration with the naive approach (*i.e.*, hash via ``id()``) is -that it can result in confusing outcomes. For example, if there were -to be two lists: +The ``@frozen``, ``@freezable`` and ``@unfreezable`` decorators +--------------------------------------------------------------- + +The decorator ``@unfreezable`` turns off support for freezing a +class or function. This allows excluding a type from a module when +the module is immutable, or a function from a type when the type is +immutable. + +The ``@freezable`` decorator makes a class freezable. This is the +same as ``set_freezable(class, Yes)``. + +The ``@frozen`` decorator freezes a declaration right after +creation. + + +Shared field +------------ + +Shared fields permit multiple interpreters to share a mutable field, +which may only hold immutable objects. It was described in the escape +hatch section above. + +The code below is not how shared fields are implemented, but describes +the behaviour of a shared field, except that freezing the field object +does not prevent subsequent assignment to ``self.value``. (To be clear: +this cannot be implemented in pure Python since it is not safe for +freezing to exclude ``self.value``.) .. code-block:: python + :caption: **Listing 19:** Semantics of shared fields described through Python + + import threading + import immutable + + def shared_field(initial_value=None): + @frozen + class SharedField: + def __init__(self, initial_value): + # Note, in this mockup, the value field stays mutable when freezing! + self.value = initial_value + self.lock = threading.Lock() + + def set(self, new_value): + if not is_frozen(new_value): + raise RuntimeError("Shared fields only store immutable values") + with self.lock: + old_value = self.value + self.value = new_value + return old_value + + def get(self): + with self.lock: + old_value = self.value + return old_value + + def swap(self, expected_value, new_value): + if not is_frozen(new_value): + raise RuntimeError("Shared fields only store immutable values") + with self.lock: + old_value = self.value + if old_value != expected_value: + return old_value + else: + self.value = new + return expected_value + + return immutable.freeze(SharedField(initial_value)) + + +Local fields +------------ + +Local fields permits an object to have a field that holds different +(mutable or immutable) values for different interpreters, i.e the field +is “interpreter-local”, analogous to how ``threading.local()`` works. It +was described in the escape hatch section above. + +The code below is not how interpreter-local fields are implemented, but +describes the behaviour of such fields, except that freezing the field +object does not prevent subsequent updates to the ``interpreter_map``. +(To be clear: this cannot be implemented in pure Python since it is not +safe for freezing to exclude ``interpreter_map``.) + +**FIXME** Check that the below corresponds with intended semantics. - a = [1, 2, 3, 4] - b = [1, 2, 3, 4] - assert(hash(a) == hash(b)) +.. code-block:: python + :caption: **Listing 20:** Semantics of local fields described through Python + + import immutable + + def local(init_func=None): + interpreter_map = {} + + @frozen # abuse of notation, interpreter_map is not made immutable + class LocalField: + def _resolve(self): + import sys + current = sys.interpreter_id + try: + return interpreter_map[current] + except KeyError: + value = init_func() + interpreter_map[current] = value + return value + + def __getattr__(self, name): + target = self._resolve() + if name == "get": + # used to read the value of the field, not dereference it + return target + else: + return getattr(target, name) + + def __setattr__(self, name, value): + if name == "set": + # used to set the value of the field, not update fields in the existing value + import sys + current = sys.interpreter_id + interpreter_map[current] = value + else: + target = self._resolve() + setattr(target, name, value) + + def __delattr__(self, name): + target = self._resolve() + delattr(target, name) + + def __call__(self, *args, **kwargs): + target = self._resolve() + return target(*args, **kwargs) + + def __repr__(self): + target = self._resolve().__repr__() + + return immutable.freeze(LocalField()) + + +Implementation +############## + +We will use two bits as flags per Python object: the first will be used +to track immutability; the second will be used by the SCC algorithm that +permits us to :ref:`manage cyclic immutable garbage without a cycle detector `. +This will be done without extending the size of the Python object +header. -There would be a reasonable expectation that this assertion would be true, -as it is for two identically defined tuples. However, without a careful -implementation of ``__hash__`` and ``__eq__`` this would not be the case. -Our opinion is that an approach like that used in ``tuplehash`` is -recommended in order to avoid this behavior. +Immutability is enforced through run-time checking. The macro +``Py_CHECKWRITE(op)`` is inserted on all paths that are guaranteed to +end up in a write to ``op``. The macro inspects the immutability flag in +the header of ``op`` and signals an error if the immutability flag is +set. + +A typical use of this check looks like this: +.. code-block:: c + :caption: **Listing 21:** Example of call to ``Py_CHECKWRITE``. -Decorators of Immutable Functions -================================= + if (!Py_CHECKWRITE(op)) { // perform the check + PyErr_WriteToImmutable(op); // raise the error if the check fails + return NULL; // abort the write + } + ... // code that performs the write -One natural issue that arises from deeply immutable functions is the -state of various objects which are attached to them, such as decorators. -In particular, the case of ``lru_cache`` is worth investigating. If the cache -is made immutable, then freezing the function has essentially disabled the -functionality of the decorator. This might be the correct and desirable -functionality, from a thread safety perspective! In practice, we see three -potential approaches: +Writes are common in the CPython code base and the writes lack a common +“code path” that they pass. To this end, the PEP requires a +``Py_CHECKWRITE`` call to be inserted and there are several places in +the CPython code base that are changed as a consequence of this PEP. So +far we have identified around 150 places in core Python which needed a +``Py_CHECKWRITE`` check. Modules in the standard library have required +somewhere between 5 and 15 checks per module. -1. The cache is frozen in its state at the point when freeze is called. - Cache misses will result in an immutability exception. +While the ``freeze(obj)`` function is available to Python programmers in +the immutable module, the actual freezing code has to live inside core +Python. This is for three reasons: -2. Access to the cache is protected by a lock to ensure thread safety +.. _freeze_in_core: -3. There is one version of the cache per interpreter (*i.e.*, the cache is thread local) +- The core object type needs to be able to freeze just-in-time + dictionaries created by its accessors when the object itself is + immutable. +- The managed buffer type needs to be immutable when the object it is + created from is immutable. +- Teardown of strongly connected components of immutable objects + (discussed further down in this section) must be hooked into + ``Py_DECREF``. -There are arguments in favor of each. Of them, (3) would -require additional class to be added (*e.g.*, via the ``immutable`` module) -which provides "interpreter local" dictionary variable that can be safely -accessed by whichever interpreter is currently calling the immutable function. -We have chosen (1) in order to provide clear feedback to the programmer that -they likely do not want to freeze a function which has a (necessarily) mutable -decorator or other object attached to it. It is likely not possible to make -all decorators work via a general mechanism, but providing some tools to -provide library authors with the means to provide a better experience for -immutable decorators is in scope for a future PEP building on this work. +As such, we implement a function which is not in the limited API (and +thus not part of the stable C ABI) called ``_PyImmutability_Freeze`` +which performs the freezing logic. This is used internally as a C Python +implementation detail, and then exposed to Python through the +``freeze(obj)`` function in the immutable module. -Deferred Ideas -============== +Atomic reference counting +========================= -Copy-on-Write -------------- +As a necessary requirement for directly sharing objects across +sub-interpreters, reference counts for immutable objects must be managed +with atomic operations. This is handled in the reference counting macro +by branching on the immutability flag, and using atomic operations only +if the bit it set. -It *may* be possible to enforce immutability through copy-on-write. -Such a system would not raise an exception on ``x.f = y`` when -``x`` points to an immutable object, but rather copy the contents -of ``x`` under the hood. Essentially, ``x.f = y`` turns into ``x = -deep_copy(x); x.f = y``. While it is nice to avoid the error, this -can also have surprising results (e.g. loss of identity of ``x``), -is less predictable (suddenly the time needed to execute ``x.f = y`` -becomes proportional to the object graph rooted in ``x``) and may -make code harder to reason about. - - -Typing ------- - -Support for immutability in the type system is worth exploring in -the future. Especially if Python adopts an ownership model that -enables reasoning about aliasing, see `Data-Race Free Python`_ -below. - -Currently in Python, ``x: Foo`` does not give very strong -guarantees about whether ``x.bar(42)`` will work or not, because -of Python's strong reflection support that permits changing a -class at run-time, or even changing the type of an object. -Making objects immutable in-place exacerbates this situation as -``x.bar(42)`` may now fail because ``x`` has been made immutable. -However, in contrast to failures due to reflective changes of -a class, a ``NotFreezableError`` will point to the place in the -code where the object was frozen. This should facilitate debugging. - -In short: the possibility of making objects immutable in-place -does not weaken type-based reasoning in Python on a fundamental -level. However, if immutability becomes very frequently used, it -may lead to the unsoundness which already exists in Python's current -typing story surfacing more frequently. As alluded to in the -future work on `Data-Race Free Python`_, this can be mitigated by -using region-based ownership. - -There are several challenges when adding immutability to a type -system for an object-oriented programming language. First, self -typing becomes more important as some methods require that self is -mutable, some require that self is immutable (e.g. to be -thread-safe), and some methods can operate on either self type. -The latter subtly needs to preserve the invariants of immutability -but also cannot rely on immutability. We would need a way of -expressing this in the type system. This could probably be done by -annotating the self type in the three different ways above -- -mutable, immutable, and works either way. - -A possibility would be to express the immutable version of a type -``T`` as the intersection type ``immutable & T`` and a type that -must preserve immutability but may not rely on it as the union -of the immutable intersection type with its mutable type -``(immutable & T) | T``. - -Furthermore, deep immutability requires some form of "view-point -adaption", which means that when ``x`` is immutable, ``x.f`` is -also immutable, regardless of the declared type of ``f``. -View-point adaptation is crucial for ensuring that immutable -objects treat themselves correctly internally and is not part of -standard type systems (but well-researched in academia). - -Making ``freeze`` a soft keyword as opposed to a function `has -been proposed -`_ -to facilitate flow typing. We believe this is an excellent -proposal to consider for the future in conjunction with work on -typing immutability. - - -Naming -====== -We propose to call deep immutability simply "immutability". This -is simple, standard, and sufficiently distinguishable from other -concepts like frozen modules. +Management of immutable objects +=============================== -We also propose to call the act of making something immutable -"freezing", and the function that does so ``freeze()``. This is -the same as used in JavaScript and Ruby and is considerably -snappier than ``make_immutable()`` which we suspect would be -immediately shortened in the community lingo. The major concern -with the freeze verb is that immutable objects risk being referred -to as "frozen" which then comes close to frozen modules (bad link) -and types like ``frozenset`` (good link). +When objects are made immutable, we remove them from the heap of their +creating interpreter. This is done by unlinking them from the GC work +list that all objects participate in. If the object ever becomes +garbage, it will be added to the interpreter with the last reference, +which will handle cleanup and finalization. -While naming is obviously important, the names we picked initially -in this PEP are not important and can be replaced. A good short -verb for the action seems reasonable. Because the term immutable -is so standard, we should think twice about replacing it with -something else. +.. _scc: -Qualifying immutability and freezing with an additional "deep" (as -proposed `here -`_) -seems like adding extra hassle for unclear gains. +Dealing with cycles in immutable object graphs +============================================== -Future Extensions +In `previous work `__, +we have identified that objects that make up cyclic immutable garbage +will always have the same lifetime. This means that a single reference +count could be used to track the lifetimes of all the objects in such a +strongly connected component (SCC). + +As part of freezing, we perform an SCC analysis that creates a +designated (atomic) reference count for every SCC created as part of +freezing the object graph. Reference count manipulations on any object +in the SCC is “forwarded” to that shared reference count. In the GIL enabled +build, this can be done without bloating objects by repurposing the +existing reference counter data to be used as a pointer to the shared counter. + +This technique permits handling cyclic garbage using plain reference +counting, and because of the single reference count for an entire SCC, +we will detect when all the objects in the SCC expire at once. + + +Weak references ================= -This PEP is the first in a series of PEPs with the goal of delivering -a Data-Race Free Python that is theoretically compatible with, but -notably not contigent on :pep:`703`. +Weak references are turned into strong references during freezing. This +is so that an immutable object cannot be effectively mutated by a weakly +referenced nested object being garbage collected. If a weak reference +loses its object during freezing, we treat this as a failure to freeze +since the program is effectively racing with the garbage collector. -This work has three different components which we intend to -package into two discrete PEPs (called A and B below): - -1. Support for identifying and freeing cyclic immutable garbage - using reference counting. (PEP A) - -2. Support for sharing immutable data across subinterpreters using - atomic reference counting of immutable objects to permit - concurrent increments and decrements on shared object RC's. (PEP A) - -3. Support for sharing mutable data across subinterpreters, with - dynamic ownership protecting against data races. (PEP B) - -Together these components deliver "Data-Race Free Python". -Note that "PEP A" has value even if "PEP B" would not materialise -for whatever reason. - - -Simplified Garbage Collection for Immutable Object Graphs ---------------------------------------------------------- - -In `previous work `_, -we have identified that objects that make up cyclic immutable -garbage will always have the same lifetime. This means that a -single reference count could be used to track the lifetimes of -all the objects in such a strongly connected component (SCC). - -We plan to extend the freeze logic with a SCC analysis that -creates a designated (atomic) reference count for the entire -SCC, such that reference count manipulations on any object in -the SCC will be "forwarded" to that shared reference count. -This can be done without bloating objects by repurposing the -existing reference counter data to be used as a pointer to -the shared counter. -This technique permits handling cyclic garbage using plain -reference counting, and because of the single reference count -for an entire SCC, we will detect when all the objects in the -SCC expire at once. +New Obligations on C Extensions +=============================== -This approach requires a second bit. Our `reference implementation`_ -already steals this bit in preparation for this extension. +As immutability support must be opted in, there are no new *obligations* +for C extensions that do not want to add support for immutability. +C modules that do want to support immutability need to do several things: +- C-types must provide the new ``tp_reachable`` function. (Most modules + will be able to reuse the existing ``tp_traverse``). See: `Traversing objects`_ +- The module object itself must me marked as freezable by setting freezable + to either ``Yes``, ``Explicit`` or ``Proxy`` +- Add write-barriers (``Py_CHECKWRITE(obj)``) that check for mutability + before they modify the state of any C-object. This is only needed for + C-objects which can be made immutable. -Support for Atomic Reference Counting -------------------------------------- +Note that the freezability also has an effect on how module state can be +accesses. A freezability of ``Yes`` and ``Explicit`` may result in multiple +sub-interpreters accessing the (frozen) module object at once. The ``Proxy`` +mode will ensure that each mutable module object is only accessed by one +interpreter at a time. -As a necessary requirement for the extension `Sharing Immutable Data Across Subinterpreters`_, -we will add support for atomic reference counting for immutable objects. This -will complement work in `Simplified Garbage Collection for Immutable Object Graphs`_, -which aims to make memory management of immutable data more efficient. +C extensions are allowed to store mutable state, this is how escape +hatches can be implemented. However, they have to ensure that all +accesses to this data is *thread-safe* and that it does not cause +a mutable object from one sub-interpreter to become accessible to +another sub-interpreter. -When immutable data is shared across threads we must ensure that -concurrent reference count manipulations are correct, which in turns -requires atomic increments and decrements. Note that since we are only -planning to share immutable objects across different GIL's, it is -*not* possible for two threads to read--write or write--write race -on a single field. Thus we only need to protect the reference counter -manipulations, avoiding most of the complexity of :pep:`703`. +Changes to the C ABI +==================== + +``Py_CHECKWRITE(obj)`` + This macro is used to check whether the argument (which must be + castable to `Py_Object *`) has its immutable bit set. If the + argument is immutable, this evaluates to ``false``. If the argument + is writeable, it evalutes to ``true``. +``Py_IsImmutable(obj)`` + This macro is used to check whether the argument has its immutable + bit set. +``PyErr_WriteToImmutable(PyObject* obj)`` + This raises an error of the form ``object of type %s is immutable``. + +These three additions to the C ABI enable C Extension implementers to +make a C extension type compatible with immutability by +adding checks to any methods or functions which mutate objects of that type. +These checks take the common form of: -Sharing Immutable Data Across Subinterpreters ---------------------------------------------- +.. code-block:: c + :caption: **Listing 22:** Example of call to ``Py_CHECKWRITE``. -We plan to extend the functionality of multiple subinterpreters in :pep:`734` -to *share* immutable data without copying. This is safe and -efficient as it avoids the copying or serialisation when -objects are transmitted across subinterpreters. + if (!Py_CHECKWRITE(op)) { // perform the check + PyErr_WriteToImmutable(op); // raise the error if the check fails + return NULL; // abort the write + } + ... // code that performs the write -This change will require reference counts to be atomic (as -discussed above) and the subclass list of a type object to -be made thread-safe. Additionally, we will need to change -the API for getting a class' subclasses in order to avoid -data races. -This change requires modules loaded in one subinterpreter to be -accessible from another. +Changes to the internal API +=========================== +In addition to these three changes to the public API, there are a few changes +made to the internal API to aid in the implementation of this PEP. Note that some +of this functionality is exposed via the `immutable` module. -Data-Race Free Python ---------------------- +``int _PyImmutability_Freeze(PyObject*)`` + This function Freezes the entire object graph it is passed as an argument. + On success, it will return ``0``. If there is an error, it will roll back the + any changes it has made and return an error code of ``-1``. This is exposed by + the ``immutable`` module as the ``freeze`` function. +``int _PyImmutability_RegisterShallowFreezable(PyTypeObject*)`` + Registers the type as being shallowly freezable. By calling this, the module indicates + that this type is already shallow immutable and no operations can change the state of the object. + Returns `0` on success, or `-1` on error. This is exposed by + the ``immutable`` module as ``register_shallow_freezable``. -While useful on their own, all the changes above are building -blocks of Data-Race Free Python. Data-Race Free Python will -borrow concepts from ownership (namely region-based ownership, -see e.g. `Cyclone `_) to make Python programs data-race free -by construction. Which will permit multiple subinterpreters to -share *mutable* state, although only one subinterpreter at a time -will be able to access (read or write) to that state. -This work is also compatible with free-theaded Python (:pep:`703`). -A description of the ownership model can be found in a paper accepted -for PLDI 2025 (an academic conference on design and implementation of -programming languages): `Dynamic Region Ownership for Concurrency -Safety `_. +Separating costs for built-in and user-defined types +==================================================== -It is important to point out that Data-Race Free Python is different -from :pep:`703`, but aims to be fully compatible with that PEP, and -we believe that both PEPs can benefit from each other. In essence -:pep:`703` focuses on making the CPython run-time resilient against -data races in Python programs: a poorly synchronized Python program -should not be able to corrupt reference counts, or other parts of -the Python interpreter. The complementary goal pursued by this PEP -is to make it impossible for Python programs to have data races. -Support for deeply immutable data is the first important step -towards this goal. +Immutability for Built-in Types +------------------------------- -The region-based ownership that we propose can be used to restrict -freezing to only be permitted on regions which are isolated. If -such a restriction is built into the system, then there will be a -guarantee that freezing objects will not turn affect references -elsewhere in the system (they cannot exist when the region is -isolated). Such a design can also be used to track immutability -better in a type system and would be able to deliver a guarantee -that a reference of a mutable type never points to an immutable -object, and conversely. These points will be unpacked and made -more clear in the PEP for the ownership model. - - - -Reference Implementation -======================== - -`Available here `_. - -There are some discrepancies between this PEP and the reference -implementation, including: - -- The ``NotFreezable`` type is currently freezable (but inheriting - from it stops instances of the inheriting class from being made immutable). +- Steal single bit in object header for the mutable / + deeply immutable flag (*e.g.*, from the refcount) +- Ensure that all types which are made deeply immutable + satisfy the invariants necessary for sharing. Any data + inside these types must be deeply immutable or managed as + laid out in the escape hatches. +- RC manipulating macros are updated with a branch for + deeply immutable objects where RC manipulations use + atomic operations. +- Deeply immutable objects are removed from the cycle + detector when they get frozen. + +Immutability for User-Defined Types +----------------------------------- + +- Steal one more bit in object header needed to + distinguishing between RC and a pointer to object in the SCC + that holds the common RC for the entire SCC. +- The freeze function (which must be implemented in core + Python for the reasons outlined :ref:`here `). +- All freezable Python objects must have calls to + ``Py_CHECKWRITE`` inserted on all paths to mutation to + be able to stop attempts at mutating deeply immutable + objects. This requires changes in ~150 places in core + Python. In particular, dictionaries, lists, and sets + are updated to perform ``Py_CHECKWRITE`` calls in the + appropriate places. +- Add additional synchronisation for updating the code + objects of function objects due to optimisations in the + interpreter. (Such synchronisation is already in place + in free-threaded Python.) +- Make weak references freezable. + + +Performance of immutability +########################### + +Below we share some *preliminary* numbers on performance based on +our current prototype. Note that we have not worked on optimisation +yet, our focus has been on correctness. + + +Effect on existing programs +=========================== + +To understand the impact of immutability on *existing* Python code +that does not use it, we compared the time it takes to run the +full CPython test suite with the time it takes to run it with our +changes on-top of it. Because of some intermittent tests failing +on the CPython baseline, these tests were performed with our +changes rebased on-top of CPython 3.14 (sha ``754e7c9b``). The +test suite contained 1109 Python files containing a total of +627917 LOC. While performance of test code is not +necessarily indicative of performance of production code, the +breadth and volume of the code gives a good indication of how +successfull we are in meeting our goal. On average over 10 runs on +a single core to reduce jitter we found that our patch runs the +tests 1.7% slower on average, which we consider a strong result +given that we have added a write-barrier and not yet optimised any +of our code. The Baseline finished in 334.6s +-0.89s; our +build in 340.6s +-1.09s. Our build ran all the passing +tests of the baseline, supressing one error due to missing +documentation. + + +Freezing vs. Picking and Unpickling +=================================== + +To understand the performance of the freeze function in our +prototype (which has yet to see any optimisation work), we +compared the time required to successfully freeze data structures +(lists, trees, dictionaries) against the time require to pickle +and unpickle the same data structures. + +Our benchmark generates 1000000 strings with eight characters and +inserts them into the respective data structures. We have two +tests for dictionaries, both using random strings as keys, with +one mapping to integers (dict-int) and the other mapping to +user-defined student objects with a name and age field +(dict-student). We then measured the time to freeze, pickle and +unpickle the data structures over 10 runs. + +The results in Table 1 show that freezing is faster than both +pickling and unpickling except for when freezing the built-in +tuple data structure. However, freezing a tuple is faster than +pickling and unpickling a tuple. + +.. figure:: pep-0795/table.png + + **Table 1:** Comparing the performance of freezing to + pickling and unpickling. F=Freezing; P=Pickling; U=Unpicking. + The fastest result is marked green. + + +Impact on freezing on communication +=================================== + +To demonstrate sharing across sub-interpreters, and what kinds of +performance can be expected when using direct object sharing in +comparison with pickling, we built a small benchmark that +constructs (per worker) 200000 4x4 matrices of random values, +implemented as a user-defined Matrix class. A producer-interpreter +shares lists of matrices with consumer-interpreters that process +them and return how many of the matrices were invertible back to +the producer. Thus, this benchmark mixes local compute with +communication. Our goal is to reduce the overhead of communication +by eliminating pickling. Thus, if communication takes C% of the +time, we should expect less than C% improvement for the entire +benchmark. Note that we do not time freezing itself since the +''return on investment'' in freezing will be dependent on object +lifetimes. + +Communication between sub-interpreters is done via a Python C +extension we authored which exposes Erlang-like send and receive +functions, which allow selective receive on a lockless message +queue. The Pickled line shows the throughput of Python 3.15 when +matrices are not frozen, in which case the data must be pickled to +be sent, and unpickled upon delivery. The line marked Immutable +represents the same operation but with a frozen Matrix class and +frozen Matrix instances. The code run on the consumer-interpreters +is visible in Figure 1. At the peak 32 sub-interpreter mark, +freezing is roughly 4 times faster than pickling. This +demonstrates that data-race free, direct sharing of immutable +objects has the potential to improve Python's performance. + +.. figure:: pep-0795/scaling.png + + **Figure 10:** (Repeat of Figure 1 to avoid scrolling.) + Effect on performance from direct + sharing of immutable objects. This plot shows the scaling + properties of sub-interpreters using immutability for user + classes vs pickling. Mean values over ten trials are shown. + One standard deviation is depicted as a vertical line. The + throughput of a single process for the task is shown for + comparison. + + +Rejected alternatives +##################### + +The proposed approach is not the only possible way to add +immutability to Python. In this section we discuss some +alternatives that were considered but ultimately rejected. + +The primary reason for rejecting these alternatives is that they either do +not make sufficient guarantees about immutability to protect the sub-interpreters +use case, or that they impose too high a cost on performance. + + +Immutable objects have different types +====================================== + +This PEP proposes to make objects immutable in-place. An alternative +approach would be to create a new type for the immutable version of +each mutable type. This is epitomised by the existing ``frozenset``, +which is an immutable version of ``set``. + +This approach has several disadvantages: + +- It requires duplicating much of the code for each type, leading + to code bloat and maintenance issues. +- It requires copying the entire object graph to create an immutable + version of an object, which can be expensive both in time and + memory. +- It requires programmers to change the types they use when they + want immutability, leading to code changes and potential + compatibility issues. + +It also has some advantages: + +- It can lead to better performance for immutable objects, as + the implementation can be optimized for immutability. (Implementation could detect + dynamic immutability and change the type in-place, but this adds complexity.) +- It can lead to clearer semantics, as the type of an object clearly + indicates whether it is mutable or immutable. + +We feel that the disadvantages outweigh the advantages, and that +making objects immutable in-place is the better approach for Python. + +The concept of the state of the type already exists in Python for example, +a file cannot be read from or written to when it is closed. Thus, +making an object immutable in-place can be viewed as consistent with existing +Python mental model. There are also many places where an API takes a container +but is not expected to mutate the contents of that container. + +We rejected this alternative if favour of the proposed approach due to the performance +benefits of in-place immutability, and the reduced complexity of not requiring +an additional set of types. + +Deep copy +========= +Another alternative would be to use a deep copy approach to create +immutable copies of objects. This would involve creating a new object +graph that is a deep copy of the original, but with all objects marked +as immutable. This similar to the previous, but would not require the creation of a +separate type for each mutable type. -Rebasing on Python 3.14 -======================= +This has the advantage of not affecting any existing aliases to an object. +However, it still has the performance overheads of copying the entire object graph. -We have found two areas that need to be addressed to integrate this work with "free-threaded Python": data-representation and data-races during freeze. +We rejected this alternative due to the performance overheads of copying. -Data-representation for immutability ------------------------------------- -With free-threaded Python the representation of the reference -count has been changed. We could either borrow a bit to represent -if an object is immutable, or alternatively, we could use the new -``ob_tid`` field to have a special value for immutable state. Using -``ob_tid`` would allow for standard mutable thread local objects to -remain the fast path, and is our preferred alternative. +``__freeze__`` method on objects +================================ -The extensions use use SCC calculations to detect cycles in -immutable graphs, would require additional state. Repurposing -``ob_tid`` and ``ob_ref_shared`` would allow sufficient space for the -necessary calculation. +We could expose a ``__freeze__`` method on objects that would be called +to freeze the object. This would allow objects to implement their own +freezing logic, and could potentially allow for more efficient freezing +of certain types. This would allow for custom types to define how they should be frozen. +However, this approach has several disadvantages: -Data-races during freeze ------------------------- +- It would not provide a mechanism to safely share objects across + sub-interpreters. This proposal alters reference counting and garbage collection + to ensure that immutable objects can be safely shared across sub-interpreters. +- It would require all types to implement their own freezing logic, + leading to code bloat and maintenance issues. +- It would make it harder to reason about the immutability of objects, + as the freezing logic could vary between types. +- It could lead to inconsistencies in the immutability guarantees + provided by different types. -We consider the following races +We rejected this alternative due to the lack of guarantees about +immutability across sub-interpreters, and the increased complexity +of requiring all types to implement their own freezing logic. -- Freezing some objects concurrently with another thread checking if a graph is immutable. +Our proposal provides the pre-freeze hook that allows types to customize +the freezing process without losing the guarantees about immutability +across sub-interpreters. -- Freezing some objects concurrently with another thread mutating those objects. -- Freezing some objects concurrently with another thread freezing those objects. +Proxies for sharing between sub-interpreters +============================================ -To address the first race, we need to consider strictness of deep -immutability. We need to ensure that querying an object graph for -immutability only says yes if it is deeply immutable. This -requires a two step immutable state: immutable but not strict, and -then immutable and strict. On a DFS traversal of the object graph -items are marked as immutable but not strict on the pre-order -step, and then immutable and strict on the post-order step. To -query if a graph is immutable, we will require the "immutable and -strict" state. +Another alternative would be to use proxies to share objects between +sub-interpreters. This would involve creating a proxy object in each +sub-interpreter that forwards operations to the original object in its +own sub-interpreter. This approach has several disadvantages: -Handling mutation during freeze can use the mutex added by -free-threading. There are some cases where mutation does not -require the acquisition of a mutex, which would no longer allowed -with this feature. Freezing would be required to lock the object, -marks it as immutable, release the lock, and then read all its -fields. +- It would introduce significant overhead for accessing shared + objects, as each operation would need to be forwarded through + the proxy. +- For complex object graphs, each individual object would need to be + proxied, leading to significant overhead and allocations of proxies. +- It would complicate the semantics of object identity, as two + proxies for the same object may not be the same object. -The final case is the most complex detecting parallel freezing of -an object graph. We will consider this an error. This error can be -detected as follows. If we encounter an object that is "immutable -but not strict", then this should be on the path to the current -object from the starting point of the freeze. If this is not the -case, then we must be observing another thread freezing an object -graph. The algorithm should back out the pending aspects of -freeze, and raise an exception to the user. This can naturally be -integrated with the SCC algorithm. +For contained mutable objects, proxies could provide an additional mechanism +for sharing state between sub-interpreters. +We rejected this alternative as not part of this PEP, but see it as a +possible future extension to provide additional mutable sharing mechanisms +between sub-interpreters. -References -========== -* :pep:`703` Making the Global Interpreter Lock Optional in CPython +Future extensions and considerations +#################################### + +Notes on hashing +================ + +Deep immutability opens up the possibility of any freezable object being +hashable, due to the fixed state of the object graph making it possible +to compute stable hash values over the graph as is the case with tuple +and frozenset . However, there are several complications (listed below) +which should be kept in mind for any future PEPs which build on this +work at add hashability for immutable objects: -* :pep:`351` The freeze protocol +Instance versus type hashability +---------------------------------- -* :pep:`734` Multiple Interpreters in the Stdlib +At the moment, the test for hashability is based upon the presence (or +absence) of a ``__hash__`` method and an ``__eq__`` method. Places where +``PyObject_HashNotImplemented`` is currently used would need to be +modified as appropriate to have a contextual logic which provides a +default implementation that uses ``id()`` if the object instance is +immutable, and throws a type error if not. -* :pep:`683` Immortal Objects, Using a Fixed Refcount +This causes issues with type checks, however. The check of +``isinstance(x, Hashable)`` would need to become contextual, and +``issubclass(type(x), Hashable)`` would become underdetermined for many +types. Handling this in a way that is not surprising will require +careful design considerations. -.. rubric:: Footnotes +Equality of immutable objects +------------------------------- -.. [#RC] Note that the same logic does not apply to e.g. an - object's reference count. The reference count is - metadata about an object that is stored in the object - for purely pragmatic reasons, but this data really - belongs to the memory management logic of the - interpreter, not the object itself. +One consideration with the naive approach (i.e., hash via id()) is that +it can result in confusing outcomes. For example, if there were to be +two lists: -Copyright -========= +.. code-block:: python + + a = [1, 2, 3, 4] + b = [1, 2, 3, 4] + assert(hash(a) == hash(b)) + +There would be a reasonable expectation that this assertion would be +true, as it is for two identically defined tuples. However, without a +careful implementation of ``__hash__`` and ``__eq__`` this would not be +the case. Our opinion is that an approach like that used in tuplehash is +recommended in order to avoid this behavior. + + +Types +====== + +Support for immutability in the type system is worth exploring in the +future. + +Currently, in Python, ``x: Foo`` does not give very strong guarantees +about whether ``x.bar(42)`` will work or not, because of Python’s strong +reflection support that permits changing a class at run-time, or even +changing the type of an object. Making objects immutable in-place +exacerbates this situation as ``x.bar(42)`` may now fail because ``x`` +has been made immutable. However, in contrast to failures due to +reflective changes of a class, a ``NotFreezableError`` will point to the +place in the code where the object was made immutable. This should facilitate +debugging. + +It is possible that there are aliases of an object that is being +frozen. Thus the type change will lead to exceptions if those +aliases are accessed in a mutating way. This is the same as the +current situation in Python where an object may be mutated in +unexpected ways that can affect the objects type. + +Making freeze a soft keyword as opposed to a function has been proposed +to facilitate flow typing. We believe this is an excellent proposal to +consider for the future in conjunction with work on typing immutability. + + +Data-race free Python +====================== -This document is placed in the public domain or under the -CC0-1.0-Universal license, whichever is more permissive. +This PEP adds support for immutable objects to Python and importantly +permits sub-interpreters to directly share *immutable* objects. As a +future PEP will we propose an extension that also permits directly +sharing *mutable* objects. We refer to this proposal as “data-race free +Python” or “DRF Python” for short. In that future proposal, mutable +objects will only be accessible to one sub-interpreter at a time, but +can be passed around and shared by reference. We believe that making +Python data-race free is the right programming model for the langauge, +and aim to be compatible with both sub-interpreters and free-threaded +Python. + +DRF Python will borrow concepts from ownership (namely region-based +ownership, see e.g. `Cyclone `__) to +make Python programs data-race free by construction. A description of +the ownership model that we envision can be found in our PLDI 2025: +`Dynamic Region Ownership for Concurrency +Safety `__. + +It is important to point out that data-race free Python is different +from free-threaded Python, but aims to be fully compatible with it, and +we believe that they can benefit from each other. In essence +free-threaded Python focuses on making the CPython run-time resilient +against data races in Python programs: a poorly synchronized Python +program should not be able to corrupt reference counts, or other parts +of the Python interpreter. The complementary goal pursued by DRF Python +is to make it impossible for Python programs to have data races. Support +for deeply immutable data can be seen as the first step towards this +goal. + + +Reference implementation +######################## + +Our `reference implementation`_, which we have made publicly available on +Github, implements all of the features described above. +We steal a bit from the top of the reference count in the object header. In 64-bit +python this comes from the (currently unused) top word and thus has no impact at +all on the runtime. In 32-bit python, the second bit of the word is used (since negative +reference counts are used as necessary error conditions. The core functionality +for immutability is provided in an (internal) ``immutability.h`` header and +additional ``immutability.c`` file, though the C ABI macros and error function are +defined in the appropriate public headers. + +**FIXME** Update to right branch! + +.. _reference implementation: https://github.com/mjp41/cpython/tree/immutable-main + +Making various types in the core and the standard library freezable (and adding/augmenting +tests) make up the majority of the other changes. We also expose the immutability +functionality as the ``immutable`` module, which includes the ``NotFreezable`` type, the +``freeze`` method, the ``register_freezable`` method, and the ``isfrozen`` method. Notably, we +do not at this moment provide the decorators (*e.g.*, ``@frozen``) at present, though +they are trivial to implement using the existing tools and functionality. + +Open questions to resolve before publishing +############################################ + +- Do we cover C extensions enough? +- Do we need a separate discussion about backwards compatibility? +- We currently do not discuss builtins +- We should discuss locks being morally immutable +- What about libraries like math, random etc.? +- Meta classes, ABCMeta in particular +- Need an example that shows sharing across sub-interpreters + +Feedback to address +==================== +- Use tp_traverse to traverse, or add a new type operation that + is required for freezable types? diff --git a/peps/pep-0795/diagram_1.mmd b/peps/pep-0795/diagram_1.mmd new file mode 100644 index 00000000000..b732f5ecf21 --- /dev/null +++ b/peps/pep-0795/diagram_1.mmd @@ -0,0 +1,24 @@ + + graph LR + subgraph Sub 1 + A[A] + D[D] + end + + subgraph Sub 2 + B[B] + end + + C:::imm + + A ----> C + B ----> C + C ----> D + A -. GIL 1 .-> C + B -. GIL 2 .-> C + C -. GIL 1 .-> D + C -. GIL 2 .-> D + + classDef imm fill:#ADD8E6,stroke:#003366,stroke-width:1px,stroke-dasharray: 4 2,color:#003366; + linkStyle 4,6 stroke:#f00,stroke-width:2px,color:blue; + linkStyle 3,5 stroke:#90f,stroke-width:2px,color:blue; diff --git a/peps/pep-0795/diagram_1.svg b/peps/pep-0795/diagram_1.svg new file mode 100644 index 00000000000..34ee8a3d983 --- /dev/null +++ b/peps/pep-0795/diagram_1.svg @@ -0,0 +1 @@ +

    Sub 2

    Sub 1

    GIL 1

    GIL 2

    GIL 1

    GIL 2

    A

    D

    B

    C

     \ No newline at end of file diff --git a/peps/pep-0795/diagram_10.mmd b/peps/pep-0795/diagram_10.mmd new file mode 100644 index 00000000000..c57e799bff8 --- /dev/null +++ b/peps/pep-0795/diagram_10.mmd @@ -0,0 +1,29 @@ + + graph LR + subgraph Sub 1 + A[A] + end + + subgraph Sub 2 + B[B] + end + + C[Cell]:::imm + D[Shared field]:::fake_imm + E[2]:::imm + + A ----> C + B ----> C + C ----> D + D ----> E + A -. GIL 1 .-> C + C -. GIL 1 .-> D + D -. GIL 1 .-> E + B -. GIL 2 .-> C + C -. GIL 2 .-> D + D -. GIL 2 .-> E + + classDef imm fill:#ADD8E6,stroke:#003366,stroke-width:1px,stroke-dasharray: 4 2,color:#003366; + classDef fake_imm fill:#aaa,stroke:#000,stroke-width:1px; + linkStyle 4,5,6 stroke:#f00,stroke-width:2px,color:blue; + linkStyle 7,8,9 stroke:#90f,stroke-width:2px,color:blue; diff --git a/peps/pep-0795/diagram_10.svg b/peps/pep-0795/diagram_10.svg new file mode 100644 index 00000000000..c8b2f4b0372 --- /dev/null +++ b/peps/pep-0795/diagram_10.svg @@ -0,0 +1 @@ +

    Sub 2

    Sub 1

    GIL 1

    GIL 1

    GIL 1

    GIL 2

    GIL 2

    GIL 2

    A

    B

    Cell

    Shared field

    2

     \ No newline at end of file diff --git a/peps/pep-0795/diagram_11.mmd b/peps/pep-0795/diagram_11.mmd new file mode 100644 index 00000000000..42be3936385 --- /dev/null +++ b/peps/pep-0795/diagram_11.mmd @@ -0,0 +1,33 @@ + + graph LR + subgraph Sub 1 + A[A] + D1[interpreter-local storage] + E[E] + end + + subgraph Sub 2 + B[B] + D2[interpreter-local storage] + F[F] + end + + C[Prime factoriser]:::imm + + A ----> C + B ----> C + C ----> D1 + C ----> D2 + D1 ----> E + D2 ----> F + A -. GIL 1 .-> C + C -. GIL 1 .-> D1 + D1 -. GIL 1 .-> E + B -. GIL 2 .-> C + C -. GIL 2 .-> D2 + D2 -. GIL 2 .-> F + + classDef imm fill:#ADD8E6,stroke:#003366,stroke-width:1px,stroke-dasharray: 4 2,color:#003366; + classDef fake_imm fill:#aaa,stroke:#000,stroke-width:1px; + linkStyle 6,7,8 stroke:#f00,stroke-width:2px,color:blue; + linkStyle 9,10,11 stroke:#90f,stroke-width:2px,color:blue; diff --git a/peps/pep-0795/diagram_11.svg b/peps/pep-0795/diagram_11.svg new file mode 100644 index 00000000000..7845df9816b --- /dev/null +++ b/peps/pep-0795/diagram_11.svg @@ -0,0 +1 @@ +

    Sub 2

    Sub 1

    GIL 1

    GIL 1

    GIL 1

    GIL 2

    GIL 2

    GIL 2

    A

    interpreter-local storage

    E

    B

    interpreter-local storage

    F

    Prime factoriser

     \ No newline at end of file diff --git a/peps/pep-0795/diagram_12.mmd b/peps/pep-0795/diagram_12.mmd new file mode 100644 index 00000000000..e3ce712f695 --- /dev/null +++ b/peps/pep-0795/diagram_12.mmd @@ -0,0 +1,50 @@ + + graph + subgraph Module1 + A[Type1] + B[Func1] + X[Var1] + subgraph Module2 + C[Type2] + D[Func2] + Y[Var2] + end + end + + subgraph Module3 + E[Type3] + EE[Type4] + Z[Var3] + F[Func3] + end + + subgraph Program + O1 + O2 + x + y + m3 + m1 + end + + A -- calls --> B + B -- uses --> C + B -- imports --> Module2 + B -- reads --> X + B -- writes --> X + C -- calls --> D + C -- writes --> Y + + E -- reads --> Z + F -- writes --> Z + + F -- imports --> Module2 + + EE -- extends --> E + + O1 -- \_\_class__ --> EE + O2 -- \_\_class__ --> A + x --> O1 + y --> O2 + m1 -- imports --> Module1 + m3 -- imports --> Module3 diff --git a/peps/pep-0795/diagram_12.svg b/peps/pep-0795/diagram_12.svg new file mode 100644 index 00000000000..81a4348f763 --- /dev/null +++ b/peps/pep-0795/diagram_12.svg @@ -0,0 +1 @@ +

    Program

    Module3

    Module1

    Module2

    calls

    uses

    reads

    writes

    calls

    writes

    reads

    writes

    extends

    __class__

    __class__

    imports

    imports

    imports

    imports

    Type1

    Func1

    Var1

    Type2

    Func2

    Var2

    Type3

    Type4

    Var3

    Func3

    O1

    O2

    x

    y

    m3

    m1

     \ No newline at end of file diff --git a/peps/pep-0795/diagram_2.mmd b/peps/pep-0795/diagram_2.mmd new file mode 100644 index 00000000000..7007d756273 --- /dev/null +++ b/peps/pep-0795/diagram_2.mmd @@ -0,0 +1,19 @@ + + graph LR + subgraph Sub 1 + A[A] + end + + subgraph Sub 2 + B[B] + end + + C:::imm + D:::imm + + A ----> C + B ----> C + C -- \_\_class__ --> D + + classDef imm fill:#ADD8E6,stroke:#003366,stroke-width:1px,stroke-dasharray: 4 2,color:#003366; + linkStyle 2 stroke:#00f,stroke-width:2px,color:blue; diff --git a/peps/pep-0795/diagram_2.svg b/peps/pep-0795/diagram_2.svg new file mode 100644 index 00000000000..ea72930e6dd --- /dev/null +++ b/peps/pep-0795/diagram_2.svg @@ -0,0 +1 @@ +

    Sub 2

    Sub 1

    __class__

    A

    B

    C

    D

     \ No newline at end of file diff --git a/peps/pep-0795/diagram_3.mmd b/peps/pep-0795/diagram_3.mmd new file mode 100644 index 00000000000..5ecdc912904 --- /dev/null +++ b/peps/pep-0795/diagram_3.mmd @@ -0,0 +1,8 @@ + + graph LR; + O[Stack frame]-- x -->A + A-- f -->B + A-- g -->B + B-- h -->A + B-- j -->C + O-- y -->C diff --git a/peps/pep-0795/diagram_3.svg b/peps/pep-0795/diagram_3.svg new file mode 100644 index 00000000000..67031fc103c --- /dev/null +++ b/peps/pep-0795/diagram_3.svg @@ -0,0 +1 @@ +

    x

    f

    g

    h

    j

    y

    Stack frame

    A

    B

    C

     \ No newline at end of file diff --git a/peps/pep-0795/diagram_4.mmd b/peps/pep-0795/diagram_4.mmd new file mode 100644 index 00000000000..021529c23e5 --- /dev/null +++ b/peps/pep-0795/diagram_4.mmd @@ -0,0 +1,14 @@ + + graph TD; + A[Stack frame]-- d -->B[DieInstance] + B-- sides -->12:::imm + B-- \_\_class__ -->C[Die]:::imm + C-- \_\_class__ -->D[type]:::imm + C-- \_\_bases__-->T[tuple]:::imm + T--> E[object]:::imm + E-- \_\_class__ -->F[type]:::imm + C-- \_\_init__ -->G[Function object]:::imm + C-- set_sides -->H[Function object]:::imm + C-- roll -->I[Function object]:::imm + classDef imm fill:#ADD8E6,stroke:#003366,stroke-width:1px,stroke-dasharray: 4 2,color:#003366; + linkStyle 3,4,5,6,7,8,9 stroke:#00f,stroke-width:2px,color:blue; diff --git a/peps/pep-0795/diagram_4.svg b/peps/pep-0795/diagram_4.svg new file mode 100644 index 00000000000..6f470e7f677 --- /dev/null +++ b/peps/pep-0795/diagram_4.svg @@ -0,0 +1 @@ +

    d

    sides

    __class__

    __class__

    __bases__

    __class__

    __init__

    set_sides

    roll

    12

    Stack frame

    DieInstance

    Die

    type

    tuple

    object

    type

    Function object

    Function object

    Function object

     \ No newline at end of file diff --git a/peps/pep-0795/diagram_4a.svg b/peps/pep-0795/diagram_4a.svg new file mode 100644 index 00000000000..76323e759c7 --- /dev/null +++ b/peps/pep-0795/diagram_4a.svg @@ -0,0 +1,102 @@ +

    d

    sides

    __class__

    __class__

    __bases__

    __class__

    __init__

    set_sides

    roll

    12

    Stack frame

    Die instance

    Die

    type

    tuple

    object

    type

    Function object

    Function object

    Function object

     \ No newline at end of file diff --git a/peps/pep-0795/diagram_4b.svg b/peps/pep-0795/diagram_4b.svg new file mode 100644 index 00000000000..0e88f434766 --- /dev/null +++ b/peps/pep-0795/diagram_4b.svg @@ -0,0 +1,102 @@ +

    d

    sides

    __class__

    __class__

    __bases__

    __class__

    __init__

    set_sides

    roll

    12

    Stack frame

    Die instance

    Die

    type

    tuple

    object

    type

    Function object

    Function object

    Function object

     \ No newline at end of file diff --git a/peps/pep-0795/diagram_4c.svg b/peps/pep-0795/diagram_4c.svg new file mode 100644 index 00000000000..0dbc097d2ad --- /dev/null +++ b/peps/pep-0795/diagram_4c.svg @@ -0,0 +1,102 @@ +

    d

    sides

    __class__

    __class__

    __bases__

    __class__

    __init__

    set_sides

    roll

    12

    Stack frame

    Die instance

    Die

    type

    tuple

    object

    type

    Function object

    Function object

    Function object

     \ No newline at end of file diff --git a/peps/pep-0795/diagram_5.mmd b/peps/pep-0795/diagram_5.mmd new file mode 100644 index 00000000000..6d53f888c00 --- /dev/null +++ b/peps/pep-0795/diagram_5.mmd @@ -0,0 +1,14 @@ + + graph TD; + A[Stack frame]-- d -->B[DieInstance]:::imm + B-- sides -->12:::imm + B-- \_\_class__ -->C[Die]:::imm + C-- \_\_class__ -->D[type]:::imm + C-- \_\_bases__-->T[tuple]:::imm + T--> E[object]:::imm + E-- \_\_class__ -->F[type]:::imm + C-- \_\_init__ -->G[Function object]:::imm + C-- set_sides -->H[Function object]:::imm + C-- roll -->I[Function object]:::imm + classDef imm fill:#ADD8E6,stroke:#003366,stroke-width:1px,stroke-dasharray: 4 2,color:#003366; + linkStyle 1,2,3,4,5,6,7,8,9 stroke:#00f,stroke-width:2px,color:blue; diff --git a/peps/pep-0795/diagram_5.svg b/peps/pep-0795/diagram_5.svg new file mode 100644 index 00000000000..f5a8d9d901e --- /dev/null +++ b/peps/pep-0795/diagram_5.svg @@ -0,0 +1 @@ +

    d

    sides

    __class__

    __class__

    __bases__

    __class__

    __init__

    set_sides

    roll

    12

    Stack frame

    DieInstance

    Die

    type

    tuple

    object

    type

    Function object

    Function object

    Function object

     \ No newline at end of file diff --git a/peps/pep-0795/diagram_6.mmd b/peps/pep-0795/diagram_6.mmd new file mode 100644 index 00000000000..b4a7b950810 --- /dev/null +++ b/peps/pep-0795/diagram_6.mmd @@ -0,0 +1,9 @@ + + graph TD; + A[Stack frame]-- f1 -->B[FractionInstance1] + B-- n -->1:::imm + B-- d -->3:::imm + A-- f2 -->D[FractionInstance2] + D-- n -->2:::imm + D-- d -->7:::imm + classDef imm fill:#ADD8E6,stroke:#003366,stroke-width:1px,stroke-dasharray: 4 2,color:#003366; diff --git a/peps/pep-0795/diagram_6.svg b/peps/pep-0795/diagram_6.svg new file mode 100644 index 00000000000..47207abed71 --- /dev/null +++ b/peps/pep-0795/diagram_6.svg @@ -0,0 +1 @@ +

    f1

    n

    d

    f2

    n

    d

    1

    2

    3

    7

    Stack frame

    FractionInstance1

    FractionInstance2

     \ No newline at end of file diff --git a/peps/pep-0795/diagram_7.mmd b/peps/pep-0795/diagram_7.mmd new file mode 100644 index 00000000000..4ee0d898c85 --- /dev/null +++ b/peps/pep-0795/diagram_7.mmd @@ -0,0 +1,10 @@ + + graph TD; + A[Stack frame]-- f1 -->B[FractionInstance1]:::imm + B-- n -->1:::imm + B-- d -->3:::imm + A-- f2 -->D[FractionInstance2] + D-- n -->2:::imm + D-- d -->7:::imm + classDef imm fill:#ADD8E6,stroke:#003366,stroke-width:1px,stroke-dasharray: 4 2,color:#003366; + linkStyle 1,2 stroke:#00f,stroke-width:2px,color:blue; diff --git a/peps/pep-0795/diagram_7.svg b/peps/pep-0795/diagram_7.svg new file mode 100644 index 00000000000..0c03185acbe --- /dev/null +++ b/peps/pep-0795/diagram_7.svg @@ -0,0 +1 @@ +

    f1

    n

    d

    f2

    n

    d

    1

    2

    3

    7

    Stack frame

    FractionInstance1

    FractionInstance2

     \ No newline at end of file diff --git a/peps/pep-0795/diagram_8.mmd b/peps/pep-0795/diagram_8.mmd new file mode 100644 index 00000000000..0c37b9087ad --- /dev/null +++ b/peps/pep-0795/diagram_8.mmd @@ -0,0 +1,44 @@ +flowchart TD + A["Stack frame"] -- f1 --> B["Fraction instance 1"] + A -- f2 --> D["Fraction instance 2"] + B -- \_\_class__ --> E["Fraction"] + B -- n --> 1["1"] + B -- d --> 3["3"] + D -- n --> 2["2"] + D -- d --> 7["7"] + D -- \_\_class__ --> E + 1 -- \_\_class__ --> int["int"] + 3 -- \_\_class__ --> int + 2 -- \_\_class__ --> int + 7 -- \_\_class__ --> int + int -- \_\_class__ --> type["type"] + E -- \_\_init__ --> AA["Function 3"] + E -- \_\_add__ --> BB["Function 4"] + E -- \_\_repr__ --> CC["Function 5"] + E -- \_\_class__ --> type + A -- utils --> DD["utils module"] + AA -- utils --> DD + BB -- Fraction --> E + int -- superclass --> O["object"] + E -- superclass --> O + O -- \_\_class__ --> type + DD -- gcd --> XX["Function 1"] + + 1:::imm + 3:::imm + 2:::imm + 7:::imm + int:::imm + type:::imm + type:::imm + type:::imm + O:::imm + + classDef imm fill:#ADD8E6,stroke:#003366,stroke-width:1px,stroke-dasharray: 4 2,color:#003366 + linkStyle 8 stroke:#00f,stroke-width:2px,color:blue,fill:none + linkStyle 9 stroke:#00f,stroke-width:2px,color:blue,fill:none + linkStyle 10 stroke:#00f,stroke-width:2px,color:blue,fill:none + linkStyle 11 stroke:#00f,stroke-width:2px,color:blue,fill:none + linkStyle 12 stroke:#00f,stroke-width:2px,color:blue,fill:none + linkStyle 20 stroke:#00f,stroke-width:2px,color:blue,fill:none + linkStyle 22 stroke:#00f,stroke-width:2px,color:blue,fill:none diff --git a/peps/pep-0795/diagram_8.svg b/peps/pep-0795/diagram_8.svg new file mode 100644 index 00000000000..f102599ce8a --- /dev/null +++ b/peps/pep-0795/diagram_8.svg @@ -0,0 +1 @@ +

    f1

    f2

    __class__

    n

    d

    n

    d

    __class__

    __class__

    __class__

    __class__

    __class__

    __class__

    __init__

    __add__

    __repr__

    __class__

    utils

    utils

    Fraction

    superclass

    superclass

    __class__

    gcd

    1

    2

    3

    7

    Stack frame

    Fraction instance 1

    Fraction instance 2

    Fraction

    int

    type

    Function 3

    Function 4

    Function 5

    utils module

    object

    Function 1

     \ No newline at end of file diff --git a/peps/pep-0795/diagram_9.mmd b/peps/pep-0795/diagram_9.mmd new file mode 100644 index 00000000000..12954a814fb --- /dev/null +++ b/peps/pep-0795/diagram_9.mmd @@ -0,0 +1,59 @@ +flowchart TD + A["Stack frame"] -- f1 --> B["Fraction instance 1"] + A -- f2 --> D["Fraction instance 2"] + B -- \_\_class__ --> E["Fraction"] + B -- n --> 1["1"] + B -- d --> 3["3"] + D -- n --> 2["2"] + D -- d --> 7["7"] + D -- \_\_class__ --> E + 1 -- \_\_class__ --> int["int"] + 3 -- \_\_class__ --> int + 2 -- \_\_class__ --> int + 7 -- \_\_class__ --> int + int -- \_\_class__ --> type["type"] + E -- \_\_init__ --> AA["Function 3"] + E -- \_\_add__ --> BB["Function 4"] + E -- \_\_repr__ --> CC["Function 5"] + E -- \_\_class__ --> type + A -- utils --> DD["utils module"] + AA -- gcd --> DD + BB -- Fraction --> E + int -- superclass --> O["object"] + E -- superclass --> O + O -- \_\_class__ --> type + DD -- gcd --> XX["Function 1"] + + B:::imm + 1:::imm + 3:::imm + 2:::imm + 7:::imm + E:::imm + int:::imm + type:::imm + AA:::imm + BB:::imm + CC:::imm + DD:::imm + O:::imm + XX:::imm + classDef imm fill:#ADD8E6,stroke:#003366,stroke-width:1px,stroke-dasharray: 4 2,color:#003366 + linkStyle 4 stroke:#00f,stroke-width:2px,color:blue,fill:none + linkStyle 5 stroke:#00f,stroke-width:2px,color:blue,fill:none + linkStyle 6 stroke:#00f,stroke-width:2px,color:blue,fill:none + linkStyle 8 stroke:#00f,stroke-width:2px,color:blue,fill:none + linkStyle 9 stroke:#00f,stroke-width:2px,color:blue,fill:none + linkStyle 10 stroke:#00f,stroke-width:2px,color:blue,fill:none + linkStyle 11 stroke:#00f,stroke-width:2px,color:blue,fill:none + linkStyle 12 stroke:#00f,stroke-width:2px,color:blue,fill:none + linkStyle 13 stroke:#00f,stroke-width:2px,color:blue,fill:none + linkStyle 14 stroke:#00f,stroke-width:2px,color:blue,fill:none + linkStyle 15 stroke:#00f,stroke-width:2px,color:blue,fill:none + linkStyle 16 stroke:#00f,stroke-width:2px,color:blue,fill:none + linkStyle 18 stroke:#00f,stroke-width:2px,color:blue,fill:none + linkStyle 19 stroke:#00f,stroke-width:2px,color:blue,fill:none + linkStyle 20 stroke:#00f,stroke-width:2px,color:blue,fill:none + linkStyle 21 stroke:#00f,stroke-width:2px,color:blue,fill:none + linkStyle 22 stroke:#00f,stroke-width:2px,color:blue,fill:none + linkStyle 23 stroke:#00f,stroke-width:2px,color:blue,fill:none diff --git a/peps/pep-0795/diagram_9.svg b/peps/pep-0795/diagram_9.svg new file mode 100644 index 00000000000..731713f95c1 --- /dev/null +++ b/peps/pep-0795/diagram_9.svg @@ -0,0 +1 @@ +

    f1

    f2

    __class__

    n

    d

    n

    d

    __class__

    __class__

    __class__

    __class__

    __class__

    __class__

    __init__

    __add__

    __repr__

    __class__

    utils

    gcd

    Fraction

    superclass

    superclass

    __class__

    gcd

    1

    2

    3

    7

    Stack frame

    Fraction instance 1

    Fraction instance 2

    Fraction

    int

    type

    Function 3

    Function 4

    Function 5

    utils module

    object

    Function 1

     \ No newline at end of file diff --git a/peps/pep-0795/scaling.png b/peps/pep-0795/scaling.png new file mode 100644 index 0000000000000000000000000000000000000000..7bdb33662fc32f97e036a7a34790f465b6e66cea GIT binary patch literal 62551 zcmd43WmHvL_%{j)2q*}GpoFA=w6F=0PLT$sOS+^%Lg`Kc>247a5D{tV?vNB|kZ$Sw zY|s0DKioU+mwU$@&0ZeIumg%U+tT;zqzN|hU&?@%uW%L%s(}{vH zDUI}RRzeM}2C*_V&YP3&g$E;A+a7u^dCBNtxNvy+b&3)H_YwsM=f4*S#D6~r2LAgg zEO!0B7yt7HuK7l!ix!MOjQpIaFF;~+W; zGp1@`tTlq0`;TKanvf>$vuJqD&B?i7%e$JEl$6xf^}Hw1_$(ad-Xj!yJh*|9Y+et2 z8A4Y2Qj=3s$jHcyp7PlIsx=?Z(;j}s7#m{Eo7xu?@aXN=#ryZ}jn}zXb}vP5e^qBT zDSwh`Atfofs6yR4Nwhd}{rdIn?Cg#H>S{jU#*DW?&2#$wRDSOd*MI&T8(ZEg8N4Rv zK34YRmk{!EamF(nhm`us$;pe0i@RE7=?FNpytK1RN=h;_sTM|`M;{D`-R^WcsWo4{ zm3BH(pduh3u+jhR+c(4Zh({EAi!ln5o6aYT{Y8@6BuCH2%Ia=)tPJX&alC=X_rRUXUJB4R$PL3ZQM}FhW#OA=;^c*~2M2_U&ogS=Z zOGSPfwcDPfp`o!yO~rwUS`8RpYkB(azw<`6KX4CwbT@4!-F>SnDTyRiUQJt@8MA3; zXQ#yTVtqJYf$hWl=R~2cqC7(*5uu@FWskXqw;QfJ@_ykzC5!0m>qD=~DoUGNvd6)} zc{DE9pYo*qJKc}Hl%r7mFhZ1p0sY{CpFd5@Clb6a|1Lx>rNiCp>gqZ@J%xec;^3qT zxN{$umiyB?aRcXj&H>TFa^FZ`_bqbl5&G=A4R0&&Tu=nl7q&TaGl@Y~I! zRlI)VB>)jv;iL`+9p@MJLt?gjZ%=V{NYi=rkM zQw1_5LZPz_&cJ37QdJd|{cxMN3-xDPp&lnPG!yuupLJ^5sy|eC<7Ex6DZ3lJ!f&1ka$ZwIG?9#cQEZh| zk5@3P^2SCHXBC6l38UoRQ*B)jTiYF&$@I5-STp68KRA>}zIr`$#d-CMPEiz9s5rG))lXR95nsG-Fcr_V#)U3+s-rIWo>>%hIV} zzs5wnX63l*&raW$a4g_zN)p}{B>9C;<9@_~L7ep52v!qaeyhQ&R3eAIni*^7YGKMB zxM5qJBg;D}Vv?kZzjKU>LwI&McoALXqz-wx=i!FrQ)6R!(P1Ox<<*^hsrw4O!N zjjuQ&?k=MU$jtM69I?K3zqSFDJzZGLS0YmT@8ssu2xC-Xinx(Ti|az>&VFKEfa>31 z<@fmB!j!+ZAIA)?nXL*_4opuMP1E!DE6BlvkIQZh8C;K z%gdLS9{I!4+iPEIr$5I8Wit3jjw>kH*pv*f!R^2wTM8OeUNjDq%$~8njdsmj_{W-~ zq~$uHn=&g=!IFo80W}`xIFzdXPt$JC`&n&-$i*dlW+%~Zytvd#4tgJZtZ-m?W2s(l zf27l56*H4;__H*{qm_|?&c0XNM)s`>=Q@jVO=hU#a%=MW!`79YDwTUJGM;8b@D7iK zMVsr?BxL*5S$dB;+!LHg-em>3{7u}K#4qVzn(g}h`7?~2&(^wfYR&QJ=xE6N{f7Yg zIlA`+XQWVYP-p|EHX};aclc+=#w53Af)nHuwSV)nraer){Md2Ko=Q$|GPS~NZWhx? z_$n-_CR<#qVNvMM>({Rb15$$Y3XHhEp1-ReGz;4zbG;apzqXOj!`1B2gBoiYFYZ?~ zE#GfPR)bcRq-3VcmoKj>Rz4V3+F6E2CY#M**0Rw%=Muxc-12OoIauf<#>L?E4_4_+wU0yVLm9(fB=LAVx{;y)Mo<>H{KPYfB6jFl z`^MA$UA8{!^LA>|{Ts}3I4tq__@5YlxlWYC`{W0no6~CGuv|HXy(v1kdzgijI5e

    Xl@aXNr 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

    2mf8u7y7$y_FN43WuT)v^;uN( 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 literal 0 HcmV?d00001 diff --git a/peps/pep-0795/table.png b/peps/pep-0795/table.png new file mode 100644 index 0000000000000000000000000000000000000000..a426d27ca92c53cdcb39591ae4634f1dc9c87e4c GIT binary patch literal 61111 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 xTUySJiH_G4-#Jh)h!rZm!~ Date: Fri, 19 Dec 2025 12:22:31 +0100 Subject: [PATCH 6/8] Fixing linting complaints --- peps/pep-0795.rst | 16 ++++++---------- peps/pep-0795/diagram_1.mmd | 1 - peps/pep-0795/diagram_10.mmd | 1 - peps/pep-0795/diagram_11.mmd | 1 - peps/pep-0795/diagram_12.mmd | 5 ++--- peps/pep-0795/diagram_2.mmd | 1 - peps/pep-0795/diagram_3.mmd | 1 - peps/pep-0795/diagram_4.mmd | 1 - peps/pep-0795/diagram_5.mmd | 1 - peps/pep-0795/diagram_6.mmd | 1 - peps/pep-0795/diagram_7.mmd | 1 - 11 files changed, 8 insertions(+), 22 deletions(-) diff --git a/peps/pep-0795.rst b/peps/pep-0795.rst index d779d9345a6..7fd09888f17 100644 --- a/peps/pep-0795.rst +++ b/peps/pep-0795.rst @@ -2,14 +2,12 @@ PEP: 795 Title: Deep Immutability for Efficient Sharing and Concurrency Safety Author: Matthew Johnson , Matthew Parkinson , Sylvan Clebsch , Fridtjof Stoldt , Tobias Wrigstad Sponsor: Michael Droettboom -Discussions-To: TBD +Discussions-To: Pending Status: Draft Type: Standards Track -Content-Type: text/x-rst Created: 19-Jun-2025 Python-Version: 3.15 Post-History: -Resolution: Abstract @@ -220,7 +218,7 @@ to immutability. In summary: 1. **Part 1: Inherently Immutable Objects**. Objects and types which are `de-facto immutable`_ in Python 3.14 are immutable according to this PEP. Examples include tuples that only - contain immutable objects, strings, numbers, booleans, and `None`. + contain immutable objects, strings, numbers, booleans, and ``None``. More information on current Python immutability can be found in the `data model documentation`_. 2. **Part 2: Supporting User-Defined Types**. @@ -850,12 +848,10 @@ Some modules may support multiple sub-interpreters but not freezing the module state. This PEP introduces an alternative to freezing modules which supports these cases by turning the modules into proxy objects that import the module on demand -very similar to the one behaviour proposed by `PEP 810`_ for +very similar to the one behaviour proposed by :pep:`810` for lazy imports. This behaviour is enabled by calling ``set_freezable(module, Proxy)`` on the module in question. -.. _PEP 810: https://peps.python.org/pep-0810/ - Before showing how ``set_freezable(module, Proxy)`` works, let's first look at what could happen if the random module with its state would be frozen without any internal changes to support this: @@ -1879,7 +1875,7 @@ Changes to the C ABI ``Py_CHECKWRITE(obj)`` This macro is used to check whether the argument (which must be - castable to `Py_Object *`) has its immutable bit set. If the + castable to ``Py_Object *``) has its immutable bit set. If the argument is immutable, this evaluates to ``false``. If the argument is writeable, it evalutes to ``true``. ``Py_IsImmutable(obj)`` @@ -1908,7 +1904,7 @@ Changes to the internal API In addition to these three changes to the public API, there are a few changes made to the internal API to aid in the implementation of this PEP. Note that some -of this functionality is exposed via the `immutable` module. +of this functionality is exposed via the ``immutable`` module. ``int _PyImmutability_Freeze(PyObject*)`` This function Freezes the entire object graph it is passed as an argument. @@ -1918,7 +1914,7 @@ of this functionality is exposed via the `immutable` module. ``int _PyImmutability_RegisterShallowFreezable(PyTypeObject*)`` Registers the type as being shallowly freezable. By calling this, the module indicates that this type is already shallow immutable and no operations can change the state of the object. - Returns `0` on success, or `-1` on error. This is exposed by + Returns ``0`` on success, or ``-1`` on error. This is exposed by the ``immutable`` module as ``register_shallow_freezable``. diff --git a/peps/pep-0795/diagram_1.mmd b/peps/pep-0795/diagram_1.mmd index b732f5ecf21..babba81f9ae 100644 --- a/peps/pep-0795/diagram_1.mmd +++ b/peps/pep-0795/diagram_1.mmd @@ -1,4 +1,3 @@ - graph LR subgraph Sub 1 A[A] diff --git a/peps/pep-0795/diagram_10.mmd b/peps/pep-0795/diagram_10.mmd index c57e799bff8..3becb4e5e48 100644 --- a/peps/pep-0795/diagram_10.mmd +++ b/peps/pep-0795/diagram_10.mmd @@ -1,4 +1,3 @@ - graph LR subgraph Sub 1 A[A] diff --git a/peps/pep-0795/diagram_11.mmd b/peps/pep-0795/diagram_11.mmd index 42be3936385..0ebe11ee4d3 100644 --- a/peps/pep-0795/diagram_11.mmd +++ b/peps/pep-0795/diagram_11.mmd @@ -1,4 +1,3 @@ - graph LR subgraph Sub 1 A[A] diff --git a/peps/pep-0795/diagram_12.mmd b/peps/pep-0795/diagram_12.mmd index e3ce712f695..2cc40b37354 100644 --- a/peps/pep-0795/diagram_12.mmd +++ b/peps/pep-0795/diagram_12.mmd @@ -1,4 +1,3 @@ - graph subgraph Module1 A[Type1] @@ -37,11 +36,11 @@ E -- reads --> Z F -- writes --> Z - + F -- imports --> Module2 EE -- extends --> E - + O1 -- \_\_class__ --> EE O2 -- \_\_class__ --> A x --> O1 diff --git a/peps/pep-0795/diagram_2.mmd b/peps/pep-0795/diagram_2.mmd index 7007d756273..8b7af3b7539 100644 --- a/peps/pep-0795/diagram_2.mmd +++ b/peps/pep-0795/diagram_2.mmd @@ -1,4 +1,3 @@ - graph LR subgraph Sub 1 A[A] diff --git a/peps/pep-0795/diagram_3.mmd b/peps/pep-0795/diagram_3.mmd index 5ecdc912904..c1d9e348145 100644 --- a/peps/pep-0795/diagram_3.mmd +++ b/peps/pep-0795/diagram_3.mmd @@ -1,4 +1,3 @@ - graph LR; O[Stack frame]-- x -->A A-- f -->B diff --git a/peps/pep-0795/diagram_4.mmd b/peps/pep-0795/diagram_4.mmd index 021529c23e5..5945827ba81 100644 --- a/peps/pep-0795/diagram_4.mmd +++ b/peps/pep-0795/diagram_4.mmd @@ -1,4 +1,3 @@ - graph TD; A[Stack frame]-- d -->B[DieInstance] B-- sides -->12:::imm diff --git a/peps/pep-0795/diagram_5.mmd b/peps/pep-0795/diagram_5.mmd index 6d53f888c00..5ebc6ad1415 100644 --- a/peps/pep-0795/diagram_5.mmd +++ b/peps/pep-0795/diagram_5.mmd @@ -1,4 +1,3 @@ - graph TD; A[Stack frame]-- d -->B[DieInstance]:::imm B-- sides -->12:::imm diff --git a/peps/pep-0795/diagram_6.mmd b/peps/pep-0795/diagram_6.mmd index b4a7b950810..7faec2d81c5 100644 --- a/peps/pep-0795/diagram_6.mmd +++ b/peps/pep-0795/diagram_6.mmd @@ -1,4 +1,3 @@ - graph TD; A[Stack frame]-- f1 -->B[FractionInstance1] B-- n -->1:::imm diff --git a/peps/pep-0795/diagram_7.mmd b/peps/pep-0795/diagram_7.mmd index 4ee0d898c85..fdb795d3362 100644 --- a/peps/pep-0795/diagram_7.mmd +++ b/peps/pep-0795/diagram_7.mmd @@ -1,4 +1,3 @@ - graph TD; A[Stack frame]-- f1 -->B[FractionInstance1]:::imm B-- n -->1:::imm From d9e77b91c90a81ce2574eb74bd04008d7d884c20 Mon Sep 17 00:00:00 2001 From: Tobias Wrigstad Date: Fri, 19 Dec 2025 12:30:56 +0100 Subject: [PATCH 7/8] Fixing broken PEP reference --- peps/pep-0795.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/peps/pep-0795.rst b/peps/pep-0795.rst index 7fd09888f17..38e90f930d9 100644 --- a/peps/pep-0795.rst +++ b/peps/pep-0795.rst @@ -891,7 +891,7 @@ sub-interpreter. Thus, the proxy mode logically turns the ``roll()`` function from **Listing 10** into the ``roll()`` function from **Listing 9** that moved the import statement into the function. In this way -it is basically the same as the behaviour from `PEP 810`_ for +it is basically the same as the behaviour from :pep:`810` for lazy imports. The proxy mode will work by installing a pre-freeze hook on the module From 88d5fdc7589fdee4152ddab4c13a1ee592a29fa9 Mon Sep 17 00:00:00 2001 From: Tobias Wrigstad Date: Fri, 19 Dec 2025 12:41:01 +0100 Subject: [PATCH 8/8] Added newlines to svg files --- peps/pep-0795/diagram_1.svg | 2 +- peps/pep-0795/diagram_10.svg | 2 +- peps/pep-0795/diagram_11.svg | 2 +- peps/pep-0795/diagram_12.svg | 2 +- peps/pep-0795/diagram_2.svg | 2 +- peps/pep-0795/diagram_3.svg | 2 +- peps/pep-0795/diagram_4.svg | 2 +- peps/pep-0795/diagram_4a.svg | 2 +- peps/pep-0795/diagram_4b.svg | 2 +- peps/pep-0795/diagram_4c.svg | 2 +- peps/pep-0795/diagram_5.svg | 2 +- peps/pep-0795/diagram_6.svg | 2 +- peps/pep-0795/diagram_7.svg | 2 +- peps/pep-0795/diagram_8.svg | 2 +- peps/pep-0795/diagram_9.svg | 2 +- 15 files changed, 15 insertions(+), 15 deletions(-) diff --git a/peps/pep-0795/diagram_1.svg b/peps/pep-0795/diagram_1.svg index 34ee8a3d983..891c4c99459 100644 --- a/peps/pep-0795/diagram_1.svg +++ b/peps/pep-0795/diagram_1.svg @@ -1 +1 @@ -

    Sub 2

    Sub 1

    GIL 1

    GIL 2

    GIL 1

    GIL 2

    A

    D

    B

    C

     \ No newline at end of file +

    Sub 2

    Sub 1

    GIL 1

    GIL 2

    GIL 1

    GIL 2

    A

    D

    B

    C

     diff --git a/peps/pep-0795/diagram_10.svg b/peps/pep-0795/diagram_10.svg index c8b2f4b0372..6ed10f3bd43 100644 --- a/peps/pep-0795/diagram_10.svg +++ b/peps/pep-0795/diagram_10.svg @@ -1 +1 @@ -

    Sub 2

    Sub 1

    GIL 1

    GIL 1

    GIL 1

    GIL 2

    GIL 2

    GIL 2

    A

    B

    Cell

    Shared field

    2

     \ No newline at end of file +

    Sub 2

    Sub 1

    GIL 1

    GIL 1

    GIL 1

    GIL 2

    GIL 2

    GIL 2

    A

    B

    Cell

    Shared field

    2

     diff --git a/peps/pep-0795/diagram_11.svg b/peps/pep-0795/diagram_11.svg index 7845df9816b..d27c8006d25 100644 --- a/peps/pep-0795/diagram_11.svg +++ b/peps/pep-0795/diagram_11.svg @@ -1 +1 @@ -

    Sub 2

    Sub 1

    GIL 1

    GIL 1

    GIL 1

    GIL 2

    GIL 2

    GIL 2

    A

    interpreter-local storage

    E

    B

    interpreter-local storage

    F

    Prime factoriser

     \ No newline at end of file +

    Sub 2

    Sub 1

    GIL 1

    GIL 1

    GIL 1

    GIL 2

    GIL 2

    GIL 2

    A

    interpreter-local storage

    E

    B

    interpreter-local storage

    F

    Prime factoriser

     diff --git a/peps/pep-0795/diagram_12.svg b/peps/pep-0795/diagram_12.svg index 81a4348f763..af78333ce33 100644 --- a/peps/pep-0795/diagram_12.svg +++ b/peps/pep-0795/diagram_12.svg @@ -1 +1 @@ -

    Program

    Module3

    Module1

    Module2

    calls

    uses

    reads

    writes

    calls

    writes

    reads

    writes

    extends

    __class__

    __class__

    imports

    imports

    imports

    imports

    Type1

    Func1

    Var1

    Type2

    Func2

    Var2

    Type3

    Type4

    Var3

    Func3

    O1

    O2

    x

    y

    m3

    m1

     \ No newline at end of file +

    Program

    Module3

    Module1

    Module2

    calls

    uses

    reads

    writes

    calls

    writes

    reads

    writes

    extends

    __class__

    __class__

    imports

    imports

    imports

    imports

    Type1

    Func1

    Var1

    Type2

    Func2

    Var2

    Type3

    Type4

    Var3

    Func3

    O1

    O2

    x

    y

    m3

    m1

     diff --git a/peps/pep-0795/diagram_2.svg b/peps/pep-0795/diagram_2.svg index ea72930e6dd..06b231fc5d5 100644 --- a/peps/pep-0795/diagram_2.svg +++ b/peps/pep-0795/diagram_2.svg @@ -1 +1 @@ -

    Sub 2

    Sub 1

    __class__

    A

    B

    C

    D

     \ No newline at end of file +

    Sub 2

    Sub 1

    __class__

    A

    B

    C

    D

     diff --git a/peps/pep-0795/diagram_3.svg b/peps/pep-0795/diagram_3.svg index 67031fc103c..23cedce2754 100644 --- a/peps/pep-0795/diagram_3.svg +++ b/peps/pep-0795/diagram_3.svg @@ -1 +1 @@ -

    x

    f

    g

    h

    j

    y

    Stack frame

    A

    B

    C

     \ No newline at end of file +

    x

    f

    g

    h

    j

    y

    Stack frame

    A

    B

    C

     diff --git a/peps/pep-0795/diagram_4.svg b/peps/pep-0795/diagram_4.svg index 6f470e7f677..49cf24da17d 100644 --- a/peps/pep-0795/diagram_4.svg +++ b/peps/pep-0795/diagram_4.svg @@ -1 +1 @@ -

    d

    sides

    __class__

    __class__

    __bases__

    __class__

    __init__

    set_sides

    roll

    12

    Stack frame

    DieInstance

    Die

    type

    tuple

    object

    type

    Function object

    Function object

    Function object

     \ No newline at end of file +

    d

    sides

    __class__

    __class__

    __bases__

    __class__

    __init__

    set_sides

    roll

    12

    Stack frame

    DieInstance

    Die

    type

    tuple

    object

    type

    Function object

    Function object

    Function object

     diff --git a/peps/pep-0795/diagram_4a.svg b/peps/pep-0795/diagram_4a.svg index 76323e759c7..a5d0e794c0d 100644 --- a/peps/pep-0795/diagram_4a.svg +++ b/peps/pep-0795/diagram_4a.svg @@ -99,4 +99,4 @@ OTHER DEALINGS IN THE FONT SOFTWARE. font-weight: 300 1000; src: url("data:font/woff2;base64,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") format('woff2-variations'); unicode-range: U+0000-00FF,U+0131,U+0152-0153,U+02BB-02BC,U+02C6,U+02DA,U+02DC,U+0304,U+0308,U+0329,U+2000-206F,U+20AC,U+2122,U+2191,U+2193,U+2212,U+2215,U+FEFF,U+FFFD; -}

    d

    sides

    __class__

    __class__

    __bases__

    __class__

    __init__

    set_sides

    roll

    12

    Stack frame

    Die instance

    Die

    type

    tuple

    object

    type

    Function object

    Function object

    Function object

     \ No newline at end of file +}

    d

    sides

    __class__

    __class__

    __bases__

    __class__

    __init__

    set_sides

    roll

    12

    Stack frame

    Die instance

    Die

    type

    tuple

    object

    type

    Function object

    Function object

    Function object

     diff --git a/peps/pep-0795/diagram_4b.svg b/peps/pep-0795/diagram_4b.svg index 0e88f434766..3101a3569d8 100644 --- a/peps/pep-0795/diagram_4b.svg +++ b/peps/pep-0795/diagram_4b.svg @@ -99,4 +99,4 @@ OTHER DEALINGS IN THE FONT SOFTWARE. font-weight: 300 1000; src: url("data:font/woff2;base64,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") format('woff2-variations'); unicode-range: U+0000-00FF,U+0131,U+0152-0153,U+02BB-02BC,U+02C6,U+02DA,U+02DC,U+0304,U+0308,U+0329,U+2000-206F,U+20AC,U+2122,U+2191,U+2193,U+2212,U+2215,U+FEFF,U+FFFD; -}

    d

    sides

    __class__

    __class__

    __bases__

    __class__

    __init__

    set_sides

    roll

    12

    Stack frame

    Die instance

    Die

    type

    tuple

    object

    type

    Function object

    Function object

    Function object

     \ No newline at end of file +}

    d

    sides

    __class__

    __class__

    __bases__

    __class__

    __init__

    set_sides

    roll

    12

    Stack frame

    Die instance

    Die

    type

    tuple

    object

    type

    Function object

    Function object

    Function object

     diff --git a/peps/pep-0795/diagram_4c.svg b/peps/pep-0795/diagram_4c.svg index 0dbc097d2ad..18f69dce46d 100644 --- a/peps/pep-0795/diagram_4c.svg +++ b/peps/pep-0795/diagram_4c.svg @@ -99,4 +99,4 @@ OTHER DEALINGS IN THE FONT SOFTWARE. font-weight: 300 1000; src: url("data:font/woff2;base64,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") format('woff2-variations'); unicode-range: U+0000-00FF,U+0131,U+0152-0153,U+02BB-02BC,U+02C6,U+02DA,U+02DC,U+0304,U+0308,U+0329,U+2000-206F,U+20AC,U+2122,U+2191,U+2193,U+2212,U+2215,U+FEFF,U+FFFD; -}

    d

    sides

    __class__

    __class__

    __bases__

    __class__

    __init__

    set_sides

    roll

    12

    Stack frame

    Die instance

    Die

    type

    tuple

    object

    type

    Function object

    Function object

    Function object

     \ No newline at end of file +}

    d

    sides

    __class__

    __class__

    __bases__

    __class__

    __init__

    set_sides

    roll

    12

    Stack frame

    Die instance

    Die

    type

    tuple

    object

    type

    Function object

    Function object

    Function object

     diff --git a/peps/pep-0795/diagram_5.svg b/peps/pep-0795/diagram_5.svg index f5a8d9d901e..20c93b74d78 100644 --- a/peps/pep-0795/diagram_5.svg +++ b/peps/pep-0795/diagram_5.svg @@ -1 +1 @@ -

    d

    sides

    __class__

    __class__

    __bases__

    __class__

    __init__

    set_sides

    roll

    12

    Stack frame

    DieInstance

    Die

    type

    tuple

    object

    type

    Function object

    Function object

    Function object

     \ No newline at end of file +

    d

    sides

    __class__

    __class__

    __bases__

    __class__

    __init__

    set_sides

    roll

    12

    Stack frame

    DieInstance

    Die

    type

    tuple

    object

    type

    Function object

    Function object

    Function object

     diff --git a/peps/pep-0795/diagram_6.svg b/peps/pep-0795/diagram_6.svg index 47207abed71..d38a930823b 100644 --- a/peps/pep-0795/diagram_6.svg +++ b/peps/pep-0795/diagram_6.svg @@ -1 +1 @@ -

    f1

    n

    d

    f2

    n

    d

    1

    2

    3

    7

    Stack frame

    FractionInstance1

    FractionInstance2

     \ No newline at end of file +

    f1

    n

    d

    f2

    n

    d

    1

    2

    3

    7

    Stack frame

    FractionInstance1

    FractionInstance2

     diff --git a/peps/pep-0795/diagram_7.svg b/peps/pep-0795/diagram_7.svg index 0c03185acbe..9ae95da3c96 100644 --- a/peps/pep-0795/diagram_7.svg +++ b/peps/pep-0795/diagram_7.svg @@ -1 +1 @@ -

    f1

    n

    d

    f2

    n

    d

    1

    2

    3

    7

    Stack frame

    FractionInstance1

    FractionInstance2

     \ No newline at end of file +

    f1

    n

    d

    f2

    n

    d

    1

    2

    3

    7

    Stack frame

    FractionInstance1

    FractionInstance2

     diff --git a/peps/pep-0795/diagram_8.svg b/peps/pep-0795/diagram_8.svg index f102599ce8a..7281385122f 100644 --- a/peps/pep-0795/diagram_8.svg +++ b/peps/pep-0795/diagram_8.svg @@ -1 +1 @@ -

    f1

    f2

    __class__

    n

    d

    n

    d

    __class__

    __class__

    __class__

    __class__

    __class__

    __class__

    __init__

    __add__

    __repr__

    __class__

    utils

    utils

    Fraction

    superclass

    superclass

    __class__

    gcd

    1

    2

    3

    7

    Stack frame

    Fraction instance 1

    Fraction instance 2

    Fraction

    int

    type

    Function 3

    Function 4

    Function 5

    utils module

    object

    Function 1

     \ No newline at end of file +

    f1

    f2

    __class__

    n

    d

    n

    d

    __class__

    __class__

    __class__

    __class__

    __class__

    __class__

    __init__

    __add__

    __repr__

    __class__

    utils

    utils

    Fraction

    superclass

    superclass

    __class__

    gcd

    1

    2

    3

    7

    Stack frame

    Fraction instance 1

    Fraction instance 2

    Fraction

    int

    type

    Function 3

    Function 4

    Function 5

    utils module

    object

    Function 1

     diff --git a/peps/pep-0795/diagram_9.svg b/peps/pep-0795/diagram_9.svg index 731713f95c1..1510e8af040 100644 --- a/peps/pep-0795/diagram_9.svg +++ b/peps/pep-0795/diagram_9.svg @@ -1 +1 @@ -

    f1

    f2

    __class__

    n

    d

    n

    d

    __class__

    __class__

    __class__

    __class__

    __class__

    __class__

    __init__

    __add__

    __repr__

    __class__

    utils

    gcd

    Fraction

    superclass

    superclass

    __class__

    gcd

    1

    2

    3

    7

    Stack frame

    Fraction instance 1

    Fraction instance 2

    Fraction

    int

    type

    Function 3

    Function 4

    Function 5

    utils module

    object

    Function 1

     \ No newline at end of file +

    f1

    f2

    __class__

    n

    d

    n

    d

    __class__

    __class__

    __class__

    __class__

    __class__

    __class__

    __init__

    __add__

    __repr__

    __class__

    utils

    gcd

    Fraction

    superclass

    superclass

    __class__

    gcd

    1

    2

    3

    7

    Stack frame

    Fraction instance 1

    Fraction instance 2

    Fraction

    int

    type

    Function 3

    Function 4

    Function 5

    utils module

    object

    Function 1