¿Cómo descargo (recargo) un módulo?

Tengo un servidor Python de larga ejecución y me gustaría poder actualizar un servicio sin reiniciar el servidor. ¿Cuál es la mejor manera de hacer esto?

if foo.py has changed:
    unimport foo  <-- How do I do this?
    import foo
    myfoo = foo.Foo()

Puede volver a cargar un módulo cuando ya se ha importado utilizando la reloadfunción incorporada (solo Python 3.4+) :

from importlib import reload  
import foo

while True:
    # Do some things.
    if is_changed(foo):
        foo = reload(foo)

En Python 3, reloadse movió al impmódulo. En 3.4, impquedó en desuso a favor de importlib, y reloadse agregó a este último. Cuando apunte a 3 o posterior, haga referencia al módulo apropiado al llamar reloado impórtelo.

Creo que esto es lo que quieres. Los servidores web como el servidor de desarrollo de Django usan esto para que pueda ver los efectos de los cambios en su código sin reiniciar el proceso del servidor.

Para citar de los documentos:

El código de los módulos de Python se vuelve a compilar y el código de nivel de módulo se vuelve a ejecutar, definiendo un nuevo conjunto de objetos que están vinculados a nombres en el diccionario del módulo. La función init de los módulos de extensión no se llama por segunda vez. Al igual que con todos los demás objetos en Python, los objetos antiguos solo se recuperan después de que sus recuentos de referencia caen a cero. Los nombres en el espacio de nombres del módulo se actualizan para señalar cualquier objeto nuevo o modificado. Otras referencias a los objetos antiguos (como los nombres externos al módulo) no se rebotan para referirse a los nuevos objetos y deben actualizarse en cada espacio de nombres donde ocurran si así se desea.

Como señaló en su pregunta, tendrá que reconstruir Fooobjetos si la Fooclase reside en el foomódulo.

En Python 3.0–3.3 usarías: imp.reload(module)

El BDFL ha respondido esta pregunta.

Sin embargo, impquedó en desuso en 3.4, a favor deimportlib (¡gracias @Stefan! ).

Yo pienso , por lo tanto, tendría ahora utiliza importlib.reload(module), aunque no estoy seguro.

Puede ser especialmente difícil eliminar un módulo si no es Python puro.

Aquí hay información de: ¿Cómo elimino realmente un módulo importado?

Puede usar sys.getrefcount () para averiguar el número real de referencias.

>>> import sys, empty, os
>>> sys.getrefcount(sys)
9
>>> sys.getrefcount(os)
6
>>> sys.getrefcount(empty)
3

Los números mayores que 3 indican que será difícil deshacerse del módulo. El módulo "vacío" (que no contiene nada) de cosecha propia debe recolectarse basura después de

>>> del sys.modules["empty"]
>>> del empty

como la tercera referencia es un artefacto de la función getrefcount ().

reload(module), pero solo si es completamente independiente. Si algo más tiene una referencia al módulo (o cualquier objeto que pertenezca al módulo), obtendrá errores sutiles y curiosos causados ​​por el código antiguo que duró más de lo esperado, y cosas como isinstanceno funcionar en diferentes versiones del mismo código

Si tiene dependencias unidireccionales, también debe volver a cargar todos los módulos que dependen del módulo recargado para deshacerse de todas las referencias al código anterior. Y luego vuelva a cargar los módulos que dependen de los módulos recargados, de forma recursiva.

Si tiene dependencias circulares, lo cual es muy común, por ejemplo, cuando se trata de recargar un paquete, debe descargar todos los módulos del grupo de una vez. No puede hacer esto reload()porque reimportará cada módulo antes de que se actualicen sus dependencias, lo que permitirá que las referencias antiguas se introduzcan en módulos nuevos.

La única forma de hacerlo en este caso es hackear sys.modules, lo que no es compatible. Tendría que revisar y eliminar cada sys.modulesentrada que desea que se vuelva a cargar en la próxima importación, y también eliminar las entradas cuyos valores son Nonepara tratar un problema de implementación relacionado con el almacenamiento en caché de importaciones relativas fallidas. No es terriblemente agradable, pero siempre que tenga un conjunto de dependencias totalmente autónomo que no deje referencias fuera de su base de código, es viable.

Probablemente sea mejor reiniciar el servidor. :-)

if 'myModule' in sys.modules:  
    del sys.modules["myModule"]

Para Python 2, use la función incorporada reload () :

reload(module)

Para Python 2 y 3.2–3.3 use reload from module imp :

import imp
imp.reload(module)

