Enhance documentation for sections FastAPI and gRPC

docs/data-processing/apis/fastapi/install.rst

@@ -38,14 +38,14 @@ Für die Produktion benötigt ihr außerdem einen `ASGI
     Updated Pipfile.lock (051f02)!
     …
 
-Pydantic kann die folgenden optionalen Abhängigkeiten verwenden:
+`Pydantic <https://pydantic.dev/>`_ kann die folgenden optionalen Abhängigkeiten verwenden:
 
 `ujson <https://github.com/ultrajson/ultrajson>`_
     für schnelleres JSON-Parsing.
 `email_validator <https://github.com/JoshData/python-email-validator>`_
     zur E-Mail-Validierung.
 
-Starlette kann die folgenden optionalen Abhängigkeiten verwenden:
+`Starlette <https://www.starlette.io/>`_ kann die folgenden optionalen Abhängigkeiten verwenden:
 
 :doc:`httpx <../../httpx/index>`
     wenn ihr den ``TestClient`` verwenden wollt.

docs/data-processing/apis/grpc/example.rst

@@ -13,8 +13,8 @@ Definieren der Datenstruktur
 ----------------------------
 
 Der erste Schritt bei der Arbeit mit Protocol-Buffers besteht darin, die
-Struktur für die Daten zu definieren, die Sie in einer ``.proto``-Datei
-serialisieren möchten. Protocol-Buffers-Daten sind als *Nachrichten*
+Struktur für die Daten zu definieren, die ihr in einer ``.proto``-Datei
+serialisieren möchtet. Protocol-Buffers-Daten sind als *Nachrichten*
 strukturiert, wobei jede Nachricht ein kleiner logischer Datensatz ist, der eine
 Reihe von Name-Wert-Paaren enthält, die *fields* genannt werden.
 :download:`accounts.proto` ist ein einfaches Beispiel hierfür:
@@ -34,7 +34,7 @@ Reihe von Name-Wert-Paaren enthält, die *fields* genannt werden.
 
 Nachdem ihr eure Datenstruktur definiert habt, könnt ihr das
 Protocol-Buffer-Compiler-Protokoll ``protoc`` verwenden, um Deskriptoren in
-eurer bevorzugten Sprache zu erzeugen. Diese bietet einfache Zugriffsfunktionen
+eurer bevorzugten Sprache zu erzeugen. Dieses bietet einfache Zugriffsfunktionen
 für jedes Feld sowie Methoden zur Serialisierung der gesamten Struktur. Wenn
 eure Sprache z.B. Python ist, werden beim Ausführen des Compilers für das obige
 Beispiel Deklaratoren generiert, die ihr dann in eurer Anwendung zum Einpflegen,
@@ -83,7 +83,7 @@ Hierfür schreiben wir die Datei :download:`accounts_server.py`:
 Client erstellen
 ----------------
 
-Hierfür schreiben wir :download:`accounts_client.py`:
+Hierfür schreiben wir die Datei :download:`accounts_client.py`:
 
 .. literalinclude:: accounts_client.py
    :caption: accounts_client.py
@@ -93,13 +93,13 @@ Hierfür schreiben wir :download:`accounts_client.py`:
 Client und Server starten
 -------------------------
 
-#. Starten des Server:
+#. Starten des Servers in einem Terminal:
 
    .. code-block:: console
 
         $ pipenv run python accounts_server.py
 
-#. Starten des Client von einem anderen Terminal aus:
+#. Starten des Clients von einem anderen Terminal aus:
 
    .. code-block:: console
 

docs/data-processing/apis/grpc/index.rst

@@ -18,12 +18,12 @@ aufgerufen werden können. Der Server implementiert dieses Interface, um die
 Client-Aufrufe zu verarbeiten. Für den Client wurde ein sog. *Stub* generiert,
 der dieselben Methoden wie der Server bereitstellt.
 
-Im folgenden die wesentlichen Design-Prinzipien von gRPC:
+gRPC liegen die folgenden Design-Prinzipien zu Grunde:
 
 * gRPC kann auf allen gängigen Entwicklungsplattformen und in vielen
   verschiedenen Sprachen erstellt werden.
