fixing flow in session 4

Author: cewing

source/presentations/session04.rst

@@ -376,7 +376,7 @@ We'll start by writing a function ``get_inspection_page``
 
     * It will accept keyword arguments for each of the possible query values
     * It will build a dictionary of request query parameters from incoming
-      keywords
+      keywords, using INSPECTION_PARAMS as a template
     * It will make a request to the inspection service search page using this
       query
     * It will return the encoded content and the encoding used as a tuple
@@ -713,19 +713,18 @@ print the first of the many divs that match):
 Parsing Restaurant Data
 -----------------------
 
-Now that we have the records we want, we need to parse them. We want to preserve:
+Now that we have the records we want, we need to parse them.
 
 .. rst-class:: build
 .. container::
 
-    We'll start by parsing out the information about the restaurant themselves:
+    We'll start by extracting information about the restaurants:
 
     .. rst-class:: build
 
     * Name
     * Address
     * Location
-    * ...
 
     How is this information contained in our records?
 
@@ -1133,7 +1132,7 @@ interaction over a network" - W3C
 
 .. nextslide:: Early Web Services
 
-RSS is one of the earliest forms of Web Services
+**RSS** is one of the earliest forms of Web Services
 
 .. rst-class:: build
 .. container::
@@ -1162,10 +1161,11 @@ procedures and pass arguments.
     * Calls are made via HTTP GET, by passing an XML document
     * Returns from a call are sent to the client in XML
 
-    In python, you can access XML-RPC services using `xmlrpclib`_ from the
-    standard library
+    In python, you can access XML-RPC services using `xmlrpc`_ from the
+    standard library. It has two libraries, ``xmlrpc.client`` and
+    ``xmlrpc.server``
 
-.. _xmlrpclib: https://docs.python.org/2/library/xmlrpclib.html
+.. _xmlrpc: https://docs.python.org/3.5/library/xmlrpc.html
 
 .. nextslide:: SOAP
 
@@ -1189,129 +1189,11 @@ SOAP extends XML-RPC in a couple of useful ways:
     * The best-known and best-supported module available is **Suds**
     * The homepage is https://fedorahosted.org/suds/
     * It can be installed using ``easy_install`` or ``pip install``
-    * But it hasn't been updated since Sept. 2010.
-
-    So we're going to move on
-
-.. nextslide:: If Not XML, Then What?
-
-XML is a pretty inefficient medium for transmitting data.  There's a lot of
-extra characters transmitted that lack any meaning.
-
-.. rst-class:: build large centered
-
-**Let's Use JSON**
-
-
-JSON
-----
-
-JavaScript Object Notation:
-
-.. rst-class:: build
-.. container::
-
-    .. rst-class:: build
-
-    * a lightweight data-interchange format
-    * easy for humans to read and write
-    * easy for machines to parse and generate
-
-    Based on Two Structures:
-
-    * object: ``{ string: value, ...}``
-    * array: ``[value, value, ]``
-
-    .. rst-class:: centered
-
-    pythonic, no?
+    * A `fork of the library`_ compatible with Python 3 does exist
 
+    **I HATE SOAP**
 
