Transcript: FastAPI

Ja, hallo, liebe Hörerinnen und Hörer, willkommen beim Python-Podcast, Episode 39.

Heute reden wir mit euch über FastAPI.

Hi, Jochen.

Ja, hallo, herzlich willkommen, Dominik.

Wir sind mal wieder im schönen Wintergarten, es ist noch relativ dunkel draußen heute mal wieder.

Ja.

Ja, und sind schon ganz gespannt, was ihr uns für Feedback gebt an hallo-at-python-podcast.de.

Genau.

Ja, machen wir wie immer so ein bisschen zuerst News oder so.

Heute haben wir auch keinen Gast irgendwie oder so, sondern...

Nur wir zwei.

Das schaffen wir.

Vielleicht können wir das auch gar nicht mehr. Mal schauen.

Es gibt ja heute ein bisschen Werbung.

Wir sind immer noch gesponsert.

Falls ihr das total doof findet, schreibt uns doch einfach.

Dann überlegen wir, ob wir es direkt wieder sein lassen.

Okay, was haben wir denn so an News?

Wir haben also einen

Pepp, der eigentlich ganz interessant

aussah. Pepp

665.

Kurz bevor The Devil, ich habe geguckt, 666 war schon

seit 2001 belegt.

Ja, die ganzen interessanten Nummern sind alle schon

irgendwie, da haben sich Leute schon viele Gedanken

zu gemacht, was man damit machen könnte.

Ja, um ein

Log-File-Format, also

das gibt es ja, also Log-Files zum

Festnageln von...

Also nicht File, dann Log-File.

Ja, mit CK.

Das gibt es ja

in diversen, also bei Poetry macht das halt,

PipTools macht das,

aber es gibt keinen Standard

dafür und deswegen ist das halt immer ein bisschen

schwierig und

ja, da war halt die Idee, dass

mal so zu standardisieren, zumindest für

Binary-Installationen, weil das geht

eigentlich auch nur so richtig gut für Wheels,

weil bei Source-Distributionen oder so ist halt

unklar, was ist denn jetzt eigentlich der Hash da?

Worüber macht man den denn jetzt?

Also, wobei bei Wheels ist es halt relativ einfach.

Genau, und das war der Pep dazu

von Bracken, der sich

jetzt auch seit einiger Zeit relativ intensiv da mit diesem

ganzen Packaging-Thema beschäftigt hat.

Und ja, das wäre halt eine schöne Gelegenheit

gewesen, das mal zu standardisieren, aber

wurde abgelehnt.

Der war nochmal Bracken, ne?

ist einer aus dem Steering Council

und auch irgendwie, der

macht, glaube ich, eigentlich ist der so, der

verantwortlich für

VSCode-Python-Integration

bei Microsoft, aber der ist eine

ganz bekannte Figur da in der

Python-Entwicklungsszene.

Und weißt du auch noch, warum das abgelehnt worden ist, das PEP?

Ja, weil es eben keine Source-Distribution

irgendwie mit umfasst und

du kannst halt damit dann nur Sachen,

wo es ein Wheel gibt, das locken und dann ist

halt irgendwie, viele sagen dann, das

bringt dann nicht so viel und

Und ach ja, naja, mal schauen.

Vielleicht mal sehen, wie das da so weitergeht.

Vielleicht denkt sich irgendjemand aus,

wie man auch Source-Sachen hashen kann oder so.

Ja, oder vielleicht gibt es da mal was ganz anderes.

Keine Ahnung, mal abwarten.

Das ist Packaging-Problem.

Man könnte ja den Source in einen ZIP runterladen,

den ZIP hashen und dann entpacken.

Naja, also es ist nicht so einfach.

Ja, genau.

Nächste News.

Nächste, was sehr schön ist.

WebAssembly.

WebAssembly ist C-Python, kompiliert komplett

nach, also das ist wirklich

das richtige C-Python, nicht irgendwie

kompiliert nach WebAssembly und

ja, kann man im Browser ausführen. Also es

gehen da natürlich noch viele Dinge noch nicht, aber

dass das überhaupt klappt, ist halt

schon mal irgendwie sehr interessant

und eine sehr gute Nachricht. Das heißt, irgendwann kann man

tatsächlich Python schreiben,

in C-Python kompilieren und dann einfach im

Browser laufen. Nee, der kompiliert mal nichts.

Du nimmst einfach, nein, C-Python ist der Interpreter

von Python. Der ist nach WebAssembly,

Das heißt, der läuft dann sozusagen im Browser

zum Beispiel oder auf irgendwas, was halt

WebAssembly ausführen kann. Und

dann kannst du da einfach Python hinschicken und dann

kann das das ausführen. Das heißt, du schickst

da quasi vom Server Python

Source-Files an den Browserskunden

und das wird dann da. Ja, der könnte das ausführen.

Ist natürlich

so die ganze Umgebung und so,

das ist natürlich dann nicht so wirklich wie

normalerweise.

Du musst halt mit den rechten Beschränkungen klarkommen,

die es dann wahrscheinlich gibt. Ja, und noch diverse

andere Geschichten. Du kannst ja auch nicht irgendwelche Sachen installieren und so, aber

und irgendwie C-Extensions und so,

das geht wahrscheinlich alles nicht, aber

dass das überhaupt geklappt hat, ist schon mal

So wird JavaScript halt endlich

wegschmeißen. Nee, also

das fürchte ich, wird

das aber, aber es ist halt

auf jeden Fall ein Ding, was dazu führen kann,

dass man da

eventuell nicht in so ein

Aussterbeproblem läuft, weil halt alles

irgendwann im Browser ist und so, dann kann man da

vielleicht auch sein oder so, mal schauen.

Was ist so ein Use Case von so WebAssembly

Zeugs? Ja, zum Beispiel

eben im Browser

halt laufen, aber auch eventuell in Zukunft

irgendwann wird es halt vielleicht auch so sein, dass

Telefone oder so das halt irgendwie nativ

ausführen.

Ich meine auch, also

unter iOS oder die

iPhones, die haben ja, da ist ja ganz viel

optimierter Kram auch für

JavaScript schon drin, aber auch für WebAssembly

ist es halt

ja, also da sozusagen das so

zu machen, dass man da den Kram halt auch irgendwie

ausführen kann, das wäre eigentlich relativ einfach.

Das heißt, der macht dann direkt dein Telefon mit die Datenanalyse

live auf dem Gerät direkt oder sowas?

Man könnte sagen, also das kann halt

auch WebAssembly ausführen. Also momentan zum Beispiel

wenn du für iOS entwickelst, geht halt nur

C,

C++, Objective-C,

Swift.

Es gibt zwar auch

Pythonista und so, man kann schon Python da ausführen,

das geht auch, aber das ist alles nicht

so richtig offiziell erlaubt.

Und ja,

JavaScript geht halt auch.

Und vielleicht ist halt

irgendwie WebAssembly irgendwann mal so ein offizielles

Target und dann

könnte man auch Python da so wieder reinschummeln

quasi. Und dann Apps für

Telefone in Python schreiben.

Was ja auch so ein anderes Problem ist.

Die beiden Hauptdinger, auf denen Python nicht da ist,

ist halt Frontend-Web und

halt mobile Geräte.

Und das sind zwei Kategorien, die immens wichtig sind

eigentlich. Und das macht so ein bisschen

Angst, dass die Story für Python da nicht so gut ist.

Aber gut, dass das in die richtige Richtung geht.

Ja, genau.

Genau, Christian Heim ist Hamburger

Python-User-Gruppe, irgendwie

ein paar Mal gesehen, hat da ganz viel gemacht

und das freut mich sehr, dass das irgendwie

coole Sachen macht.

Dann ist Black

jetzt stable. Black ist stable.

Das ist,

ja, genau, das ist toll.

Oder so. Manche Leute finden es auch schrecklich,

aber ich finde es eigentlich eine gute Nachricht.

Das heißt, man kann sich jetzt darauf verlassen, dass das erstmal

eine Zeit lang alles so bleiben wird. Was auch mit

dazugekommen ist, ist Port für Python

3.10-Syntax und so und

ja, eine ganze lange Liste von Dingen, die da

Und damit ist jetzt auch die DIP,

die Django Enhancement Proposal

Ah, ja, ja, ja, es gab

Django Enhancement Proposal

8 sagt irgendwie, lass doch mal

Autofarmata benutzen, aber erst

wenn es Stable ist und genau,

da Blackhead Stable ist, ist Django

jetzt auch quasi mit Black formatiert

und ja.

Ja, wir hatten ja schon mal darüber gesprochen,

wie man Black noch so einsetzen kann mit

Darker oder

Blue war das? Ja, Blue ist halt dann mit

Single Quotes statt Double. Genau, und

Darker ist halt inkrementelles

Black Bike mit

Hooks zum Beispiel.

Ja gut, aber genau, Jungle ist jetzt auch Black.

PyTest. PyTest gibt es

eine neue Version, sieben Seiten.

