So erstellen und veröffentlichen Sie Python-Pakete mit Poetry

Ein Python-Paket ist eine Sammlung von Python-Modulen, die einfach verteilt und installiert werden können. Es ermöglicht Entwicklern, Code in mehreren Projekten wiederzuverwenden und mit anderen zu teilen.

Python-Pakete enthalten typischerweise eine Reihe von Funktionen, Klassen oder anderen Komponenten, die einem bestimmten Zweck dienen, beispielsweise Datenanalyse, Webentwicklung oder maschinelles Lernen.

Möglicherweise haben Sie integrierte Python-Pakete wie os, sys oder math oder externe Abhängigkeiten wie requests verwendet. , pandas oder numpy in Ihren Python-Projekten.

Das Tutorial führt Sie durch den Prozess der Erstellung und Veröffentlichung eines Python-Pakets mit Poetry. Sie erstellen ein Telefonnummernvalidierungspaket, um zu überprüfen, ob eine bestimmte Telefonnummer gültig ist. Unterwegs erfahren Sie, wie Sie mit Poetry Abhängigkeiten verwalten, Paketkonfigurationen definieren und Tests für das Paket schreiben.

Am Ende dieses Tutorials sollten Sie ein gutes Verständnis dafür haben, wie Sie Poetry zum Erstellen und Veröffentlichen Ihrer eigenen Python-Pakete verwenden.

Was ist Poesie?

Poetry ist ein modernes Tool zur Paketverwaltung in Python, das den Prozess der Erstellung, Verwaltung und Veröffentlichung von Python-Paketen vereinfacht.

Es bietet eine benutzerfreundliche Befehlszeilenschnittstelle zum Verwalten von Abhängigkeiten, zum Erstellen von Paketen und deren Veröffentlichung in PyPI (Python Package Index), dem offiziellen Repository für Python-Pakete.

Die Verwendung von Poetry für die Paketverwaltung in Python bietet mehrere Vorteile:

• Abhängigkeitsauflösung: Es verwaltet automatisch Abhängigkeiten und stellt sicher, dass Ihr Paket mit anderen Paketen in Ihrem Projekt kompatibel ist.
• Virtuelle Umgebungen: Es erstellt eine virtuelle Umgebung für Ihr Projekt, die es Ihnen ermöglicht, Ihr Paket und seine Abhängigkeiten vom Rest Ihres Systems zu isolieren.
• Projektgerüst: Es bietet eine einfache Befehlszeilenschnittstelle zum Erstellen neuer Python-Projekte und zum Einrichten ihrer Grundstruktur.
• Integrierte Erstellung und Paketierung: Es bietet Tools zum Erstellen verteilbarer Pakete in verschiedenen Formaten, einschließlich Quelldistributionen, Wheel-Distributionen und Binärdistributionen.
• Veröffentlichen auf PyPI: Es erleichtert die Veröffentlichung Ihres Pakets auf PyPI, sodass andere Entwickler Ihr Paket problemlos installieren und verwenden können.

Insgesamt bietet Poetry eine einfache und intuitive Schnittstelle zum Verwalten von Abhängigkeiten, zum Erstellen von Paketen und deren Veröffentlichung in PyPI. Wenn Sie an einem Python-Projekt arbeiten, das eine Paketverwaltung erfordert, ist Poetry auf jeden Fall einen Blick wert.

Voraussetzungen

Um diesem Tutorial folgen zu können, wird empfohlen, dass Sie über Folgendes verfügen:

• Python 3.7+ installiert
• Grundlegendes Verständnis virtueller Umgebungen, Module und Pakete
• Grundkenntnisse in Requests und PyTest

Die in diesem Tutorial verwendeten Codebeispiele finden Sie in diesem Repository.

So richten Sie das Projekt ein

Bevor Sie mit der Erstellung Ihres Python-Pakets beginnen können, müssen Sie Ihre Entwicklungsumgebung einrichten. Dazu gehört die Installation von Poetry, das Erstellen eines neuen Projekts und das Konfigurieren der Projektabhängigkeiten.

