missing method how docstrings python scripting metadata

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



missing method docstring (6)

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?

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)

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.

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.

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

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