Add unit testing example

Author: gjbex

source-code/README.md

@@ -21,6 +21,7 @@ was used to develop it.
    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/pyparsing/branch_lengths.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python
+
+from argparse import ArgumentParser, FileType
+from newick_parser import NewickParser
+
+
+def compute_branch_lengths(node, branch_lengths=None, length=0.0):
+    if branch_lengths is None:
+        branch_lengths = {}
+        compute_branch_lengths(node, branch_lengths, length)
+        return branch_lengths
+    if node.is_leaf():
+        branch_lengths[node.label] = length + node.length
+    else:
+        if node.length is not None:
+            length += node.length
+        for child in node.children():
+            compute_branch_lengths(child, branch_lengths, length)
+
+
+def main():
+    arg_parser = ArgumentParser(description='Determine leaf branch '
+                                            'lengths for Newick tree.')
+    arg_parser.add_argument('--file', type=FileType('r'), action='store',
+                            dest='file', required=True,
+                            help='Newick file to parse')
+    options = arg_parser.parse_args()
+    tree_str = '\n'.join(options.file.readlines())
+    options.file.close()
+    node_parser = NewickParser()
+    tree = node_parser.parse(tree_str)
+    branch_lengths = compute_branch_lengths(tree)
+    for taxa, length in list(branch_lengths.items()):
+        print('{taxa}: {length}'.format(taxa=taxa, length=length))
+
+if __name__ == '__main__':
+    main()

source-code/pyparsing/macro_defs.py

@@ -0,0 +1,17 @@
+'''Module containing implementations of macros that
+   can be used in macro-expansion texts.'''
+
+
+def upper(text):
+    '''convert argument to all uppercase'''
+    return text.upper()
+
+
+def lower(text):
+    '''convert argument to all lowercase'''
+    return text.lower()
+
+
+def author():
+    '''returns the author'''
+    return 'Geert Jan Bex'

source-code/pyparsing/macro_expander.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python
+
+from argparse import ArgumentParser, FileType
+import imp
+import sys
+import types
+from pyparsing import Regex, Literal, ZeroOrMore, Group
+
+
+class UndefinedMacroError(Exception):
+    '''Class encoding an exception for an undefined macro encountered
+       while parsing a text'''
+
+    def __init__(self, function_name):
+        '''Constructor, takes the unknown macro name as an argument'''
+        super(UndefinedMacroError, self).__init__()
+        self._msg = "unknown macro '{0}'".format(function_name.strip('\\'))
+
+    def __str__(self):
+        '''method to stringify the exception'''
+        return repr(self._msg)
+
+
+class MacroExpander(object):
+    '''Macro expansion class, macros are encoded as
+       \\macro_name{param_1}...{param_n}'''
+
+    def __init__(self):
+        '''Constructor'''
+        self._macros = {}
+        text = Regex(r'[^\\]+').leaveWhitespace()
+        lb = Literal('{').suppress()
+        rb = Literal('}').suppress()
+        param_value = Regex(r'[^}\\]+')
+        param = lb + ZeroOrMore(param_value) + rb
+        params = Group(ZeroOrMore(param)).setResultsName('params')
+        macro_name = Regex(r'\\\w+').setResultsName('macro')
+        macro_call = macro_name + params
+        text_file = ZeroOrMore(text | macro_call)
+
+        def macro_action(toks):
+            macro_name = toks['macro']
+            params = toks['params']
+            if self._has_macro(macro_name):
+                return self._macros[macro_name](*params)
+            else:
+                raise UndefinedMacroError(macro_name)
+        macro_call.addParseAction(macro_action)
+        self._grammar = text_file
+
+    def add_macro(self, macro_name, macro_impl):
+        '''method to add a new macro to the macro expander, given
+           the function name, and its implementation as arguments'''
+        self._macros['\\' + macro_name] = macro_impl
+
+    def _has_macro(self, macro_name):
+        '''internal method to check whether the parser has a
+           definition for the given macro name'''
+        return macro_name in self._macros
+
+    def expand(self, text):
+        '''method to perform the macro expansion on the given text'''
+        results = self._grammar.parseString(text)
+        return ''.join(results)
+
+
+def main():
+    arg_parser = ArgumentParser(description='macro expansion utility')
+    arg_parser.add_argument('--file', type=FileType('r'),
+                            action='store', dest='file',
+                            required=True, help='file to expand')
+    arg_parser.add_argument('--def', type=str, action='store',
+                            default='macro_defs', dest='defs',
+                            help='macro definitions module name')
+    try:
+        options = arg_parser.parse_args()
+        text = ''.join(options.file)
+        module_info = imp.find_module(options.defs)
+        macro_module = imp.load_module(options.defs, *module_info)
+        expander = MacroExpander()
+        for macro_def in macro_module.__dict__.values():
+            if isinstance(macro_def, types.FunctionType):
+                expander.add_macro(macro_def.__name__, macro_def)
+        print(expander.expand(text))
+    except UndefinedMacroError as error:
+        sys.stderr.write('### error: ' + str(error) + '\n')
+        sys.exit(2)
+    except Exception as error:
+        sys.stderr.write('### error: ' + str(error) + '\n')
+        sys.exit(1)
+
+if __name__ == '__main__':
+    main()

