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 DLT-pijplijnen. Zie Werken met Python- en R-modulesvoor 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 DLT-pijplijn configureren.

Een Python-module importeren in een DLT-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 werkruimtebrowser om een map voor de Python-modules te selecteren.

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

4. Voer een naam in voor het bestand, bijvoorbeeld 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, bijvoorbeeld clickstream_prepared_module.py, 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 notitieblok maken, of klik op Nieuw in de zijbalk en selecteer Notitieblok. U kunt het notitieblok ook maken in de werkruimtebrowser door te klikken op en op > Notitieblok makente klikken.

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

8. Klik op maken.

9. Voer de voorbeeldcode in het notebook in.

   Notitie

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

   Als u een bestand uit een Git-map importeert, moet u /Workspace/ aan het pad toevoegen. Bijvoorbeeld sys.path.append('/Workspace/...'). Als u /Workspace/ weglaat 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("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)
     )
   

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

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

11. Voer de pijplijn uit door op de pagina Pijplijndetails te klikken op Start.

U kunt python-code ook importeren als een pakket. Met het volgende codefragment uit een DLT-notebook importeert u het test_utils-pakket uit de dlt_packages map in dezelfde map als het notebook. De map dlt_packages bevat de bestanden test_utils.py en __init__.py, en test_utils.py definieert 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)