What is a frozen Python module?

The answer is in the same place:

(Frozen modules are modules written in Python whose compiled byte-code object is incorporated into a custom-built Python interpreter by Python’s freeze utility. See Tools/freeze/ for now.)

http://docs.python.org/library/imp.html#imp.PY_FROZEN links to http://docs.python.org/library/imp.html#imp.init_frozen which explains it:

Frozen modules are modules written in Python whose compiled byte-code object is incorporated into a custom-built Python interpreter by Python’s freeze utility. See Tools/freeze/ for now.

Have you considered using cx_freeze to create frozen modules? cx_freeze was recently updated and it supports Python 3.7 to 3.11.

• cx_freeze documentation
• cx_freeze Github

This Stack Overflow question: Errors while dynamic imports using importlib in python3 discusses how to use importlib and sys.metapath.

This article is mentioned in one of the answers to the question.

Concerning importlib:

It contains a class for importing and using frozen modules

class importlib.machinery.FrozenImporter

class FrozenImporter:

    """Meta path import for frozen modules.

    All methods are either class or static methods to avoid the need to
    instantiate the class.

    """

    _ORIGIN = "frozen"

    @staticmethod
    def module_repr(m):
        """Return repr for the module.

        The method is deprecated.  The import machinery does the job itself.

        """
        return '<module {!r} ({})>'.format(m.__name__, FrozenImporter._ORIGIN)

    @classmethod
    def find_spec(cls, fullname, path=None, target=None):
        if _imp.is_frozen(fullname):
            return spec_from_loader(fullname, cls, origin=cls._ORIGIN)
        else:
            return None

    @classmethod
    def find_module(cls, fullname, path=None):
        """Find a frozen module.

        This method is deprecated.  Use find_spec() instead.

        """
        return cls if _imp.is_frozen(fullname) else None

    @classmethod
    def create_module(cls, spec):
        """Use default semantics for module creation."""

    @staticmethod
    def exec_module(module):
        name = module.__spec__.name
        if not _imp.is_frozen(name):
            raise ImportError('{!r} is not a frozen module'.format(name),
                              name=name)
        code = _call_with_frames_removed(_imp.get_frozen_object, name)
        exec(code, module.__dict__)

    @classmethod
    def load_module(cls, fullname):
        """Load a frozen module.

        This method is deprecated.  Use exec_module() instead.

        """
        return _load_module_shim(cls, fullname)

    @classmethod
    @_requires_frozen
    def get_code(cls, fullname):
        """Return the code object for the frozen module."""
        return _imp.get_frozen_object(fullname)

    @classmethod
    @_requires_frozen
    def get_source(cls, fullname):
        """Return None as frozen modules do not have source code."""
        return None

    @classmethod
    @_requires_frozen
    def is_package(cls, fullname):
        """Return True if the frozen module is a package."""
        return _imp.is_frozen_package(fullname)

A frozen module in Python is a Python module that has been converted into a byte-compiled code (compiled to bytecode) and then embedded directly into the Python interpreter. It allows distributing a single binary that contains both the Python interpreter and the byte-compiled modules, making it more efficient and easy to use. Freezing is often done mostly for standalone executables, where you want to distribute your application as a single file without the need for users to have Python and the required libraries installed.

The freezing process involves these general steps:

1. Write the Python scripts you want to include in your executable.
2. Compile the scripts to bytecode (.pyc files)
3. Create a custom Python interpreter with the bytecode files embedded (usually C code)
4. Compile the custom Python interpreter into a binary executable

There are several tools available for freezing Python modules:

1. cx_Freeze (https://cx-freeze.readthedocs.io)
2. PyInstaller (https://www.pyinstaller.org)
3. PyOxidizer (https://pyoxidizer.readthedocs.io)

Here’s an example using cx_Freeze:

1. Install cx_Freeze:

pip install cx_Freeze

2. Create a Python script named main.py:

def main():
    print("Hello, frozen world!")

if __name__ == "__main__":
    main()

3. Create a setup.py script to configure cx_Freeze:

from cx_Freeze import setup, Executable

setup(
    name="HelloFrozenWorld",
    version="0.1",
    description="A simple 'Hello, frozen world!' application",
    executables=[Executable("main.py")],
)

4. Run the setup.py script to create the executable:

python setup.py build

This will generate an executable in the "build" directory. You can run this executable without needing a Python installation or separate module files.

Note that this example is for a basic and small project. The complexity of the freezing process may vary depending on the size and dependencies involved in a project.