Merge branch 'master' of https://github.com/gjbex/Python-software-engineering

Author: gjbex

source-code/README.md

@@ -6,6 +6,7 @@ was used to develop it.
 
 ## What is it?
 
+1. `code-testing`: illustrations of using assertions and unit tests.
 1. `context-manager`: illustrates how to write your own context managers.
 1. `coroutines`: illustrates how to write coroutines in Python.
 1. `decorators`: illustrates how to write decorators in Python.
@@ -15,10 +16,12 @@ was used to develop it.
    programming in Python.
 1. `introspection`: illustration of how to implement introspection in
    Python.
+1. `iterators`: illustrates iterators and functional programming concepts.
 1. `object-orientation`: illustrates some concepts of object-oriented
    programming in Python.
 1. `operators-functools`: illustrates some applications of the `operator`
    and `functools` modules in Python's standard library.
+1. `pyparsing`: illustration of unit testing on real world code.
 1. `typing`: illustrates how to use type annotation in Python, and
    demonstrates `mypy`.
 1. `unit-testing`: illustrates writing unit tests with `unittest` and

source-code/code-testing/Asserts/README.md

@@ -0,0 +1,12 @@
+# Asserts
+
+`assert` is a Python statement, so it not part of unit testing per se.
+It is mainly intended for contract-based programming and one can prevent
+code to be emitted for asserts by using the `-O` optimizatino flag when
+running the code.
+
+## What is it?
+1. `fac.py`: implements factorial function, checking whether the
+    argument is of type integer, and positive using asserts.
+1. `run.sh`: Bash shell script to run the Python code, once with, and once
+    without code generated for assertions.

source-code/code-testing/Asserts/fac.py

@@ -0,0 +1,19 @@
+#!/usr/bin/env python
+
+def fac(n):
+    '''compute the factorial of given number'''
+    assert type(n) == int, 'argument must be integer'
+    assert n >= 0, 'argument must be positive'
+    if n > 1:
+        return n*fac(n - 1)
+    else:
+        return 1
+
+if __name__ == '__main__':
+    for i in range(5):
+        print('{0}! = {1}'.format(i, fac(i)))
+    for i in [-2, 0.3, 3.0]:
+        try:
+            print('{0}! = {1}'.format(i, fac(i)))
+        except AssertionError as error:
+            print('{0}! failed: "{1}"'.format(i, error))

source-code/code-testing/Asserts/run.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+echo '# run with assertions enabled (default):'
+python ./fac.py
+echo '# --------------------'
+echo '# run with assertions disabled (-O optimization flag):'
+python -O ./fac.py

source-code/code-testing/README.md

@@ -0,0 +1,31 @@
+CodeTesting
+===========
+
+Python's standard library contains the `unittest` module, which allows
+to easily implement unit testing, i.e., it is a framework for setting
+up code for regression testing while developing, modifying, or refactoring
+a code base.
+
+What is it?
+-----------
+1. `constant_db.py`: implements a class that creates a database containing
+    constants (mathematical or fysical), and defines a number of methods
+    to query it.
+1. `constant_db_test.py`: `unittest.TestCase` extension that implements a
+    number of tests for the database.  The database is set up in the
+    `setUp` method, and closed and removed in the `tearDown` method.
+    Various tests are implemented to illustrate some of the assert methods
+    defined by `unittest.TestCase`.
+1. `run_test.sh`: shell script that actually runs the test code, and that
+    uses discovery to minimize maintenance of test code.
+1. `Asserts`: `assert` is a Python statement, so it not part of unit
+    testing per se.  It is mainly intended for contract-based programming
+    and one can prevent code to be emitted for asserts by using the
+    `-O` optimizatino flag when running the code.
+
+Note
+----
+The unit test that checks the number of entries in the database should
+fail to illustrate the output.  Although there are only three constants
+defined in the database, `pi` was added twice, so the total number of
+rows is 4, not 3.

source-code/code-testing/constant_db.py

@@ -0,0 +1,58 @@
+import sqlite3
+
+
+class UnknownConstantError(Exception):
+    pass
+
+
+class ConstantDb(object):
+
+    def __init__(self, file_name='const.db'):
+        self._conn = sqlite3.connect(file_name)
+
+    def close(self):
+        self._conn.close()
+
+    def init(self):
+        constants = {
+            'g': (9.81, 'm/s**2'),
+            'pi': (3.14, None),
+            'mach': (0.00338, 'm/s'),
+        }
+        cursor = self._conn.cursor()
+        cursor.execute('''CREATE TABLE constants (
+                              name  TEXT NOT NULL,
+                              value REAL NOT NULL,
+                              unit  TEXT
+                          )''')
+        for name, data in constants.items():
+            cursor.execute('''INSERT INTO constants
+                                  (name, value, unit) VALUES (?, ?, ?)''',
+                           (name, data[0], data[1]))
+        cursor.execute('''INSERT INTO constants
+                              (name, value, unit) VALUES (?, ?, ?)''',
+                       ('pi', 3.1415, None))
+        self._conn.commit()
+        cursor.close()
+
+    def get_value(self, name):
+        cursor = self._conn.cursor()
+        cursor.execute('''SELECT value FROM constants
+                              WHERE name = ?''', (name, ))
+        rows = cursor.fetchall()
+        cursor.close()
+        if not rows:
+            msg = "constant '{0}' is undefined".format(name)
+            raise UnknownConstantError(msg)
+        else:
+            return rows[0][0]
+
+    def get_names(self):
+        cursor = self._conn.cursor()
+        cursor.execute('''SELECT name FROM constants''')
+        rows = cursor.fetchall()
+        cursor.close()
+        return [row[0] for row in rows]
+
+    def get_nr_constants(self):
+        return len(self.get_names())

