Tests sind ein zentraler Bestandteil moderner Entwicklung. Das Framework pytest macht das Schreiben, Organisieren und Ausführen von Tests einfach, flexibel und leistungsfähig.

Tests schreiben und ausführen

Installation

Zuerst installierst du pytest mit:

pip install pytest

pytest ist kompatibel mit unittest-Tests und erfordert keine Testklassen.

Namenskonventionen

Damit pytest Tests automatisch findet, müssen Dateien und Funktionen bestimmte Namen haben:

• Dateinamen haben test im Namen
• Funktionsnamen beginnen mit test_

Beispiel:

def test_example():
    x = 5
    assert x == 5

Mit pytest im Terminal führt pytest alle passenden Tests aus.

Testauswahl

Du kannst gezielt Tests ausführen:

pytest test_module.py::test_function
pytest -k "keyword"

Optionen wie -v (verbose), -x (bei Fehler abbrechen) oder -s (print-Ausgaben anzeigen) sind sehr praktisch.

Um Optionen nicht immer per Hand eingeben zu müssen, können diese auch in einer pytest.ini angegeben werden:

[pytest]
pythonpath = .
addopts = -x --durations=0 -vv

Fortgeschrittene pytest-Techniken

Fixtures

import pytest

@pytest.fixture(scope="function")
def simple_fixture():
    return 42

def test_function(simple_fixture):
    assert simple_fixture == 42

Fixture scopes

pytest-Fixtures haben einen Scope, der bestimmt, wie oft eine Fixture erzeugt und wiederverwendet wird.
Der Standard-Scope ist function, d. h. die Fixture wird für jeden Test neu ausgeführt.

Weitere Scopes sind:

• class – einmal pro Testklasse
• module – einmal pro Datei
• package – einmal pro Paket
• session – einmal pro gesamtem Testlauf

Größere Scopes verbessern die Performance, bergen aber das Risiko von geteiltem Zustand zwischen Tests.
Daher gilt: so klein wie möglich, so groß wie nötig.

Setup and teardown

Mit pytest können wir klassische setup / teardown Methoden mit fixtures nachbauen

import pytest

def test_setup_and_teardown():
    assert True

@pytest.fixture(autouse=True, scope="function")
def setup_and_teardown():
    print("SetUp")
    # setup code goes here
    yield
    print("TearDown")
    # teardown code goes here

Parametrisierung

Mit Parametrisierung lässt sich derselbe Test mit verschiedenen Daten ausführen. So umgehst du Duplikate:

import pytest

@pytest.mark.parametrize("data, expected", [
    ([1], 1),
    ([1, 2], 1.5),
    ([1, 2, 3], 2),
])
def test_calculate_mean(data, expected_mean):
    mean = calculate_mean(data)
    assert mean == expected_mean

def calculate_mean(data):
    return sum(data) / len(data)

Das definiert mehrere Testinstanzen automatisch.

Marker

Marker helfen, Gruppen von Tests zu steuern.
Marker eignen sich z. B. zur Gruppierung nach Plattform, Kategorie oder Dauer.

Es gibt drei eingebaute Marker:

• skip
• skipif
• xfail

import pytest
import sys

@pytest.mark.skip(reason="Feature not yet implemented")
def test_future():
    pass

@pytest.mark.skipif(sys.platform == "win32", reason="Linux only")
def test_linux_only():
    pass

@pytest.mark.xfail(reason="Bug #123")
def test_known_bug():
    pass

Eigene Marker

import pytest

@pytest.mark.slow
def test_slow():
    pass

In pytest.ini:

[pytest]
...
markers =
    slow: mark slow tests

Dann kannst du testen mit:

pytest -m slow

Oder alle nicht langsamen Tests laufen lassen:

pytest -m "not slow"

Nahezu gleiche Vergleiche

Für Fließkommazahlen ist ein exakter Vergleich oft ungeeignet. pytest bietet das approx-Feature:

assert 2.2 == pytest.approx(2.3, 0.1)

Erlaubt eine Toleranz statt exakter Übereinstimmung.

Exceptions testen

Mit pytest kannst du das Auftreten von Ausnahmen elegant testen:

def test_zero_division():
    with pytest.raises(ZeroDivisionError):
        1 / 0

Das prüft, ob ein Fehler erwartet korrekt geworfen wird.

Test-Reporting & Coverage

Testabdeckung mit pytest-cov

Mit dem Plugin pytest-cov lässt sich messen, wie viel deines Codes getestet wird:

pip install pytest-cov

pytest --cov=my_app 10_app_test

Ergebnis: Coverage-Statistiken zeigen an, wie viele Zeilen getestet wurden.

HTML-Reports

Du kannst mit demselben Plugin HTML-Berichte erzeugen:

pytest --cov=my_app --cov-report=html

Eine visuelle Übersicht über die Abdeckung hilft bei der Analyse.

Integration mit Werkzeugen

Coverage-Daten lassen sich in Tools wie SonarQube einbinden:

pytest --cov-report=xml:coverage.xml

Dadurch kannst du Metriken in CI/CD-Pipelines oder Dashboards verwenden.

Assertions mit Hamcrest (optional, aber mächtig)

Neben den eingebauten assert-Anweisungen von pytest kann man auch Hamcrest verwenden.
Hamcrest ist eine Matcher-Bibliothek, die Tests lesbarer und ausdrucksstärker machen kann – besonders bei komplexen Datenstrukturen.

Installation

pip install pyhamcrest

Import in Tests:

