204. Python’s Import Hooks

---

🔹 1. Basic Import Hook (Logging Imports)

• Hooks into Python’s import system to log imports.

import sys

class ImportLogger:
    def find_module(self, fullname, path=None):
        print(f"Importing {fullname}")
        return None  # Let Python handle the import

sys.meta_path.insert(0, ImportLogger())

import math  # Output: Importing math

🔍 How it works:

• find_module() logs module imports but doesn’t modify them.

---

🔹 2. Blocking Certain Modules from Being Imported

• Prevents unwanted modules from being imported.

import sys

class BlockModules:
    def find_module(self, fullname, path=None):
        if fullname in {"os", "sys"}:
            raise ImportError(f"Blocked import: {fullname}")
        return None  # Allow other imports

sys.meta_path.insert(0, BlockModules())

import os  # Raises ImportError

🔍 How it works:

• Blocks specific modules by raising an ImportError.

---

🔹 3. Custom Module Loader

• Loads a module dynamically at runtime.

import sys
import types

class CustomLoader:
    def find_module(self, fullname, path=None):
        if fullname == "custom_module":
            return self  # This loader will handle the import
        return None

    def load_module(self, fullname):
        mod = types.ModuleType(fullname)
        mod.hello = lambda: "Hello from custom_module!"
        sys.modules[fullname] = mod
        return mod

sys.meta_path.insert(0, CustomLoader())

import custom_module
print(custom_module.hello())  # Output: Hello from custom_module!

🔍 How it works:

• Dynamically creates and loads a module named custom_module.

---

🔹 4. Importing from a ZIP File

• Implements a custom import hook to load modules from a ZIP archive.

import sys
import zipimport

sys.path.insert(0, "modules.zip")  # Add ZIP file to sys.path

import mymodule  # This module is inside `modules.zip`
print(mymodule.some_function())  # Output depends on module content

🔍 How it works:

• zipimport allows loading Python modules from a ZIP file.

---

🔹 5. Redirecting Imports

• Redirects an import to a different module.

import sys

class RedirectImport:
    def find_module(self, fullname, path=None):
        if fullname == "math":
            print("Redirecting import from 'math' to 'random'")
            return self
        return None

    def load_module(self, fullname):
        import random
        sys.modules[fullname] = random
        return random

sys.meta_path.insert(0, RedirectImport())

import math  # Redirected to `random`
print(math.randint(1, 10))  # Works because math is now random

🔍 How it works:

• Any import of math gets replaced by random.

---

🔹 6. Creating a Read-Only Import Hook

• Prevents modifications to imported modules.

import sys

class ReadOnlyImport:
    def find_module(self, fullname, path=None):
        return self

    def load_module(self, fullname):
        mod = __import__(fullname)
        mod.__dict__ = types.MappingProxyType(mod.__dict__)  # Make read-only
        return mod

sys.meta_path.insert(0, ReadOnlyImport())

import math
math.pi = 4  # Raises TypeError

🔍 How it works:

• Makes module attributes immutable.

---

🔹 7. Importing from a Custom Directory

• Loads modules from a specific directory outside sys.path.

import sys
import os
import importlib.util

class CustomDirLoader:
    def __init__(self, directory):
        self.directory = directory

    def find_spec(self, fullname, path, target=None):
        filepath = os.path.join(self.directory, fullname + ".py")
        if os.path.exists(filepath):
            spec = importlib.util.spec_from_file_location(fullname, filepath)
            return spec
        return None

sys.meta_path.insert(0, CustomDirLoader("/path/to/custom/modules"))

import my_custom_module  # Loads from `/path/to/custom/modules`
print(my_custom_module.some_function())

🔍 How it works:

• Dynamically loads modules from a user-defined directory.

---

🔹 8. Import Hook for Enforcing Module Naming Conventions

• Enforces naming conventions for imported modules.

import sys

class NamingConventionEnforcer:
    def find_module(self, fullname, path=None):
        if fullname.islower():
            return None  # Allow valid imports
        raise ImportError(f"Invalid module name: {fullname}")

sys.meta_path.insert(0, NamingConventionEnforcer())

import json  # Works
import MyModule  # Raises ImportError

🔍 How it works:

• Prevents importing modules with uppercase names.

---

🔹 9. Auto-Reloading Modules on Import

• Automatically reloads a module when imported.

import sys
import importlib

class AutoReloader:
    def find_module(self, fullname, path=None):
        return self

    def load_module(self, fullname):
        if fullname in sys.modules:
            importlib.reload(sys.modules[fullname])
        else:
            mod = __import__(fullname)
            sys.modules[fullname] = mod
        return sys.modules[fullname]

sys.meta_path.insert(0, AutoReloader())

import mymodule  # Reloads on every import

🔍 How it works:

• Forces a module to reload every time it’s imported.

---

🔹 10. Importing Encrypted Modules

• Loads modules encrypted with a custom scheme.

import sys
import types
import base64

class EncryptedImport:
    def find_module(self, fullname, path=None):
        if fullname == "secure_module":
            return self
        return None

    def load_module(self, fullname):
        encrypted_code = "cHJpbnQoIkhlbGxvLCBFbmNyeXB0ZWQgV29ybGQhIik="  # base64-encoded script
        decrypted_code = base64.b64decode(encrypted_code).decode("utf-8")
        mod = types.ModuleType(fullname)
        exec(decrypted_code, mod.__dict__)
        sys.modules[fullname] = mod
        return mod

sys.meta_path.insert(0, EncryptedImport())

import secure_module  # Executes decrypted code

🔍 How it works:

• Decrypts an encoded module before execution.

---

Summary

Snippet	Description
1️⃣	Logs imports
2️⃣	Blocks specific imports
3️⃣	Dynamically creates modules
4️⃣	Imports from a ZIP file
5️⃣	Redirects imports
6️⃣	Makes modules read-only
7️⃣	Imports from a custom directory
8️⃣	Enforces naming conventions
9️⃣	Auto-reloads modules
🔟	Imports encrypted modules

---