trackler 2.2.1.52 → 2.2.1.53

data/tracks/python/README.md

@@ -19,10 +19,12 @@ A list of missing exercise can be found here: http://exercism.io/languages/pytho
 
 ### Conventions
 
-- We use minimalistic stub files for all exercises (#272).
+- We use minimalistic stub files for all exercises ([#272](https://github.com/exercism/python/issues/272)).
 - We use `unittest` (Python Standard Library) and no 3rd-party-framework.
-- We use the parameter order `self.assertEqual(actual, expected)` (#440).
-- We use context managers (`with self.assertRaises(\<exception type\>):`) for testing for exceptions (#477).
+- We use the parameter order `self.assertEqual(actual, expected)` ([#440](https://github.com/exercism/python/issues/440)).
+- We use context managers (`with self.assertRaises(\<exception type\>):`) for testing for exceptions ([#477](https://github.com/exercism/python/issues/477)).
+- We use `assertIs(actual, True)` and `assertIs(actual, False)` rather than `assertTrue(actual)` or `assertFalse(actual)` ([#419](https://github.com/exercism/python/pull/419)).
+- We use a comment string in the test file to reference the version of the exercise's `canonical-data.json` that tests were adapted from (wording can be found in: [#784](https://github.com/exercism/python/issues/784)).
 
 
 ### Testing
@@ -56,12 +58,12 @@ It will automatically check the code style, the problem configuration, and run t
 
 ## Pull Requests
 
-We :heart: pull requests! 
+We :heart: pull requests!
 We even :sparkling_heart: them if they contain well written commit messages!
 
 Please write the first line of your commit message in the following style:
 
-```exercise-name: Change some things``` 
+```exercise-name: Change some things```
 
 Please try to follow the [The seven rules of a great Git commit message](https://chris.beams.io/posts/git-commit/#seven-rules) like to capitalize the subject line and use the imperative mood. If there are more details to add, put those into the body of the commit message.
 

data/tracks/python/config.json

@@ -9,9 +9,9 @@
       "unlocked_by": null,
       "difficulty": 1,
       "topics": [
-        "control-flow (if-else statements)",
-        "optional values",
-        "text formatting"
+        "conditionals",
+        "optional_values",
+        "text_formatting"
       ]
     },
     {
@@ -21,7 +21,7 @@
       "unlocked_by": null,
       "difficulty": 1,
       "topics": [
-        "control-flow (if-else statements)",
+        "conditionals",
         "booleans",
         "logic"
       ]
@@ -46,8 +46,8 @@
       "unlocked_by": null,
       "difficulty": 1,
       "topics": [
-        "control-flow (loops)",
-        "control-flow (if-else statements)",
+        "loops",
+        "conditionals",
         "strings",
         "algorithms",
         "filtering",
@@ -61,8 +61,8 @@
       "unlocked_by": null,
       "difficulty": 1,
       "topics": [
-        "control-flow (if-else statements)",
-        "control-flow (loops)",
+        "conditionals",
+        "loops",
         "maps",
         "strings",
         "logic",
@@ -76,8 +76,8 @@
       "unlocked_by": null,
       "difficulty": 1,
       "topics": [
-        "control-flow (if-else statements)",
-        "control-flow (loops)",
+        "conditionals",
+        "loops",
         "sequences",
         "sets",
         "strings",
@@ -96,8 +96,8 @@
         "strings",
         "algorithms",
         "logic",
-        "pattern recognition",
-        "text formatting"
+        "pattern_recognition",
+        "text_formatting"
       ]
     },
     {
@@ -158,7 +158,7 @@
       "topics": [
         "strings",
         "logic",
-        "control-flow (loops)"
+        "loops"
       ]
     },
     {
@@ -479,8 +479,7 @@
       "topics": [
         "lists",
         "searching",
-        "loops",
-        "iteration"
+        "loops"
       ]
     },
     {
@@ -672,7 +671,7 @@
       "topics": [
         "lists",
         "parsing",
-        "transformation",
+        "transforming",
         "loops",
         "games"
       ]
@@ -908,7 +907,7 @@
         "time",
         "mathematics",
         "logic",
-        "text formatting"
+        "text_formatting"
       ]
     },
     {
@@ -919,7 +918,7 @@
       "difficulty": 4,
       "topics": [
         "files",
-        "text formatting",
+        "text_formatting",
         "searching"
       ]
     },
@@ -967,7 +966,7 @@
       "difficulty": 3,
       "topics": [
         "strings",
-        "pattern matching"
+        "pattern_matching"
       ]
     },
     {
@@ -978,7 +977,7 @@
       "difficulty": 3,
       "topics": [
         "strings",
-        "pattern matching"
+        "pattern_matching"
       ]
     },
     {
@@ -988,9 +987,9 @@
       "unlocked_by": null,
       "difficulty": 4,
       "topics": [
-        "Control-flow (loops)",
-        "Arrays",
-        "Algorithms"
+        "loops",
+        "arrays",
+        "algorithms"
       ]
     },
     {
@@ -1000,9 +999,9 @@
       "unlocked_by": null,
       "difficulty": 1,
       "topics": [
-        "control-flow (if-else statements)",
-        "optional values",
-        "text formatting"
+        "conditionals",
+        "optional_values",
+        "text_formatting"
       ]
     },
     {
@@ -1012,7 +1011,7 @@
       "unlocked_by": null,
       "difficulty": 1,
       "topics": [
-            "control-flow (loops)"
+        "loops"
       ]
     },
     {
@@ -1089,6 +1088,16 @@
             "trees"
         ]
     },
+    {
+      "uuid": "3a2a947a-01b3-1e80-e32b-de1756fd88365adf12e",
+      "slug": "error-handling",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 3,
+      "topics": [
+        "exception_handling"
+      ]
+    },
     {
       "uuid": "e7351e8e-d3ff-4621-b818-cd55cf05bffd",
       "slug": "accumulate",

data/tracks/python/docs/TESTS.md

@@ -4,14 +4,38 @@ We recommend you install [pytest](http://pytest.org/latest/) and
 [pytest-cache](http://pythonhosted.org/pytest-cache/). `pytest` is a testing
 tool that will give you more flexibility over running your unit tests.
 
+If you want to install `pytest` for Python 2, then use `pip`.
+
 ```bash
 pip install pytest pytest-cache
 ```
+If you instead want the version of `pytest` for Python 3, then use `pip3`.
+
+```bash
+pip3 install pytest pytest-cache
+```
 
 If you get a `command not found` response from your system, you can find a
 tutorial on how to install `pip`
 [here](https://pip.pypa.io/en/stable/installing/).
 
+**Note:** Whichever version of `pytest` you install last will be the default one used whenever `pytest` is executed, regardless of whether you have installed both versions.
+
+If you want to check what the default version of `pytest` being used is, run the following:
+
+```bash
+pytest --version
+```
+
+If you have either version of `pytest` installed and you want to specifically run one of the versions, you can run that version by using `python` with the `-m` flag.
+
+For example, you could run the Python 3 version of pytest like so:
+
+```bash
+$ python3 -m pytest --version
+This is pytest version 3.2.3, imported from /usr/local/lib/python3.5/dist-packages/pytest.py
+```
+
 If you choose not to install `pytest`, you can still run tests individually and
 skip the rest of this tutorial:
 
@@ -29,7 +53,7 @@ an example here), place yourself in the directory where that exercise has been
 fetched and run:
 
 ```bash
-py.test bob_test.py
+pytest bob_test.py
 ```
 
 **Note:** To run the tests you need to pass the name of the testsuite file to
@@ -56,7 +80,7 @@ The above will run all the tests, whether they fail or not. If you'd rather stop
 the process and exit on the first failure, run:
 
 ```bash
-py.test -x bob_test.py
+pytest -x bob_test.py
 ```
 
 ### Failed Tests First
@@ -64,14 +88,14 @@ py.test -x bob_test.py
 `pytest-cache` remembers which tests failed, and can run those tests first.
 
 ```bash
-py.test --ff bob_test.py
+pytest --ff bob_test.py
 ```
 
 ### Running All Tests for All Exercises
 
 ```bash
 cd exercism/python/
-py.test
+pytest
 ```
 
 ## Recommended Workflow
@@ -80,7 +104,7 @@ We recommend you run this command while working on exercises.
 
 ```bash
 cd exercism/python/bob
-py.test -x --ff bob_test.py
+pytest -x --ff bob_test.py
 ```
 
 ## PDB
@@ -89,28 +113,28 @@ Will drop you into the python debugger when a test fails. To learn how to use
 pdb, check out the
 [documentation](https://docs.python.org/3/library/pdb.html#debugger-commands).
 
-You may also be interested in watching [Clayton Parker's "So you think you can
-pdb?" PyCon 2015 talk](https://www.youtube.com/watch?v=P0pIW5tJrRM)
-
 ```bash
-py.test --pdb bob_test.py
+pytest --pdb bob_test.py
 ```
 
+You may also be interested in watching [Clayton Parker's "So you think you can
+pdb?" PyCon 2015 talk](https://www.youtube.com/watch?v=P0pIW5tJrRM).
+
 ## PEP8
 
 PEP8 is the [Style Guide for Python
 Code](https://www.python.org/dev/peps/pep-0008/). If you would like to test for
 compliance to the style guide, install
-[pytest-pep8](https://pypi.python.org/pypi/pytest-pep8)
+[pytest-pep8](https://pypi.python.org/pypi/pytest-pep8).
 
 ```bash
 pip install pytest-pep8
 ```
 
-and add the pep8 flag to your command
+Then, just add the `--pep8` flag to your command
 
 ```bash
-py.test --pep8 bob_test.py
+pytest --pep8 bob_test.py
 ```
 
 Read the [pytest documentation](http://pytest.org/latest/contents.html#toc) and

data/tracks/python/exercises/complex-numbers/complex_numbers_test.py

@@ -55,7 +55,7 @@ class ComplexNumbersTest(unittest.TestCase):
         self.assertEqual(first_input.sub(second_input).real, 2)
         self.assertEqual(first_input.sub(second_input).imaginary, 0)
 
-    def test_substract_numbers_with_real_and_imaginary_part(self):
+    def test_subtract_numbers_with_real_and_imaginary_part(self):
         first_input = ComplexNumber(1, 2)
         second_input = ComplexNumber(-2, -2)
         self.assertEqual(first_input.sub(second_input).real, 3)

data/tracks/python/exercises/diffie-hellman/.meta/hints.md

@@ -0,0 +1,16 @@
+## Should I use random or secrets?
+
+Python, as of version 3.6, includes two different random modules.
+
+The module called `random` is pseudo-random, meaning it does not generate
+true randomness, but follows an algorithm that simulates randomness.
+Since random numbers are generated through a known algorithm, they are not truly random.
+
+The `random` module is not correctly suited for cryptography and should not be used,
+precisely because it is pseudo-random.
+
+For this reason, in version 3.6, Python introduced the `secrets` module, which generates
+cryptographically strong random numbers that provide the greater security required for cryptography.
+
+Since this is only an exercise, `random` is fine to use, but note that **it would be
+very insecure if actually used for cryptography.**

data/tracks/python/exercises/diffie-hellman/README.md

@@ -37,9 +37,22 @@ Bob calculates
 The calculations produce the same result!  Alice and Bob now share
 secret s.
 
-## Notes
+## Should I use random or secrets?
 
-Python, as of version 3.6, includes two different random modules. The module called `random` is pseudo-random, meaning it does not generate true randomness, but follows and algorithm that simulates randomness. Since random numbers are generated through a known algorithm, they are not truly random. The `random` module is not correctly suited for cryptography and should not be used, because it is pseudo-random. In version 3.6, Python introduced the `secrets` module, which generates cryptographically strong random numbers that provide the greater security required for cryptography. Since this is only an exercise, `random` is fine to use, but note that it would be very insecure if actually used for cryptography.
+Python, as of version 3.6, includes two different random modules.
+
+The module called `random` is pseudo-random, meaning it does not generate
+true randomness, but follows an algorithm that simulates randomness.
+Since random numbers are generated through a known algorithm, they are not truly random.
+
+The `random` module is not correctly suited for cryptography and should not be used,
+precisely because it is pseudo-random.
+
+For this reason, in version 3.6, Python introduced the `secrets` module, which generates
+cryptographically strong random numbers that provide the greater security required for cryptography.
+
+Since this is only an exercise, `random` is fine to use, but note that **it would be
+very insecure if actually used for cryptography.**
 
 ### Submitting Exercises
 

data/tracks/python/exercises/error-handling/README.md

@@ -0,0 +1,23 @@
+# Error Handling
+
+Implement various kinds of error handling and resource management.
+
+An important point of programming is how to handle errors and close
+resources even if errors occur.
+
+This exercise requires you to handle various errors. Because error handling
+is rather programming language specific you'll have to refer to the tests
+for your track to see what's exactly required.
+
+### Submitting Exercises
+
+Note that, when trying to submit an exercise, make sure the solution is in the `exercism/python/<exerciseName>` directory.
+
+For example, if you're submitting `bob.py` for the Bob exercise, the submit command would be something like `exercism submit <path_to_exercism_dir>/python/bob/bob.py`.
+
+
+For more detailed information about running tests, code style and linting,
+please see the [help page](http://exercism.io/languages/python).
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/python/exercises/error-handling/error_handling.py

@@ -0,0 +1,14 @@
+def handle_error_by_throwing_exception():
+    pass
+
+
+def handle_error_by_returning_none(input_data):
+    pass
+
+
+def handle_error_by_returning_tuple(input_data):
+    pass
+
+
+def filelike_objects_are_closed_on_exception(filelike_object):
+    pass

data/tracks/python/exercises/error-handling/error_handling_test.py

@@ -0,0 +1,66 @@
+import unittest
+
+import error_handling as er
+
+
+class FileLike(object):
+    def __init__(self):
+        self.is_open = False
+        self.was_open = False
+        self.did_something = False
+
+    def open(self):
+        self.was_open = False
+        self.is_open = True
+
+    def close(self):
+        self.is_open = False
+        self.was_open = True
+
+    def __enter__(self):
+        self.open()
+        return self
+
+    def __exit__(self, *args):
+        self.close()
+
+    def do_something(self):
+        self.did_something = True
+        raise Exception()
+
+
+class ErrorHandlingTest(unittest.TestCase):
+    def test_throw_exception(self):
+        with self.assertRaises(Exception):
+            er.handle_error_by_throwing_exception()
+
+    def test_return_none(self):
+        self.assertEqual(er.handle_error_by_returning_none('1'), 1,
+                         'Result of valid input should not be None')
+        self.assertIsNone(er.handle_error_by_returning_none('a'),
+                          'Result of invalid input should be None')
+
+    def test_return_tuple(self):
+        successful_result, result = er.handle_error_by_returning_tuple('1')
+        self.assertIs(successful_result, True,
+                      'Valid input should be successful')
+        self.assertEqual(result, 1, 'Result of valid input should not be None')
+
+        failure_result, result = er.handle_error_by_returning_tuple('a')
+        self.assertIs(failure_result, False,
+                      'Invalid input should not be successful')
+
+    def test_filelike_objects_are_closed_on_exception(self):
+        filelike_object = FileLike()
+        with self.assertRaises(Exception):
+            er.filelike_objects_are_closed_on_exception(filelike_object)
+        self.assertIs(filelike_object.is_open, False,
+                      'filelike_object should be closed')
+        self.assertIs(filelike_object.was_open, True,
+                      'filelike_object should have been opened')
+        self.assertIs(filelike_object.did_something, True,
+                      'filelike_object should call do_something()')
+
+
+if __name__ == '__main__':
+    unittest.main()