from hamcrest import assert_that, equal_to

Warum Hamcrest?

Vergleich:

def test_hamcrest_assert():
    result = 42
    assert_that(result, equal_to(42))

Der Vorteil zeigt sich bei komplexeren Assertions:

def test_hamcrest_start_with():
    name = "Max Mustermann"
    assert_that(name, starts_with("Max"))

def test_hamcrest_has_length():
    items: Sized = ['apple', 'banana', 'cherry']
    assert_that(items, has_length(3))

Tests lesen sich mehr wie Spezifikationen.

Listen & Collections

from hamcrest import assert_that, has_items
from collections.abc import Sequence

def test_compare_list_of_items():
    actual_list_of_items: Sequence[str] = ['apple', 'banana', 'cherry']
    assert_that(actual_list_of_items, has_items("apple", "banana"))

Fazit

pytest ist ein einfaches, doch mächtiges Framework zur Testautomatisierung in Python. Es kombiniert:

• geringe Einstiegshürde – einfache Tests schnell geschrieben
• hohe Flexibilität – Marker, Parameter, Coverage
• gute Tools-Integration – HTML-Reports oder CI-Coverage

Damit eignet es sich sowohl für Einsteiger als auch für professionelle Test-Pipelines.

Code

https://github.com/jboegeholz/pytest_tutorial

The post Pytest Tutorial appeared first on Creatronix.

Wenn man Daten über eine serielle Schnittstelle zwischen z.b Raspberry Pi und einem Arduino schicken will,
ergibt es Sinn, sich über das Format Gedanken zu machen. Angenommen wir wollen einen Drehzahlwert von 60 RPM jeweils für die linke und rechte Seite übertragen.
Standardmäßig verschickt eine Bibliothek wie pyserial ASCII-Zeichen, dass heißt eine Zahl wie 60 würde als zwei Byte ASCII übertragen. Das sind doppelt so viele Daten wie benötigt würden, wenn wir die Zahl als Integer übertragen. Hier kommen structs ins Spiel.

struct for the rescue

Mit dem struct Modul in Python können wir Binärdaten in einem bestimmten Format packen und entpacken.

def test_struct_b():
    assert struct.pack('b', 1) == b'\x01'
    assert struct.pack('b', 127) == b'\x7f'
    assert struct.pack('b', -128) == b'\x80'

def test_unpack_b():
    packed = struct.pack('b', 127)
    unpacked = struct.unpack('b', packed)[0]
    assert unpacked == 127

Mehrere Variablen

def test_struct_bb():
    msg = struct.pack('bb', int(60), int(60))
    assert msg == b'\x3C\x3C'

Fallstricke

Damit die Empfängerseite die Daten auch wieder korrekt entpacken kann, muss natürlich das Format beachtet werden.

Achtet dementsprechend auf gute Dokumentation und versioniert idelaerweise die Dateien für die Datenübertragung in den gleichen Commits.

Datentypen

In structs können verschiedene Datentypen verwendet werden:
Tabelle der wichtigsten Datentypen:

Pretty hex

Wenn man die Darstellung der Zahlen auf der Konsole oder im Log etwas aufhübschen will:

def test_pretty_hex():
    msg = struct.pack('>I', 2864434397)
    pretty_hex = ' '.join(f'{b:02x}' for b in msg)
    assert pretty_hex == "aa bb cc dd"

The post So funktionieren structs in Python appeared first on Creatronix.

Du entwickelst ein kleines Python-Skript, das externe Abhängigkeiten verwendet (z. B. requests, pandas oder andere Pakete aus PyPI). Möchtest du dieses Skript weitergeben, müssen Empfänger die erforderlichen Dependencies manuell installieren. Das ist nicht besonders benutzerfreundlich.

Ein naheliegender Ansatz wäre es, das Skript mit pyinstaller in ein ausführbares Binary zu verpacken – allerdings ist das für kleine Tools oft überdimensioniert.

Idee: “Bootstrapping” à la Münchhausen

Angelehnt an die Geschichte des Baron Münchhausen, der sich selbst am eigenen Schopf aus dem Sumpf zog: Auch in Python kann sich ein Skript “selbst helfen”. Das Skript prüft beim Start, ob benötigte Pakete installiert sind. Falls nicht, installiert es diese zur Laufzeit mittels subprocess und versucht anschließend erneut den Import.

Erster Wurf

Hier ein Code-Beispiel mit dem Paket dotenv

import subprocess
import sys
import importlib

try:
    import dotenv
    print("dotenv already installed.")
except ImportError:
    print("dotenv not installed: trying to install")
    result = subprocess.run([sys.executable, "-m", "pip", "install", "python-dotenv"])
    if result.returncode == 0:
        try:
            importlib.import_module("dotenv")
            print("dotenv is now available.")
        except ImportError:
            print("dotenv still cannot be imported after installation.")
    else:
        print("dotenv could not be installed")

Funktion für mehrere Pakete

Ein häufiges Problem besteht darin, dass der Name eines Pakets beim Import nicht mit dem Namen übereinstimmt, unter dem es via pip installiert wird.
Im obigen Code siehst du bereits dass dotenv mit import dotenv eingebunden wird, aber über pip install python-dotenv installiert werden muss.

Dieses Mismatch lässt sich elegant lösen, indem man ein Dictionary definiert, das die Zuordnung zwischen Importnamen und pip-Paketnamen enthält.
Anschließend kann man über dieses Dictionary iterieren, den Import jedes Moduls versuchen und – falls erforderlich – das zugehörige pip-Paket automatisch nachinstallieren.

