Como descarregar (recarregar) um módulo?

Eu tenho um servidor Python de execução demorada e gostaria de poder atualizar um serviço sem reiniciar o servidor. Qual é a melhor maneira de fazer isso?

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

Você pode recarregar um módulo quando ele já tiver sido importado usando a reloadfunção incorporada (somente Python 3.4+) :

from importlib import reload  
import foo

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

No Python 3, reloadfoi movido para o impmódulo. Em 3.4, impfoi preterido em favor de importlibe reloadfoi adicionado a este último. Ao direcionar 3 ou mais recente, faça referência ao módulo apropriado ao chamá reload-lo ou importá-lo.

Eu acho que é isso que você quer. Servidores da Web como o servidor de desenvolvimento do Django usam isso para que você possa ver os efeitos das alterações no seu código sem reiniciar o processo do servidor.

Para citar os documentos:

O código dos módulos Python é recompilado e o código no nível do módulo reexecutado, definindo um novo conjunto de objetos vinculados a nomes no dicionário do módulo. A função init dos módulos de extensão não é chamada uma segunda vez. Como em todos os outros objetos em Python, os objetos antigos são recuperados somente depois que suas contagens de referência caem para zero. Os nomes no espaço para nome do módulo são atualizados para apontar para qualquer objeto novo ou alterado. Outras referências aos objetos antigos (como nomes externos ao módulo) não são recuperadas para se referir aos novos objetos e devem ser atualizadas em cada espaço de nome em que ocorrem, se desejado.

Como você observou na sua pergunta, você precisará reconstruir Fooobjetos se a Fooclasse residir no foomódulo.

No Python 3.0-3.3, você usaria: imp.reload(module)

O BDFL tem respondido a esta pergunta.

No entanto, impfoi preterido no 3.4, a favor deimportlib (obrigado @Stefan! ).

Eu acho que , portanto, você usaria agora importlib.reload(module), embora não tenha certeza.

Pode ser especialmente difícil excluir um módulo se não for um Python puro.

Aqui estão algumas informações de: Como eu realmente excluo um módulo importado?

Você pode usar sys.getrefcount () para descobrir o número real de referências.

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

Números maiores que 3 indicam que será difícil se livrar do módulo. O módulo caseiro "vazio" (sem nada) deve ser coletado como lixo após

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

como a terceira referência é um artefato da função getrefcount ().

reload(module), mas somente se for completamente independente. Se qualquer outra coisa tiver uma referência ao módulo (ou qualquer objeto pertencente ao módulo), você receberá erros sutis e curiosos causados ​​pelo código antigo por mais tempo do que o esperado e coisas como isinstancenão funcionar em versões diferentes do mesmo código.

Se você tiver dependências unidirecionais, também deverá recarregar todos os módulos que dependem do módulo recarregado para se livrar de todas as referências ao código antigo. E, em seguida, recarregue os módulos que dependem dos módulos recarregados, recursivamente.

Se você tiver dependências circulares, o que é muito comum, por exemplo, ao lidar com o recarregamento de um pacote, você deve descarregar todos os módulos do grupo de uma só vez. Não é possível fazer isso reload()porque ele reimporta cada módulo antes que suas dependências sejam atualizadas, permitindo que referências antigas entrem em novos módulos.

A única maneira de fazer isso nesse caso é hackear sys.modules, o que é meio que sem suporte. Você precisaria passar e excluir cada sys.modulesentrada que desejava recarregar na próxima importação e também excluir entradas cujos valores devem Nonelidar com um problema de implementação relacionado ao armazenamento em cache de importações relativas com falha. Não é muito agradável, mas contanto que você tenha um conjunto totalmente independente de dependências que não deixa referências fora de sua base de código, é viável.

Provavelmente é melhor reiniciar o servidor. :-)

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

Para Python 2, use a função interna reload () :

reload(module)

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

import imp
imp.reload(module)

Mas imp está obsoleto desde a versão 3.4 em favor do importlib , então use:

import importlib
importlib.reload(module)

ou

from importlib import reload
reload(module)

O código a seguir permite compatibilidade com Python 2/3:

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

Você pode usá-lo como reload()nas duas versões, o que simplifica as coisas.

A resposta aceita não trata do caso Y de importação de X. Este código lida com ele e também com o caso de importação padrão:

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")

No caso de recarregamento, reatribuímos os nomes de nível superior aos valores armazenados no módulo recém-recarregado, que os atualiza.

Esta é a maneira moderna de recarregar um módulo:

from importlib import reload

Se você deseja oferecer suporte a versões do Python anteriores à 3.5, tente o seguinte:

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 usá-lo, execute reload(MODULE), substituindo MODULEpelo módulo que você deseja recarregar.

Por exemplo, reload(math)recarregará o mathmódulo.

