Update docs

Author: dbrattli

docs-src/communicate/fable-from-py.md

@@ -27,11 +27,11 @@ containing actual members and is not nested by any other.
 // counting when it finds actual code
 module A.Long.Namespace.RootModule
 
-// The name of this function will be the same in JS
+// The name of this function will be the same in Python
 let add (x: int) (y: int) = x + y
 
 module Nested =
-    // This will be prefixed with the name of the module in JS
+    // This will be prefixed with the name of the module in Python
     let add (x: int) (y: int) = x * y
 ```
 
@@ -79,7 +79,7 @@ exchanging data between F# and Python. The most important common types are:
 - Mutable **hashsets** (not F# sets) compile to a custom HashSet type.
 
 > If the dictionary or hashset requires custom or structural equality, Fable will generate a custom type, but it will
-> share the same properties as JS maps and sets.
+> share the same properties as Python maps and sets.
 
 - **Objects**: As seen above, only record fields and interface members will be attached to objects without name
   mangling. Take this into account when sending to or receiving an object from Python.
@@ -158,7 +158,7 @@ let myEffect() =
     printfn "Effect!"
     fun () -> printfn "Cleaning up"
 
-// Method from a JS module, expects a function
+// Method from a Python module, expects a function
 // that returns another function for disposing
 let useEffect (effect: unit -> (unit -> unit)): unit =
     importMember "my-js-module"

docs-src/communicate/py-from-fable.md

@@ -117,7 +117,7 @@ MyDataManager(myConfig) |> test myData
 ```
 
 :::{note}
