módulo dinámico en Python

Question

Estoy escribiendo una aplicación Python que toma como un comando como argumento, por ejemplo:

$ python myapp.py command1 

Quiero que la aplicación sea extensible, es decir, que sea capaz de añadir nuevos módulos que implementan nuevos comandos sin tener que cambiar el origen de la aplicación principal. El árbol se ve algo como:

myapp/ 
    __init__.py 
    commands/ 
     __init__.py 
     command1.py 
     command2.py 
    foo.py 
    bar.py 

Así que desea que la aplicación para encontrar los módulos de comando disponibles en tiempo de ejecución y ejecutar el apropiado.

Actualmente esto se implementa algo como:

command = sys.argv[1] 
try: 
    command_module = __import__("myapp.commands.%s" % command, fromlist=["myapp.commands"]) 
except ImportError: 
    # Display error message 

command_module.run() 

Esto funciona muy bien, me pregunto si hay posiblemente una forma más idiomática para lograr lo que estamos haciendo con este código.

Tenga en cuenta que específicamente no quiero entrar al uso de huevos o puntos de extensión. Este no es un proyecto de código abierto y no espero que haya "complementos". El objetivo es simplificar el código de la aplicación principal y eliminar la necesidad de modificarlo cada vez que se agrega un nuevo módulo de comando.

Answer 1

Con Python mayores de 2.7/3.1, que es más o menos la forma de hacerlo. Para versiones más nuevas, vea importlib.import_modulefor 2.7+ y for 3.1+.

Puedes usar exec si quieres también.

Nota puede importar una lista de módulos al hacer esto:

>>> moduleNames = ['sys', 'os', 're', 'unittest'] 
>>> moduleNames 
['sys', 'os', 're', 'unittest'] 
>>> modules = map(__import__, moduleNames) 

Ripped directamente desde Dive Into Python.

Answer 2

Puede utilizar exec:

exec "import myapp.commands.%s" % command 

Answer 3

Utilice la función imp module, o la más directa __import__().

Answer 4

Como se ha mencionado el módulo imp le proporciona las funciones de carga:

imp.load_source(name, path) 
imp.load_compiled(name, path) 

He usado estos antes de realizar algo similar.

En mi caso, definí una clase específica con los métodos definidos que se requerían. Una vez cargado el módulo de E comprobaría si la clase estaba en el módulo, y luego crear una instancia de esa clase, algo como esto:

import imp 
import os 

def load_from_file(filepath): 
    class_inst = None 
    expected_class = 'MyClass' 

    mod_name,file_ext = os.path.splitext(os.path.split(filepath)[-1]) 

    if file_ext.lower() == '.py': 
     py_mod = imp.load_source(mod_name, filepath) 

    elif file_ext.lower() == '.pyc': 
     py_mod = imp.load_compiled(mod_name, filepath) 

    if hasattr(py_mod, expected_class): 
     class_inst = getattr(py_mod, expected_class)() 

    return class_inst 

Answer 5

Suena como lo que realmente quiere es una arquitectura de plugins.

Debe echar un vistazo a la funcionalidad entry points proporcionada por el paquete setuptools. Ofrece una excelente manera de descubrir los complementos que se cargan para su aplicación.

Answer 6

A continuación trabajó para mí:

import sys, glob 
sys.path.append('/home/marc/python/importtest/modus') 
fl = glob.glob('modus/*.py') 
modulist = [] 
adapters=[] 
for i in range(len(fl)): 
    fl[i] = fl[i].split('/')[1] 
    fl[i] = fl[i][0:(len(fl[i])-3)] 
    modulist.append(getattr(__import__(fl[i]),fl[i])) 
    adapters.append(modulist[i]()) 

Se carga los módulos de la carpeta 'operandi'. Los módulos tienen una sola clase con el mismo nombre que el nombre del módulo. P.ej. el modus archivo/modu1.py contiene:

class modu1(): 
    def __init__(self): 
     self.x=1 
     print self.x 

El resultado es una lista de clases de "adaptadores" carga dinámica.

Answer 7

Si lo desea, en sus locales:

>>> mod = 'sys' 
>>> locals()['my_module'] = __import__(mod) 
>>> my_module.version 
'2.6.6 (r266:84297, Aug 24 2010, 18:46:32) [MSC v.1500 32 bit (Intel)]' 

misma trabajaría con globals()

Answer 8

La forma recomendada para Python 2.7 y más tarde es utilizar importlib módulo:

my_module = importlib.import_module('os.path') 

Answer 9

similares como la solución de @monkut pero reutilizable y tolerante a errores descrito aquí http://stamat.wordpress.com/dynamic-module-import-in-python/:

import os 
import imp 

def importFromURI(uri, absl): 
    mod = None 
    if not absl: 
     uri = os.path.normpath(os.path.join(os.path.dirname(__file__), uri)) 
    path, fname = os.path.split(uri) 
    mname, ext = os.path.splitext(fname) 

    if os.path.exists(os.path.join(path,mname)+'.pyc'): 
     try: 
      return imp.load_compiled(mname, uri) 
     except: 
      pass 
    if os.path.exists(os.path.join(path,mname)+'.py'): 
     try: 
      return imp.load_source(mname, uri) 
     except: 
      pass 

    return mod 

Answer 10

La pieza más adelante trabajó para mí:

>>>import imp; 
>>>fp, pathname, description = imp.find_module("/home/test_module"); 
>>>test_module = imp.load_module("test_module", fp, pathname, description); 
>>>print test_module.print_hello(); 

si desea importar en shell-script:

python -c '<above entire code in one line>'