So installieren Sie Poesie

Poetry ist ein plattformübergreifender Paketmanager und Build-Tool, das auf verschiedenen Betriebssystemen installiert werden kann, darunter Linux, macOS und Windows.

Es verfügt über ein benutzerdefiniertes Installationsprogramm, das eine dedizierte virtuelle Umgebung für Poetry erstellt, die sicherstellt, dass es unabhängig vom Rest des Systems funktioniert. Diese isolierte Umgebung verhindert unbeabsichtigte Upgrades oder Entfernungen von Abhängigkeiten und ermöglicht es Poetry, seine Abhängigkeiten effizienter zu verwalten.

Um Poetry zu installieren, müssen Sie zunächst das Terminal oder die Eingabeaufforderung öffnen, je nachdem, welches Betriebssystem Sie verwenden.

Für Windows-Benutzer öffnen Sie Windows Powershell und führen Sie den folgenden Befehl aus:

(Invoke-WebRequest -Uri https://install.python-poetry.org -UseBasicParsing).Content | py -

Für Benutzer von Linux, macOS und Windows Subsystem for Linux (WSL) öffnen Sie das Terminal und führen Sie den folgenden Befehl aus:

curl -sSL https://install.python-poetry.org | python3 -

Beachten Sie, dass sich der Befehl python auf einigen Systemen möglicherweise auf Python 2 statt auf Python 3 bezieht. Um Unklarheiten zu vermeiden, wird empfohlen, stattdessen die Binärdatei python3 zu verwenden.

Sobald der Installationsvorgang abgeschlossen ist, können Sie überprüfen, ob Poetry korrekt installiert wurde, indem Sie den folgenden Befehl ausführen:

poetry --version

Wenn eine Ausgabe ähnlich der von Poetry (version 1.4.1) angezeigt wird, ist Ihre Installation abgeschlossen und einsatzbereit.

So erstellen Sie ein neues Projekt

Um ein neues Poetry-Projekt zu erstellen, können Sie den Befehl new gefolgt vom Namen des Projekts verwenden. Wenn Sie beispielsweise ein Paket zur Validierung von Telefonnummern erstellen möchten, können Sie den folgenden Befehl verwenden:

poetry new phone-number-validator

Dadurch wird ein neuer Ordner namens phone-number-validator mit der folgenden Struktur erstellt:

phone-number-validator
├── pyproject.toml
├── README.md
├── phone_number_validator
│   └── __init__.py
└── tests
     └── __init__.py

Der Ordner phone-number-validator enthält zwei Dateien: pyproject.toml und README.md sowie zwei Pakete: phone_number_validator zum Speichern der Quellcodedateien und tests zum Speichern der Testdateien.

Grundlegendes zur Datei pyproject.toml

Die Datei pyproject.toml dient als Konfigurationsdatei für ein Poetry-Projekt und enthält Informationen über das Projekt und seine Abhängigkeiten. Die Datei enthält standardmäßig drei Tabellen – tool.poetry, tool.poetry.dependencies und build-system.

[tool.poetry]
name = "phone-number-validator"
version = "0.1.0"
description = ""
authors = ["Ashutosh Krishna <ashutoshbritish@gmail.com>"]
readme = "README.md"
packages = [{include = "phone_number_validator"}]

Die Tabelle tool.poetry in der Datei pyproject.toml verfügt über mehrere Schlüssel/Wert-Paare mit name, version , description und authors sind erforderlich, während andere optional sind.

Poetry geht davon aus, dass sich ein Paket mit demselben Namen wie der in der Datei pyproject.toml angegebene tool.poetry.name im Stammverzeichnis des Projekts befindet. Wenn der Paketspeicherort jedoch unterschiedlich ist, können die Pakete und ihre Speicherorte im Schlüssel tool.poetry.packages angegeben werden.

[tool.poetry.dependencies]
python = "^3.11"

In der Tabelle tool.poetry.dependencies muss unbedingt die Python-Version angegeben werden, mit der das Paket kompatibel ist.

[build-system]
requires = ["poetry-core"]
build-backend = "poetry.core.masonry.api"

Die letzte Tabelle, build-system, hat zwei Schlüssel – requires und build-backend. Der Schlüssel requires ist eine Liste der Abhängigkeiten, die zum Erstellen des Pakets erforderlich sind, während der Schlüssel build-backend das Python-Objekt ist, das zum Durchführen des Erstellungsprozesses verwendet wird.

TOML ist das bevorzugte Konfigurationsformat von Poetry, und ab Version 3.11 stellt Python das Modul tomllib zum Parsen von TOML-Dateien bereit.

Derzeit sieht die Datei pyproject.toml so aus.

So erstellen Sie eine neue virtuelle Umgebung

Poetry vereinfacht die Erstellung virtueller Umgebungen für Ihre Projekte. Um eine virtuelle Umgebung für Ihre phone-number-validator-Bibliothek zu erstellen, navigieren Sie zu Ihrem Projektverzeichnis und führen Sie den Befehl env use aus:

poetry env use /full/path/to/python

Der /full/path/to/python gibt den vollständigen Pfad zur ausführbaren Python-Datei an.

Zum Beispiel in MacOS:

poetry env use /usr/local/bin/python3.11

Unter Windows:

poetry env use "C:\Users\ashut\AppData\Local\Programs\Python\Python311\python.exe"

So konfigurieren Sie Projektabhängigkeiten

Nachdem Sie Ihr Poetry-Projekt eingerichtet haben, besteht der nächste Schritt darin, die erforderlichen Abhängigkeiten zu installieren.

Da Sie mit einem externen Webdienst interagieren, ist die erste Abhängigkeit, die Sie benötigen, requests. Um diese Abhängigkeit zu installieren, stellt Poetry einen add-Befehl zur Verfügung, der sich um die korrekte Installation des Pakets, die Definition von Versionseinschränkungen und die Aktualisierung der Datei pyproject.toml mit den entsprechenden Informationen kümmert.

poetry add requests

Sobald die Abhängigkeit installiert ist, wird die hinzugefügte Abhängigkeit in der Tabelle tool.poetry.dependencies in Ihrer Datei pyproject.toml angezeigt.

[tool.poetry.dependencies]
python = "^3.11"
requests = "^2.28.2"

Die Datei poetry.lock

Die Datei poetry.lock dient als Aufzeichnung aller genauen Versionen der Abhängigkeiten, die in einem Projekt während der Installation, Entfernung oder Aktualisierung einer Abhängigkeit verwendet werden. Es stellt sicher, dass Ihr Projekt die richtigen Versionen von Abhängigkeiten verwendet, indem es alle Pakete, ihre genauen Versionen und die Hashes ihrer Quelldateien auflistet.

Sobald Sie die requests-Bibliothek installiert haben, wird die Datei poetry.lock aktualisiert, um die genaue Version und den Hash der installierten Abhängigkeit aufzuzeichnen. Wenn Sie Ihrem Projekt weitere Abhängigkeiten hinzufügen, werden in dieser Datei alle Änderungen nachverfolgt.

Es ist wichtig, die Datei poetry.lock Ihrer Versionskontrolle zu übergeben, wenn Sie Ihr Projekt freigeben, da dadurch sichergestellt wird, dass andere dieselben Versionen von Abhängigkeiten verwenden, die Sie zum Erstellen und Testen Ihres Projekts verwendet haben.

Um eine requirements.txt-Datei aus der poetry.lock-Datei zu erstellen, können Sie den folgenden Befehl verwenden:

poetry export --output requirements.txt

So entwickeln Sie das Paket

Zu diesem Zeitpunkt haben Sie die Anforderungsbibliothek installiert, aber Ihre Anwendung führt noch keine Aktionen aus. In diesem Abschnitt beginnen Sie mit dem Aufbau der Funktionalität Ihrer Anwendung.

Erstellen Sie zunächst eine neue Datei mit dem Namen validator.py im Paket phone_number_validator und folgen Sie den Anweisungen.

In diesem Tutorial verwenden Sie die Prinzipien der objektorientierten Programmierung, um Ihre Anwendung zu erstellen. Erstellen Sie zunächst eine Klasse mit dem Namen PhoneNumberValidator:

class PhoneNumberValidator:
    pass

Als nächstes müssen Sie einen Konstruktor für die Klasse erstellen. Standardmäßig möchten wir, dass der Benutzer seinen eigenen API-Schlüssel bereitstellt. Daher sollte der Konstruktor ein api_key-Argument annehmen. Darüber hinaus sollte der Konstruktor das Attribut api_url auf https://api.numlookupapi.com/v1/validate/ initialisieren:

class PhoneNumberValidator:
    def __init__(self, api_key: str) -> None:
        self.api_key = api_key
        self.api_url = "https://api.numlookupapi.com/v1/validate/"

Damit verfügen Sie über eine grundlegende Klassenstruktur. Sie können jetzt damit beginnen, der Klasse PhoneNumberValidator weitere Funktionen hinzuzufügen.

Als Nächstes müssen Sie eine Methode definieren, mit der der Benutzer eine Telefonnummer validieren kann. Diese Methode wird validate() heißen.

def validate(self, phone_number: str, country_code: str = None) -> bool:
    if not phone_number:
        raise ValueError("Phone Number cannot be empty!")
    response = self._make_api_call(phone_number, country_code)
    if response.ok:
       return response.json()["valid"]
   else:
       response.raise_for_status()

Die Methode benötigt zwei Parameter: phone_number, ein erforderlicher String-Parameter, und country_code, ein optionaler String-Parameter mit dem Standardwert None. Die Methode gibt einen booleschen Wert zurück, der angibt, ob die Telefonnummer gültig ist oder nicht.

Die Methode prüft zunächst, ob der Parameter phone_number nicht leer ist. Wenn es leer ist, wird ein ValueError ausgelöst. Als Nächstes ruft die Methode eine _make_api_call()-Methode (später definiert) mit den Parametern phone_number und country_code auf, um einen API-Aufruf zur Validierung des Telefons durchzuführen Nummer.

Wenn der API-Aufruf erfolgreich ist, also den Statuscode 200 zurückgibt, gibt die Methode den booleschen Wert des Schlüssels valid in der JSON-Antwort zurück. Wenn der API-Aufruf fehlschlägt, wird ein HTTPError mit dem Statuscode und der Meldung aus der API-Antwort ausgelöst.

Da die obige Methode einen _make_api_call() verwendet, um den API-Aufruf durchzuführen, definieren wir diese Methode:

import requests

def _make_api_call(self, phone_number: str, country_code: str = None)
    params = {"apikey": self.api_key}
    if country_code:
        params["country_code"] = country_code
    response = requests.get(self.api_url + phone_number, params=params)
    return response

Die Methode _make_api_call() ist eine private Methode der Klasse PhoneNumberValidator, die einen API-Aufruf an NumLookupAPI durchführt, um eine Telefonnummer zu validieren.

Die Methode benötigt zwei Argumente: phone_number (eine Zeichenfolge, die die zu validierende Telefonnummer darstellt) und country_code (eine optionale Zeichenfolge, die den ISO-Alpha-2-Ländercode für die Telefonnummer darstellt). .

Die Methode gibt ein requests.Response-Objekt zurück, das die vom API-Aufruf zurückgegebene Antwort enthält. Die Variable params ist ein Wörterbuch, das den API-Schlüssel und, falls angegeben, den Ländercode enthält. Die Methode requests.get() wird verwendet, um eine GET-Anfrage mit der Telefonnummer und Parametern an die API zu senden.

Wenn der API-Aufruf erfolgreich ist, gibt die Methode das Antwortobjekt zurück, das von der Methode validate() weiterverarbeitet wird. Wenn der API-Aufruf fehlschlägt, wird eine Ausnahme mit der Fehlermeldung ausgelöst.

Ihre PhoneNumberValidator-Klasse sieht an dieser Stelle so aus.

Hinweis: Weitere Informationen zur NumLookupAPI finden Sie in der offiziellen Dokumentation hier.

Beispielverwendung der Klasse PhoneNumberValidator (optional)

Sie haben nun die Implementierung der Telefonnummernvalidierungsfunktion abgeschlossen. Um Ihre Anwendung zu testen, können Sie eine Datei mit dem Namen main.py im Stammverzeichnis Ihres Projekts erstellen. Beachten Sie, dass dieser Schritt optional ist.

In main.py können Sie die Klasse PhoneNumberValidator verwenden, indem Sie sie aus dem Modul phone_number_validator.validator importieren. Anschließend können Sie eine Instanz der Klasse erstellen, indem Sie Ihren API-Schlüssel als Argument an den Konstruktor übergeben.

Um den API-Schlüssel zu erhalten, registrieren Sie sich für ein kostenloses Konto bei NumLookupAPI und kopieren Sie den Schlüssel aus dem Dashboard:

Danach können Sie die Methode validate für die Instanz mit Telefonnummern aufrufen, die Sie validieren möchten. Die Methode validate gibt einen booleschen Wert zurück, der angibt, ob die Telefonnummer gültig ist oder nicht.

Hier ist ein Beispielcode-Snippet für main.py:

from phone_number_validator.validator import PhoneNumberValidator

validator = PhoneNumberValidator(api_key="your-api-key-here")
is_valid1 = validator.validate("+15551234")
is_valid2= validator.validate("+12069220880")
is_valid3= validator.validate("2069220880", country_code="US")
print(is_valid1)
print(is_valid2)
print(is_valid3)

Ausgabe :

False
True
True

So testen Sie das Paket

In diesem Abschnitt testen Sie das Paket phone_number_validator mit Pytest. Tests sind ein wesentlicher Bestandteil der Softwareentwicklung, da sie sicherstellen, dass unser Code wie erwartet funktioniert, und dabei helfen, potenzielle Fehler oder Probleme zu erkennen, bevor sie in der Produktion bereitgestellt werden. Sie werden Testfälle schreiben, um die Funktionalität der Klasse PhoneNumberValidator und ihrer Methoden zu überprüfen.

So installieren Sie Testabhängigkeiten

In der Poesie ist eine Abhängigkeitsgruppe eine Möglichkeit, Abhängigkeiten zu gruppieren. Die häufigste Verwendung von Abhängigkeitsgruppen besteht darin, Entwicklungs- und Produktionsabhängigkeiten zu trennen. Beim Installieren von Abhängigkeiten können Sie auswählen, welche Abhängigkeitsgruppe installiert werden soll.

Um die Pakete pytest und requests-mock in einer Gruppe namens test zu installieren, führen Sie den folgenden Befehl aus:

poetry add pytest requests-mock --group test

Im obigen Befehl haben Sie die Option --group verwendet, um den Gruppennamen anzugeben, in diesem Fall test. Nachdem Sie die Abhängigkeiten installiert haben, sieht Ihre Datei pyproject.toml wie folgt aus:

[tool.poetry]
name = "phone-number-validator"
version = "0.1.0"
description = ""
authors = ["Ashutosh Krishna <ashutoshbritish@gmail.com>"]
readme = "README.md"
packages = [{include = "phone_number_validator"}]

[tool.poetry.dependencies]
python = "^3.11"
requests = "^2.28.2"


[tool.poetry.group.test.dependencies]
pytest = "^7.2.2"
requests-mock = "^1.10.0"

[build-system]
requires = ["poetry-core"]
build-backend = "poetry.core.masonry.api"

So schreiben Sie die Tests

Zur Erinnerung: Sie haben zuvor eine validate-Methode zur Validierung von Telefonnummern erstellt. Nachdem Sie nun die erforderlichen Abhängigkeiten der Testumgebung installiert haben, ist es an der Zeit, den Code zu schreiben, um die Funktionalität Ihrer Anwendung zu testen.

Erstellen Sie eine test_validator.py-Datei in Ihrem tests-Paket und fügen Sie den folgenden Code hinzu:

import pytest
from phone_number_validator.validator import PhoneNumberValidator


VALID_PHONE_NUMBER="+12069220880"
INVALID_PHONE_NUMBER="+15551234"
PHONE_NUMBER_WITHOUT_COUNTRY_CODE="2069220880"


@pytest.fixture
def validator():
    return PhoneNumberValidator(api_key="test_api_key")

Der Code importiert die notwendigen Module zum Schreiben der Testfälle. Der Dekorator @pytest.fixture wird verwendet, um einen Fixture-validator() zu definieren, der eine neue Instanz der Klasse PhoneNumberValidator mit dem erstellt test_api_key Parameter. Dieses Fixture kann in mehreren Tests verwendet werden, um eine neue Instanz von PhoneNumberValidator zu erstellen.

Fügen Sie als Nächstes nach dem Fixture die folgenden Testfälle hinzu:

def test_valid_phone_number(validator, requests_mock):
    requests_mock.get(validator.api_url + VALID_PHONE_NUMBER, json={"valid": True})
    assert validator.validate(VALID_PHONE_NUMBER) == True


def test_invalid_phone_number(validator, requests_mock):
    requests_mock.get(validator.api_url + INVALID_PHONE_NUMBER, json={"valid": False})
    assert validator.validate(INVALID_PHONE_NUMBER) == False


def test_api_call_failure(validator, requests_mock):
    requests_mock.get(validator.api_url, status_code=500)
    with pytest.raises(Exception):
        validator.validate(INVALID_PHONE_NUMBER)


def test_phone_number_without_country_code(validator, requests_mock):
    requests_mock.get(
        validator.api_url + PHONE_NUMBER_WITHOUT_COUNTRY_CODE, json={"valid": True, "country_code": "US"}
    )
    assert validator.validate(PHONE_NUMBER_WITHOUT_COUNTRY_CODE, country_code="US") == True


def test_phone_number_with_unsupported_country_code(validator, requests_mock):
    requests_mock.get(validator.api_url, status_code=400)
    with pytest.raises(Exception):
        validator.validate(VALID_PHONE_NUMBER, country_code="ZZ")


def test_invalid_api_key(validator, requests_mock):
    requests_mock.get(validator.api_url, status_code=401)
    with pytest.raises(Exception):
        validator.validate(VALID_PHONE_NUMBER)


def test_invalid_phone_number_type(validator):
    with pytest.raises(TypeError):
        validator.validate(5551234)


def test_empty_phone_number(validator):
    with pytest.raises(ValueError):
        validator.validate("")

Jede Testfunktion definiert ein Szenario, das testet, ob die Methode validate() für eine bestimmte Eingabe korrekt funktioniert. Die Testfälle decken die folgenden Szenarien ab:

1. test_valid_phone_number: Dieser Testfall prüft, ob die Methode validate True für eine gültige Telefonnummer zurückgibt. Die für diesen Test verwendete Telefonnummer ist +12069220880 und die Antwort der API wird so simuliert, dass sie {"valid": True zurückgibt.
2. test_invalid_phone_number: Dieser Testfall prüft, ob die Methode validate False für eine ungültige Telefonnummer zurückgibt. Die für diesen Test verwendete Telefonnummer ist +15551234 und die Antwort der API wird so simuliert, dass sie {"valid": False zurückgibt.
3. test_api_call_failure: Dieser Testfall prüft, ob eine Ausnahme ausgelöst wird, wenn beim Durchführen eines API-Aufrufs ein Fehler auftritt. Die für diesen Test verwendete Telefonnummer ist eine ungültige Telefonnummer (+15551234) und der API-Aufruf wird simuliert, um den Statuscode 500 zurückzugeben.
4. test_phone_number_without_country_code: Dieser Testfall prüft, ob die Methode validate eine Telefonnummer ohne Landesvorwahl validieren kann, indem sie die Landesvorwahl als Argument angibt. Die für diesen Test verwendete Telefonnummer ist 2069220880 und die Antwort der API wird so simuliert, dass sie {"valid": True, "country_code": "US" zurückgibt.
5. test_phone_number_with_unsupported_country_code: Dieser Testfall prüft, ob eine Ausnahme ausgelöst wird, wenn eine nicht unterstützte Ländervorwahl angegeben wird. Die für diesen Test verwendete Telefonnummer ist eine gültige Telefonnummer (+12069220880), und der API-Aufruf wird simuliert, um den Statuscode 400 zurückzugeben.
6. test_invalid_api_key: Dieser Testfall prüft, ob eine Ausnahme ausgelöst wird, wenn ein ungültiger API-Schlüssel verwendet wird. Die für diesen Test verwendete Telefonnummer ist eine gültige Telefonnummer (+12069220880), und der API-Aufruf wird simuliert, um den Statuscode 401 zurückzugeben.
7. test_invalid_phone_number_type: Dieser Testfall prüft, ob eine Ausnahme ausgelöst wird, wenn die an die Methode validate übergebene Telefonnummer keine Zeichenfolge ist.
8. test_empty_phone_number: Dieser Testfall prüft, ob eine Ausnahme ausgelöst wird, wenn eine leere Zeichenfolge als Telefonnummer an die Methode validate übergeben wird.

Ihre Datei test_validator.py sollte an dieser Stelle so aussehen.

Um die Tests auszuführen, ist es wichtig, den Befehl pytest innerhalb der virtuellen Umgebung auszuführen. Poetry bietet einen run-Befehl, um den angegebenen Befehl in der virtuellen Umgebung des Projekts auszuführen. Führen Sie daher den folgenden Befehl aus, um die Tests auszuführen:

poetry run pytest -v

Ausgabe :

poetry run pytest -v
============================================== test session starts ===============================================
platform win32 -- Python 3.11.0, pytest-7.2.2, pluggy-1.0.0 -- C:\Users\ashut\AppData\Local\pypoetry\Cache\virtualenvs\phone-number-validator-j1Sa98gs-py3.11\Scripts\python.exe
cachedir: .pytest_cache
rootdir: D:\Blog-Codes\phone-number-validator
plugins: requests-mock-1.10.0
collected 8 items

tests/test_validator.py::test_valid_phone_number PASSED                                                     [ 12%] 
tests/test_validator.py::test_invalid_phone_number PASSED                                                   [ 25%] 
tests/test_validator.py::test_api_call_failure PASSED                                                       [ 37%] 
tests/test_validator.py::test_phone_number_without_country_code PASSED                                      [ 50%]
tests/test_validator.py::test_phone_number_with_unsupported_country_code PASSED                             [ 62%] 
tests/test_validator.py::test_invalid_api_key PASSED                                                        [ 75%] 
tests/test_validator.py::test_invalid_phone_number_type PASSED                                              [ 87%] 
tests/test_validator.py::test_empty_phone_number PASSED                                                     [100%] 

=============================================== 8 passed in 0.05s ================================================ 

So veröffentlichen Sie das Paket

An diesem Punkt Ihres Projekts haben Sie eine Bibliothek erstellt, die Telefonnummern validieren kann, und Sie haben Testfälle geschrieben, um deren Funktionalität sicherzustellen.

Wenn Sie diese Bibliothek anderen zugänglich machen möchten, können Sie sie online veröffentlichen. Poetry bietet eine einfache Möglichkeit, ein Paket mit dem Befehl „publish“ zu veröffentlichen.

Doch bevor Sie Ihre Bibliothek veröffentlichen können, müssen Sie sie mit dem Build-Befehl packen:

poetry build

Ausgabe :

Building phone-number-validator (0.1.0)
  - Building sdist
  - Built phone_number_validator-0.1.0.tar.gz
  - Building wheel
  - Built phone_number_validator-0.1.0-py3-none-any.whl

Das Verpacken eines Projekts vor der Veröffentlichung ist ein entscheidender Schritt, da es den Prozess der Verteilung, Installation und Nutzung für andere vereinfacht.

Poetry verwendet die in der Datei pyproject.toml angegebenen Informationen wie Projektname, Version und Abhängigkeiten, um das Projekt in zwei verschiedenen Formaten zu verpacken – sdist und Wheel. Bei den Wheel-Distributionen handelt es sich um vorkompilierte Pakete, die schnell installiert werden können, während Quelldistributionen den Rohquellcode enthalten und kompiliert werden müssen.

Um Ihre Bibliothek zu veröffentlichen, müssen Sie Ihre PyPI-Anmeldeinformationen ordnungsgemäß konfigurieren, da Poetry die Bibliothek standardmäßig auf PyPI veröffentlicht.

Sobald die Bibliothek gepackt ist, können Sie sie mit dem Befehl publish veröffentlichen.

poetry publish

Nachdem Sie den Befehl poetry publizieren ausgeführt haben, wird Ihr Paket im Python Package Index (PyPI) veröffentlicht, wodurch es für die Installation über Poetry verfügbar ist.

Ausgabe :

Publishing phone-number-validator (0.1.0) to PyPI
 - Uploading phone_number_validator-0.1.0-py3-none-any.whl 0%
 - Uploading phone_number_validator-0.1.0-py3-none-any.whl 100%
 - Uploading phone_number_validator-0.1.0.tar.gz 0%
 - Uploading phone_number_validator-0.1.0.tar.gz 100%

Sobald das Paket veröffentlicht ist, kann es auf PyPI durchsucht werden. Sie können beispielsweise auf PyPI nach der Bibliothek phone-number-validator suchen. Nachdem Sie es gefunden haben, können Sie es auf Ihrem System installieren und versuchen, es zu verwenden.

Abschluss

In diesem Tutorial habe ich erklärt, wie Poetry funktioniert und wie man seine Funktionen nutzt. Sie haben gelernt, wie Sie ein neues Poetry-Projekt erstellen, Abhängigkeiten verwalten und mit der Versionierung umgehen. Sie haben außerdem gelernt, wie Sie Tests mit Pytest schreiben und ausführen und Ihre Python-Bibliothek mit Poetry auf PyPI verpacken und veröffentlichen.

Wenn Sie diesem Tutorial folgen, verfügen Sie nun über die erforderlichen Fähigkeiten, um ganz einfach Ihre eigenen Python-Pakete zu erstellen, zu verwalten und zu verteilen. Durch weitere Erkundung und Übung können Sie Ihr Wissen über Poesie erweitern und es nutzen, um Ihre eigenen Python-Bibliotheken zu entwickeln und für andere zur Nutzung freizugeben.

Wenn Sie diesem Tutorial gefolgt sind und Ihr eigenes Paket erstellt haben, empfehle ich Ihnen, Ihre Kreation mit der Welt zu teilen! Machen Sie einen Screenshot oder zeichnen Sie ein Video Ihrer Anwendung in Aktion auf und teilen Sie es auf Twitter. Markieren Sie mich unbedingt mit @ashutoshkrris, damit ich Ihre Arbeit sehen und mit meinen Followern teilen kann.

Ich kann es kaum erwarten zu sehen, was Sie geschaffen haben! Viel Spaß beim Codieren!

Zusätzliche Ressourcen

• Github-Repository für das Tutorial
• So interagieren Sie mit Webdiensten in Python
• NumLookupAPI-Dokumentation