import subprocess
import sys
import importlib

dict_of_packages = {
    "dotenv": "python-dotenv",
    "xlrd": "xlrd"
                    }
def ensure_packages(dict_of_packages):
    for package_name, package_pip_name in dict_of_packages.items():
        try:
            importlib.import_module(package_name)
            print(f"{package_name} already installed.")
        except ImportError:
            print(f"{package_name} not installed: trying to install")
            result = subprocess.run([sys.executable, "-m", "pip", "install", package_pip_name])
            if result.returncode == 0:
                try:
                    importlib.import_module(package_name)
                    print(f"{package_name} is now available.")
                except ImportError:
                    print(f"{package_name} still cannot be imported after installation.")
            else:
                print(f"{package_name} could not be installed")

Fazit

Dieser Ansatz funktioniert gut in kontrollierten Umgebungen (bspw. venv, Skripte für Kollegen, Schulungen).

Bei Deployment auf Produktivsystemen sollte Package-Management über requirements.txt und pip install -r bevorzugt werden.

Für komplexere Setups oder GUI-Tools sind Build-Systeme wie setuptools, pipx, shiv, pex oder pyinstaller besser geeignet.

The post Autarke Skripte in Python appeared first on Creatronix.

Python gibt’s inzwischen seit über 30 Jahren – eine echte Veteranin unter den Programmiersprachen. Und ganz ehrlich: Bisher hatte ich nie das Gefühl, dass mir ein bestimmtes Sprachfeature gefehlt hätte. Alles irgendwie machbar.

Aber dann kam Python 3.10 mit einer interessanten Neuerung um die Ecke: match–case, also eine Art switch-case, wie man’s aus anderen Sprachen kennt – aber auf Python-Art natürlich, mit mehr Wumms.

🧱 Klassisch: if–elif–else

Der Standard-Weg, Entscheidungen zu treffen, ist klar: if–elif–else. Nehmen wir mal ein Beispiel aus der Praxis:

Du bekommst einen Steuerschlüssel und sollst den in einen kompakten Suffix umwandeln – etwa _9 für 19%, _7 für 7%, um ihn dann an einen Kostenträger dranzuhängen:

def convert_tax_code(tax_code, cost_carrier):
    if tax_code == "19%":
        cost_carrier += "_9"
    elif tax_code == "7%":
        cost_carrier += "_7"
    else:
        print("Error: unknown tax code")
    return cost_carrier

So weit, so simpel. Aber dann will der Kunde auch "19" und "7" (ohne %) unterstützt haben:

def convert_tax_code(tax_code, cost_carrier):
    if tax_code == "19%" or tax_code == "19":
        cost_carrier += "_9"
    elif tax_code == "7%" or tax_code == "7":
        cost_carrier += "_7"
    else:
        print("Error: unknown tax code")
    return cost_carrier

Und es hört natürlich nicht auf – jetzt sollen auch "0,19" und "0,07" funktionieren:

def convert_tax_code(tax_code, cost_carrier):
    if tax_code == "19%" or tax_code == "19" or tax_code == "0,19":
        cost_carrier += "_9"
    elif tax_code == "7%" or tax_code == "7" or tax_code == "0,07":
        cost_carrier += "_7"
    else:
        print("Error: unknown tax code")
    return cost_carrier

Und ja, das funktioniert – aber der Code wird langsam ziemlich unleserlich. Die Bedingung wird länger, tax_code wiederholt sich ständig, und elegant ist was anderes.

Spätestens hier wäre für mich der Punkt erreicht, nach einer besseren Lösung zu suchen:

🗂️ Alternative: Dictionary als Lookup

Eine super Alternative für solche Mappings: ein Dictionary.

TAX_CODE_DICT = {
    "19%": "_9",
    "19": "_9",
    "0,19": "_9",
    "7%": "_7",
    "7": "_7",
    "0,07": "_7",
}

def convert_tax_code_dict(tax_code, cost_carrier):
    if tax_code in TAX_CODE_DICT:
        cost_carrier += TAX_CODE_DICT[tax_code]
    else:
        print("Error: unknown tax code")
    return cost_carrier

Das sieht schon viel sauberer aus. Aber: Es bringt ein paar (kleine) Nachteile mit sich:

1. Kohäsion – Das Dictionary lebt außerhalb der Funktion. Muss man mögen.
2. Fehlerbehandlung – Der else-Zweig bleibt, um ungültige Eingaben abzufangen.

🎯 Endlich: match case

Jetzt kommt Python 3.10 ins Spiel – und mit ihm match case. Das liest sich nicht nur gut, es lässt sich auch gut gruppieren und ist super erweiterbar:

def convert_tax_code_match_case(cost_carrier, tax_code):
    match tax_code:
        case "19%" | "19" | "0,19":
            cost_carrier += "_9"
        case "7%" | "7" | "0,07":
            cost_carrier += "_7"
        case _:
            print("Error: unknown tax code")
    return cost_carrier

Nice! Keine unnötige Wiederholung, alle verwandten Werte sind gruppiert, und das Ganze liest sich wie ein klar strukturierter Entscheidungsbaum.

✅ Fazit

Mit match case bekommst du eine moderne, saubere Alternative zum klassischen if-Konstrukt, ohne gleich auf externe Strukturen wie Dictionaries ausweichen zu müssen.
Vor allem bei vielen, strukturierten Bedingungen kann das eine Erleichterung sein.

