Importación de módulos de Python desde carpetas de Git o archivos de área de trabajo

Puede almacenar código de Python en carpetas de Git de Databricks o en archivos del área de trabajo y, a continuación, importar ese código de Python dentro de la canalización. Para obtener más información sobre cómo trabajar con módulos en carpetas de Git o archivos de área de trabajo, vea Trabajar con módulos de Python y R.

Para importar un archivo de Python, tiene varias opciones:

• Incluya el módulo de Python en la canalización como un archivo de utilidad. Esto funciona mejor si el módulo es específico de la canalización.
• Agregue un módulo compartido al entorno de canalización, en cualquier canalización que necesite usarla.
• Importe un módulo en el espacio de trabajo directamente en el código fuente de Python, con una import instrucción.

Incluir un módulo de Python en una canalización

Puede crear un módulo de Python como parte del pipeline. La carpeta raíz de la canalización se anexa automáticamente a sys.path. Esto le permite hacer referencia al módulo directamente en el código fuente de Python de la canalización.

En el ejemplo siguiente se muestra cómo crear un módulo de Python en la carpeta raíz de la canalización y hacer referencia a él desde un archivo de origen de Python en el origen de la canalización:

1. Abra la canalización en el editor de canalizaciones.

2. En el explorador de recursos de canalización de la izquierda, haga clic en Agregue y, a continuación, elija Utilidad en el menú.

3. Escriba my_utils.py como Nombre.

4. Deje la ruta de acceso predeterminada y haga clic en Crear.

   Esto crea el archivo my_utils.py en la carpeta utilities de canalización y crea la carpeta utilities, si no existe. Los archivos de esta carpeta no se agregan al origen de la canalización de forma predeterminada, pero están disponibles para llamarse desde los .py archivos que forman parte del código fuente.

   De forma predeterminada, el archivo de utilidad tiene una función de ejemplo denominada distance_km() que toma una distancia en millas y la convierte.

5. En un archivo de código fuente de Python en la carpeta de transformaciones (puede crear uno si elige Agregue y, a continuación, seleccione Transformación en el menú), agregue el código siguiente:

   from utilities import my_utils
   

Ahora puede llamar a funciones en my_utils desde ese archivo de Python. Debe agregar la import instrucción de cualquier archivo de Python que necesite invocar funciones del módulo.

Adición de un módulo de Python al entorno de canalización

Si desea compartir un módulo de Python en varias canalizaciones, puede guardar el módulo en cualquier parte de los archivos del área de trabajo y hacer referencia a él desde el entorno de cualquier canalización que necesite usarla. Puede hacer referencia a módulos de Python que son:

• Archivos individuales de Python (.py).
• Proyecto de Python empaquetado como un archivo de rueda de Python (.whl).
• Proyecto de Python sin empaquetar con un pyproject.toml archivo (para definir el nombre y la versión del proyecto).

En el ejemplo siguiente se muestra cómo agregar una dependencia a una canalización.

1. Abra la canalización en el editor de canalizaciones.

2. Haga clic en Configuración de la barra superior.

3. En la diapositiva Configuración del pipeline, en Entorno del pipeline, haga clic en Editar entorno.

4. Agregue una dependencia. Por ejemplo, para agregar un archivo en el área de trabajo, puede agregar /Volumes/libraries/path/to/python_files/file.py. En el caso de un Python wheel almacenado en carpetas de Git, la ruta de acceso podría ser similar a /Workspace/libraries/path/to/wheel_files/file.whl.

   Puede agregar un archivo sin especificar una ruta, o con una ruta relativa, si se encuentra en la carpeta raíz de la tubería.

Importación de un módulo de Python mediante la import instrucción

También puede hacer referencia directamente a un archivo de área de trabajo en el código fuente de Python.

• Si el archivo está en la carpeta de la utilities canalización, puede hacer referencia a él sin una ruta de acceso:

  from utilities import my_module
  

• Si el archivo está en cualquier otro lugar, puede importarlo anexando primero la ruta de acceso del módulo a sys.path:

  import sys, os
  sys.path.append(os.path.abspath('<module-path>'))
  
  from my_module import *
  

• También puede agregar a sys.path todos los archivos fuente de la canalización añadiendo la trayectoria al entorno de la canalización, según se describe en la sección anterior.

Ejemplo de importación de consultas como módulos de Python

