Mon Sep 30 11:31:15 PDT 2024

hw/sol-hw03/construct_check.py

@@ -0,0 +1,180 @@
+from ast import parse, NodeVisitor, Name
+
+# For error messages (student-facing) only
+_NAMES = {
+    'Add': '+',
+    'And': 'and',
+    'Assert': 'assert',
+    'Assign': '=',
+    'AnnAssign': '=',
+    'AugAssign': 'op=',
+    'BitAnd': '&',
+    'BitOr': '|',
+    'BitXor': '^',
+    'Break': 'break',
+    'Recursion': 'recursive call',
+    'ClassDef': 'class',
+    'Continue': 'continue',
+    'Del': 'del',
+    'Delete': 'delete',
+    'Dict': '{...}',
+    'DictComp': '{...}',
+    'Div': '/',
+    'Ellipsis': '...',
+    'Eq': '==',
+    'ExceptHandler': 'except',
+    'ExtSlice': '[::]',
+    'FloorDiv': '//',
+    'For': 'for',
+    'FunctionDef': 'def',
+    'Filter': 'filter',
+    'GeneratorExp': '(... for ...)',
+    'Global': 'global',
+    'Gt': '>',
+    'GtE': '>=',
+    'If': 'if',
+    'IfExp': '...if...else...',
+    'Import': 'import',
+    'ImportFrom': 'from ... import ...',
+    'In': 'in',
+    'Index': '...[...]',
+    'Invert': '~',
+    'Is': 'is',
+    'IsNot': 'is not ',
+    'LShift': '<<',
+    'Lambda': 'lambda',
+    'List': '[...]',
+    'ListComp': '[...for...]',
+    'Lt': '<',
+    'LtE': '<=',
+    'Mod': '%',
+    'Mult': '*',
+    'NamedExpr': ':=',
+    'Nonlocal': 'nonlocal',
+    'Not': 'not',
+    'NotEq': '!=',
+    'NotIn': 'not in',
+    'Or': 'or',
+    'Pass': 'pass',
+    'Pow': '**',
+    'RShift': '>>',
+    'Raise': 'raise',
+    'Return': 'return',
+    'Set': '{ ... } (set)',
+    'SetComp': '{ ... for ... } (set)',
+    'Slice': '[ : ]',
+    'Starred': '',
+    'Str': 'str',
+    'Sub': '-',
+    'Subscript': '[]',
+    'Try': 'try',
+    'Tuple': '(... , ... )',
+    'UAdd': '+',
+    'USub': '-',
+    'While': 'while',
+    'With': 'with',
+    'Yield': 'yield',
+    'YieldFrom': 'yield from',
+}
+
+def check(source_file, checked_funcs, disallow, source=None):
+    """Checks that AST nodes whose type names are present in DISALLOW
+    (an object supporting 'in') are not present in the function(s) named
+    CHECKED_FUNCS in SOURCE.  By default, SOURCE is the contents of the
+    file SOURCE_FILE.  CHECKED_FUNCS is either a string (indicating a single
+    name) or an object of some other type that supports 'in'. CHECKED_FUNCS
+    may contain __main__ to indicate an entire  module. Prints reports of
+    each prohibited node and returns True iff none are found.
+    See ast.__dir__() for AST type names.  The special node name 'Recursion'
+    checks for overtly recursive calls (i.e., calls of the form NAME(...) where
+    NAME is an enclosing def."""
+    return ExclusionChecker(disallow).check(source_file, checked_funcs, source)
+
+class ExclusionChecker(NodeVisitor):
+    """An AST visitor that checks that certain constructs are excluded from
+    parts of a program.  ExclusionChecker(EXC) checks that AST node types
+    whose names are in the sequence or set EXC are not present.  Its check
+    method visits nodes in a given function of a source file checking that the
+    indicated node types are not used."""
+
+    def __init__(self, disallow=()):
+        """DISALLOW is the initial default list of disallowed
+        node-type names."""
+        self._disallow = set(disallow)
+        self._checking = False
+        self._errs = 0
+
+    def generic_visit(self, node):
+        if self._checking and type(node).__name__ in self._disallow:
+            self._report(node)
+        super().generic_visit(node)
+
+    def visit_Module(self, node):
+        if "__main__" in self._checked_funcs:
+            self._checking = True
+            self._checked_name = self._source_file
+        super().generic_visit(node)
+
+    def visit_Call(self, node):
+        if 'Recursion' in self._disallow and \
+           type(node.func) is Name and \
+           node.func.id in self._func_nest:
+            self._report(node, "should not be recursive")
+        self.generic_visit(node)
+
+    def visit_FunctionDef(self, node):
+        self._func_nest.append(node.name)
+        if self._checking:
+            self.generic_visit(node)
+        elif node.name in self._checked_funcs:
+            self._checked_name = "Function " + node.name
+            checking0 = self._checking
+            self._checking = True
+            super().generic_visit(node)
+            self._checking = checking0
+        self._func_nest.pop()
+
+    def _report(self, node, msg=None):
+        node_name = _NAMES.get(type(node).__name__, type(node).__name__)
+        if msg is None:
+            msg = "should not contain '{}'".format(node_name)
+        print("{} {}".format(self._checked_name, msg))
+        self._errs += 1
+
+    def errors(self):
+        """Returns the number of number of prohibited constructs found in
+        the last call to check."""
+        return self._errs
+
+    def check(self, source_file, checked_funcs, disallow=None, source=None):
+        """Checks that AST nodes whose type names are present in DISALLOW
+        (an object supporting the contains test) are not present in
+        the function(s) named CHECKED_FUNCS in SOURCE.  By default, SOURCE
+        is the contents of the file SOURCE_FILE.  DISALLOW defaults to the
+        argument given to the constructor (and resets that value if it is
+        present).  CHECKED_FUNCS is either a string (indicating a single
+        name) or an object of some other type that supports 'in'.
+        CHECKED_FUNCS may contain __main__ to indicate an entire module.
+        Prints reports of each prohibited node and returns True iff none
+        are found.
+        See ast.__dir__() for AST type names.  The special node name
+        'Recursion' checks for overtly recursive calls (i.e., calls of the
+        form NAME(...) where NAME is an enclosing def."""
+
+        self._checking = False
+        self._source_file = source_file
+        self._func_nest = []
+        if type(checked_funcs) is str:
+            self._checked_funcs = { checked_funcs }
+        else:
+            self._checked_funcs = set(checked_funcs)
+        if disallow is not None:
+            self._disallow = set(disallow)
+        if source is None:
+            with open(source_file, 'r', errors='ignore') as inp:
+                source = inp.read()
+        p = parse(source, source_file)
+        self._errs = 0
+
+        self.visit(p)
+        return self._errs == 0

