This forum uses cookies
This forum makes use of cookies to store your login information if you are registered, and your last visit if you are not. Cookies are small text documents stored on your computer; the cookies set by this forum can only be used on this website and pose no security risk. Cookies on this forum also track the specific topics you have read and when you last read them. Please confirm whether you accept or reject these cookies being set.

A cookie will be stored in your browser regardless of choice to prevent you being asked this question again. You will be able to change your cookie settings at any time using the link in the footer.

Virtuelle Python Umgebungen mit pyenv und pipenv
#1
Motivation
Es gibt Python-Packages, die sich mit Hilfe des Paketmanagers installieren und aktuell halten lassen. Diese Packages können auch mit Root-Rechten installiert und so dem gesamten  System zur Verfügung gestellt werden.

Das gilt aber nicht grundsätzlich. Oft muss man Python-Packages mit Hilfe des Tools pip3 installieren. Die Installation von Packages mit pip3 sollte nie mit Root-Rechten passieren. Das könnte zu Rechteproblemen und Konflikten mit dem Paketmanager führen.

Die Fähigkeiten des Tools pip3 gehen nicht soweit wie die der Linux-Paketmanager. Einzelne Pakete können mit pip3 aktuell gehalten werden. Dazu muß man aber wissen, daß sie installiert wurden. Am Anfang wenn man mit einem Package arbeitet ist das sicher kein Problem, aber im Laufe der Jahre könnte das Wissen darüber verloren gehen. Gerade mit vielen Python-Paketen ist es insgesamt schwierig, die Installation der Python-Pakete aktuell und sauber zu halten.

Es gibt zwar die Möglichkeit mit Hilfe eines Skriptes nach den installierten Python-Paketen zu suchen, und dann auch zu aktualisieren. Aber es gibt, noch andere Aspekte zu beachten. Man brauch unter Umständen bestimmte Pythonversionen und bestimmte Versionen von Python-Paketen, weil deren Abhängigkeiten in den aktuellen Versionen nicht aufzulösen sind. Oder es sind getrennte virtuelle Pythonumgebungen notwendig, da 2 Python-Pakete die man für unterschiedliche Projekte brauch nicht zueinander kompatibel sind. Außerdem ist es wichtig, eine Entwicklungsumgebung nach der Archivierung wieder genau wie ursprünglich zur Verfügung zu haben, wenn das Projekt fortgesetzt wird.

Das Alles kann mit den Tools pyenv und pipenv erreicht werden. pyenv verwaltet im Hintergrund die Pythonversionen. Es wird nur mit pipenv direkt gearbeitet, mit dessen Hilfe werden projektspezifische virtuelle Pythonumgebungen eingerichtet. Das heisst, die virtuelle Pythonumgebung liegt neben dem Quellcode im Projektverzeichnis. Pakt und archiviert man das Projektverzeichnis, sichert man so den Quellcode aber auch die Entwicklungsumgebung.

Unter Manjaro-Linux sind diese beiden Tools mit "pamac install python-pipenv pyenv" schnell installiert. Sie lassen sich dann genau wie hier beschrieben benutzen. Unter Linux-Mint müssen wir ein paar Klimmzüge mehr machen. Manjaro-Linux ist eine Distribution mit Rolling Releases. Das heisst, es gibt nicht nur Updates zur Fehlerbeseitigung und Sicherheitsupdates, sondern es werden alle Pakete ständig aktualisiert. Das kann dazu führen, daß man nach einem Update in seltenen Fällen auch einmal korrigierend eingreifen muss. Damit ist Manjaro Linux zwar sehr gut für die Softwareentwicklung aber nicht für Anfänger geeignet. Wenn es außerdem nicht nur um Softwareentwicklung geht sondern auch um Themen wie 3D Design, Malen oder das Arbeiten mit einem Officepaket wie libreOffice, sorgen für meinen Geschmack Rolling Releases auch für zuviel Unruhe. Man kann aber nicht sagen, diese oder jene Distribution ist besser oder schlechter, das hängt stark vom Anwendungszweck ab. Wer dennoch Manjaro Linux einmal ausprobieren möchte, dem empfehle ich die Variante mit dem erprobten Xfce (um so einfacher, um so stabiler). Es sei denn man verwendet ein WACOM Grafik-Tablet, dann empfehle ich eher die Community Variante Manjaro Cinnamon. Manjaro Gnome würde auch gehen, aus mehreren Gründen gefällt mir aber Gnome nicht. Manjaro KDE naja, sagen wir mal so, ich empfinde es als nicht sehr performant.

