Administrivia

Add more example files, and add more ignore

Author: rocky

.gitignore

@@ -6,9 +6,11 @@
 .python-version
 /*.egg
 /.cache
+/.config
 /.coverage
 /.eggs
 /.tox
+/.venv38
 /ChangeLog
 /build
 /dist

test/example/.gitignore

@@ -0,0 +1 @@
+/bug.py

test/example/bug.py

@@ -0,0 +1,4 @@
+# Stepping in multi-line statements is broken.
+def five(): return 5
+x = five()+1; y= five() + 2; a = 4
+z = x + y + a

test/example/gcd-breakpoint.py

@@ -0,0 +1,45 @@
+#!/usr/bin/python
+"""Greatest Common Divisor
+
+Some characterstics of this program used for testing check_args() does
+not have a 'return' statement.
+
+check_args() raises an uncaught exception when given the wrong number
+of parameters.
+
+"""
+import sys
+
+def check_args():
+    if len(sys.argv) != 3:
+        # Rather than use sys.exit let's just raise an error
+        raise Exception("Need to give two numbers")
+    for i in range(2):
+        try:
+            sys.argv[i + 1] = int(sys.argv[i + 1])
+        except ValueError:
+            print("** Expecting an integer, got: %s" % repr(sys.argv[i]))
+            sys.exit(2)
+
+
+def gcd(a, b):
+    """GCD. We assume positive numbers"""
+
+    # Make: a <= b
+    if a > b:
+        (a, b) = (b, a)
+
+    if a <= 0:
+        breakpoint()
+        return None
+    if a == 1 or b - a == 0:
+        breakpoint()
+        return a
+    return gcd(b - a, a)
+
+
+if __name__ == "__main__":
+    check_args()
+
+    (a, b) = sys.argv[1:3]
+    print("The GCD of %d and %d is %d" % (a, b, gcd(a, b)))

test/example/tail.py

@@ -0,0 +1,92 @@
+import os, sys
+
+# Implement a function that works like tail.
+# tail -n 10 file.txt
+# will return last 10 lines from the file.
+
+# Issues:
+#   Q: do we have to worry about -f?
+#   A: No.
+#   Q: what do we do if tail count is greater than lines of file?
+#   A: give entire file
+#   Q: how do we handle if last line doesn't contain a \n?
+#   A: treat it like it has \n
+
+# Algorithm idea:
+#   go to end keeping track of the i-th
+#   from the end line end, where i goes from 0 to n;
+#   n is the number of lines to tail.
+#   Then seek to that position and print the remaining bytes.
+#
+# Time Complexity:
+#   Let m be the size of the file and n size of the output
+#   and k be the blocksize
+#   Complexity is O(min(m,n)/k) since we may have to read and print the entire file
+# Space Complexity:
+#   O(min(m, k))
+
+def get_tail_start(path, count, blocksize):
+    """Return the position of where to start the tail listing.
+    This is \n positions from the end of the path. None
+    """
+    # seek to end - blocksize
+    file_size = os.stat(path).st_size
+    seek_position = file_size
+    # print(seek_position)
+    remaining = count+1
+    at_end = False
+    pos = -1
+    first_time = True
+    with open(path) as fd:
+        while remaining > 0 and seek_position >= 0 and not at_end:
+            seek_position -= blocksize
+            if seek_position < 0: seek_position = 0
+            fd.seek(seek_position)
+            block = fd.read(blocksize)
+            if first_time:
+                if block[-1:] != "\n": remaining -= 1
+                first_time = False
+            at_end = len(block) < blocksize
+            pos, remaining = find_line_end(block, remaining)
+    if pos is None: pos = -1
+    # print(seek_position + pos + 1)
+    return seek_position + pos + 1
+
+
+def find_line_end(block, remaining):
+    """Search backwards from block for at most *remaining* \n's
+    and return tuple [position, 0] if found in this block or
+    [None, remaining] if we have more to go"""
+    last_position = len(block)
+    while remaining != 0:
+        position = block.rfind("\n", 0, last_position)
+        if position == -1: return [None, remaining]
+        remaining -= 1
+        last_position = position
+    return [last_position, 0]
+
+def print_tail(path, pos, blocksize):
+    with open(path) as fd:
+        fd.seek(pos)
+        block = fd.read(blocksize)
+        while len(block) > 0:
+            if sys.version_info[0] < 3:
+                os.write(sys.stdout.fileno(), block)
+            else:
+                os.write(sys.stdout.fileno(), bytes(block, 'UTF-8'))
+            block = fd.read(blocksize)
+
+if __name__ == '__main__':
+    count = 5
+    path = __file__
+    # path = './test.txt'
+    # blocksize = 10000
+    # pos = get_tail_start(path, count, blocksize)
+    # print_tail(path, pos, blocksize)
+    # print('-----')
+    for blocksize in [5, 100, 100000]:
+        for count in range(5):
+            pos = get_tail_start(path, count, blocksize)
+            print('-------------------- %d' % count)
+            print_tail(path, pos, blocksize)
+            print('====================')

test/functional/example/step/test_skip.py

@@ -0,0 +1,9 @@
+##############################
+x = 4
+x = 5
+y = 7  # NOQA
+##############################
+x = 10
+x = 9
+z = 7  # NOQA
+##############################