Se você não está em um servidor, mas está desenvolvendo e precisa recarregar frequentemente um módulo, aqui está uma boa dica.

Primeiro, verifique se você está usando o excelente shell IPython , do projeto Jupyter Notebook. Depois de instalar o Jupyter, você pode iniciá-lo com ipython, ou jupyter console, melhor ainda, com jupyter qtconsoleum bom console colorido com conclusão de código em qualquer sistema operacional.

Agora no seu shell, digite:

%load_ext autoreload
%autoreload 2

Agora, toda vez que você executar seu script, seus módulos serão recarregados.

Além do 2, existem outras opções da magia de carregamento automático :

%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 aqueles como eu que querem descarregar todos os módulos (quando executados no interpretador Python no Emacs ):

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

Mais informações estão em Recarregando módulos Python .

O Enthought Traits possui um módulo que funciona razoavelmente bem para isso. https://traits.readthedocs.org/en/4.3.0/_modules/traits/util/refresh.html

Ele recarregará qualquer módulo que foi alterado e atualizará outros módulos e objetos instanciados que o estão usando. Ele não funciona na maioria das vezes com __very_private__métodos e pode engasgar com a herança de classe, mas poupa muito tempo de reiniciar o aplicativo host ao escrever guis do PyQt, ou coisas que são executadas em programas como o Maya ou o Nuke. Talvez não funcione entre 20 e 30% do tempo, mas ainda é incrivelmente útil.

O pacote da Enthought não recarrega os arquivos no momento em que eles mudam - você precisa chamá-lo explicitamente - mas isso não deve ser tão difícil de implementar se você realmente precisar

Aqueles que estão usando o python 3 e recarregam a partir do importlib.

Se você tiver problemas como parece que o módulo não é recarregado ... Isso ocorre porque ele precisa de algum tempo para recompilar o pyc (até 60 segundos).

01/02/2018

1. O módulo foodeve ser importado com sucesso com antecedência.
2. from importlib import reload, reload(foo)

31,5 importlib - A implementação de import - documentação do Python 3.6.4

Outra opção. Veja que o padrão do Python importlib.reloadapenas reimporta a biblioteca passada como argumento. Ele não recarregará as bibliotecas importadas pela sua lib. Se você alterou muitos arquivos e possui um pacote um pouco complexo para importar, é necessário fazer uma atualização profunda .

Se você possui o IPython ou o Jupyter instalado, pode usar uma função para recarregar profundamente todas as bibliotecas:

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

Se você não possui o Jupyter, instale-o com este comando no seu shell:

pip3 install jupyter

Editar (Resposta V2)

A solução anterior é boa apenas para obter as informações de redefinição, mas não altera todas as referências (mais do que reloadmas menos que o necessário). Para definir todas as referências também, tive que entrar no coletor de lixo e reescrever as referências lá. Agora isso trabalha como charme!

Observe que isso não funcionará se o GC estiver desligado ou se estiver recarregando dados que não são monitorados pelo GC. Se você não quiser mexer com o GC, a resposta original pode ser suficiente para você.

Novo 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)

Resposta original

Conforme escrito na resposta de @ bobince, se já houver uma referência a esse módulo em outro módulo (especialmente se ele foi importado com a aspalavra - chave like import numpy as np), essa instância não será substituída.

Isso me mostrou bastante problemático ao aplicar testes que exigiam um estado "clean-slate" dos módulos de configuração, por isso escrevi uma função denominada reset_moduleque usa importliba reloadfunção de e substitui recursivamente todos os atributos do módulo declarado. Foi testado com o Python versão 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: Use com cuidado! O uso desses módulos em módulos não periféricos (módulos que definem classes usadas externamente, por exemplo) pode levar a problemas internos no Python (como problemas de decapagem / não decapagem).

para mim, no caso de Abaqus, é assim que funciona. Imagine que seu arquivo é 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'])

Eu tive muitos problemas ao tentar recarregar algo dentro do Sublime Text, mas finalmente pude escrever esse utilitário para recarregar os módulos no Sublime Text com base no código sublime_plugin.pyusado para recarregar os módulos.

Isso abaixo permite que você recarregue módulos de caminhos com espaços em seus nomes; depois, depois de recarregar, você pode apenas importar como costuma fazer.

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()

Se você executar pela primeira vez, isso deverá carregar o módulo, mas se mais tarde você puder novamente o método / função, run_tests()ele recarregará os arquivos de teste. Com o Sublime Text ( Python 3.3.6), isso acontece muito porque o intérprete nunca fecha (a menos que você reinicie o Sublime Text, ou seja, o Python3.3intérprete).

Outra maneira poderia ser importar o módulo em uma função. Dessa forma, quando a função é concluída, o módulo recebe o lixo coletado.