Update patch documentation

Summary:
We have various things in our patches which add new API surface but it's not documented: https://github.com/facebookincubator/cinder/actions/runs/27316517505/job/80698211733

This is just some claude generated documentation.

Reviewed By: alexmalyshev

Differential Revision: D108635749

fbshipit-source-id: 72ed3150a4b8d59c65fd947fbb086858945af010

Author: DinoV

Doc/c-api/dict.rst

@@ -386,6 +386,47 @@ Dictionary Objects
       :term:`strong reference <strong reference>` (for example, using
       :c:func:`Py_NewRef`).
 
+.. c:function:: int PyDict_NextWithError(PyObject *p, Py_ssize_t *ppos, PyObject **pkey, PyObject **pvalue)
+
+   Similar to :c:func:`PyDict_Next`, but any :ref:`lazy import <lazy-imports>`
+   placeholder values encountered during iteration are resolved (by performing
+   the deferred import) before being returned through *pvalue*.  Because
+   resolving a lazy import can execute arbitrary code and fail, this function
+   may set an exception and return false even when the iteration has not yet
+   completed.  After the loop ends, call :c:func:`PyErr_Occurred` to
+   distinguish normal completion from an error.
+
+   .. note::
+
+      This function is specific to Meta's Python build and is only available
+      when lazy imports support is compiled in.
+
+.. c:function:: Py_ssize_t PyDict_ResolveLazyImports(PyObject *p)
+
+   Resolve every :ref:`lazy import <lazy-imports>` placeholder currently stored
+   in the dictionary *p*, performing the deferred imports so that the dictionary
+   no longer contains any unresolved lazy values.  Return the number of values
+   that were resolved, or ``-1`` with an exception set if resolving one of them
+   failed.
+
+   .. note::
+
+      This function is specific to Meta's Python build and is only available
+      when lazy imports support is compiled in.
+
+.. c:function:: int PyDict_IsLazyImport(PyObject *p, PyObject *name)
+
+   Return ``1`` if the value stored under *name* in dictionary *p* is an
+   unresolved :ref:`lazy import <lazy-imports>` placeholder, ``0`` if it is a
+   regular (already resolved) value or is not present, and ``-1`` with an
+   exception set on error.  Unlike a normal lookup, this does not trigger
+   resolution of the lazy import.
+
+   .. note::
+
+      This function is specific to Meta's Python build and is only available
+      when lazy imports support is compiled in.
+
 .. c:function:: int PyDict_Merge(PyObject *a, PyObject *b, int override)
 
    Iterate over mapping object *b* adding key-value pairs to dictionary *a*.

Doc/c-api/exceptions.rst

@@ -1218,6 +1218,17 @@ Exception types
 .. versionadded:: 3.11
    :c:data:`PyExc_BaseExceptionGroup`.
 
+.. c:var:: PyObject *PyExc_ImportCycleError
+
+   A subclass of :c:data:`PyExc_ImportError` raised when resolving a
+   :ref:`lazy import <lazy-imports>` would require importing a module that is
+   already in the process of being imported, i.e. an import cycle is detected.
+
+   .. note::
+
+      This exception is specific to Meta's Python build and is only available
+      when lazy imports support is compiled in.
+
 
 OSError aliases
 ---------------

Doc/c-api/import.rst

@@ -353,3 +353,51 @@ Importing Modules
    strings instead of Python :class:`str` objects.
 
    .. versionadded:: 3.14
+
+
+.. c:function:: PyObject* PyImport_CreateModuleFromInitfunc(PyObject *spec, PyObject* (*initfunc)(void))
+
+   Initialize an extension module directly from a module *spec* and its
+   initialization function *initfunc*, returning a new reference to the
+   resulting module object, or ``NULL`` with an exception set on failure.
+
+   Custom importers can use this to initialize statically linked extension
+   modules without registering them in the table of built-in modules (see
+   :c:func:`PyImport_ExtendInittab`).  *initfunc* is the module's
+   ``PyInit_<name>`` function and *spec* is the
+   :class:`~importlib.machinery.ModuleSpec` describing the module.
+
+
+.. _lazy-imports:
+
+Lazy imports
+------------
+
+The following APIs are specific to Meta's Python build.  When *lazy imports*
+are enabled, the work of importing a module is deferred until the imported
+name is first used: an import binds a lightweight placeholder object in the
+namespace, and the real import is performed on first lookup of that name.
+
+.. c:function:: PyObject* PyImport_SetLazyImports(PyObject *enabled, PyObject *excluding, PyObject *eager)
+
+   Configure lazy imports for the running interpreter.  *enabled* is a truth
+   value controlling whether lazy imports are turned on.  *excluding*, if not
+   ``NULL``, is a container of module names that should never be imported
+   lazily, and *eager*, if not ``NULL``, is a container of module names that
+   should always be imported eagerly.  Return a value reflecting the previous
+   configuration, or ``NULL`` with an exception set on failure.
+
+.. c:function:: int PyImport_IsLazyImportsEnabled(void)
+
+   Return a nonzero value if lazy imports are currently enabled for the running
+   interpreter, and ``0`` otherwise.
+
+.. c:var:: PyTypeObject PyLazyImport_Type
+
+   The type object for lazy import placeholder objects, the objects that stand
+   in for a not-yet-performed import until the imported name is first used.
+
+.. c:macro:: PyLazyImport_CheckExact(op)
+
+   Return non-zero if *op* is exactly a lazy import placeholder object (that is,
+   its type is :c:data:`PyLazyImport_Type`); this function always succeeds.

Doc/c-api/veryhigh.rst

@@ -343,6 +343,13 @@ the same library that the Python runtime is using.
       :py:mod:`!ast` Python module, which exports these constants under
       the same names.
 
+   .. c:macro:: PyCF_DISABLE_LAZY_IMPORTS
+
+      Compile the code with :ref:`lazy imports <lazy-imports>` disabled, so that
+      every ``import`` statement in the compiled code is performed eagerly even
+      when lazy imports are otherwise enabled.  This flag is specific to Meta's
+      Python build.
+
    The "``PyCF``" flags above can be combined with "``CO_FUTURE``" flags such
    as :c:macro:`CO_FUTURE_ANNOTATIONS` to enable features normally
    selectable using :ref:`future statements <future>`.

Tools/check-c-api-docs/ignored_c_api.txt

@@ -75,6 +75,7 @@ PyException_HEAD
 # cpython/pyframe.h
 PyUnstable_EXECUTABLE_KINDS
 PyUnstable_EXECUTABLE_KIND_BUILTIN_FUNCTION
+PyUnstable_EXECUTABLE_KIND_JIT
 PyUnstable_EXECUTABLE_KIND_METHOD_DESCRIPTOR
 PyUnstable_EXECUTABLE_KIND_PY_FUNCTION
 PyUnstable_EXECUTABLE_KIND_SKIP