source-code/pyparsing/macro_tests.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python
+'''Module defining some unit tests for the MacroExpander utility'''
+
+import unittest
+from macro_expander import MacroExpander
+
+
+class MacroExapnderTest(unittest.TestCase):
+
+    def setUp(self):
+        self._expander = MacroExpander()
+        self._expander.add_macro('upper', lambda x: x.upper())
+        self._expander.add_macro('lower', lambda x: x.lower())
+        self._expander.add_macro('gjb', lambda: 'Geert Jan Bex')
+        self._expander.add_macro('repeat', lambda x, n: int(n)*x)
+        self._expander.add_macro('cat', lambda x, y: x + '-' + y)
+        self._expander.add_macro('add', lambda x, y: str(int(x) + int(y)))
+
+    def test_upper(self):
+        orig_text = 'This is a text with \\upper{a function call}.'
+        target_text = 'This is a text with A FUNCTION CALL.'
+        text = self._expander.expand(orig_text)
+        self.assertEqual(text, target_text)
+
+    def test_apostrophe(self):
+        orig_text = "This'll be upper case \\upper{won't it?}."
+        target_text = "This'll be upper case WON'T IT?."
+        text = self._expander.expand(orig_text)
+        self.assertEqual(text, target_text)
+
+    def test_multiple_arguments(self):
+        orig_text = 'This \cat{abc}{def} a text.'
+        target_text = 'This abc-def a text.'
+        text = self._expander.expand(orig_text)
+        self.assertEqual(text, target_text)
+
+    def test_numerical_arguments(self):
+        orig_text = 'This is a sum: \\add{3}{7}.'
+        target_text = 'This is a sum: 10.'
+        text = self._expander.expand(orig_text)
+        self.assertEqual(text, target_text)
+
+    def test_literal_string(self):
+        orig_text = r'This \repeat{is}{3} a text.'
+        target_text = 'This isisis a text.'
+        text = self._expander.expand(orig_text)
+        self.assertEqual(text, target_text)
+
+    def test_multiple_macros(self):
+        orig_text = ('This \\repeat{is}{3} a text with \\upper{a ' +
+                     'function call}.')
+        target_text = 'This isisis a text with A FUNCTION CALL.'
+        text = self._expander.expand(orig_text)
+        self.assertEqual(text, target_text)
+
+    def test_multiple_lines(self):
+        orig_text = ('This is a text with \\upper{a function call},\n' +
+                     'and \lower{ANOTHER ONE} on multiple lines\n\n' +
+                     'authored by... \gjb.\n')
+        target_text = ('This is a text with A FUNCTION CALL,\n' +
+                       'and another one on multiple lines\n\n' +
+                       'authored by... Geert Jan Bex.\n')
+        text = self._expander.expand(orig_text)
+        self.assertEqual(text, target_text)
+
+
+if __name__ == '__main__':
+    unittest.main()

source-code/pyparsing/newick.txt

@@ -0,0 +1 @@
+(taxa1: 0.1, ((taxa2: 0.2, taxa3: 0.3): 0.11, taxa4: 0.4): 0.12);

source-code/pyparsing/newick_converter.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python
+'''various implementations of tree writers'''
+
+from argparse import ArgumentParser, FileType
+from tree_converter import XmlWriter, IndentedStringWriter, RelationalWriter
+from newick_parser import NewickParser
+
+
+class XmlNewickWriter(XmlWriter):
+    '''Writes a given node and its children as XML'''
+
+    def node_attr(self, node):
+        '''formats node attributes, if any'''
+        attr = ''
+        if node.label is not None:
+            attr += ' label="{0}"'.format(node.label)
+        if node.length is not None:
+            attr += ' length="{0}"'.format(node.length)
+        return attr
+
+
+class IndentedStringNewickWriter(IndentedStringWriter):
+    '''Writes a given node and its children as an indented string'''
+
+    def node_attr(self, node):
+        '''formats node attributes, if any'''
+        attr = ''
+        if node.label is not None:
+            attr += ': {0}'.format(node.label)
+        if node.length is not None:
+            attr += '[{0}]'.format(node.length)
+        return attr
+
+
+class RelationalNewickWriter(RelationalWriter):
+    '''Writes a given node and its children in a form that can be stored in
+       a relational table'''
+
+    def node_attr(self, node):
+        '''formats node attributes, if any'''
+        attr = ''
+        if node.label is not None:
+            attr += '\t{0}'.format(node.label)
+        else:
+            attr += '\tNone'
+        if node.length is not None:
+            attr += '\t{0}'.format(node.length)
+        else:
+            attr += '\tNone'
+        return attr
+
+
+def main():
+    '''Function that will parse the given file and convert the tree to the
+       format specified'''
+    argParser = ArgumentParser(description='tree structured data converter')
+    argParser.add_argument('--file', type=FileType('r'), action='store',
+                           dest='file', required=True,
+                           help='file to parse')
+    argParser.add_argument('--format', type=str, action='store',
+                           default='string', dest='format',
+                           help='format to convert to, default = string')
+    options = argParser.parse_args()
+    tree_str = '\n'.join(options.file.readlines())
+    options.file.close()
+    node_parser = NewickParser()
+    tree = node_parser.parse(tree_str)
+    if options.format == 'xml':
+        writer = XmlNewickWriter()
+    elif options.format == 'relational':
+        writer = RelationalNewickWriter()
+    else:
+        writer = IndentedStringNewickWriter()
+    print(writer.write(tree))
+
+if __name__ == '__main__':
+    main()

source-code/pyparsing/newick_indented.txt

@@ -0,0 +1,8 @@
+node "node_007"
+  node "node_001": taxa1[0.1]
+  node "node_006"[0.12]
+    node "node_004"[0.11]
+      node "node_002": taxa2[0.2]
+      node "node_003": taxa3[0.3]
+    node "node_005": taxa4[0.4]
+