Built a higher-level wrapper around pythonmemorymodule — pyd_loader

[testAccountDeltas]

Hey! First off, thanks for pythonmemorymodule — it's a great low-level building block.

I built a higher-level wrapper on top of it called pyd_loader that handles a lot of the boilerplate that comes up when loading .pyd files in practice:

• Single-phase and multi-phase (PEP 451) init — handled automatically
• Package loading with relative imports (from .parser import ...) — just call PydPackageLoader.from_dir()
• Module inspection — functions, classes, constants, DLL import/export tables
• Runtime import tracking with callbacks
• DEBUG output suppressed by default (via the debug=False param you exposed)

Might be useful to others hitting the same rough edges. Repo here if you're curious:
https://github.com/testAccountDeltas/pyd_loader

Would love to hear if you see anything that could be done better at the lower level!

[testAccountDeltas]

https://github.com/testAccountDeltas/pyd_loader/blob/main/samples/loader_template.py

loader_template.py: In-Memory Pyd Loader with Decryption

This file serves as a production-ready template for using the pyd_loader library. Its core function is to dynamically load encrypted Cython Python extension modules (.pyd files) directly from memory, without ever writing them to disk.

It acts as a custom Python importer that decrypts, extracts, and executes .pyd modules packaged inside an encrypted ZIP archive.

How It Works: Step-by-Step

1. Decrypts the Payload: It takes an encrypted payload (a ZIP file), derives a decryption key from an obfuscated password using PBKDF2, and decrypts it.
2. Maps Modules: It reads the decrypted ZIP in memory, cataloging all .pyd files. It intelligently normalizes file paths (e.g., atom/parser.cp312-win_amd64.pyd) into importable Python module names (e.g., atom.parser). It also identifies packages by looking for __init__.py equivalents (like atom.__init__).
3. Loads via pyd_loader:
   • For single .pyd files, it uses PydMemoryLoader to load the binary directly into the current Python process.
   • For packages (a folder with multiple .pyd files), it uses PydPackageLoader. This loader assembles the package by first adding all submodules and then the __init__ module, ensuring the package behaves correctly (e.g., setting up __path__).
4. Hooks into Python's Import System: It installs a custom MetaPathFinder (EncryptedModuleFinder) that intercepts all import statements. If a requested module is part of the decrypted payload, it serves the already-loaded in-memory module. It also removes standard file-based finders to prevent accidental disk access.
5. Executes the Entry Point: Finally, it attempts to import a module named main from the loaded payload and execute its main() function.

Why This is a Good Example for pyd_loader

• Demonstrates Core Capabilities: It showcases both PydMemoryLoader (for single files) and PydPackageLoader (for complex packages).
• Real-World Scenario: It solves a practical problem—securely distributing and loading compiled extensions without disk persistence, useful for anti-tampering or code protection.
• Complete Integration: It shows how to integrate pyd_loader deeply with Python's import machinery (importlib) to create a seamless, transparent loading experience.

In short, this template turns a standard Python process into a secure, in-memory executor for encrypted, compiled modules.