Prevent reordering of imports by auto formatter to avoid crashes

Summary:
Apparently this is the generally accepted way to do this.

https://usort.readthedocs.io/en/stable/guide.html#import-blocks

What do you tihnk?

Differential Revision: D62147522

Author: bshethmeta

tests/torch_test_contrib.py

@@ -3,11 +3,12 @@
 # This source code is licensed under the MIT license found in the
 # LICENSE file in the root directory of this source tree.
 
-import torch
-import unittest
-import numpy as np
-import faiss
-import faiss.contrib.torch_utils
+import torch  # usort: skip
+import unittest  # usort: skip
+import numpy as np  # usort: skip
+import faiss  # usort: skip
+import faiss.contrib.torch_utils  # usort: skip
+
 
 class TestTorchUtilsCPU(unittest.TestCase):
     # tests add, search
@@ -141,7 +142,7 @@ def test_assign(self):
         self.assertTrue(np.array_equal(labels, labels_ref))
 
         # Test assign with numpy output provided
-        labels = np.empty((xq.shape[0], 5), dtype='int64')
+        labels = np.empty((xq.shape[0], 5), dtype="int64")
         index.assign(xq.numpy(), 5, labels)
         self.assertTrue(np.array_equal(labels, labels_ref))
 

tests/torch_test_neural_net.py

@@ -3,25 +3,25 @@
 # This source code is licensed under the MIT license found in the
 # LICENSE file in the root directory of this source tree.
 
-import torch
-from torch import nn
-import unittest
-import numpy as np
-import faiss
+import torch  # usort: skip
+from torch import nn  # usort: skip
+import unittest  # usort: skip
+import numpy as np  # usort: skip
+import faiss  # usort: skip
 
-from faiss.contrib import datasets
-from faiss.contrib.inspect_tools import get_additive_quantizer_codebooks
+from faiss.contrib import datasets  # usort: skip
+from faiss.contrib.inspect_tools import get_additive_quantizer_codebooks  # usort: skip
 
 
 class TestLayer(unittest.TestCase):
 
     @torch.no_grad()
     def test_Embedding(self):
-        """ verify that the Faiss Embedding works the same as in Pytorch """
+        """verify that the Faiss Embedding works the same as in Pytorch"""
         torch.manual_seed(123)
 
         emb = nn.Embedding(40, 50)
-        idx = torch.randint(40, (25, ))
+        idx = torch.randint(40, (25,))
         ref_batch = emb(idx)
 
         emb2 = faiss.Embedding(emb)
@@ -33,7 +33,7 @@ def test_Embedding(self):
 
     @torch.no_grad()
     def do_test_Linear(self, bias):
-        """ verify that the Faiss Linear works the same as in Pytorch """
+        """verify that the Faiss Linear works the same as in Pytorch"""
         torch.manual_seed(123)
         linear = nn.Linear(50, 40, bias=bias)
         x = torch.randn(25, 50)
@@ -50,6 +50,7 @@ def test_Linear(self):
     def test_Linear_nobias(self):
         self.do_test_Linear(False)
 
+
 ######################################################
 # QINCo Pytorch implementation copied from
 # https://github.com/facebookresearch/Qinco/blob/main/model_qinco.py
@@ -219,6 +220,7 @@ def encode(self, x, code0=None):
 # QINCo tests
 ######################################################
 
+
 def copy_QINCoStep(step):
     step2 = faiss.QINCoStep(step.d, step.K, step.L, step.h)
     step2.codebook.from_torch(step.codebook)
@@ -238,7 +240,7 @@ def test_decode(self):
         torch.manual_seed(123)
         step = QINCoStep(d=16, K=20, L=2, h=8)
 
-        codes = torch.randint(0, 20, (10, ))
+        codes = torch.randint(0, 20, (10,))
         xhat = torch.randn(10, 16)
         ref_decode = step.decode(xhat, codes)
 
@@ -247,28 +249,23 @@ def test_decode(self):
         codes2 = faiss.Int32Tensor2D(codes[:, None].to(dtype=torch.int32))
 
         np.testing.assert_array_equal(
-            step.codebook(codes).numpy(),
-            step2.codebook(codes2).numpy()
+            step.codebook(codes).numpy(), step2.codebook(codes2).numpy()
         )
 
         xhat2 = faiss.Tensor2D(xhat)
         # xhat2 = faiss.Tensor2D(len(codes), step2.d)
 
         new_decode = step2.decode(xhat2, codes2)
 
-        np.testing.assert_allclose(
-            ref_decode.numpy(),
-            new_decode.numpy(),
-            atol=2e-6
-        )
+        np.testing.assert_allclose(ref_decode.numpy(), new_decode.numpy(), atol=2e-6)
 
     @torch.no_grad()
     def test_encode(self):
         torch.manual_seed(123)
         step = QINCoStep(d=16, K=20, L=2, h=8)
 
         # create plausible x for testing starting from actual codes
-        codes = torch.randint(0, 20, (10, ))
+        codes = torch.randint(0, 20, (10,))
         xhat = torch.zeros(10, 16)
         x = step.decode(xhat, codes)
         del codes
@@ -282,14 +279,11 @@ def test_encode(self):
         new_codes = step2.encode(xhat2, x2, toadd2)
 
         np.testing.assert_allclose(
-            ref_codes.numpy(),
-            new_codes.numpy().ravel(),
-            atol=2e-6
+            ref_codes.numpy(), new_codes.numpy().ravel(), atol=2e-6
         )
         np.testing.assert_allclose(toadd.numpy(), toadd2.numpy(), atol=2e-6)
 
 
-
 class TestQINCo(unittest.TestCase):
 
     @torch.no_grad()
@@ -327,11 +321,12 @@ def test_encode(self):
 # Test index
 ######################################################
 
+
 class TestIndexQINCo(unittest.TestCase):
 
     def test_search(self):
         """
-        We can't train qinco with just Faiss so we just train a RQ and use the 
+        We can't train qinco with just Faiss so we just train a RQ and use the
         codebooks in QINCo with L = 0 residual blocks
         """
         ds = datasets.SyntheticDataset(32, 1000, 100, 0)
@@ -342,7 +337,7 @@ def test_search(self):
         rq = index_ref.rq
         # rq = faiss.ResidualQuantizer(ds.d, M, 4)
         rq.train_type = faiss.ResidualQuantizer.Train_default
-        rq.max_beam_size = 1    # beam search not implemented for QINCo (yet)
+        rq.max_beam_size = 1  # beam search not implemented for QINCo (yet)
         index_ref.train(ds.get_train())
         codebooks = get_additive_quantizer_codebooks(rq)