Der letzte kam irgendwann im Frühjahr letzten

Jahres oder so raus, also das ist ein ganz großer Schritt.

Ich weiß aber gar nicht genau, also es ist nichts, was jetzt irgendwie

rausstechen würde, was man sagen kann, oh das ist ganz toll.

Aber kann man ja mal ausprobieren.

Also die Information, es gibt jetzt eine neue

Version ist vielleicht daran am interessantesten.

Ja,

ansonsten genau zu der

zu der HTMX-Episode

vom letzten Mal. Es gab da noch so ein Essay

von, das habe ich dann gesehen, als ich gedacht habe,

okay, kann man das nicht vielleicht irgendwie einfacher erklären mit diesem

HTUS-Ding?

Was ist das eigentlich? Und so

und habe dann gesehen, es gibt ein

Essay von dem Carson Gross

dazu,

wo er

beschreibt, wie er sich so

gedacht hat und nimmt da halt so ein Bankbeispiel

und sagt halt,

also wenn du eine JSON-API hast, dann

muss, wenn du so eine

JavaScript-Applikation hast, dann muss

ja

sozusagen die Applikation

immer wissen, was zum Beispiel sowas bedeutet,

wie du hast dein Konto überzogen

und welche Aktionen

du dann machen darfst und welche nicht.

Während wenn du halt HTML rüberschickst, dann

können da ja zum Beispiel, ob du jetzt eine Überweisung

machen kannst oder so, ist halt ein Link.

Dann kann der Link da halt entweder drin sein oder nicht.

und dein Browser muss halt nicht wissen, dass du dein Konto überzogen hast, der zeigt einfach nur Formulare an und das Formular zum Überweisen zeigt dir halt einfach nicht mehr an und sozusagen der State, dass der das dann nicht mehr anzeigt, ist halt im HTML und nicht in der Applikation, während in einem JavaScript-Fall kriegst du halt nur die Account-Daten von der Bank und musst dann halt in der Applikation überprüfen, okay, hat er sein Konto überzogen?

Wenn ja, dann darf er nicht überweisen.

Und das ist natürlich sozusagen

einfach ein bisschen anders. Und vielleicht kann man sich das

anhand dieser Geschichte, ich will verlinken,

packen das in die Shownotes. Also ich fand, daran kann man

eigentlich ganz schön sehen, was da eigentlich so gemeint ist

mit Hypermedia

ist die Engine of Application State

nicht.

Was gab es noch? Ach ja, Wagtail.

Wagtail, genau.

Wagtail bekommt einen neuen Page Editor

und zwar von Google.

Genau, von Google gesponsert.

weil Google relativ viel Wagtail wohl intern

benutzt.

Ja, und das ist natürlich schon nett. Also ist

es nicht so wahnsinnig viel Geld, irgendwie, was

sind das, 150.000 Dollar oder so, die sie denen geben,

aber ich meine, da kannst du halt schon

ein bisschen was mit machen und

ja, also freut mich auf jeden Fall auch, dass die Ergebnisse

dann halt allen hinterher zugutekommen, das ist ja

sehr schön.

Genau, und ja, ich meine, ich benutze

ja jetzt auch für meine Geschichten da

Wagtail. Ich bin nicht immer so

ganz super überzeugt, ob das die richtige Entscheidung ist, aber

solche Nachrichten sind auch gute Nachrichten

für mich.

Apropos Open Source,

da gab es doch irgendwie noch eine Meldung von uns.

Ja, Oliver

hat netterweise einen Kommentar

zu der Open Source Episode, glaube ich,

hinterlassen und meinte, da kennt ihr eigentlich diesen

Prototype Fund.

Und nö, kannte ich zumindest überhaupt gar nicht.

Ja, man sagte mir auch nichts.

Und was ist das? Das ist irgendwie

ein Fonds, der

aufgelegt ist, das Bildungsministerium

zahlt dann irgendwie für,

also das geht vom Jahr

2016 bis 2024,

25 Projekte und

16

Förderungsrunden und

also, ja, da sind wir

natürlich jetzt mit 2022 so mittendrin

oder am Ende eigentlich schon fast.

Ja, wenn der jetzt noch einen Förderantrag schreiben will,

also das Problem ist wahrscheinlich immer, der Förderantrag ist relativ

lang, aber ja,

wie immer so bei solchen Dingen, aber

wie viel kriegt man? 50k für 6 Monate?

Ja, 47.500 Euro für 6 Monate

maximal, also vielleicht auch weniger.

Doch, dann dachte ich so, oh,

für ein Team,

die helfen, ja.

Also ich meine, tatsächlich mache ich ja eigentlich genau

das, da steht auch noch in diesem Ding drin, so für Freelancer

oder so, vielleicht ganz interessant, da dachte ich mir so, oh ja, stimmt.

Eigentlich mache ich genau sowas und

eigentlich wäre das ja tatsächlich, vielleicht schreibe ich da

einfach mal was hin, aber andererseits,

ja, so vom Finanziell

ist das jetzt nicht so super attraktiv, ehrlich gesagt.

Und für ein Team ist das natürlich,

ja, nee.

Ja, da kann man, ja, ja.

Ach ja.

Tja, die Preise und so, öffentliche Hand.

Ja, aber prinzipiell sehr interessant

und auch gut, dass das jemand macht,

weil das ist eigentlich total wichtig

und müsste man eigentlich noch mehr machen.

Aber immerhin, das ist ja schon nicht so schlecht.

Und vielleicht weiß ja jemand noch nicht, dass es das gibt.

Ja, und wenn jemand zum Beispiel gerade nach dem Studium

damit durchaus zufrieden sein kann

und dann damit was probieren kann

und damit gefühlt wird, das ist auch schon mal super.

Ja, dann, das war auch jetzt

vor ganz kurzem

EdgeDB 1.0

Release ist vielleicht auch interessant.

Ja,

muss man eigentlich, ich weiß nicht, ob man da so

in Detail drauf eingehen kann.

Aber was ist denn eine EdgeDB trotzdem?

EdgeDB ist, ja,

quasi

ein Versuch, sozusagen

diesen Object Relational

Impedance

Mismatch, irgendwie so ein bisschen.

Okay, jetzt hast du was gesagt, das habe ich überhaupt nicht verstanden.

Edge Relational

in... Object Relational...

Also du hast ja immer das

Problem in

objektorientierten Sprachen, das mappt halt

nicht so richtig gut auf

relationale Datenbanken. Relationale Datenbanken

ist halt so eine Idee aus Anfang

der 70er und

eigentlich eine ziemlich coole Idee, aber damals gab es

objektorientierte Programmierung und sowas gab es einfach nicht.

Und das ist aber

irgendwie das dominante Programmierparadigma

irgendwie geworden.

Und jetzt haben wir halt immer das Problem,

okay, man speichert die Daten

halt in Relationen

oder in einer relationalen Datenbank und man hat aber jetzt

Objekte irgendwie

in der Applikation

und wie kriegt man das jetzt zusammen?

Da gibt es im Grunde zwei wesentliche, also

du kannst auch hohe SQL-Szenen natürlich schreiben, aber

das ist halt so ein bisschen unhandlich.

Die meisten verwenden dann eben

ORMs, also so

Object Relational Mapper.

Wie den von Django oder Peewee oder sowas.

Genau, oder SQL Alchemies für Python

vielleicht der bekannteste.

Und da gibt es zwei grundsätzlich unterschiedliche

Patterns. Das eine ist Active Record Pattern,

was halt Ruby on Rails

verwendet. Django verwendet das auch.

Oder halt Datamapper-Pattern,

das verwendet SQL Alchemy.

Die haben halt so ihre Trade-Offs.

Die haben halt Vorurteile und Nachteile.

Man kann jetzt nicht sagen, das eine oder andere ist besser.

Jedenfalls, aber

sowas muss man halt eigentlich, oder die meisten Leute

verwenden sowas heutzutage einfach deswegen, weil es

halt das Leben einfach deutlich leichter macht.

Aber trotzdem hat man immer noch das Problem,

dass viele Sachen nicht so richtig gut

gehen und schwierig sind.

Und man muss mit den Dingern auch teilweise ein bisschen kämpfen.

Und ja, die Idee bei HDB ist halt einfach zu sagen,

warum denken wir das Ganze nicht einfach nochmal neu

und machen das halt eher so,

dass die Datenhaltung auch zu der Art,

wie wir heutzutage programmieren, besser passt.

Und die Standardfälle,

wo man halt in SQL komische Sachen schreiben muss

oder die mit den normalen ORMs nicht so gut gehen,

die machen wir halt so, dass es halt einfach geht.

und dass man auch,

das ist halt immer so ein Fremdkörper,

selbst wenn man es mit einem ORM macht,

es sieht immer komisch aus,

ein bisschen eigenartig, es passt halt

nicht so richtig und

genau, dafür haben sie sich eine neue Sprache überlegt,

haben gesagt, das eigentliche Problem ist halt, warum die

