Update English translation

Author: veit

README.rst

@@ -101,14 +101,12 @@ Follow us
 
 * `GitHub <https://github.com/veit/pyviz-tutorial>`_
 * `Mastodon <https://mastodon.social/@PyViz>`_
-* `Mastodon <https://mastodon.social/@PyViz>`_
 
 Pull-Requests
 -------------
 
-Wenn ihr Vorschläge für Verbesserungen und Ergänzungen habt, empfehle ich euch,
-einen `Fork <https://github.com/veit/pyviz-tutorial/fork>`_ meines
-`GitHub-Repository <https://github.com/veit/pyviz-tutorial/>`_ zu erstellen
-und darin eure Änderungen vorzunehmen. Gerne dürft ihr auch einen *Pull Request*
-stellen. Sofern die darin enthaltenen Änderungen klein und atomar sind, schaue
-ich mir eure Vorschläge gerne an.
+If you have suggestions for improvements and additions, I recommend that you
+create a `fork <https://github.com/veit/pyviz-tutorial/fork>`_ of my `GitHub
+repository <https://github.com/veit/pyviz-tutorial/>`_ and make your changes
+there. You are also welcome to submit a pull request. As long as the changes are
+small and atomic, I will be happy to look at your suggestions.

docs/bokeh/annotations.ipynb

@@ -11,9 +11,9 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Überblick\n",
+    "## Overview\n",
     "\n",