Pero imp está en desuso desde la versión 3.4 a favor de importlib , así que use:

import importlib
importlib.reload(module)

o

from importlib import reload
reload(module)

El siguiente código le permite la compatibilidad con Python 2/3:

try:
    reload
except NameError:
    # Python 3
    from imp import reload

Puede usarlo como reload()en ambas versiones, lo que simplifica las cosas.

La respuesta aceptada no maneja el caso de X import Y. Este código lo maneja y el caso de importación estándar también:

def importOrReload(module_name, *names):
    import sys

    if module_name in sys.modules:
        reload(sys.modules[module_name])
    else:
        __import__(module_name, fromlist=names)

    for name in names:
        globals()[name] = getattr(sys.modules[module_name], name)

# use instead of: from dfly_parser import parseMessages
importOrReload("dfly_parser", "parseMessages")

En el caso de recarga, reasignamos los nombres de nivel superior a los valores almacenados en el módulo recién recargado, que los actualiza.

Esta es la forma moderna de recargar un módulo:

from importlib import reload

Si desea admitir versiones de Python anteriores a la 3.5, intente esto:

from sys import version_info
if version_info[0] < 3:
    pass # Python 2 has built in reload
elif version_info[0] == 3 and version_info[1] <= 4:
    from imp import reload # Python 3.0 - 3.4 
else:
    from importlib import reload # Python 3.5+

Para usarlo, ejecute reload(MODULE), reemplazando MODULEcon el módulo que desea volver a cargar.

Por ejemplo, reload(math)volverá a cargar el mathmódulo.

Si usted es no en un servidor, pero el desarrollo y la necesidad de recargar con frecuencia un módulo, he aquí una buena propina.

Primero, asegúrese de estar utilizando el excelente shell de IPython , del proyecto Jupyter Notebook. Después de instalar Jupyter, puede comenzar con ipythono jupyter console, o incluso mejor jupyter qtconsole, lo que le dará una buena consola coloreada con finalización de código en cualquier sistema operativo.

Ahora en su shell, escriba:

%load_ext autoreload
%autoreload 2

Ahora, cada vez que ejecute su script, sus módulos se recargarán.

Más allá del 2, hay otras opciones de la magia de autocarga :

%autoreload
Reload all modules (except those excluded by %aimport) automatically now.

%autoreload 0
Disable automatic reloading.

%autoreload 1
Reload all modules imported with %aimport every time before executing the Python code typed.

%autoreload 2
Reload all modules (except those excluded by %aimport) every time before
executing the Python code typed.

Para aquellos como yo que desean descargar todos los módulos (cuando se ejecutan en el intérprete de Python en Emacs ):

   for mod in sys.modules.values():
      reload(mod)

Más información se encuentra en los módulos de recarga Python .

Enthought Traits tiene un módulo que funciona bastante bien para esto. https://traits.readthedocs.org/en/4.3.0/_modules/traits/util/refresh.html

Recargará cualquier módulo que se haya cambiado y actualizará otros módulos y objetos instanciados que lo estén utilizando. No funciona la mayoría de las veces con __very_private__métodos, y puede ahogarse con la herencia de clase, pero me ahorra una gran cantidad de tiempo al tener que reiniciar la aplicación host al escribir guiones PyQt, o cosas que se ejecutan dentro de programas como Maya o Nuke. No funciona tal vez el 20-30% del tiempo, pero sigue siendo increíblemente útil.

El paquete de Enthought no recarga los archivos en el momento en que cambian, debe llamarlo explícitamente, pero eso no debería ser tan difícil de implementar si realmente lo necesita

Aquellos que usan python 3 y recargan desde importlib.

Si tiene problemas, parece que el módulo no se recarga ... Eso se debe a que necesita un poco de tiempo para volver a compilar pyc (hasta 60 segundos) .Escribo esta sugerencia solo para saber si ha experimentado este tipo de problema.

2018-02-01

1. El módulo foodebe importarse con éxito por adelantado.
2. from importlib import reload, reload(foo)

31.5. importlib - La implementación de import - Documentación de Python 3.6.4

Otra opción. Vea que el valor predeterminado de Python importlib.reloadsolo volverá a importar la biblioteca pasada como argumento. No volverá a cargar las bibliotecas que importa su lib. Si cambió muchos archivos y tiene un paquete algo complejo para importar, debe realizar una recarga profunda .

Si tiene instalado IPython o Jupyter , puede usar una función para volver a cargar todas las bibliotecas:

from IPython.lib.deepreload import reload as dreload
dreload(foo)