The post match case in Python 3.10 appeared first on Creatronix.

numpy is das Arbeitspferd für Data Scientists und Machine Learning Engineers. Aber auch als Robotiker kann diese Bibliothek nützlich sein, wenn man zum Beispiel Bildverarbeitung macht.

Es ist eine Bibliothek für numerische Berechnungen und bietet viele Funktionen, die das Arbeiten mit Zahlen erleichtern.
numpy ist schneller als Python-Listen, weil es in C geschrieben ist. Es ist auch effizienter, weil es homogene Datenstrukturen verwendet.
Das bedeutet, dass alle Elemente in einem numpy-Array den gleichen Datentyp haben. numpy ist auch effizienter, weil es Vektorisierung verwendet.
Das bedeutet, dass Operationen auf numpy-Arrays auf einmal auf alle Elemente angewendet werden können, anstatt sie einzeln zu durchlaufen.
Das macht numpy ideal für mathematische Operationen, lineare Algebra, Statistik und maschinelles Lernen.

Historie

numpy wurde 2005 von Travis Oliphant entwickelt. (Damals noch unter dem Namen Numeric.)
Es wurde später in numpy umbenannt, um Verwechslungen mit einem anderen Paket zu vermeiden.
numpy ist Teil des SciPy-Stacks, einer Sammlung von Open-Source-Software für wissenschaftliches Rechnen in Python.
Der SciPy-Stack enthält auch Bibliotheken wie pandas, matplotlib und scikit-learn.

Installation

pip install numpy

Import

import numpy as np

Der `as`-Befehl definiert einen sogenannten Alias. Jetzt können Strukturen aus numpy via np referenziert werden.

ndarray

ndarray ist die wichtigste Datenstruktur in numpy. Sie steht für n-dimensionale Arrays.
Ein Array kann mit der Methode `array` aus einer Liste erstellt werden.

a = np.array([1, 2, 3])
a
array([1, 2, 3])

Ein Array kann auch wieder in eine Liste umgewandelt werden.

b = a.tolist()
b
[1, 2, 3]

Datentypen

Im Gegensatz zu Python-Listen sind numpy-Arrays homogen, d.h. alle Elemente haben den gleichen Datentyp.
Der Datentyp eines Arrays kann mit der Methode `dtype` abgefragt werden.

a.dtype
dtype('int64')

Wenn man ein Array mit einem anderen Datentyp erstellen möchte, kann man explizit den Datentyp angeben.

b = np.array([1, 2, 3], dtype='float')
b
array([1., 2., 3., 4.], dtype=float32)

Vektoren

Wir schauen uns zuerst die Vektorarithmetik an:

Addition / Subtraktion

a = np.array([1, 2, 3])
b = np.array([5, 6, 7])
a + b

Hier werden die Elemente der Arrays elementweise addiert.
das ergibt array([6, 8, 10])

Skalarmultiplikation

a = np.array([1, 2, 3])
3 * a

Hier werden die Elemente des Arrays mit 3 multipliziert.

Hier können wir sehen, warum es charmant ist, numpy’s Array für diese Operation zu verwenden.
Wenn wir das mit einer List comprehension machen, sieht das so aus:

c = [1, 2, 3]
d = [x * 3 for x in c]

Das ist weniger intuitiv und auch langsamer.

Skalarprodukt

a = np.array([1, 2, 3])
b = np.array([5, 6, 7])
a.dot(b)

Hier wird das Skalarprodukt berechnet, in dem alle Elemente miteinander multipliziert und dann summiert werden.
Das ergibt in diesem Fall 38.

Hadamard-Produkt

a = np.array([1, 2, 3])
b = np.array([5, 6, 7])
a * b

Hier wird das Hadamard-Produkt berechnet, in dem die Elemente der Arrays elementweise multipliziert werden.
Das ergibt

array([5, 12, 21])

Kreuzprodukt

a = np.array([1, 2, 3])
b = np.array([5, 6, 7])
np.cross(a, b)

Hier wird das Kreuzprodukt berechnet.
Das Ergebnis ist ein neues Array, das das Kreuzprodukt von a und b darstellt.

Matrizen

ndarray kann auch für Matrizen verwendet werden.

Matrixmultiplikation

Bei der Matrixmultiplikation ist es wichtig, dass die Anzahl der Spalten der ersten Matrix gleich der Anzahl der Zeilen der zweiten Matrix ist.
Dann kann nach dem Schema “Zeile mal Spalte” multipliziert werden. Das kenne wir noch aus der Schulzeit.
Dort haben wir es unter dem Namen Schema von Falk kennengelernt.

a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])
a.dot(b)

Hier wird die Matrixmultiplikation durchgeführt.
Das Ergebnis ist ein neues Array, das die Matrixmultiplikation von a und b darstellt.

matmul() und dot() sind äquivalent, aber matmul() sollte bevorzugt werden, weil es klarer ist. Besser noch ist die @-Operator-Syntax.

np.matmul(a, b)
a @ b

Reshape

Mit der Methode reshape kann ein Array in eine andere Form gebracht werden.

a = np.array([1,2,3,4,5,6,7,8])
reshaped = a.reshape([2, 4])
reshaped
array([[1, 2, 3, 4],
[5, 6, 7, 8]])

einsum

einsum ist eine Funktion, die es ermöglicht, die Summation über die Elemente eines Arrays zu steuern.

a = np.array([[1, 2], [3, 4]])
np.einsum('ii', a)