ORMs nicht so gut sein können, ist halt, dass sie,

dass halt SQL als Compile-Target

sozusagen ziemlich schwierig ist, weil halt

SQL ist ja auch kompliziert, ist eigentlich auch dafür

gemacht, dass Menschen das schreiben,

was ja heute auch keiner mehr macht, eigentlich war das mal gedacht

für das Analysten und so

Queries schreiben.

Weiß ich nicht, ob das jemals passiert ist, aber

heutzutage passiert das kaum, denke ich.

Sondern

es ist halt immer so, dass du verwendest

halt einen ORM, der compiled dann zu SQL,

also zu etwas, was eigentlich dafür gemacht ist, dass Menschen

das finden, das macht irgendwie alles keinen Sinn.

Dann ist es halt auch so, SQL ist nicht so gut composable,

du kannst halt nicht irgendwie

Schnipsel SQL rumreichen und die dann halt

zusammensetzen oder es geht alles nicht so gut.

Das ist eine Gesamtstatement-Syndromie.

Und genau, all diese Dinge sind halt bei

EdgeQL oder so ist, glaube ich, dann die

Sprache besser

sozusagen. Aber da weiß man nicht so genau.

Das ist halt jetzt gerade eine neue Ankündigung.

Die entwickeln da schon seit ein paar Jahren dran, aber

jetzt ist halt die erste

1.0-Version erschienen.

Ja, also

das hört sich auf jeden Fall interessant an. Kann man sich

ja mal angucken. Und es ist halt so eine Mischung.

Das, was sie da gebaut haben, ist

die Sprache soll halt standardisiert

werden. Das ist eher so ein Standard.

Es gibt aber auch eine konkrete Implementation, die

basiert auf

Postgres und

quasi so ein bisschen Erweiterung

Richtung Graphen, Datenbanken,

weil das ist ja auch immer so ein Ding,

es ist eigentlich gar nicht so klar, warum wir jetzt Relationale Datenbanken gewonnen haben

gegenüber den Graphen-Datenbanken und es gibt

ja auch noch Graphen-Datenbanken, Neo4j oder

diverse andere, Dgraph

und Zeugs und

ja, eigentlich will man beides irgendwie haben und

in Postgres kann man das ja ganz gut

auch abbilden und dann haben sie

halt irgendwie so ein Layer über Postgres gelegt und

Ah, wie heißt das? Ein Layer über Postgres?

Klingt ja spannend. Also es klingt auch so, als könnte man das

mit Fast-IP benutzen.

Ja, die haben auch,

also die Leute, die das gemacht haben,

das sind bekannte Leute, das ist nicht so,

dass das irgendwie aus dem Nichts kommt,

sondern

der CEO

von HDB ist dann auch eine Firma,

das macht das Ganze wieder so ein bisschen, ich weiß nicht genau,

die machen halt vor allen Dingen, die haben viel Consulting gemacht

und haben halt viele Probleme gesehen auch,

die man halt

normalerweise so hat.

Ja, der

wie heißt der, Jure Selin

der hat auch

an den

Peps zu

Async Await diese ganzen Geschichten, da hat er hauptsächlich

dran mitgeschrieben, also der ist halt

auch einer der Hauptverantwortlichen

dafür, dass wir jetzt in Python

Keywords für Async Await

also Syntax-Unterstützung

für diese ganzen Async-Geschichten haben

und hat da auch

ganz viele Dinge implementiert und

Lukas Schlanger hat

irgendwie für RGB auch gearbeitet schon

und ja, es ist alles

typisiert, genau, das ist auch sowas.

Den letzten Namen hatte ich jetzt auch noch nicht gehört.

Lukas? Der Release-Manager von Python

für 3.8, 3.9, 3.10.

Ah, okay. Nee, nicht für 3.10, nicht Quatsch.

Das ist Unsinn.

Oder vielleicht noch sogar früher,

ich weiß es gar nicht mehr genau.

Und der, ja, auch ganz einer,

der hat ganz viel zu

Type-Annotation-Geschichten gemacht, der hat Black geschrieben,

genau.

naja, also auch

sehr bekannte

Typ da und

ja, genau, der hatte

und Async.io hat halt mit halt auch

viel zu tun und

das ist alles, die haben auch, genau, die haben

auch

Async.pg geschrieben, das ist halt

die schnellste Postgres-Artenanbindung

sozusagen, die es so gibt.

Ist auch ein ganz tolles Projekt,

also muss man sich, ja,

dann haben sie, genau, haben sie

UV-Loop geschrieben, also das Ding, was halt

unter UV-Corn und so

drunter liegt.

Also eine schnelle Async-IO-Implementation,

die in der Standardbibliothek ist ja sozusagen

nur eine Referenz-Implementation, aber die ist halt

nicht schnell. Und sie haben halt eine schnelle

Version geschrieben, also ganz viel der

Basis-Infrastruktur, die man so, kommt da auch aus

der Ecke schon. Insofern, das

sind schon Leute, die wissen, was sie da tun.

Dann darf man auch ein bisschen Werbung für seine Projekte machen.

Genau, wobei, ja, Firma ist natürlich

Was uns ja zur Werbung bringt.

Moment, wir sind noch nicht mit den News durch.

Wir sind noch nicht mit den News durch.

Achso, was Geheimes, das ich noch gar nicht weiß.

Also

einen Punkt noch, genau, ich habe wieder Podcast

gehört, Problemierbar hat jetzt auch was über

letzte Episode, das war

Laravel, PHP,

Livewire,

das fand ich auch ganz interessant, weil immer so diese

Verbindungen finde ich immer interessant, weil die vielleicht nicht so

klar sind oder mir nicht so klar waren

und wenn man das dann weiß, dann

macht das halt das alles schon mal ein bisschen

verständlicher, nämlich

Laravel

Livewire ist auch tatsächlich

inspiriert von Phoenix Liveview.

Ist aber auch schon ein bisschen älter,

das ist von 2019. Ich hätte das jetzt gedacht, dass es

jünger ist, aber das ist auch schon relativ lange quasi dabei.

Also bei diesem Trend, die Dinge jetzt wieder

vom Server aus zu machen. Und der

Autor von Livewire ist der gleiche wie der von

Alpine.js. Das ist halt, wie heißt der?

Caleb.

Habe ich jetzt den Namen vergessen, aber

irgendwas mit P.

Und Portio, oder

wieso? Und

genau, der hat AlpineJS gebaut und halt aber auch

LiveWire. Und der wollte

eigentlich ja sowas eben wie PhoenixLiveView

bauen. Und dann

ist aber das Problem mit dem PHP,

naja, also so WebSockets,

also PhoenixLiveView macht das ja über

WebSockets. Das geht halt mit PHP

nicht so richtig, weil du hast halt den Async-Teil

in PHP nicht. Also gibt's jetzt

auch seit PHP 8.1,

das ja auch vor ein paar Monaten rausgekommen ist.

Aber es gibt

keine Infrastruktur so richtig dafür und die ganzen

Russer können das nicht und so. Das heißt,

quasi eine Verbindung offen

halten vom Server aus ist in

PHP sehr, sehr schwierig. Das geht eigentlich gar nicht richtig.

Und dann hat er halt angefangen nachzudenken,

so okay, ja Mist, mit WebSocket

das wird irgendwie nicht funktionieren. Wie kann man das

denn sonst machen? Und die machen das,

der macht das auch alles über

AJAX-Calls und Pollen

und, ja, sie

machen so ein bisschen komplizierte Dinge darüber, dass sie

halt immer alles mit übertragen, wenn sobald

irgendwie ein AJAX-Call gemacht wird. Aber

was ich daran cool finde, ist, dass das überhaupt geht

und dass man den Websocket gar nicht so

unbedingt braucht. Also das zeigt das

auf jeden Fall irgendwie. Man kann halt sehr viel machen,

ohne unbedingt einen Websocket haben zu müssen

und das ist eigentlich auch sehr nett, weil

tatsächlich, so Websocket

wird es wahrscheinlich in Django ohne

Django-Channels-Anstützung oder so auch wahrscheinlich nie geben.

Und daher,

aber offenbar scheint man

braucht es auch nicht unbedingt.

Das ist interessant, da können wir vielleicht gleich nochmal drauf eingehen und sagen,

warum oder was FastAPI

Genau, aber mit Fast-TP

könnte man das wahrscheinlich sehr gut machen.

Genau.

Ja, das war's eigentlich.

Ich glaube, das probiere ich

nächstes Mal aus. Habe ich auf Twitter gesehen.

Dachte ich, kann ich hier auch mal anbringen.

Wenn jemand anders das auch

Twitter hat, hat jemand

irgendwie geschrieben.

Jetzt war ich beim Zahnarzt und da hat er

irgendwie

wurde gerückt, beziehungsweise

Moment, warte, gerade dein Zahnarzt

Okay, nochmal.

Nicht ich, ich hab nur gelesen, ich hab es auf Twitter gelesen.