-.. nextslide:: JSON Data Types
-
-JSON provides a few basic data types (see http://json.org/):
-
-.. rst-class:: build
-.. container::
-
-    .. rst-class:: build
-
-    * string: unicode, anything but ", \\ and control characters
-    * number: any number, but json does not use octal or hexadecimal
-    * object, array (we've seen these above)
-    * true
-    * false
-    * null
-
-    .. rst-class:: centered
-
-    **No date type? OMGWTF??!!1!1**
-
-.. nextslide:: Dates in JSON
-
-You have two options:
-
-.. rst-class:: build
-.. container::
-
-    .. container::
-
-        Option 1 - Unix Epoch Time (number):
-
-        .. code-block:: python
-
-            >>> import time
-            >>> time.time()
-            1358212616.7691269
-
-    .. container::
-
-        Option 2 - ISO 8661 (string):
-
-        .. code-block:: python
-
-            >>> import datetime
-            >>> datetime.datetime.now().isoformat()
-            '2013-01-14T17:18:10.727240'
-
-
-JSON in Python
---------------
-
-You can encode python to json, and decode json back to python:
-
-.. rst-class:: build
-.. container::
-
-    .. code-block:: python
-
-        In [1]: import json
-        In [2]: array = [1, 2, 3]
-        In [3]: json.dumps(array)
-        Out[3]: '[1, 2, 3]'
-        In [4]: orig = {'foo': [1,2,3], 'bar': 'my resumé', 'baz': True}
-        In [5]: encoded = json.dumps(orig)
-        In [6]: encoded
-        Out[6]: '{"foo": [1, 2, 3], "bar": "my resum\\u00e9", "baz": true}'
-        In [7]: decoded = json.loads(encoded)
-        In [8]: decoded == orig
-        Out[8]: True
-
-    Customizing the encoder or decoder class allows for specialized serializations
-
-
-.. nextslide::
-
-the json module also supports reading and writing to *file-like objects* via
-``json.dump(fp)`` and ``json.load(fp)`` (note the missing 's')
-
-.. rst-class:: build
-.. container::
-
-    Remember duck-typing. Anything with a ``.write`` and a ``.read`` method is
-    *file-like*
-
-    This usage can be much more memory-friendly with large files/sources
+.. _fork of the library`: https://github.com/cackharot/suds-py3
 
 .. nextslide:: What about WSDL?
 
@@ -1325,24 +1207,45 @@ interoperability.
 
     .. rst-class:: centered
 
-    Hardly ever
+    **Hardly ever**
 
     Another reason was to provide extensibility via custom types
 
     *Does that really work in real life?*
 
     .. rst-class:: centered
 
-    Hardly ever
+    **Hardly ever**
+
+.. nextslide:: I have to write XML?
+
+In addition, XML is a pretty inefficient medium for transmitting data.  There's
+a lot of extra characters transmitted that lack any meaning.
+
+.. code-block:: xml
+
+    <?xml version="1.0"?>
+    <soap:Envelope xmlns:soap="http://www.w3.org/2003/05/soap-envelope">
+      <soap:Header>
+      </soap:Header>
+      <soap:Body>
+        <m:GetStockPrice xmlns:m="http://www.example.org/stock/Surya">
+          <m:StockName>IBM</m:StockName>
+        </m:GetStockPrice>
+      </soap:Body>
+    </soap:Envelope>
 
 .. nextslide:: Why Do All The Work?
 
-So, if neither of these goals is really achieved by using SOAP, why pay all
-the overhead required to use the protocol?
+So, if neither of the original goals is really achieved by using SOAP
 
 .. rst-class:: build
 .. container::
 
+    And if the transmission medium is too bloated to use
+
+    why pay all the overhead required to use the protocol?
+
     Is there another way we could consider approaching the problem?
 
     .. rst-class:: centered
@@ -1434,6 +1337,116 @@ REST is a **Resource Oriented Architecture**
 
     * Success: ``HTTP/1.1 204 No Content``
 
+REST uses JSON
+--------------
+
+JavaScript Object Notation:
+
+.. rst-class:: build
+.. container::
+
+    .. rst-class:: build
+
+    * a lightweight data-interchange format
+    * easy for humans to read and write
+    * easy for machines to parse and generate
+
+    Based on Two Structures:
+
+    * object: ``{ string: value, ...}``
+    * array: ``[value, value, ]``
+
+    .. rst-class:: centered
+
+    pythonic, no?
+
+
+.. nextslide:: JSON Data Types
+
+JSON provides a few basic data types (see http://json.org/):
+
+.. rst-class:: build
+.. container::
+
+    .. rst-class:: build
+
+    * string: unicode, anything but ", \\ and control characters
+    * number: any number, but json does not use octal or hexadecimal
+    * object, array (we've seen these above)
+    * true
+    * false
+    * null
+
+    .. rst-class:: centered
+
+    **No date type? OMGWTF??!!1!1**
+
+.. nextslide:: Dates in JSON
+
+You have two options:
+
+.. rst-class:: build
+.. container::
+
+    .. container::
+
+        Option 1 - Unix Epoch Time (number):
+
+        .. code-block:: python
+
+            >>> import time
+            >>> time.time()
+            1358212616.7691269
+
+    .. container::
+
+        Option 2 - ISO 8661 (string):
+
+        .. code-block:: python
+
+            >>> import datetime
+            >>> datetime.datetime.now().isoformat()
+            '2013-01-14T17:18:10.727240'
+
+
+JSON in Python
+--------------
+
+You can encode python to json, and decode json back to python:
+
+.. rst-class:: build
+.. container::
+
+    .. code-block:: python
+
+        In [1]: import json
+        In [2]: array = [1, 2, 3]
+        In [3]: json.dumps(array)
+        Out[3]: '[1, 2, 3]'
+        In [4]: orig = {'foo': [1,2,3], 'bar': 'my resumé', 'baz': True}
+        In [5]: encoded = json.dumps(orig)
+        In [6]: encoded
+        Out[6]: '{"foo": [1, 2, 3], "bar": "my resum\\u00e9", "baz": true}'
+        In [7]: decoded = json.loads(encoded)
+        In [8]: decoded == orig
+        Out[8]: True
+
+    Customizing the encoder or decoder class allows for specialized serializations
+
+
+.. nextslide::
+
+the json module also supports reading and writing to *file-like objects* via
+``json.dump(fp)`` and ``json.load(fp)`` (note the missing 's')
+
+.. rst-class:: build
+.. container::
+
+    Remember duck-typing. Anything with a ``.write`` and a ``.read`` method is
+    *file-like*
+
+    This usage can be much more memory-friendly with large files/sources
+
 
 Playing With REST
 -----------------