Hier wird die Summe der Diagonalelemente berechnet.
Das Ergebnis ist 5.

ranges und linspace

numpy hat auch Funktionen, um die Erstellung von Arrays zu erleichtern.

arange

arange erstellt ein Array mit einer Sequenz von Zahlen.

a = np.arange(10)
a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

wie die range-Funktion in Python, kann auch arange mit einem Startwert, einem Endwert und einem Schritt verwendet werden.

b = np.arange(1, 10, 2)
b
array([1, 3, 5, 7, 9])

linspace

linspace erstellt ein Array mit einer Sequenz von Zahlen, die gleichmäßig verteilt sind.

a = np.linspace(0, 1, 5)
a
array([0. , 0.25, 0.5 , 0.75, 1. ])

Zufallszahlen

numpy hat auch Funktionen, um Zufallszahlen zu generieren.

rand

rand erstellt ein Array mit Zufallszahlen zwischen 0 und 1.

a = np.random.rand(3)
a
array([0.5488135 , 0.71518937, 0.60276338])

randint

randint erstellt ein Array mit Zufallszahlen zwischen einem Startwert und einem Endwert.

a = np.random.randint(1, 10, 3)
a
array([6, 1, 1])

Fazit

NumPy ist eine leistungsstarke Bibliothek für numerische Berechnungen in Python.
Es bietet viele Funktionen, die das Arbeiten mit Vektoren und Matrizen erleichtern.

The post Einführung in numpy appeared first on Creatronix.

Unserer Zeiterfassungssoftware startet normalerweise beim Hochfahren des Rechners.
Im Homeoffice kann es aber passieren, dass der VPN-Client nicht automatisch startet und die Zeiterfassung nicht funktioniert.
Dann muss man die Arbeitszeit per Hand eintragen. Dazu schaue ich mir im Event Viewer das letzten winlogon-Event an.

Um nicht mehr in der Ereignisanzeige suchen zu müssen, habe ich mir ein kleines Script geschrieben, dass mir das letzten winlogon-Event anzeigt.

Code

Als Erstes installieren wir das Paket pywin32, welches uns den Zugriff auf die Windows-API ermöglicht.

pip install pywin32

Mit der OpenEventLog-Methode können wir das eventlog öffnen:

handle = win32evtlog.OpenEventLog(SERVER, LOGTYPE)

Da wir die Events vom letzten Eintrag aus durchgehen wollen, setzen wir die flags auf EVENTLOG_BACKWARDS_READ.

flags = win32evtlog.EVENTLOG_SEQUENTIAL_READ | win32evtlog.EVENTLOG_BACKWARDS_READ

Mit der ReadEventLog Methode können wir die Events auslesen.

events = win32evtlog.ReadEventLog(handle, flags, 0)

Achtung: Es kommen nicht alle Events, sondern nur Chunks! Deshalb müssen wir iterieren.

Die Information, die wir suchen, steckt im SourceName und heißt “Microsoft-Windows-Winlogon”
Wenn wir ein Event mit dem Namen gefunden haben, können wir den Timestamp aus der TimeGenerated Property auslesen.

for event in events:
    if 'Microsoft-Windows-Winlogon' in event.SourceName:
        last_logon = event.TimeGenerated
        found = True  # we're only interested in the last
        break

Da uns nur der letzte Eintrag interessiert, brechen wir aus beiden Schleifen raus.

zu guter Letzt schließen wir das Eventlog noch sauber

win32evtlog.CloseEventLog(handle)

Vollständiger Code

import win32evtlog

def get_last_win_logon():
    last_logon = None
    handle = win32evtlog.OpenEventLog(None, 'System')
    flags = win32evtlog.EVENTLOG_SEQUENTIAL_READ | win32evtlog.EVENTLOG_BACKWARDS_READ
    found = False
    while not found:  # we need an outer loop because events will be retrieved as chunks
        events = win32evtlog.ReadEventLog(handle, flags, 0)
        if not events:
            break  # no more events

        for event in events:
            if 'Microsoft-Windows-Winlogon' in event.SourceName:
                last_logon = event.TimeGenerated
                found = True  # we're only interested in the last
                break

    win32evtlog.CloseEventLog(handle)
    return last_logon

The post Letzen winlogon mit win32evtlog auslesen appeared first on Creatronix.

In diesem Artikel möchte ich euch den Einsatz von TDD schmackhaft machen. Es gibt viel zu viel schlechte Software und aus meiner Sicht hängt das zu großen Teilen daran, dass diese Software nicht genug getestet wurde. Auch wenn ein Großteil der Tests oft von dedizierten Testern gemacht wird, könnt ihr als Entwickler euren Beitrag leisten, indem ihr für eine gute Testabdeckung auf der untersten Ebene sorgt. Als unterste Ebene in der Software-Entwicklung spricht man oft über eine “Unit”. Der Begriff ist nicht exakt definiert, hier kann eine Klasse, ein Modul, aber auch eine einzelne Funktion gemeint sein. Nichtsdestotrotz sind Unit-Tests ein wirksames Mittel, um die intrinsische Software-Qualität zu steigern. Ein Weg wie Unit-Tests entstehen können ist TDD.

Was bedeutet TDD?