Ja gut, da meint jemand dann, ja, also manchmal fühlt man sich ja so ausgeliefert, wenn man so beim Zahnarzt sitzt, ne, und dann kriegt man auch noch irgendwie so harsche Ansagen wie irgendwie, benutzen Sie eine Zahnseide, ja, Mund auf und dann so, was ist das denn hier, irgendwie, benutzen Sie eigentlich Zahnseide, warum nicht, macht das doch mal bitte häufiger.

Und der meinte dann so, ja, ich habe dann, also nachdem ich diese Zahnseide-Geschichte darauf so hingewiesen worden bin, habe ich dann gefragt, ja, wie sieht es eigentlich bei Ihnen aus, machen Sie Backups?

Und prüfen Sie die auch, ob Sie die ab und zu mal einspielen, ob das überhaupt geht, also wäre schon gut, wenn man das macht, ansonsten, ja.

Das war eine Geschichte, habe ich auch irgendwo im Talk gesehen.

Kein Mitleid.

Kongress, glaube ich sogar.

Schön, muss ich mir merken, muss ich auch mal versuchen

anzubringen. Ja, habe ich mir auch fest vorgenommen,

wenn ich es in Zahlen suche, wenn dann die Frage

kommt, und machen sie eigentlich ihre Backups?

Genau, ja. So, aber jetzt glaube ich,

dann sind wir mit den News durch. Ja, okay.

Ja, okay. Dann wollen wir jetzt wieder

Werbung schalten, also wir wollen nicht, aber wir müssen natürlich.

Ja.

Und wieder mit freundlicher Unterstützung heute von

unserem Werbepartner NordVPN.

Gibt es was Neues?

Ja, ein Exklusiv-Deal

und ein Geschenk obendrauf zum NordVPN-Geburtstag.

Und dann könnt ihr auf den NordVPN-Python-Podcast gehen

und euch den Deal da sichern.

Und da gibt es auch so eine 30-Tage-Geld-Zurück-Garantie.

Genau.

Hatten wir ja auch letztes Mal schon.

Ja, genau.

Ich weiß nicht, benutzt du VPNs irgendwie?

Relativ selten, aber ich glaube,

zum Geoblocking umgehen ist das gar nicht so schlecht.

Ist wahrscheinlich so schlecht, ja.

Wenn du Streaming haben möchtest

und möchtest du irgendwie das Streaming-Programm von zu Hause gucken,

wenn du im Urlaub bist oder so,

ist das doch gar nicht so unnützlich.

Genau, also diese

Geoblocking-Geschichten oder halt auch eben

wenn man sicherstellen möchte,

dass man genug Durchsatz hat

und das irgendwie vom lokalen ISP

vielleicht nicht unbedingt zu erwarten ist,

dann kann das durchaus

hilfreich sein.

Ja, also genau, einfach da

auf https.nordvpn.com

slash pythonpodcast gehen und mal

angucken, was da so von dir gibt.

Genau, damit würdet ihr uns unterstützen.

Jo.

Dann machen wir weiter im Programm

und gehen zu FastAPI.

Ja, FastAPI, das Thema.

Genau, das Thema unserer Folge.

Was ist denn FastAPI überhaupt?

Also es ist ein weiteres Web-Framework, ein neues

Web-Framework und

ersetzt, oder was heißt ersetzt, also ergänzt

vielleicht so ein bisschen die Welt, die es in Python dazu gibt.

Ja, das ist sehr interessant.

Also genau, also eigentlich

die meisten anderen Sachen sind ja sehr alt, also Flask ist

sehr alt, Django ist sehr alt.

Also wenn ich das so richtig verstanden habe,

ist FastAPI quasi das neue Flask, das setzt

du das so ein bisschen, was man da gemacht hat?

Ja, also es ist auf jeden Fall eher, also es kommt

darauf an, aber also auf jeden Fall ist es eher

vergleichbar

mit Flask quasi, was die so

grundsätzliche, den grundsätzlichen

Ansatz angeht, aber

ja, es ist halt auch irgendwie wieder so ein bisschen anders

insofern, aber es ist einfach historisch, man hatte

so eine Explosion von irgendwie unterschiedlichen

Webframework-Projekten

irgendwann halt um diesen Dreh, wo die alle entstanden

sind, 2004, 5, 6, irgendwie so.

Pyramid ist auch aus der Zeit, oder?

Das weiß ich nicht, es kann sein, dass das auch

später, weil ich weiß es nicht so genau

bei Pyramid, aber so viele

Web-Frameworks

kommen halt aus der Zeit.

Oder da gab es halt ganz, ganz viele. Da gab es

so eine Zeit, wo alle zwei Monate

irgendwie was Neues rausgekommen ist.

So wie jetzt bei JavaScript.

Und ja,

die meisten sind wieder verschwunden.

Ich weiß nicht, was gab es damals? Also TurboGears

und ach, was ist der Teufel?

Naja, das meiste ist halt alles wieder

verschwunden und übrig geblieben sind

im Grunde Flask und Django.

Und die repräsentieren ja auch so

irgendwie

gegensätzliche,

die Enden von irgendwie so, also entweder

Batteries included oder halt irgendwie sehr

wenig dabei, aber dafür sehr flexibel.

Ja, genau.

Also der Unterschied auch mit den URMs hatten wir eben schon

gesprochen, dass halt Django

den URM mitliefert

und dass du bei Flask meistens die Core-Icony nimmst.

Ja, aber kannst halt auch irgendwas anderes

nehmen, also bist du halt nicht...

Hast da keine feste Bindung und...

Ja, aber irgendwie seit ein paar Jahren

gibt es halt sowas Ähnliches wieder.

Es gibt wieder viele neue Web-Frameworks.

Also was vor allen Dingen an der neuen Syntax bei Python ist,

liegt halt an der Sprache, dass sie sich geändert hat.

Genau, an den Typefilms, die es dazu gekommen sind.

Typefilms, Async.io.

Genau, das ist Async.

Und was unter FastAPI drunter liegt, ist ja Starlet.

Starlet, genau.

Ja, vielleicht kann man das so ein bisschen

in die ganze Historie so ein bisschen kurz erzählen.

eben, wir sehen so Async-Web-Frameworks

jetzt wieder ganz viele, so Scenic,

Falcon, FastAPI,

Quad,

also jetzt gibt es auch wieder ganz viele

und

der Autor von

FastAPI hat sich auch viele angeguckt

und hat das vorher schon...

Sebastian Ramirez, also Tiandolo,

der viele andere coole Sachen noch macht nebenbei,

neben FastAPI. Also Typer ist auch

sehr ähnlich und dann gibt es auch SQL-Model,

wenn man das irgendwie mit dem OEM machen möchte.

Aber vielleicht erstmal nochmal, was du sagen wolltest.

Genau, der hat viel

Django gemacht oder viel mit anderen,

der hat auch viel APIs gemacht

und war auf der Suche nach einem

Framework, das halt irgendwie bessere

Entwickler-Experience

irgendwie bietet. Also Django REST

Framework oder so.

Er fand das jetzt nicht schlecht, er fand das schon gut.

Also er hat sich halt auch, also die

Browsable API bei Django REST

Framework, es war halt auch eine wesentliche

Inspiration für das, was er dann halt da gemacht hat.

Und fand

das schon gut, aber

es war halt nicht alles dabei,

was er gerne gehabt hätte und

ja,

dann war aber ein Ding

fast perfekt. Also er hat sich

zum Beispiel, Django Rest Framework hat er sich viele Sachen

angeschaut, die er gut fand, aber es war halt nicht.

Dann hat er sich Marshmallow angeguckt, bei Flask

fand er auch gut, diese ganze

Validierungsgeschichten und Serialisierung

von ganzen Objekt-Hierarchien

und so, aber das ist halt

auch noch nicht so

hundertprozentig hat das das getroffen, was er

irgendwie haben wollte. Und

es gab noch ein paar andere Sachen, die er sich auch angeguckt hat.

dann

hat er

sich dann der Autor von

Jungle Rest Framework, Tom Christie, ist ja

auch so einer, der hat ganz, ganz viele Projekte gemacht.

Und

viele Dinge sind auch Basisinfrastruktur für ganz

viele andere Sachen. Also

er hat Jungle Rest Framework irgendwann mal geschrieben.

Dann hat er irgendwann Jungle Rest Framework

quasi abgegeben oder

macht es, weil

ehrlich gesagt ist es auch mehr oder weniger fertig, da ändert sich

schon seit einigen Jahren nicht mehr viel

und hat dann

etwas gemacht, wollte aber schon

APIs weitermachen und hat dann API-Star

mal ins Leben gerufen

und die Idee dabei war halt auch

so ein bisschen irgendwie

das so zu machen, dass es halt von der Kommandozeile

ausgeht plus irgendwie im Web,

dass es halt alles das gleiche Interface hat mit Typen

dran und nativ Async

und all sowas und

genau

Sebastian Ramirez meinte dann auch so,