https://manjaro.org/

Wenden wir uns aber jetzt wieder unserem Linux-Mint zu, denn rund um das Thema Opensims schätze auch ich dessen Stabilität. Mit Python beschäftige ich mich in diesem Zusammenhang, da es möglich sein soll Python-Bibliotheken zur Nutzung in OSSL-Skripten mit einzubinden. Das wird aber erst später ein eigenes Thema.


Pyenv installieren

1) Build Umgebung installieren:
pyenv läd und baut später die gewünschte Pythonversion. Dafür müssen die folgenden Abhängigkeiten installiert werden.

Code:
$ sudo apt-get update; sudo apt-get install make build-essential libssl-dev zlib1g-dev \
libbz2-dev libreadline-dev libsqlite3-dev wget curl llvm \
libncursesw5-dev xz-utils tk-dev libxml2-dev libxmlsec1-dev libffi-dev liblzma-dev


2) Checkout pyenv:
Das pyenv Git-Repository wird geclont.
Code:
$ git clone https://github.com/pyenv/pyenv.git ~/.pyenv


3) Dynamische Bash Erweiterung:
Zur Beschleunigung von pyenv wird versucht eine dynamische Bash-Erweiterung zu kompilieren. Wenn es fehlschlägt einfach ignorieren, pyenv wird trotzdem normal arbeiten.
Code:
$ cd ~/.pyenv && src/configure && make -C src


4) Bash Umgebung:
Die Einstellungen in der ~/.bashrc werden gesetzt, wenn ein Terminal geöffnet wird. Die Datei ~/.profile wird beim Systemstart ausgeführt. Damit sichergestellt ist, daß pyenv in allen Umgebungen korrekt arbeitet, werden die Einstellungen beiden Dateien hinzugefügt.

Führe die folgenden Befehle aus, um der Datei ~/.bashrc Zeilen hinzuzufügen.
Code:
$ echo 'export PYENV_ROOT="$HOME/.pyenv"' >> ~/.bashrc
$ echo 'command -v pyenv >/dev/null || export PATH="$PYENV_ROOT/bin:$PATH"' >> ~/.bashrc
$ echo 'eval "$(pyenv init -)"' >> ~/.bashrc

Führe die folgenden Befehle aus, um der Datei ~/.profile Zeilen hinzuzufügen.
Code:
$ echo 'export PYENV_ROOT="$HOME/.pyenv"' >> ~/.profile
$ echo 'command -v pyenv >/dev/null || export PATH="$PYENV_ROOT/bin:$PATH"' >> ~/.profile
$ echo 'eval "$(pyenv init -)"' >> ~/.profile


5) Restarte die Bash:
Code:
$ exec "$SHELL"


6) Pyenv testen:
Code:
$ pyenv global
system

Pipenv installieren
Das pipenv apt-Paket scheint nicht mehr zum aktuellen Python zu passen. Man kann es nicht starten. Ähnliche Probleme soll es mit dem Paket
python3-virtualenv geben. Wir deinstallieren beide, und installieren beide mit dem Tool pip3 als Python-Packages wieder.

pip3 sollte man nicht mit sudo ausführen! Das kann mit dem Paketmanager zu Konflikten und Rechteproblemen führen. Wenn der Pfad
~/.local/bin in der Umgebungsvariable PATH vor dem Pfad /usr/bin steht, sollte das lokal installierte pipenv immer zuerst gefunden werden. Also
selbst wenn pipenv und virtualenv über den Paketmanager installiert wurden, sollte man das lokale pipenv ausführen. Wenn also andere Benutzer das apt-Package
python3-virtualenv brauchen, sollte es uns nicht stören, und das Deinstallieren kann unterbleiben.

Code:
sudo apt-get purge pipenv python3-virtualenv
sudo apt-get autoremove
sudo apt-get autoclean
sudo apt-get install python3-pip
pip3 install pipenv
$ exec "$SHELL"



Update von pipenv und pyenv
Da wir beide Tools manuell installiert haben, werden diese nicht durch den Paketmanager aktualisiert.
Wir müssen selbst dafür sorgen, dass die Tools aktuell bleiben. Am Besten tut man das mit Hilfe eines
Scripts.
Code:
pyenv update:
$ PFAD=$(pwd)
$ cd ~/.pyenv && git pull && src/configure && make -C src
$ cd $PFAD

pipenv update:
$ pip3 install --upgrade pipenv


