Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Python-Bibliotheken in Athena für Spark verwenden
**Anmerkung**
Diese Seite bezieht sich auf die Verwendung von Python-Bibliotheken in der Release-Version Pyspark Engine Version 3. Die Release-Version Apache Spark Version 3.5 basiert auf [Amazon EMR 7.12](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-7120-release.html). Informationen zu den in dieser Version enthaltenen Bibliotheken finden Sie in EMR 7.12.
Auf dieser Seite werden die verwendete Terminologie und das befolgte Lebenszyklusmanagement für die Laufzeiten, Bibliotheken und Pakete beschrieben, die in Amazon Athena für Apache Spark verwendet werden.
## Definitionen
+ **Amazon Athena for Apache Spark** (Amazon Athena für Apache Spark) ist eine benutzerdefinierte Version von Open Source Apache Spark. Um die aktuelle Version zu sehen, führen Sie den Befehl `print(f'{spark.version}')` in einer Notebookzelle aus.
+ Die **Athena runtime** (Athena-Laufzeit) ist die Umgebung, in der Ihr Code ausgeführt wird. Die Umgebung umfasst einen Python-Interpreter und PySpark Bibliotheken.
+ Eine **external library or package** (externe Bibliothek oder ein Paket) ist eine Java- oder Scala-JAR- oder Python-Bibliothek, die nicht Teil der Athena-Laufzeit ist, aber in Athena-für-Spark-Aufträge enthalten sein kann. Externe Pakete können von Amazon oder von Ihnen erstellt werden.
+ Ein **convenience package** (Convenience-Paket) ist eine Sammlung externer Pakete, die von Athena ausgewählt wurden und die Sie in Ihre Spark-Anwendungen aufnehmen können.
+ Ein **bundle** (Bundle) kombiniert die Athena-Laufzeit und ein Convenience-Paket.
+ Eine **user library** (Benutzerbibliothek) ist eine externe Bibliothek oder ein externes Paket, das Sie Ihrem Athena-für-Spark-Auftrag explizit hinzufügen.
+ Eine Benutzerbibliothek ist ein externes Paket, das nicht Teil eines Convenience-Pakets ist. Eine Benutzerbibliothek muss geladen und installiert werden. Wenn Sie beispielsweise einige `.py`-Dateien schreiben, komprimieren Sie sie und fügen Sie die `.zip`-Datei dann zu Ihrer Anwendung hinzu.
+ Eine **Athena for Spark application** (Athena-für-Spark-Anwendung) ist ein Auftrag oder eine Abfrage, die Sie an Athena für Spark senden.
## Lebenszyklusmanagement
In den folgenden Abschnitten werden die Richtlinien bezüglich Versionsverwaltung und Verfall für die Laufzeit- und Convenience-Pakete beschrieben, die in Athena für Spark verwendet werden.
### Versionsverwaltung und Veraltung zur Laufzeit
Die Hauptkomponente in der Athena-Laufzeit ist der Python-Interpreter. Da Python eine sich entwickelnde Sprache ist, werden regelmäßig neue Versionen veröffentlicht und die Unterstützung für ältere Versionen entfernt. Athena rät davon ab, Programme mit veralteten Versionen des Python-Interpreters auszuführen, und empfiehlt dringend, nach Möglichkeit die neueste Athena-Laufzeitumgebung zu verwenden.
Der Zeitplan für die Veraltung der Athena-Laufzeit sieht wie folgt aus:
1. Nachdem Athena eine neue Laufzeit bereitgestellt hat, unterstützt Athena die vorherige Laufzeit weiterhin für 6 Monate. Während dieser Zeit wendet Athena Sicherheitspatches und Updates auf die vorherige Laufzeit an.
1. Nach 6 Monaten beendet Athena die Unterstützung für die vorherige Laufzeit. Athena wendet keine Sicherheitspatches und andere Updates mehr auf die vorherige Laufzeit an. Spark-Anwendungen, die die vorherige Laufzeit verwenden, haben keinen Anspruch mehr auf technischen Support.
1. Nach 12 Monaten können Sie Spark-Anwendungen in einer Arbeitsgruppe, die die vorherige Laufzeit verwendet, nicht mehr aktualisieren oder bearbeiten. Wir empfehlen Ihnen, Ihre Spark-Anwendungen vor Ablauf dieses Zeitraums zu aktualisieren. Nach Ablauf des Zeitraums können Sie vorhandene Notebooks weiterhin ausführen, aber alle Notebooks, die noch die vorherige Laufzeit verwenden, protokollieren eine entsprechende Warnung.
1. Nach 18 Monaten können Sie in der Arbeitsgruppe keine Aufträge mehr mit der vorherigen Laufzeit ausführen.
### Versionsverwaltung und Veraltung von Convenience-Paketen
Der Inhalt von Convenience-Paketen ändert sich im Laufe der Zeit. Athena fügt diese Convenience-Pakete gelegentlich hinzu, entfernt oder aktualisiert sie.
Athena verwendet die folgenden Richtlinien für Convenience-Pakete:
+ Convenience-Pakete verfügen über ein einfaches Versionsverwaltungsschema wie 1, 2, 3.
+ Jede Version des Convenience-Pakets enthält spezifische Versionen externer Pakete. Nachdem Athena ein Convenience-Paket erstellt hat, ändern sich die externen Pakete des Convenience-Pakets und ihre entsprechenden Versionen nicht.
+ Athena erstellt eine neue Convenience-Paketversion, wenn es ein neues externes Paket enthält, ein externes Paket entfernt oder die Version eines oder mehrerer externer Pakete aktualisiert.
Athena markiert ein Convenience-Paket als veraltet, wenn es die vom Paket verwendete Athena-Laufzeit als veraltet markiert. Athena kann Pakete früher als veraltet markieren, um die Anzahl der unterstützten Bundles zu begrenzen.
Der Zeitplan für die Verwerfung von Convenience-Paketen folgt dem Zeitplan für die Verwerfung der Athena-Laufzeit.
# Liste der vorinstallierten Python-Bibliotheken
Zu den vorinstallierten Python-Bibliotheken gehören die folgenden.
```
boto3==1.24.31
botocore==1.27.31
certifi==2022.6.15
charset-normalizer==2.1.0
cycler==0.11.0
cython==0.29.30
docutils==0.19
fonttools==4.34.4
idna==3.3
jmespath==1.0.1
joblib==1.1.0
kiwisolver==1.4.4
matplotlib==3.5.2
mpmath==1.2.1
numpy==1.23.1
packaging==21.3
pandas==1.4.3
patsy==0.5.2
pillow==9.2.0
plotly==5.9.0
pmdarima==1.8.5
pyathena==2.9.6
pyparsing==3.0.9
python-dateutil==2.8.2
pytz==2022.1
requests==2.28.1
s3transfer==0.6.0
scikit-learn==1.1.1
scipy==1.8.1
seaborn==0.11.2
six==1.16.0
statsmodels==0.13.2
sympy==1.10.1
tenacity==8.0.1
threadpoolctl==3.1.0
urllib3==1.26.10
pyarrow==9.0.0
```
## Hinweise
+ MLlib (Apache Spark-Bibliothek für maschinelles Lernen) und das `pyspark.ml` Paket werden nicht unterstützt.
+ `pip install` wird derzeit in Athena für Spark-Sitzungen nicht unterstützt.
Weitere Informationen zum Importieren von Python-Bibliotheken in Amazon Athena für Apache Spark finden Sie unter [Dateien und Python-Bibliotheken in Amazon Athena für Spark importieren](notebooks-import-files-libraries.md).
# Dateien und Python-Bibliotheken in Amazon Athena für Spark importieren
Dieses Dokument enthält Beispiele für den Import von Dateien und Python-Bibliotheken in Amazon Athena für Apache Spark.
## Überlegungen und Einschränkungen
+ **Python-Version** – Derzeit verwendet Athena für Spark die Python-Version 3.9.16. Beachten Sie, dass Python-Pakete empfindlich auf Python-Nebenversionen reagieren.
+ **Athena for Spark-Architektur** — Athena for Spark verwendet Amazon Linux 2 für die Architektur. ARM64 Beachten Sie, dass einige Python-Bibliotheken keine Binärdateien für diese Architektur verteilen.
+ **Binäre gemeinsame Objekte (SOs)** — Da die SparkContext [addPyFile](https://spark.apache.org/docs/latest/api/python/reference/api/pyspark.SparkContext.addPyFile.html)Methode keine binären gemeinsamen Objekte erkennt, kann sie in Athena for Spark nicht verwendet werden, um Python-Pakete hinzuzufügen, die von gemeinsamen Objekten abhängen.
+ **Resilient Distributed Datasets (RDDs)** — [RDDs](https://spark.apache.org/docs/latest/api/python/reference/api/pyspark.RDD.html)werden nicht unterstützt.
+ **DataFrame.forEach — Die PySpark DataFrame .foreach-Methode** [wird nicht unterstützt.](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.DataFrame.foreach.html)
## Beispiele
In den Beispielen werden die folgenden Konventionen verwendet.
+ Der Platzhalter Amazon-S3-Speicherort `s3://amzn-s3-demo-bucket`. Ersetzen Sie dies durch Ihren eigenen S3-Bucket-Speicherort.
+ Alle Codeblöcke, die von einer Unix-Shell aus ausgeführt werden, werden als angezeigt. *directory\$1name* `$` Beispielsweise werden der Befehl `ls` im Verzeichnis `/tmp` und seine Ausgabe wie folgt angezeigt:
```
/tmp $ ls
```
**Ausgabe**
```
file1 file2
```
## Importieren von Textdateien zur Verwendung in Berechnungen
Die Beispiele in diesem Abschnitt veranschaulichen, wie Sie Textarchive für Berechnungen in Ihren Notebooks in Athena für Spark importieren.
### Hinzufügen einer Datei zu einem Notebook nachdem Sie sie in das lokale temporäre Verzeichnis schreiben
Das folgende Beispiel zeigt, wie eine Datei in ein lokales temporäres Verzeichnis geschrieben, einem Notebook hinzugefügt und getestet wird.
```
import os
from pyspark import SparkFiles
tempdir = '/tmp/'
path = os.path.join(tempdir, "test.txt")
with open(path, "w") as testFile:
_ = testFile.write("5")
sc.addFile(path)
def func(iterator):
with open(SparkFiles.get("test.txt")) as testFile:
fileVal = int(testFile.readline())
return [x * fileVal for x in iterator]
#Test the file
from pyspark.sql.functions import udf
from pyspark.sql.functions import col
udf_with_import = udf(func)
df = spark.createDataFrame([(1, "a"), (2, "b")])
df.withColumn("col", udf_with_import(col('_2'))).show()
```
**Ausgabe**
```
Calculation completed.
+---+---+-------+
| _1| _2| col|
+---+---+-------+
| 1| a|[aaaaa]|
| 2| b|[bbbbb]|
+---+---+-------+
```
### Importieren einer Datei aus Amazon S3
Das folgende Beispiel zeigt, wie Sie eine Datei aus Amazon S3 in ein Notebook importieren und testen.
**Importieren einer Datei aus Amazon S3 in ein Notebook**
1. Erstellen Sie eine Datei mit dem Namen `test.txt`, die eine einzelne Zeile mit dem Wert `5` enthält.
1. Fügen Sie die Datei einem Bucket in Amazon S3 hinzu. In diesem Beispiel wird der Speicherort `s3://amzn-s3-demo-bucket` verwendet.
1. Verwenden Sie den folgenden Code, um die Datei in Ihr Notebook zu importieren und die Datei zu testen.
```
from pyspark import SparkFiles
sc.addFile('s3://amzn-s3-demo-bucket/test.txt')
def func(iterator):
with open(SparkFiles.get("test.txt")) as testFile:
fileVal = int(testFile.readline())
return [x * fileVal for x in iterator]
#Test the file
from pyspark.sql.functions import udf
from pyspark.sql.functions import col
udf_with_import = udf(func)
df = spark.createDataFrame([(1, "a"), (2, "b")])
df.withColumn("col", udf_with_import(col('_2'))).show()
```
**Ausgabe**
```
Calculation completed.
+---+---+-------+
| _1| _2| col|
+---+---+-------+
| 1| a|[aaaaa]|
| 2| b|[bbbbb]|
+---+---+-------+
```
## Python-Dateien hinzufügen
Die Beispiele in diesem Abschnitt zeigen, wie Sie Ihren Spark-Notebooks in Athena-Python-Dateien und -Bibliotheken hinzufügen.
### Hinzufügen von Python-Dateien und Registrieren einer UDF
Das folgende Beispiel zeigt, wie Sie Python-Dateien aus Amazon S3 zu Ihrem Notebook hinzufügen und eine UDF registrieren.
**So fügen Sie Ihrem Notebook Python-Dateien hinzu und registrieren eine UDF**
1. Verwenden Sie Ihren eigenen Amazon-S3-Speicherort und erstellen Sie die Datei `s3://amzn-s3-demo-bucket/file1.py` mit dem folgenden Inhalt:
```
def xyz(input):
return 'xyz - udf ' + str(input);
```
1. Erstellen Sie am selben S3-Speicherort die Datei `s3://amzn-s3-demo-bucket/file2.py` mit dem folgenden Inhalt:
```
from file1 import xyz
def uvw(input):
return 'uvw -> ' + xyz(input);
```
1. Führen Sie in Ihrem Athena-for-Spark-Notebook die folgenden Befehle aus.
```
sc.addPyFile('s3://amzn-s3-demo-bucket/file1.py')
sc.addPyFile('s3://amzn-s3-demo-bucket/file2.py')
def func(iterator):
from file2 import uvw
return [uvw(x) for x in iterator]
from pyspark.sql.functions import udf
from pyspark.sql.functions import col
udf_with_import = udf(func)
df = spark.createDataFrame([(1, "a"), (2, "b")])
df.withColumn("col", udf_with_import(col('_2'))).show(10)
```
**Ausgabe**
```
Calculation started (calculation_id=1ec09e01-3dec-a096-00ea-57289cdb8ce7) in (session=c8c09e00-6f20-41e5-98bd-4024913d6cee). Checking calculation status...
Calculation completed.
+---+---+--------------------+
| _1| _2| col|
+---+---+--------------------+
| 1 | a|[uvw -> xyz - ud... |
| 2 | b|[uvw -> xyz - ud... |
+---+---+--------------------+
```
### Importieren einer Python-ZIP-Datei
Sie können die Python-Methoden `addPyFile` und `import` verwenden, um eine Python-ZIP-Datei in Ihr Notebook zu importieren.
**Anmerkung**
Die `.zip`-Dateien, die Sie in Athena Spark importieren, enthalten möglicherweise nur Python-Pakete. Beispielsweise wird das Einbeziehen von Paketen mit C-basierten Dateien nicht unterstützt.
**So importieren Sie eine `.zip`-Python-Datei in Ihr Notebook**
1. Erstellen Sie auf Ihrem lokalen Computer in einem Desktop-Verzeichnis wie z. B. `\tmp` ein Verzeichnis mit dem Namen `moduletest`.
1. Erstellen Sie im Verzeichnis `moduletest` eine Datei namens `hello.py` mit folgendem Inhalt:
```
def hi(input):
return 'hi ' + str(input);
```
1. Fügen Sie im selben Verzeichnis eine leere Datei mit dem Namen `__init__.py` hinzu.
Wenn Sie die Verzeichnisinhalte auflisten, sollten diese jetzt wie folgt aussehen.
```
/tmp $ ls moduletest
__init__.py hello.py
```
1. Verwenden Sie den `zip`-Befehl, um die beiden Moduldateien in einer Datei mit dem Namen `moduletest.zip` zu platzieren.
```
moduletest $ zip -r9 ../moduletest.zip *
```
1. Laden Sie die `.zip`-Datei in Ihren Bucket in Amazon S3 hoch.
1. Verwenden Sie den folgenden Code, um die `.zip`-Python-Datei in Ihr Notebook zu importieren.
```
sc.addPyFile('s3://amzn-s3-demo-bucket/moduletest.zip')
from moduletest.hello import hi
from pyspark.sql.functions import udf
from pyspark.sql.functions import col
hi_udf = udf(hi)
df = spark.createDataFrame([(1, "a"), (2, "b")])
df.withColumn("col", hi_udf(col('_2'))).show()
```
**Ausgabe**
```
Calculation started (calculation_id=6ec09e8c-6fe0-4547-5f1b-6b01adb2242c) in (session=dcc09e8c-3f80-9cdc-bfc5-7effa1686b76). Checking calculation status...
Calculation completed.
+---+---+----+
| _1| _2| col|
+---+---+----+
| 1| a|hi a|
| 2| b|hi b|
+---+---+----+
```
### Importieren von zwei Versionen einer Python-Bibliothek als separate Module
Die folgenden Codebeispiele zeigen, wie Sie zwei verschiedene Versionen einer Python-Bibliothek von einem Speicherort in Amazon S3 als zwei separate Module hinzufügen und importieren. Der Code fügt jeweils die Bibliotheksdatei aus S3 hinzu, importiert sie und gibt dann die Bibliotheksversion aus, um den Import zu überprüfen.
```
sc.addPyFile('s3://amzn-s3-demo-bucket/python-third-party-libs-test/simplejson_v3_15.zip')
sc.addPyFile('s3://amzn-s3-demo-bucket/python-third-party-libs-test/simplejson_v3_17_6.zip')
import simplejson_v3_15
print(simplejson_v3_15.__version__)
```
**Ausgabe**
```
3.15.0
```
```
import simplejson_v3_17_6
print(simplejson_v3_17_6.__version__)
```
**Ausgabe**
```
3.17.6
```
### Importieren einer Python-ZIP-Datei aus PyPI
In diesem Beispiel wird der `pip`-Befehl verwendet, um eine Python-ZIP-Datei des Projekts [bpabel/piglatin](https://github.com/bpabel/piglatin) aus dem [Python Package Index (PyPI)](https://pypi.org/) herunterzuladen.
**So importieren Sie eine Python-ZIP-Datei aus PyPI**
1. Verwenden Sie auf Ihrem lokalen Desktop die folgenden Befehle, um ein Verzeichnis mit dem Namen `testpiglatin` zu erstellen und eine virtuelle Umgebung zu erstellen.
```
/tmp $ mkdir testpiglatin
/tmp $ cd testpiglatin
testpiglatin $ virtualenv .
```
**Ausgabe**
```
created virtual environment CPython3.9.6.final.0-64 in 410ms
creator CPython3Posix(dest=/private/tmp/testpiglatin, clear=False, no_vcs_ignore=False, global=False)
seeder FromAppData(download=False, pip=bundle, setuptools=bundle, wheel=bundle, via=copy, app_data_dir=/Users/user1/Library/Application Support/virtualenv)
added seed packages: pip==22.0.4, setuptools==62.1.0, wheel==0.37.1
activators BashActivator,CShellActivator,FishActivator,NushellActivator,PowerShellActivator,PythonActivator
```
1. Erstellen Sie ein Unterverzeichnis mit dem Namen `unpacked`, um das Projekt zu speichern.
```
testpiglatin $ mkdir unpacked
```
1. Verwenden Sie den `pip`-Befehl, um das Projekt in das `unpacked`-Verzeichnis zu installieren.
```
testpiglatin $ bin/pip install -t $PWD/unpacked piglatin
```
**Ausgabe**
```
Collecting piglatin
Using cached piglatin-1.0.6-py2.py3-none-any.whl (3.1 kB)
Installing collected packages: piglatin
Successfully installed piglatin-1.0.6
```
1. Überprüfen Sie den Inhalt des Verzeichnisses.
```
testpiglatin $ ls
```
**Ausgabe**
```
bin lib pyvenv.cfg unpacked
```
1. Wechseln Sie in das `unpacked`-Verzeichnis und zeigen Sie den Inhalt an.
```
testpiglatin $ cd unpacked
unpacked $ ls
```
**Ausgabe**
```
piglatin piglatin-1.0.6.dist-info
```
1. Verwenden Sie den `zip`-Befehl, um den Inhalt des Piglatin-Projekts in einer Datei mit dem Namen `library.zip` zu platzieren.
```
unpacked $ zip -r9 ../library.zip *
```
**Ausgabe**
```
adding: piglatin/ (stored 0%)
adding: piglatin/__init__.py (deflated 56%)
adding: piglatin/__pycache__/ (stored 0%)
adding: piglatin/__pycache__/__init__.cpython-39.pyc (deflated 31%)
adding: piglatin-1.0.6.dist-info/ (stored 0%)
adding: piglatin-1.0.6.dist-info/RECORD (deflated 39%)
adding: piglatin-1.0.6.dist-info/LICENSE (deflated 41%)
adding: piglatin-1.0.6.dist-info/WHEEL (deflated 15%)
adding: piglatin-1.0.6.dist-info/REQUESTED (stored 0%)
adding: piglatin-1.0.6.dist-info/INSTALLER (stored 0%)
adding: piglatin-1.0.6.dist-info/METADATA (deflated 48%)
```
1. (Optional) Verwenden Sie die folgenden Befehle, um den Import lokal zu testen.
1. Legen Sie den Python-Pfad auf den Speicherort der `library.zip`-Datei fest und starten Sie Python.
```
/home $ PYTHONPATH=/tmp/testpiglatin/library.zip
/home $ python3
```
**Ausgabe**
```
Python 3.9.6 (default, Jun 29 2021, 06:20:32)
[Clang 12.0.0 (clang-1200.0.32.29)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
```
1. Importieren Sie die Bibliothek und führen Sie einen Testbefehl aus.
```
>>> import piglatin
>>> piglatin.translate('hello')
```
**Ausgabe**
```
'ello-hay'
```
1. Verwenden Sie Befehle wie die folgenden, um die `.zip`-Datei aus Amazon S3 hinzuzufügen, sie in Ihr Notebook in Athena zu importieren und zu testen.
```
sc.addPyFile('s3://amzn-s3-demo-bucket/library.zip')
import piglatin
piglatin.translate('hello')
from pyspark.sql.functions import udf
from pyspark.sql.functions import col
hi_udf = udf(piglatin.translate)
df = spark.createDataFrame([(1, "hello"), (2, "world")])
df.withColumn("col", hi_udf(col('_2'))).show()
```
**Ausgabe**
```
Calculation started (calculation_id=e2c0a06e-f45d-d96d-9b8c-ff6a58b2a525) in (session=82c0a06d-d60e-8c66-5d12-23bcd55a6457). Checking calculation status...
Calculation completed.
+---+-----+--------+
| _1| _2| col|
+---+-----+--------+
| 1|hello|ello-hay|
| 2|world|orld-way|
+---+-----+--------+
```
### Importieren einer Python-ZIP-Datei aus PyPI mit Abhängigkeiten
In diesem Beispiel wird das [md2gemini](https://github.com/makeworld-the-better-one/md2gemini)-Paket, das Text im Markdown in das [Gemini](https://gemini.circumlunar.space/)-Textformat konvertiert, aus PyPI importiert. Das Paket weist folgende [Abhängigkeiten](https://libraries.io/pypi/md2gemini) auf:
```
cjkwrap
mistune
wcwidth
```
**So importieren Sie eine Python-ZIP-Datei mit Abhängigkeiten**
1. Verwenden Sie auf Ihrem lokalen Computer die folgenden Befehle, um ein Verzeichnis mit dem Namen `testmd2gemini` zu erstellen und eine virtuelle Umgebung zu erstellen.
```
/tmp $ mkdir testmd2gemini
/tmp $ cd testmd2gemini
testmd2gemini$ virtualenv .
```
1. Erstellen Sie ein Unterverzeichnis mit dem Namen `unpacked`, um das Projekt zu speichern.
```
testmd2gemini $ mkdir unpacked
```
1. Verwenden Sie den `pip`-Befehl, um das Projekt in das `unpacked`-Verzeichnis zu installieren.
```
/testmd2gemini $ bin/pip install -t $PWD/unpacked md2gemini
```
**Ausgabe**
```
Collecting md2gemini
Downloading md2gemini-1.9.0-py3-none-any.whl (31 kB)
Collecting wcwidth
Downloading wcwidth-0.2.5-py2.py3-none-any.whl (30 kB)
Collecting mistune<3,>=2.0.0
Downloading mistune-2.0.2-py2.py3-none-any.whl (24 kB)
Collecting cjkwrap
Downloading CJKwrap-2.2-py2.py3-none-any.whl (4.3 kB)
Installing collected packages: wcwidth, mistune, cjkwrap, md2gemini
Successfully installed cjkwrap-2.2 md2gemini-1.9.0 mistune-2.0.2 wcwidth-0.2.5
...
```
1. Wechseln Sie in das `unpacked`-Verzeichnis und überprüfen Sie den Inhalt.
```
testmd2gemini $ cd unpacked
unpacked $ ls -lah
```
**Ausgabe**
```
total 16
drwxr-xr-x 13 user1 wheel 416B Jun 7 18:43 .
drwxr-xr-x 8 user1 wheel 256B Jun 7 18:44 ..
drwxr-xr-x 9 user1 staff 288B Jun 7 18:43 CJKwrap-2.2.dist-info
drwxr-xr-x 3 user1 staff 96B Jun 7 18:43 __pycache__
drwxr-xr-x 3 user1 staff 96B Jun 7 18:43 bin
-rw-r--r-- 1 user1 staff 5.0K Jun 7 18:43 cjkwrap.py
drwxr-xr-x 7 user1 staff 224B Jun 7 18:43 md2gemini
drwxr-xr-x 10 user1 staff 320B Jun 7 18:43 md2gemini-1.9.0.dist-info
drwxr-xr-x 12 user1 staff 384B Jun 7 18:43 mistune
drwxr-xr-x 8 user1 staff 256B Jun 7 18:43 mistune-2.0.2.dist-info
drwxr-xr-x 16 user1 staff 512B Jun 7 18:43 tests
drwxr-xr-x 10 user1 staff 320B Jun 7 18:43 wcwidth
drwxr-xr-x 9 user1 staff 288B Jun 7 18:43 wcwidth-0.2.5.dist-info
```
1. Verwenden Sie den `zip`-Befehl, um den Inhalt des md2gemini-Projekts in einer Datei mit dem Namen `md2gemini.zip` zu platzieren.
```
unpacked $ zip -r9 ../md2gemini *
```
**Ausgabe**
```
adding: CJKwrap-2.2.dist-info/ (stored 0%)
adding: CJKwrap-2.2.dist-info/RECORD (deflated 37%)
....
adding: wcwidth-0.2.5.dist-info/INSTALLER (stored 0%)
adding: wcwidth-0.2.5.dist-info/METADATA (deflated 62%)
```
1. (Optional) Verwenden Sie die folgenden Befehle, um zu testen, ob die Bibliothek auf Ihrem lokalen Computer funktioniert.
1. Legen Sie den Python-Pfad auf den Speicherort der `md2gemini.zip`-Datei fest und starten Sie Python.
```
/home $ PYTHONPATH=/tmp/testmd2gemini/md2gemini.zip
/home python3
```
1. Importieren Sie die Bibliothek und führen Sie einen Test durch.
```
>>> from md2gemini import md2gemini
>>> print(md2gemini('[abc](https://abc.def)'))
```
**Ausgabe**
```
https://abc.def abc
```
1. Verwenden Sie die folgenden Befehle, um die `.zip`-Datei aus Amazon S3 hinzuzufügen, diese in Ihr Notebook in Athena zu importieren und einen Nicht-UDF-Test durchzuführen.
```
# (non udf test)
sc.addPyFile('s3://amzn-s3-demo-bucket/md2gemini.zip')
from md2gemini import md2gemini
print(md2gemini('[abc](https://abc.def)'))
```
**Ausgabe**
```
Calculation started (calculation_id=0ac0a082-6c3f-5a8f-eb6e-f8e9a5f9bc44) in (session=36c0a082-5338-3755-9f41-0cc954c55b35). Checking calculation status...
Calculation completed.
=> https://abc.def (https://abc.def/) abc
```
1. Verwenden Sie die folgenden Befehle, um einen UDF-Test durchzuführen.
```
# (udf test)
from pyspark.sql.functions import udf
from pyspark.sql.functions import col
from md2gemini import md2gemini
hi_udf = udf(md2gemini)
df = spark.createDataFrame([(1, "[first website](https://abc.def)"), (2, "[second website](https://aws.com)")])
df.withColumn("col", hi_udf(col('_2'))).show()
```
**Ausgabe**
```
Calculation started (calculation_id=60c0a082-f04d-41c1-a10d-d5d365ef5157) in (session=36c0a082-5338-3755-9f41-0cc954c55b35). Checking calculation status...
Calculation completed.
+---+--------------------+--------------------+
| _1| _2| col|
+---+--------------------+--------------------+
| 1|[first website](h...|=> https://abc.de...|
| 2|[second website](...|=> https://aws.co...|
+---+--------------------+--------------------+
```