Python-modules importeren uit Git-mappen of werkruimtebestanden

U kunt Python-code opslaan in Databricks Git-mappen of in werkruimtebestanden en die Python-code vervolgens importeren in uw Delta Live Tables-pijplijnen. Zie Werken met Python- en R-modules voor meer informatie over het werken met modules in Git-mappen of werkruimtebestanden.

Notitie

U kunt de broncode niet importeren uit een notebook dat is opgeslagen in een Databricks Git-map of een werkruimtebestand. Voeg in plaats daarvan het notitieblok rechtstreeks toe wanneer u een pijplijn maakt of bewerkt. Zie Een Delta Live Tables-pijplijn configureren.

Een Python-module importeren in een Delta Live Tables-pijplijn

In het volgende voorbeeld ziet u hoe u query's voor gegevenssets importeert als Python-modules uit werkruimtebestanden. Hoewel in dit voorbeeld wordt beschreven hoe u werkruimtebestanden gebruikt om de broncode van de pijplijn op te slaan, kunt u deze gebruiken met broncode die is opgeslagen in een Git-map.

Voer de volgende stappen uit om dit voorbeeld uit te voeren:

1. Klik op Werkruimte in de zijbalk van uw Azure Databricks-werkruimte om de werkruimtebrowser te openen.

2. Gebruik de werkruimtebrowser om een map voor de Python-modules te selecteren.

3. Klik in de meest rechtse kolom van de geselecteerde map en klik op Bestand maken>.

4. Voer bijvoorbeeld een naam in voor het bestand clickstream_raw_module.py. De bestandseditor wordt geopend. Als u een module wilt maken om brongegevens in een tabel te lezen, voert u het volgende in het editorvenster in:

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

5. Als u een module wilt maken waarmee een nieuwe tabel met voorbereide gegevens wordt gemaakt, maakt u een nieuw bestand in dezelfde map, voert u een naam in voor het bestand, clickstream_prepared_module.pybijvoorbeeld en voert u het volgende in het nieuwe editorvenster in:

   from clickstream_raw_module import *
   from dlt import read
   from pyspark.sql.functions import *
   from pyspark.sql.types import *
   
   def create_clickstream_prepared_table(spark):
     create_clickstream_raw_table(spark)
     @table
     @expect("valid_current_page_title", "current_page_title IS NOT NULL")
     @expect_or_fail("valid_count", "click_count > 0")
     def clickstream_prepared():
       return (
         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. Maak vervolgens een pijplijnnotebook. Ga naar de landingspagina van Azure Databricks en selecteer Een notebook maken of klik op Nieuw in de zijbalk en selecteer Notebook. U kunt het notitieblok ook maken in de werkruimtebrowser door te klikken en op Notitieblok maken > te klikken.

7. Geef uw notebook een naam en controleer of Python de standaardtaal is.

8. Klik op Create.

9. Voer de voorbeeldcode in het notebook in.

   Notitie

   Als uw notebook modules of pakketten importeert vanuit een pad naar werkruimtebestanden of een Ander Pad naar Git-mappen dan de notebookmap, moet u het pad handmatig toevoegen aan de bestanden met behulp van sys.path.append().

   Als u een bestand uit een Git-map importeert, moet u naar het pad gaan /Workspace/ . Bijvoorbeeld: sys.path.append('/Workspace/...'). Als u weglaat /Workspace/ uit het pad, treedt er een fout op.

   Als de modules of pakketten zijn opgeslagen in dezelfde map als het notebook, hoeft u het pad niet handmatig toe te voegen. U hoeft het pad ook niet handmatig toe te voegen bij het importeren uit de hoofdmap van een Git-map, omdat de hoofdmap automatisch aan het pad wordt toegevoegd.

   import sys, os
   # You can omit the sys.path.append() statement when the imports are from the same directory as the notebook.
   sys.path.append(os.path.abspath('<module-path>'))
   
   import dlt
   from clickstream_prepared_module import *
   from pyspark.sql.functions import *
   from pyspark.sql.types import *
   
   create_clickstream_prepared_table(spark)
   
   @dlt.table(
     comment="A table containing the top pages linking to the Apache Spark page."
   )
   def top_spark_referrers():
     return (
       dlt.read("clickstream_prepared")
         .filter(expr("current_page_title == 'Apache_Spark'"))
         .withColumnRenamed("previous_page_title", "referrer")
         .sort(desc("click_count"))
         .select("referrer", "click_count")
         .limit(10)
     )
   

   Vervang <module-path> door het pad naar de map die de Python-modules bevat die moeten worden geïmporteerd.

10. Maak een pijplijn met behulp van het nieuwe notebook.

11. Als u de pijplijn wilt uitvoeren, klikt u op de pagina Pijplijndetails op Start.

U kunt python-code ook importeren als een pakket. Met het volgende codefragment uit een Delta Live Tables-notebook importeert u het test_utils pakket uit de dlt_packages map in dezelfde map als het notebook. De dlt_packages map bevat de bestanden test_utils.py en __init__.pydefinieert test_utils.py de functie create_test_table():

import dlt

@dlt.table
def my_table():
  return dlt.read(...)

# ...

import dlt_packages.test_utils as test_utils
test_utils.create_test_table(spark)