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 gegevenssetquery's 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 werkbalkbrowser om een map voor de Python-modules aan te maken met de select-functie.

3. Klik op in de meest rechtse column van de geselecteerde map en klik op >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 tablete lezen, voert u het volgende in de editor in window:

   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 table met voorbereide gegevens wordt gemaakt, maakt u een nieuw bestand in dezelfde map, voert u een naam in voor het bestand, bijvoorbeeld clickstream_prepared_module.pyen voert u het volgende in de nieuwe editor in window:

   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 selectMaak een notitieblokof klik op Nieuw in de zijbalk en selectNotebook. 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 (
       spark.read.table("LIVE.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 spark.read.table(...)

# ...

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