fix typo ("All methods are static")

Author: pthom

_litgen_template

@@ -615,7 +615,7 @@ <h1>Use litgen online<a class="headerlink" href="#use-litgen-online" title="Perm
 
 # <submodule my_math>
 class my_math:  # Proxy class that introduces typings for the *submodule* my_math
-    pass  # (This corresponds to a C++ namespace. All method are static!)
+    pass  # (This corresponds to a C++ namespace. All methods are static!)
     """This namespace is not ignored and introduces a new python module"""
     # div and mul: divide or multiply float numbers
     # (This comment concerns the two grouped
@@ -759,7 +759,7 @@ <h1>Use litgen online<a class="headerlink" href="#use-litgen-online" title="Perm
 
 <span class="c1"># &lt;submodule my_math&gt;</span>
 <span class="k">class</span> <span class="nc">my_math</span><span class="p">:</span>  <span class="c1"># Proxy class that introduces typings for the *submodule* my_math</span>
-    <span class="k">pass</span>  <span class="c1"># (This corresponds to a C++ namespace. All method are static!)</span>
+    <span class="k">pass</span>  <span class="c1"># (This corresponds to a C++ namespace. All methods are static!)</span>
 <span class="w">    </span><span class="sd">&quot;&quot;&quot;This namespace is not ignored and introduces a new python module&quot;&quot;&quot;</span>
     <span class="c1"># div and mul: divide or multiply float numbers</span>
     <span class="c1"># (This comment concerns the two grouped</span>

docs/litgen_book/01_05_05_online.html

@@ -2158,7 +2158,7 @@ <h2>Convert to snake case<a class="headerlink" href="#convert-to-snake-case" tit
 
 # <submodule my_namespace>
 class my_namespace:  # Proxy class that introduces typings for the *submodule* my_namespace
-    pass  # (This corresponds to a C++ namespace. All method are static!)
+    pass  # (This corresponds to a C++ namespace. All methods are static!)
     class MyClass:
         def add_number(self, a: int, b: int) -> int:
             pass