Visual Studio Code installieren
"Visual Studio Code" hat nichts mit "Visual Studio" zu tun. "Visual Studio Code" ist ohne Extensions nicht mehr als ein Editor. Auch die Oberfläche der Beiden ist nicht ähnlich. Außerdem ist "Visual Studio Code" kostenlos.

Unter Linux eine Microsoft IDE zu benutzen, mögen manche als Sakrileg ansehen. Ich halte nichts von dem ewigen Gezanke in den Foren bei dem Thema Linux versus Microsoft. Man sollte einfach emotionslos das jeweils geeignete Tool oder Betriebssystem wählen, und dann einfach seine Aufgaben erfüllen.

Von Eclipse halte ich nicht sehr viel. Es wird mit Java implementiert, aber auf die Laufzeit möchte ich gar nicht hinaus. Die spielt auf heutigen Rechnern keine Rolle mehr. Ich finde nur, daß Eclipse einfach viel zu überfrachtet und damit unübersichtlich ist. Allerdings lege ich in der täglichen Arbeit Wert darauf, das die IDE den GDB grafisch unterstützt. Das Debuggen auf  Kommandozeile ist natürlich möglich, aber es kommt dabei nicht viel Freude auf.

Für C/C++ findet sich noch der Qt-Creator als Alternative. Für Python ist sicher auch Spyder geeignet. Neben diesen Sprachen beschäftige ich mich aber auch mit der Sprache Rust, die eine sehr interessante Neuentwicklung aus der Mozilla-Welt ist. Mittlerweile wird Rust auch von der Community unterstützt. Rust kann sowohl für embedded Firmware's als auch für PC-Anwendungen benutzt werden.

https://www.spyder-ide.org/
https://www.rust-lang.org/
https://www.rust-lang.org/tools
https://www.redox-os.org/

Auf den Rust-Seiten werden zwar einige Editoren/IDE's genannt, aber unter den kostenlosen IDE's/Editoren funktioniert nur für Visual Studio Code das Debuggen grafisch innerhalb der IDE-Oberfläche. Insgesamt deckt Visual Studio Code alle diese Sprachen mit Debugger Unterstützung ab, und ist daher momentan meine erste Wahl.

Unter Linux Mint lade ich mir das 64Bit Deb-File für die Installation herunter.
https://code.visualstudio.com/Download

Installation mit:
Code:
$ sudo apt install ./<file>.deb

Dabei wurden bei mir automatisch das entsprechende Microsoft Repository und dessen Keys als zusätzliche Paketquelle eingerichtet. VSCode wird also danach einfach per apt oder apt-get aktuell gehalten.

Einen Überblick über die Plugins bzw. Extensions von VSCode kann man sich auf der folgenden Seite verschaffen. Installiert werden sie aber innerhalb von VSCode.
https://marketplace.visualstudio.com/VSCode

Für die Python Entwicklung installiert man unter VSCode die kostenlose Python Extension von Microsoft selbst.
https://marketplace.visualstudio.com/ite...hon.python

VSCode möchte ich nun hier nicht erklären, das würde jeden Umfang sprengen, auf der folgenden Seite findet man aber eigentlich alles.
https://code.visualstudio.com/docs


Anwendung der Tools

1) Projektverzeichnis erstellen:
Code:
$ mkdir hello
$ cd hello

2) Verzeichnis für die virtuelle Pythonumgebung erzeugen.
Code:
$ mkdir .venv

3) Eine grundlegende Datei "Pipfile" erzeugen. Diese Datei wird im nächsten Schritt nur als Vorlage benutzt,
  um zu definieren, was in welcher Version installiert werden soll. Zunächst wird dabei das Systempython benutzt.
Code:
$ pipenv install art

4) Die Datei Pipfile.lock löschen.

5) Die Datei Pipfile anpassen:
  Die Python Version auf 3.9.10 setzen. Das Paket "art" in der aktuellsten Version gegen "art 5.5" austauschen.
Code:
[[source]]
url = "https://pypi.org/simple"
verify_ssl = true
name = "pypi"

[packages]
art = "==5.5"

[dev-packages]

[requires]
python_version = "3.9.10"


6) Die virtuelle Pythonumgebung zunächst wieder deinstallieren.
Code:
$ pipenv --rm

7) Das Verzeichnis für die virtuelle Umgebung wieder anlegen.
Code:
$ mkdir .venv

8) Endgültig die Pythonumgebung installieren. Dabei wird jetzt im Hintergrund pyenv benutzt. Pyenv überprüft ob die Pythonversion 3.9.10 vorhanden ist, wenn nicht wird diese installiert. Bei diesem Schritt wird die Datei Pipfile.lock erzeugt. In dieser Datei stehen alle installierten Packageversionen. Behält man die Dateien Pipfile und Pipfile.lock kann man mit dem folgenden Befehl immer wieder die identische Umgebung installieren.
Code:
$ pipenv install

