如何在导入第三方模块时将非PEP8规范名称转为PEP8规范？

Great question! When stuck with uneditable third-party modules that use non-PEP8 naming (like thisIsABase_function(self,a,b)), your existing _pep8ify function is perfect for bridging the gap. Here are three practical, clean ways to implement automatic name conversion so you can call functions using PEP8-compliant names:

1. Simple Module Wrapper (Most Straightforward) #

Create a wrapper module that imports the third-party code, then dynamically maps all non-PEP8 names to their PEP8 equivalents using your _pep8ify function. This is easy to set up and understand.

# pep8_third_party.py
import third_party_module  # Replace with your actual module name
from your_utils_module import _pep8ify  # Import your existing function

# Iterate over all public attributes in the original module
for attr_name in dir(third_party_module):
    # Skip private attributes (adjust this if you need to handle underscore-prefixed names)
    if not attr_name.startswith('_'):
        pep8_name = _pep8ify(attr_name)
        # Avoid overwriting existing attributes to prevent conflicts
        if pep8_name != attr_name and not hasattr(third_party_module, pep8_name):
            setattr(third_party_module, pep8_name, getattr(third_party_module, attr_name))

Usage: #

from pep8_third_party import third_party_module

# Now you can call the PEP8-compliant name instead of the original
third_party_module.this_is_a_base_function(self, a, b)

2. Custom Import Hook (Automated for All Imports) #

For a more hands-off approach, use Python's importlib to create a custom import hook that automatically converts names whenever you import the target module. This works across your entire codebase without needing a wrapper for each module.

# pep8_import_hook.py
import importlib.abc
import importlib.util
from your_utils_module import _pep8ify

class PEP8ifyImporter(importlib.abc.MetaPathFinder, importlib.abc.Loader):
    def find_spec(self, fullname, path, target=None):
        # Only apply this hook to your target third-party module
        if fullname != "third_party_module":
            return None
        # Get the original module's spec
        spec = importlib.util.find_spec(fullname)
        if spec:
            # Replace the default loader with our custom one
            spec.loader = self
            return spec
        return None

    def create_module(self, spec):
        # Create the base module object
        return importlib.util.module_from_spec(spec)

    def exec_module(self, module):
        # Execute the original module's code to populate the module object
        spec = importlib.util.find_spec(module.__name__)
        with open(spec.origin, 'r') as f:
            exec(f.read(), module.__dict__)
        
        # Convert all public attributes to PEP8 names
        for attr_name in list(module.__dict__.keys()):
            if not attr_name.startswith('_'):
                pep8_name = _pep8ify(attr_name)
                if pep8_name != attr_name and pep8_name not in module.__dict__:
                    module.__dict__[pep8_name] = module.__dict__[attr_name]

# Register the hook with Python's import system
import sys
sys.meta_path.insert(0, PEP8ifyImporter())

Usage: #

Just import the hook once (e.g., at the start of your main script), then import the third-party module normally:

import pep8_import_hook
import third_party_module

third_party_module.this_is_a_base_function(self, a, b)

3. Module-Level __getattr__ (Lightweight, Python 3.7+) #

If you're using Python 3.7 or later, you can use a proxy module with a __getattr__ function that dynamically resolves PEP8 names to the original non-compliant ones. This is lazy-loaded and avoids modifying the original module directly.

# third_party_proxy.py
import third_party_module as _original_module
from your_utils_module import _pep8ify

def __getattr__(name):
    # First try to get the attribute directly (in case it's already PEP8-compliant)
    try:
        return getattr(_original_module, name)
    except AttributeError:
        # Look for an original attribute that converts to the requested PEP8 name
        for original_name in dir(_original_module):
            if _pep8ify(original_name) == name:
                return getattr(_original_module, original_name)
        # If no match found, raise the standard AttributeError
        raise AttributeError(f"Module 'third_party_module' has no attribute '{name}'")

Usage: #

Import directly from the proxy module:

from third_party_proxy import this_is_a_base_function

this_is_a_base_function(self, a, b)

Key Notes: #

• Avoid Conflicts: Always check if the PEP8 name already exists in the module before overwriting it to prevent unexpected behavior.
• Private Attributes: The examples skip attributes starting with _—adjust this logic if you need to handle private names too.
• Performance: The import hook and __getattr__ methods have minimal overhead, but the wrapper approach is the fastest since it does all conversion upfront.

内容的提问来源于stack exchange，提问作者code base 5000