En el ejemplo siguiente se muestra cómo importar consultas de conjunto de datos como módulos de Python desde archivos del área de trabajo. Aunque en este ejemplo se describe el uso de archivos de área de trabajo para almacenar el código fuente de la canalización, puede usarlo con código fuente almacenado en una carpeta git.

Para ejecutar este ejemplo, siga estos pasos:

1. Haga clic en Área de trabajo de la barra lateral del área de trabajo de Azure Databricks para abrir el explorador del área de trabajo.

2. Use el explorador del área de trabajo para seleccionar un directorio para los módulos de Python.

3. Haga clic en el en la columna situada más a la derecha del directorio seleccionado y haga clic en Crear > archivo.

4. Escriba un nombre para el archivo, por ejemplo, clickstream_raw_module.py. Se abre el editor de archivos. Para crear un módulo para leer los datos de origen en una tabla, escriba lo siguiente en la ventana del editor:

   from pyspark import pipelines as dp
   
   json_path = "/databricks-datasets/wikipedia-datasets/data-001/clickstream/raw-uncompressed-json/2015_2_clickstream.json"
   
   def create_clickstream_raw_table(spark):
     @dp.table
     def clickstream_raw():
       return (
         spark.read.json(json_path)
       )
   

5. Para crear un módulo que cree una nueva tabla que contenga datos preparados, cree un nuevo archivo en el mismo directorio, escriba un nombre para el archivo, por ejemplo, clickstream_prepared_module.pyy escriba lo siguiente en la nueva ventana del editor:

   from clickstream_raw_module import *
   from pyspark import pipelines as dp
   from pyspark.sql.functions import *
   from pyspark.sql.types import *
   
   def create_clickstream_prepared_table(spark):
     create_clickstream_raw_table(spark)
     @dp.table
     @dp.expect("valid_current_page_title", "current_page_title IS NOT NULL")
     @dp.expect_or_fail("valid_count", "click_count > 0")
     def clickstream_prepared():
       return (
         spark.read("clickstream_raw")
           .withColumn("click_count", expr("CAST(n AS INT)"))
           .withColumnRenamed("curr_title", "current_page_title")
           .withColumnRenamed("prev_title", "previous_page_title")
           .select("current_page_title", "click_count", "previous_page_title")
       )
   

6. A continuación, cree un archivo de Python en el origen de la canalización. En el editor de canalización, elija Agregue y luego transformación.

7. Asigne un nombre al archivo y confirme que Python es el lenguaje predeterminado.

8. Haga clic en Crear.

9. Escriba el código de ejemplo siguiente en el cuaderno.

   Nota:

   Si el cuaderno importa módulos o paquetes desde una ruta de acceso de archivos del área de trabajo o una ruta de acceso de carpetas de Git diferente del directorio del cuaderno, debe anexar manualmente la ruta de acceso a los archivos mediante sys.path.append().

   Si va a importar un archivo desde una carpeta Git, debe anteponer /Workspace/ a la ruta de acceso. Por ejemplo: sys.path.append('/Workspace/...'). Si se omite /Workspace/ de la ruta de acceso, se produce un error.

   Si los módulos o paquetes se almacenan en el mismo directorio que el cuaderno, no es necesario anexar la ruta de acceso manualmente. Tampoco es necesario anexar manualmente la ruta de acceso al importar desde el directorio raíz de una carpeta git porque el directorio raíz se anexa automáticamente a la ruta de acceso.

   import sys, os
   sys.path.append(os.path.abspath('<module-path>'))
   
   from pyspark import pipelines as dp
   from clickstream_prepared_module import *
   from pyspark.sql.functions import *
   from pyspark.sql.types import *
   
   create_clickstream_prepared_table(spark)
   
   @dp.table(
     comment="A table containing the top pages linking to the Apache Spark page."
   )
   def top_spark_referrers():
     return (
       spark.read.table("catalog_name.schema_name.clickstream_prepared")
         .filter(expr("current_page_title == 'Apache_Spark'"))
         .withColumnRenamed("previous_page_title", "referrer")
         .sort(desc("click_count"))
         .select("referrer", "click_count")
         .limit(10)
     )
   

   Reemplace por <module-path> la ruta de acceso al directorio que contiene los módulos de Python que se van a importar.

10. Para ejecutar la canalización, haga clic en Ejecutar canalización.