add signet

Author: jimmysong

apply_patch.py

@@ -4,27 +4,27 @@
 
 
 patch = sys.argv[1]
-parts = patch.split('/')
+parts = patch.split("/")
 start = int(parts[0][-1])
 print(start)
 
-if parts[1] == 'complete':
+if parts[1] == "complete":
     start += 1
     patch_file = parts[2]
     skip = False
 else:
     patch_file = parts[1]
     skip = True
 
-to_patch = patch_file.split('.')[0] + '.py'
+to_patch = patch_file.split(".")[0] + ".py"
 
 for session in range(start, 9):
     if skip:
         skip = False
     else:
-        filename = 'session{}/{}'.format(session, to_patch)
-        call('git checkout {}'.format(filename), shell=True)
-        call('patch -p1 {} < {}'.format(filename, patch), shell=True)
-    filename = 'session{}/complete/{}'.format(session, to_patch)
-    call('git checkout {}'.format(filename), shell=True)
-    call('patch -p1 {} < {}'.format(filename, patch), shell=True)
+        filename = "session{}/{}".format(session, to_patch)
+        call("git checkout {}".format(filename), shell=True)
+        call("patch -p1 {} < {}".format(filename, patch), shell=True)
+    filename = "session{}/complete/{}".format(session, to_patch)
+    call("git checkout {}".format(filename), shell=True)
+    call("patch -p1 {} < {}".format(filename, patch), shell=True)

generate_jupyter.py

@@ -6,79 +6,79 @@
 if len(sessions) == 0:
     sessions = range(9)
 
-FIRST_CELL = '''############## PLEASE RUN THIS CELL FIRST! ###################
+FIRST_CELL = """############## PLEASE RUN THIS CELL FIRST! ###################
 
 # import everything and define a test runner function
 from importlib import reload
 from helper import run
-'''
+"""
 
-UNITTEST_TEMPLATE_1 = '''### Exercise {exercise_number}
+UNITTEST_TEMPLATE_1 = """### Exercise {exercise_number}
 
 {instructions}
 
-#### Make [this test](/edit/{path}/{module}.py) pass: `{module}.py:{test_suite}:{test}`'''
+#### Make [this test](/edit/{path}/{module}.py) pass: `{module}.py:{test_suite}:{test}`"""
 
 
-UNITTEST_TEMPLATE_2 = '''# Exercise {exercise_number}
+UNITTEST_TEMPLATE_2 = """# Exercise {exercise_number}
 
 reload({module})
-run({module}.{test_suite}('{test}'))'''
+run({module}.{test_suite}('{test}'))"""
 
 
-UNITTEST_TEMPLATE_3 = '''# Exercise {exercise_number}
+UNITTEST_TEMPLATE_3 = """# Exercise {exercise_number}
 
 reload({module})
 reload(script)
-run({module}.{test_suite}('{test}'))'''
+run({module}.{test_suite}('{test}'))"""
 
 
-EXERCISE_TEMPLATE_1 = '''### Exercise {exercise_number}
-{instructions}'''
+EXERCISE_TEMPLATE_1 = """### Exercise {exercise_number}
+{instructions}"""
 
 
-EXERCISE_TEMPLATE_2 = '''# Exercise {exercise_number}
+EXERCISE_TEMPLATE_2 = """# Exercise {exercise_number}
 
-{code}'''
+{code}"""
 
 
 for session in sessions:
     notebook = nbformat.v4.new_notebook()
     notebook_complete = nbformat.v4.new_notebook()
-    cells = notebook['cells']
-    cells_complete = notebook_complete['cells']
-    path = 'session{}'.format(session)
-    with open('{}/answers.py'.format(path), 'r') as f:
-        current = ''
+    cells = notebook["cells"]
+    cells_complete = notebook_complete["cells"]
+    path = "session{}".format(session)
+    with open("{}/answers.py".format(path), "r") as f:
+        current = ""
         cell_type = None
         exercise_number = 1
         first_code_cell = True
         for l in f:
             line = l.strip()
-            if line in ('#markdown', '#code', '#exercise', '#unittest'):
+            if line in ("#markdown", "#code", "#exercise", "#unittest"):
                 cell_type = line[1:]
-            elif line == '#end{}'.format(cell_type):
-                if cell_type == 'markdown':
+            elif line == "#end{}".format(cell_type):
+                if cell_type == "markdown":
                     markdown_cell = nbformat.v4.new_markdown_cell(current)
                     cells.append(markdown_cell)
                     cells_complete.append(markdown_cell)
-                elif cell_type == 'code':
+                elif cell_type == "code":
                     # only take >>> or ... lines
                     lines = []
-                    for line in current.split('\n'):
-                        if line.startswith('>>> ') or line.startswith('... '):
-                            line = re.sub(r'\\\\x', r'\\x', line)
+                    for line in current.split("\n"):
+                        if line.startswith(">>> ") or line.startswith("... "):
+                            line = re.sub(r"\\\\x", r"\\x", line)
                             lines.append(line[4:])
                     if first_code_cell:
-                        code = FIRST_CELL + '\n'.join(lines)
+                        code = FIRST_CELL + "\n".join(lines)
                         first_code_cell = False
                     else:
-                        code = '\n'.join(lines)
+                        code = "\n".join(lines)
                     code_cell = nbformat.v4.new_code_cell(code)
                     cells.append(code_cell)
                     cells_complete.append(code_cell)
-                elif cell_type == 'exercise':
-                    instructions, code = current.split('---')
+                elif cell_type == "exercise":
+                    instructions, code = current.split("---")
                     markdown = EXERCISE_TEMPLATE_1.format(
                         exercise_number=exercise_number,
                         instructions=instructions,
@@ -88,31 +88,31 @@
                     cells_complete.append(markdown_cell)
                     lines = []
                     lines_complete = []
-                    for line in code.split('\n'):
-                        if line.startswith('>>> ') or line.startswith('... '):
-                            line = re.sub(r'\\\\x', r'\\x', line)
-                            start_alt = line.find('  #/')
+                    for line in code.split("\n"):
+                        if line.startswith(">>> ") or line.startswith("... "):
+                            line = re.sub(r"\\\\x", r"\\x", line)
+                            start_alt = line.find("  #/")
                             if start_alt == -1:
                                 lines.append(line[4:])
                                 lines_complete.append(line[4:])
                             else:
-                                lines.append(line[start_alt+4:])
+                                lines.append(line[start_alt + 4 :])
                                 lines_complete.append(line[4:start_alt])
                     code_1 = EXERCISE_TEMPLATE_2.format(
-                        code='\n'.join(lines),
+                        code="\n".join(lines),
                         exercise_number=exercise_number,
                     )
                     code_cell_1 = nbformat.v4.new_code_cell(code_1)
                     cells.append(code_cell_1)
                     code_2 = EXERCISE_TEMPLATE_2.format(
-                        code='\n'.join(lines_complete),
+                        code="\n".join(lines_complete),
                         exercise_number=exercise_number,
                     )
                     code_cell_2 = nbformat.v4.new_code_cell(code_2)
                     cells_complete.append(code_cell_2)
                     exercise_number += 1
-                elif cell_type == 'unittest':
-                    module, test_suite, test, instructions = current.split(':', 3)
+                elif cell_type == "unittest":
+                    module, test_suite, test, instructions = current.split(":", 3)
                     markdown = UNITTEST_TEMPLATE_1.format(
                         exercise_number=exercise_number,
                         instructions=instructions,
@@ -124,7 +124,7 @@
                     markdown_cell = nbformat.v4.new_markdown_cell(markdown)
                     cells.append(markdown_cell)
                     cells_complete.append(markdown_cell)
-                    if module == 'op':
+                    if module == "op":
                         template = UNITTEST_TEMPLATE_3
                     else:
                         template = UNITTEST_TEMPLATE_2
@@ -139,9 +139,11 @@
                     cells.append(code_cell)
                     cells_complete.append(code_cell)
                     exercise_number += 1
-                current = ''
+                current = ""
                 cell_type = None
             elif cell_type:
-                current += line + '\n'
-    nbformat.write(notebook, '{}/session{}.ipynb'.format(path, session))
-    nbformat.write(notebook_complete, '{}/complete/session{}.ipynb'.format(path, session))
+                current += line + "\n"
+    nbformat.write(notebook, "{}/session{}.ipynb".format(path, session))
+    nbformat.write(
+        notebook_complete, "{}/complete/session{}.ipynb".format(path, session)
+    )

remake.py

@@ -3,25 +3,29 @@
 
 
 for i in range(8):
-    current = 'session{}'.format(i)
-    branch = 's{}'.format(i)
-    output = subprocess.check_output(['git', 'ls-tree', '-r', '--name-only', current]).decode('ascii')
+    current = "session{}".format(i)
+    branch = "s{}".format(i)
+    output = subprocess.check_output(
+        ["git", "ls-tree", "-r", "--name-only", current]
+    ).decode("ascii")
     for filename in output.split():
-        if filename.endswith(('py','ipynb')) and filename != 'redo.py':
-            if filename.endswith('ipynb') \
-               and not filename.startswith(current):
+        if filename.endswith(("py", "ipynb")) and filename != "redo.py":
+            if filename.endswith("ipynb") and not filename.startswith(current):
                 continue
-            with open('{}/{}'.format(current, filename), 'wb') as f:
-                contents = subprocess.check_output(['git', 'show', '{}:{}'.format(branch, filename)])
+            with open("{}/{}".format(current, filename), "wb") as f:
+                contents = subprocess.check_output(
+                    ["git", "show", "{}:{}".format(branch, filename)]
+                )
                 f.write(contents)
-    output = subprocess.check_output(['git', 'ls-tree', '-r', '--name-only', '{}-c'.format(branch)]).decode('ascii')
+    output = subprocess.check_output(
+        ["git", "ls-tree", "-r", "--name-only", "{}-c".format(branch)]
+    ).decode("ascii")
     for filename in output.split():
-        if filename.endswith(('py','ipynb')) and filename != 'redo.py':
-            if filename.endswith('ipynb') \
-               and not filename.startswith(current):
+        if filename.endswith(("py", "ipynb")) and filename != "redo.py":
+            if filename.endswith("ipynb") and not filename.startswith(current):
                 continue
-            with open('{}/complete/{}'.format(current, filename), 'wb') as f:
-                contents = subprocess.check_output(['git', 'show', '{}-c:{}'.format(branch, filename)])
+            with open("{}/complete/{}".format(current, filename), "wb") as f:
+                contents = subprocess.check_output(
+                    ["git", "show", "{}-c:{}".format(branch, filename)]
+                )
                 f.write(contents)
-    
-                      

session0/answers.py

@@ -1,4 +1,4 @@
-'''
+"""
 #code
 >>> import helper
 
@@ -131,7 +131,7 @@
 Indexing bytes will get you the numerical value:
 
 ```python
-print(b'&'[0]) # 38 since & is charcter #38
+print(b'&'[0]) # 38 since & is character #38
 ```
 
 You can do the reverse by using bytes:
@@ -152,7 +152,7 @@
 >>> print(b[::-1]) # b'dlrow olleh'
 b'dlrow olleh'
 >>>
->>> print(b'&'[0]) # 38 since & charcter #38
+>>> print(b'&'[0]) # 38 since & character #38
 38
 >>>
 >>> print(bytes([38])) # b'&'
@@ -302,29 +302,31 @@
 helper:HelperTest:test_int_to_little_endian:
 Similarly, we'll want to do the inverse operation, so write a function that will convert an integer to little-endian bytes given the number and the number of bytes it should take up.
 #endunittest
-'''
+"""
 
 
 from unittest import TestCase
 
 import helper
 
 
-def bytes_to_str(b, encoding='ascii'):
+def bytes_to_str(b, encoding="ascii"):
     return b.decode(encoding)
 
-def str_to_bytes(s, encoding='ascii'):
+
+def str_to_bytes(s, encoding="ascii"):
     return s.encode(encoding)
 
+
 def little_endian_to_int(b):
-    return int.from_bytes(b, 'little')
+    return int.from_bytes(b, "little")
+
 
 def int_to_little_endian(n, length):
-    return n.to_bytes(length, 'little')
+    return n.to_bytes(length, "little")
 
 
 class SessionTest(TestCase):
-
     def test_apply(self):
         helper.bytes_to_str = bytes_to_str
         helper.str_to_bytes = str_to_bytes

session0/complete/helper.py

@@ -7,52 +7,51 @@ def run(test):
     TextTestRunner().run(suite)
 
 
-def bytes_to_str(b, encoding='ascii'):
-    '''Returns a string version of the bytes'''
+def bytes_to_str(b, encoding="ascii"):
+    """Returns a string version of the bytes"""
     # use the bytes.decode(encoding) method
     return b.decode(encoding)
 
 
-def str_to_bytes(s, encoding='ascii'):
-    '''Returns a bytes version of the string'''
+def str_to_bytes(s, encoding="ascii"):
+    """Returns a bytes version of the string"""
     # use the string.encode(encoding) method
     return s.encode(encoding)
 
 
 def little_endian_to_int(b):
-    '''little_endian_to_int takes byte sequence as a little-endian number.
-    Returns an integer'''
+    """little_endian_to_int takes byte sequence as a little-endian number.
+    Returns an integer"""
     # use the int.from_bytes(b, <endianness>) method
-    return int.from_bytes(b, 'little')
+    return int.from_bytes(b, "little")
 
 
 def int_to_little_endian(n, length):
-    '''endian_to_little_endian takes an integer and returns the little-endian
-    byte sequence of length'''
+    """endian_to_little_endian takes an integer and returns the little-endian
+    byte sequence of length"""
     # use the int.to_bytes(length, <endianness>) method
-    return n.to_bytes(length, 'little')
+    return n.to_bytes(length, "little")
 
 
 class HelperTest(TestCase):
-
     def test_bytes(self):
-        b = b'hello world'
-        s = 'hello world'
+        b = b"hello world"
+        s = "hello world"
         self.assertEqual(b, str_to_bytes(s))
         self.assertEqual(s, bytes_to_str(b))
 
     def test_little_endian_to_int(self):
-        h = bytes.fromhex('99c3980000000000')
+        h = bytes.fromhex("99c3980000000000")
         want = 10011545
         self.assertEqual(little_endian_to_int(h), want)
-        h = bytes.fromhex('a135ef0100000000')
+        h = bytes.fromhex("a135ef0100000000")
         want = 32454049
         self.assertEqual(little_endian_to_int(h), want)
 
     def test_int_to_little_endian(self):
         n = 1
-        want = b'\x01\x00\x00\x00'
+        want = b"\x01\x00\x00\x00"
         self.assertEqual(int_to_little_endian(n, 4), want)
         n = 10011545
-        want = b'\x99\xc3\x98\x00\x00\x00\x00\x00'
+        want = b"\x99\xc3\x98\x00\x00\x00\x00\x00"
         self.assertEqual(int_to_little_endian(n, 8), want)