hw/sol-hw03/hw03.ok

@@ -0,0 +1,26 @@
+{
+    "name": "Homework 3",
+    "endpoint": "cal/c88c/fa24/hw03",
+    "src": [
+        "hw03.py"
+    ],
+    "tests": {
+        "hw*.py": "doctest",
+        "tests/*.py": "ok_test"
+    },
+    "default_tests": [
+        "product",
+        "accumulate",
+        "summation_using_accumulate",
+        "product_using_accumulate",
+        "make_repeater"
+    ],
+    "protocols": [
+        "restore",
+        "file_contents",
+        "grading",
+        "help",
+        "analytics",
+        "backup"
+    ]
+}

hw/sol-hw03/hw03.py

@@ -0,0 +1,121 @@
+from operator import add, mul
+
+square = lambda x: x * x
+
+identity = lambda x: x
+
+triple = lambda x: 3 * x
+
+increment = lambda x: x + 1
+
+
+HW_SOURCE_FILE=__file__
+
+
+def product(n, term):
+    """Return the product of the first n terms in a sequence.
+
+    n: a positive integer
+    term:  a function that takes one argument to produce the term
+
+    >>> product(3, identity)  # 1 * 2 * 3
+    6
+    >>> product(5, identity)  # 1 * 2 * 3 * 4 * 5
+    120
+    >>> product(3, square)    # 1^2 * 2^2 * 3^2
+    36
+    >>> product(5, square)    # 1^2 * 2^2 * 3^2 * 4^2 * 5^2
+    14400
+    >>> product(3, increment) # (1+1) * (2+1) * (3+1)
+    24
+    >>> product(3, triple)    # 1*3 * 2*3 * 3*3
+    162
+    """
+    prod, k = 1, 1
+    while k <= n:
+        prod, k = term(k) * prod, k + 1
+    return prod
+
+
+def accumulate(fuse, start, n, term):
+    """Return the result of fusing together the first n terms in a sequence 
+    and start.  The terms to be fused are term(1), term(2), ..., term(n). 
+    The function fuse is a two-argument commutative & associative function.
+
+    >>> accumulate(add, 0, 5, identity)  # 0 + 1 + 2 + 3 + 4 + 5
+    15
+    >>> accumulate(add, 11, 5, identity) # 11 + 1 + 2 + 3 + 4 + 5
+    26
+    >>> accumulate(add, 11, 0, identity) # 11 (fuse is never used)
+    11
+    >>> accumulate(add, 11, 3, square)   # 11 + 1^2 + 2^2 + 3^2
+    25
+    >>> accumulate(mul, 2, 3, square)    # 2 * 1^2 * 2^2 * 3^2
+    72
+    >>> # 2 + (1^2 + 1) + (2^2 + 1) + (3^2 + 1)
+    >>> accumulate(lambda x, y: x + y + 1, 2, 3, square)
+    19
+    """
+    total, k = start, 1
+    while k <= n:
+        total, k = fuse(total, term(k)), k + 1
+    return total
+
+# Alternative solution
+def accumulate_reverse(fuse, start, n, term):
+    total, k = start, n
+    while k >= 1:
+        total, k = fuse(total, term(k)), k - 1
+    return total
+
+
+def summation_using_accumulate(n, term):
+    """Returns the sum: term(1) + ... + term(n), using accumulate.
+
+    >>> summation_using_accumulate(5, square) # square(1) + square(2) + ... + square(4) + square(5)
+    55
+    >>> summation_using_accumulate(5, triple) # triple(1) + triple(2) + ... + triple(4) + triple(5)
+    45
+    >>> # This test checks that the body of the function is just a return statement.
+    >>> import inspect, ast
+    >>> [type(x).__name__ for x in ast.parse(inspect.getsource(summation_using_accumulate)).body[0].body]
+    ['Expr', 'Return']
+    """
+    return accumulate(add, 0, n, term)
+
+
+def product_using_accumulate(n, term):
+    """Returns the product: term(1) * ... * term(n), using accumulate.
+
+    >>> product_using_accumulate(4, square) # square(1) * square(2) * square(3) * square()
+    576
+    >>> product_using_accumulate(6, triple) # triple(1) * triple(2) * ... * triple(5) * triple(6)
+    524880
+    >>> # This test checks that the body of the function is just a return statement.
+    >>> import inspect, ast
+    >>> [type(x).__name__ for x in ast.parse(inspect.getsource(product_using_accumulate)).body[0].body]
+    ['Expr', 'Return']
+    """
+    return accumulate(mul, 1, n, term)
+
+
+def make_repeater(f, n):
+    """Returns the function that computes the nth application of f.
+
+    >>> add_three = make_repeater(increment, 3)
+    >>> add_three(5)
+    8
+    >>> make_repeater(triple, 5)(1) # 3 * (3 * (3 * (3 * (3 * 1))))
+    243
+    >>> make_repeater(square, 2)(5) # square(square(5))
+    625
+    >>> make_repeater(square, 3)(5) # square(square(square(5)))
+    390625
+    """
+    def repeater(x):
+        k = 0
+        while k < n:
+            x, k = f(x), k + 1
+        return x
+    return repeater
+