-* Es ist auf Geräten mit geringer CPU- und Speicherfähigkeiten funktionsfähig
-  sein, so neben Android [#]_- und iOS-Geräten auch auf MicroPython-Boards und
+* Es ist auf Geräten mit geringer CPU- und Speicherfähigkeit funktionsfähig,
+  so neben Android [#]_- und iOS-Geräten auch auf MicroPython-Boards und
   in Browsern [#]_ [#]_.
 * Es ist lizenziert unter Apache License 2.0 und nutzt offene Standards wie z.B.
   HTTP/2 und Quick UDP Internet Connections (QUIC).
@@ -35,7 +35,8 @@ Im folgenden die wesentlichen Design-Prinzipien von gRPC:
 * gRPC unterstützt unterschiedliche Serialisierungsformate, u.a.
   :doc:`/data-processing/serialisation-formats/protobuf`,
   :doc:`/data-processing/serialisation-formats/json/index` [#]_,
-  :doc:`/data-processing/serialisation-formats/xml-html/index` und Thrift)
+  :doc:`/data-processing/serialisation-formats/xml-html/index` und
+  `Thrift <https://thrift.apache.org/>`_)
 * Asynchrone und synchrone (blockierende) Verarbeitung werden in den meisten
   Sprachen unterstützt.
 * Das Streaming von Nachrichten in einem einzelnen RPC-Aufruf wird unterstützt.
@@ -108,7 +109,7 @@ Im folgenden die wesentlichen Design-Prinzipien von gRPC:
 
 Ausgehend von einer Schnittstellendefinition in einer ``.proto``-Datei bietet
 gRPC Protocol-Compiler-Plugins, die clientseitige und serverseitige APIs
-generieren.  Das `gRPC-Protokoll
+generieren. Das `gRPC-Protokoll
 <https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md>`_ gibt abstrakt
 die Kommunikation zwischen Clients und Servern an:
 

docs/data-processing/apis/grpc/test.rst

@@ -75,13 +75,13 @@ Wireshark
 ---------
 
 `Wireshark <https://www.wireshark.org/>`_ ist ein Open-Source-Tool zur Analyse
-von Netzwerkprotokollen. Im Folgenden zeigen wir Euch, wie ihr den `gRPC
+von Netzwerkprotokollen. Im Folgenden seht ihr, wie ihr den `gRPC
 <https://gitlab.com/wireshark/wireshark/-/wikis/gRPC>`_- und den `Protobuf
-<https://gitlab.com/wireshark/wireshark/-/wikis/Protobuf>`_-Dissectors verwenden
-könnt. Sie erleichtern Euch das Zerlegen (Dekodieren) von gRPC-Nachrichten, die
+<https://gitlab.com/wireshark/wireshark/-/wikis/Protobuf>`_-Dissector verwenden
+könnt. Sie erleichtern euch das Zerlegen (Dekodieren) von gRPC-Nachrichten, die
 im :doc:`Protobuf </data-processing/serialisation-formats/protobuf>`- oder
 :doc:`/data-processing/serialisation-formats/json/index`-Format serialisiert
-sind. Zudem könnt ihr damit das Server-, Client- und bidirektionales
+sind. Zudem könnt ihr damit das Server-, Client- und bidirektionale
 gRPC-Streaming analysieren.
 
 .. note::

docs/data-processing/postgresql/fdw.rst

@@ -5,10 +5,10 @@
 Foreign Data Wrappers (FDW)
 ===========================
 
-2003 wurde SQL erweitert um  SQL/MED (*SQL Management of External Data*).
-PostgreSQL 9.1 unterstützte dies *read-only*, 9.3 dann auch schreibend.
-Seitdem sind eine Reihe von Foreign Data Wrappers (FDW) für PostgreSQL
-entwickelt worden.
+2003 wurde SQL um SQL/MED (*SQL Management of External Data*) erweitert.
+PostgreSQL 9.1 unterstützte dies *read-only*, ab der Version 9.3 dann
+auch schreibend. Seitdem wurden eine Reihe von Foreign Data Wrappers (FDW)
+für PostgreSQL entwickelt.
 
 Im Folgenden nur eine kleine Auswahl der bekanntesten FDW:
 

docs/data-processing/postgresql/index.rst

@@ -99,7 +99,7 @@ Common Table Expression
 Multi-Version Concurrency Control (MVCC)
     `Multi-Version Concurrency Control
     <https://www.postgresql.org/docs/current/mvcc.html>`_ erlaubt, dass zwei
-    oder mehr Sessions gleicheitig auf dieselben Daten zugreifen ohne dabei die
+    oder mehr Sessions gleichzeitig auf dieselben Daten zugreifen, ohne dabei die
     Integrität der Daten zu gefährden.
 
 Cross Platform