source-code/code-testing/constant_db_test.py

@@ -0,0 +1,37 @@
+import os
+import unittest
+
+from constant_db import ConstantDb, UnknownConstantError
+
+
+class ConstantDbTest(unittest.TestCase):
+
+    def setUp(self):
+        self.file_name = 'test.db'
+        self.db = ConstantDb(self.file_name)
+        self.db.init()
+
+    def test_g_value(self):
+        expected_value = 9.81
+        value = self.db.get_value('g')
+        self.assertAlmostEqual(expected_value, value, 1.0e-4)
+
+    def test_constant_names(self):
+        expected_names = {'g', 'pi', 'mach'}
+        names = self.db.get_names()
+        for name in names:
+            self.assertIn(name, expected_names)
+
+    def test_constant_unknown(self):
+        self.assertRaises(UnknownConstantError, self.db.get_value, 'c')
+
+    def test_nr_constants(self):
+        expected_nr_constants = 3
+        nr_constats = self.db.get_nr_constants()
+        self.assertEquals(expected_nr_constants, nr_constats,
+                          'This test is supposed to fail by way '
+                          'of illustration')
+
+    def tearDown(self):
+        self.db.close()
+        os.remove(self.file_name)

source-code/code-testing/run_tests.sh

@@ -0,0 +1,3 @@
+#!/bin/bash -l
+
+python -m unittest discover -p '*_test.py'

source-code/iterators/README.md

@@ -0,0 +1,44 @@
+# Iterators
+An iterator is a nice concept since it allows to create laze sequences,
+i.e., sequences that have elements that are computed only when they are
+requested by retrieving the enxt element.
+
+Python allows for two basic ways to implement iterators, either as
+function that have a LHS yield statements, or as class that implement
+an `__iter__` and a `next` method.
+
+However, often it is not necessary to implements iterators from scratch,
+often they can be constructed by using the Python standard library's
+`itertools` functionality.
+
+## What is it?
+1. `accumulator.py`: illustrates the use of `itertools`'s `accumulate` in
+    for various types of data and operators.
+1. `count_down.py`: simple illustration of a class that implements an
+    iterable.
+1. `event_generate.py`: a sequence of `Event` objects is generated by
+    an instance of the `EventIter` class.  Events have a type, a start time,
+    and a duration.  Events of the same type can not overlap.  The
+    `EventIter` constructor takes a list of event types, and a start time.
+    It generates sequence of random type, start time and duration, until an
+    event is generated that last later than the stop time.
+1. `generators.ipynb`: Jupyter notebook illustrating generators.
+1. `people.py`: illustration of `itertools`'s `groupby`, and `operator`'s
+    `attrgetter` methods.  Note that `groupby` does not reorder the
+    original iterators element, but only groups consecutive elements that
+    have the same key.
+1. `primes.py`: this script will generate the sequence of prime numbers
+    until it is interupted.  The iterator is implemented by a function with
+    a `yield` statement.
+1. `primes_multiple_calls.py`: illustrates that a function with `yield`
+    instantiates a generator when called, and hence "starts over" for
+    each `for`-loop.
+1. `primes_itertools.py`: this script also generates a potentially
+    infinite sequence of prime numbers, but it is implemented using
+    the `count` function of the `itertools` module in Python's standard
+    library, as well as the `filter` function.
+1. `dataset.py`: illustrates the `__iter__` and `__next__` methods, as well
+    as utilities of the `operator` module.
+1. `generating_data.py`: a retake of the data geenration script in
+    Fundamentals, now using `itertools` and built-in Python functional
+    features.

source-code/iterators/accumulator.py

@@ -0,0 +1,17 @@
+#!/usr/bin/env python
+
+from itertools import accumulate
+from operator import add, mul, concat
+
+if __name__ == '__main__':
+    data = range(10)
+    for x in accumulate(data, add):
+        print(x)
+    for x in accumulate(data[1:], mul):
+        print(x)
+    for x in ([y] for y in data):
+        print(x)
+    for x in accumulate(([y] for y in data), concat):
+        print(x)
+    for fragment in accumulate('hello world!', concat):
+        print(fragment)