-    "Wir können visuelle Hinweise (Begrenzungslinien, schattierte Bereiche, Beschriftungen und Pfeile usw.) zu unseren Plots hinzufügen, um bestimmte Merkmale hervorzuheben. Bokeh bietet hierfür mehrere Annotationstypen. Um *Annotations* hinzuzufügen, erstellen wir normalerweise ein *Low-Level*-Objekt und fügen es mit `add_layout` unserem Diagramm hinzu. Schauen wir uns einige konkrete Beispiele an:"
+    "We can add visual cues (boundary lines, shaded areas, labels and arrows, etc.) to our plots to emphasise certain features. Bokeh offers several annotation types for this purpose. To add annotations, we usually create a low-level object and add it to our diagram using `add_layout`. Let’s look at some concrete examples:"
    ]
   },
   {
@@ -22,7 +22,7 @@
    "source": [
     "### Spans\n",
     "\n",
-    "Spans sind vertikale oder horizontale Linien, für die die Spannweiten zwischen den Bemaßung angegeben werden kann, z.B.:"
+    "Spans are vertical or horizontal lines for which the spans between the dimensions can be specified, for example:"
    ]
   },
   {
@@ -428,18 +428,18 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Box Annotations\n",
+    "### Box annotations\n",
     "\n",
-    "Soll ein Bereich eines Diagramms hervorgehoben werden, so können diese mit `BoxAnnotation`, den Koordinateneigenschaften \n",
+    "If an area of a diagram is to be highlighted, this can be done with `BoxAnnotation`, the coordinate properties\n",
     "\n",
     "* `top`\n",
     "* `left`\n",
     "* `bottom`\n",
     "* `right`\n",
     "\n",
-    "sowie Linien- und Fülleigenschaften das Erscheinungsbild konfiguriert werden.\n",
+    "as well as line and fill properties to configure the appearance.\n",
     "\n",
-    "Infinite Boxen können erstellt werden, indem die Koordinaten nicht angegeben werden. Wenn zum Beispiel `top` nicht angegeben ist, wird die Box immer bis zum oberen Rand des Plotbereichs angezeigt, unabhängig davon, ob ein Verschieben oder Zoomen stattfindet, z.B.:"
+    "Infinite boxes can be created by not specifying the coordinates. For example, if `top` is not specified, the box is always displayed up to the top edge of the plot area, regardless of whether panning or zooming takes place, for example:"
    ]
   },
   {
@@ -530,15 +530,15 @@
    "source": [
     "### Label\n",
     "\n",
-    "Mit der Annotation `Label` können wir einzelne Beschriftungen einfach an Plots anbringen. Die anzuzeigende Position und der Text sind als `x`, `y` und `text` konfiguriert:\n",
+    "With the `Label` annotation, we can easily attach individual labels to plots. The position to be displayed and the text are configured as `x`, `y` and `text`:\n",
     "\n",
     "``` Python\n",
     "Label(x=10, y=5, text=\"Some Label\")\n",
     "```\n",
     "\n",
-    "Standardmäßig befinden sich die Einheiten im *data space*, aber `x_units` und `y_units` können auf `screen` gesetzt werden, um die Beschriftung relativ zur Zeichenfläche zu positionieren, und Labels können mit `x_offset` und `y_offset` positioniert werden.\n",
+    "By default, the units are in the *data space*, but `x_units` and `y_units` can be set to `screen` to position the label relative to the drawing area, and labels can be positioned with `x_offset` and `y_offset`.\n",
     "\n",
-    "`Label`-Objekte haben auch Standardtext-, Zeilen- (`border_line`) und Fülleigenschaften (`background_fill`). Die Linien- und Fülleigenschaften gelten für einen Begrenzungsrahmen um den Text:\n",
+    "`Label` objects also have standard text, line (`border_line`) and fill (`background_fill`) properties. The line and fill properties apply to a bounding box around the text:\n",
     "\n",
     "``` Python\n",
     "Label(x=10, y=5, text=\"Some Label\", text_font_size=\"12pt\", \n",
@@ -618,7 +618,7 @@
    "source": [
     "### LabelSet\n",
     "\n",
-    "Mit der Annotation `LabelSet` könnt ihr viele Beschriftungen gleichzeitig erstellen, z.B. wenn ihr einen ganzen Satz von Scatter Markers beschriften möchtet. Sie ähneln `Label`, können aber auch eine `ColumnDataSource` als `source` -Eigenschaft nutzen, wobei sich `x` und `y` auf Spalten in der Datenquelle beziehen."
+    "With the `LabelSet` annotation, you can create many labels at the same time, for example if you want to label a whole set of scatter markers. They are similar to `Label`, but can also use a `ColumnDataSource` as a `source` property, where `x` and `y` refer to columns in the data source."
    ]
   },
   {
@@ -714,28 +714,28 @@
    "source": [
     "### Arrows\n",
     "\n",
-    "Mit der Annotation `Arrow` könnt ihr auf verschiedene Elemente in eurer Zeichnung *zeigen+. Dies kann besonders bei Beschriftungen hilfreich sein.\n",
+    "You can use the `Arrow` annotation to point to various elements in your drawing. This can be particularly helpful for labelling.\n",
     "\n",
-    "So könnt ihr beispielsweise einen Pfeil erstellen, der von `(0,0)` bis `(1,1)` zeigt:\n",
+    "For example, you can create an arrow that points from `(0,0)` to `(1,1)`:\n",
     "\n",
     "``` Python\n",
     "p.add_layout(Arrow(x_start=0, y_start=0, x_end=1, y_end=0))\n",
     "```\n",
     "\n",
-    "Dieser Pfeil hat die Standardspitze [OpenHead](https://docs.bokeh.org/en/latest/docs/reference/models/annotations.html#bokeh.models.OpenHead). Andere Arten von Pfeilspitzen sind  [NormalHead](https://docs.bokeh.org/en/latest/docs/reference/models/annotations.html#bokeh.models.NormalHead) und [VeeHead](https://docs.bokeh.org/en/latest/docs/reference/models/annotations.html#bokeh.models.VeeHead). Der Typ des Pfeilkopfs kann durch die Eigenschaften `start` and `end` von `Arrow`-Objekten konfiguriert werden:\n",
+    "This arrow has the standard [OpenHead](https://docs.bokeh.org/en/latest/docs/reference/models/annotations.html#bokeh.models.OpenHead) tip. Other types of arrowheads are [NormalHead](https://docs.bokeh.org/en/latest/docs/reference/models/annotations.html#bokeh.models.NormalHead) and [VeeHead](https://docs.bokeh.org/en/latest/docs/reference/models/annotations.html#bokeh.models.VeeHead). The type of arrowhead can be configured using the `start` and `end` properties of `Arrow` objects:\n",
     "\n",
     "``` Python\n",
     "p.add_layout(Arrow(start=OpenHead(), end=VeeHead(), \n",
     "             x_start=0, y_start=0, x_end=1, y_end=0))\n",
     "```\n",
     "\n",
-    "Dies erzeugt einen Doppelpfeil mit `OpenHead` und `VeeHead`. Pfeilspitzen haben darüberhinaus den Standardsatz von Linien- und Fülleigenschaften, um deren Aussehen zu konfigurieren, z.B.:\n",
+    "This creates a double arrow with `OpenHead` and `VeeHead`. Arrowheads also have the standard set of line and fill properties to configure their appearance, for example\n",
     "\n",
     "``` Python\n",
     "OpenHead(line_color=\"firebrick\", line_width=4)\n",
     "```\n",
     "\n",
-    "Der Code und das Diagramm unten zeigen mehrere dieser Konfigurationen zusammen."
+    "The code and diagram below show several of these configurations together."
    ]
   },
   {
@@ -851,24 +851,24 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Legenden\n",
+    "### Legends\n",
     "\n",
-    "Wenn Diagramme mehrere Glyphen enthalten, ist es wünschenswert, eine Legende hinzuzufügen, um Betrachtern die Interpretation zu erleichtern. Bokeh kann Legenden anhand der hinzugefügten Glyphen leicht generieren."
+    "When diagrams contain multiple glyphs, it is desirable to add a legend to help viewers interpret them. Bokeh can easily generate legends based on the added glyphs."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "#### Einfache Legenden\n",
+    "#### Simple legends\n",
     "\n",
-    "Im einfachsten Fall könnt ihr einen String als `legend` an eine Glyph-Funktion übergeben:\n",
+    "In the simplest case, you can pass a string as a `legend` to a glyph function:\n",
     "\n",
     "``` Python\n",
     "p.circle(x, y, legend=\"sin(x)\")\n",
-    "``` \n",
+    "```\n",
     "\n",
-    "In diesem Fall erstellt Bokeh automatisch eine Legende, die eine Darstellung dieser Glyphe zeigt."
+    "In this case, Bokeh automatically creates a legend that shows a representation of this glyph."
    ]
   },
   {
@@ -950,9 +950,9 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "#### Zusammengesetzte Legenden\n",
+    "#### Composite legends\n",
     "\n",
-    "Im obigen Beispiel haben wir für jede Glyphenmethode ein anderes Etikett bereitgestellt. Manchmal werden zwei (oder mehr) verschiedene Glyphen mit einer einzigen Datenquelle verwendet. In diesem Fall können zusammengesetzte Legenden erstellt werden. Wenn ihr z.B. eine Sin-Kurve mit einer Linie und einer Markierung plottet, könnt ihr ihnen dieselbe Bezeichnung geben um sie dazu zu bringen, gemeinsam in der Legende zu erscheinen:\n",
+    "In the example above, we have provided a different label for each glyph method. Sometimes two (or more) different glyphs are used with a single data source. In this case, composite legends can be created. For example, if you plot a sin curve with a line and a marker, you can give them the same label to make them appear together in the legend:\n",
     "\n",
     "``` Python\n",
     "p.circle(x, y, legend=\"sin(x)\")\n",
@@ -964,17 +964,17 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Farbbalken\n",
+    "### Colour bars\n",
     "\n",
-    "Farbbalken sind besonders nützlich, wenn wir die Farbe einer Glyphe entsprechend der Farbzuordnung variiert. Bokeh-Farbbalken werden mit einer Farbzuordnung konfiguriert und mit der `add_layout'-Methode zu Plots hinzugefügt:\n",
+    "Colour bars are particularly useful when we vary the colour of a glyph according to the colour mapping. Bokeh colour bars are configured with a colour mapping and added to plots using the `add_layout` method:\n",
     "\n",
     "``` Python\n",
     "color_mapper = LinearColorMapper(palette=\"Viridis256\", low=data_low, high=data_high)\n",
     "color_bar = ColorBar(color_mapper=color_mapper, location=(0,0))\n",
     "p.add_layout(color_bar, 'right')\n",
     "```\n",
     "\n",
-    "Das folgende Beispiel zeigt ein vollständiges Beispiel, in dem auch die Farbzuordnung zur Umwandlung der Glyphenfarbe verwendet wird."
+    "In the following example, the colour mapping is also used to convert the glyph colour."
    ]
   },
   {

docs/bokeh/bokeh-server.ipynb

@@ -6,21 +6,21 @@
    "source": [
     "# Bokeh-Server\n",
     "\n",
-    "Die Architektur von Bokeh ist so, dass übergeordnete *Modellobjekte*, also Darstellungen wie Plots, Bereiche, Achsen, Glyphen usw.) in Python erstellt und dann in ein JSON-Format konvertiert werden, das von der Client-Bibliothek `BokehJS` verwendet wird. Mit Hilfe des Bokeh-Servers können die *Modellobjekte* in Python und im Browser miteinander synchronisiert werden, wodurch mächtige Funktionen geschaffen werden:\n",
+    "The architecture of Bokeh is such that higher-level model objects (that is, representations such as plots, areas, axes, glyphs, etc.) are created in Python and then converted into a JSON format that is used by the `BokehJS` client library. With the help of the Bokeh server, the model objects in Python and in the browser can be synchronised with each other, creating powerful functions:\n",
     "\n",
-    "* Browser-Events führen zu serverseitigen Python-Berechnungen oder -Abfragen\n",
-    "* Automatische Push-Aktualisierung des Browser-UI (z.B. Widgets oder Plots)\n",
-    "* Periodische, Timeout- und asynchronen Callbacks für Streaming-Updates\n",
+    "* Browser events lead to server-side Python calculations or queries\n",
+    "* Automatic push update of the browser UI (for example, widgets or plots)\n",
+    "* Periodic, timeout and asynchronous callbacks for streaming updates\n",
     "\n",
-    "Diese Funktion zur Synchronisierung zwischen serverseitigem Python und dem Browser ist der Hauptzweck des Bokeh-Servers.\n",
+    "This function for synchronisation between server-side Python and the browser is the main purpose of the Bokeh server.\n",
     "\n",
-    "Es ist auch möglich, Bokeh-Anwendungen zu definieren, indem ein Standard-Python-Skript erstellt wird. In diesem Fall ist es nicht erforderlich, eine Funktion wie `modify_doc` zu erstellen. Normalerweise erstellt das Skript einfach alle Bokeh-Kontingente und fügt es mit einer Zeile dem Dokument hinzu:\n",
+    "It is also possible to define Bokeh applications by creating a standard Python script. In this case, it is not necessary to create a function like `modify_doc`. Normally, the script simply creates all bokeh quotas and adds it to the document with one line:\n",
     "\n",
     "``` Python\n",
     "curdoc().add_root(layout)\n",
     "```\n",
     "\n",
-    "Um das Beispiel unten auszuprobieren, kopiert den Code in eine Datei `hello.py` und führt dann Folgendes aus:\n",
+    "To try out the example below, copy the code into a file `hello.py` and then execute the following:\n",
     "\n",
     "``` bash\n",
     "$ pipenv run python -m bokeh serve --show hello.py\n",