TDD steht für Test Driven Development, also test-getriebene Entwicklung. In einer perfekten Welt entsteht damit keine Zeile Produktiv-Code ohne einen korrespondieren Testfall.
Warum ist das gut? Aus mehreren Gründen. Bevor ihr den Code schreibt, macht ihr euch Gedanken über seine Verwendung, weil ihr im Test euren Code selbst aufrufen müsst.
Das führt dazu, dass man sich mehr Gedanken um die Schnittstelle und die Modularisierung machen muss, damit man überhaupt etwas testbares bekommt. (Weg vom Spaghetti-Code)
Dann implementiert man auch immer nur so viel Code, dass der Test erfolgreich durchläuft (Wir sagen “grün wird”)
Das korrespondiert sehr gut mit dem agilen Konzept der “Definition of Done”: Ich mache mir vor der Arbeit Gedanken darüber, wann die Arbeit erledigt ist.
Als Nächstes kann ich hemmungslos meinen Code refaktorn ohne mir Gedanken zu machen, ob ich ein einmal erfolgreich gebautes Feature wieder kaputtmache, weil mir die Tests unmittelbar verraten, wenn ich Mist mache.
Aber lassen wir den Worten doch Taten folgen:

Vorbereitung

Für dieses Beispiel benötigt ihr eine halbwegs aktuelle Python-Installation und einen Editor eurer Wahl.
Für TDD empfehle ich die Benutzung von pytest, da es weniger setup braucht, um erste Tests schreiben zu können und das Standardkommando auch das automatische Finden von Testfällen erleichtert.

pip install pytest

Unser erster Test

Wir legen eine neue Datei test_mean.py an und fügen den ersten Testfall hinzu:

def test_mean():
    assert False

Jetzt können wir pytest im Terminal starten, um sicherzugehen, dass der Test gefunden wird. pytest deutet alles was das Wort “test” im Namen hat als Test und versucht es auszuführen.

Struktur schaffen

Das Ziel der Übung soll sein, eine Funktion zu haben, die den Mittelwert einer Datenreihe berechnet.
Dazu schreiben wir das Grundgerüst der Funktion und rufen diese in unserem Test auf.

def test_mean():
    assert calculate_mean([1]) == 1

def calculate_mean(data):
    pass

Der Test ist jetzt noch rot. Das ist aber richtig und wichtig, weil wir sicherstellen müssen, dass unser Test auch wirklich unsere Implementierung testet.
Wäre er schon am Anfang grün, würden wir irgendetwas testen, nur nicht den Code, den wir ja jetzt eigentlich erst schreiben wollen.

Implementieren bis Test grün

Unsere Aufgabe ist es jetzt, den Test mit dem dümmst-möglichen Code auf grün zu bringen. In unserem Fall:

def calculate_mean(data):
    return 1

Das ist so dumm, das tut schon fast weh. Aber: Fake it till you make it! Wir wissen, dass der Mittelwert einer Zahl sie selbst sein muss und deshalb ist der Code auch so korrekt.

Wenn wir pytest im Terminal ausführen, läuft der Test jetzt auch durch. Bingo!

Neuer Testcase

Wir wollen uns aber auch nicht zu lange ausruhen und wiederholen das Spiel mit folgendem Testfall:

def test_mean_2():
    assert calculate_mean([2]) == 2

Wenn wir pytest ausführen, ist der Test auch wieder rot.

Implementieren bis Test grün

def calculate_mean(data):
    return data[0]

Jetzt können wir beide Testfälle erfüllen, indem wir das erste Element der Liste (Achtung Index 0!) zurückgeben,

Neuer Testcase

Ein weiterer Fall mit einem Element würde keinen Erkenntnisgewinn bringen, deshalb übergeben wir jetzt eine Liste mit zwei Elementen:

def test_mean_two_elements():
    assert calculate_mean([1, 2]) == 1.5

Implementieren bis Test grün

Jetzt müssen wir eine Fallunterscheidung machen: wenn die Länge der Datenreihe zwei ist, addieren wir die Werte an Index 0 und 1 und teilen sie durch zwei.

def calculate_mean(data):
    if len(data) == 2:
        return (data[0] + data[1]) / 2
    return data[0]

Rule of Three

Jetzt haben wir den Punkt erreicht, an dem wir dreimal das gleich getan haben. Wir haben dreimal einen ähnlichen Testfall geschrieben und deshalb führen wir jetzt parametrisierte Tests ein. parametrize ist ein schönes pytest-Feature. Ihr definiert Eingangsdaten und Erwartungswert und der decorator @pytest.mark.parametrize sorgt dafür, dass euer Test so oft ausgeführt wird, wie Datenzeilen vorhanden sind. Ihr spart damit eine Menge Schreibarbeit!

import pytest

@pytest.mark.parametrize(
    "data, expected_mean",
    [
        ([1], 1),
        ([2], 2),
        ([1, 2], 1.5)
    ]
)
def test_mean(data, expected_mean):
    assert calculate_mean(data) == expected_mean

Wenn ihr den Test startet, sollte der auch noch grün sein, da wir die drei einzelnen Testfälle durch den einen parametrisierten Test ersetzt haben.

Neuer Testcase

Jetzt haben wir die Grundlage, um entspannt einen neuen Testfall mit drei Eingangswerten zu ergänzen:

@pytest.mark.parametrize(
    "data, expected_mean",
    [
        ([1], 1),
        ([2], 2),
        ([1, 2], 1.5),
        ([1, 2, 3], 2),
    ]
)

Implementieren bis Test grün

Wir wiederholen das Spiel für den Fall mit drei Elementen: Überprüfen der Länge, Addieren der Elemente und Teilen durch drei.