ja, das war eigentlich schon genau das, was ich gerne gehabt hätte.

Und dann hat er aber

Tom Christie irgendwie angefangen, Starlet zu entwickeln.

Also

auch ein Web-Framework, aber sehr

Basis-Infrastruktur-mäßig, sehr

auf Async fokussiert und gar nicht mehr unbedingt

im API-Bereich. Und AP Star

ist dann eher zu so einem Schema-

Validierungstool geworden.

Und das heißt, das Ding, was

er am besten fand eigentlich oder am besten zu seinen

Anforderungen passte, hat plötzlich

den Fokus gewechselt und was anderes gemacht.

Und dann dachte er so, oh Mist, jetzt gibt's

nix mehr. Jetzt muss ich irgendwie,

ich wollte es wirklich vermeiden, aber jetzt muss ich es vielleicht doch selber

in ein Webfile beschreiben. Und dann hat er das halt

gemacht und dabei ist FastAPI

rausgekommen. Und dabei hat er, glaube ich, relativ viel

auch noch an Pidentic mit rumgewerkelt,

wenn ich das so gesehen habe. Ja, genau. Pidentic

ist halt eine der Geschichten,

die sonst nirgendwo drin sind, die halt da mit

dabei sind. Genau, weil halt so Erweiterung

von Data Classes halt, dass man so ein bisschen

Typen und Modelle hat,

dann direkt mit Validierung und so. Aber darauf

gehen wir gleich ein bisschen genauer ein, würde ich sagen.

Also wir haben gesagt, das ist jetzt ASCII,

hast du gesagt, das ist Async.

Was ist denn da eine ASCII-Applikation

überhaupt nochmal?

Die immer

die Fragen.

Ja, also

ganz lange der Standard für die Kommunikation

zwischen irgendwie dem

Applikationsserver, der halt

irgendwie tatsächlich Requests annimmt und dann

irgendwie, also die Kommunikation mit dem Browser

tatsächlich macht. Das machst du ja normalerweise

nicht, wenn man irgendwie eine Web-Applikation

schreibt, sondern

das nennt sich

WSGI oder WSGI oder

weiß ich nicht, wie man das am besten ausspricht, Micro-Whisky.

Ist das nicht dasselbe wie

What you see is what you get, Whisky?

Ja.

Das Ding,

das ist auch super

einfach. Also eigentlich ist das alles total trivial.

Aber das Gute, dass es halt ein Standard ist,

dass es mehr oder weniger eine Funktion,

die man halt implementieren muss. Und wenn man das

tut, ist man halt ein WSGI

Server. So, das ist der Grund,

warum man da jetzt nochmal irgendwas anderes brauchte.

Also der kriegt im Wesentlichen ein Request,

kommt rein, Response geht raus. Das ist es eigentlich.

Das ist was man klassisch aus HTTP kennt.

Ja,

genau, aber

genau. So, jetzt ist aber

ja, Dinge haben sich

geändert und man will jetzt eventuell auch

solche Dinge machen können wie WebSockets

oder halt, man hat halt eventuell langlaufende

Requests.

Und wenn man viel parallel machen,

dieses Async-Zeugs. Genau, man möchte halt

nicht nur einmal eine Response zurückgeben

können, sondern vielleicht halt auch irgendwie

wieder was zurückbekommen,

dann wieder was rausreichen und

mit Co-Routinen geht das ja super eigentlich.

Und genau,

dann gibt es, aber es gab

keinen Standard und dann

irgendwann, glaube ich, Andrew

Godwin, auch bekannter Django

Entwickler, der hat

das Migrations-Ding gebaut und so.

Der hat dann irgendwann in diesen

ASGI-Standard geschrieben,

um halt das dann halt

möglich zu machen, dass man da halt einen Standard hat für alle.

Und da ist es im Grunde so,

es ist auch wieder super minimal, aber

man hat halt auch eine Funktion, die man implementieren muss

und die kriegt im Grunde eine Receive- und eine Send-Funktion

und halt, ich weiß gar nicht, muss ich nachgucken.

Und Scope. Und Scope, genau.

Ja, aber

da geht das halt. Da kannst du halt dann auch wieder Sachen

nochmal empfangen und

dann irgendwas machen und dann wieder was rausschicken und

bist halt nicht in diesem Request-Response-Ding

so drin.

Ja, und genau.

Ja, und FastAPI

ist halt ein SGI-Server.

Und dann gibt es halt eine gute Implementation

darunter, das ist UV-Con.

Also UV-Loop,

da hatten wir es schon. Also eigentlich ganz

unten drunter ist LibUV.

Das ist das Ding, was halt auch unter Node.js drunter liegt.

Aber ich glaube, da haben wir auch schon

eine Episode mal drüber gesprochen.

Ja, vielleicht einmal doch mal kurz erklären, weil nicht alle Leute haben ja alle

Episoden gehört. Das ist halt eine Bibliothek,

weg abstrahiert, die dieses

Betriebssystem, Syscalls, weg abstrahiert,

die man halt benutzen muss, um halt schnell

I.O. zu machen.

Genau. Und das ist halt unterschiedlich

je nachdem, was man verwendet. Unter Windows

TCP-Completion-Ports oder was auch immer

da verwendet, keine Ahnung.

Unter FreeBSD ist es halt

KQ

und

Linux ist es halt E-Poll

und das Ding bietet halt

ein Standard-Interface für all diese Dinge.

SelectPol, ich weiß nicht, was da noch alles drin ist.

Und das kann man halt benutzen,

da muss man sich nicht drum kümmern, auf welchem Betriebssystem

man läuft und so.

Und genau, das

und Node.js hat

das halt

relativ, hat diese

Entwicklung da getrieben, weil die haben das halt dann

stark verwendet.

Und ja,

mit den

AsyncIO-Primitiv

Keyword-Geschichten in Python

bot es sich dann halt ja auch an, da irgendwie sowas

zu verwenden und da gab es

halt die schnelle Event-Loop-Implementation mit

UV-Loop von den Leuten, die jetzt HDB gemacht haben

und dann so und

auf UV-Loop drauf sitzt halt

UV-Corn, also quasi

so wie G-Unicorn halt als Applikations-

Server, der dann halt Web-Geschichten macht

und dann halt UV-Loop nutzt, um halt schnell

I.O. machen zu können und das ist auch

wieder ein Projekt von Tom Christie.

Okay, ja, da sind die Katzen mit dem Schwanz.

Genau und

darüber gibt es halt dann nochmal so ein minimales

Web-Framework, was halt

dann nochmal die ganzen

Routing-Request-Response-Geschichten abstrahiert

und das ist halt dann Starlet.

Ja, und

FastAPI benutzt Starlet.

Und, ja,

genau.

Aber die Idee ist im Grunde, viele Sachen zu kombinieren,

Pydentic zu kombinieren mit Type-Annotationen,

mit einem

Dependency-Injection-Geschichte.

Parameter und sowas.

Und

ja, halt Starlet als

quasi schnell,

für das schnell unten drunter.

Und ASGI.

Und ja, das

ist eigentlich eine ziemlich coole Kombination

irgendwie. Man kann jetzt sagen, na gut,

ich habe mir jetzt den FastAPI-Source-Code

auch so ein bisschen angeguckt mal.

Also ganz oft sieht man schon

so irgendwie, naja, er importiert

halt Sachen von Starlet und das war's.

Das ganze WebSocket-Modul in FastAPI.

ist halt irgendwie vom Starlet-Import-Websocket fertig.

Ja gut, also abstrahiert halt, ne?

Und dann einen anderen abgibt vielleicht an ein, zwei Stellen und

wird halt gut integriert. Genau.

Das, was man da haben möchte, ja. Und es ist halt, die Dokumentation

ist halt schön geschrieben und so. Er hat das dann irgendwann mal

in Reddit, auf irgendeinem

in einer Reddit-Group oder so angekündigt,

irgendwie, FastAPI. Und die

Reaktionen waren da so ein bisschen geteilt.

Also ich finde das

super, was er gemacht hat, aber

auf Reddit wurde dann halt irgendwie

so, ne? Also diese Dokumentation

und da sind so viele Emojis und das

ist alles so mit diesen GIFs.

Ja, da waren die ganzen, ganz seriösen

Jungs, die alle die ganze Zeit keinen

Humor haben und im Keller sitzen, die fanden das überhaupt nicht witzig.

Die sagen so, das ist so gebraucht,

war ein Verkäufer-Style, das finde ich nicht gut,

da lese ich gar nicht weiter.

Also ich finde das super, weil ich finde die Dokumentation

tatsächlich sehr eingängig, auch

für Leute geschrieben, die mit Python noch nicht so viel zu tun

hatten und gerade mit

Web-Krams und ich glaube, da gibt es relativ

gute Hinweise und so Querlings, man kann es wirklich,

wenn man anfangen möchte, auch mit Web-Frameworks,

finde ich das gar nicht so schlecht, dass man sich das damit mal

anguckt und ich glaube gerade für so Einsatzzwecke

