Fix: Use real codelens not from rs-substitutes

Author: bnmnetp

pretext/ClassesBasics/ImprovingourConstructor.ptx

@@ -5,7 +5,19 @@
             provide some additional capability for the user to pass information to the constructor.  Since constructors are simply specially named functions, we can use parameters (as we've seen before) to provide the specific information.</p>
   <p>We can make our class constructor more general by putting extra parameters into
             the <c>__init__</c> method, as shown in this codelens example.</p>
-  <exercise runestone="chp13_improveconstructor"/>
+  <program xml:id="chp13_improveconstructor" interactive="codelens" language="python">
+    <input>
+          class Point:
+              """ Point class for representing and manipulating x,y coordinates. """
+          
+              def __init__(self, initX, initY):
+                  """ Create a new point at the given coordinates. """
+                  self.x = initX
+                  self.y = initY
+          
+          p = Point(7, 6)
+    </input>
+  </program>
   <p>Now when we create new points, we supply the x and y coordinates as parameters.  When the point is created, the values of <c>initX</c> and <c>initY</c> are assigned to the state of the object.</p>
   <image source="ClassesBasics/Figures/objectpic5.png" width="50%" alt="Simple object has state and methods"/>
 </section>

pretext/ClassesBasics/UserDefinedClasses.ptx

@@ -1,14 +1,14 @@
 <?xml version="1.0"?>
 <section xml:id="classes-basics_user-defined-classes">
   <title>User Defined Classes</title>
-  <p>We've already seen classes like <c>str</c>, <c>int</c>, <c>float</c> and <c>Turtle</c>.  These were defined by Python and
+  <p>We've already seen classes like <c>str</c>,    <c>int</c>,    <c>float</c> and <c>Turtle</c>.  These were defined by Python and
             made available for us to use.  However, in many cases when we are solving problems we need to create data objects
             that are related to the problem we are trying to solve.  We need to create our own classes.</p>
   <p>As an example, consider the concept of a mathematical point. In two dimensions, a point is two
             numbers (coordinates) that are treated collectively as a single object.
             Points are often written in parentheses with a comma
             separating the coordinates. For example, <c>(0, 0)</c> represents the origin, and
-            <c>(x, y)</c> represents the point <c>x</c> units to the right and <c>y</c> units up
+    <c>(x, y)</c> represents the point <c>x</c> units to the right and <c>y</c> units up
             from the origin.  This <c>(x,y)</c> is the state of the point.</p>
   <p>Thinking about our diagram above, we could draw a <c>point</c> object as shown here.</p>
   <image source="ClassesBasics/Figures/objectpic2.png" width="50%" alt="A point has an x and a y"/>
@@ -31,7 +31,7 @@ class Point:
         """ Create a new point at the origin """
         self.x = 0
         self.y = 0
-</input>
+    </input>
   </program>
   <p>Class definitions can appear anywhere in a program, but they are usually near
             the beginning (after the <c>import</c> statements). The syntax rules for a class
@@ -63,7 +63,7 @@ p = Point()         # Instantiate an object of type Point
 q = Point()         # and make a second point
 
 print("Nothing seems to have happened with the points")
-        </input>
+    </input>
   </program>
   <p>During the initialization of the objects, we created two
             attributes called <title_reference>x</title_reference> and <title_reference>y</title_reference> for each, and gave them both the value 0.</p>
@@ -77,7 +77,22 @@ print("Nothing seems to have happened with the points")
             having an x and y coordinate with value 0.  However, because we have not asked the point to do anything, we don't see any other result.</p>
   <image source="ClassesBasics/Figures/objectpic4.png" width="50%" alt="Simple object has state and methods"/>
   <p>You can see this for yourself, via codelens:</p>
-  <exercise runestone="chp13_points"/>
+  <program xml:id="chp13_points" interactive="codelens" language="python">
+    <input>
+class Point:
+    """ Point class for representing and manipulating x,y coordinates. """
+
+    def __init__(self):
+        """ Create a new point at the origin """
+        self.x = 0
+        self.y = 0
+
+p = Point()         # Instantiate an object of type Point
+q = Point()         # and make a second point
+
+print("Nothing seems to have happened with the points")
+    </input>
+  </program>
   <p>The following program adds a few print statements. You can see that the output suggests that each one is a <c>Point object</c>.
             However, notice that the <c>is</c> operator returns <c>False</c> meaning that they are different objects (we will have more to say about this in a later chapter).</p>
   <program xml:id="chp13_classes2" interactive="activecode" language="python">
@@ -97,7 +112,7 @@ print(p)
 print(q)
 
 print(p is q)
-        </input>
+    </input>
   </program>
   <p>This should look familiar &#x2014; we've used classes before to create
             more than one object:</p>
@@ -107,7 +122,7 @@ from turtle import Turtle
 
 tess = Turtle()     # Instantiate objects of type Turtle
 alex = Turtle()
-</input>
+    </input>
   </program>
   <p>The variables <c>p</c> and <c>q</c> are assigned references to two new <c>Point</c> objects.
             A function like <c>Turtle</c> or <c>Point</c> that creates a new object instance
@@ -121,7 +136,8 @@ alex = Turtle()
             production line, its initialization method is executed to
             get the object properly set up with its factory default settings.</p>
   <p>The combined process of <q>make me a new object</q> and <q>get its settings initialized
-            to the factory default settings</q> is called <term>instantiation</term>.</p>
+            to the factory default settings</q> is called <term>instantiation</term>.
+  </p>
   <p>
     <term>Check Your Understanding</term>
   </p>
@@ -142,7 +158,7 @@ x = BMW is Tesla
 y = type(BMW)==type(Tesla)
 
 print(x, y)
-</input>
+        </input>
       </program>
     </statement>
     <choices>
@@ -152,31 +168,31 @@ print(x, y)
         </statement>
         <feedback>
                     Look closely at how the objects are instantiated.
-                </feedback>
+        </feedback>
       </choice>
       <choice>
         <statement>
           <p>True False</p>
         </statement>
         <feedback>
                     Look closely at how the objects are instantiated and the types of the objects.
-                </feedback>
+        </feedback>
       </choice>
       <choice correct="yes">
         <statement>
           <p>False True</p>
         </statement>
         <feedback>
                     Correct, the BMW object is not the Tesla object but they are of the same type.
-                </feedback>
+        </feedback>
       </choice>
       <choice>
         <statement>
           <p>False False</p>
         </statement>
         <feedback>
                     Look closer at types of the objects.
-                </feedback>
+        </feedback>
       </choice>
     </choices>
   </exercise>

pretext/Dictionaries/Dictionaryoperations.ptx

@@ -4,14 +4,36 @@
   <p>The <c>del</c> statement removes a key-value pair from a dictionary. For example,
             the following dictionary contains the names of various fruits and the number of
             each fruit in stock.  If someone buys all of the pears, we can remove the entry from the dictionary.</p>
-  <exercise runestone="ch12_dict4"/>
+  <program xml:id="ch12_dict4" interactive="codelens" language="python">
+    <input>
+          inventory = {'apples': 430, 'bananas': 312, 'oranges': 525, 'pears': 217}
+          
+          del inventory['pears']
+    </input>
+  </program>
+
   <p>Dictionaries are also mutable.  As we've seen before with lists, this means that the dictionary can
             be modified by referencing an association on the left hand side of the assignment statement.  In the previous
-            example, instead of deleting the entry for <c>pears</c>, we could have set the inventory to <c>0</c>.</p>
-  <exercise runestone="ch12_dict4a"/>
+            example, instead of deleting the entry for <c>pears</c>, we could have set the inventory to <c>0</c>.
+  </p>
+  <program xml:id="ch12_dict4a" interactive="codelens" language="python">
+    <input>
+          inventory = {'apples': 430, 'bananas': 312, 'oranges': 525, 'pears': 217}
+          
+          inventory['pears'] = 0
+    </input>
+  </program>
   <p>Similarily,
             a new shipment of 200 bananas arriving could be handled like this.</p>
-  <exercise runestone="ch12_dict5"/>
+  <program xml:id="ch12_dict5" interactive="codelens" language="python">
+    <input>
+          inventory = {'apples': 430, 'bananas': 312, 'oranges': 525, 'pears': 217}
+          inventory['bananas'] = inventory['bananas'] + 200
+          
+          
+          numItems = len(inventory)
+    </input>
+  </program>
   <p>Notice that there are now 512 bananas&#x2014;the dictionary has been modified.  Note also that the <c>len</c> function also works on dictionaries.  It returns the number
             of key-value pairs:</p>
   <p>
@@ -25,7 +47,7 @@
 mydict = {"cat":12, "dog":6, "elephant":23}
 mydict["mouse"] = mydict["cat"] + mydict["dog"]
 print(mydict["mouse"])
-</input>
+        </input>
       </program>
     </statement>
     <choices>
@@ -35,31 +57,31 @@ print(mydict["mouse"])
         </statement>
         <feedback>
                     12 is associated with the key cat.
-                </feedback>
+        </feedback>
       </choice>
       <choice>
         <statement>
           <p>0</p>
         </statement>
         <feedback>
                     The key mouse will be associated with the sum of the two values.
-                </feedback>
+        </feedback>
       </choice>
       <choice correct="yes">
         <statement>
           <p>18</p>
         </statement>
         <feedback>
                     Yes, add the value for cat and the value for dog (12 + 6) and create a new entry for mouse.
-                </feedback>
+        </feedback>
       </choice>
       <choice>
         <statement>
           <p>Error, there is no entry with mouse as the key.</p>
         </statement>
         <feedback>
                     Since the new key is introduced on the left hand side of the assignment statement, a new key-value pair is added to the dictionary.
-                </feedback>
+        </feedback>
       </choice>
     </choices>
   </exercise>

pretext/Dictionaries/intro-Dictionaries.ptx

@@ -5,15 +5,24 @@
             lists, and tuples — are sequential collections.  This means that the items in the collection are
             ordered from left to right and they use integers as indices to access
             the values they contain.</p>
-  <p><term>Dictionaries</term> are a different kind of collection. They are Python's
+  <p>
+    <term>Dictionaries</term> are a different kind of collection. They are Python's
             built-in <term>mapping type</term>. A map is an unordered, associative collection.  The association, or mapping,
             is from a <term>key</term>, which can be any immutable type,
             to a <term>value</term>, which can be any Python data object.</p>
   <p>As an example, we will create a dictionary to translate English words into
             Spanish. For this dictionary, the keys are strings and the values will also be strings.</p>
   <p>One way to create a dictionary is to start with the empty dictionary and add
-            <term>key-value pairs</term>. The empty dictionary is denoted <c>{}</c></p>
-  <exercise runestone="chp12_dict1"/>
+    <term>key-value pairs</term>. The empty dictionary is denoted <c>{}</c>
+  </p>
+  <program xml:id="chp12_dict1" interactive="codelens" language="python">
+    <input>
+          eng2sp = {}
+          eng2sp['one'] = 'uno'
+          eng2sp['two'] = 'dos'
+          eng2sp['three'] = 'tres'
+    </input>
+  </program>
   <p>The first assignment creates an empty dictionary named <c>eng2sp</c>.  The other
             assignments add new key-value pairs to the dictionary.  The left hand side gives the dictionary and the key being associated.  The right hand side gives the value being associated with that key.
             We can print the current
@@ -26,20 +35,34 @@
             For our purposes we can think of this ordering as unpredictable.</p>
   <p>Another way to create a dictionary is to provide a list of key-value pairs
             using the same syntax as the previous output.</p>
-  <exercise runestone="chp12_dict2"/>
+  <program xml:id="chp12_dict2" interactive="codelens" language="python">
+    <input>
+          eng2sp = {'three': 'tres', 'one': 'uno', 'two': 'dos'}
+          print(eng2sp)
+    </input>
+  </program>
+
   <p>It doesn't matter what order we write the pairs. The values in a dictionary are
             accessed with keys, not with indices, so there is no need to care about
             ordering.</p>
   <p>Here is how we use a key to look up the corresponding value.</p>
-  <exercise runestone="chp12_dict3"/>
-  <p>The key <c>'two'</c> yields the value <c>'dos'</c>.</p>
+  <program xml:id="chp12_dict3" interactive="codelens" language="python">
+    <input>
+eng2sp = {'three': 'tres', 'one': 'uno', 'two': 'dos'}
+
+value = eng2sp['two']
+print(value)
+    </input>
+  </program>
+  <p>The key <c>'two'</c> yields the value <c>'dos'</c>.
+  </p>
   <note>
     <p>This workspace is provided for your convenience.  You can use this activecode window to try out anything you like.</p>
     <program xml:id="scratch_11_01" interactive="activecode" language="python">
       <input>
 
 
-        </input>
+      </input>
     </program>
   </note>
   <p>
@@ -56,15 +79,15 @@
         </statement>
         <feedback>
                     Dictionaries associate keys with values but there is no assumed order for the entries.
-                </feedback>
+        </feedback>
       </choice>
       <choice correct="yes">
         <statement>
           <p>True</p>
         </statement>
         <feedback>
                     Yes, dictionaries are associative collections meaning that they store key-value pairs.
-                </feedback>
+        </feedback>
       </choice>
     </choices>
   </exercise>
@@ -75,7 +98,7 @@
         <input>
 mydict = {"cat":12, "dog":6, "elephant":23}
 print(mydict["dog"])
-</input>
+        </input>
       </program>
     </statement>
     <choices>
@@ -85,31 +108,31 @@ print(mydict["dog"])
         </statement>
         <feedback>
                     12 is associated with the key cat.
-                </feedback>
+        </feedback>
       </choice>
       <choice correct="yes">
         <statement>
           <p>6</p>
         </statement>
         <feedback>
                     Yes, 6 is associated with the key dog.
-                </feedback>
+        </feedback>
       </choice>
       <choice>
         <statement>
           <p>23</p>
         </statement>
         <feedback>
                     23 is associated with the key elephant.
-                </feedback>
+        </feedback>
       </choice>
       <choice>
         <statement>
           <p>Error, you cannot use the index operator with a dictionary.</p>
         </statement>
         <feedback>
                     The [ ] operator, when used with a dictionary, will look up a value based on its key.
-                </feedback>
+        </feedback>
       </choice>
     </choices>
   </exercise>