-If you have a Python type declaration for the Python code you want to import, you can use 
+If you have a Python type declaration for the Python code you want to import, you can use
 [ts2fable](https://github.com/fable-compiler/ts2fable) to help you write the F# bindings.
 :::
 
@@ -189,7 +189,7 @@ def draw_bubble(id):
 we could use the same method we used with `alert.py`:
 
 ```fsharp
-open Fable.Core.JsInterop // needed to call interop tools
+open Fable.Core.PyInterop // needed to call interop tools
 
 type ICanvas =
     abstract drawSmiley: (id:string) -> unit
@@ -204,7 +204,7 @@ mylib.drawSmiley "smiley" // etc..
 or we could use the `importMember` helper function to directly map the Python function to the F# function.
 
 ```fsharp
-open Fable.Core.JsInterop // needed to call interop tools
+open Fable.Core.PyInterop // needed to call interop tools
 
 module Canvas =
   // here we just import a member function from canvas.js called drawSmiley.
@@ -235,7 +235,7 @@ let aDifferentName: string = import "myString" "my-lib"
 // Py: from my_lib import my_string
 ```
 
-Occasionally, you may need to import Python purely for its side-effects. 
+Occasionally, you may need to import Python purely for its side-effects.
 
 For this, use `importSideEffects`.
 
@@ -285,33 +285,33 @@ The content of `Emit` will not be checked by the F# compiler so it's not advised
 Now let's work with Emit and look at a new example with the following `my_class.py`:
 
 ```py
-import math 
+import math
 
 class MyClass:
     # Note the constructor accepts an object
     # with the `value` and `awesomeness` fields
     def __init__(self, value, awesomeness):
         self._value = value
         self._awesomeness = awesomeness
-  
+
     @property
     def value()
         return this._value
-  
+
 
     @value.setter
     def set_value(self, new_alue)
         self._value = new_value
-  
+
 
     def is_awesome(self):
       return this._value == this._awesomeness
-  
+
 
     @staticmethod
     def getPI():
        return math.pi
-  
+
 
 ```
 
@@ -436,7 +436,7 @@ myMethod(U3.Case3 testValue)
 When passing arguments to a method accepting `U2`, `U3`... you can use the `!^` as syntax sugar so you don't need to type the exact case (the argument will still be type checked):
 
 ```fsharp
-open Fable.Core.JsInterop
+open Fable.Core.PyInterop
 
 myMethod !^5 // Equivalent to: myMethod(U3.Case2 5)
 myMethod !^testValue
@@ -496,7 +496,7 @@ myLib.myMethod("vertical", "Horizontal");
 To create a plain JS object (aka POJO), use `createObj`:
 
 ```fsharp
-open Fable.Core.JsInterop
+open Fable.Core.PyInterop
 
 let data =
     createObj [
@@ -573,7 +573,7 @@ sendToPy [
 ```
 
 :::{note}
-Fable can make the transformation at compile time when applying the list literal directly to `keyValueList`. That's why 
+Fable can make the transformation at compile time when applying the list literal directly to `keyValueList`. That's why
 it's usually a good idea to inline the function containing the helper.
 :::
 

docs/.buildinfo

@@ -1,4 +1,4 @@
 # Sphinx build info version 1
 # This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.
-config: c6e0a32b1ffc4227edef3400a2591539
+config: 65a62f5c8786decb6b98d7000b454921
 tags: 645f666f9bcd5a90fca523b33c5a78b7

docs/communicate/fable-from-py.html

@@ -474,11 +474,11 @@ <h2>Name mangling<a class="headerlink" href="#name-mangling" title="Permalink to
 <span class="c1">// counting when it finds actual code</span><span class="w"></span>
 <span class="k">module</span><span class="w"> </span><span class="nn">A.Long.Namespace.RootModule</span><span class="w"></span>
 
-<span class="c1">// The name of this function will be the same in JS</span><span class="w"></span>
+<span class="c1">// The name of this function will be the same in Python</span><span class="w"></span>
 <span class="k">let</span><span class="w"> </span><span class="nv">add</span><span class="w"> </span><span class="o">(</span><span class="n">x</span><span class="o">:</span><span class="w"> </span><span class="n">int</span><span class="o">)</span><span class="w"> </span><span class="o">(</span><span class="n">y</span><span class="o">:</span><span class="w"> </span><span class="n">int</span><span class="o">)</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">y</span><span class="w"></span>
 
 <span class="k">module</span><span class="w"> </span><span class="nn">Nested</span><span class="w"> </span><span class="o">=</span><span class="w"></span>
-<span class="w">    </span><span class="c1">// This will be prefixed with the name of the module in JS</span><span class="w"></span>
+<span class="w">    </span><span class="c1">// This will be prefixed with the name of the module in Python</span><span class="w"></span>
 <span class="w">    </span><span class="k">let</span><span class="w"> </span><span class="nv">add</span><span class="w"> </span><span class="o">(</span><span class="n">x</span><span class="o">:</span><span class="w"> </span><span class="n">int</span><span class="o">)</span><span class="w"> </span><span class="o">(</span><span class="n">y</span><span class="o">:</span><span class="w"> </span><span class="n">int</span><span class="o">)</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="n">y</span><span class="w"></span>
 </pre></div>
 </div>
@@ -527,7 +527,7 @@ <h2>Common types and objects<a class="headerlink" href="#common-types-and-object
 </ul>
 <blockquote>
 <div><p>If the dictionary or hashset requires custom or structural equality, Fable will generate a custom type, but it will
-share the same properties as JS maps and sets.</p>
+share the same properties as Python maps and sets.</p>
 </div></blockquote>
 <ul class="simple">
 <li><p><strong>Objects</strong>: As seen above, only record fields and interface members will be attached to objects without name
@@ -602,7 +602,7 @@ <h3>Using delegates for disambiguation<a class="headerlink" href="#using-delegat
 <span class="w">    </span><span class="n">printfn</span><span class="w"> </span><span class="s">&quot;Effect!&quot;</span><span class="w"></span>
 <span class="w">    </span><span class="k">fun</span><span class="w"> </span><span class="bp">()</span><span class="w"> </span><span class="o">-&gt;</span><span class="w"> </span><span class="n">printfn</span><span class="w"> </span><span class="s">&quot;Cleaning up&quot;</span><span class="w"></span>
 
-<span class="c1">// Method from a JS module, expects a function</span><span class="w"></span>
+<span class="c1">// Method from a Python module, expects a function</span><span class="w"></span>
 <span class="c1">// that returns another function for disposing</span><span class="w"></span>
 <span class="k">let</span><span class="w"> </span><span class="nv">useEffect</span><span class="w"> </span><span class="o">(</span><span class="n">effect</span><span class="o">:</span><span class="w"> </span><span class="kt">unit</span><span class="w"> </span><span class="o">-&gt;</span><span class="w"> </span><span class="o">(</span><span class="kt">unit</span><span class="w"> </span><span class="o">-&gt;</span><span class="w"> </span><span class="kt">unit</span><span class="o">)):</span><span class="w"> </span><span class="kt">unit</span><span class="w"> </span><span class="o">=</span><span class="w"></span>
 <span class="w">    </span><span class="n">importMember</span><span class="w"> </span><span class="s">&quot;my-js-module&quot;</span><span class="w"></span>

docs/communicate/py-from-fable.html

@@ -733,7 +733,7 @@ <h3>Let’s practice! 2nd try!<a class="headerlink" href="#let-s-practice-2nd-tr
 </pre></div>
 </div>
 <p>we could use the same method we used with <code class="docutils literal notranslate"><span class="pre">alert.py</span></code>:</p>
-<div class="highlight-fsharp notranslate"><div class="highlight"><pre><span></span><span class="k">open</span><span class="w"> </span><span class="nn">Fable.Core.JsInterop</span><span class="w"> </span><span class="c1">// needed to call interop tools</span><span class="w"></span>
+<div class="highlight-fsharp notranslate"><div class="highlight"><pre><span></span><span class="k">open</span><span class="w"> </span><span class="nn">Fable.Core.PyInterop</span><span class="w"> </span><span class="c1">// needed to call interop tools</span><span class="w"></span>
 
 <span class="k">type</span><span class="w"> </span><span class="nc">ICanvas</span><span class="w"> </span><span class="o">=</span><span class="w"></span>
 <span class="w">    </span><span class="k">abstract</span><span class="w"> </span><span class="n">drawSmiley</span><span class="o">:</span><span class="w"> </span><span class="o">(</span><span class="n">id</span><span class="o">:</span><span class="kt">string</span><span class="o">)</span><span class="w"> </span><span class="o">-&gt;</span><span class="w"> </span><span class="kt">unit</span><span class="w"></span>
@@ -746,7 +746,7 @@ <h3>Let’s practice! 2nd try!<a class="headerlink" href="#let-s-practice-2nd-tr
 </pre></div>
 </div>
 <p>or we could use the <code class="docutils literal notranslate"><span class="pre">importMember</span></code> helper function to directly map the Python function to the F# function.</p>
-<div class="highlight-fsharp notranslate"><div class="highlight"><pre><span></span><span class="k">open</span><span class="w"> </span><span class="nn">Fable.Core.JsInterop</span><span class="w"> </span><span class="c1">// needed to call interop tools</span><span class="w"></span>
+<div class="highlight-fsharp notranslate"><div class="highlight"><pre><span></span><span class="k">open</span><span class="w"> </span><span class="nn">Fable.Core.PyInterop</span><span class="w"> </span><span class="c1">// needed to call interop tools</span><span class="w"></span>
 
 <span class="k">module</span><span class="w"> </span><span class="nn">Canvas</span><span class="w"> </span><span class="o">=</span><span class="w"></span>
 <span class="w">  </span><span class="c1">// here we just import a member function from canvas.js called drawSmiley.</span><span class="w"></span>
@@ -815,33 +815,33 @@ <h2>Emit, when F# is not enough<a class="headerlink" href="#emit-when-f-is-not-e
 <section id="let-s-do-it-use-emit">
 <h3>Let’s do it! Use Emit<a class="headerlink" href="#let-s-do-it-use-emit" title="Permalink to this headline">#</a></h3>
 <p>Now let’s work with Emit and look at a new example with the following <code class="docutils literal notranslate"><span class="pre">my_class.py</span></code>:</p>
-<div class="highlight-py notranslate"><div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">math</span> 
+<div class="highlight-py notranslate"><div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">math</span>
 
 <span class="k">class</span> <span class="nc">MyClass</span><span class="p">:</span>
     <span class="c1"># Note the constructor accepts an object</span>
     <span class="c1"># with the `value` and `awesomeness` fields</span>
     <span class="k">def</span> <span class="fm">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">value</span><span class="p">,</span> <span class="n">awesomeness</span><span class="p">):</span>
         <span class="bp">self</span><span class="o">.</span><span class="n">_value</span> <span class="o">=</span> <span class="n">value</span>
         <span class="bp">self</span><span class="o">.</span><span class="n">_awesomeness</span> <span class="o">=</span> <span class="n">awesomeness</span>
-  
+
     <span class="nd">@property</span>
     <span class="k">def</span> <span class="nf">value</span><span class="p">()</span>
         <span class="k">return</span> <span class="n">this</span><span class="o">.</span><span class="n">_value</span>
-  
+
 
     <span class="nd">@value</span><span class="o">.</span><span class="n">setter</span>
     <span class="k">def</span> <span class="nf">set_value</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">new_alue</span><span class="p">)</span>
         <span class="bp">self</span><span class="o">.</span><span class="n">_value</span> <span class="o">=</span> <span class="n">new_value</span>
-  
+
 
     <span class="k">def</span> <span class="nf">is_awesome</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
       <span class="k">return</span> <span class="n">this</span><span class="o">.</span><span class="n">_value</span> <span class="o">==</span> <span class="n">this</span><span class="o">.</span><span class="n">_awesomeness</span>
-  
+
 
     <span class="nd">@staticmethod</span>
     <span class="k">def</span> <span class="nf">getPI</span><span class="p">():</span>
        <span class="k">return</span> <span class="n">math</span><span class="o">.</span><span class="n">pi</span>
-  
+
 
 </pre></div>
 </div>
@@ -949,7 +949,7 @@ <h3>Erase attribute<a class="headerlink" href="#erase-attribute" title="Permalin
 </pre></div>
 </div>
 <p>When passing arguments to a method accepting <code class="docutils literal notranslate"><span class="pre">U2</span></code>, <code class="docutils literal notranslate"><span class="pre">U3</span></code>… you can use the <code class="docutils literal notranslate"><span class="pre">!^</span></code> as syntax sugar so you don’t need to type the exact case (the argument will still be type checked):</p>
-<div class="highlight-fsharp notranslate"><div class="highlight"><pre><span></span><span class="k">open</span><span class="w"> </span><span class="nn">Fable.Core.JsInterop</span><span class="w"></span>
+<div class="highlight-fsharp notranslate"><div class="highlight"><pre><span></span><span class="k">open</span><span class="w"> </span><span class="nn">Fable.Core.PyInterop</span><span class="w"></span>
 
 <span class="n">myMethod</span><span class="w"> </span><span class="o">!^</span><span class="mi">5</span><span class="w"> </span><span class="c1">// Equivalent to: myMethod(U3.Case2 5)</span><span class="w"></span>
 <span class="n">myMethod</span><span class="w"> </span><span class="o">!^</span><span class="n">testValue</span><span class="w"></span>
@@ -1005,7 +1005,7 @@ <h3>StringEnum<a class="headerlink" href="#stringenum" title="Permalink to this
 <section id="plain-old-javascript-objects">
 <h2>Plain Old JavaScript Objects<a class="headerlink" href="#plain-old-javascript-objects" title="Permalink to this headline">#</a></h2>
 <p>To create a plain JS object (aka POJO), use <code class="docutils literal notranslate"><span class="pre">createObj</span></code>:</p>
-<div class="highlight-fsharp notranslate"><div class="highlight"><pre><span></span><span class="k">open</span><span class="w"> </span><span class="nn">Fable.Core.JsInterop</span><span class="w"></span>
+<div class="highlight-fsharp notranslate"><div class="highlight"><pre><span></span><span class="k">open</span><span class="w"> </span><span class="nn">Fable.Core.PyInterop</span><span class="w"></span>
 
 <span class="k">let</span><span class="w"> </span><span class="nv">data</span><span class="w"> </span><span class="o">=</span><span class="w"></span>
 <span class="w">    </span><span class="n">createObj</span><span class="w"> </span><span class="o">[</span><span class="w"></span>