wie man macht eigentlich so Data Science

oder sowas. Ja, man braucht

vielleicht gar keine Webseite, sondern halt eher eine

API oder so, dann ist das halt schon super.

Ja, und dann liest man das halt durch, man lernt da relativ viel

und das Tutorial ist echt nett und angenehm

zu lesen und nimmt einen sehr an die Hand,

auch wenn es so wirklich ein Graufahrenverkäufer ist.

Also man muss ja nicht immer einen Neuwagen kaufen,

das ist ein bisschen teuer und auch aus Sustainability-Gründen

nicht immer so super.

Ja.

Nee, also ja,

im Grunde ist

eine wirklich schicke Geschichte

und überhaupt, ich würde mal sagen, also was daran

halt neu, also es hat sich ja

es gibt es erst seit 2019 ja und das ist

jetzt schon, weiß ich nicht

sehr, sehr verbreitet, keine Ahnung wie verbreitet

aber in den entsprechenden Umfragen ist es halt

irgendwie

nicht mehr viel hinter Django und Flask

sondern wie viele Leute verwenden das

und das

ich glaube einer der Gründe, warum das

so ist, ist einmal, dass es halt

viele Dinge, also wo bei anderen Geschichten was

gefehlt hat, sind halt da mit drin.

Und dann auch,

dass

diese

Developer-Experience-Geschichte da so betont

wird. Das ist auch etwas, was man jetzt in letzter Zeit

immer mehr sieht. Von früher

kenne ich das so nicht.

Da musste man doch alles von Hand und selber und es war alles

schön und hässlich.

Wenn es kryptisch ist und schwer zu installieren,

das war so ein bisschen...

Ja, deswegen macht man das.

Ja, genau. Du musst ja erstmal beweisen, dass du manns genug bist

und hier das Shred aus

zum Stein ziehen, bevor du irgendwie

so und dass man das den Entwicklern

einfach macht und dass die

da irgendwie einfach eine gute Experience...

Ja, das ist irgendwie so ein Ansatz,

also früher

wäre das Leuten fremdartig vorgekommen,

indem man sich sowas... Aber heute ist das

irgendwie... Heute, ja, Zeiten haben sich geändert.

Ja, so will man das wahrscheinlich auch machen, weil man

keine Lust hat, die ganze Zeit nur im Keller rumzusitzen.

Gut ist, wenn die Leute aus dem

Business noch erwarten, dass es doch genauso lange dauert wie früher.

Ja, ja, ja, gut.

Ich meine, es ist halt die Frage, ob einem das wirklich

so wahnsinnig viel hilft, aber

ich würde schon sagen, ja.

Aber

es ist auf jeden Fall irgendwie eine neue

Geschichte und ich finde das ja auch im Prinzip gut,

dass man da so, dass das halt irgendwie alles ein bisschen

angenehmer wird also und nicht so

stachlig ist.

Ja, vielleicht müssen wir mal kurz darüber reden,

wie der das macht. Also zum Beispiel über Type Annotations

geht halt da ganz viel an den Guten dran.

Parameter kannst du übergeben und kannst direkt

sagen, okay,

das Query enthält jetzt ein

Integer oder sowas. Ja, also eine

Geschichte, das hatte mich am Anfang auch so ein bisschen

verwirrt.

Die Query würde ich jetzt so intuitiv

sagen, ich weiß aber nicht, ob es richtig ist, keine Ahnung.

Das hatte

mich am Anfang, da wurde ich dann nach der, also klar,

man schreibt jetzt, also man hat auch immer

die Dinger, die man halt in FastAP

schreibt, sozusagen

die Endpunkte,

was man sagen möchte, sind halt Funktionen

und die Funktionen haben halt Parameter und

dann geht da was rein, also kommt ein Request mehr oder

weniger rein und es geht eine Response raus.

Man sagt jetzt nicht unbedingt Request,

beziehungsweise bei Django wäre es

halt so, da kommt ein Request rein, geht eine Response raus

und dann popelt man sich sozusagen

aus dem Request die ganzen Sachen halt raus,

die man so braucht. Also aus dem,

da gibt es dann Request.get oder Request.post

oder

man nimmt dann halt den Body und dann gut,

wenn man jetzt sowas wie REST-Framework

oder Formulare nimmt an, dann natürlich

eine ganze Menge ab. Oder Class-Based-Views oder sowas, ja.

Ja, aber prinzipiell

muss man sich den, ist der Teil,

man poolt sich den Kram

da selber halt raus, so.

Und das ist bei FastAPI halt nicht so.

Und das passiert halt sehr viel

von dieser Magie direkt,

wenn du die Type-Annotation richtig

dran schreibst, dass halt du...

Man schreibt halt Type-Annotation in die Parameter und dann

kommen die Daten

irgendwie magisch da rein.

Ja, also wenn man besonders gut wird, wenn man da

zu Pidentic-Modelle verwendet als

Parameter-

Annotation, weil dann wird halt

die Validierung von den Objekten, die da beispielsweise

als JSON reinkommen oder so,

direkt mit Pidentic durchgeführt

und das ist sehr cool, weil halt die ganzen Validierungen

dabei sind, die kann man an den Pidentic reinschreiben,

die passieren halt automatisch,

die Type-Konvertierung passiert automatisch,

du hast in den Objekten direkt die richtige

Datenstruktur vorliegen,

du kannst auch das mit, weiß nicht, sogar mit

Daytimes machen, deinen eigenen Parser dafür in dieses

Pidentic-Modell integrieren, wie du das haben willst

und kriegst direkt die nutzbaren

Python-Objekte da raus, die du brauchst.

Das ist schon sehr, sehr, sehr, sehr nett.

Ja, tatsächlich,

Also ich fand es halt am Anfang so, ich habe das nicht

direkt verstanden, dass das so ist und das hat

mich irgendwie eine Zeit lang verwirrt,

weil ich dachte so, okay, wo gebe ich denn jetzt an,

dass das jetzt die Get-Parameter sind

oder wo sage ich denn jetzt, dass es im Body

vorkommt? Und tatsächlich tut man das halt nicht,

sondern man schreibt das halt da in die

Tube-Annotation und dann

magie, findet fast irgendwie

selber raus, ob das jetzt in den Cookies war oder

ob das halt im Body von dem Request

war oder ob das irgendwie in den

Get-Parametern war.

Und ja,

das funktioniert eigentlich auch immer irgendwie ganz gut.

Das ist echt super, ja.

Also was man dann, also vielleicht an der Stelle

nochmal ganz kurz, würde ich gerne eingehen

auf SQL-Model, weil

man diese Pidentic-Modelle, die man dann halt

netterweise geschrieben hat, mit SQL-Model,

das ist auch ein Projekt von Sebastian Ramirez,

ist noch relativ am Anfang, also noch nicht so ganz

produktionsreif, da waren

noch so ein paar Breaking Changes drin, aber

da kann man einfach diese Pidentic-Models

direkt in der Datenbank speichern.

Und der nimmt das dann direkt und zum Beispiel mit

dem SQL-Alchemy drunter,

Dann wird es halt direkt in die Datenbank geschrieben, die man da angeschlossen hat, was halt auch sehr angenehm ist, weil man halt diese Duplikation von der ganzen Logik nicht mehr hat, sondern halt einfach wie bei, wenn man das vielleicht von Dango gewohnt ist so ein bisschen, nur so Modelle schreibt und hat dann direkt seine Datenbankadaptation und die Validierung damit drin.

Ja, und das ist halt dann quasi das Gleiche für Datenbank, man schreibt halt, was das ist, quasi einmal hin und dann gilt das halt für Datenbank, also es wird dann halt ein Datenbank-Schema draus generiert, also es wird halt auch das Schema für die API draus generiert und das ist halt in beiden Fällen gleich und das ist natürlich schon nett, also man kann sich da vielleicht schon eine ganze Menge Schreibarbeit sparen.

Genau, man kann auch dann tatsächlich, das ist auch

in FastAPI mit drin, direkt das

Schema daraus rennen lassen.

Als OpenIP

kompatibles

JSON oder so, das ist direkt mit drin.

Muss man eigentlich eine Funktion aufrufen, dann ist das da.

Auch sehr schick.

Ich mache dabei, also mit SQL Academy

die Migration ist immer mit Alembic.

Damit ich so ein bisschen so eine Art Tango-mäßiges

Migration-System habe, das heißt,

kannst du dann sowas machen wie Migrate schreiben

oder so. Das funktioniert ein bisschen anders.

Das sind halt

andere Formen von Migrationen ran, aber die schreibt man

eigentlich nur in eine Datei an, da kann man relativ viel anpassen

und der macht dann auch relativ automatisch das

Vor- und Zurückspulen.

Das finde ich ganz schick.

Ja, aber gut, das ist halt

dann irgendwie, um diese Sachen muss man sich dann halt

selber so ein bisschen kümmern. Ja, genau, das ist halt das, was

FASAPI nicht mitliefert im Vergleich zu Dango oder sowas,