9) Die virtuelle Pythonumgebung starten:
Code:
$ pipenv shell

10) Visual Studio Code von der Kommandozeile aus starten. Es wird im VSCode der aktuelle Ordner als Arbeitsordner geöffnet:
Code:
$ code .

11) Wenn keine Kommandozeile in einem Terminal geöffnet wird, das Terminal öffenen:
Main Menu-->Terminal-->Neues Terminal

12) Die Datei hello.py erstellen. Wenn eine Python Datei geöffnet wurde sieht man unten rechts in der Statuszeile die benutzte Pythonversion z.B. "3.9.10('.venv':'pipenv')"
Code:
from art import *
tprint('Hello World!')

13) Das Script über den Debugger starten:
    a) In der Iconzeile links das vierte Symbol von oben mit dem Käfer drücken.
    b) Es erscheint links der Text: "Zum Anpassen von "Ausführen und Debuggen" erstellen sie eine launch.json-Datei." Auf den blauen Teil des Textes klicken.
    c) Debugkonfiguration "Python-Datei wählen".
    d) Die Datei launch.json speichern und schliessen. Der Debugger ist jetzt bereit.
    e) Oben links neben "Ausführen und ..." das grüne Dreieck anklicken. Das Script hello.py wird ausgeführt, und man erhält im Terminal die folgende Ausgabe:
Code:
_   _        _  _         __        __              _      _  _
| | | |  ___ | || |  ___   \ \      / /  ___   _ __ | |  __| || |
| |_| | / _ \| || | / _ \   \ \ /\ / /  / _ \ | '__|| | / _` || |
|  _  ||  __/| || || (_) |   \ V  V /  | (_) || |   | || (_| ||_|
|_| |_| \___||_||_| \___/     \_/\_/    \___/ |_|   |_| \__,_|(_)

14) Zur Anzeige des Projektordners mit seinen Dateien wechselt man mit dem ersten Symbol in der Iconleiste links.

15) Klick man vor den Zeilennummern in der Datei hello.py kann man einen Breakpoint in Form eines roten Punktes setzen.

16) VSCode schliessen.

17) Die virtuelle Pythonumgebung verlassen:
Code:
$ exit


Software(Projekt) Versionsverwaltung

Ich möchte auch hier wieder nicht das Tool "git" erklären. Das wäre wiederum viel zu umfangreich. An dieser Stelle möchte ich nur einen Tip loswerden.

Bevor man jetzt mit "git init" ein lokales Repository anlegt, sollte man eine Datei .gitignore anlegen. In dieser Datei sollte man mindestens dafür sorgen, daß das Verzeichnis ".venv" von git ignoriert wird, sonst speichert man Binaries und nicht nur Ascii-Text im Repository. Wenn zusätzlich dafür gesorgt werden soll, daß das Repository auch unabhängig von der verwendeten IDE ist, sollte auch das Verzeichnis ".vscode" von git ignoriert werden.
Code:
hello/.gitignore:
.venv/
.vscode/

Dann die folgenden Befehle ausführen:
Code:
git init
git add .
git commit --all -m 'Erstes Commit'

Mit dem letzten Befehl sollte man die folgende Ausgabe erhalten:
Code:
[master (Root-Commit) 34158ab] Erstes Commit
4 files changed, 47 insertions(+)
create mode 100644 .gitignore
create mode 100644 Pipfile
create mode 100644 Pipfile.lock
create mode 100644 hello.py

Wie man sieht, sind die Verzeichnisse ".venv" und ".vscode" in der Ausgabe nicht enthalten. Neben dem Pythonquellcode sind noch die Dateien Pipfile und Pipfile.lock im Repository enthalten. Auf diese Weise sichert man neben den Quellcode auch die Pythonumgebung. Denn wie oben schon erklärt wurde, kann man diese mit Hilfe der Dateien Pipfile und Pipfile.lock in identischer Weise wieder installieren.

Und nun, um es mit den Worten von Bob Ross zu sagen: "Happy programming!" oder so ähnlich. ;-)
(Happy Painter - Bob Ross: https://www.youtube.com/watch?v=MCwGOMloBPk)
Mein Heimatgrid: https://swissgrid.opensim.ch
Zitieren


Gehe zu:


Benutzer, die gerade dieses Thema anschauen: 1 Gast/Gäste