Si no tiene Jupyter, instálelo con este comando en su shell:

pip3 install jupyter

Editar (Respuesta V2)

La solución anterior es buena solo para obtener la información de reinicio, pero no cambiará todas las referencias (más de reloadpero menos de lo requerido). Para configurar realmente todas las referencias también, tuve que ir al recolector de basura y reescribir las referencias allí. ¡Ahora funciona como un encanto!

Tenga en cuenta que esto no funcionará si el GC está apagado, o si vuelve a cargar datos que no son monitoreados por el GC. Si no quiere meterse con el GC, la respuesta original podría ser suficiente para usted.

Nuevo código:

import importlib
import inspect
import gc
from weakref import ref


def reset_module(module, inner_modules_also=True):
    """
    This function is a stronger form of importlib's `reload` function. What it does, is that aside from reloading a
    module, it goes to the old instance of the module, and sets all the (not read-only) attributes, functions and classes
    to be the reloaded-module's
    :param module: The module to reload (module reference, not the name)
    :param inner_modules_also: Whether to treat ths module as a package as well, and reload all the modules within it.
    """

    # For the case when the module is actually a package
    if inner_modules_also:
        submods = {submod for _, submod in inspect.getmembers(module)
                   if (type(submod).__name__ == 'module') and (submod.__package__.startswith(module.__name__))}
        for submod in submods:
            reset_module(submod, True)

    # First, log all the references before reloading (because some references may be changed by the reload operation).
    module_tree = _get_tree_references_to_reset_recursively(module, module.__name__)

    new_module = importlib.reload(module)
    _reset_item_recursively(module, module_tree, new_module)


def _update_referrers(item, new_item):
    refs = gc.get_referrers(item)

    weak_ref_item = ref(item)
    for coll in refs:
        if type(coll) == dict:
            enumerator = coll.keys()
        elif type(coll) == list:
            enumerator = range(len(coll))
        else:
            continue

        for key in enumerator:

            if weak_ref_item() is None:
                # No refs are left in the GC
                return

            if coll[key] is weak_ref_item():
                coll[key] = new_item

def _get_tree_references_to_reset_recursively(item, module_name, grayed_out_item_ids = None):
    if grayed_out_item_ids is None:
        grayed_out_item_ids = set()

    item_tree = dict()
    attr_names = set(dir(item)) - _readonly_attrs
    for sub_item_name in attr_names:

        sub_item = getattr(item, sub_item_name)
        item_tree[sub_item_name] = [sub_item, None]

        try:
            # Will work for classes and functions defined in that module.
            mod_name = sub_item.__module__
        except AttributeError:
            mod_name = None

        # If this item was defined within this module, deep-reset
        if (mod_name is None) or (mod_name != module_name) or (id(sub_item) in grayed_out_item_ids) \
                or isinstance(sub_item, EnumMeta):
            continue

        grayed_out_item_ids.add(id(sub_item))
        item_tree[sub_item_name][1] = \
            _get_tree_references_to_reset_recursively(sub_item, module_name, grayed_out_item_ids)

    return item_tree


def _reset_item_recursively(item, item_subtree, new_item):

    # Set children first so we don't lose the current references.
    if item_subtree is not None:
        for sub_item_name, (sub_item, sub_item_tree) in item_subtree.items():

            try:
                new_sub_item = getattr(new_item, sub_item_name)
            except AttributeError:
                # The item doesn't exist in the reloaded module. Ignore.
                continue

            try:
                # Set the item
                _reset_item_recursively(sub_item, sub_item_tree, new_sub_item)
            except Exception as ex:
                pass

    _update_referrers(item, new_item)

Respuesta original

Como está escrito en la respuesta de @ bobince, si ya hay una referencia a ese módulo en otro módulo (especialmente si se importó con la aspalabra clave like import numpy as np), esa instancia no se sobrescribirá.

Esto resultó bastante problemático para mí al aplicar pruebas que requerían un estado "limpio" de los módulos de configuración, así que escribí una función llamada reset_moduleque usa importlibla reloadfunción y sobrescribe recursivamente todos los atributos del módulo declarado. Ha sido probado con Python versión 3.6.

import importlib
import inspect
from enum import EnumMeta

_readonly_attrs = {'__annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__',
               '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__func__', '__ge__', '__get__',
               '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__',
               '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__',
               '__reduce__', '__reduce_ex__', '__repr__', '__self__', '__setattr__', '__sizeof__', '__str__',
               '__subclasshook__', '__weakref__', '__members__', '__mro__', '__itemsize__', '__isabstractmethod__',
               '__basicsize__', '__base__'}