aber das geht eigentlich auch ganz gut, wenn

man es dann reinbaut. Ja, also was

den Unterschied angeht, also

wir haben ja schon gesagt, irgendwie ist es so

ähnlich wie Flask, aber

also ich würde sagen, der Hauptunterschied ist eben, dass

bei Flask ist, man kriegt

die Werte eher relativ

roh und man hat eben nicht

weiß, wenn man jetzt in Fast

API das schon annotiert hat mit

das ist ein Integer oder so, dann kriegt man halt ein Integer.

Und in Flask ist das halt nicht so.

Genau. Das ist halt der

genau, dann diese Pidentic-Geschichten, das

könnte man in Flask vielleicht auch so machen, aber das

muss man halt selber machen, das ist halt nicht integriert.

Ja, das ist

und vielleicht auch

noch etwas, was halt

interessant ist, wenn man gerade so

Data-Science-Geschichten macht oder halt

Dinge, die so ein bisschen anders sind als

in Django, hast du halt irgendwie eine

relationelle Datenbank darunter, weil der ORM ist halt so,

wenn man den ORM nicht verwenden möchte,

dann macht es eigentlich gar nicht so viel Sinn, Django zu verwenden,

weil das ist halt der Hauptteil von Django.

Und

wenn man jetzt irgendwie eine MongoDB

verwenden will oder so, oder irgendeine andere

NoSQL-Geschichte, dann ist das halt mit

Django eher so, das geht auch,

aber muss man halt,

es geht nicht über die Modelle.

So ein modularer Teil. Also wenn man jetzt das mit SQL-Model zum Beispiel verwendet, habe ich ja gerade versucht zu erzählen, dann genau diese Revision, die man halt hat, die kann man ja vor- und zurückspulen und da kann man sicher alles Mögliche reinhängen.

Naja, NoSQL hat man auch nicht.

Ja, Moment, aber was cool ist, du kannst aus diesen Pydentic-Modellen, die du halt hast, kannst du auch erzeugen aus einer OpenAPI, die du halt hast, wenn du eine OpenAPI-JSON hast oder sowas.

Achso, kannst du dir direkt die Pydentic-Modelle...

Identik-Modelle bauen lassen.

Und so hast du dann halt dann die Sachen direkt, die du dann auch

in eine Datenbank wegschreiben willst.

Das ist halt auch schon sehr, sehr nett.

Klar, man muss sich

dann halt trotzdem, wenn man das jetzt nicht relational ablegen

will, dann irgendwie eine andere Integration nehmen.

Ja, aber sowas geht halt

prinzipiell. Während das mit Django eigentlich nicht wirklich

geht, kannst du halt in FastAPI,

ob du jetzt irgendwie eine relationale Datenbank verwendest

oder halt irgendwas, oder MongoDB oder so,

das geht beides.

Und zwar ist es nicht so, dass man das

irgendwie, dass man dann gegen

das Framework arbeitet, wenn man jetzt irgendwie NoSQL

verwendet mit FastAPI.

Ja, das finde ich sehr, sehr schick.

Genau.

FastAPI selber benutzt

MakeDocs, MKDocs, ist auch sehr schick.

Ja, weißt du, von wem das ist?

Nein.

Ich müsste jetzt einen von

den Namen sagen, die wir jetzt gerade eben schon erwähnt haben.

Von Chris, die ist auch...

Ja, okay, tatsächlich.

Ja, das ist echt erstaunlich, der hat irgendwie, ja,

genau.

Ja, auch ganz schick. Ich habe dazu

einen kleinen Skeleton tatsächlich mal geschrieben, so für die kleinen

Anfangssachen. Da ist so ein bisschen viel vielleicht schon drin.

Ein bisschen rumgespielt. Können wir vielleicht

mal verlinken. Vielleicht mag ja jemand

den direkt benutzen, wenn er es will. Also ist das nichts

Tolles, aber ein bisschen aus.

Ich habe damit noch nicht so viel gemacht.

Ich habe mir aber vorgenommen, dass ich das mal

tun muss, weil...

Ich habe so ein bisschen Django versucht zu enthinken.

Das ist vielleicht nicht immer ganz so cool, aber Typer ist da auch

dabei. Also so Commands-mäßig.

Ja. Was könnt ihr mir denn noch so alles

erzählen über FastAPI? Ja, also vielleicht

noch mal so ein bisschen, wie das funktioniert mit den Datentypen

und diesen Dependency-Injection-Systemen.

Man kann ja auch damit

sowas machen wie Permissions oder sowas.

Wenn du sagen kannst, bestimmte Dinge müssen enthalten

sein, wie Authentifizierung oder so.

Ja, also diese Magie,

dass halt irgendwie

man einfach nur die Annotationen

hinschreibt und dann die Werte so richtig

bekommt.

Depends on us.

Das sind halt,

das funktioniert über diese

Path-Operations-Geschichten

und das ist halt auch irgendwie

über Dependency Injection

wird das halt gemacht. Und du kannst aber auch das

selber definieren, genau. Da musst du halt nur irgendwie

schreibst halt Depends und dann übergibst du halt ein

Callable und das kriegst du dann halt den ganzen Kram.

Da kannst du halt Code wiederverwenden,

der halt irgendwie, weiß ich nicht, irgendwas

eben ein OAuth-Token irgendwie

validiert oder so. Genau, genau.

Oder halt irgendwas anderes macht.

An der Stelle vielleicht.

Datenbankverbindung reinreicht oder so.

Was ist denn ein Dependency Injection?

Oh je, das ist auch so ein Ding.

Genau, in der letzten Episode hat ja schon jemand gesagt,

Thomas hat das...

Weiß ich nicht, ob man das erklären kann.

Das ist halt auch so ein etwas schwieriges

Konzept. Also im Grunde...

Ist das ein Pattern? Kann man das so sagen?

Ja, ist irgendwie

ein Design-Pattern, kann man sagen.

Also wie man ein Objekt in eine Klasse reingibt, ohne

dass man das jetzt mal neu definiert?

Nee, ist eher so, dass du das halt umdrehst.

Sozusagen, also Dependency

Injection ist ein bisschen

sozusagen das Ding, wie man

Dependency Inversion implementiert.

Also du willst halt nicht, also was du halt

nicht machen möchtest vielleicht, ist

in deiner Funktion, die

halt irgendwie Request-Response

macht, irgendwie ein Datenbank-Ding

importieren und dann

was noch machen. Also

weil du dann ja damit hängst.

Genau. Und dann, was passiert jetzt eigentlich,

wenn du testest? Okay, das heißt, du musst dich mit reingeben,

da ist dann alles abstrahiert in diesem Ding.

Genau. Und jetzt willst du das aber auch

nicht explizit irgendwie da rein,

weil du rufst ja gar nicht, du bist ja gar nicht

derjenige, der das aufruft, den

Funktion, die halt irgendwie

Request-Response macht, sondern das wird ja

irgendwie aufgerufen. Das heißt,

du übergibst es nicht wirklich, sondern du injectest es.

Es wird halt irgendwie automatisch...

Depends on database access oder sowas. Genau.

Und damit sagst du halt eigentlich, dass du das gerne

injectest hättest, sozusagen an der

Stelle. Ja. Und dann

kannst du das halt in Tests halt auch ändern.

In Tests kannst du dann einfach sagen,

in der Applikation,

in der Fast API, also dem

Hauptapplikationsobjekt, kann man irgendwie sagen,

Dependency Override,

und dann kannst du halt definieren,

was da injectet werden soll.

Und sagst halt, Depends on Database bedeutet jetzt,

gib mir einfach ein anderes Objekt

oder eine Testdatenbank. Genau, und dann kannst du halt

die Testdatenbank reinreißen oder du reißt halt

irgendeine Memory Repository rein.

Genau, und

ja, das ist halt sozusagen eine Methode,

um diese Sachen

halt voneinander so zu entkoppeln,

dass du halt nicht, weil, also

eingekoppelt wäre es halt, wenn du von irgendwas erbst,

oder wenn du halt irgendwie das importierst oder so,

dann hängst du halt direkt davon ab

und wenn du es halt so indirekt reingereicht

bekommst, dann bist du halt so

ein bisschen losgelöst.

Ja, und das ist

halt auch in Flask alles ein bisschen schwieriger,

das ist halt schon elegant gemacht, wobei

ehrlich gesagt, also ich habe mir den, ich habe mir

kurz den Code angeguckt,

also das Konzept ist relativ

elegant, aber die Implementation ist ein bisschen

ne. Also

da gibt es halt in Flask API so diese

Dependencies-Module-Package

und dann der Hauptinhalt

der Implementation liegt in Utils.py

und das

war schon

schwer zu lesen, also

ja, aber

es funktioniert einfach.

Also ich finde das, du hast schon recht,

wie hast du das eben genommen mit DevFriendly oder sowas, also ich finde

das sehr angenehm. Ja, ja, es ist genau, es ist halt