def calculate_mean(data):
    if len(data) == 2:
        return (data[0] + data[1]) / 2
    if len(data) == 3:
        return (data[0] + data[1] + data[2]) / 3
    return data[0]

Der Test sollte jetzt auch wieder grün sein.

Refactoring

Mit einem grünen Test können wir jetzt gefahrlos refactorn.
Die Implementierung aus Test 1 & 2 passen wir vom Aussehen an, damit es sich im nächsten Schritt generalisieren lassen kann.

def calculate_mean(data):
    if len(data) == 1:
        return data[0] / 1
    if len(data) == 2:
        return (data[0] + data[1]) / 2
    if len(data) == 3:
        return (data[0] + data[1] + data[2]) / 3

Rule of Three – die Zwote

Jetzt haben wir wieder einen Punkt erreicht, an dem wir wieder dreimal das gleich getan haben.
In diesem Fall haben wir dreimal eine ähnliche Implementierung geschrieben. Der Unterschied besteht hier in der Länge der Datenreihe.

Deshalb refactorn wir erstmal die len(data)-Aufrufe und ziehen eine Variable raus:

def calculate_mean(data):
    length = len(data)
    if length == 1:
        return data[0] / 1
    if length == 2:
        return (data[0] + data[1]) / 2
    if length == 3:
        return (data[0] + data[1] + data[2]) / 3

Als Nächstes können wir den Teiler durch die length-Variable ersetzen:

def calculate_mean(data):
    length = len(data)
    if length == 1:
        return data[0] / length
    if length == 2:
        return (data[0] + data[1]) / length
    if length == 3:
        return (data[0] + data[1] + data[2]) / length

Achtung: bitte immer nach jeder Änderung den Test / die Tests laufen lassen, damit wir frühzeitig herausfinden, ob wir etwas kaputtgemacht haben.

Jetzt geht es ans Eingemachte und es ist auch der größte Stretch: Wir müssen die Additionen loswerden. Dies können wir in einer Schleife machen. Wir benötigen eine Variable, die die Summe repräsentiert und am Anfang 0 ist. Dann addieren wir jedes Element aus unserer Datenreihe auf. Danach ersetzen wir die Additionen durch unsere neue Variable

if length == 3:
    sum = 0
    for elem in data:
        sum = sum + elem
    return sum / length

Die Tests laufen noch durch, also können wir weiter vereinfachen und die Abfragen für die unterschiedlichen Längen entfernen. Damit sieht unser Code nun so aus:

def calculate_mean(data):
    length = len(data)
    sum = 0
    for elem in data:
        sum = sum + elem
    return sum / length

Das kann sich doch schon sehen lassen!

Just to be sure – neuer Testfall

Wir testen jetzt, ob unsere Generalisierung auch für den Fall mit 4 Elementen funktioniert und fügen noch

    ([1, 2, 3, 4], 2.5),

hinzu. pytest gestartet, läuft noch!

Corner Cases

Um eine robuste Implementierung zu bekommen, müssen wir noch den Fall “leere Liste” abhandeln. Also fügen wir noch den Testfall

    ([], None),

hinzu. Das heißt wir erwarten, dass die Funktion None zurückgibt, wenn eine leere Liste übergeben wird. Das frühstücken wir mit einem

if length == 0:
    return

ab. Alternativ ließe sich natürlich auch eine Exception werfen.

Damit sind wir auch am Ende unserer kleinen TDD-Session.

Finale Worte

Dies ist ein Beispiel, wie sich TDD anwenden lässt. Die Anzahl der Zwischenschritte wirkt hier eventuell etwas künstlich hoch. Erfahrenere Entwickler würden wahrscheinlich dazu tendieren den Schritt mit der Summenberechnung direkt hinzuschreiben. Primär soll es aber darum gehen, die Abläufe im TDD zu üben (insbesondere die Rule of Three), daher ist die Implementierung die entstehen sollte bewusst einfach gewählt. Im Idealfall implementieren wir eine Mittelwertberechnung gar nicht selbst, sondern nutzen das statistics Modul.

Kompletter Code

import pytest

@pytest.mark.parametrize(
    "data, expected_mean",
    [
        ([], None),
        ([1], 1),
        ([2], 2),
        ([1, 2], 1.5),
        ([1, 2, 3], 2),
        ([1, 2, 3, 4], 2.5),
    ]
)
def test_mean(data, expected_mean):
    assert calculate_mean(data) == expected_mean


def calculate_mean(data):
    length = len(data)
    if length == 0:
        return
    sum = 0
    for elem in data:
        sum = sum + elem
    return sum / length

The post Wie TDD die Welt rettet (und deine Nerven schont) appeared first on Creatronix.

WebP is a modern image format that provides superior lossless and lossy compression for images on the web. It was developed by Google, and is designed to be smaller in size than other image formats, while still maintaining high image quality.

One reason WebP is often considered better than JPEG is that it can achieve significantly smaller file sizes for images with the same visual quality. This is because WebP uses more advanced compression techniques than JPEG, which allows it to reduce the size of the image data without sacrificing quality. This can be especially useful for websites, as smaller image sizes can lead to faster page load times and a better user experience.

In addition to its smaller file size, WebP also has other advantages over JPEG. It supports both lossless and lossy compression, so you can choose the right balance of file size and image quality for your needs. WebP also supports transparency, which can be useful for graphics and logos.

Overall, WebP is a modern image format that can provide improved compression and faster page load times, making it a good choice for use on the web.

Conversion with Pillow

Pillow supports webp as well. The cool thing is that the conversion can be done in a couple of lines:

