मैं पाइथन में किसी विशिष्ट पैकेज में कक्षाओं को कैसे खोज सकता हूं?

Question

मेरे पास प्लग-इन शैली मॉड्यूल का एक पैकेज है। यह इस तरह दिखता है:

 
/Plugins 
/Plugins/__init__.py 
/Plugins/Plugin1.py 
/Plugins/Plugin2.py 
etc... 

प्रत्येक .py फ़ाइल एक वर्ग है कि PluginBaseClass से निकला होता है। तो मुझे Plugins पैकेज में प्रत्येक मॉड्यूल को सूचीबद्ध करने की आवश्यकता है और फिर PluginBaseClass लागू करने वाले किसी भी वर्ग की खोज करें। आदर्श रूप में मैं इस तरह कुछ करने के लिए सक्षम होना चाहते हैं:

for klass in iter_plugins(project.Plugins): 
    action = klass() 
    action.run() 

मैं कुछ अन्य उत्तर वहाँ देखा है, लेकिन मेरी स्थिति अलग है। मेरे पास मूल पैकेज में वास्तविक आयात है (यानी: import project.Plugins) और मुझे मॉड्यूल की खोज के बाद कक्षाएं खोजने की आवश्यकता है।

Answer 1

स्कैनिंग मॉड्यूल अच्छा विचार नहीं है। यदि आपको कक्षा रजिस्ट्री की आवश्यकता है तो आपको metaclasses पर देखना चाहिए या zope.interface जैसे मौजूदा समाधानों का उपयोग करना चाहिए। metaclasses के माध्यम से सरल समाधान है कि तरह लग रहे हो सकता है:

from functools import reduce 
class DerivationRegistry(type): 
    def __init__(cls,name,bases,cls_dict): 
     type.__init__(cls,name,bases,cls_dict) 
     cls._subclasses = set() 
     for base in bases: 
      if isinstance(base,DerivationRegistry): 
       base._subclasses.add(cls) 

    def getSubclasses(cls): 
     return reduce(set.union, 
         (succ.getSubclasses() for succ in cls._subclasses if isinstance(succ,DerivationRegistry)), 
         cls._subclasses) 

class Base(object): 
    __metaclass__ = DerivationRegistry 

class Cls1(object): 
    pass 

class Cls2(Base): 
    pass 

class Cls3(Cls2,Cls1): 
    pass 

class Cls4(Cls3): 
    pass 

print(Base.getSubclasses()) 

Answer 2

आप नहीं जानते कि क्या समय की Plugins आगे में होने जा रहा है, तो आप पैकेज की निर्देशिका में अजगर फ़ाइलों की एक सूची प्राप्त कर सकते हैं, और उन्हें इतनी तरह आयात:

# compute a list of modules in the Plugins package 

import os 
import Plugins 
plugin_modules = [f[:-3] for f in os.listdir(os.path.dirname(Plugins.__file__)) 
        if f.endswith('.py') and f != '__init__.py'] 

क्षमा करें, कि समझ अपेक्षाकृत नया पाइथन के लिए एक मुट्ठी भर हो सकता है। यहाँ एक अधिक वर्बोज़ संस्करण है (आसान का पालन करने के हो सकता है):

plugin_modules = [] 

package_path = Plugins.__file__ 
file_list = os.listdir(os.path.dirname(package_path)) 
for file_name in file_list: 
    if file_name.endswith('.py') and file_name != '__init__.py': 
     plugin_modules.append(file_name) 

तो फिर तुम मॉड्यूल पाने के लिए __import__ उपयोग कर सकते हैं:

# get the first one 
plugin = __import__('Plugins.' + plugin_modules[0]) 

Answer 3

संपादित करें: यहाँ एक संशोधित समाधान है। मुझे एहसास हुआ कि मैं अपने पिछले एक परीक्षण के दौरान गलती कर रहा था, और यह वास्तव में जिस तरह से आप उम्मीद करेंगे काम नहीं करता है। तो यहाँ एक अधिक पूर्ण समाधान है:

import os 
from imp import find_module 
from types import ModuleType, ClassType 

def iter_plugins(package): 
    """Receives package (as a string) and, for all of its contained modules, 
    generates all classes that are subclasses of PluginBaseClass.""" 

    # Despite the function name, "find_module" will find the package 
    # (the "filename" part of the return value will be None, in this case) 
    filename, path, description = find_module(package) 

    # dir(some_package) will not list the modules within the package, 
    # so we explicitly look for files. If you need to recursively descend 
    # a directory tree, you can adapt this to use os.walk instead of os.listdir 
    modules = sorted(set(i.partition('.')[0] 
          for i in os.listdir(path) 
          if i.endswith(('.py', '.pyc', '.pyo')) 
          and not i.startswith('__init__.py'))) 
    pkg = __import__(package, fromlist=modules) 
    for m in modules: 
     module = getattr(pkg, m) 
     if type(module) == ModuleType: 
      for c in dir(module): 
       klass = getattr(module, c) 
       if (type(klass) == ClassType and 
        klass is not PluginBaseClass and 
        issubclass(klass, PluginBaseClass)): 
        yield klass 

मेरे पिछले समाधान था:

from types import ModuleType 
import Plugins 

classes = [] 
for item in dir(Plugins): 
    module = getattr(Plugins, item) 
    # Get all (and only) modules in Plugins 
    if type(module) == ModuleType: 
     for c in dir(module): 
      klass = getattr(module, c) 
      if isinstance(klass, PluginBaseClass): 
       classes.append(klass) 

असल

, और भी बेहतर, आप कुछ प्रतिरूपकता चाहते हैं::

आप की तरह कुछ की कोशिश कर सकते

from types import ModuleType 

def iter_plugins(package): 
    # This assumes "package" is a package name. 
    # If it's the package itself, you can remove this __import__ 
    pkg = __import__(package) 
    for item in dir(pkg): 
     module = getattr(pkg, item) 
     if type(module) == ModuleType: 
      for c in dir(module): 
       klass = getattr(module, c) 
       if issubclass(klass, PluginBaseClass): 
        yield klass 

Answer 4

आप __all__ को __init__.py में परिभाषित कर सकते हैं (और शायद चाहिए) आपके पैकेज में submodules की एक सूची; ऐसा इसलिए है कि आप from Plugins import * करने वाले लोगों का समर्थन करते हैं। आपने ऐसा किया है, तो आप के साथ

import Plugins 
import sys 
modules = { } 
for module in Plugins.__all__: 
    __import__(module) 
    modules[ module ] = sys.modules[ module ] 
    # iterate over dir(module) as above 

कारण एक और उत्तर यहां पोस्ट में विफल रहता है कि __import__ सबसे कम स्तर के मॉड्यूल का आयात करता है, लेकिन रिटर्न शीर्ष स्तर के एक (docs देखने मॉड्यूल से अधिक पुनरावृति कर सकते हैं)। मुझे नहीं पता क्यों।