@@ -2250,7 +2250,7 @@ <h2>Convert to snake case<a class="headerlink" href="#convert-to-snake-case" tit
 .highlight .vm { color: #076678 } /* Name.Variable.Magic */
 .highlight .il { color: #8f3f71 } /* Literal.Number.Integer.Long */</style> <div class="highlight"><pre><span></span><span class="c1"># &lt;submodule my_namespace&gt;</span>
 <span class="k">class</span> <span class="nc">my_namespace</span><span class="p">:</span>  <span class="c1"># Proxy class that introduces typings for the *submodule* my_namespace</span>
-    <span class="k">pass</span>  <span class="c1"># (This corresponds to a C++ namespace. All method are static!)</span>
+    <span class="k">pass</span>  <span class="c1"># (This corresponds to a C++ namespace. All methods are static!)</span>
     <span class="k">class</span> <span class="nc">MyClass</span><span class="p">:</span>
         <span class="k">def</span> <span class="nf">add_number</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">a</span><span class="p">:</span> <span class="nb">int</span><span class="p">,</span> <span class="n">b</span><span class="p">:</span> <span class="nb">int</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">int</span><span class="p">:</span>
             <span class="k">pass</span>
@@ -2942,7 +2942,7 @@ <h2>Convert to snake case<a class="headerlink" href="#convert-to-snake-case" tit
 
 # <submodule MyNamespace>
 class MyNamespace:  # Proxy class that introduces typings for the *submodule* MyNamespace
-    pass  # (This corresponds to a C++ namespace. All method are static!)
+    pass  # (This corresponds to a C++ namespace. All methods are static!)
     class MyClass:
         def AddNumber(self, a: int, b: int) -> int:
             pass
@@ -3034,7 +3034,7 @@ <h2>Convert to snake case<a class="headerlink" href="#convert-to-snake-case" tit
 .highlight .vm { color: #076678 } /* Name.Variable.Magic */
 .highlight .il { color: #8f3f71 } /* Literal.Number.Integer.Long */</style> <div class="highlight"><pre><span></span><span class="c1"># &lt;submodule MyNamespace&gt;</span>
 <span class="k">class</span> <span class="nc">MyNamespace</span><span class="p">:</span>  <span class="c1"># Proxy class that introduces typings for the *submodule* MyNamespace</span>
-    <span class="k">pass</span>  <span class="c1"># (This corresponds to a C++ namespace. All method are static!)</span>
+    <span class="k">pass</span>  <span class="c1"># (This corresponds to a C++ namespace. All methods are static!)</span>
     <span class="k">class</span> <span class="nc">MyClass</span><span class="p">:</span>
         <span class="k">def</span> <span class="nf">AddNumber</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">a</span><span class="p">:</span> <span class="nb">int</span><span class="p">,</span> <span class="n">b</span><span class="p">:</span> <span class="nb">int</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">int</span><span class="p">:</span>
             <span class="k">pass</span>

docs/litgen_book/04_05_00_names_translation.html

@@ -12093,7 +12093,7 @@ <h2>Vectorize functions<a class="headerlink" href="#vectorize-functions" title="
 
 # <submodule math_functions>
 class math_functions:  # Proxy class that introduces typings for the *submodule* math_functions
-    pass  # (This corresponds to a C++ namespace. All method are static!)
+    pass  # (This corresponds to a C++ namespace. All methods are static!)
     @staticmethod
     def fn1(x: float, y: float) -> float:
         pass
@@ -12189,7 +12189,7 @@ <h2>Vectorize functions<a class="headerlink" href="#vectorize-functions" title="
 .highlight .vm { color: #076678 } /* Name.Variable.Magic */
 .highlight .il { color: #8f3f71 } /* Literal.Number.Integer.Long */</style> <div class="highlight"><pre><span></span><span class="c1"># &lt;submodule math_functions&gt;</span>
 <span class="k">class</span> <span class="nc">math_functions</span><span class="p">:</span>  <span class="c1"># Proxy class that introduces typings for the *submodule* math_functions</span>
-    <span class="k">pass</span>  <span class="c1"># (This corresponds to a C++ namespace. All method are static!)</span>
+    <span class="k">pass</span>  <span class="c1"># (This corresponds to a C++ namespace. All methods are static!)</span>
     <span class="nd">@staticmethod</span>
     <span class="k">def</span> <span class="nf">fn1</span><span class="p">(</span><span class="n">x</span><span class="p">:</span> <span class="nb">float</span><span class="p">,</span> <span class="n">y</span><span class="p">:</span> <span class="nb">float</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">float</span><span class="p">:</span>
         <span class="k">pass</span>

docs/litgen_book/05_05_00_functions.html

@@ -828,7 +828,7 @@ <h1>Namespaces<a class="headerlink" href="#namespaces" title="Permalink to this
 
 # <submodule inner>
 class inner:  # Proxy class that introduces typings for the *submodule* inner
-    pass  # (This corresponds to a C++ namespace. All method are static!)
+    pass  # (This corresponds to a C++ namespace. All methods are static!)
     """ this is an inner namespace (this comment should become the namespace doc)"""
     @staticmethod
     def foo_inner() -> None:
@@ -928,7 +928,7 @@ <h1>Namespaces<a class="headerlink" href="#namespaces" title="Permalink to this
 
 <span class="c1"># &lt;submodule inner&gt;</span>
 <span class="k">class</span> <span class="nc">inner</span><span class="p">:</span>  <span class="c1"># Proxy class that introduces typings for the *submodule* inner</span>
-    <span class="k">pass</span>  <span class="c1"># (This corresponds to a C++ namespace. All method are static!)</span>
+    <span class="k">pass</span>  <span class="c1"># (This corresponds to a C++ namespace. All methods are static!)</span>
 <span class="w">    </span><span class="sd">&quot;&quot;&quot; this is an inner namespace (this comment should become the namespace doc)&quot;&quot;&quot;</span>
     <span class="nd">@staticmethod</span>
     <span class="k">def</span> <span class="nf">foo_inner</span><span class="p">()</span> <span class="o">-&gt;</span> <span class="kc">None</span><span class="p">:</span>

docs/litgen_book/08_05_00_namespaces.html

@@ -896,7 +896,7 @@ <h2>Generated code (with custom bindings)<a class="headerlink" href="#generated-
 
 # <submodule root_ns>
 class root_ns:  # Proxy class that introduces typings for the *submodule* root_ns
-    pass  # (This corresponds to a C++ namespace. All method are static!)
+    pass  # (This corresponds to a C++ namespace. All methods are static!)
     class Foo:
         m_value: int = 0
         def __init__(self, m_value: int = 0) -> None:
@@ -1001,7 +1001,7 @@ <h2>Generated code (with custom bindings)<a class="headerlink" href="#generated-
 .highlight .vm { color: #076678 } /* Name.Variable.Magic */
 .highlight .il { color: #8f3f71 } /* Literal.Number.Integer.Long */</style> <div class="highlight"><pre><span></span><span class="c1"># &lt;submodule root_ns&gt;</span>
 <span class="k">class</span> <span class="nc">root_ns</span><span class="p">:</span>  <span class="c1"># Proxy class that introduces typings for the *submodule* root_ns</span>
-    <span class="k">pass</span>  <span class="c1"># (This corresponds to a C++ namespace. All method are static!)</span>
+    <span class="k">pass</span>  <span class="c1"># (This corresponds to a C++ namespace. All methods are static!)</span>
     <span class="k">class</span> <span class="nc">Foo</span><span class="p">:</span>
         <span class="n">m_value</span><span class="p">:</span> <span class="nb">int</span> <span class="o">=</span> <span class="mi">0</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">m_value</span><span class="p">:</span> <span class="nb">int</span> <span class="o">=</span> <span class="mi">0</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="kc">None</span><span class="p">:</span>

docs/litgen_book/08_10_00_custom_bindings.html

@@ -967,7 +967,7 @@ def fn_brace(
 
 # <submodule math_functions>
 class math_functions:  # Proxy class that introduces typings for the *submodule* math_functions
-    pass  # (This corresponds to a C++ namespace. All method are static!)
+    pass  # (This corresponds to a C++ namespace. All methods are static!)
     """ Vectorizable functions example
         Numeric functions (i.e. function accepting and returning only numeric params or py::array), can be vectorized
         i.e. they will accept numpy arrays as an input.
@@ -990,7 +990,7 @@ class math_functions:  # Proxy class that introduces typings for the *submodule*
 
 # <submodule animals>
 class animals:  # Proxy class that introduces typings for the *submodule* animals
-    pass  # (This corresponds to a C++ namespace. All method are static!)
+    pass  # (This corresponds to a C++ namespace. All methods are static!)
 
     class Animal:
         def __init__(self, name: str) -> None:
@@ -1007,7 +1007,7 @@ class animals:  # Proxy class that introduces typings for the *submodule* animal
 
 # <submodule home>
 class home:  # Proxy class that introduces typings for the *submodule* home
-    pass  # (This corresponds to a C++ namespace. All method are static!)
+    pass  # (This corresponds to a C++ namespace. All methods are static!)
 
     class Pet:
         def is_pet(self) -> bool:
@@ -1026,7 +1026,7 @@ class home:  # Proxy class that introduces typings for the *submodule* home
 
 # <submodule aaa>
 class aaa:  # Proxy class that introduces typings for the *submodule* aaa
-    pass  # (This corresponds to a C++ namespace. All method are static!)
+    pass  # (This corresponds to a C++ namespace. All methods are static!)
 
     #  ------------------------------------------------------------------------
     #      <template specializations for class Copyable_Template>
@@ -1042,11 +1042,11 @@ class aaa:  # Proxy class that introduces typings for the *submodule* aaa
 
 # <submodule root>
 class root:  # Proxy class that introduces typings for the *submodule* root
-    pass  # (This corresponds to a C++ namespace. All method are static!)
+    pass  # (This corresponds to a C++ namespace. All methods are static!)
 
     # <submodule inner>
     class inner:  # Proxy class that introduces typings for the *submodule* inner
-        pass  # (This corresponds to a C++ namespace. All method are static!)
+        pass  # (This corresponds to a C++ namespace. All methods are static!)
 
         class MyVirtualClass:
             def foo_concrete(self, x: int, name: str) -> str:
@@ -1082,7 +1082,7 @@ class root:  # Proxy class that introduces typings for the *submodule* root
 
 # <submodule some_namespace>
 class some_namespace:  # Proxy class that introduces typings for the *submodule* some_namespace
-    pass  # (This corresponds to a C++ namespace. All method are static!)
+    pass  # (This corresponds to a C++ namespace. All methods are static!)
     """ namespace SomeNamespace"""
 
     class ParentStruct:
@@ -1141,7 +1141,7 @@ class some_namespace:  # Proxy class that introduces typings for the *submodule*
 
     # <submodule some_inner_namespace>
     class some_inner_namespace:  # Proxy class that introduces typings for the *submodule* some_inner_namespace
-        pass  # (This corresponds to a C++ namespace. All method are static!)
+        pass  # (This corresponds to a C++ namespace. All methods are static!)
         """ namespace SomeInnerNamespace"""
         @staticmethod
         def toggle_bool_pointer(v: BoxedBool) -> None:
@@ -1178,7 +1178,7 @@ class some_namespace:  # Proxy class that introduces typings for the *submodule*
 
 # <submodule inner>
 class inner:  # Proxy class that introduces typings for the *submodule* inner
-    pass  # (This corresponds to a C++ namespace. All method are static!)
+    pass  # (This corresponds to a C++ namespace. All methods are static!)
     """ this is an inner namespace (this comment should become the namespace doc)"""
     @staticmethod
     def foo_inner() -> int:
@@ -1191,7 +1191,7 @@ class inner:  # Proxy class that introduces typings for the *submodule* inner
 
 # <submodule n>
 class n:  # Proxy class that introduces typings for the *submodule* n
-    pass  # (This corresponds to a C++ namespace. All method are static!)
+    pass  # (This corresponds to a C++ namespace. All methods are static!)
 
     class S:
         def __init__(self) -> None:
@@ -1220,7 +1220,7 @@ class n:  # Proxy class that introduces typings for the *submodule* n
 
 # <submodule a>
 class a:  # Proxy class that introduces typings for the *submodule* a
-    pass  # (This corresponds to a C++ namespace. All method are static!)
+    pass  # (This corresponds to a C++ namespace. All methods are static!)
 
     class Foo(enum.IntEnum):
         foo1 = enum.auto()  # (= 0)
@@ -1245,7 +1245,7 @@ class a:  # Proxy class that introduces typings for the *submodule* a
 
     # <submodule n>
     class n:  # Proxy class that introduces typings for the *submodule* n
-        pass  # (This corresponds to a C++ namespace. All method are static!)
+        pass  # (This corresponds to a C++ namespace. All methods are static!)
 
         class S:
             def __init__(self) -> None:
@@ -1275,7 +1275,7 @@ class a:  # Proxy class that introduces typings for the *submodule* a
 
 # <submodule root_custom>
 class root_custom:  # Proxy class that introduces typings for the *submodule* root_custom
-    pass  # (This corresponds to a C++ namespace. All method are static!)
+    pass  # (This corresponds to a C++ namespace. All methods are static!)
 
     class Foo:
         m_value: int = 0

src/litgen/integration_tests/_stubs/lg_mylib/__init__.pyi

@@ -30,7 +30,7 @@ def my_mul(a: int, b: int) -> int:
 
 # <submodule math_functions>
 class math_functions:  # Proxy class that introduces typings for the *submodule* math_functions
-    pass  # (This corresponds to a C++ namespace. All method are static!)
+    pass  # (This corresponds to a C++ namespace. All methods are static!)
     """ Vectorizable functions example
         Numeric functions (i.e. function accepting and returning only numeric params or py::array), can be vectorized
         i.e. they will accept numpy arrays as an input.

src/litgen/integration_tests/mylib/basic_test.h.pyi

@@ -41,7 +41,7 @@ class Copyable_DeletedCopyCtor:
 
 # <submodule aaa>
 class aaa:  # Proxy class that introduces typings for the *submodule* aaa
-    pass  # (This corresponds to a C++ namespace. All method are static!)
+    pass  # (This corresponds to a C++ namespace. All methods are static!)
 
     #  ------------------------------------------------------------------------
     #      <template specializations for class Copyable_Template>

src/litgen/integration_tests/mylib/class_copy_test.h.pyi

@@ -17,7 +17,7 @@ from typing import overload
 
 # <submodule a>
 class a:  # Proxy class that introduces typings for the *submodule* a
-    pass  # (This corresponds to a C++ namespace. All method are static!)
+    pass  # (This corresponds to a C++ namespace. All methods are static!)
 
     class Foo(enum.IntEnum):
         foo1 = enum.auto()  # (= 0)
@@ -42,7 +42,7 @@ class a:  # Proxy class that introduces typings for the *submodule* a
 
     # <submodule n>
     class n:  # Proxy class that introduces typings for the *submodule* n
-        pass  # (This corresponds to a C++ namespace. All method are static!)
+        pass  # (This corresponds to a C++ namespace. All methods are static!)
 
         class S:
             def __init__(self) -> None: