PEP8 correct F401 and F841

build/lib/navipy/comparing/test.py

@@ -13,10 +13,8 @@ class TestCase(unittest.TestCase):
         self.mydb = database.DataBaseLoad(self.mydb_filename)
 
     def test_imagediff_curr(self):
-        curr = self.mydb.read_image(rowid=1)
-        mem = self.mydb.read_image(rowid=2)
-        curr = np.expand_dims(curr, axis=3)
-        mem = np.expand_dims(mem, axis=3)
+        curr = self.mydb.scene(rowid=1)
+        mem = self.mydb.scene(rowid=2)
         curr2 = curr.copy()
         curr2[3, 5, 2, 0] = np.nan
         curr3 = [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
@@ -41,10 +39,8 @@ class TestCase(unittest.TestCase):
             self.assertTrue(is_numeric_array(diff))
 
     def test_imagediff_memory(self):
-        curr = self.mydb.read_image(rowid=1)
-        mem = self.mydb.read_image(rowid=2)
-        curr = np.expand_dims(curr, axis=3)
-        mem = np.expand_dims(mem, axis=3)
+        curr = self.mydb.scene(rowid=1)
+        mem = self.mydb.scene(rowid=2)
         mem2 = curr.copy()
         mem2[3, 5, 2] = np.nan
         mem3 = [[1, 2], [1, 2], [1, 2]]
@@ -68,10 +64,8 @@ class TestCase(unittest.TestCase):
             self.assertTrue(is_numeric_array(diff))
 
     def test_rot_imagediff_curr(self):
-        curr = self.mydb.read_image(rowid=1)
-        mem = self.mydb.read_image(rowid=2)
-        curr = np.expand_dims(curr, axis=3)
-        mem = np.expand_dims(mem, axis=3)
+        curr = self.mydb.scene(rowid=1)
+        mem = self.mydb.scene(rowid=2)
         curr2 = curr.copy()
         curr2[3, 5, 2] = np.nan
         curr3 = [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
@@ -95,10 +89,8 @@ class TestCase(unittest.TestCase):
             self.assertTrue(is_numeric_array(diff))
 
     def test_rotimagediff_memory(self):
-        curr = self.mydb.read_image(rowid=1)
-        mem = self.mydb.read_image(rowid=2)
-        curr = np.expand_dims(curr, axis=3)
-        mem = np.expand_dims(mem, axis=3)
+        curr = self.mydb.scene(rowid=1)
+        mem = self.mydb.scene(rowid=2)
         mem2 = curr.copy()
         mem2[3, 5, 2] = np.nan
         mem3 = [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
@@ -122,10 +114,8 @@ class TestCase(unittest.TestCase):
             self.assertTrue(is_numeric_array(diff))
 
     def test_simple_imagediff_curr(self):
-        curr = self.mydb.read_image(rowid=1)
-        mem = self.mydb.read_image(rowid=2)
-        curr = np.expand_dims(curr, axis=3)
-        mem = np.expand_dims(mem, axis=3)
+        curr = self.mydb.scene(rowid=1)
+        mem = self.mydb.scene(rowid=2)
         curr2 = curr.copy()
         curr2[3, 5, 2] = np.nan
         curr3 = [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
@@ -151,10 +141,8 @@ class TestCase(unittest.TestCase):
             # self.assertTrue(diff.shape[3] == 1)
 
     def test_simple_imagediff_mem(self):
-        curr = self.mydb.read_image(rowid=1)
-        mem = self.mydb.read_image(rowid=2)
-        curr = np.expand_dims(curr, axis=3)
-        mem = np.expand_dims(mem, axis=3)
+        curr = self.mydb.scene(rowid=1)
+        mem = self.mydb.scene(rowid=2)
         mem2 = curr.copy()
         mem2[3, 5, 2] = np.nan
         mem3 = [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
@@ -180,10 +168,8 @@ class TestCase(unittest.TestCase):
             # self.assertTrue(diff.shape[3] == 1)
 
     def test_diff_optic_flow_memory(self):
-        curr = self.mydb.read_image(rowid=1)
-        mem = self.mydb.read_image(rowid=2)
-        curr = np.expand_dims(curr, axis=3)
-        mem = np.expand_dims(mem, axis=3)
+        curr = self.mydb.scene(rowid=1)
+        mem = self.mydb.scene(rowid=2)
         mem2 = curr.copy()
         mem2[3, 5, 2] = np.nan
         mem3 = [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
@@ -206,10 +192,8 @@ class TestCase(unittest.TestCase):
             self.assertTrue(is_numeric_array(vec))
 
     def test_diff_optic_flow_curr(self):
-        curr = self.mydb.read_image(rowid=1)
-        mem = self.mydb.read_image(rowid=2)
-        curr = np.expand_dims(curr, axis=3)
-        mem = np.expand_dims(mem, axis=3)
+        curr = self.mydb.scene(rowid=1)
+        mem = self.mydb.scene(rowid=2)
         curr2 = curr.copy()
         curr2[3, 5, 2] = np.nan
         curr3 = [[1, 2], [1, 2], [1, 2]]

build/lib/navipy/moving/agent.py

@@ -7,15 +7,12 @@ import networkx as nx
 import multiprocessing
 from multiprocessing import Queue, JoinableQueue, Process
 import inspect
-try:
-    from pandas.core.common import is_numeric_dtype
-except ImportError:
-    from pandas.api.types import is_numeric_dtype
 from navipy.database import DataBaseLoad
 import navipy.moving.maths as navimomath
 
 
 def defaultcallback(*args, **kwargs):
+    """default call back"""
     raise NameError('No Callback')
 
 
@@ -90,7 +87,6 @@ class AbstractAgent():
                                       columns=self.posorient_vel_col)
             trajectory.loc[0, :] = self._posorient_vel.copy()
         for stepi in range(1, max_nstep):
-            print(stepi, self._posorient_vel)
             self.move()
             if return_tra:
                 trajectory.loc[stepi, :] = self._posorient_vel.copy()

build/lib/navipy/moving/test_agent.py

@@ -80,8 +80,6 @@ class TestNavipyMovingAgent(unittest.TestCase):
         agent.mode_of_motion = mode_move
         agent.fly(max_nstep=10)
         obtained = agent.posorient
-        print(obtained)
-        print(initposorient.loc[obtained.index])
         self.assertTrue(np.allclose(obtained,
                                     initposorient.loc[obtained.index]))
 

build/lib/navipy/processing/test.py

@@ -28,8 +28,7 @@ class TestCase(unittest.TestCase):
         posorient.alpha_0 = rows[3]
         posorient.alpha_1 = rows[2]
         posorient.alpha_2 = rows[4]
-        image = self.mydb.read_image(posorient=posorient)
-        image = np.expand_dims(image, axis=3)
+        image = self.mydb.scene(posorient=posorient)
         self.assertIsNotNone(image)
         self.assertFalse(sum(image.shape) == 0)
         # print("shape",image.shape)
@@ -45,7 +44,7 @@ class TestCase(unittest.TestCase):
         posorient2.alpha_1 = posorient.alpha_1
         posorient2.alpha_2 = posorient.alpha_2
         with self.assertRaises(Exception):
-            image = self.mydb.read_image(posorient=posorient2)
+            image = self.mydb.scene(posorient=posorient2)
 
         # incorrect case None
         posorient2 = pd.Series(index=['x', 'y', 'z',
@@ -57,7 +56,7 @@ class TestCase(unittest.TestCase):
         posorient2.alpha_1 = posorient.alpha_1
         posorient2.alpha_2 = posorient.alpha_2
         with self.assertRaises(ValueError):
-            image = self.mydb.read_image(posorient=posorient2)
+            image = self.mydb.scene(posorient=posorient2)
 
         # incorrect case nan
         posorient2 = pd.Series(index=['x', 'y', 'z',
@@ -69,7 +68,7 @@ class TestCase(unittest.TestCase):
         posorient2.alpha_1 = posorient.alpha_1
         posorient2.alpha_2 = posorient.alpha_2
         with self.assertRaises(ValueError):
-            image = self.mydb.read_image(posorient=posorient2)
+            image = self.mydb.scene(posorient=posorient2)
 
         # incorrect case no pandas series but dict
         posorient2 = {}
@@ -80,20 +79,18 @@ class TestCase(unittest.TestCase):
         posorient2['alpha_1'] = posorient.alpha_1
         posorient2['alpha_2'] = posorient.alpha_2
         with self.assertRaises(TypeError):
-            image = self.mydb.read_image(posorient=posorient2)
+            image = self.mydb.scene(posorient=posorient2)
 
         # not working case empty
         posorient2 = pd.Series(index=['x', 'y', 'z',
                                       'alpha_0', 'alpha_1', 'alpha_2'])
 
         with self.assertRaises(Exception):
-            image = self.mydb.read_image(posorient=posorient2)
+            image = self.mydb.scene(posorient=posorient2)
 
     def test_skyline_scene(self):
-        scene = self.mydb.read_image(rowid=1)
+        scene = self.mydb.scene(rowid=1)
         scene2 = scene.copy()
-        scene = np.expand_dims(scene, axis=3)
-        scene2 = np.expand_dims(scene2, axis=3)
         scene2[3, 5, 2, 0] = np.nan
         scene3 = [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
         scene3 = [scene3, scene3, scene3]
@@ -124,19 +121,18 @@ class TestCase(unittest.TestCase):
         for rowid in [0, -2]:
             with self.assertRaises(ValueError):
                 # print("rowid",rowid)
-                self.mydb.read_image(rowid=rowid)
+                self.mydb.scene(rowid=rowid)
         with self.assertRaises(TypeError):
-            self.mydb.read_image(rowid='T')
+            self.mydb.scene(rowid='T')
         with self.assertRaises(TypeError):
-            self.mydb.read_image(rowid=None)
+            self.mydb.scene(rowid=None)
         with self.assertRaises(TypeError):
-            self.mydb.read_image(rowid=np.nan)
+            self.mydb.scene(rowid=np.nan)
         with self.assertRaises(TypeError):
-            self.mydb.read_image(rowid=4.5)
+            self.mydb.scene(rowid=4.5)
 
         for rowid in [1, 2, 3, 4, 5]:
-            image = self.mydb.read_image(rowid=rowid)
-            image = np.expand_dims(image, axis=3)
+            image = self.mydb.scene(rowid=rowid)
             # image=np.array(image)
             self.assertIsNotNone(image)
             self.assertFalse(sum(image.shape) == 0)
@@ -148,8 +144,8 @@ class TestCase(unittest.TestCase):
             self.assertTrue(image.shape[1] > 0)
 
     def test_distance_channel(self):
-        scene = self.mydb.read_image(rowid=1)
-        scene = np.expand_dims(scene, axis=3)
+        scene = self.mydb.scene(rowid=1)
+
         # should not be working
         for d in ['g', None, np.nan, 8.4]:
             with self.assertRaises(TypeError):
@@ -170,8 +166,8 @@ class TestCase(unittest.TestCase):
         self.assertEqual(weighted_scene.shape, scene.shape)
 
     def test_contr_weight_scene(self):
-        scene = self.mydb.read_image(rowid=1)
-        scene = np.expand_dims(scene, axis=3)
+        scene = self.mydb.scene(rowid=1)
+
         # working cases
         contrast = pcode.contrast_weighted_nearness(scene)
         self.assertIsNotNone(contrast)
@@ -198,8 +194,7 @@ class TestCase(unittest.TestCase):
             contrast = pcode.contrast_weighted_nearness(scene4)
 
     def test_contr_weight_contrast(self):
-        scene = self.mydb.read_image(rowid=1)
-        scene = np.expand_dims(scene, axis=3)
+        scene = self.mydb.scene(rowid=1)
         for size in [9.4, 'g', None, np.nan]:
             with self.assertRaises(TypeError):
                 contrast = pcode.contrast_weighted_nearness(
@@ -226,8 +221,7 @@ class TestCase(unittest.TestCase):
     def test_pcv(self):
         # working case
         rowid = 1
-        my_scene = self.mydb.read_image(rowid=rowid)
-        my_scene = np.expand_dims(my_scene, axis=3)
+        my_scene = self.mydb.scene(rowid=rowid)
         directions = self.mydb.viewing_directions
         my_pcv = pcode.pcv(my_scene, directions)
         self.assertIsNotNone(my_pcv)
@@ -268,11 +262,9 @@ class TestCase(unittest.TestCase):
     def test_apcv(self):
         # working case
         rowid = 1
-        my_scene = self.mydb.read_image(rowid=rowid)
-        my_scene = np.expand_dims(my_scene, axis=3)
+        my_scene = self.mydb.scene(rowid=rowid)
         # print("scene shape",my_scene.shape)
         directions = self.mydb.viewing_directions
-        print("directions", directions.shape)
         my_pcv = pcode.apcv(my_scene, directions)
 
         self.assertIsNotNone(my_pcv)
@@ -312,8 +304,8 @@ class TestCase(unittest.TestCase):
 
     def test_size(self):
         # not working cases:
-        scene = self.mydb.read_image(rowid=1)
-        scene = np.expand_dims(scene, axis=3)
+        scene = self.mydb.scene(rowid=1)
+
         for size in [8, 1, 0, -4]:
             with self.assertRaises(ValueError):
                 contrast = pcode.michelson_contrast(
@@ -337,8 +329,7 @@ class TestCase(unittest.TestCase):
 
     def test_michelsoncontrast_scene(self):
 
-        scene = self.mydb.read_image(rowid=1)
-        scene = np.expand_dims(scene, axis=3)
+        scene = self.mydb.scene(rowid=1)
 
         # working cases
         contrast = pcode.michelson_contrast(scene)
@@ -359,9 +350,8 @@ class TestCase(unittest.TestCase):
         scene3 = np.array(scene3)
         scene4 = np.zeros((3, 4, 5, 0))
         for s in [scene2, scene3, scene4]:
-            with self.assertRaises(Exception) as cm:
+            with self.assertRaises(Exception):
                 contrast = pcode.michelson_contrast(s,)
-            print("wanted exception occured", cm.exception)
 
 
 if __name__ == '__main__':