def reset_module(module, inner_modules_also=True):
    """
    This function is a stronger form of importlib's `reload` function. What it does, is that aside from reloading a
    module, it goes to the old instance of the module, and sets all the (not read-only) attributes, functions and classes
    to be the reloaded-module's
    :param module: The module to reload (module reference, not the name)
    :param inner_modules_also: Whether to treat ths module as a package as well, and reload all the modules within it.
    """

    new_module = importlib.reload(module)

    reset_items = set()

    # For the case when the module is actually a package
    if inner_modules_also:
        submods = {submod for _, submod in inspect.getmembers(module)
                   if (type(submod).__name__ == 'module') and (submod.__package__.startswith(module.__name__))}
        for submod in submods:
            reset_module(submod, True)

    _reset_item_recursively(module, new_module, module.__name__, reset_items)


def _reset_item_recursively(item, new_item, module_name, reset_items=None):
    if reset_items is None:
        reset_items = set()

    attr_names = set(dir(item)) - _readonly_attrs

    for sitem_name in attr_names:

        sitem = getattr(item, sitem_name)
        new_sitem = getattr(new_item, sitem_name)

        try:
            # Set the item
            setattr(item, sitem_name, new_sitem)

            try:
                # Will work for classes and functions defined in that module.
                mod_name = sitem.__module__
            except AttributeError:
                mod_name = None

            # If this item was defined within this module, deep-reset
            if (mod_name is None) or (mod_name != module_name) or (id(sitem) in reset_items) \
                    or isinstance(sitem, EnumMeta):  # Deal with enums
                continue

            reset_items.add(id(sitem))
            _reset_item_recursively(sitem, new_sitem, module_name, reset_items)
        except Exception as ex:
            raise Exception(sitem_name) from ex

Nota: ¡ Usar con cuidado! El uso de estos en módulos no periféricos (módulos que definen clases usadas externamente, por ejemplo) podría conducir a problemas internos en Python (como problemas de decapado / no decapado).

para mí para el caso de Abaqus es la forma en que funciona. Imagine que su archivo es Class_VerticesEdges.py

sys.path.append('D:\...\My Pythons')
if 'Class_VerticesEdges' in sys.modules:  
    del sys.modules['Class_VerticesEdges']
    print 'old module Class_VerticesEdges deleted'
from Class_VerticesEdges import *
reload(sys.modules['Class_VerticesEdges'])

Tuve muchos problemas para intentar volver a cargar algo dentro de Sublime Text, pero finalmente pude escribir esta utilidad para recargar módulos en Sublime Text en función del código sublime_plugin.pyutilizado para recargar módulos.

Lo siguiente acepta que recargue módulos desde rutas con espacios en sus nombres, luego, después de volver a cargar, puede importar como lo hace normalmente.

def reload_module(full_module_name):
    """
        Assuming the folder `full_module_name` is a folder inside some
        folder on the python sys.path, for example, sys.path as `C:/`, and
        you are inside the folder `C:/Path With Spaces` on the file 
        `C:/Path With Spaces/main.py` and want to re-import some files on
        the folder `C:/Path With Spaces/tests`

        @param full_module_name   the relative full path to the module file
                                  you want to reload from a folder on the
                                  python `sys.path`
    """
    import imp
    import sys
    import importlib

    if full_module_name in sys.modules:
        module_object = sys.modules[full_module_name]
        module_object = imp.reload( module_object )

    else:
        importlib.import_module( full_module_name )

def run_tests():
    print( "\n\n" )
    reload_module( "Path With Spaces.tests.semantic_linefeed_unit_tests" )
    reload_module( "Path With Spaces.tests.semantic_linefeed_manual_tests" )

    from .tests import semantic_linefeed_unit_tests
    from .tests import semantic_linefeed_manual_tests

    semantic_linefeed_unit_tests.run_unit_tests()
    semantic_linefeed_manual_tests.run_manual_tests()

if __name__ == "__main__":
    run_tests()

Si ejecuta por primera vez, esto debería cargar el módulo, pero si luego puede volver a utilizar el método / función run_tests(), volverá a cargar los archivos de prueba. Con Sublime Text ( Python 3.3.6) esto sucede mucho porque su intérprete nunca se cierra (a menos que reinicie Sublime Text, es decir, el Python3.3intérprete).

Otra forma podría ser importar el módulo en una función. De esta manera, cuando la función se completa, el módulo obtiene basura recolectada.