darauf optimiert, dass man, also

es ist halt anders. Man kann schnellere Ergebnisse erzeugen, wenn du irgendwie

JSON rauspowern willst und hast nicht so viel

Aufgaben, dann kannst du relativ schnell

Erfolge damit erzielen, finde ich. Ja, ja, absolut.

Es ist halt darauf optimiert, dass du als

Entwickler, der das benutzt, um irgendwie ein Ziel zu erreichen,

dass du da gut zum Ziel kommst.

Und ja, diese

anderen Dinge, also ich finde das ganz interessant,

wenn du zum Beispiel Starlet Sourcecode anguckst,

also die Sachen, die Tom Christie so macht, die sind halt

alle super poliert innen

drin, ja. So ein bisschen wie bei

Apple, wenn man Apple Geräte aufschraubt, die sind auch

innen hübsch. Also da sind auch innen

die Sachen, ja.

Man könnte ja mal aufschrauben, reingucken.

Das ist nicht irgendwie so ein Kabelsalat.

Es gibt ja bei anderen Sachen, da schraubst du das halt so auf,

dann nimmst du die Abdeckung ab und dann machst du

platzt da so ein

Gedärmen-Kabel-Ding draus.

Das ist, wenn du Apple-Dinger hast, das ist halt super ordentlich

und alles. Und das ist halt,

wenn du irgendwie Starlet dir den Source-Code

anguckst, der ist halt auch so. Das ist halt irgendwie

alles total, so wenn man

die Fast-API-Source-Code anguckt,

das ist halt schon so,

da hängt dann eher so, da hängt dann

irgendwie Dinge von der Decke und, aber...

Also ich hab zum Beispiel in meinem Computer, wenn ich den aufschraube,

da hab ich auch so ein paar LEDs reingebaut, das hast du.

Ja, genau, ist halt auch

so ein bisschen eine Typfrage.

Die sind auch unnötig halt, die braucht man halt nicht.

Ob man das jetzt hässlich findet oder hübsch ist.

Wichtig ist halt, dass die Luftzufuhr

vernünftig ist, dass es schön kühl ist und dass es

schnell ist.

Ja, genau.

Aber auf der anderen Seite wiederum

zum Beispiel, also auch das

wiederum, das ist halt unterschiedlich.

Auch der Source Code hat kaum Kommentare

oder so.

Dockstrings gibt es fast

gar nicht. Ich habe vielleicht zwei, drei Stellen gefunden,

welche drin sind und Kommentare gibt es eigentlich auch nicht.

Das bin ich auch schon ein paar

Mal drüber gestolpert, ich muss mal gucken. Aber dafür

sind halt die Type Annotations

so aussagekräftig schon

oft.

Ja, aber auch da, das ist halt so ein bisschen,

ja, sie sind aussagekräftig und ja,

wenn du das im Editor mit, der das unterstützt,

halt benutzt, dann ist das halt,

dann ist das für dich halt total cool.

Ehrlich gesagt, aber den Code einfacher

zu lesen, macht das jetzt nichts.

Ja, ich muss auch sagen, den Code selber, wenn ich da reingucke,

muss ich ein bisschen suchen, was macht der denn jetzt.

Geht das alles über Keyword-Only-Argumente?

Was ja auch irgendwie, also es ist klar,

dass das halt für jemanden, der eine IDE benutzt,

vielleicht besser so ist, wenn er halt Funktionen aufruft

oder Dinge, die halt Keyword-Only sind.

Also das heißt, alle Funktionen und Methoden fangen an

mit irgendwie irgendwas, Stern, Komma irgendwie.

Aber für jemanden, der so, von früher hätte man gesagt,

oh mein Gott, was ist das denn?

Das ist ja schrecklich hässlich.

Warum nicht einfach hinschreiben, was man,

und aber

also es ist halt so ein bisschen

also du verbietest ja mit diesem Stern

erstmal, dass es irgendwelche Argumente gibt, außer den

Keyword-Dingern. Auf der anderen Seite

ist es natürlich so, wenn ein IDE dann

halt anbieten kann, was du alles auswählen kannst

an Dingen, die du da reingibst, ist es natürlich für dich

irgendwie angenehmer. Also sozusagen

deine Entwickler-Experience,

wenn du das in einer IDE verwendest,

ist halt besser, aber wenn du das jetzt

in einem Source-Code liest, ist es eher so ein bisschen

ikidigit, ja so sag ich mal.

Ikidigit.

Ja, ja.

Es ist halt die Frage, wie man das gewohnt ist.

Man muss halt damit schnell arbeiten, deswegen ja.

Ja, also ich meine, heutzutage benutzen die Leute halt alle Idees

und gucken halt darüber, was der Code denn macht.

Wenn du dann halt aber mit einem VI da sitzt

und den Source Code liest, dann denkst du ja so,

was ist das denn?

Ich verstehe diese modernen Zeiten nicht mehr.

Ja.

Es hängt es, aber ja.

Der VI kann das ja wahrscheinlich jetzt auch

mit Autocompletion auf den Quarks und so.

Kann man auch alles machen,

wenn man da die entsprechenden Plugins richtig konfiguriert hat,

was einem erstmal ein paar Monate kosten wird.

Ja, ich habe immer zu wenig

Zeit, um das neben der Arbeit noch hinzubekommen, aber

ja. Naja, also

ich finde es interessant. Also es ist

auf jeden Fall irgendwie so ein bisschen was anderes

und das ist, ja.

Also ich mag es sehr gerne. Also zum Benutzen und zum

Anfassen, das gibt einem so ein bisschen

Speed auf der Straße. Ja.

Ja, das auf jeden Fall. Also ich meine, Pidentic ist auch sowas.

Das ist halt. Das ist echt gut.

Das hilft einem enorm. Ich finde auch

ehrlich gesagt, immer wenn ich jetzt so

Alt-Klassen

im alten Style verwende, oder ich meine,

ich habe auch schon häufiger mal irgendwie

Atteris verwendet,

das war ein guter Atteris-Episode,

oder Data-Classes, und

das macht schon, es ist einfach angenehmer,

das so hinzuschreiben, dass halt die

Sachen

als Attribute direkt in die Klasse reinschreibst

und nicht in Init

und dann das nochmal setzt, das ist halt

immer so ein bisschen umständlich.

Jaja, das ist so ein bisschen

ein bisschen wie die neue Variante

von dem Tupel.

Auf der anderen Seite muss man, ich habe jetzt

nochmal geguckt, weil es gab jetzt

bei DDF, da war ich,

warst du da? Ich konnte nicht,

da hatte jemand Geburtstag. Ach ja, richtig.

Genau, ich habe mir das Video

so teilweise jedenfalls angeguckt und

weil mich interessiert hat, irgendwie, weil da

Klaus gesprochen hat über

wie schnell ist eigentlich

Data Class im Vergleich zu einem alten. Genau,

rausgekommen, dass Pylentic ein bisschen langsamer ist bei der

Umformung von vielen Transaktionen. Kann das sein?

Nee, der hatte Pylentic gar nicht. Der hat nur

Data Classes. Achso, ich hatte mal so ein Video

gepostet, wo das verglichen wurde.

Und ja, also

tatsächlich, Data Classes sind auch ein bisschen

langsamer. Die waren früher viel, viel langsamer.

Sind inzwischen gar nicht mehr so schrecklich viel langsamer.

Ein bisschen langsamer sind sie aber.

Und bei Pylentic habe ich es jetzt selber

nochmal nachgeguckt, weil mich das interessiert hat.

Weil ich dachte so, okay, wie schlimm ist es denn eigentlich?

Und gut, ich habe das

jetzt in meinem, ich habe

kleine Objekte genommen,

wo nicht viel Validierung drauf ist.

Aber ich dachte, gut,

ehrlich gesagt kann es dann ja nicht mehr besser werden für

Pydentic, sondern es wird eher schlimmer.

Aber da war der Unterschied schon relativ

riesig. Also da ist es

halt so beim Deserialisieren,

also quasi du hast

sowas wie JSON oder DICT. Ich habe immer DICT genommen, nicht JSON,

weil ich wollte jetzt nicht die JSON-Library

brennschmarken, sondern einfach nur von DICT

zu irgendwie Objekt.

Es ist so, dass Pydentic ist halt

irgendwie so achtmal langsamer.

Und beim

Serialisieren, also von

Objekt zu, also objektgerecht zu

irgendwie dickt, ist es halt

sogar irgendwie zwanzigmal langsamer.

Und das ist natürlich schon, also es kommt drauf an.

Bei WANs wird das dann relevant?

Genau, das ist halt die Frage.

Das ist halt, also ich meine

irgendwie Serialisieren von

irgendwie hundert Objekten, ich weiß

jetzt gar nicht mehr genau, bis ich jetzt nachgucke,

aber es war halt irgendwie so, das ist halt

für einzelne Objekte so ein paar hundert

Nanosekunden.

Bei Nativ

und Pydentic ist es halt dann so, geht in den