method - En Python, ¿cómo puedo administrar de manera eficiente las referencias entre los archivos de script?

missing method docstring

Question

Tengo un buen número de scripts de Python que contienen código reutilizable que otros scripts de Python usan y referencian. Sin embargo, estos guiones tienden a estar dispersos en diferentes directorios y me resulta tedioso tener que incluir (con frecuencia múltiples) llamadas a sys.path.append en mis scripts de nivel superior. Solo quiero proporcionar las declaraciones de ''importación'' sin las referencias de archivos adicionales en el mismo script.

Actualmente, tengo esto:

import sys
sys.path.append(''..//shared1//reusable_foo'')
import Foo
sys.path.append(''..//shared2//reusable_bar'')
import Bar

Mi preferencia sería la siguiente:

import Foo
import Bar

Mis antecedentes se encuentran principalmente en la plataforma .NET, así que estoy acostumbrado a tener metaarchivos como * .csproj, * .vbproj, * .sln, etc. para administrar y contener las referencias de ruta de archivo reales fuera de los archivos fuente. Esto me permite simplemente proporcionar directivas ''using'' (equivalentes a la importación de Python) sin exponer todas las referencias y permitir la reutilización de las referencias de ruta a través de múltiples scripts.

¿Python tiene soporte equivalente para esto y, si no, cuáles son algunas técnicas y enfoques?

Answer 1

En un proyecto, quería asegurarme de que el usuario pudiera colocar scripts de Python (que básicamente podrían usarse como complementos) en cualquier lugar. Mi solución fue poner lo siguiente en el archivo de configuración para ese proyecto:

[server]
PYPATH_APPEND: /home/jason:/usr/share/some_directory

De esta forma, esto agregaría / home / jason y / usr / share / some_directory a la ruta python al inicio del programa.

Entonces, es simplemente una cuestión de dividir la cadena entre los dos puntos y agregar esos directorios al final de sys.path. Es posible que desee considerar poner un módulo en el directorio de paquetes de sitio que contiene una función para leer en ese archivo de configuración y agregar esos directorios a sys.path (desafortunadamente, no tengo tiempo en este momento para escribir un ejemplo) .

Como otros han mencionado, es una buena idea poner tanto en paquetes de sitios como sea posible y también usar archivos .pth. Pero esto puede ser una buena idea si tiene un script que necesita importar un montón de cosas que no están en el sitio: paquetes que no le gustaría importar de otros scripts.

(También puede haber una forma de hacer esto usando archivos .pth, pero me gusta poder manipular la ruta de Python en el mismo lugar donde pongo el resto de la información de configuración)

Answer 2

Puede poner las cosas reutilizables en site-packages . Eso es completamente transparente, ya que está en sys.path de forma predeterminada.

Puede poner someName.pth archivos someName.pth en site-packages . Estos archivos tienen el directorio en el que viven sus cosas reales reutilizables. Esto también es completamente transparente. Y no implica el paso adicional de instalar un cambio en site-packages .

Puede poner el directorio de las cosas reutilizables en PYTHONPATH . Eso es un poco menos transparente, porque debes asegurarte de que esté configurado. No ciencia de cohetes, pero no completamente transparente.

Answer 3

La forma más simple es establecer (o agregar) PYTHONPATH y poner (o enlazar) sus módulos y paquetes en una ruta contenida en PYTHONPATH.

Answer 4

Mi solución fue empaquetar una utilidad que importaría el módulo: my_util está en paquetes del sitio

import my_util

foo = myutil.import_script(''..//shared1//reusable_foo'')
if foo == None:
    sys.exit(1)


def import_script(script_path, log_status = True):
    """
    imports a module and returns the handle
    """
    lpath = os.path.split(script_path)

    if lpath[1] == '''':
        log(''Error in script "%s" in import_script'' % (script_path))
        return None


    #check if path is already in sys.path so we don''t repeat
    npath = None
    if lpath[0] == '''':
        npath = ''.''
    else:
        if lpath[0] not in sys.path:
            npath = lpath[0]

    if npath != None:
        try:
            sys.path.append(npath)
        except:
            if log_status == True:
                log(''Error adding path "%s" in import_script'' % npath)
            return None

    try:   
        mod =  __import__(lpath[1])
    except:
        error_trace,error_reason =  FormatExceptionInfo()
        if log_status == True:
            log(''Error importing "%s" module in import_script: %s'' % (script_path, error_trace + error_reason))
        sys.path.remove(npath)
        return None

    return mod

Answer 5

La respuesta simple es poner su código reutilizable en su directorio de paquetes de sitio, que se encuentra en su sys.path.

También puede ampliar la ruta de búsqueda agregando archivos .pth en algún lugar de su ruta. Consulte https://docs.python.org/2/install/#modifying-python-s-search-path para obtener más información.

Ah, y Python 2.6 / 3.0 agrega soporte para PEP370, Directorio de paquetes de sitios por usuario

Answer 6

Si sus archivos reutilizables están empaquetados (es decir, incluyen un archivo __init__.py ) y la ruta a ese paquete es parte de su PYTHONPATH o sys.path, entonces debería poder hacer solo

import Foo

Esta pregunta proporciona algunos detalles más.

(Nota: como dijo Jim, también podría colocar su código reutilizable en el directorio de site-packages su site-packages ).