def test_convert_to_webp():
    source = Path("pillow_webp-fi.jpg")
    destination = source.with_suffix(".webp")

    image = Image.open(source)
    image.save(destination, format="webp")

    path_webp = Path("pillow_webp-fi.webp")
    assert path_webp.exists()

Bottom line

After conversion the image size is cut in half (7.3 MB to 3.6MB) without any visual artifacts of compression.

Further Reading

How to create youtube thumbnails – pillow tutorial

The post Pillow how to convert images to webp appeared first on Creatronix.

The DRY (Don’t repeat yourself) principle does not only apply to code but to mouse clicks as well:
When you are repeatedly clicking buttons you might want to figure out some keyboard shortcuts.

In Jetbrains IDEs like PyCharm you can use the plugin Key Promotor X to learn these shortcuts.

Installation

• Open the File menu
• Choose Settings
• Go to Plugins
• Switch to marketplace
• Search for “Key Promoter X”
• Click “Install”
• Restart your IDE (if necessary)

Usage

After Key Promotor X is correctly installed it will nag you in two different ways to get your shortcut game up and running

Tool Window

Under View -> Tool windows you will find a new entry for Key Promotor X
If you enable the tool window you will get a list of your missed shortcuts sorted after frequency.

Alert

For every action you take in your IDE you will now get a notification. It shows you if there already is a shortcut or let’s you create one.

Further Reading

If you like to become more efficient please also read our articles about other shortcuts

My most used keyboard shortcuts in Windows 10

Shortcuts for Screenshots on macOS

Keyboard shortcuts for signals in the macOS terminal

How to enable spell checking for German in PyCharm

The post How to learn IDE Shortcuts with Key Promotor X appeared first on Creatronix.

https://adventofcode.com/2022/day/3

Problem

vJrwpWtwJgWrhcsFMMfFFhFp
jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL
PmmdzqPrVvPwwTWBwg
wMqvLMZHhHMvwLHjbvcjnnSBnvTQFn
ttgJtRGJQctTZtZT
CrZsJsPPZsGzwwsLwLmpwMDw

The first rucksack contains the items vJrwpWtwJgWrhcsFMMfFFhFp, which means its first compartment contains the items vJrwpWtwJgWr, while the second compartment contains the items hcsFMMfFFhFp. The only item type that appears in both compartments is lowercase p.
The second rucksack’s compartments contain jqHRNqRjqzjGDLGL and rsFMfFZSrLrFZsSL. The only item type that appears in both compartments is uppercase L.
The third rucksack’s compartments contain PmmdzqPrV and vPwwTWBwg; the only common item type is uppercase P.
The fourth rucksack’s compartments only share item type v.
The fifth rucksack’s compartments only share item type t.
The sixth rucksack’s compartments only share item type s.

To help prioritize item rearrangement, every item type can be converted to a priority:

Lowercase item types a through z have priorities 1 through 26.
Uppercase item types A through Z have priorities 27 through 52.

In the above example, the priority of the item type that appears in both compartments of each rucksack is 16 (p), 38 (L), 42 (P), 22 (v), 20 (t), and 19 (s); the sum of these is 157.

Find the item type that appears in both compartments of each rucksack. What is the sum of the priorities of those item types?

Solution

We put the sample data into a multi-line string:

data="""vJrwpWtwJgWrhcsFMMfFFhFp
jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL
PmmdzqPrVvPwwTWBwg
wMqvLMZHhHMvwLHjbvcjnnSBnvTQFn
ttgJtRGJQctTZtZT
CrZsJsPPZsGzwwsLwLmpwMDw"""

We check if we can get the first rucksack:

def test_split_rucksacks():
    first_rucksack = data.split("\n")[0]
    assert first_rucksack == "vJrwpWtwJgWrhcsFMMfFFhFp"

Due to different length of each rucksack we need to determine the splitting point:

def test_split_rucksack_items():
    first_rucksack = data.split("\n")[0]
    split_point = len(first_rucksack)//2
    first_rucksack_item = first_rucksack[0:split_point]
    assert first_rucksack_item == "vJrwpWtwJgWr"
    second_rucksack_item = first_rucksack[split_point:]
    assert second_rucksack_item == "hcsFMMfFFhFp"

A neat solution for checking common characters is putting the strings into sets and logically and them

def test_check_common_char():
    first_rucksack_item = "vJrwpWtwJgWr"
    second_rucksack_item = "hcsFMMfFFhFp"
    a = list(set(first_rucksack_item) & set(second_rucksack_item))
    assert a == ['p']

To get the corresponding value for the characters we use the built-in ascii_letters:

def test_lookup_char_value():
    chars = string.ascii_letters
    value = chars.index('p') + 1
    assert value == 16

    value = chars.index('L') + 1
    assert value == 38

Putting it all together:

def test_sum_priorities_data():
    with open("aoc_data_03.txt", "r") as f:
        data_from_file = f.read()
    sum_of_list = 0
    chars = string.ascii_letters
    rucksacks = data_from_file.split("\n")
    for rucksack in rucksacks:
        split_point = len(rucksack) // 2
        first_rucksack_item = rucksack[0:split_point]
        second_rucksack_item = rucksack[split_point:]
        common_char = list(set(first_rucksack_item) & set(second_rucksack_item))
        value = chars.index(common_char[0]) + 1
        sum_of_list += value
    assert sum_of_list == 8202

The post Advent of Code 2022 Day 3 appeared first on Creatronix.