EHN: Refactor with black

Author: hlouzada

labfis/__init__.py

@@ -3,9 +3,9 @@
 # Copyright © 2020 labfis.py
 # (see LICENSE for details)
 
-__version__ = '1.2.0b1'
+__version__ = "1.2.0b1"
 
 # Local imports
 from labfis.uncertainty import labfloat, Infix
 
-u = Infix(lambda x,y: labfloat(x,y))
+u = Infix(lambda x, y: labfloat(x, y))

labfis/test/accuracy_test.py

@@ -11,20 +11,19 @@ def labfloat_iterative(vardic, exp):
     resulterror = 0
 
     for var in vardic.keys():
-        exec(var + "=" + 'vardic[var][0]')
+        exec(var + "=" + "vardic[var][0]")
 
     for var in vardic.keys():
         var_value = vardic[var][0]
         var_error = vardic[var][1]
 
-        exec(var + "=" + 'var_value' +
-             "+" + 'dx')
+        exec(var + "=" + "var_value" + "+" + "dx")
         dph = eval(exp)
 
-        exec(var + "=" + 'var_value')
+        exec(var + "=" + "var_value")
         dpn = eval(exp)
 
-        derivative = (dph - dpn)/dx
+        derivative = (dph - dpn) / dx
         resulterror += (derivative ** 2) * (var_error ** 2)
     return sqrt(resulterror)
 
@@ -45,26 +44,26 @@ def labfloat_calc(vardic, exp):
     "b": (rng.random(), rng.random()),
     "c": (rng.random(), rng.random()),
     "d": (rng.random(), rng.random()),
-    "e": (rng.random(), rng.random())
+    "e": (rng.random(), rng.random()),
 }
 
 
 def test_labfloat_expressions():
     print(vals)
     var = list(vals.keys())
-    opers = itertools.combinations_with_replacement(operations, len(var)-1)
+    opers = itertools.combinations_with_replacement(operations, len(var) - 1)
     for exp in opers:
         expression = ""
         for i in range(len(exp)):
-            if i == len(exp)-1:
-                expression += var[i]+exp[i]+var[i+1]
+            if i == len(exp) - 1:
+                expression += var[i] + exp[i] + var[i + 1]
             else:
-                expression += var[i]+exp[i]
+                expression += var[i] + exp[i]
 
         result1 = labfloat_iterative(vals, expression)
         result2 = labfloat_calc(vals, expression)
 
-        error = abs(result2 - result1)/result2
+        error = abs(result2 - result1) / result2
 
         print(expression)
         print(type(result1), type(result2))

labfis/test/arithmetic_test.py

@@ -3,13 +3,21 @@
 
 
 def test_zeros():
-    zeros = [labfloat(), labfloat(0), labfloat(0.), labfloat(0, 0),
-             labfloat(0., 0.), labfloat(0., 0), labfloat(0, 0.)]
+    zeros = [
+        labfloat(),
+        labfloat(0),
+        labfloat(0.0),
+        labfloat(0, 0),
+        labfloat(0.0, 0.0),
+        labfloat(0.0, 0),
+        labfloat(0, 0.0),
+    ]
 
     for z1, z2 in combinations(zeros, 2):
         print(z1, z2)
         assert list(z1) == list(z2)
 
+
 def test_indexing():
     assert labfloat(10, 2)[:] == (10, 2)
 
@@ -34,4 +42,5 @@ def test_neg_uncertainty():
 
         assert list(x) == list(y)
 
+
 # TODO: test cases for other arithmetic operators

labfis/test/interface_test.py

@@ -1,10 +1,12 @@
 from random import uniform
-from labfis import u, labfloat 
+from labfis import u, labfloat
+
 
 def test_infix():
     for _ in range(200):
-        x, e = uniform(-2e50,2e50), uniform(-2e50,2e50) 
-        assert labfloat(x, e) == x |u| e == x <<u>> e 
+        x, e = uniform(-2e50, 2e50), uniform(-2e50, 2e50)
+        assert labfloat(x, e) == x | u | e == x << u >> e
+
 
 def test_attrs():
     x = labfloat(10, 1)