English
You're encountering this issue because you're trying to load a .pyd (native extension module) using a SourceLoader, which is intended for .py files (text). Native extensions like .pyd must be loaded using ExtensionFileLoader — otherwise, you’ll get DLL or encoding-related errors.

Assuming you dynamically created this structure:

/a/temp/dir/foo/
    __init__.py
    bar.pyd

You can correctly import the package and the .pyd module like this:

import sys
import importlib.util
import importlib.machinery
import os

def import_pyd_module(package_name, module_name, path_to_pyd, path_to_init):
    # Ensure package is imported first
    if package_name not in sys.modules:
        spec_pkg = importlib.util.spec_from_file_location(
            package_name,
            path_to_init,
            submodule_search_locations=[os.path.dirname(path_to_init)]
        )
        module_pkg = importlib.util.module_from_spec(spec_pkg)
        sys.modules[package_name] = module_pkg
        spec_pkg.loader.exec_module(module_pkg)

    # Load the compiled submodule
    fullname = f"{package_name}.{module_name}"
    loader = importlib.machinery.ExtensionFileLoader(fullname, path_to_pyd)
    spec = importlib.util.spec_from_file_location(fullname, path_to_pyd, loader=loader)
    module = importlib.util.module_from_spec(spec)
    sys.modules[fullname] = module
    spec.loader.exec_module(module)
    return module

Why Your Custom Loader Fails

Your MyLoader inherits from SourceLoader, which expects a .py file and calls get_data() expecting text. This cannot be used for .pyd files, which are binary and must be handled using the built-in ExtensionFileLoader.

If you want a custom import system with dynamic .pyd loading, you can still use a MetaPathFinder, but your loader must delegate to ExtensionFileLoader.

Usage:

mod = import_pyd_module(
    package_name="foo",
    module_name="bar",
    path_to_pyd="/a/temp/dir/foo/bar.pyd",
    path_to_init="/a/temp/dir/foo/__init__.py"
)

mod.some_method()

Spanish
Estás teniendo este problema porque intentas cargar un módulo compilado .pyd usando un SourceLoader, que está diseñado para archivos .py (texto fuente). Los archivos .pyd (extensiones nativas en Windows) deben cargarse usando ExtensionFileLoader, o de lo contrario recibirás errores como el de carga de DLL o problemas de codificación.

Supongamos que creaste dinámicamente la siguiente estructura:

/a/temp/dir/foo/
    __init__.py
    bar.pyd

Puedes importar correctamente el paquete y el módulo .pyd con el siguiente código:

import sys
import importlib.util
import importlib.machinery
import os

def importar_pyd_como_modulo(nombre_paquete, nombre_modulo, ruta_pyd, ruta_init):
    # Asegurar que el paquete esté importado primero
    if nombre_paquete not in sys.modules:
        spec_pkg = importlib.util.spec_from_file_location(
            nombre_paquete,
            ruta_init,
            submodule_search_locations=[os.path.dirname(ruta_init)]
        )
        modulo_pkg = importlib.util.module_from_spec(spec_pkg)
        sys.modules[nombre_paquete] = modulo_pkg
        spec_pkg.loader.exec_module(modulo_pkg)

    # Cargar el submódulo compilado
    nombre_completo = f"{nombre_paquete}.{nombre_modulo}"
    loader = importlib.machinery.ExtensionFileLoader(nombre_completo, ruta_pyd)
    spec = importlib.util.spec_from_file_location(nombre_completo, ruta_pyd, loader=loader)
    modulo = importlib.util.module_from_spec(spec)
    sys.modules[nombre_completo] = modulo
    spec.loader.exec_module(modulo)
    return modulo

Por qué falla tu MyLoader

Tu clase MyLoader hereda de SourceLoader, lo cual no sirve para archivos .pyd, porque espera archivos fuente .py y llama a get_data() esperando texto plano. Sin embargo, .pyd es binario, y debe manejarse con el loader nativo de extensiones: ExtensionFileLoader.

Si deseas implementar un sistema de carga personalizado, puedes seguir usando MetaPathFinder, pero el loader debe delegar a ExtensionFileLoader.