triangle: sync with problem-specifications

exercises/triangle/example.py

@@ -1,20 +1,18 @@
 def valid(sides):
-    return (
-        sum(sorted(sides)[:2]) >= sorted(sides)[2] and
-        all(s > 0 for s in sides)
+    return sum(sorted(sides)[:2]) >= sorted(sides)[2] and all(
+        s > 0 for s in sides
     )
 
 
-def is_equilateral(sides):
+def equilateral(sides):
     return valid(sides) and all(sides[0] == s for s in sides)
 
 
-def is_isosceles(sides):
-    return (
-        valid(sides) and
-        any(s1 == s2 for s1, s2 in zip(sorted(sides), sorted(sides)[1:]))
+def isosceles(sides):
+    return valid(sides) and any(
+        s1 == s2 for s1, s2 in zip(sorted(sides), sorted(sides)[1:])
     )
 
 
-def is_scalene(sides):
-    return valid(sides) and not is_isosceles(sides)
+def scalene(sides):
+    return valid(sides) and not isosceles(sides)

exercises/triangle/triangle.py

@@ -1,10 +1,10 @@
-def is_equilateral(sides):
+def equilateral(sides):
     pass
 
 
-def is_isosceles(sides):
+def isosceles(sides):
     pass
 
 
-def is_scalene(sides):
+def scalene(sides):
     pass

exercises/triangle/triangle_test.py

@@ -1,72 +1,73 @@
 import unittest
 
-from triangle import is_equilateral, is_isosceles, is_scalene
+from triangle import equilateral, isosceles, scalene
 
 
 # Tests adapted from `problem-specifications//canonical-data.json` @ v1.2.1
 
-class is_equilateralTests(unittest.TestCase):
+
+class TestEquilateralTriangle(unittest.TestCase):
     def test_all_sides_are_equal(self):
-        self.assertIs(is_equilateral([2, 2, 2]), True)
+        self.assertIs(equilateral([2, 2, 2]), True)
 
     def test_any_side_is_unequal(self):
-        self.assertIs(is_equilateral([2, 3, 2]), False)
+        self.assertIs(equilateral([2, 3, 2]), False)
 
     def test_no_sides_are_equal(self):
-        self.assertIs(is_equilateral([5, 4, 6]), False)
+        self.assertIs(equilateral([5, 4, 6]), False)
 
     def test_all_zero_sides_is_not_a_triangle(self):
-        self.assertIs(is_equilateral([0, 0, 0]), False)
+        self.assertIs(equilateral([0, 0, 0]), False)
 
     def test_sides_may_be_floats(self):
-        self.assertIs(is_equilateral([0.5, 0.5, 0.5]), True)
+        self.assertIs(equilateral([0.5, 0.5, 0.5]), True)
 
 
-class is_isoscelesTests(unittest.TestCase):
+class TestIsoscelesTriangle(unittest.TestCase):
     def test_last_two_sides_are_equal(self):
-        self.assertIs(is_isosceles([3, 4, 4]), True)
+        self.assertIs(isosceles([3, 4, 4]), True)
 
     def test_first_two_sides_are_equal(self):
-        self.assertIs(is_isosceles([4, 4, 3]), True)
+        self.assertIs(isosceles([4, 4, 3]), True)
 
     def test_first_and_last_sides_are_equal(self):
-        self.assertIs(is_isosceles([4, 3, 4]), True)
+        self.assertIs(isosceles([4, 3, 4]), True)
 
     def test_equilateral_triangles_are_also_isosceles(self):
-        self.assertIs(is_isosceles([4, 4, 4]), True)
+        self.assertIs(isosceles([4, 4, 4]), True)
 
     def test_no_sides_are_equal(self):
-        self.assertIs(is_isosceles([2, 3, 4]), False)
+        self.assertIs(isosceles([2, 3, 4]), False)
 
     def test_first_triangle_inequality_violation(self):
-        self.assertIs(is_isosceles([1, 1, 3]), False)
+        self.assertIs(isosceles([1, 1, 3]), False)
 
     def test_second_triangle_inequality_violation(self):
-        self.assertIs(is_isosceles([1, 3, 1]), False)
+        self.assertIs(isosceles([1, 3, 1]), False)
 
     def test_third_triangle_inequality_violation(self):
-        self.assertIs(is_isosceles([3, 1, 1]), False)
+        self.assertIs(isosceles([3, 1, 1]), False)
 
     def test_sides_may_be_floats(self):
-        self.assertIs(is_isosceles([0.5, 0.4, 0.5]), True)
+        self.assertIs(isosceles([0.5, 0.4, 0.5]), True)
 
 
-class is_scaleneTests(unittest.TestCase):
+class TestScaleneTriangle(unittest.TestCase):
     def test_no_sides_are_equal(self):
-        self.assertIs(is_scalene([5, 4, 6]), True)
+        self.assertIs(scalene([5, 4, 6]), True)
 
     def test_all_sides_are_equal(self):
-        self.assertIs(is_scalene([4, 4, 4]), False)
+        self.assertIs(scalene([4, 4, 4]), False)
 
     def test_two_sides_are_equal(self):
-        self.assertIs(is_scalene([4, 4, 3]), False)
+        self.assertIs(scalene([4, 4, 3]), False)
 
     def test_may_not_violate_triangle_inequality(self):
-        self.assertIs(is_scalene([7, 3, 2]), False)
+        self.assertIs(scalene([7, 3, 2]), False)
 
     def test_sides_may_be_floats(self):
-        self.assertIs(is_scalene([0.5, 0.4, 0.6]), True)
+        self.assertIs(scalene([0.5, 0.4, 0.6]), True)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()